The fxml Reference Manual

Table of Contents

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

The fxml Reference Manual

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


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

1 Introduction


Closure XML Parser

   An XML parser written in Common Lisp.

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

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

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

   CXML is licensed under Lisp-LGPL.

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


Documentation

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

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


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

2 Systems

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


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

2.1 fxml

Dependencies
Source

fxml.asd (file)


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

2.2 fxml/dom

Dependency

fxml/xml (system)

Source

fxml.asd (file)

Components

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

2.3 fxml/klacks

Dependency

fxml/xml (system)

Source

fxml.asd (file)

Components

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

2.4 fxml/xml

Dependencies
Source

fxml.asd (file)

Components

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

2.5 fxml/runes

Dependencies
Source

fxml.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 fxml.asd

Location

fxml.asd

Systems
Packages

fxml-system


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

3.1.2 fxml/dom/package.lisp

Parent

fxml/dom (system)

Location

dom/package.lisp

Packages

fxml.dom

Exported Definitions

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

3.1.3 fxml/dom/dom-impl.lisp

Dependency

package.lisp (file)

Parent

fxml/dom (system)

Location

dom/dom-impl.lisp

Packages

fxml.rune-dom

Exported Definitions
Internal Definitions

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

3.1.4 fxml/dom/dom-builder.lisp

Dependency

dom-impl.lisp (file)

Parent

fxml/dom (system)

Location

dom/dom-builder.lisp

Exported Definitions
Internal Definitions

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

3.1.5 fxml/dom/dom-sax.lisp

Dependency

package.lisp (file)

Parent

fxml/dom (system)

Location

dom/dom-sax.lisp

Exported Definitions

map-document (function)

Internal Definitions

compute-attributes (function)


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

3.1.6 fxml/klacks/package.lisp

Parent

fxml/klacks (system)

Location

klacks/package.lisp

Packages

fxml.klacks


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

3.1.7 fxml/klacks/klacks.lisp

Dependency

package.lisp (file)

Parent

fxml/klacks (system)

Location

klacks/klacks.lisp

Exported Definitions
Internal Definitions

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

3.1.8 fxml/klacks/klacks-impl.lisp

Dependency

klacks.lisp (file)

Parent

fxml/klacks (system)

Location

klacks/klacks-impl.lisp

Exported Definitions
Internal Definitions

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

3.1.9 fxml/klacks/tap-source.lisp

Dependency

klacks-impl.lisp (file)

Parent

fxml/klacks (system)

Location

klacks/tap-source.lisp

Exported Definitions
Internal Definitions

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

3.1.10 fxml/xml/package.lisp

Parent

fxml/xml (system)

Location

xml/package.lisp

Packages

fxml


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

3.1.11 fxml/xml/util.lisp

Dependency

package.lisp (file)

Parent

fxml/xml (system)

Location

xml/util.lisp

Exported Definitions
Internal Definitions

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

3.1.12 fxml/xml/sax-handler.lisp

Parent

fxml/xml (system)

Location

xml/sax-handler.lisp

Packages

fxml.sax

Exported Definitions
Internal Definitions

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

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

Dependencies
Parent

fxml/xml (system)

Location

xml/xml-name-rune-p.lisp

Exported Definitions
Internal Definitions

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

3.1.14 fxml/xml/xml-parse.lisp

Dependencies
Parent

fxml/xml (system)

Location

xml/xml-parse.lisp

Exported Definitions
Internal Definitions

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

3.1.15 fxml/xml/unparse.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/unparse.lisp

Exported Definitions
Internal Definitions

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

3.1.16 fxml/xml/xmls-compat.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/xmls-compat.lisp

Packages

fxml.xmls

Exported Definitions
Internal Definitions

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

3.1.17 fxml/xml/recoder.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/recoder.lisp

Exported Definitions
Internal Definitions

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

3.1.18 fxml/xml/xmlns-normalizer.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/xmlns-normalizer.lisp

Exported Definitions
Internal Definitions

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

3.1.19 fxml/xml/space-normalizer.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/space-normalizer.lisp

Exported Definitions
Internal Definitions

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

3.1.20 fxml/xml/catalog.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/catalog.lisp

Exported Definitions
Internal Definitions

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

3.1.21 fxml/xml/sax-proxy.lisp

Dependency

xml-parse.lisp (file)

Parent

fxml/xml (system)

Location

xml/sax-proxy.lisp

Exported Definitions
Internal Definitions

define-sax-proxy-method (macro)


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

3.1.22 fxml/xml/atdoc-configuration.lisp

Dependency

package.lisp (file)

Parent

fxml/xml (system)

Location

xml/atdoc-configuration.lisp

Internal Definitions

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

3.1.23 fxml/runes/package.lisp

Parent

fxml/runes (system)

Location

runes/package.lisp

Packages

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

3.1.24 fxml/runes/definline.lisp

Dependency

package.lisp (file)

Parent

fxml/runes (system)

Location

runes/definline.lisp

Exported Definitions

definline (macro)


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

3.1.25 fxml/runes/characters.lisp

Dependency

definline.lisp (file)

Parent

fxml/runes (system)

Location

runes/characters.lisp

Exported Definitions
Internal Definitions

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

3.1.26 fxml/runes/syntax.lisp

Dependency

characters.lisp (file)

Parent

fxml/runes (system)

Location

runes/syntax.lisp

Internal Definitions

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

3.1.27 fxml/runes/encodings.lisp

Dependency

syntax.lisp (file)

Parent

fxml/runes (system)

Location

runes/encodings.lisp

Exported Definitions
Internal Definitions

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

3.1.28 fxml/runes/encodings-data.lisp

Dependency

encodings.lisp (file)

Parent

fxml/runes (system)

Location

runes/encodings-data.lisp


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

3.1.29 fxml/runes/xstream.lisp

Dependency

encodings-data.lisp (file)

Parent

fxml/runes (system)

Location

runes/xstream.lisp

Exported Definitions
Internal Definitions

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

3.1.30 fxml/runes/ystream.lisp

Dependency

xstream.lisp (file)

Parent

fxml/runes (system)

Location

runes/ystream.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 fxml.dom

Source

package.lisp (file)

Exported Definitions
Internal Definitions

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

4.2 fxml.rune-dom

Source

dom-impl.lisp (file)

Nickname

fxml-dom

Use List
Exported Definitions
Internal Definitions

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

4.3 fxml.klacks

Source

package.lisp (file)

Exported Definitions

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

4.4 fxml

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.5 fxml.sax

Source

sax-handler.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.6 fxml.xmls

Source

xmls-compat.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.7 fxml-system

Source

fxml.asd

Use List

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

4.8 fxml.runes-encoding

Source

package.lisp (file)

Use List
Used By List

fxml

Exported Definitions
Internal Definitions

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

4.9 fxml.utf8-runes

Source

package.lisp (file)

Use List

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

4.10 fxml.runes

Source

package.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *cache-all-dtds*
Package

fxml

Source

xml-parse.lisp (file)

Special Variable: *catalog*
Package

fxml

Source

xml-parse.lisp (file)

Special Variable: *dtd-cache*
Package

fxml

Source

xml-parse.lisp (file)

Special Variable: *include-xmlns-attributes*

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

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

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

Package

fxml.sax

Source

sax-handler.lisp (file)

Special Variable: *namespace-processing*

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

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

Package

fxml.sax

Source

sax-handler.lisp (file)

Special Variable: *prefer*
Package

fxml

Source

catalog.lisp (file)

Special Variable: *use-xmlns-namespace*

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

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

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

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

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

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

Package

fxml.sax

Source

sax-handler.lisp (file)


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

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

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

Macro: definline NAME ARGS &body BODY
Package

fxml.runes

Source

definline.lisp (file)

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

fxml.dom

Source

dom-impl.lisp (file)

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

fxml.dom

Source

dom-impl.lisp (file)

Macro: do-splits ((L R CHAR) (STRING &optional START END) SPLIT-FN &optional RETURN) &body BODY
Package

fxml.runes

Source

ystream.lisp (file)

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

fxml.klacks

Source

klacks.lisp (file)

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

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

Macro: with-document-events (HANDLER) &body BODY
Package

fxml.sax

Source

sax-handler.lisp (file)

Macro: with-element QNAME &body BODY

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

Writes an element to the current output sink.

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

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

Package

fxml

Source

unparse.lisp (file)

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

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

Writes an element to the current output sink.

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

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

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

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

Finally, 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 (file)

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

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

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

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

Package

fxml

Source

unparse.lisp (file)

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

fxml.klacks

Source

klacks.lisp (file)

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

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

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

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

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

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

Package

fxml

Source

unparse.lisp (file)

Macro: with-xml-output SINK &body BODY

@arg[sink]{A @class{SAX handler}, evaluated}
@arg[body]{forms}
@return{The result of calling @code{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 (file)


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

5.1.3 Compiler macros

Compiler Macro: rune<= RUNE &rest MORE-RUNES
Package

fxml.runes

Source

characters.lisp (file)

Compiler Macro: rune>= RUNE &rest MORE-RUNES
Package

fxml.runes

Source

characters.lisp (file)


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

5.1.4 Functions

Function: %rune ROD INDEX
Function: (setf %rune) NEW ROD INDEX
Package

fxml.runes

Source

characters.lisp (file)

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

Function: attribute* PREFIX LNAME VALUE &optional QNAME

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

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

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

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

Package

fxml

Source

unparse.lisp (file)

Function: cdata DATA &aux SINK

@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 (file)

Function: char-rune CHAR
Package

fxml.runes

Source

characters.lisp (file)

Function: clear-dtd-cache DTD-CACHE
Package

fxml

Source

xml-parse.lisp (file)

Function: close-xstream INPUT

Close INPUT, an xstream.

Package

fxml.runes

Source

xstream.lisp (file)

Function: code-rune X
Package

fxml.runes

Source

characters.lisp (file)

Function: comment DATA

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

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

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

Package

fxml

Source

unparse.lisp (file)

Function: consume-characters SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Function: create-document &optional DOCUMENT-ELEMENT
Package

fxml.rune-dom

Source

dom-impl.lisp (file)

Function: current-characters SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Function: current-encoding ()

Return the current encoding of the input stream.

Package

fxml

Source

xml-parse.lisp (file)

Function: current-lname SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Function: current-qname SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Function: current-uri SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Function: digit-rune-p CHAR &optional RADIX
Package

fxml.runes

Source

characters.lisp (file)

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

@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 (file)

Function: expect SOURCE KEY &optional U V W
Package

fxml.klacks

Source

klacks.lisp (file)

Function: external-reference-forbidden PUBID SYSID
Package

fxml

Source

xml-parse.lisp (file)

Function: find-attribute QNAME ATTRS
Package

fxml.sax

Source

sax-handler.lisp (file)

Function: find-attribute-ns URI LNAME ATTRS
Package

fxml.sax

Source

sax-handler.lisp (file)

Function: find-element SOURCE &optional LNAME URI
Package

fxml.klacks

Source

klacks.lisp (file)

Function: find-encoding NAME
Package

fxml.runes-encoding

Source

encodings.lisp (file)

Function: find-event SOURCE KEY
Package

fxml.klacks

Source

klacks.lisp (file)

Function: find-output-encoding NAME
Package

fxml.runes

Source

ystream.lisp (file)

Function: fpeek-rune INPUT

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

Package

fxml.runes

Source

xstream.lisp (file)

Function: fread-rune INPUT

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

Package

fxml.runes

Source

xstream.lisp (file)

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

fxml

Source

xml-parse.lisp (file)

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

fxml.sax

Source

sax-handler.lisp (file)

Function: make-broadcast-handler &rest HANDLERS

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

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

See @class{broadcast-handler} for details.

Package

fxml

Source

sax-proxy.lisp (file)

Function: make-callback-handler &rest ARGS &key &allow-other-keys
Package

fxml.sax

Source

sax-handler.lisp (file)

Function: make-catalog &optional URIS
Package

fxml

Source

catalog.lisp (file)

Function: make-character-stream-sink STREAM &rest INITARGS &key CANONICAL 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 (file)

Function: make-character-stream-ystream TARGET-STREAM
Package

fxml.runes

Source

ystream.lisp (file)

Function: make-dom-builder ()
Package

fxml.rune-dom

Source

dom-builder.lisp (file)

Function: make-dtd-cache ()
Package

fxml

Source

xml-parse.lisp (file)

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

Function: make-namespace-normalizer CHAINED-HANDLER

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

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

Package

fxml

Source

xmlns-normalizer.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

Function: make-octet-input-stream OCTETS
Package

fxml.runes

Source

ystream.lisp (file)

Function: make-octet-stream-sink STREAM &rest INITARGS &key CANONICAL 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 (file)

Function: make-octet-stream-ystream OS-STREAM
Package

fxml.runes

Source

ystream.lisp (file)

Function: make-octet-vector-sink &rest INITARGS &key CANONICAL 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 (file)

Function: make-octet-vector-ystream &key (ENCODING ENCODING) (COLUMN COLUMN) (IN-PTR IN-PTR) (IN-BUFFER IN-BUFFER) (OUT-BUFFER OUT-BUFFER) (RESULT RESULT)
Package

fxml.runes

Source

ystream.lisp (file)

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

fxml

Source

recoder.lisp (file)

Function: make-rod SIZE
Package

fxml.runes

Source

characters.lisp (file)

Function: make-rod-sink &rest INITARGS &key CANONICAL 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 (file)

Function: make-rod-xstream STRING &key NAME

Make an xstream that reads from STRING.

Package

fxml.runes

Source

xstream.lisp (file)

Function: make-rod-ystream &key (ENCODING ENCODING) (COLUMN COLUMN) (IN-PTR IN-PTR) (IN-BUFFER IN-BUFFER)
Package

fxml.runes

Source

ystream.lisp (file)

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

Function: make-string-sink &rest ARGS &key CANONICAL 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 (file)

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

fxml.klacks

Source

tap-source.lisp (file)

Function: make-validator DTD ROOT

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

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

Example:

@pre{(let ((d (parse-file "~/test.xml" (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 (file)

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

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

fxml

Source

space-normalizer.lisp (file)

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

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

Package

fxml.xmls

Source

xmls-compat.lisp (file)

Function: make-xpath-navigator ()
Package

fxml.xmls

Source

xmls-compat.lisp (file)

Function: make-xstream OS-STREAM &key NAME SPEED INITIAL-SPEED INITIAL-ENCODING

Make an xstream from OS-STREAM.

Package

fxml.runes

Source

xstream.lisp (file)

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

fxml.dom

Source

dom-sax.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

Function: map-node-list FN NODELIST
Package

fxml.dom

Source

dom-impl.lisp (file)

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

fxml.dom

Source

dom-impl.lisp (file)

Function: name-rune-p RUNE
Package

fxml

Source

xml-name-rune-p.lisp (file)

Function: name-start-rune-p RUNE
Package

fxml

Source

xml-name-rune-p.lisp (file)

Function: nc-name-p NAME
Package

fxml

Source

xml-parse.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

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

fxml.xmls

Source

xmls-compat.lisp (file)

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

Function: parse-dtd-file FILENAME &optional HANDLER

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

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

Package

fxml

Source

xml-parse.lisp (file)

Function: parse-dtd-stream STREAM &optional HANDLER

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

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

Package

fxml

Source

xml-parse.lisp (file)

Function: parse-rod STRING HANDLER &rest ARGS

@arg[string]{An string of unicode characters.}
@arg[handler]{A @class{SAX handler}}
@return{The value returned by @fun{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 (file)

Function: processing-instruction TARGET DATA

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

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

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

Package

fxml

Source

unparse.lisp (file)

Function: remdtd URI DTD-CACHE
Package

fxml

Source

xml-parse.lisp (file)

Function: resolve-extid PUBLIC SYSTEM CATALOG
Package

fxml

Source

catalog.lisp (file)

Function: resolve-uri URI CATALOG
Package

fxml

Source

catalog.lisp (file)

Function: rod X
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-capitalize ROD
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-downcase ROD
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-equal X Y
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-string ROD &optional DEFAULT-CHAR
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-subseq SOURCE START &optional END
Package

fxml.runes

Source

characters.lisp (file)

Function: rod-to-utf8-string ROD
Package

fxml.runes

Source

ystream.lisp (file)

Function: rod-upcase ROD
Package

fxml.runes

Source

characters.lisp (file)

Function: rod< ROD1 ROD2
Package

fxml.runes

Source

characters.lisp (file)

Function: rod= X Y
Package

fxml.runes

Source

characters.lisp (file)

Function: rune ROD INDEX
Function: (setf rune) NEW ROD INDEX
Package

fxml.runes

Source

characters.lisp (file)

Function: rune-char RUNE &optional DEFAULT
Package

fxml.runes

Source

characters.lisp (file)

Function: rune-code X
Package

fxml.runes

Source

characters.lisp (file)

Function: rune-downcase RUNE
Package

fxml.runes

Source

characters.lisp (file)

Function: rune-equal X Y
Package

fxml.runes

Source

characters.lisp (file)

Function: rune-upcase RUNE
Package

fxml.runes

Source

characters.lisp (file)

Function: rune<= RUNE &rest MORE-RUNES
Package

fxml.runes

Source

characters.lisp (file)

Function: rune= X Y
Package

fxml.runes

Source

characters.lisp (file)

Function: rune>= RUNE &rest MORE-RUNES
Package

fxml.runes

Source

characters.lisp (file)

Function: runep X
Package

fxml.runes

Source

characters.lisp (file)

Function: runes-to-utf8/adjustable-string OUT IN N
Package

fxml.runes

Source

ystream.lisp (file)

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

fxml.klacks

Source

klacks.lisp (file)

Function: serialize-event SOURCE HANDLER &key CONSUME
Package

fxml.klacks

Source

klacks.lisp (file)

Function: serialize-source SOURCE HANDLER
Package

fxml.klacks

Source

klacks.lisp (file)

Function: set-to-full-speed XSTREAM

Cf. ‘xstream-encoding’.

Package

fxml.runes

Source

xstream.lisp (file)

Function: skip SOURCE KEY &optional A B C
Package

fxml.klacks

Source

klacks.lisp (file)

Function: split-qname ()
Package

fxml

Source

xml-parse.lisp (file)

Function: string-rod STRING
Package

fxml.runes

Source

characters.lisp (file)

Function: text DATA

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

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

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

Package

fxml

Source

unparse.lisp (file)

Function: undeclared-namespace PREFIX
Package

fxml

Source

xml-parse.lisp (file)

Function: undefined-entity STREAM ENTITY-NAME
Package

fxml

Source

xml-parse.lisp (file)

Function: unescaped STR

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

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

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

Package

fxml

Source

unparse.lisp (file)

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

Function: utf8-string-to-rod STR
Package

fxml.runes

Source

ystream.lisp (file)

Function: validity-error FMT &rest ARGS
Package

fxml

Source

xml-parse.lisp (file)

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

fxml.runes

Source

characters.lisp (file)

Function: xml-character-p C
Package

fxml

Source

util.lisp (file)

Function: xml-characters-p STR
Package

fxml

Source

util.lisp (file)

Function: xstream-column-number INPUT

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

Package

fxml.runes

Source

xstream.lisp (file)

Function: 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 (file)

Writer

(setf xstream-encoding) (function)

Function: (setf xstream-encoding) VALUE INSTANCE
Package

fxml.runes

Source

xstream.lisp (file)

Reader

xstream-encoding (function)

Function: xstream-line-number INSTANCE

The line number of the underlying stream.

Package

fxml.runes

Source

xstream.lisp (file)

Writer

(setf xstream-line-number) (function)

Function: (setf xstream-line-number) VALUE INSTANCE
Package

fxml.runes

Source

xstream.lisp (file)

Reader

xstream-line-number (function)

Function: xstream-name INSTANCE
Function: (setf xstream-name) VALUE INSTANCE
Package

fxml.runes

Source

xstream.lisp (file)

Function: xstream-p OBJECT
Package

fxml.runes

Source

xstream.lisp (file)

Function: xstream-position INPUT

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

Package

fxml.runes

Source

xstream.lisp (file)

Function: ystream-column INSTANCE
Function: (setf ystream-column) VALUE INSTANCE
Package

fxml.runes

Source

ystream.lisp (file)

Function: ystream-encoding INSTANCE
Function: (setf ystream-encoding) VALUE INSTANCE
Package

fxml.runes

Source

ystream.lisp (file)

Function: ystream-write-escapable-rod ROD YSTREAM &key START END
Package

fxml.runes

Source

ystream.lisp (file)

Function: ystream-write-escapable-rune RUNE YSTREAM
Package

fxml.runes

Source

ystream.lisp (file)

Function: ystream-write-rod ROD YSTREAM &key START END
Package

fxml.runes

Source

ystream.lisp (file)

Function: ystream-write-rune RUNE YSTREAM
Package

fxml.runes

Source

ystream.lisp (file)


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

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

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

dom-impl.lisp (file)

Generic Function: append-data NODE ARG
Package

fxml.dom

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

dom-impl.lisp (file)

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

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

Package

fxml.sax

Source

sax-handler.lisp (file)

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

klacks-impl.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

recoder.lisp (file)

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

unparse.lisp (file)

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

fxml.sax

Source

sax-handler.lisp (file)

Writer

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

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

fxml.sax

Reader

attribute-local-name (generic function)

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

sax-handler.lisp (file)

Generic Function: attribute-namespace-uri ATTRIBUTE
Package

fxml.sax

Source

sax-handler.lisp (file)

Writer

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

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

fxml.sax

Reader

attribute-namespace-uri (generic function)

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

sax-handler.lisp (file)

Generic Function: attribute-p OBJECT
Package

fxml.dom

Methods
Method: attribute-p OBJECT
Source

dom-impl.lisp (file)

Method: attribute-p (OBJECT attribute)
Source

dom-impl.lisp (file)

Generic Function: attribute-qname ATTRIBUTE
Package

fxml.sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-qname) (generic function)

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

fxml.sax

Reader

attribute-qname (generic function)

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

sax-handler.lisp (file)

Generic Function: attribute-specified-p ATTRIBUTE
Package

fxml.sax

Source

sax-handler.lisp (file)

Writer

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

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

fxml.sax

Reader

attribute-specified-p (generic function)

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

sax-handler.lisp (file)

Generic Function: attribute-value ATTRIBUTE
Package

fxml.sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-value) (generic function)

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

fxml.sax

Reader

attribute-value (generic function)

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

sax-handler.lisp (file)

Generic Function: attributes OBJECT
Package

fxml.dom

Methods
Method: attributes (SELF node)
Source

dom-impl.lisp (file)

Method: attributes (ELEMENT element)

automatically generated reader method

Source

dom-impl.lisp (file)

Generic Function: broadcast-handler-handlers OBJECT

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

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

Package

fxml

Writer

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

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

automatically generated reader method

Source

sax-proxy.lisp (file)

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

fxml

Reader

broadcast-handler-handlers (generic function)

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

automatically generated writer method

Source

sax-proxy.lisp (file)

Generic Function: cdata-section-p OBJECT
Package

fxml.dom

Methods
Method: cdata-section-p OBJECT
Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

Generic Function: character-data-p OBJECT
Package

fxml.dom

Methods
Method: character-data-p OBJECT
Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

Generic Function: characters HANDLER DATA

Called for textual element content.

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

Package

fxml.sax

Source

sax-handler.lisp (file)

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

dom-builder.lisp (file)

Method: characters (HANDLER broadcast-handler) DATA
Source

sax-proxy.lisp (file)

Method: characters (HANDLER whitespace-normalizer) DATA
Source

space-normalizer.lisp (file)

Method: characters (HANDLER recoder) DATA
Source

recoder.lisp (file)

Method: characters (HANDLER xmls-builder) DATA
Source

xmls-compat.lisp (file)

Method: characters (SINK sink) DATA
Source

unparse.lisp (file)

Method: characters (HANDLER validator) DATA
Source

xml-parse.lisp (file)

Method: characters (SELF62 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-nodes NODE
Package

fxml.dom

Methods
Method: child-nodes (NODE node)
Source

dom-impl.lisp (file)

Generic Function: clone-node NODE DEEP
Package

fxml.dom

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

dom-impl.lisp (file)

Method: clone-node (NODE node) DEEP
Source

dom-impl.lisp (file)

Generic Function: close-source SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: close-ystream YSTREAM
Package

fxml.runes

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

ystream.lisp (file)

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

ystream.lisp (file)

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

ystream.lisp (file)

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

ystream.lisp (file)

Method: close-ystream (YSTREAM ystream) before
Source

ystream.lisp (file)

Generic Function: code SELF
Package

fxml.dom

Methods
Method: code (SELF dom-exception)
Source

dom-impl.lisp (file)

Generic Function: column-number SAX-PARSER

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

Package

fxml.sax

Source

sax-handler.lisp (file)

Methods
Method: column-number (PARSER klacksax)
Source

klacks.lisp (file)

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

xml-parse.lisp (file)

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

fxml.sax

Source

sax-handler.lisp (file)

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

dom-builder.lisp (file)

Method: comment (HANDLER broadcast-handler) DATA
Source

sax-proxy.lisp (file)

Method: comment (HANDLER recoder) DATA
Source

recoder.lisp (file)

Method: comment (SINK sink) DATA
Source

unparse.lisp (file)

Method: comment (SELF90 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 (file)

Method: comment-p (OBJECT comment)
Source

dom-impl.lisp (file)

Generic Function: consume SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

Methods
Method: consume (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: consume (SOURCE fxml-source)
Source

klacks-impl.lisp (file)

Generic Function: create-attribute DOCUMENT NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-cdata-section DOCUMENT DATA
Package

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-comment DOCUMENT DATA
Package

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-document FACTORY URI QNAME DOCTYPE
Package

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-document-fragment DOCUMENT
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-element DOCUMENT TAG-NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-entity-reference DOCUMENT NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

Generic Function: create-text-node DOCUMENT DATA
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

Method: current-cdata-section-p (FXML-SOURCE fxml-source)

automatically generated reader method

Source

klacks-impl.lisp (file)

Generic Function: current-column-number SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: current-line-number SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: current-system-id SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: current-xml-base SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

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

fxml.dom

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

automatically generated reader method

Source

dom-impl.lisp (file)

Method: data (CHARACTER-DATA character-data)

automatically generated reader method

Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

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

dom-impl.lisp (file)

Generic Function: decode-qname QNAME SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: decode-sequence ENCODING INPUT INPUT-START INPUT-END OUTPUT OUTPUT-START OUTPUT-END EOF-P
Package

fxml.runes-encoding

Source

encodings.lisp (file)

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

Generic Function: deprecated-sax-default-method HANDLER EVENT
Package

fxml.sax

Source

sax-handler.lisp (file)

Methods
Method: deprecated-sax-default-method HANDLER EVENT
Generic Function: doctype OBJECT
Package

fxml.dom

Methods
Method: doctype (DOCUMENT document)

automatically generated reader method

Source

dom-impl.lisp (file)

Generic Function: document-element DOCUMENT
Package

fxml.dom

Methods
Method: document-element (DOCUMENT document)
Source

dom-impl.lisp (file)

Generic Function: document-fragment-p OBJECT
Package

fxml.dom

Methods
Method: document-fragment-p OBJECT
Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

Generic Function: document-p OBJECT
Package

fxml.dom

Methods
Method: document-p OBJECT
Source

dom-impl.lisp (file)

Method: document-p (OBJECT document)
Source

dom-impl.lisp (file)

Generic Function: document-type-p OBJECT
Package

fxml.dom

Methods
Method: document-type-p OBJECT
Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

Generic Function: dtd HANDLER DTD
Package

fxml.sax

Source

sax-handler.lisp (file)

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

klacks-impl.lisp (file)

Method: dtd (HANDLER dom-builder) DTD
Source

dom-builder.lisp (file)

Method: dtd (HANDLER broadcast-handler) DTD
Source

sax-proxy.lisp (file)

Method: dtd (HANDLER whitespace-normalizer) DTD
Source

space-normalizer.lisp (file)

Method: dtd (HANDLER recoder) DTD
Source

recoder.lisp (file)

Method: dtd (HANDLER null) DTD
Method: dtd HANDLER DTD
Method: dtd (HANDLER abstract-handler) DTD
Method: dtd (HANDLER content-handler) DTD
Generic Function: dtd-name CONDITION
Package

fxml

Methods
Method: dtd-name (CONDITION dtd-forbidden)
Source

xml-parse.lisp (file)

Generic Function: dtd-pubid CONDITION
Package

fxml

Methods
Method: dtd-pubid (CONDITION dtd-forbidden)
Source

xml-parse.lisp (file)

Generic Function: dtd-sysid CONDITION
Package

fxml

Methods
Method: dtd-sysid (CONDITION dtd-forbidden)
Source

xml-parse.lisp (file)

Generic Function: element-declaration HANDLER NAME MODEL

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

Package

fxml.sax

Source

sax-handler.lisp (file)

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

klacks-impl.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

recoder.lisp (file)

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

unparse.lisp (file)

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

fxml.dom

Methods
Method: element-p OBJECT
Source

dom-impl.lisp (file)

Method: element-p (OBJECT element)
Source

dom-impl.lisp (file)

Generic Function: end-cdata HANDLER

Called at the end of parsing a CDATA section.

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

Package

fxml.sax

Source

sax-handler.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

Method: end-cdata (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-cdata (SINK sink)
Source

unparse.lisp (file)

Method: end-cdata (HANDLER validator)
Source

xml-parse.lisp (file)

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

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

sax-proxy.lisp (file)

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

catalog.lisp (file)

Method: end-document (HANDLER recoder)
Source

recoder.lisp (file)

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

xmls-compat.lisp (file)

Method: end-document (SINK sink)
Source

unparse.lisp (file)

Method: end-document (SELF50 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 (file)

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

klacks-impl.lisp (file)

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

sax-proxy.lisp (file)

Method: end-dtd (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-dtd (SINK sink)
Source

unparse.lisp (file)

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

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

catalog.lisp (file)

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

space-normalizer.lisp (file)

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

xmlns-normalizer.lisp (file)

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

recoder.lisp (file)

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

xmls-compat.lisp (file)

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

unparse.lisp (file)

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

xml-parse.lisp (file)

Method: end-element (SELF20 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 (file)

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

klacks-impl.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

recoder.lisp (file)

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

unparse.lisp (file)

Method: end-internal-subset (HANDLER null)
Method: end-internal-subset HANDLER
Method: end-internal-subset (HANDLER abstract-handler)
Method: end-internal-subset (HANDLER content-handler)
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 (file)

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

sax-proxy.lisp (file)

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

recoder.lisp (file)

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

fxml.dom

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

automatically generated reader method

Source

dom-impl.lisp (file)

Generic Function: entity-name CONDITION
Package

fxml

Methods
Method: entity-name (CONDITION entities-forbidden)
Source

xml-parse.lisp (file)

Generic Function: entity-p OBJECT
Package

fxml.dom

Methods
Method: entity-p OBJECT
Source

dom-impl.lisp (file)

Method: entity-p (OBJECT entity)
Source

dom-impl.lisp (file)

Generic Function: entity-reference-p OBJECT
Package

fxml.dom

Methods
Method: entity-reference-p OBJECT
Source

dom-impl.lisp (file)

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

dom-impl.lisp (file)

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

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

klacks-impl.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

Method: entity-resolver (HANDLER recoder) RESOLVER
Source

recoder.lisp (file)

Method: entity-resolver (HANDLER null) RESOLVER
Method: entity-resolver HANDLER RESOLVER
Method: entity-resolver (HANDLER abstract-handler) RESOLVER
Method: entity-resolver (HANDLER content-handler) RESOLVER
Generic Function: entity-value CONDITION
Package

fxml

Methods
Method: entity-value (CONDITION entities-forbidden)
Source

xml-parse.lisp (file)

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

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

klacks-impl.lisp (file)

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

dom-builder.lisp (file)

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

sax-proxy.lisp (file)

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

recoder.lisp (file)

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

unparse.lisp (file)

Method: external-entity-declaration (HANDLER null) KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration HANDLER KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration (HANDLER abstract-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration (HANDLER content-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Generic Function: external-reference-pubid CONDITION
Package

fxml

Methods
Method: external-reference-pubid (CONDITION external-reference-forbidden)
Source

xml-parse.lisp (file)

Generic Function: external-reference-sysid CONDITION
Package

fxml

Methods
Method: external-reference-sysid (CONDITION external-reference-forbidden)
Source

xml-parse.lisp (file)

Generic Function: find-namespace-binding PREFIX SOURCE
Package

fxml.klacks

Source

klacks.lisp (file)

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

tap-source.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: first-child NODE
Package

fxml.dom

Methods
Method: first-child (NODE node)
Source

dom-impl.lisp (file)

Generic Function: get-attribute ELEMENT NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.klacks

Source

klacks.lisp (file)

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

klacks-impl.lisp (file)

Generic Function: get-attribute-node ELEMENT NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

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

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

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

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

dom-impl.lisp (file)

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

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

dom-impl.lisp (file)

Generic Function: get-named-item SELF NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

Generic Function: has-attribute ELEMENT NAME
Package

fxml.dom

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

dom-impl.lisp (file)

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

fxml.dom

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

dom-impl.lisp (file)

Generic Function: has-attributes ELEMENT
Package

fxml.dom

Methods
Method: has-attributes (ELEMENT element)
Source

dom-impl.lisp (file)

Method: has-attributes (ELEMENT node)
Source

dom-impl.lisp (file)

Generic Function: has-child-nodes NODE
Package

fxml.dom

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

dom-impl.lisp (file)

Generic Function: has-feature FACTORY FEATURE VERSION
Package

fxml.dom

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

dom-impl.lisp (file)

Generic Function: implementation DOCUMENT