The fxml Reference Manual

This is the fxml Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Jul 15 05:06:20 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 fxml

Dependencies
Source

fxml.asd.


2.2 fxml/dom

Dependency

fxml/xml (system).

Source

fxml.asd.

Child Components

2.3 fxml/xml

Dependencies
  • fxml/runes (system).
  • quri (system).
  • flexi-streams (system).
  • alexandria (system).
  • serapeum (system).
  • split-sequence (system).
Source

fxml.asd.

Child Components

2.4 fxml/runes

Dependencies
  • babel (system).
  • named-readtables (system).
  • serapeum (system).
  • trivial-gray-streams (system).
Source

fxml.asd.

Child Components

2.5 fxml/klacks

Dependency

fxml/xml (system).

Source

fxml.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 fxml/fxml.asd

Source

fxml.asd.

Parent Component

fxml (system).

ASDF Systems

3.1.2 fxml/dom/package.lisp

Source

fxml.asd.

Parent Component

fxml/dom (system).

Packages

fxml.dom.

Public Interface

3.1.3 fxml/dom/dom-impl.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/dom (system).

Packages

fxml.rune-dom.

Public Interface
Internals

3.1.4 fxml/dom/dom-builder.lisp

Dependency

dom-impl.lisp (file).

Source

fxml.asd.

Parent Component

fxml/dom (system).

Public Interface
Internals

3.1.5 fxml/dom/dom-sax.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/dom (system).

Public Interface

map-document (function).

Internals

compute-attributes (function).


3.1.6 fxml/xml/package.lisp

Source

fxml.asd.

Parent Component

fxml/xml (system).

Packages

fxml.


3.1.7 fxml/xml/util.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.8 fxml/xml/sax-handler.lisp

Source

fxml.asd.

Parent Component

fxml/xml (system).

Packages

fxml.sax.

Public Interface
Internals

3.1.9 fxml/xml/xml-name-rune-p.lisp

Dependencies
Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.10 fxml/xml/rod-hashtable.lisp

Dependencies
Source

fxml.asd.

Parent Component

fxml/xml (system).

Internals

3.1.11 fxml/xml/xml-parse.lisp

Dependencies
Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.12 fxml/xml/unparse.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.13 fxml/xml/xmls-compat.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Packages

fxml.xmls.

Public Interface
Internals

3.1.14 fxml/xml/recoder.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.15 fxml/xml/xmlns-normalizer.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.16 fxml/xml/space-normalizer.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.17 fxml/xml/catalog.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

3.1.18 fxml/xml/sax-proxy.lisp

Dependency

xml-parse.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Public Interface
Internals

define-sax-proxy-method (macro).


3.1.19 fxml/xml/atdoc-configuration.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/xml (system).

Internals

3.1.20 fxml/runes/package.lisp

Source

fxml.asd.

Parent Component

fxml/runes (system).

Packages

3.1.21 fxml/runes/definline.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Public Interface

definline (macro).


3.1.22 fxml/runes/characters.lisp

Dependency

definline.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Public Interface
Internals

3.1.23 fxml/runes/syntax.lisp

Dependency

characters.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Internals

3.1.24 fxml/runes/encodings.lisp

Dependency

syntax.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Public Interface
Internals

3.1.25 fxml/runes/encodings-data.lisp

Dependency

encodings.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).


3.1.26 fxml/runes/xstream.lisp

Dependency

encodings-data.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Public Interface
Internals

3.1.27 fxml/runes/ystream.lisp

Dependency

xstream.lisp (file).

Source

fxml.asd.

Parent Component

fxml/runes (system).

Public Interface
Internals

3.1.28 fxml/klacks/package.lisp

Source

fxml.asd.

Parent Component

fxml/klacks (system).

Packages

fxml.klacks.


3.1.29 fxml/klacks/klacks.lisp

Dependency

package.lisp (file).

Source

fxml.asd.

Parent Component

fxml/klacks (system).

Public Interface
Internals

3.1.30 fxml/klacks/klacks-impl.lisp

Dependency

klacks.lisp (file).

Source

fxml.asd.

Parent Component

fxml/klacks (system).

Public Interface
Internals

3.1.31 fxml/klacks/tap-source.lisp

Dependency

klacks-impl.lisp (file).

Source

fxml.asd.

Parent Component

fxml/klacks (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 fxml.runes

Source

package.lisp.

Use List
  • common-lisp.
  • editor-hints.named-readtables.
  • trivial-gray-streams.
Used By List
Public Interface
Internals

4.2 fxml

Source

package.lisp.

Use List
Public Interface
Internals

4.3 fxml.runes-encoding

Source

package.lisp.

Use List
Used By List

fxml.

Public Interface
Internals

4.4 fxml.dom

Source

package.lisp.

Public Interface
Internals

4.5 fxml.utf8-runes

Source

package.lisp.

Use List
  • common-lisp.
  • editor-hints.named-readtables.

4.6 fxml.rune-dom

Source

dom-impl.lisp.

Nickname

fxml-dom

Use List
  • common-lisp.
  • editor-hints.named-readtables.
  • fxml.runes.
Public Interface
Internals

4.7 fxml.xmls

Source

xmls-compat.lisp.

Use List
Public Interface
Internals

4.8 fxml.klacks

Source

package.lisp.

Public Interface

4.9 fxml.sax

Source

sax-handler.lisp.

Use List
  • common-lisp.
  • editor-hints.named-readtables.
Public Interface
Internals

5 Definitions

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


5.1 Public Interface


5.1.1 Special variables

Special Variable: *cache-all-dtds*
Package

fxml.

Source

xml-parse.lisp.

Special Variable: *catalog*
Package

fxml.

Source

xml-parse.lisp.

Special Variable: *dtd-cache*
Package

fxml.

Source

xml-parse.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

Special Variable: *prefer*
Package

fxml.

Source

catalog.lisp.

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

fxml.sax.

Source

sax-handler.lisp.


5.1.2 Macros

Macro: consume-rune (input)

Like READ-RUNE, but does not actually return the read rune.

Package

fxml.runes.

Source

xstream.lisp.

Macro: decode-sequence* (&key encoding in out in-start in-end out-start out-end eof)

Wrapper around ‘decode-sequence’ with friendlier args.

Package

fxml.runes-encoding.

Source

encodings.lisp.

Macro: definline (name args &body body)
Package

fxml.runes.

Source

definline.lisp.

Macro: do-node-list ((var nodelist &optional resultform) &body body)
Package

fxml.dom.

Source

dom-impl.lisp.

Macro: do-node-map ((var node-map &optional resultform) &body body)
Package

fxml.dom.

Source

dom-impl.lisp.

Macro: expecting-element ((source &optional lname uri) &body body)
Package

fxml.klacks.

Source

klacks.lisp.

Macro: peek-rune (input)

Peek a single rune off the xstream ‘input’. In case of end of file :EOF is returned.

Package

fxml.runes.

Source

xstream.lisp.

Macro: read-rune (input)

Read a single rune off the xstream ‘input’. In case of end of file :EOF is returned.

Package

fxml.runes.

Source

xstream.lisp.

Macro: with-document-events ((handler) &body body)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.

Source

unparse.lisp.

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, fxml.sax:end-element is used to write an end tag, using the same qualified name and namespace information as above.

Package

fxml.

Source

unparse.lisp.

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

fxml.

Source

unparse.lisp.

Macro: with-open-source ((var source) &body body)
Package

fxml.klacks.

Source

klacks.lisp.

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

fxml.

Source

unparse.lisp.

Macro: with-simple-rod ((s) &body body)

Specialize BODY for the subtypes of ‘simple-rod’.

Package

fxml.runes.

Source

characters.lisp.

Macro: with-xml-output (sink &body body)

@arg[sink]{A @class{SAX handler}, evaluated}
@arg[body]{forms}
@return{The result of calling @code{fxml.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{fxml.sax:start-document} is signalled to the @code{sink}. Afterwards, @fun{fxml.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{fxml.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

fxml.

Source

unparse.lisp.


5.1.3 Compiler macros

Compiler Macro: rune<= (rune &rest more-runes)
Package

fxml.runes.

Source

characters.lisp.

Compiler Macro: rune>= (rune &rest more-runes)
Package

fxml.runes.

Source

characters.lisp.


5.1.4 Ordinary functions

Function: %rune (rod index)
Package

fxml.runes.

Source

characters.lisp.

Function: (setf %rune) (rod index)
Package

fxml.runes.

Source

characters.lisp.

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

fxml.

Source

unparse.lisp.

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

fxml.

Source

unparse.lisp.

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

fxml.

Source

unparse.lisp.

Function: char-rune (char)
Package

fxml.runes.

Source

characters.lisp.

Function: clear-dtd-cache (dtd-cache)
Package

fxml.

Source

xml-parse.lisp.

Function: close-xstream (input)

Close INPUT, an xstream.

Package

fxml.runes.

Source

xstream.lisp.

Function: code-rune (x)
Package

fxml.runes.

Source

characters.lisp.

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

fxml.

Source

unparse.lisp.

Function: consume-characters (source)
Package

fxml.klacks.

Source

klacks.lisp.

Function: create-document (&optional document-element)
Package

fxml.rune-dom.

Source

dom-impl.lisp.

Function: current-characters (source)
Package

fxml.klacks.

Source

klacks.lisp.

Function: current-encoding ()

Return the current encoding of the input stream.

Package

fxml.

Source

xml-parse.lisp.

Function: current-lname (source)
Package

fxml.klacks.

Source

klacks.lisp.

Function: current-qname (source)
Package

fxml.klacks.

Source

klacks.lisp.

Function: current-uri (source)
Package

fxml.klacks.

Source

klacks.lisp.

Function: digit-rune-p (char &optional radix)
Package

fxml.runes.

Source

characters.lisp.

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{quri: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

fxml.

Source

unparse.lisp.

Function: expect (source key &optional u v w)
Package

fxml.klacks.

Source

klacks.lisp.

Function: external-reference-forbidden (pubid sysid)
Package

fxml.

Source

xml-parse.lisp.

Function: find-attribute (qname attrs)
Package

fxml.sax.

Source

sax-handler.lisp.

Function: find-attribute-ns (uri lname attrs)
Package

fxml.sax.

Source

sax-handler.lisp.

Function: find-element (source &optional lname uri)
Package

fxml.klacks.

Source

klacks.lisp.

Function: find-encoding (name)
Package

fxml.runes-encoding.

Source

encodings.lisp.

Function: find-event (source key)
Package

fxml.klacks.

Source

klacks.lisp.

Function: find-output-encoding (name)
Package

fxml.runes.

Source

ystream.lisp.

Function: fpeek-rune (input)

Same as ‘peek-rune’, but not a macro.

Package

fxml.runes.

Source

xstream.lisp.

Function: fread-rune (input)

Same as ‘read-rune’, but not a macro.

Package

fxml.runes.

Source

xstream.lisp.

Function: getdtd (uri dtd-cache)
Package

fxml.

Source

xml-parse.lisp.

Function: (setf getdtd) (uri dtd-cache)
Package

fxml.

Source

xml-parse.lisp.

Function: make-attribute (&key namespace-uri local-name qname value specified-p)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.

Source

sax-proxy.lisp.

Function: make-callback-handler (&rest args &key &allow-other-keys)
Package

fxml.sax.

Source

sax-handler.lisp.

Function: make-catalog (&optional uris)
Package

fxml.

Source

catalog.lisp.

Function: make-character-stream-sink (stream &rest initargs &key canonical indentation text-indentation encoding omit-xml-declaration)

@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{fxml.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

fxml.

Source

unparse.lisp.

Function: make-character-stream-ystream (target-stream)
Package

fxml.runes.

Source

ystream.lisp.

Function: make-dom-builder ()
Package

fxml.rune-dom.

Source

dom-builder.lisp.

Function: make-dtd-cache ()
Package

fxml.

Source

xml-parse.lisp.

Function: make-extid (public system)

@arg[publicid]{string or nil} @arg[systemid]{@class{quri: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

fxml.

Source

xml-parse.lisp.

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{fxml.sax:start-element} events before passing them on the next handler.

Package

fxml.

Source

xmlns-normalizer.lisp.

Function: make-node (&key name ns attrs children)
Package

fxml.xmls.

Source

xmls-compat.lisp.

Function: make-octet-input-stream (octets)
Package

fxml.runes.

Source

ystream.lisp.

Function: make-octet-stream-sink (stream &rest initargs &key canonical indentation text-indentation encoding omit-xml-declaration)

@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{fxml.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

fxml.

Source

unparse.lisp.

Function: make-octet-stream-ystream (os-stream)
Package

fxml.runes.

Source

ystream.lisp.

Function: make-octet-vector-sink (&rest initargs &key canonical indentation text-indentation encoding omit-xml-declaration)

@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{fxml.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 fxml.dom:map-document should be set to nil for the former behaviour and :canonical-notations for the latter.

Package

fxml.

Source

unparse.lisp.

Function: make-octet-vector-ystream (&key encoding column in-ptr in-buffer out-buffer result)
Package

fxml.runes.

Source

ystream.lisp.

Function: make-recoder (chained-handler recoder-fn)
Package

fxml.

Source

recoder.lisp.

Function: make-rod (size)
Package

fxml.runes.

Source

characters.lisp.

Function: make-rod-sink (&rest initargs &key canonical indentation text-indentation encoding omit-xml-declaration)

@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{fxml.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

fxml.

Source

unparse.lisp.

Function: make-rod-xstream (string &key name)

Make an xstream that reads from STRING.

Package

fxml.runes.

Source

xstream.lisp.

Function: make-rod-ystream (&key encoding column in-ptr in-buffer)
Package

fxml.runes.

Source

ystream.lisp.

Function: make-source (input &rest args &key validate dtd root entity-resolver disallow-internal-subset buffering pathname forbid-entities forbid-external ignore-dtd forbid-dtd)
Package

fxml.

Source

klacks-impl.lisp.

Function: make-string-sink (&rest args &key canonical indentation text-indentation encoding omit-xml-declaration)

@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{fxml.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

fxml.

Source

unparse.lisp.

Function: make-tapping-source (upstream-source &optional sax-handler)
Package

fxml.klacks.

Source

tap-source.lisp.

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" (fxml-dom:make-dom-builder))) (x (parse-dtd-file "~/test.dtd")))
(fxml.dom:map-document (fxml:make-validator x #"foo") d))}

Package

fxml.

Source

xml-parse.lisp.

Function: make-values-handler (&rest handlers)

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

Creates a SAX handler which passes every event it receives on to each handler specified as an argument to this function, and finally returns, as multiple values, the result of calling @fun{sax:end-document} on each.

See @class{broadcast-handler} for details.

Package

fxml.

Source

sax-proxy.lisp.

Function: make-whitespace-normalizer (chained-handler &optional dtd)
Package

fxml.

Source

space-normalizer.lisp.

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

fxml.xmls.

Source

xmls-compat.lisp.

Function: make-xpath-navigator ()
Package

fxml.xmls.

Source

xmls-compat.lisp.

Function: make-xstream (os-stream &key name speed initial-speed initial-encoding)

Make an xstream from OS-STREAM.

Package

fxml.runes.

Source

xstream.lisp.

Function: map-document (handler document &key include-xmlns-attributes include-doctype include-default-values)
Package

fxml.dom.

Source

dom-sax.lisp.

Function: map-node (handler node &key include-xmlns-attributes include-namespace-uri)
Package

fxml.xmls.

Source

xmls-compat.lisp.

Function: map-node-list (fn nodelist)
Package

fxml.dom.

Source

dom-impl.lisp.

Function: map-node-map (fn node-map)
Package

fxml.dom.

Source

dom-impl.lisp.

Function: name-rune-p (rune)
Package

fxml.

Source

xml-name-rune-p.lisp.

Function: name-start-rune-p (rune)
Package

fxml.

Source

xml-name-rune-p.lisp.

Function: nc-name-p (name)
Package

fxml.

Source

xml-parse.lisp.

Function: node-attrs (node)
Package

fxml.xmls.

Source

xmls-compat.lisp.

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

fxml.xmls.

Source

xmls-compat.lisp.

Function: node-children (node)
Package

fxml.xmls.

Source

xmls-compat.lisp.

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

fxml.xmls.

Source

xmls-compat.lisp.

Function: node-name (node)
Package

fxml.xmls.

Source

xmls-compat.lisp.

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

fxml.xmls.

Source

xmls-compat.lisp.

Function: node-ns (node)
Package

fxml.xmls.

Source

xmls-compat.lisp.

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

fxml.xmls.

Source

xmls-compat.lisp.

Function: parse (input handler &rest args &key validate dtd root entity-resolver disallow-internal-subset recode pathname ignore-dtd forbid-dtd forbid-entities forbid-external)

@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, FXML 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{fxml.utf8-dom:make-dom-builder} if this
option is enabled and @fun{fxml.rune-dom:make-dom-builder} otherwise.}
@return{The value returned by @fun{fxml.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

fxml.

Source

xml-parse.lisp.

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

fxml.

Source

xml-parse.lisp.

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

fxml.

Source

xml-parse.lisp.

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{fxml.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

fxml.

Source

xml-parse.lisp.

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

fxml.

Source

unparse.lisp.

Function: remdtd (uri dtd-cache)
Package

fxml.

Source

xml-parse.lisp.

Function: resolve-extid (public system catalog)
Package

fxml.

Source

catalog.lisp.

Function: resolve-uri (uri catalog)
Package

fxml.

Source

catalog.lisp.

Function: rod (x)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-capitalize (rod)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-downcase (rod)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-equal (x y)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-string (rod &optional default-char)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-subseq (source start &optional end)
Package

fxml.runes.

Source

characters.lisp.

Function: rod-to-utf8-string (rod)
Package

fxml.runes.

Source

ystream.lisp.

Function: rod-upcase (rod)
Package

fxml.runes.

Source

characters.lisp.

Function: rod< (rod1 rod2)
Package

fxml.runes.

Source

characters.lisp.

Function: rod= (x y)
Package

fxml.runes.

Source

characters.lisp.

Function: rune (rod index)
Package

fxml.runes.

Source

characters.lisp.

Function: (setf rune) (rod index)
Package

fxml.runes.

Source

characters.lisp.

Function: rune-char (rune &optional default)
Package

fxml.runes.

Source

characters.lisp.

Function: rune-code (x)
Package

fxml.runes.

Source

characters.lisp.

Function: rune-downcase (rune)
Package

fxml.runes.

Source

characters.lisp.

Function: rune-equal (x y)
Package

fxml.runes.

Source

characters.lisp.

Function: rune-upcase (rune)
Package

fxml.runes.

Source

characters.lisp.

Function: rune<= (rune &rest more-runes)
Package

fxml.runes.

Source

characters.lisp.

Function: rune= (x y)
Package

fxml.runes.

Source

characters.lisp.

Function: rune>= (rune &rest more-runes)
Package

fxml.runes.

Source

characters.lisp.

Function: runep (x)
Package

fxml.runes.

Source

characters.lisp.

Function: runes-to-utf8/adjustable-string (out in n)
Package

fxml.runes.

Source

ystream.lisp.

Function: serialize-element (source handler &key document-events)
Package

fxml.klacks.

Source

klacks.lisp.

Function: serialize-event (source handler &key consume)
Package

fxml.klacks.

Source

klacks.lisp.

Function: serialize-source (source handler)
Package

fxml.klacks.

Source

klacks.lisp.

Function: set-to-full-speed (xstream)

Cf. ‘xstream-encoding’.

Package

fxml.runes.

Source

xstream.lisp.

Function: skip (source key &optional a b c)
Package

fxml.klacks.

Source

klacks.lisp.

Function: split-qname (qname)
Package

fxml.

Source

xml-parse.lisp.

Function: string-rod (string)
Package

fxml.runes.

Source

characters.lisp.

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

fxml.

Source

unparse.lisp.

Function: undeclared-namespace (prefix)
Package

fxml.

Source

xml-parse.lisp.

Function: undefined-entity (stream entity-name)
Package

fxml.

Source

xml-parse.lisp.

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

fxml.

Source

unparse.lisp.

Function: unread-rune (rune input)

Unread the last recently read rune; if there wasn’t such a rune, you deserve to lose.

Package

fxml.runes.

Source

xstream.lisp.

Function: utf8-string-to-rod (str)
Package

fxml.runes.

Source

ystream.lisp.

Function: validity-error (fmt &rest args)
Package

fxml.

Source

xml-parse.lisp.

Function: white-space-rune-p (char)
Package

fxml.runes.

Source

characters.lisp.

Function: xml-character-p (c)
Package

fxml.

Source

util.lisp.

Function: xml-characters-p (str)
Package

fxml.

Source

util.lisp.

Function: xstream-column-number (input)

The column number of the underlying stream in INPUT, an xstream.

Package

fxml.runes.

Source

xstream.lisp.

Reader: xstream-encoding (instance)

Switching the encoding on the fly is only possible when the stream’s buffer is empty; therefore to be able to switch the encoding, while some runes are already read, set the stream’s speed to 1 initially (via the initial-speed argument for MAKE-XSTREAM) and later set it to full speed. (The encoding of the runes sequence, you fetch off with READ-RUNE is always UTF-16 though). After switching the encoding, SET-TO-FULL-SPEED can be used to bump the speed up to a full buffer length.

An encoding is simply something, which provides the DECODE-SEQUENCE method.

Package

fxml.runes.

Source

xstream.lisp.

Target Slot

encoding.

Writer: (setf xstream-encoding) (instance)
Package

fxml.runes.

Source

xstream.lisp.

Target Slot

encoding.

Reader: xstream-line-number (instance)

The line number of the underlying stream.

Package

fxml.runes.

Source

xstream.lisp.

Target Slot

line-number.

Writer: (setf xstream-line-number) (instance)
Package

fxml.runes.

Source

xstream.lisp.

Target Slot

line-number.

Reader: xstream-name (instance)
Writer: (setf xstream-name) (instance)
Package

fxml.runes.

Source

xstream.lisp.

Target Slot

name.

Function: xstream-p (object)
Package

fxml.runes.

Source

xstream.lisp.

Function: xstream-position (input)

Return the position of the underlying stream in INPUT, an xstream.

Package

fxml.runes.

Source

xstream.lisp.

Reader: ystream-column (instance)
Writer: (setf ystream-column) (instance)
Package

fxml.runes.

Source

ystream.lisp.

Target Slot

column.

Reader: ystream-encoding (instance)
Writer: (setf ystream-encoding) (instance)
Package

fxml.runes.

Source

ystream.lisp.

Target Slot

encoding.

Function: ystream-write-escapable-rod (rod ystream &key start end)
Package

fxml.runes.

Source

ystream.lisp.

Function: ystream-write-escapable-rune (rune ystream)
Package

fxml.runes.

Source

ystream.lisp.

Function: ystream-write-rod (rod ystream &key start end)
Package

fxml.runes.

Source

ystream.lisp.

Function: ystream-write-rune (rune ystream)
Package

fxml.runes.

Source

ystream.lisp.


5.1.5 Generic functions

Generic Function: append-child (node new-child)
Package

fxml.dom.

Methods
Method: append-child ((node node) (new-child document-fragment))
Source

dom-impl.lisp.

Method: append-child ((node node) (new-child node))
Source

dom-impl.lisp.

Generic Function: append-data (node arg)
Package

fxml.dom.

Methods
Method: append-data ((node character-data) arg)
Source

dom-impl.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: attribute-declaration ((handler klacks-dtd-handler) element-name attribute-name type default)
Source

klacks-impl.lisp.

Method: attribute-declaration ((handler dom-builder) element-name attribute-name type default)
Source

dom-builder.lisp.

Method: attribute-declaration ((handler broadcast-handler) elt attr type default)
Source

sax-proxy.lisp.

Method: attribute-declaration ((handler recoder) element-name attribute-name type default)
Source

recoder.lisp.

Method: attribute-declaration ((sink sink) ename aname type default)
Source

unparse.lisp.

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)
Generic Function: attribute-local-name (attribute)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

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

sax-handler.lisp.

Generic Function: attribute-namespace-uri (attribute)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

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

sax-handler.lisp.

Generic Function: attribute-p (object)
Package

fxml.dom.

Methods
Method: attribute-p (object)
Source

dom-impl.lisp.

Method: attribute-p ((object attribute))
Source

dom-impl.lisp.

Generic Function: attribute-qname (attribute)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

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

sax-handler.lisp.

Generic Function: attribute-specified-p (attribute)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

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

sax-handler.lisp.

Generic Function: attribute-value (attribute)
Package

fxml.sax.

Source

sax-handler.lisp.

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

fxml.sax.

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

sax-handler.lisp.

Generic Function: attributes (object)
Package

fxml.dom.

Methods
Method: attributes ((self node))
Source

dom-impl.lisp.

Reader Method: attributes ((element element))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

attributes.

Generic Reader: 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

fxml.

Methods
Reader Method: broadcast-handler-handlers ((broadcast-handler broadcast-handler))

automatically generated reader method

Source

sax-proxy.lisp.

Target Slot

handlers.

Generic Writer: (setf broadcast-handler-handlers) (object)
Package

fxml.

Methods
Writer Method: (setf broadcast-handler-handlers) ((broadcast-handler broadcast-handler))

automatically generated writer method

Source

sax-proxy.lisp.

Target Slot

handlers.

Generic Function: cdata-section-p (object)
Package

fxml.dom.

Methods
Method: cdata-section-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: character-data-p (object)
Package

fxml.dom.

Methods
Method: character-data-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: characters ((handler dom-builder) data)
Source

dom-builder.lisp.

Method: characters ((handler broadcast-handler) data)
Source

sax-proxy.lisp.

Method: characters ((handler whitespace-normalizer) data)
Source

space-normalizer.lisp.

Method: characters ((handler recoder) data)
Source

recoder.lisp.

Method: characters ((handler xmls-builder) data)
Source

xmls-compat.lisp.

Method: characters ((sink sink) data)
Source

unparse.lisp.

Method: characters ((handler validator) data)
Source

xml-parse.lisp.

Method: characters ((self115 callback-handler) data)
Method: characters ((handler null) data)
Method: characters (handler data)
Method: characters ((handler abstract-handler) data)
Method: characters ((handler default-handler) data)
Generic Function: child-element-count (node)
Package

fxml.dom.

Methods
Method: child-element-count ((node node))
Source

dom-impl.lisp.

Generic Function: child-nodes (node)
Package

fxml.dom.

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

dom-impl.lisp.

Generic Function: clone-node (node deep)
Package

fxml.dom.

Methods
Method: clone-node ((node document) deep)
Source

dom-impl.lisp.

Method: clone-node ((node node) deep)
Source

dom-impl.lisp.

Generic Function: close-source (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: close-source ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: close-ystream (ystream)
Package

fxml.runes.

Methods
Method: close-ystream ((ystream octet-vector-ystream))
Source

ystream.lisp.

Method: close-ystream ((ystream character-stream-ystream))
Source

ystream.lisp.

Method: close-ystream ((ystream rod-ystream))
Source

ystream.lisp.

Method: close-ystream ((ystream %stream-ystream))
Source

ystream.lisp.

Method: close-ystream :before ((ystream ystream))
Source

ystream.lisp.

Generic Function: code (self)
Package

fxml.dom.

Methods
Method: code ((self dom-exception))
Source

dom-impl.lisp.

Generic Function: column-number (sax-parser)

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

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: column-number ((parser klacksax))
Source

klacks.lisp.

Method: column-number ((parser fxml-parser))
Source

xml-parse.lisp.

Method: column-number ((handler sax-parser-mixin))
Generic Function: comment (handler data)
Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: comment ((handler dom-builder) data)
Source

dom-builder.lisp.

Method: comment ((handler broadcast-handler) data)
Source

sax-proxy.lisp.

Method: comment ((handler recoder) data)
Source

recoder.lisp.

Method: comment ((sink sink) data)
Source

unparse.lisp.

Method: comment ((self141 callback-handler) data)
Method: comment ((handler null) data)
Method: comment (handler data)
Method: comment ((handler abstract-handler) data)
Method: comment ((handler content-handler) data)
Generic Function: comment-p (object)
Package

fxml.dom.

Methods
Method: comment-p (object)
Source

dom-impl.lisp.

Method: comment-p ((object comment))
Source

dom-impl.lisp.

Generic Function: consume (source)
Package

fxml.klacks.

Source

klacks.lisp.

Methods
Method: consume ((source tapping-source))
Source

tap-source.lisp.

Method: consume ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: contains (node descendant)
Package

fxml.dom.

Methods
Method: contains ((node node) (descendant node))
Source

dom-impl.lisp.

Generic Function: create-attribute (document name)
Package

fxml.dom.

Methods
Method: create-attribute ((document document) name)
Source

dom-impl.lisp.

Generic Function: create-attribute-ns (document uri qname)
Package

fxml.dom.

Methods
Method: create-attribute-ns ((document document) uri qname)
Source

dom-impl.lisp.

Generic Function: create-cdata-section (document data)
Package

fxml.dom.

Methods
Method: create-cdata-section ((document document) data)
Source

dom-impl.lisp.

Generic Function: create-comment (document data)
Package

fxml.dom.

Methods
Method: create-comment ((document document) data)
Source

dom-impl.lisp.

Generic Function: create-document (factory uri qname doctype)
Package

fxml.dom.

Methods
Method: create-document ((factory (eql fxml.rune-dom:implementation)) uri qname doctype)
Source

dom-impl.lisp.

Generic Function: create-document-fragment (document)
Package

fxml.dom.

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

dom-impl.lisp.

Generic Function: create-document-type (factory name publicid systemid)
Package

fxml.dom.

Methods
Method: create-document-type ((factory (eql fxml.rune-dom:implementation)) name publicid systemid)
Source

dom-impl.lisp.

Generic Function: create-element (document tag-name)
Package

fxml.dom.

Methods
Method: create-element ((document document) tag-name)
Source

dom-impl.lisp.

Generic Function: create-element-ns (document uri qname)
Package

fxml.dom.

Methods
Method: create-element-ns ((document document) uri qname)
Source

dom-impl.lisp.

Generic Function: create-entity-reference (document name)
Package

fxml.dom.

Methods
Method: create-entity-reference ((document document) name)
Source

dom-impl.lisp.

Generic Function: create-processing-instruction (document target data)
Package

fxml.dom.

Methods
Method: create-processing-instruction ((document document) target data)
Source

dom-impl.lisp.

Generic Function: create-text-node (document data)
Package

fxml.dom.

Methods
Method: create-text-node ((document document) data)
Source

dom-impl.lisp.

Generic Function: current-cdata-section-p (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Reader Method: current-cdata-section-p ((fxml-source fxml-source))

automatically generated reader method

Source

klacks-impl.lisp.

Target Slot

cdata-section-p.

Generic Function: current-column-number (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: current-column-number ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: current-line-number (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: current-line-number ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: current-system-id (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: current-system-id ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: current-xml-base (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: current-xml-base ((source fxml-source))
Source

klacks-impl.lisp.

Generic Reader: data (object)
Package

fxml.dom.

Methods
Reader Method: data ((processing-instruction processing-instruction))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

data.

Reader Method: data ((character-data character-data))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

value.

Generic Function: (setf data) (self)
Package

fxml.dom.

Methods
Method: (setf data) ((self processing-instruction))
Source

dom-impl.lisp.

Method: (setf data) ((self character-data))
Source

dom-impl.lisp.

Generic Function: decode-qname (qname source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: decode-qname (qname (source fxml-source))
Source

klacks-impl.lisp.

Generic Function: decode-sequence (encoding input input-start input-end output output-start output-end eof-p)
Package

fxml.runes-encoding.

Source

encodings.lisp.

Methods
Method: decode-sequence ((encoding simple-8-bit-encoding) in in-start in-end out out-start out-end eof?)
Method: decode-sequence ((encoding (eql :utf-8)) in in-start in-end out out-start out-end eof?)
Method: decode-sequence ((encoding (eql :utf-16-little-endian)) in in-start in-end out out-start out-end eof?)
Method: decode-sequence ((encoding (eql :utf-16-big-endian)) in in-start in-end out out-start out-end eof?)
Generic Function: delete-data (node offset count)
Package

fxml.dom.

Methods
Method: delete-data ((node character-data) offset count)
Source

dom-impl.lisp.

Generic Function: deprecated-sax-default-method (handler event)
Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: deprecated-sax-default-method (handler event)
Generic Reader: doctype (object)
Package

fxml.dom.

Methods
Reader Method: doctype ((document document))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

doc-type.

Generic Function: document-element (document)
Package

fxml.dom.

Methods
Method: document-element ((document document))
Source

dom-impl.lisp.

Generic Function: document-fragment-p (object)
Package

fxml.dom.

Methods
Method: document-fragment-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: document-p (object)
Package

fxml.dom.

Methods
Method: document-p (object)
Source

dom-impl.lisp.

Method: document-p ((object document))
Source

dom-impl.lisp.

Generic Function: document-type-p (object)
Package

fxml.dom.

Methods
Method: document-type-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: dtd (handler dtd)
Package

fxml.sax.

Source

sax-handler.lisp.

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

klacks-impl.lisp.

Method: dtd ((handler dom-builder) dtd)
Source

dom-builder.lisp.

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

sax-proxy.lisp.

Method: dtd ((handler whitespace-normalizer) dtd)
Source

space-normalizer.lisp.

Method: dtd ((handler recoder) dtd)
Source

recoder.lisp.

Method: dtd ((handler null) dtd)
Method: dtd (handler dtd)
Method: dtd ((handler abstract-handler) dtd)
Method: dtd ((handler content-handler) dtd)
Generic Reader: dtd-name (condition)
Package

fxml.

Methods
Reader Method: dtd-name ((condition dtd-forbidden))
Source

xml-parse.lisp.

Target Slot

name.

Generic Reader: dtd-pubid (condition)
Package

fxml.

Methods
Reader Method: dtd-pubid ((condition dtd-forbidden))
Source

xml-parse.lisp.

Target Slot

pubid.

Generic Reader: dtd-sysid (condition)
Package

fxml.

Methods
Reader Method: dtd-sysid ((condition dtd-forbidden))
Source

xml-parse.lisp.

Target Slot

sysid.

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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: element-declaration ((handler klacks-dtd-handler) name model)
Source

klacks-impl.lisp.

Method: element-declaration ((handler dom-builder) name model)
Source

dom-builder.lisp.

Method: element-declaration ((handler broadcast-handler) name model)
Source

sax-proxy.lisp.

Method: element-declaration ((handler recoder) name model)
Source

recoder.lisp.

Method: element-declaration ((sink sink) name model)
Source

unparse.lisp.

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)
Generic Function: element-p (object)
Package

fxml.dom.

Methods
Method: element-p (object)
Source

dom-impl.lisp.

Method: element-p ((object element))
Source

dom-impl.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

Method: end-cdata ((handler recoder))
Source

recoder.lisp.

Method: end-cdata ((sink sink))
Source

unparse.lisp.

Method: end-cdata ((handler validator))
Source

xml-parse.lisp.

Method: end-cdata ((handler null))
Method: end-cdata (handler)
Method: end-cdata ((handler abstract-handler))
Method: end-cdata ((handler content-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

fxml.sax.

Source

sax-handler.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

Method: end-document ((self values-handler))
Source

sax-proxy.lisp.

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

catalog.lisp.

Method: end-document ((handler recoder))
Source

recoder.lisp.

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

xmls-compat.lisp.

Method: end-document ((sink sink))
Source

unparse.lisp.

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

Called at the end of parsing a DTD.

Package

fxml.sax.

Source

sax-handler.lisp.

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

klacks-impl.lisp.

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

sax-proxy.lisp.

Method: end-dtd ((handler recoder))
Source

recoder.lisp.

Method: end-dtd ((sink sink))
Source

unparse.lisp.

Method: end-dtd ((handler null))
Method: end-dtd (handler)
Method: end-dtd ((handler abstract-handler))
Method: end-dtd ((handler content-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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: end-element ((handler dom-builder) namespace-uri local-name qname)
Source

dom-builder.lisp.

Method: end-element ((handler broadcast-handler) namespace-uri local-name qname)
Source

sax-proxy.lisp.

Method: end-element ((handler catalog-parser) uri lname qname)
Source

catalog.lisp.

Method: end-element ((handler whitespace-normalizer) uri lname qname)
Source

space-normalizer.lisp.

Method: end-element ((handler namespace-normalizer) uri lname qname)
Source

xmlns-normalizer.lisp.

Method: end-element ((handler recoder) namespace-uri local-name qname)
Source

recoder.lisp.

Method: end-element ((handler xmls-builder) namespace-uri local-name qname)
Source

xmls-compat.lisp.

Method: end-element ((sink sink) namespace-uri local-name qname)
Source

unparse.lisp.

Method: end-element ((handler validator) uri lname qname)
Source

xml-parse.lisp.

Method: end-element ((self76 callback-handler) ns lname qname)
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)
Generic Function: end-internal-subset (handler)

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

Package

fxml.sax.

Source

sax-handler.lisp.

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

klacks-impl.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

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

recoder.lisp.

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

unparse.lisp.

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))
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

fxml.sax.

Source

sax-handler.lisp.

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

sax-proxy.lisp.

Method: end-prefix-mapping ((handler recoder) prefix)
Source

recoder.lisp.

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)
Generic Reader: entities (object)
Package

fxml.dom.

Methods
Reader Method: entities ((document-type document-type))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

entities.

Generic Reader: entity-name (condition)
Package

fxml.

Methods
Reader Method: entity-name ((condition entities-forbidden))
Source

xml-parse.lisp.

Target Slot

name.

Generic Function: entity-p (object)
Package

fxml.dom.

Methods
Method: entity-p (object)
Source

dom-impl.lisp.

Method: entity-p ((object entity))
Source

dom-impl.lisp.

Generic Function: entity-reference-p (object)
Package

fxml.dom.

Methods
Method: entity-reference-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: entity-resolver (handler resolver)

Called between fxml.sax:end-dtd and fxml.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

fxml.sax.

Source

sax-handler.lisp.

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

klacks-impl.lisp.

Method: entity-resolver ((handler dom-builder) resolver)
Source

dom-builder.lisp.

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

sax-proxy.lisp.

Method: entity-resolver ((handler recoder) resolver)
Source

recoder.lisp.

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)
Generic Reader: entity-value (condition)
Package

fxml.

Methods
Reader Method: entity-value ((condition entities-forbidden))
Source

xml-parse.lisp.

Target Slot

value.

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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: external-entity-declaration ((handler klacks-dtd-handler) kind name public-id system-id)
Source

klacks-impl.lisp.

Method: external-entity-declaration ((handler dom-builder) kind name public-id system-id)
Source

dom-builder.lisp.

Method: external-entity-declaration ((handler broadcast-handler) kind name pub sys)
Source

sax-proxy.lisp.

Method: external-entity-declaration ((handler recoder) kind name public-id system-id)
Source

recoder.lisp.

Method: external-entity-declaration ((sink sink) kind name public-id system-id)
Source

unparse.lisp.

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)
Generic Reader: external-reference-pubid (condition)
Package

fxml.

Methods
Reader Method: external-reference-pubid ((condition external-reference-forbidden))
Source

xml-parse.lisp.

Target Slot

pubid.

Generic Reader: external-reference-sysid (condition)
Package

fxml.

Methods
Reader Method: external-reference-sysid ((condition external-reference-forbidden))
Source

xml-parse.lisp.

Target Slot

sysid.

Generic Function: find-namespace-binding (prefix source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: find-namespace-binding (prefix (source fxml-source))
Source

klacks-impl.lisp.

Generic Function: first-child (node)
Package

fxml.dom.

Methods
Method: first-child ((node node))
Source

dom-impl.lisp.

Generic Function: first-element-child (node)
Package

fxml.dom.

Methods
Method: first-element-child ((node node))
Source

dom-impl.lisp.

Generic Function: get-attribute (element name)
Package

fxml.dom.

Methods
Method: get-attribute ((element element) name)
Source

dom-impl.lisp.

Generic Function: get-attribute (source lname &optional uri)
Package

fxml.klacks.

Source

klacks.lisp.

Methods
Method: get-attribute ((source fxml-source) lname &optional uri)
Source

klacks-impl.lisp.

Generic Function: get-attribute-node (element name)
Package

fxml.dom.

Methods
Method: get-attribute-node ((element element) name)
Source

dom-impl.lisp.

Generic Function: get-attribute-node-ns (element uri lname)
Package

fxml.dom.

Methods
Method: get-attribute-node-ns ((element element) uri lname)
Source

dom-impl.lisp.

Generic Function: get-attribute-ns (element uri lname)
Package

fxml.dom.

Methods
Method: get-attribute-ns ((element element) uri lname)
Source

dom-impl.lisp.

Generic Function: get-element-by-id (document id)
Package

fxml.dom.

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

dom-impl.lisp.

Generic Function: get-elements-by-class-name (document class-name)

Get descendant elements of DOCUMENT (in the HTML namespace) with a class attribute matching CLASS-NAME.

Package

fxml.dom.

Source

dom-impl.lisp.

Methods
Method: get-elements-by-class-name ((element element) name)
Method: get-elements-by-class-name ((document document) class-name)
Generic Function: get-elements-by-tag-name (document tag-name)
Package

fxml.dom.

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

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: get-elements-by-tag-name-ns (document uri lname)
Package

fxml.dom.

Methods
Method: get-elements-by-tag-name-ns ((element element) uri lname)
Source

dom-impl.lisp.

Method: get-elements-by-tag-name-ns ((document document) uri lname)
Source

dom-impl.lisp.

Generic Function: get-named-item (self name)
Package

fxml.dom.

Methods
Method: get-named-item ((self named-node-map) name)
Source

dom-impl.lisp.

Generic Function: get-named-item-ns (self uri lname)
Package

fxml.dom.

Methods
Method: get-named-item-ns ((self named-node-map) uri lname)
Source

dom-impl.lisp.

Generic Function: has-attribute (element name)
Package

fxml.dom.

Methods
Method: has-attribute ((element element) name)
Source

dom-impl.lisp.

Generic Function: has-attribute-ns (element uri lname)
Package

fxml.dom.

Methods
Method: has-attribute-ns ((element element) uri lname)
Source

dom-impl.lisp.

Generic Function: has-attributes (element)
Package

fxml.dom.

Methods
Method: has-attributes ((element element))
Source

dom-impl.lisp.

Method: has-attributes ((element node))
Source

dom-impl.lisp.

Generic Function: has-child-nodes (node)
Package

fxml.dom.

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

dom-impl.lisp.

Generic Function: has-feature (factory feature version)
Package

fxml.dom.

Methods
Method: has-feature ((factory (eql fxml.rune-dom:implementation)) feature version)
Source

dom-impl.lisp.

Generic Function: implementation (document)
Package

fxml.dom.

Methods
Method: implementation ((document document))
Source

dom-impl.lisp.

Generic Function: import-node (document node deep)
Package

fxml.dom.

Methods
Method: import-node ((document document) (node character-data) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node processing-instruction) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node notation) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node entity-reference) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node entity) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node element) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node document-fragment) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) (node attribute) deep)
Source

dom-impl.lisp.

Method: import-node ((document document) node deep)
Source

dom-impl.lisp.

Generic Function: insert-before (node new-child ref-child)
Package

fxml.dom.

Methods
Method: insert-before ((node node) (fragment document-fragment) ref-child)
Source

dom-impl.lisp.

Method: insert-before ((node node) (new-child node) ref-child)
Source

dom-impl.lisp.

Generic Function: insert-data (node offset arg)
Package

fxml.dom.

Methods
Method: insert-data ((node character-data) offset arg)
Source

dom-impl.lisp.

Generic Function: internal-entity-declaration (handler kind name value)

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

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: internal-entity-declaration ((handler klacks-dtd-handler) kind name value)
Source

klacks-impl.lisp.

Method: internal-entity-declaration ((handler dom-builder) kind name value)
Source

dom-builder.lisp.

Method: internal-entity-declaration ((handler broadcast-handler) kind name value)
Source

sax-proxy.lisp.

Method: internal-entity-declaration ((handler recoder) kind name value)
Source

recoder.lisp.

Method: internal-entity-declaration ((sink sink) kind name value)
Source

unparse.lisp.

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)
Generic Function: internal-subset (node)
Package

fxml.dom.

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

dom-impl.lisp.

Generic Function: is-supported (node feature version)
Package

fxml.dom.

Methods
Method: is-supported ((node node) feature version)
Source

dom-impl.lisp.

Generic Function: item (self index)
Package

fxml.dom.

Methods
Method: item ((self named-node-map) index)
Source

dom-impl.lisp.

Method: item ((self vector) index)
Source

dom-impl.lisp.

Generic Reader: items (object)
Package

fxml.dom.

Methods
Reader Method: items ((named-node-map named-node-map))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

items.

Generic Function: last-child (node)
Package

fxml.dom.

Methods
Method: last-child ((node node))
Source

dom-impl.lisp.

Generic Function: last-element-child (node)
Package

fxml.dom.

Methods
Method: last-element-child ((node node))
Source

dom-impl.lisp.

Generic Function: length (self)
Package

fxml.dom.

Methods
Method: length ((node character-data))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: length ((self vector))
Source

dom-impl.lisp.

Generic Function: line-number (sax-parser)

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

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: line-number ((parser klacksax))
Source

klacks.lisp.

Method: line-number ((parser fxml-parser))
Source

xml-parse.lisp.

Method: line-number ((handler sax-parser-mixin))
Generic Function: list-attributes (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: list-attributes ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: local-name (node)
Package

fxml.dom.

Methods
Reader Method: local-name ((namespace-mixin namespace-mixin))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

local-name.

Method: local-name ((node node))
Source

dom-impl.lisp.

Generic Function: map-attributes (fn source)
Package

fxml.klacks.

Source

klacks.lisp.

Methods
Method: map-attributes (fn (source tapping-source))
Source

tap-source.lisp.

Method: map-attributes (fn (source fxml-source))
Source

klacks-impl.lisp.

Generic Function: map-current-namespace-declarations (fn source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: map-current-namespace-declarations (fn (source fxml-source))
Source

klacks-impl.lisp.

Generic Reader: name (object)
Package

fxml.dom.

Methods
Reader Method: name ((entity-reference entity-reference))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

name.

Reader Method: name ((entity entity))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

name.

Reader Method: name ((notation notation))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

name.

Reader Method: name ((document-type document-type))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

name.

Reader Method: name ((attribute attribute))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

name.

Generic Function: named-node-map-p (object)
Package

fxml.dom.

Methods
Method: named-node-map-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: namespace-uri (node)
Package

fxml.dom.

Methods
Reader Method: namespace-uri ((namespace-mixin namespace-mixin))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

namespace-uri.

Method: namespace-uri ((node node))
Source

dom-impl.lisp.

Generic Function: next-element-sibling (node)
Package

fxml.dom.

Methods
Method: next-element-sibling ((node document-type))
Source

dom-impl.lisp.

Method: next-element-sibling ((node node))
Source

dom-impl.lisp.

Generic Function: next-sibling (node)
Package

fxml.dom.

Methods
Method: next-sibling ((node node))
Source

dom-impl.lisp.

Generic Function: node-name (self)
Package

fxml.dom.

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

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-name ((self entity))
Source

dom-impl.lisp.

Method: node-name ((self notation))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-name ((self element))
Source

dom-impl.lisp.

Method: node-name ((self attribute))
Source

dom-impl.lisp.

Method: node-name ((self comment))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-name ((self text))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-name ((self document))
Source

dom-impl.lisp.

Generic Function: node-p (object)
Package

fxml.dom.

Methods
Method: node-p (object)
Source

dom-impl.lisp.

Method: node-p ((object node))
Source

dom-impl.lisp.

Generic Function: node-type (self)
Package

fxml.dom.

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

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-type ((self entity))
Source

dom-impl.lisp.

Method: node-type ((self notation))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-type ((self element))
Source

dom-impl.lisp.

Method: node-type ((self attribute))
Source

dom-impl.lisp.

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

dom-impl.lisp.

Method: node-type ((self comment))
Source

dom-impl.lisp.

Method: node-type ((self text))
Source

dom-impl.lisp.

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

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: node-value (self)
Package

fxml.dom.

Methods
Method: node-value ((self processing-instruction))
Source

dom-impl.lisp.

Method: node-value ((self entity-reference))
Source

dom-impl.lisp.

Method: node-value ((self entity))
Source

dom-impl.lisp.

Method: node-value ((self notation))
Source

dom-impl.lisp.

Method: node-value ((self document-type))
Source

dom-impl.lisp.

Method: node-value ((self element))
Source

dom-impl.lisp.

Method: node-value ((self attribute))
Source

dom-impl.lisp.

Method: node-value ((self character-data))
Source

dom-impl.lisp.

Method: node-value ((self document-fragment))
Source

dom-impl.lisp.

Method: node-value ((self document))
Source

dom-impl.lisp.

Generic Function: (setf node-value) (self)
Package

fxml.dom.

Methods
Method: (setf node-value) ((self notation))
Source

dom-impl.lisp.

Method: (setf node-value) ((self document-fragment))
Source

dom-impl.lisp.

Method: (setf node-value) ((self document-type))
Source

dom-impl.lisp.

Method: (setf node-value) ((self document))
Source

dom-impl.lisp.

Method: (setf node-value) ((self entity))
Source

dom-impl.lisp.

Method: (setf node-value) ((self entity-reference))
Source

dom-impl.lisp.

Method: (setf node-value) ((self element))
Source

dom-impl.lisp.

Method: (setf node-value) ((self processing-instruction))
Source

dom-impl.lisp.

Method: (setf node-value) ((self attribute))
Source

dom-impl.lisp.

Method: (setf node-value) ((self character-data))
Source

dom-impl.lisp.

Generic Function: normalize (node)
Package

fxml.dom.

Methods
Method: normalize ((node node))
Source

dom-impl.lisp.

Generic Function: notation-declaration (handler name public-id system-id)

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

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: notation-declaration ((handler klacks-dtd-handler) name public-id system-id)
Source

klacks-impl.lisp.

Method: notation-declaration ((handler dom-builder) name public-id system-id)
Source

dom-builder.lisp.

Method: notation-declaration ((handler broadcast-handler) name public-id system-id)
Source

sax-proxy.lisp.

Method: notation-declaration ((handler recoder) name public-id system-id)
Source

recoder.lisp.

Method: notation-declaration ((sink sink) name public-id system-id)
Source

unparse.lisp.

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)
Generic Reader: notation-name (object)
Package

fxml.dom.

Methods
Reader Method: notation-name ((entity entity))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

notation-name.

Generic Function: notation-p (object)
Package

fxml.dom.

Methods
Method: notation-p (object)
Source

dom-impl.lisp.

Method: notation-p ((object notation))
Source

dom-impl.lisp.

Generic Reader: notations (object)
Package

fxml.dom.

Methods
Reader Method: notations ((document-type document-type))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

notations.

Generic Function: owner-document (object)
Package

fxml.dom.

Methods
Method: owner-document ((node node))
Source

dom-impl.lisp.

Reader Method: owner-document ((named-node-map named-node-map))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

owner.

Generic Reader: owner-element (object)
Package

fxml.dom.

Methods
Reader Method: owner-element ((attribute attribute))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

owner-element.

Generic Function: parent-node (node)
Package

fxml.dom.

Methods
Method: parent-node ((node node))
Source

dom-impl.lisp.

Generic Function: peek (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: peek ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: peek-next (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: peek-next ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: peek-value (source)
Package

fxml.klacks.

Source

klacks.lisp.

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

tap-source.lisp.

Method: peek-value ((source fxml-source))
Source

klacks-impl.lisp.

Generic Function: prefix (node)
Package

fxml.dom.

Methods
Reader Method: prefix ((namespace-mixin namespace-mixin))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

prefix.

Method: prefix ((node node))
Source

dom-impl.lisp.

Generic Function: (setf prefix) (node)
Package

fxml.dom.

Methods
Method: (setf prefix) :after ((node element))
Source

dom-impl.lisp.

Method: (setf prefix) :after ((node attribute))
Source

dom-impl.lisp.

Method: (setf prefix) :before ((node attribute))
Source

dom-impl.lisp.

Method: (setf prefix) ((node namespace-mixin))
Source

dom-impl.lisp.

Generic Function: previous-element-sibling (node)
Package

fxml.dom.

Methods
Method: previous-element-sibling ((node document-type))
Source

dom-impl.lisp.

Method: previous-element-sibling ((node node))
Source

dom-impl.lisp.

Generic Function: previous-sibling (node)
Package

fxml.dom.

Methods
Method: previous-sibling ((node node))
Source

dom-impl.lisp.

Generic Function: processing-instruction (handler target data)

Called when a processing instruction is read.

Both target and data are rods.

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: processing-instruction ((handler dom-builder) target data)
Source

dom-builder.lisp.

Method: processing-instruction ((handler broadcast-handler) target data)
Source

sax-proxy.lisp.

Method: processing-instruction ((handler recoder) target data)
Source

recoder.lisp.

Method: processing-instruction ((sink sink) target data)
Source

unparse.lisp.

Method: processing-instruction ((self154 callback-handler) target data)
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)
Generic Function: processing-instruction-p (object)
Package

fxml.dom.

Methods
Method: processing-instruction-p (object)
Source

dom-impl.lisp.

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

dom-impl.lisp.

Generic Function: proxy-chained-handler (instance)
Package

fxml.

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.

Generic Function: (setf proxy-chained-handler) (instance)
Package

fxml.

Methods
Method: (setf proxy-chained-handler) ((instance sax-proxy))
Source

sax-proxy.lisp.

Generic Reader: public-id (object)
Package

fxml.dom.

Methods
Reader Method: public-id ((entity entity))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

public-id.

Reader Method: public-id ((notation notation))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

public-id.

Reader Method: public-id ((document-type document-type))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

public-id.

Generic Function: register-sax-parser (handler sax-parser)

Set the SAX-PARSER instance of this handler.

Package

fxml.sax.

Source

sax-handler.lisp.

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

sax-proxy.lisp.

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)
Generic Function: remove-attribute (element name)
Package

fxml.dom.

Methods
Method: remove-attribute ((element element) name)
Source

dom-impl.lisp.

Generic Function: remove-attribute-node (element old-attr)
Package

fxml.dom.

Methods
Method: remove-attribute-node ((element element) (old-attr attribute))
Source

dom-impl.lisp.

Generic Function: remove-attribute-ns (elt uri lname)
Package

fxml.dom.

Methods
Method: remove-attribute-ns ((elt element) uri lname)
Source

dom-impl.lisp.

Generic Function: remove-child (node old-child)
Package

fxml.dom.

Methods
Method: remove-child ((node node) (old-child node))
Source

dom-impl.lisp.

Generic Function: remove-named-item (self name)
Package

fxml.dom.

Methods
Method: remove-named-item ((self attribute-node-map) name)
Source

dom-impl.lisp.

Method: remove-named-item ((self named-node-map) name)
Source

dom-impl.lisp.

Generic Function: remove-named-item-ns (self uri lname)
Package

fxml.dom.

Methods
Method: remove-named-item-ns ((self attribute-node-map) uri lname)
Source

dom-impl.lisp.

Method: remove-named-item-ns ((self named-node-map) uri lname)
Source

dom-impl.lisp.

Generic Function: rename-node (node uri qname)
Package

fxml.dom.

Source

dom-impl.lisp.

Methods
Method: rename-node ((attribute attribute) uri qname)
Method: rename-node ((element element) uri qname)
Method: rename-node (node uri qname)
Generic Function: replace-child (node new-child old-child)
Package

fxml.dom.

Methods
Method: replace-child ((node node) (new-child document-fragment) (old-child node))
Source

dom-impl.lisp.

Method: replace-child ((node node) (new-child node) (old-child node))
Source

dom-impl.lisp.

Generic Function: replace-data (node offset count arg)
Package

fxml.dom.

Methods
Method: replace-data ((node character-data) offset count arg)
Source

dom-impl.lisp.

Generic Reader: sax-condition.event (condition)
Package

fxml.sax.

Methods
Reader Method: sax-condition.event ((condition sax-condition))
Source

sax-handler.lisp.

Target Slot

event.

Generic Reader: sax-condition.handler (condition)
Package

fxml.sax.

Methods
Reader Method: sax-condition.handler ((condition sax-condition))
Source

sax-handler.lisp.

Target Slot

handler.

Generic Reader: sax-parser (object)
Package

fxml.sax.

Methods
Reader Method: sax-parser ((sax-parser-mixin sax-parser-mixin))

automatically generated reader method

Source

sax-handler.lisp.

Target Slot

sax-parser.

Generic Function: set-attribute (element name value)
Package

fxml.dom.

Methods
Method: set-attribute ((element element) name value)
Source

dom-impl.lisp.

Generic Function: set-attribute-node (element new-attr)
Package

fxml.dom.

Methods
Method: set-attribute-node ((element element) (new-attr attribute))
Source

dom-impl.lisp.

Generic Function: set-attribute-node-ns (element new-attr)
Package

fxml.dom.

Methods
Method: set-attribute-node-ns ((element element) (new-attr attribute))
Source

dom-impl.lisp.

Generic Function: set-attribute-ns (element uri lname value)
Package

fxml.dom.

Methods
Method: set-attribute-ns ((element element) uri lname value)
Source

dom-impl.lisp.

Generic Function: set-named-item (self arg)
Package

fxml.dom.

Methods
Method: set-named-item :after ((self attribute-node-map) arg)
Source

dom-impl.lisp.

Method: set-named-item ((self named-node-map) arg)
Source

dom-impl.lisp.

Generic Function: set-named-item-ns (self arg)
Package

fxml.dom.

Methods
Method: set-named-item-ns :after ((self attribute-node-map) arg)
Source

dom-impl.lisp.

Method: set-named-item-ns ((self named-node-map) arg)
Source

dom-impl.lisp.

Generic Reader: sink-encoding (object)
Package

fxml.

Methods
Reader Method: sink-encoding ((sink sink))

automatically generated reader method

Source

unparse.lisp.

Target Slot

encoding.

Generic Reader: sink-omit-xml-declaration-p (object)
Package

fxml.

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

automatically generated reader method

Source

unparse.lisp.

Target Slot

sink-omit-xml-declaration-p.

Generic Writer: (setf sink-omit-xml-declaration-p) (object)
Package

fxml.

Methods
Writer Method: (setf sink-omit-xml-declaration-p) ((sink sink))

automatically generated writer method

Source

unparse.lisp.

Target Slot

sink-omit-xml-declaration-p.

Generic Reader: specified (object)
Package

fxml.dom.

Methods
Reader Method: specified ((attribute attribute))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

specified-p.

Generic Function: split-text (text offset)
Package

fxml.dom.

Methods
Method: split-text ((text text) offset)
Source

dom-impl.lisp.

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

fxml.sax.

Source

sax-handler.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

Method: start-cdata ((handler recoder))
Source

recoder.lisp.

Method: start-cdata ((sink sink))
Source

unparse.lisp.

Method: start-cdata ((handler validator))
Source

xml-parse.lisp.

Method: start-cdata ((handler null))
Method: start-cdata (handler)
Method: start-cdata ((handler abstract-handler))
Method: start-cdata ((handler content-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

fxml.sax.

Source

sax-handler.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

Method: start-document ((handler recoder))
Source

recoder.lisp.

Method: start-document ((sink sink))
Source

unparse.lisp.

Method: start-document ((self93 callback-handler))
Method: start-document ((handler null))
Method: start-document (handler)
Method: start-document ((handler abstract-handler))
Method: start-document ((handler default-handler))
Generic Function: start-dtd (handler name public-id system-id)

Called at the beginning of parsing a DTD.

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: start-dtd ((handler dom-builder) name publicid systemid)
Source

dom-builder.lisp.

Method: start-dtd ((handler broadcast-handler) name public-id system-id)
Source

sax-proxy.lisp.

Method: start-dtd ((handler recoder) name public-id system-id)
Source

recoder.lisp.

Method: start-dtd ((sink sink) name public-id system-id)
Source

unparse.lisp.

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)
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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: start-element ((handler dom-builder) namespace-uri local-name qname attributes)
Source

dom-builder.lisp.

Method: start-element ((handler broadcast-handler) uri lname qname attributes)
Source

sax-proxy.lisp.

Method: start-element ((handler catalog-parser) uri lname qname attrs)
Source

catalog.lisp.

Method: start-element ((handler whitespace-normalizer) uri lname qname attrs)
Source

space-normalizer.lisp.

Method: start-element ((handler namespace-normalizer) uri lname qname attrs)
Source

xmlns-normalizer.lisp.

Method: start-element ((handler recoder) namespace-uri local-name qname attributes)
Source

recoder.lisp.

Method: start-element ((handler xmls-builder) namespace-uri local-name qname attributes)
Source

xmls-compat.lisp.

Method: start-element ((sink sink) namespace-uri local-name qname attributes)
Source

unparse.lisp.

Method: start-element ((handler validator) uri lname qname attributes)
Source

xml-parse.lisp.

Method: start-element ((self0 callback-handler) ns lname qname attrs)
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)
Generic Function: start-internal-subset (handler)

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

Package

fxml.sax.

Source

sax-handler.lisp.

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

klacks-impl.lisp.

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

dom-builder.lisp.

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

sax-proxy.lisp.

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

recoder.lisp.

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

unparse.lisp.

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))
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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: start-prefix-mapping ((handler broadcast-handler) prefix uri)
Source

sax-proxy.lisp.

Method: start-prefix-mapping ((handler recoder) prefix uri)
Source

recoder.lisp.

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)
Generic Function: substring-data (node offset count)
Package

fxml.dom.

Methods
Method: substring-data ((node character-data) offset count)
Source

dom-impl.lisp.

Generic Reader: system-id (object)
Package

fxml.dom.

Methods
Reader Method: system-id ((entity entity))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

system-id.

Reader Method: system-id ((notation notation))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

system-id.

Reader Method: system-id ((document-type document-type))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

system-id.

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

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: system-id ((parser klacksax))
Source

klacks.lisp.

Method: system-id ((parser fxml-parser))
Source

xml-parse.lisp.

Method: system-id ((handler sax-parser-mixin))
Generic Reader: tag-name (object)
Package

fxml.dom.

Methods
Reader Method: tag-name ((element element))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

tag-name.

Generic Reader: target (object)
Package

fxml.dom.

Methods
Reader Method: target ((processing-instruction processing-instruction))

automatically generated reader method

Source

dom-impl.lisp.

Target Slot

target.

Generic Function: text-content (node)
Package

fxml.dom.

Methods
Method: text-content ((node element))
Source

dom-impl.lisp.

Method: text-content ((node document-fragment))
Source

dom-impl.lisp.

Method: text-content ((node attribute))
Source

dom-impl.lisp.

Method: text-content ((node comment))
Source

dom-impl.lisp.

Method: text-content ((node processing-instruction))
Source

dom-impl.lisp.

Method: text-content ((node text))
Source

dom-impl.lisp.

Method: text-content ((node node))
Source

dom-impl.lisp.

Generic Function: (setf text-content) (node)
Package

fxml.dom.

Methods
Method: (setf text-content) ((node element))
Source

dom-impl.lisp.

Method: (setf text-content) ((node document-fragment))
Source

dom-impl.lisp.

Method: (setf text-content) ((node attribute))
Source

dom-impl.lisp.

Method: (setf text-content) ((node comment))
Source

dom-impl.lisp.

Method: (setf text-content) ((node processing-instruction))
Source

dom-impl.lisp.

Method: (setf text-content) ((node text))
Source

dom-impl.lisp.

Method: (setf text-content) ((node node))
Source

dom-impl.lisp.

Method: (setf text-content) (node)
Source

dom-impl.lisp.

Generic Function: text-node-p (object)
Package

fxml.dom.

Methods
Method: text-node-p (object)
Source

dom-impl.lisp.

Method: text-node-p ((object text))
Source

dom-impl.lisp.

Generic Reader: undeclared-namespace-prefix (condition)
Package

fxml.

Methods
Reader Method: undeclared-namespace-prefix ((condition undeclared-namespace))
Source

xml-parse.lisp.

Target Slot

prefix.

Generic Reader: undefined-entity-name (condition)
Package

fxml.

Methods
Reader Method: undefined-entity-name ((condition undefined-entity))
Source

xml-parse.lisp.

Target Slot

name.

Generic Function: unescaped (handler data)

Called for unescaped element content. Beware dragons.

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: unescaped ((handler broadcast-handler) data)
Source

sax-proxy.lisp.

Method: unescaped ((sink sink) data)
Source

unparse.lisp.

Method: unescaped ((self128 callback-handler) data)
Method: unescaped ((handler null) data)
Method: unescaped (handler data)
Method: unescaped ((handler abstract-handler) data)
Method: unescaped ((handler default-handler) data)
Generic Function: unparse-attribute (value)
Package

fxml.

Source

unparse.lisp.

Methods
Method: unparse-attribute ((value integer))
Method: unparse-attribute ((value null))
Method: unparse-attribute ((value string))
Generic Function: unparsed-entity-declaration (handler name public-id system-id notation-name)

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

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: unparsed-entity-declaration ((handler klacks-dtd-handler) name public-id system-id notation-name)
Source

klacks-impl.lisp.

Method: unparsed-entity-declaration ((handler dom-builder) name public-id system-id notation-name)
Source

dom-builder.lisp.

Method: unparsed-entity-declaration ((handler broadcast-handler) name pub sys not)
Source

sax-proxy.lisp.

Method: unparsed-entity-declaration ((handler recoder) name public-id system-id notation-name)
Source

recoder.lisp.

Method: unparsed-entity-declaration ((sink sink) name public-id system-id notation-name)
Source

unparse.lisp.

Method: unparsed-entity-declaration ((handler null) name public-id system-id notation-name)
Method: unparsed-entity-declaration (handler name public-id system-id notation-name)
Method: unparsed-entity-declaration ((handler abstract-handler) name public-id system-id notation-name)
Method: unparsed-entity-declaration ((handler content-handler) name public-id system-id notation-name)
Generic Function: unparsed-internal-subset (handler str)

Reports that an internal subset is present, but has not been parsed and is available as a string.

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: unparsed-internal-subset ((sink sink) str)
Source

unparse.lisp.

Method: unparsed-internal-subset ((handler null) str)
Method: unparsed-internal-subset (handler str)
Method: unparsed-internal-subset ((handler abstract-handler) str)
Method: unparsed-internal-subset ((handler content-handler) str)
Generic Function: value (node)
Package

fxml.dom.

Methods
Method: value ((node attribute))
Source

dom-impl.lisp.

Generic Function: (setf value) (node)
Package

fxml.dom.

Methods
Method: (setf value) ((node attribute))
Source

dom-impl.lisp.

Generic Function: xml-base (sax-parser)

Return the [Base URI] of the current element. This URI can differ from
the value returned by FXML.SAX:SYSTEM-ID if xml:base attributes are present.

Package

fxml.sax.

Source

sax-handler.lisp.

Methods
Method: xml-base ((parser klacksax))
Source

klacks.lisp.

Method: xml-base ((parser fxml-parser))
Source

xml-parse.lisp.

Method: xml-base ((handler sax-parser-mixin))

5.1.6 Standalone methods

Method: close ((stream octet-input-stream) &key &allow-other-keys)
Source

ystream.lisp.

Method: initialize-instance :after ((instance sax-proxy) &key chained-handler)
Source

sax-proxy.lisp.

Method: initialize-instance :after ((instance sink) &key)
Source

unparse.lisp.

Method: initialize-instance :after ((instance catalog-parser) &key uri)
Source

catalog.lisp.

Method: initialize-instance :after ((inst