The cxml-stp Reference Manual

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

The cxml-stp Reference Manual

This is the cxml-stp Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 04:32:57 2022 GMT+0.

Table of Contents


1 Introduction


   cxml-stp

   A data structure for well-formed XML documents, inspired by XOM but
   designed for Common Lisp.

   cxml-stp is an alternative to the W3C's DOM, which cxml also
   implements. It was written by David Lichteblau as an add-on library
   for Closure XML and is available under an X11-style license.

   Please send bug reports to cxml-devel@common-lisp.net
   


For more information, see index.html or
http://www.lichteblau.com/cxml-stp/


2 Systems

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


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

2.1 cxml-stp

Dependencies
  • cxml (system).
  • alexandria (system).
  • xpath (system).
Source

cxml-stp.asd.

Child Components

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   [Contents][Index]

3.1.1 cxml-stp/cxml-stp.asd

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

ASDF Systems

cxml-stp.

Packages

cxml-stp-system.

Public Interface

perform (method).

Internals

closure-source-file (class).


3.1.2 cxml-stp/package.lisp

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Packages

3.1.3 cxml-stp/classes.lisp

Dependency

package.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.4 cxml-stp/node.lisp

Dependency

classes.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.5 cxml-stp/parent-node.lisp

Dependency

node.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.6 cxml-stp/leaf-node.lisp

Dependency

parent-node.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface

map-children (method).

Internals

%children (method).


3.1.7 cxml-stp/document.lisp

Dependency

leaf-node.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.8 cxml-stp/element.lisp

Dependency

document.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.9 cxml-stp/attribute.lisp

Dependency

element.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.10 cxml-stp/document-type.lisp

Dependency

attribute.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.11 cxml-stp/comment.lisp

Dependency

document-type.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.12 cxml-stp/processing-instruction.lisp

Dependency

comment.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.13 cxml-stp/text.lisp

Dependency

processing-instruction.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

3.1.14 cxml-stp/builder.lisp

Dependency

text.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

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

3.1.15 cxml-stp/xpath.lisp

Dependency

builder.lisp (file).

Source

cxml-stp.asd.

Parent Component

cxml-stp (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


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

4.1 cxml-stp-system

Source

cxml-stp.asd.

Use List
  • asdf/interface.
  • common-lisp.
Internals

closure-source-file (class).


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

4.2 cxml-stp

STP is a data structure for well-formed XML documents.

@begin[Parsing and Serializing]{section}
To parse into STP, use an STP builder together with a function generating SAX events:

@aboutfun{make-builder}
Serialize STP by sending SAX events for the tree to a sink:

@aboutfun{serialize}
@end{section}
@begin[Names and Namespace URIs]{section}
STP represents namespace-well-formed documents only. All functions accepting names take a local-name and and a namespace URI as an argument. Qualified names are accepted where it makes sense, and named nodes have a namespace prefix that is taken into account for well-formedness checks.

There are two kinds of named nodes: @class{element} and @class{attribute}. Their slots are:

@aboutfun{local-name}
@aboutfun{namespace-uri}
@aboutfun{namespace-prefix}
For @code{element}, all of the above can be changed using SETF (subject to well-formedness checks).

For attribute, @fun{local-name} can be changed directly, while URI and prefix always have to be changed in the same step using @fun{rename-attribute}.

A node’s qualified name can be be queried:

@aboutfun{qualified-name}

@code{of-name} is convenient when searching for elements or attributes:

@aboutfun{of-name}
@end{section}
@begin[Subclasses of Node]{section}
All STP nodes have a common superclass.

@aboutclass{node}
Documents and elements can have children:

@aboutclass{parent-node}
@aboutclass{document}
@aboutclass{element}
Attributes belong to an @code{element}:

@aboutclass{attribute}
Other kinds of nodes:

@aboutclass{comment}
@aboutclass{document-type}
@aboutclass{processing-instruction}
@aboutclass{text}
@end{section}
@begin[Creating nodes]{section}
Nodes are created using the following functions:

@aboutfun{make-attribute}
@aboutfun{make-comment}
@aboutfun{make-document}
@aboutfun{make-document-type}
@aboutfun{make-element}
@aboutfun{make-processing-instruction}
@aboutfun{make-text}
In addition, nodes can be copied including all their children:

@aboutfun{copy}
@end{section}
@begin[Listing Child Nodes]{section}
Nodes have an optional parent node and can have children.

@aboutfun{parent}
If a node has a @class{document} as its ancestor, it can be found using the @fun{document} function.

@aboutfun{document}
Since the @code{parent} slot needs to be updated when children are added or removed, the sequence of children is not exposed as a mutable Common Lisp sequence.

@aboutfun{list-children}
@aboutfun{map-children}
@aboutmacro{do-children}
The following DOM-like functions are also offered:

@aboutfun{nth-child}
@aboutfun{first-child}
@aboutfun{last-child}
@aboutfun{previous-sibling}
@aboutfun{next-sibling}
A wide variety of sequence-related functions is offered that work
like the Common Lisp functions of the same name, but without the need to call @fun{list-children} first:

@aboutfun{find-child}
@aboutfun{find-child-if}
@aboutfun{child-position}
@aboutfun{child-position-if}
@aboutfun{count-children}
@aboutfun{count-children-if}
@aboutfun{filter-children}
The functions listed above walk only across the direct children of the parent node. In addition, the node hierarchy can be mapped recursively using these functions:

@aboutfun{map-recursively}
@aboutmacro{do-recursively}
@aboutfun{find-recursively}
@aboutfun{filter-recursively}

@end{section}
@begin[Adding and Removing Child Nodes]{section}
While all nodes can be asked for their children, only documents and elements permit actually adding children. (For all other nodes, the sequence of children appears as empty.)

The most flexible function capable of changing the child nodes is @fun{replace-children}. Perhaps more common is @fun{insert-child},
a specialized version for only one new child.

@aboutfun{replace-children}
@aboutfun{insert-child}
Various convenience functions are offered in addition:

@aboutfun{prepend-child}
@aboutfun{append-child}
@aboutfun{delete-child}
@aboutfun{delete-child-if}
@aboutfun{delete-nth-child}
@aboutfun{insert-child-before}
@aboutfun{insert-child-after}
@aboutfun{replace-child}
A node can also be deleted from its parent directly using @fun{detach}.

@aboutfun{detach}
@fun{detach} also works for attributes.

@end{section}
@begin[Elements and their Attributes]{section}
In addition to their children, elements have attributes and "extra namespaces".

Attributes themselves are nodes and be accessed using these functions:

@aboutfun{add-attribute}
@aboutfun{remove-attribute}
@aboutfun{find-attribute-named}
@aboutfun{find-attribute-if}
@aboutfun{list-attributes}
@aboutfun{map-attributes}
@aboutmacro{with-attributes}
As a shortcut, the @fun{attribute-value} and its @code{setf} function allow access to attribute values by name, without having to look up the attribute node first:

@aboutfun{attribute-value}
There are three ways to declare a namespace: Using the name of the element, using the name of one of its attributes, or using an "extra namespace". A prefix can be looked up from any of these local declarations. It is also possible to look up a namespace while taking into account all declarations on parent elements.

@aboutfun{find-local-namespace}
@aboutfun{find-namespace}
Extra namespaces are needed only when a namespace must be declared even though there is no element or attribute referencing it through its name. For example, an attribute declared with type @code{QName} using RelaxNG/XSD must reference a namespace in scope.

@aboutfun{add-extra-namespace}
@aboutfun{remove-extra-namespace}
@aboutfun{find-extra-namespace}
@aboutfun{map-extra-namespaces}
@end{section}

Source

package.lisp.

Nickname

stp

Use List

common-lisp.

Used By List

cxml-stp-impl.

Public Interface

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

4.3 cxml-stp-impl

Source

package.lisp.

Use List
Internals

5 Definitions

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


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

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *check-uri-syntax*

If true (the default), a warning is issued if a string specified as a namespace URI does not have URI syntax.

Package

cxml-stp.

Source

node.lisp.


5.1.2 Macros

Macro: do-children ((var node &optional result) &body body)

@arg[var]{symbol, a variable name}
@arg[node]{a @class{node}}
@arg[result]{a form}
@return{the result of evaluating @code{result}}
Executes @code{body} with @code{var} bound to successive child nodes.

Package

cxml-stp.

Source

node.lisp.

Macro: do-recursively ((var node &optional result) &body body)

@arg[var]{symbol, a variable name}
@arg[node]{a @class{node}}
@arg[result]{a form}
@return{the result of evaluating @code{result}}
Executes @code{bode} with @code{var} bound to successive descendants of @code{node} in pre-order.

Package

cxml-stp.

Source

node.lisp.

Macro: with-attributes ((&rest entries) element &body body)

Evaluate body with the specified attributes bound lexically as if they were variables.

Each entry in @code{entries} is a list of the form @em{(variable-name attribute-name &optional uri)}, where @code{variable-name}
is a symbol and @code{attribute-name} and @code{uri} are strings.

The macro with-attributes invokes @fun{attribute-value}
to access the attributes. specified by each entry.
Both setf and setq can be used to set the value of the attribute.

Package

cxml-stp.

Source

element.lisp.


5.1.3 Ordinary functions

Function: add-attribute (element attribute)

@arg[element]{an instance of @class{element}}
@arg[attribute]{an instance of @class{attribute}}
@short{Add a new attribute to @code{element} or replace an existing attribute node of the same name.}

It is an error if the attribute’s namespace conflicts with existing namespace declarations on this element.

Package

cxml-stp.

Source

element.lisp.

Function: add-extra-namespace (element prefix uri)

@arg[prefix]{string, an NCName}
@arg[uri]{string, a namespace URI}
@arg[element]{an instance of @class{element}}
@return{@code{uri}}
@short{Add an extra namespace to @code{element} that maps @code{prefix} to @code{uri}.}

It is an error if the new namespace conflicts with existing namespace declarations on this element.

Package

cxml-stp.

Source

element.lisp.

Function: append-child (parent child)

@arg[child]{a @class{node}}
@arg[parent]{a @class{parent-node}}
Adds @code{child} as the last child of @code{parent}, if allowed.

Signals an error if the child already has a parent.

Package

cxml-stp.

Source

parent-node.lisp.

Function: attribute (&rest keys)

@unexport{}

Package

cxml-stp.

Source

attribute.lisp.

Function: attribute-value (element name &optional uri)

@arg[element]{an instance of @class{element}} @arg[name]{string, an NCName}
@arg[uri]{string, a namespace URI}
@return{a string or nil}
@short{Searches for an attribute node of @code{element} with the specified local name and namespace URI and returns its value.}

Returns nil if no such attribute was found.

Package

cxml-stp.

Source

element.lisp.

Function: (setf attribute-value) (element name &optional uri)
Package

cxml-stp.

Source

element.lisp.

Function: child-position (value parent &rest args &key from-end start end key test)

@arg[value]{an object}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches for a child node of @code{parent} that satisfies the @code{test} and returns its position.

@see{child-position-if}

Package

cxml-stp.

Source

node.lisp.

Function: child-position-if (predicate parent &rest args &key from-end start end key)

@arg[predicate]{a designator for a function of one argument that returns
a generalized boolean}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches for a child node of @code{parent} that satisfies the @code{test} and returns its position.

@see{child-position}

Package

cxml-stp.

Source

node.lisp.

Function: comment (&rest keys)

@unexport{}

Package

cxml-stp.

Source

comment.lisp.

Function: count-children (value parent &rest args &key from-end start end key test)

@arg[value]{an object}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a non-negative integer less than or equal to the number of child nodes}
Counts (and returns the number of) @code{parent}’s child nodes satisfying the test.
@see{number-of-children}
@see{count-children-if}

Package

cxml-stp.

Source

node.lisp.

Function: count-children-if (predicate parent &rest args &key from-end start end key)

@arg[predicate]{a designator for a function of one argument that returns
a generalized boolean}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @return{a non-negative integer less than or equal to the number of child nodes}
Counts (and returns the number of) @code{parent}’s child nodes satisfying @code{predicate}.
@see{number-of-children}
@see{count-children}

Package

cxml-stp.

Source

node.lisp.

Function: delete-child (child parent &key from-end test start end count key)

@arg[child]{an object}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches for a child node of @code{parent} that satisfies the @code{test} and removes it, if allowed.

Package

cxml-stp.

Source

parent-node.lisp.

Function: delete-children (parent)

@arg[parent]{an @class{element}} @return{nil}
Deletes all children of @code{element}.

Package

cxml-stp.

Source

element.lisp.

Function: delete-nth-child (idx parent)

@arg[idx]{a non-negative integer}
@arg[parent]{a @class{parent-node}}
Removes child @code{idx} of @code{parent}, if allowed.

Package

cxml-stp.

Source

parent-node.lisp.

Function: document (node)

@arg[node]{an instance of @class{node}}
@return{a @class{document} or nil}
@short{Returns the document node ancestor of @code{node}.}

Returns the @class{document} node that is the @fun{root} of @code{node} or @code{nil} if the root node is not a document.

Package

cxml-stp.

Source

node.lisp.

Function: document-element (document)

@arg[document]{a @class{document}}
@return{an @class{element}}
This function returns the child node that is an element. @see{document-type}

Package

cxml-stp.

Source

document.lisp.

Function: (setf document-element) (document)
Package

cxml-stp.

Source

document.lisp.

Function: document-type (document)

@arg[document]{a @class{document}}
@return{a @class{document-type}, or nil}
This function returns the child node that is a document type, or nil. @see{document-element}

Package

cxml-stp.

Source

document.lisp.

Function: (setf document-type) (document)
Package

cxml-stp.

Source

document.lisp.

Function: element (&rest keys)

@unexport{}

Package

cxml-stp.

Source

element.lisp.

Function: filter-children (predicate parent &rest args &key from-end start end count key)

@arg[predicate]{a designator for a function of one argument that returns
a generalized boolean}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @arg[count]{an integer or nil}
@return{a sequence containing nodes}
@short{Return a list of child nodes of @code{parent} from which nodes that do not satisfy @code{predicate} have been removed.}

This function returns the same list as @code{remove-if-not} on the result of @fun{list-children}.

Package

cxml-stp.

Source

node.lisp.

Function: filter-recursively (test node &key key)

@arg[test]{a designator for a function of one argument that returns
a generalized boolean}
@arg[node]{a @class{node}}
@arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a sequence containing nodes}
Return a list of descendant nodes of @code{node} in pre-order, from which nodes that do not satisfy @code{predicate} have been removed.

Package

cxml-stp.

Source

node.lisp.

Function: find-attribute-if (test element)

@arg[test]{a designator for a function of one argument.} @arg[element]{an instance of @class{element}}
@return{an @class{attribute} or nil}
@short{Searches for an attribute node of @code{element} satisfying @code{test}}

Returns nil if no such attribute was found.

Package

cxml-stp.

Source

element.lisp.

Function: find-attribute-named (element name &optional uri)

@arg[element]{an instance of @class{element}} @arg[name]{string, an NCName}
@arg[uri]{string, a namespace URI}
@return{an @class{attribute} or nil}
@short{Searches for an attribute node of @code{element} with the specified local name and namespace URI and returns it.}

Returns nil if no such attribute was found.

Package

cxml-stp.

Source

element.lisp.

Function: find-child (value parent &rest args &key from-end start end key test)

@arg[value]{an object}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches for a child node of @code{parent} that satisfies the @code{test} and returns it.

@see{find-child-if}

Package

cxml-stp.

Source

node.lisp.

Function: find-child-if (predicate parent &rest args &key from-end start end key)

@arg[predicate]{a designator for a function of one argument that returns
a generalized boolean}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @return{a @class{node} or nil}
Searches for a child node of @code{parent} that satisfies @code{predicate} and returns it.

@see{find-child}

Package

cxml-stp.

Source

node.lisp.

Function: find-extra-namespace (prefix element)

@arg[prefix]{a string}
@arg[element]{an instance of @class{element}}
@return{the namespace URI (a string), or nil}
Find the extra namespace named @code{prefix} declared on @code{element} and return its namespace URI, or return nil if no such namespace was found.

Package

cxml-stp.

Source

element.lisp.

Function: find-local-namespace (prefix element)

@arg[prefix]{a string}
@arg[element]{an instance of @class{element}}
@return{the namespace URI (a string), or nil}
@short{Find the namespace @code{prefix} declared on @code{element}
and return its namespace URI, or return nil if no such namespace was found.}

The namespaces considered by this function are: The namespace of the element itself. The namespaces of element’s attributes. Extra namespaces declared by the element. The "xmlns" namespace, which is always fixed.

Package

cxml-stp.

Source

element.lisp.

Function: find-namespace (prefix element)

@arg[prefix]{a string}
@arg[element]{an instance of @class{element}}
@return{the namespace URI (a string), or nil}
@short{Find the namespace @code{prefix} declared on @code{element} or its parent and return its namespace URI, or return nil if no such namespace was found.}

This functions returns the same result as @fun{find-local-namespace} if the namespace is declared directly on @code{element}. Otherwise it takes into account namespaces declared on parent elements.

Package

cxml-stp.

Source

element.lisp.

Function: find-recursively (item node &key key test)

@arg[item]{an object}
@arg[node]{a @class{node}}
@arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches in pre-order for the first descendant of @code{node} that satisfies the @code{test} and returns it.

@see{find-child-if}

Package

cxml-stp.

Source

node.lisp.

Function: find-recursively-if (predicate node &key key)

@arg[test]{a designator for a function of one argument that returns a generalized boolean}
@arg[node]{a @class{node}}
@arg[key]{a designator for a function of one argument, or nil} @return{a @class{node} or nil}
Searches in pre-order for the first descendant of @code{node} that satisfies the @code{test} and returns it.

@see{find-child-if}

Package

cxml-stp.

Source

node.lisp.

Function: first-child (node)

@arg[node]{a @class{node}}
@return{a @class{node} or nil}
Returns first child of @code{node}, or nil.

Package

cxml-stp.

Source

node.lisp.

Function: insert-child-after (parent new-child ref-child)

@arg[parent]{a @class{parent-node}}
@arg[new-child]{a @class{node}}
@arg[ref-child]{a @class{node}}
@short{Adds @code{new-child} after @code{ref-child} as a child node of @code{parent}, if allowed.}

Signals an error if the child already has a parent.

Also signals an error if @code{ref-child} is not a child of @code{parent}.

Package

cxml-stp.

Source

parent-node.lisp.

Function: insert-child-before (parent new-child ref-child)

@arg[parent]{a @class{parent-node}}
@arg[new-child]{a @class{node}}
@arg[ref-child]{a @class{node}}
@short{Adds @code{new-child} before @code{ref-child} as a child node of @code{parent}, if allowed.}

Signals an error if the child already has a parent.

Also signals an error if @code{ref-child} is not a child of @code{parent}.

Package

cxml-stp.

Source

parent-node.lisp.

Function: last-child (node)

@arg[node]{a @class{node}}
@return{a @class{node} or nil}
Returns last child of @code{node}, or nil.

Package

cxml-stp.

Source

node.lisp.

Function: list-attributes (element)

@arg[element]{an @class{element}}
@return{a list of @class{attribute} nodes}
Returns a freshly consed list containing the attributes of @code{element}.

Package

cxml-stp.

Source

element.lisp.

Function: list-children (node)

@arg[node]{a @class{node}}
@return{a list of nodes}
Returns a freshly consed list containing the child nodes of @code{node}.

Package

cxml-stp.

Source

node.lisp.

Function: make-attribute (value name &optional uri)

@arg[value]{a string containing XML characters only}
@arg[name]{a string, either a QName or an NCName}
@arg[uri]{a string, the namespace URI}
@return{an @class{attribute}}
@short{This function creates an attribute node of the given value and name.}

@see{element}

Package

cxml-stp.

Source

attribute.lisp.

Function: make-builder ()

@return{STP builder, a SAX handler}
@short{This function creates SAX handler that constructs an STP document.}

The builder processes SAX events and can be used with any
function generating such events, in particular with cxml:parse-file.

Examples. Parsing a file:
@begin{pre}(cxml:parse #p"example.xml" (stp:make-builder))@end{pre} Parsing a string:
@begin{pre}(cxml:parse "<example/>" (stp:make-builder))@end{pre}

@see{serialize}

Package

cxml-stp.

Source

builder.lisp.

Function: make-comment (data)

@arg[data]{a string containing XML characters only} @return{an @class{comment}}
@short{This function creates a comment node.}

@code{data} must not contain two consecutive dashes, or a dash at the end.

Package

cxml-stp.

Source

comment.lisp.

Function: make-document (document-element)

@arg[document-element]{an @class{element}}
@return{an @class{document}}
@short{This function creates document.}

The given element is used as the document’s only initial child.

Package

cxml-stp.

Source

document.lisp.

Function: make-document-type (root-element-name &optional system-id public-id internal-subset)

@arg[root-element-name]{string, a Name}
@arg[system-id]{a string allowed as a system ID} @arg[public-id]{a string allowed as a public ID} @arg[internal-subset]{a well-formed internal subset as a string} @return{an @class{documen-type}}
@short{This function creates a document-type node.}

@see{document}

Package

cxml-stp.

Source

document-type.lisp.

Function: make-element (name &optional uri)

@arg[name]{string, a QName or NCName}
@arg[uri]{a string, the namespace URI}
@return{an @class{element}}
@short{This function creates an element node of the given name.}

Package

cxml-stp.

Source

element.lisp.

Function: make-processing-instruction (target data)

@arg[target]{string, an NCName}
@arg[data]{string containing XML characters only} @return{an @class{processing-instruction}} @short{This function creates a processing instruction.}

@code{target} must not equal "xml".

@code{data} must not contain the substring "?>".

Package

cxml-stp.

Source

processing-instruction.lisp.

Function: make-text (data)

@arg[data]{a string containing XML characters only} @return{an @class{text}}
@short{This function creates a text node.}

Package

cxml-stp.

Source

text.lisp.

Function: map-attributes (result-type fn element)

@arg[result-type]{a sequence type specifier, or nil}
@arg[fn]{a designator for a function of one argument} @arg[element]{an instance of @class{element}}
@return{an sequence of @code{result-type}, or nil}
@short{Applies @code{fn} to each attribute nodes of @code{element}.}

The @code{result-type} specifies the type of the resulting sequence. @code{map-children} returns nil if @code{result-type} is nil.

Package

cxml-stp.

Source

element.lisp.

Function: map-extra-namespaces (fn element)

@arg[fn]{a designator for a function of two arguments} @arg[element]{an instance of @class{element}} @return{nil}
Call fn for each extra namespace declared on @code{element} with namespace prefix and URI as arguments.

Package

cxml-stp.

Source

element.lisp.

Function: map-recursively (fn node)

@arg[fn]{a designator for a function of one argument} @arg[node]{a @class{node}}
@return{nil}
Applies @code{fn} to successive descendants of @code{node} in pre-order.

Package

cxml-stp.

Source

node.lisp.

Function: (setf namespace-prefix) (element)
Package

cxml-stp.

Source

element.lisp.

Function: (setf namespace-uri) (element)
Package

cxml-stp.

Source

element.lisp.

Function: next-sibling (node)

@arg[node]{a @class{node}}
@return{a @class{node} or nil}
@short{Returns the child following @code{node} in the child list of its parent.}

Signals an error if @code{node} has no parent or is the last child of its parent.

Package

cxml-stp.

Source

node.lisp.

Function: nth-child (n parent)

@arg[n]{a non-negative integer}
@arg[parent]{a @class{node}}
@return{a @class{node}}
@short{Returns child node @code{n} of @code{parent}}, or signals an error if n is negative or as large or larger that the number of child nodes.

Package

cxml-stp.

Source

node.lisp.

Function: number-of-children (parent)

@arg[parent]{a @class{node}}
@return{the number of child nodes}
Returns the number of @code{parent}’s child nodes. @see{count-children}

Package

cxml-stp.

Source

node.lisp.

Function: of-name (name &optional uri)

@arg[name]{an NCName string or @code{nil}}
@arg[uri]{a string, the namespace URI}
@return{an function of one argument}
@short{This function creates a test function for nodes of this name.}

The function returned will return T if the argument is an instance
of @class{attribute} or @class{element} and has the specified local-name and namespace URI, and will return NIL otherwise.

If local-name is nil, only the namespace URI is considered for comparison.

@see{local-name}
@see{namespace-uri}

Package

cxml-stp.

Source

element.lisp.

Function: parent-node (&rest keys)

@unexport{}

Package

cxml-stp.

Source

parent-node.lisp.

Function: prepend-child (parent child)

@arg[parent]{a @class{parent-node}}
@arg[child]{a @class{node}}
@short{Adds @code{child} as the first child of @code{parent}, if allowed.}

Signals an error if the child already has a parent.

Package

cxml-stp.

Source

parent-node.lisp.

Function: previous-sibling (node)

@arg[node]{a @class{node}}
@return{a @class{node} or nil}
@short{Returns the child preceding @code{node} in the child list of its parent.}

Signals an error if @code{node} has no parent or is the first child of its parent.

Package

cxml-stp.

Source

node.lisp.

Function: processing-instruction (&rest keys)

@unexport{}

Package

cxml-stp.

Source

processing-instruction.lisp.

Function: qualified-name (node)

@arg[node]{an @class{element} or @class{attribute}} @return{string, a QName}
@short{Returns the node’s qualified name.}
The qualified name is computed as prefix ’:’ local-name. @see{local-name}
@see{namespace-uri}
@see{namespace-prefix}

Package

cxml-stp.

Source

element.lisp.

Function: remove-attribute (element attribute)

@arg[element]{an instance of @class{element}}
@arg[attribute]{an instance of @class{attribute}}
@return{the attribute}
@short{Remove an attribute node from @code{element}.}

It is an error if @code{attribute} is not an attribute of @code{element}.

Package

cxml-stp.

Source

element.lisp.

Function: remove-extra-namespace (element prefix)

@arg[prefix]{string, an NCName}
@arg[element]{an instance of @class{element}}
@return{@code{uri}}
Removed the extra namespace declared on @code{element} for @code{prefix}.

Package

cxml-stp.

Source

element.lisp.

Function: rename-attribute (attribute prefix uri)

@arg[attribute]{the @class{attribute} to be renamed} @arg[prefix]{string, an NCName}
@arg[uri]{a string, the namespace URI}
@return{the attribute}
@short{This function changed namespace prefix and URI of an attribute.}

Since there is no default namespace for attributes, prefix and uri must be changed in the same step to rename an attribute with no namespace to an attribute with both namespace prefix and URI.

@see{local-name}

Package

cxml-stp.

Source

attribute.lisp.

Function: root (node)

@arg[node]{an instance of @class{node}}
@return{a @class{node} or nil}
@short{Returns the root of the tree of nodes @code{node} is part of.}

In a complete document, this is an instance of @class{document}, but a detached subtree can have any node as its root. In particular, the argument itself is returned if it does not have a @fun{parent}.

Package

cxml-stp.

Source

node.lisp.

Function: stp-error (fmt &rest args)

@unexport{}

Package

cxml-stp.

Source

node.lisp.

Function: text (&rest keys)

@unexport{}

Package

cxml-stp.

Source

text.lisp.


5.1.4 Generic functions

Generic Function: base-uri (node)

@arg[node]{an @class{node}} @return{a string}
@short{Returns the node’s base URI.}

Package

cxml-stp.

Source

node.lisp.

Methods
Method: base-uri ((node element))
Source

element.lisp.

Method: base-uri ((document document))
Source

document.lisp.

Generic Function: (setf base-uri) (node)

@arg[newval]{string, the new base URI} @arg[node]{an @class{parent-node}} @return{the new base URI} @short{Sets the node’s base URI.}

Package

cxml-stp.

Source

parent-node.lisp.

Methods
Method: (setf base-uri) ((node element))
Source

element.lisp.

Method: (setf base-uri) ((document document))
Source

document.lisp.

Generic Function: copy (node)

@arg[node]{a @class{node}}
@short{This function copies a node recursively.}

The resulting node is of the same class as the argument, and all child nodes and attributes are copied in the same way.

Shared structure includes only primitive slot values like strings. (The consequences are undefined if user code mutates such values, whether @code{copy} is used or not.)

Package

cxml-stp.

Source

node.lisp.

Methods
Method: copy ((node text))
Source

text.lisp.

Method: copy ((node processing-instruction))
Source

processing-instruction.lisp.

Method: copy ((node comment))
Source

comment.lisp.

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

document-type.lisp.

Method: copy ((node attribute))
Source

attribute.lisp.

Method: copy ((node element))
Source

element.lisp.

Method: copy ((node document))
Source

document.lisp.

Generic Reader: data (node)

@arg[node]{a @class{comment}, @class{processing-instruction}, or @class{text}}
@return{a string of XML characters}
@short{Returns the node’s data.}

Package

cxml-stp.

Source

comment.lisp.

Methods
Reader Method: data ((text text))

automatically generated reader method

Source

classes.lisp.

Target Slot

data.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

data.

Reader Method: data ((comment comment))

automatically generated reader method

Source

classes.lisp.

Target Slot

data.

Generic Function: (setf data) (node)

@arg[newval]{a string of XML characters}
@arg[node]{a @class{comment}, @class{processing-instruction}, or @class{text}}
@return{the data}
@short{Sets the node’s data.}

Package

cxml-stp.

Source

comment.lisp.

Methods
Writer Method: (setf data) :around ((node text))
Source

text.lisp.

Target Slot

data.

Writer Method: (setf data) :around ((node processing-instruction))
Source

processing-instruction.lisp.

Target Slot

data.

Writer Method: (setf data) :around ((node comment))
Target Slot

data.

Method: (setf data) ((text text))

automatically generated writer method

Source

classes.lisp.

Method: (setf data) ((processing-instruction processing-instruction))

automatically generated writer method

Source

classes.lisp.

Method: (setf data) ((comment comment))

automatically generated writer method

Source

classes.lisp.

Generic Function: delete-child-if (predicate parent &rest args &key from-end start end count key)

@arg[predicate]{a designator for a function of one argument that returns
a generalized boolean}
@arg[parent]{a @class{node}}
@arg[from-end]{a generalized boolead}
@arg[start, end]{bounding index designators for @code{parent}’s child list} @arg[key]{a designator for a function of one argument, or nil} @arg[test]{a designator for a function of two arguments, or nil} @return{a @class{node} or nil}
Searches for an child node of @code{parent} that satisfies @code{predicate} and removes it, if allowed.

Package

cxml-stp.

Source

parent-node.lisp.

Methods
Method: delete-child-if (predicate (parent parent-node) &key from-end start end count key)
Generic Function: detach (node)

@arg[node]{a @class{node}}
@short{This function removes a child node or attribute.}

In contrast to functions for child nodes, this function can also remove an attribute from its parent.

@see{parent}

Package

cxml-stp.

Source

node.lisp.

Methods
Method: detach ((node attribute))
Source

attribute.lisp.

Method: detach ((node node))
Generic Reader: dtd (object)
Package

cxml-stp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

dtd.

Generic Function: (setf dtd) (object)
Package

cxml-stp.

Methods
Writer Method: (setf dtd) :before ((node document-type))
Source

document-type.lisp.

Target Slot

dtd.

Method: (setf dtd) ((document-type document-type))

automatically generated writer method

Source

classes.lisp.

Generic Function: insert-child (parent child position)

@arg[parent]{a @class{parent-node}}
@arg[child]{a @class{node}}
@arg[position]{a non-negative integer}
@short{Adds @code{child} as a child node of @code{parent} at position @code{position} if allowed.}

Signals an error if the new child already has a parent.

Also signals an error if @code{position} is greater than the number @code{parent}’s child nodes.

Package

cxml-stp.

Source

parent-node.lisp.

Methods
Method: insert-child ((parent parent-node) (child node) i)
Generic Reader: internal-subset (document-type)

@arg[document-type]{@class{document-type}}
@return{string, a well-formed internal subset} @short{Returns the document-type’s internal subset as a string.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Reader Method: internal-subset ((document-type document-type))

automatically generated reader method

Source

classes.lisp.

Target Slot

internal-subset.

Generic Function: (setf internal-subset) (document-type)

@arg[newval]{string, a well-formed internal subset} @arg[document-type]{@class{document-type}} @return{the internal-subset}
@short{Sets the document-type’s internal subset.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Writer Method: (setf internal-subset) :around ((node document-type))
Target Slot

internal-subset.

Method: (setf internal-subset) ((document-type document-type))

automatically generated writer method

Source

classes.lisp.

Generic Reader: local-name (node)

@arg[node]{an @class{element} or @class{attribute}} @return{string, an NCName}
@short{Returns the node’s local name.} @see{qualified-name} @see{namespace-uri} @see{namespace-prefix}

Package

cxml-stp.

Source

element.lisp.

Methods
Reader Method: local-name ((named-node-mixin named-node-mixin))

automatically generated reader method

Source

classes.lisp.

Target Slot

local-name.

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

cxml-stp.

Source

element.lisp.

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

attribute.lisp.

Method: (setf local-name) ((node element))
Generic Function: map-children (result-type function node)

@arg[result-type]{a sequence type specifier, or nil}
@arg[function]{a designator for a function of one argument} @arg[node]{a @class{node}}
@return{an sequence of @code{result-type}, or nil}
@short{Applies @code{function} to successive child nodes.}

The @code{result-type} specifies the type of the resulting sequence. @code{map-children} returns nil if @code{result-type} is nil. Otherwise it returns a sequence such that element i is the result of applying @code{function} to child i of @class{node}.

Package

cxml-stp.

Source

node.lisp.

Methods
Method: map-children (result-type fn (node leaf-node))
Source

leaf-node.lisp.

Method: map-children (result-type fn (node parent-node))
Source

parent-node.lisp.

Generic Reader: namespace-prefix (node)

@arg[node]{an @class{element} or @class{attribute}} @return{string, an NCName}
@short{Returns the node’s namespace prefix.} @see{qualified-name}
@see{local-name}
@see{namespace-uri}

Package

cxml-stp.

Source

element.lisp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

prefix.

Generic Reader: namespace-uri (node)

@arg[node]{an @class{element} or @class{attribute}} @return{string, a URI}
@short{Returns the node’s namespace URI.} @see{qualified-name}
@see{local-name}
@see{namespace-prefix}

Package

cxml-stp.

Source

element.lisp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

namespace-uri.

Generic Reader: parent (node)

@arg[node]{an @class{node}} @return{the parent node, or nil} @short{Returns the node’s parent.}

Package

cxml-stp.

Source

node.lisp.

Methods
Reader Method: parent ((node node))

automatically generated reader method

Source

classes.lisp.

Target Slot

parent.

Generic Reader: public-id (document-type)

@arg[document-type]{@class{document-type}} @return{string suitable as a system ID} @short{Returns the document-type’s public-id.}

Package

cxml-stp.

Source

document-type.lisp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

public-id.

Generic Function: (setf public-id) (document-type)

@arg[newval]{string, suitable as a system ID} @arg[document-type]{@class{document-type}} @return{the public-id}
@short{Sets the document-type’s public-id.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Writer Method: (setf public-id) :around ((node document-type))
Target Slot

public-id.

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

automatically generated writer method

Source

classes.lisp.

Generic Function: replace-child (parent old-child new-child)

@arg[parent]{a @class{parent-node}}
@arg[old-child]{a @class{node}}
@arg[new-child]{a @class{node}}
@short{Adds @code{new-child} instead of @code{old-child} as a child node of @code{parent}, if allowed.}

Signals an error if the new child already has a parent.

Also signals an error if @code{old-child} is not a child of @code{parent}.

Package

cxml-stp.

Source

parent-node.lisp.

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

document.lisp.

Method: replace-child ((parent parent-node) old-child new-child)
Generic Reader: root-element-name (document-type)

@arg[document-type]{@class{document-type}} @return{string, a Name}
@short{Returns the document-type’s root-element-name.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Reader Method: root-element-name ((document-type document-type))

automatically generated reader method

Source

classes.lisp.

Target Slot

root-element-name.

Generic Function: (setf root-element-name) (document-type)

@arg[newval]{string, a Name} @arg[document-type]{@class{document-type}} @return{the root-element-name}
@short{Sets the document-type’s root-element-name.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Writer Method: (setf root-element-name) :before ((node document-type))
Target Slot

root-element-name.

Method: (setf root-element-name) ((document-type document-type))

automatically generated writer method

Source

classes.lisp.

Generic Function: serialize (node handler)

@arg[node]{a @class{node}}
@short{This function generates SAX events representing @code{node}.}

Use this function together with a serialization sink to generate
a serialized XML document.

Examples. Serializing to a stream:
@begin{pre}CL-USER> (stp:serialize (stp:make-document (stp:make-element "test")) (cxml:make-character-stream-sink *standard-output*))
<?xml version="1.0" encoding="UTF-8"?>
<test/>
#<SWANK-BACKEND::SLIME-OUTPUT-STREAM {10037EA611@}>
@end{pre}
Examples. Serializing to a string:
@begin{pre}CL-USER> (stp:serialize (stp:make-document (stp:make-element "test")) (cxml:make-string-sink))
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<test/>"
@end{pre}

@see{make-builder}

Package

cxml-stp.

Source

node.lisp.

Methods
Method: serialize ((node text) handler)
Source

text.lisp.

Method: serialize ((node processing-instruction) handler)
Source

processing-instruction.lisp.

Method: serialize ((node comment) handler)
Source

comment.lisp.

Method: serialize ((node document-type) handler)
Source

document-type.lisp.

Method: serialize ((node attribute) handler)
Source

attribute.lisp.

Method: serialize ((node element) handler)
Source

element.lisp.

Method: serialize ((node document) handler)
Source

document.lisp.

Generic Function: string-value (node)

@arg[node]{an instance of @class{node}}
@return{a string}
@short{Returns the string value of @code{node} as defined by XPath.}

For a document, this is the value of its root element.

For an element, the concatenation of the values of those child nodes is returned that are elements or text nodes.
(Leaving only the PCDATA content.)

For a text, comment, and processing instruction nodes, the node’s data is returned.

For an attribute, the attribute value is returned.

The value for document types is not specified.

Package

cxml-stp.

Source

node.lisp.

Methods
Method: string-value ((node text))
Source

text.lisp.

Method: string-value ((node processing-instruction))
Source

processing-instruction.lisp.

Method: string-value ((node comment))
Source

comment.lisp.

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

document-type.lisp.

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

attribute.lisp.

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

element.lisp.

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

document.lisp.

Generic Reader: system-id (document-type)

@arg[document-type]{@class{document-type}} @return{string suitable as a system ID} @short{Returns the document-type’s system-id.}

Package

cxml-stp.

Source

document-type.lisp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

system-id.

Generic Function: (setf system-id) (document-type)

@arg[newval]{string, suitable as a system ID} @arg[document-type]{@class{document-type}} @return{the system-id}
@short{Sets the document-type’s system-id.}

Package

cxml-stp.

Source

document-type.lisp.

Methods
Writer Method: (setf system-id) :around ((node document-type))
Target Slot

system-id.

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

automatically generated writer method

Source

classes.lisp.

Generic Reader: target (processing-instruction)

@arg[processing-instruction]{@class{processing-instruction}} @return{string, a Name}
@short{Returns the processing-instruction’s target.}

Package

cxml-stp.

Source

processing-instruction.lisp.

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

automatically generated reader method

Source

classes.lisp.

Target Slot

target.

Generic Function: (setf target) (processing-instruction)

@arg[newval]{string, a Name} @arg[processing-instruction]{@class{processing-instruction}} @return{the target}
@short{Sets the processing-instruction’s target.}

Package

cxml-stp.

Source

processing-instruction.lisp.

Methods
Writer Method: (setf target) :before ((node processing-instruction))
Target Slot

target.

Method: (setf target) ((processing-instruction processing-instruction))

automatically generated writer method

Source

classes.lisp.

Generic Reader: value (attribute)

@arg[attribute]{an @class{attribute}} @return{a string of XML characters} @short{Returns the attribute’s value.}

Package

cxml-stp.

Source

attribute.lisp.

Methods
Reader Method: value ((attribute attribute))

automatically generated reader method

Source

classes.lisp.

Target Slot

value.

Generic Function: (setf value) (attribute)

@arg[newval]{a string of XML characters} @arg[attribute]{an @class{attribute}} @return{the value}
@short{Sets the attribute’s value.}

Package

cxml-stp.

Source

attribute.lisp.

Methods
Writer Method: (setf value) :before ((node attribute))
Target Slot

value.

Method: (setf value) ((attribute attribute))

automatically generated writer method

Source

classes.lisp.


5.1.5 Standalone methods

Method: attribute-declaration ((builder builder) element-name attribute-name type default)
Package

sax.

Source

builder.lisp.

Method: attribute-pipe-using-navigator ((navigator (eql :default-navigator)) (node element))
Package

xpath-protocol.

Source

xpath.lisp.

Method: attribute-pipe-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: attribute-pipe-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: base-uri-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: base-uri-using-navigator ((navigator (eql :default-navigator)) (node element))
Package

xpath-protocol.

Source

xpath.lisp.

Method: base-uri-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: base-uri-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: characters ((builder builder) data)
Package

sax.

Source

builder.lisp.

Method: child-pipe-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: child-pipe-using-navigator ((navigator (eql :default-navigator)) (node element))
Package

xpath-protocol.

Source

xpath.lisp.

Method: child-pipe-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: child-pipe-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: comment ((builder builder) data)
Package

sax.

Source

builder.lisp.

Method: element-declaration ((builder builder) name model)
Package

sax.

Source

builder.lisp.

Method: end-document ((handler notation-collector))
Package

sax.

Source

document-type.lisp.

Method: end-document ((builder builder))
Package

sax.

Source

builder.lisp.

Method: end-element ((builder builder) uri lname qname)
Package

sax.

Source

builder.lisp.

Method: end-internal-subset ((builder builder))
Package

sax.

Source

builder.lisp.

Method: external-entity-declaration ((builder builder) kind name public-id system-id)
Package

sax.

Source

builder.lisp.

Method: get-element-by-id-using-navigator ((navigator (eql :default-navigator)) (node node) id)
Package

xpath-protocol.

Source

xpath.lisp.

Method: hash-key-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: internal-entity-declaration ((builder builder) kind name value)
Package

sax.

Source

builder.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction))
Package

xpath-protocol.

Source

xpath.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node comment))
Package

xpath-protocol.

Source

xpath.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node text))
Package

xpath-protocol.

Source

xpath.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: local-name-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-pipe-using-navigator ((navigator (eql :default-navigator)) (original-node element))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-pipe-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-pipe-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-prefix-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-prefix-using-navigator ((navigator (eql :default-navigator)) (node comment))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-prefix-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-prefix-using-navigator ((navigator (eql :default-navigator)) (node text))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-prefix-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node comment))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node text))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: namespace-uri-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-equal-using-navigator ((navigator (eql :default-navigator)) (a stp-namespace) (b stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-p-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-p-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-text-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-text-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node attribute) (type (eql :attribute)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction) (type (eql :processing-instruction)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node comment) (type (eql :comment)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node document) (type (eql :document)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node element) (type (eql :element)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node text) (type (eql :text)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node node) type)
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace) (type (eql :namespace)))
Package

xpath-protocol.

Source

xpath.lisp.

Method: node-type-p-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace) type)
Package

xpath-protocol.

Source

xpath.lisp.

Method: notation-declaration ((handler notation-collector) name public system)
Package

sax.

Source

document-type.lisp.

Method: notation-declaration ((builder builder) name public-id system-id)
Package

sax.

Source

builder.lisp.

Method: parent-node-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: parent-node-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: perform :around ((o compile-op) (s closure-source-file))
Package

asdf/action.

Source

cxml-stp.asd.

Method: print-object ((object node) stream)
Source

node.lisp.

Method: processing-instruction ((builder builder) target data)
Package

sax.

Source

builder.lisp.

Method: processing-instruction-target-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction))
Package

xpath-protocol.

Source

xpath.lisp.

Method: processing-instruction-target-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node processing-instruction))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node comment))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node document))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node text))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node node))
Package

xpath-protocol.

Source

xpath.lisp.

Method: qualified-name-using-navigator ((navigator (eql :default-navigator)) (node stp-namespace))
Package

xpath-protocol.

Source

xpath.lisp.

Method: start-document ((builder builder))
Package

sax.

Source

builder.lisp.

Method: start-dtd ((builder builder) name publicid systemid)
Package

sax.

Source

builder.lisp.

Method: start-element ((builder builder) uri lname qname attrs)
Package

sax.

Source

builder.lisp.

Method: start-internal-subset ((builder builder))
Package

sax.

Source

builder.lisp.

Method: start-prefix-mapping ((builder builder) prefix uri)
Package

sax.

Source

builder.lisp.

Method: unparsed-entity-declaration ((builder builder) name public-id system-id notation-name)
Package

sax.

Source

builder.lisp.

Method: unparsed-entity-uri-using-navigator ((navigator (eql :default-navigator)) (node node) name)
Package

xpath-protocol.

Source

xpath.lisp.


5.1.6 Conditions

Condition: stp-error

The class of all STP errors.

Package

cxml-stp.

Source

node.lisp.

Direct superclasses

simple-error.


Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Classes

Class: attribute

@short{Instances of this class represent attributes of an @class{element}, excluding namespace declarations.}

The @fun{parent} of an attribute is always an @class{element} or nil, but the attribute is not a child of that element.

@see-slot{local-name}
@see-slot{namespace-prefix}
@see-slot{namespace-uri}
@see-slot{qualified-name}
@see-slot{value}
@see{list-attributes}
@see-constructor{make-attribute}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: value
Readers

value.

Writers

(setf value).

Class: comment

Instances of this class represent XML comments. @see-slot{data} @see-constructor{make-comment}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

leaf-node.

Direct methods
Direct slots
Slot: data
Initargs

:data

Readers

data.

Writers

(setf data).

Class: document

@short{Instances of this class represent an entire XML document.}

A document may have at most one document-type, and must have exactly one element as a child (in this order).

It may also have comments and processing-instructions anywhere.

@see-constructor{make-document}
@see-slot{document-element}
@see-slot{document-type}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

parent-node.

Direct methods
Class: document-type

@short{Instances of this class represent the DOCTYPE declaration at the beginning of a document.}

The document type is an optional child of a @class{document}. At most one document type is allowed, and it must precede the document element.

Since STP checks well-formedness only, not validity, the document type only declares what DTD the document claims to be conforming to, but does not guarantee that it actually does.

@see-constructor{make-document-type} @see-slot{root-element-name}
@see-slot{system-id}
@see-slot{public-id}
@see-slot{internal-subset}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

leaf-node.

Direct methods
Direct slots
Slot: root-element-name
Readers

root-element-name.

Writers

(setf root-element-name).

Slot: system-id
Readers

system-id.

Writers

(setf system-id).

Slot: public-id
Readers

public-id.

Writers

(setf public-id).

Slot: internal-subset
Readers

internal-subset.

Writers

(setf internal-subset).

Slot: dtd
Readers

dtd.

Writers

(setf dtd).

Class: element

@short{Instances of this class represent XML elements with their attributes and namespaces.}

See @class{node} for functions to query the list of children.

See @class{parent-node} for functions to add or remove children.

@see-slot{local-name}
@see-slot{namespace-prefix}
@see-slot{namespace-uri}
@see-slot{qualified-name}
@see{add-attribute}
@see{remove-attribute}
@see{find-attribute-named}
@see{find-attribute-if}
@see{with-attributes}
@see{list-attributes}
@see{map-attributes}
@see{attribute-value}
@see{find-namespace}
@see{find-attribute-namespace}
@see{find-local-namespace}
@see{find-extra-namespace}
@see{add-extra-namespace}
@see{remove-extra-namespace}
@see{map-extra-namespaces}
@see-constructor{make-element}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: attributes
Package

cxml-stp-impl.

Readers

%attributes.

Writers

(setf %attributes).

Slot: namespaces
Package

cxml-stp-impl.

Readers

%namespaces.

Writers

(setf %namespaces).

Class: node

@short{The superclass of all nodes.}

Although only @class{document} and @class{element} allow children, read-only functions accessing the list of children are available for all nodes and always return zero children for other classes.

@see-slot{parent}
@see-slot{base-uri}
@see{document}
@see{root}
@see{detach}
@see{copy}
@see{serialize}
@see{map-children}
@see{do-children}
@see{list-children}
@see{first-child}
@see{last-child}
@see{nth-child}
@see{previous-sibling}
@see{next-sibling}
@see{count-children}
@see{find-child}
@see{child-position}
@see{count-children-if}
@see{find-child-if}
@see{child-position-if}
@see{filter-children}
@see{map-recursively}
@see{do-recursively}
@see{find-recursively}
@see{filter-recursively}

Package

cxml-stp.

Source

classes.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: parent
Readers

parent.

Writers

(setf %parent).

Class: parent-node

@short{Instances of this class can have children.}

See @class{node} for functions to query the list of children without changing it.

@see{prepend-child}
@see{append-child}
@see{delete-nth-child}
@see{delete-child}
@see{insert-child-before}
@see{insert-child-after}
@see{replace-child}
@see{insert-child}
@see{delete-child-if}
@see{replace-children}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

node.

Direct subclasses
Direct methods
Direct slots
Slot: %base-uri
Package

cxml-stp-impl.

Slot: %children
Package

cxml-stp-impl.

Readers

%children.

Writers

(setf %children).

Class: processing-instruction

Instances of this class represent processing instructions. @see-slot{target}
@see-slot{data} @see-constructor{make-processing-instruction}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

leaf-node.

Direct methods
Direct slots
Slot: target
Initargs

:target

Readers

target.

Writers

(setf target).

Slot: data
Initargs

:data

Readers

data.

Writers

(setf data).

Class: text

Instances of this class represent text nodes. @see-slot{data} @see-constructor{make-text}

Package

cxml-stp.

Source

classes.lisp.

Direct superclasses

leaf-node.

Direct methods
Direct slots
Slot: data
Initargs

:data

Readers

data.

Writers

(setf data).


5.2 Internals


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

5.2.1 Special variables

Special Variable: *serialize-canonical-notations-only-p*
Package

cxml-stp-impl.

Source

document-type.lisp.


5.2.2 Macros

Macro: defreader (name (&rest args) &body body)
Package

cxml-stp-impl.

Source

node.lisp.


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

5.2.3 Ordinary functions

Function: %add-attribute (attribute element)
Package

cxml-stp-impl.

Source

element.lisp.

Function: %nuke-nth-child (parent i)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Function: %remove-attribute (attribute)
Package

cxml-stp-impl.

Source

element.lisp.

Function: %unchecked-insert-child (parent child i)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Function: assert-orphan (node)
Package

cxml-stp-impl.

Source

document.lisp.

Function: attributes-for-print (elt)
Package

cxml-stp-impl.

Source

element.lisp.

Function: builder-append (builder x)
Package

cxml-stp-impl.

Source

builder.lisp.

Function: check-namespace-uri (uri)
Package

cxml-stp-impl.

Source

node.lisp.

Function: check-nc-name (str)
Package

cxml-stp-impl.

Source

element.lisp.

Function: check-uri-like (newval)
Package

cxml-stp-impl.

Source

element.lisp.

Function: check-xml-name (str)
Package

cxml-stp-impl.

Source

document-type.lisp.

Function: childp (a b)
Package

cxml-stp-impl.

Source

element.lisp.

Function: collect-local-namespaces (element)
Package

cxml-stp-impl.

Source

element.lisp.

Function: copy-attributes (new old)
Package

cxml-stp-impl.

Source

element.lisp.

Function: copy-stp-namespace (instance)
Package

cxml-stp-impl.

Source

xpath.lisp.

Function: document (&rest keys)

@unexport{}

Package

cxml-stp-impl.

Source

document.lisp.

Function: document-type (&rest keys)

@unexport{}

Package

cxml-stp-impl.

Source

document-type.lisp.

Function: escape-uri (string)
Package

cxml-stp-impl.

Source

element.lisp.

Function: fill-in-base-uri (removed-child)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Function: find-attribute-namespace (prefix element)
Package

cxml-stp-impl.

Source

element.lisp.

Function: find-base-uri (node)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Function: make-stp-namespace (parent prefix uri)
Package

cxml-stp-impl.

Source

xpath.lisp.

Function: maybe-fill-in-base-uri (removed-child)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Function: maybe-uri->string (thing)
Package

cxml-stp-impl.

Source

node.lisp.

Function: named-node-mixin (&rest keys)

@unexport{}

Package

cxml-stp-impl.

Source

element.lisp.

Function: namep (str)
Package

cxml-stp-impl.

Source

document-type.lisp.

Function: namespaces-for-print (element)
Package

cxml-stp-impl.

Source

element.lisp.

Function: nc-name-p (str)
Package

cxml-stp-impl.

Source

element.lisp.

Function: non-empty-string (x)
Package

cxml-stp-impl.

Source

element.lisp.

Function: normalize-text-nodes! (node)
Package

cxml-stp-impl.

Source

xpath.lisp.

Function: pretty-print-node (node stream)
Package

cxml-stp-impl.

Source

node.lisp.

Function: qualified-of-name (qname element)

@arg[qname]{string, a QName}
@arg[element]{an element in which to look up @code{name}’s namespace} @return{an function of one argument}
@short{This function creates a test function for nodes of this name.}

@code{qname}’s namespace prefix is resolved into its namespace URI as declared by @code{element}. If @code{qname} does not have a prefix, the namespace URI is the empty string. If @code{qname}’s prefix is not declared on @code{element}, an error is signalled.

A function is returned that will return T if the argument is an instance of @class{attribute} or @class{element} and has the local-name namespace URI specified by @code{qname}, and will return NIL otherwise.

@see{qualified-name}
@see{local-name}
@see{find-namespace}
@see{namespace-uri}

Package

cxml-stp-impl.

Source

element.lisp.

Function: sanitize-attribute-name (element name uri urip)
Package

cxml-stp-impl.

Source

element.lisp.

Function: stp-namespace-p (object)
Package

cxml-stp-impl.

Source

xpath.lisp.

Reader: stp-namespace-parent (instance)
Writer: (setf stp-namespace-parent) (instance)
Package

cxml-stp-impl.

Source

xpath.lisp.

Target Slot

parent.

Reader: stp-namespace-prefix (instance)
Writer: (setf stp-namespace-prefix) (instance)
Package

cxml-stp-impl.

Source

xpath.lisp.

Target Slot

prefix.

Reader: stp-namespace-uri (instance)
Writer: (setf stp-namespace-uri) (instance)
Package

cxml-stp-impl.

Source

xpath.lisp.

Target Slot

uri.

Function: ugly-print-node (node stream)
Package

cxml-stp-impl.

Source

node.lisp.

Function: vector->pipe (vector &optional start)
Package

cxml-stp-impl.

Source

xpath.lisp.

Function: xml-characters-p (str)
Package

cxml-stp-impl.

Source

attribute.lisp.

Function: xor (a b)
Package

cxml-stp-impl.

Source

attribute.lisp.


5.2.4 Generic functions

Generic Reader: %attributes (object)
Package

cxml-stp-impl.

Methods
Reader Method: %attributes ((element element))

automatically generated reader method

Source

classes.lisp.

Target Slot

attributes.

Generic Writer: (setf %attributes) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %attributes) ((element element))

automatically generated writer method

Source

classes.lisp.

Target Slot

attributes.

Generic Function: %base-uri (node)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Methods
Method: %base-uri ((node node))
Generic Function: (setf %base-uri) (node)
Package

cxml-stp-impl.

Methods
Method: (setf %base-uri) ((node node))
Source

parent-node.lisp.

Generic Function: %children (object)
Package

cxml-stp-impl.

Methods
Method: %children ((node leaf-node))
Source

leaf-node.lisp.

Reader Method: %children ((parent-node parent-node))

automatically generated reader method

Source

classes.lisp.

Target Slot

%children.

Generic Writer: (setf %children) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %children) ((parent-node parent-node))

automatically generated writer method

Source

classes.lisp.

Target Slot

%children.

Generic Reader: %local-name (object)
Package

cxml-stp-impl.

Methods
Reader Method: %local-name ((named-node-mixin named-node-mixin))

automatically generated reader method

Source

classes.lisp.

Target Slot

local-name.

Generic Writer: (setf %local-name) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %local-name) ((named-node-mixin named-node-mixin))

automatically generated writer method

Source

classes.lisp.

Target Slot

local-name.

Generic Reader: %namespace-prefix (object)
Package

cxml-stp-impl.

Methods
Reader Method: %namespace-prefix ((named-node-mixin named-node-mixin))

automatically generated reader method

Source

classes.lisp.

Target Slot

prefix.

Generic Writer: (setf %namespace-prefix) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %namespace-prefix) ((named-node-mixin named-node-mixin))

automatically generated writer method

Source

classes.lisp.

Target Slot

prefix.

Generic Reader: %namespace-uri (object)
Package

cxml-stp-impl.

Methods
Reader Method: %namespace-uri ((named-node-mixin named-node-mixin))

automatically generated reader method

Source

classes.lisp.

Target Slot

namespace-uri.

Generic Writer: (setf %namespace-uri) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %namespace-uri) ((named-node-mixin named-node-mixin))

automatically generated writer method

Source

classes.lisp.

Target Slot

namespace-uri.

Generic Reader: %namespaces (object)
Package

cxml-stp-impl.

Methods
Reader Method: %namespaces ((element element))

automatically generated reader method

Source

classes.lisp.

Target Slot

namespaces.

Generic Writer: (setf %namespaces) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %namespaces) ((element element))

automatically generated writer method

Source

classes.lisp.

Target Slot

namespaces.

Generic Writer: (setf %parent) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf %parent) ((node node))

automatically generated writer method

Source

classes.lisp.

Target Slot

parent.

Generic Reader: builder-doctype (object)
Package

cxml-stp-impl.

Methods
Reader Method: builder-doctype ((builder builder))

automatically generated reader method

Source

builder.lisp.

Target Slot

doctype.

Generic Writer: (setf builder-doctype) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf builder-doctype) ((builder builder))

automatically generated writer method

Source

builder.lisp.

Target Slot

doctype.

Generic Reader: builder-internal-subset-sink (object)
Package

cxml-stp-impl.

Methods
Reader Method: builder-internal-subset-sink ((builder builder))

automatically generated reader method

Source

builder.lisp.

Target Slot

internal-subset-sink.

Generic Writer: (setf builder-internal-subset-sink) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf builder-internal-subset-sink) ((builder builder))

automatically generated writer method

Source

builder.lisp.

Target Slot

internal-subset-sink.

Generic Reader: builder-nodes (object)
Package

cxml-stp-impl.

Methods
Reader Method: builder-nodes ((builder builder))

automatically generated reader method

Source

builder.lisp.

Target Slot

nodes.

Generic Writer: (setf builder-nodes) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf builder-nodes) ((builder builder))

automatically generated writer method

Source

builder.lisp.

Target Slot

nodes.

Generic Function: check-deletion-allowed (parent child position)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Methods
Method: check-deletion-allowed ((parent element) (child node) i)
Source

element.lisp.

Method: check-deletion-allowed ((parent document) (child element) i)
Source

document.lisp.

Method: check-deletion-allowed ((parent document) (child node) i)
Source

document.lisp.

Generic Function: check-insertion-allowed (parent child position)
Package

cxml-stp-impl.

Source

parent-node.lisp.

Methods
Method: check-insertion-allowed ((parent element) child i)
Source

element.lisp.

Method: check-insertion-allowed ((parent document) child i)
Source

document.lisp.

Generic Reader: collected-notations (object)
Package

cxml-stp-impl.

Methods
Reader Method: collected-notations ((notation-collector notation-collector))

automatically generated reader method

Source

document-type.lisp.

Target Slot

collected-notations.

Generic Writer: (setf collected-notations) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf collected-notations) ((notation-collector notation-collector))

automatically generated writer method

Source

document-type.lisp.

Target Slot

collected-notations.

Generic Reader: namespace-declarations (object)
Package

cxml-stp-impl.

Methods
Reader Method: namespace-declarations ((builder builder))

automatically generated reader method

Source

builder.lisp.

Target Slot

namespace-declarations.

Generic Writer: (setf namespace-declarations) (object)
Package

cxml-stp-impl.

Methods
Writer Method: (setf namespace-declarations) ((builder builder))

automatically generated writer method

Source

builder.lisp.

Target Slot

namespace-declarations.

Generic Function: reconstruct (node &key data target root-element-name system-id public-id internal-subset value attributes extra-namespaces local-name namespace-prefix namespace-uri base-uri children &allow-other-keys)
Package

cxml-stp-impl.

Source

node.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: reconstruct progn ((this text) &key data &allow-other-keys)
Source

text.lisp.

Method: reconstruct progn ((this processing-instruction) &key data target &allow-other-keys)
Source

processing-instruction.lisp.

Method: reconstruct progn ((this comment) &key data &allow-other-keys)
Source

comment.lisp.

Method: reconstruct progn ((this document-type) &key root-element-name system-id public-id internal-subset &allow-other-keys)
Source

document-type.lisp.

Method: reconstruct progn ((this attribute) &key value &allow-other-keys)
Source

attribute.lisp.

Method: reconstruct progn ((this element) &key attributes extra-namespaces &allow-other-keys)
Source

element.lisp.

Method: reconstruct progn ((this named-node-mixin) &key local-name namespace-prefix namespace-uri &allow-other-keys)
Source

element.lisp.

Method: reconstruct progn ((this document) &key &allow-other-keys)
Source

document.lisp.

Method: reconstruct progn ((this parent-node) &key base-uri children &allow-other-keys)
Source

parent-node.lisp.

Generic Function: slots-for-print-object (node)
Package

cxml-stp-impl.

Source

node.lisp.

Method Combination

append.

Options

:most-specific-first

Methods
Method: slots-for-print-object append ((node text))
Source

text.lisp.

Method: slots-for-print-object append ((node processing-instruction))
Source

processing-instruction.lisp.

Method: slots-for-print-object append ((node comment))
Source

comment.lisp.

Method: slots-for-print-object append ((node document-type))
Source

document-type.lisp.

Method: slots-for-print-object append ((node attribute))
Source

attribute.lisp.

Method: slots-for-print-object append ((node element))
Source

element.lisp.

Method: slots-for-print-object append ((node named-node-mixin))
Source

element.lisp.

Method: slots-for-print-object append ((node parent-node))

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

5.2.5 Standalone methods

Method: dtd ((builder builder) dtd)
Package

sax.

Source

builder.lisp.


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

5.2.7 Classes

Class: builder
Package

cxml-stp-impl.

Source

builder.lisp.

Direct superclasses

content-handler.

Direct methods
Direct slots
Slot: nodes
Readers

builder-nodes.

Writers

(setf builder-nodes).

Slot: doctype
Readers

builder-doctype.

Writers

(setf builder-doctype).

Slot: namespace-declarations
Readers

namespace-declarations.

Writers

(setf namespace-declarations).

Slot: internal-subset-sink
Readers

builder-internal-subset-sink.

Writers

(setf builder-internal-subset-sink).

Class: closure-source-file
Package

cxml-stp-system.

Source

cxml-stp.asd.

Direct superclasses

cl-source-file.

Direct methods

perform.

Class: document

@short{Instances of this class represent an entire XML document.}

A document may have at most one document-type, and must have exactly one element as a child (in this order).

It may also have comments and processing-instructions anywhere.

@see-constructor{make-document}
@see-slot{document-element}
@see-slot{document-type}

Package

cxml-stp-impl.

Source

classes.lisp.

Direct superclasses

parent-node.

Direct methods
Class: document-type

@short{Instances of this class represent the DOCTYPE declaration at the beginning of a document.}

The document type is an optional child of a @class{document}. At most one document type is allowed, and it must precede the document element.

Since STP checks well-formedness only, not validity, the document type only declares what DTD the document claims to be conforming to, but does not guarantee that it actually does.

@see-constructor{make-document-type} @see-slot{root-element-name}
@see-slot{system-id}
@see-slot{public-id}
@see-slot{internal-subset}

Package

cxml-stp-impl.

Source

classes.lisp.

Direct superclasses

leaf-node.

Direct methods
Direct slots
Slot: root-element-name
Package

cxml-stp.

Readers

root-element-name.

Writers

(setf root-element-name).

Slot: system-id
Package

cxml-stp.

Readers

system-id.

Writers

(setf system-id).

Slot: public-id
Package

cxml-stp.

Readers

public-id.

Writers

(setf public-id).

Slot: internal-subset
Package

cxml-stp.

Readers

internal-subset.

Writers

(setf internal-subset).

Slot: dtd
Package

cxml-stp.

Readers

dtd.

Writers

(setf dtd).

Class: leaf-node
Package

cxml-stp-impl.

Source

classes.lisp.

Direct superclasses

node.

Direct subclasses
Direct methods
Class: named-node-mixin
Package

cxml-stp-impl.

Source

classes.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: local-name
Package

cxml-stp.

Readers
Writers

(setf %local-name).

Slot: prefix
Readers
Writers

(setf %namespace-prefix).

Slot: namespace-uri
Package

cxml-stp.

Readers
Writers

(setf %namespace-uri).

Class: notation-collector
Package

cxml-stp-impl.

Source

document-type.lisp.

Direct methods
Direct slots
Slot: collected-notations
Readers

collected-notations.

Writers

(setf collected-notations).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W   X  
Index Entry  Section

%
%add-attribute: Private ordinary functions
%attributes: Private generic functions
%attributes: Private generic functions
%base-uri: Private generic functions
%base-uri: Private generic functions
%children: Private generic functions
%children: Private generic functions
%children: Private generic functions
%local-name: Private generic functions
%local-name: Private generic functions
%namespace-prefix: Private generic functions
%namespace-prefix: Private generic functions
%namespace-uri: Private generic functions
%namespace-uri: Private generic functions
%namespaces: Private generic functions
%namespaces: Private generic functions
%nuke-nth-child: Private ordinary functions
%remove-attribute: Private ordinary functions
%unchecked-insert-child: Private ordinary functions

(
(setf %attributes): Private generic functions
(setf %attributes): Private generic functions
(setf %base-uri): Private generic functions
(setf %base-uri): Private generic functions
(setf %children): Private generic functions
(setf %children): Private generic functions
(setf %local-name): Private generic functions
(setf %local-name): Private generic functions
(setf %namespace-prefix): Private generic functions
(setf %namespace-prefix): Private generic functions
(setf %namespace-uri): Private generic functions
(setf %namespace-uri): Private generic functions
(setf %namespaces): Private generic functions
(setf %namespaces): Private generic functions
(setf %parent): Private generic functions
(setf %parent): Private generic functions
(setf attribute-value): Public ordinary functions
(setf base-uri): Public generic functions
(setf base-uri): Public generic functions
(setf base-uri): Public generic functions
(setf builder-doctype): Private generic functions
(setf builder-doctype): Private generic functions
(setf builder-internal-subset-sink): Private generic functions
(setf builder-internal-subset-sink): Private generic functions
(setf builder-nodes): Private generic functions
(setf builder-nodes): Private generic functions
(setf collected-notations): Private generic functions
(setf collected-notations): Private generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf data): Public generic functions
(setf document-element): Public ordinary functions
(setf document-type): Public ordinary functions
(setf dtd): Public generic functions
(setf dtd): Public generic functions
(setf dtd): Public generic functions
(setf internal-subset): Public generic functions
(setf internal-subset): Public generic functions
(setf internal-subset): Public generic functions
(setf local-name): Public generic functions
(setf local-name): Public generic functions
(setf local-name): Public generic functions
(setf namespace-declarations): Private generic functions
(setf namespace-declarations): Private generic functions
(setf namespace-prefix): Public ordinary functions
(setf namespace-uri): Public ordinary functions
(setf public-id): Public generic functions
(setf public-id): Public generic functions
(setf public-id): Public generic functions
(setf root-element-name): Public generic functions
(setf root-element-name): Public generic functions
(setf root-element-name): Public generic functions
(setf stp-namespace-parent): Private ordinary functions
(setf stp-namespace-prefix): Private ordinary functions
(setf stp-namespace-uri): Private ordinary functions
(setf system-id): Public generic functions
(setf system-id): Public generic functions
(setf system-id): Public generic functions
(setf target): Public generic functions
(setf target): Public generic functions
(setf target): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions

A
add-attribute: Public ordinary functions
add-extra-namespace: Public ordinary functions
append-child: Public ordinary functions
assert-orphan: Private ordinary functions
attribute: Public ordinary functions
attribute-declaration: Public standalone methods
attribute-pipe-using-navigator: Public standalone methods
attribute-pipe-using-navigator: Public standalone methods
attribute-pipe-using-navigator: Public standalone methods
attribute-value: Public ordinary functions
attributes-for-print: Private ordinary functions

B
base-uri: Public generic functions
base-uri: Public generic functions
base-uri: Public generic functions
base-uri-using-navigator: Public standalone methods
base-uri-using-navigator: Public standalone methods
base-uri-using-navigator: Public standalone methods
base-uri-using-navigator: Public standalone methods
builder-append: Private ordinary functions
builder-doctype: Private generic functions
builder-doctype: Private generic functions
builder-internal-subset-sink: Private generic functions
builder-internal-subset-sink: Private generic functions
builder-nodes: Private generic functions
builder-nodes: Private generic functions

C
characters: Public standalone methods
check-deletion-allowed: Private generic functions
check-deletion-allowed: Private generic functions
check-deletion-allowed: Private generic functions
check-deletion-allowed: Private generic functions
check-insertion-allowed: Private generic functions
check-insertion-allowed: Private generic functions
check-insertion-allowed: Private generic functions
check-namespace-uri: Private ordinary functions
check-nc-name: Private ordinary functions
check-uri-like: Private ordinary functions
check-xml-name: Private ordinary functions
child-pipe-using-navigator: Public standalone methods
child-pipe-using-navigator: Public standalone methods
child-pipe-using-navigator: Public standalone methods
child-pipe-using-navigator: Public standalone methods
child-position: Public ordinary functions
child-position-if: Public ordinary functions
childp: Private ordinary functions
collect-local-namespaces: Private ordinary functions
collected-notations: Private generic functions
collected-notations: Private generic functions
comment: Public ordinary functions
comment: Public standalone methods
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy-attributes: Private ordinary functions
copy-stp-namespace: Private ordinary functions
count-children: Public ordinary functions
count-children-if: Public ordinary functions

D
data: Public generic functions
data: Public generic functions
data: Public generic functions
data: Public generic functions
defreader: Private macros
delete-child: Public ordinary functions
delete-child-if: Public generic functions
delete-child-if: Public generic functions
delete-children: Public ordinary functions
delete-nth-child: Public ordinary functions
detach: Public generic functions
detach: Public generic functions
detach: Public generic functions
do-children: Public macros
do-recursively: Public macros
document: Public ordinary functions
document: Private ordinary functions
document-element: Public ordinary functions
document-type: Public ordinary functions
document-type: Private ordinary functions
dtd: Public generic functions
dtd: Public generic functions
dtd: Private standalone methods

E
element: Public ordinary functions
element-declaration: Public standalone methods
end-document: Public standalone methods
end-document: Public standalone methods
end-element: Public standalone methods
end-internal-subset: Public standalone methods
escape-uri: Private ordinary functions
external-entity-declaration: Public standalone methods

F
fill-in-base-uri: Private ordinary functions
filter-children: Public ordinary functions
filter-recursively: Public ordinary functions
find-attribute-if: Public ordinary functions
find-attribute-named: Public ordinary functions
find-attribute-namespace: Private ordinary functions
find-base-uri: Private ordinary functions
find-child: Public ordinary functions
find-child-if: Public ordinary functions
find-extra-namespace: Public ordinary functions
find-local-namespace: Public ordinary functions
find-namespace: Public ordinary functions
find-recursively: Public ordinary functions
find-recursively-if: Public ordinary functions
first-child: Public ordinary functions
Function, %add-attribute: Private ordinary functions
Function, %nuke-nth-child: Private ordinary functions
Function, %remove-attribute: Private ordinary functions
Function, %unchecked-insert-child: Private ordinary functions
Function, (setf attribute-value): Public ordinary functions
Function, (setf document-element): Public ordinary functions
Function, (setf document-type): Public ordinary functions
Function, (setf namespace-prefix): Public ordinary functions
Function, (setf namespace-uri): Public ordinary functions
Function, (setf stp-namespace-parent): Private ordinary functions
Function, (setf stp-namespace-prefix): Private ordinary functions
Function, (setf stp-namespace-uri): Private ordinary functions
Function, add-attribute: Public ordinary functions
Function, add-extra-namespace: Public ordinary functions
Function, append-child: Public ordinary functions
Function, assert-orphan: Private ordinary functions
Function, attribute: Public ordinary functions
Function, attribute-value: Public ordinary functions
Function, attributes-for-print: Private ordinary functions
Function, builder-append: Private ordinary functions
Function, check-namespace-uri: Private ordinary functions
Function, check-nc-name: Private ordinary functions
Function, check-uri-like: Private ordinary functions
Function, check-xml-name: Private ordinary functions
Function, child-position: Public ordinary functions
Function, child-position-if: Public ordinary functions
Function, childp: Private ordinary functions
Function, collect-local-namespaces: Private ordinary functions
Function, comment: Public ordinary functions
Function, copy-attributes: Private ordinary functions
Function, copy-stp-namespace: Private ordinary functions
Function, count-children: Public ordinary functions
Function, count-children-if: Public ordinary functions
Function, delete-child: Public ordinary functions
Function, delete-children: Public ordinary functions
Function, delete-nth-child: Public ordinary functions
Function, document: Public ordinary functions
Function, document: Private ordinary functions
Function, document-element: Public ordinary functions
Function, document-type: Public ordinary functions
Function, document-type: Private ordinary functions
Function, element: Public ordinary functions
Function, escape-uri: Private ordinary functions
Function, fill-in-base-uri: Private ordinary functions
Function, filter-children: Public ordinary functions
Function, filter-recursively: Public ordinary functions
Function, find-attribute-if: Public ordinary functions
Function, find-attribute-named: Public ordinary functions
Function, find-attribute-namespace: Private ordinary functions
Function, find-base-uri: Private ordinary functions
Function, find-child: Public ordinary functions
Function, find-child-if: Public ordinary functions
Function, find-extra-namespace: Public ordinary functions
Function, find-local-namespace: Public ordinary functions
Function, find-namespace: Public ordinary functions
Function, find-recursively: Public ordinary functions
Function, find-recursively-if: Public ordinary functions
Function, first-child: Public ordinary functions
Function, insert-child-after: Public ordinary functions
Function, insert-child-before: Public ordinary functions
Function, last-child: Public ordinary functions
Function, list-attributes: Public ordinary functions
Function, list-children: Public ordinary functions
Function, make-attribute: Public ordinary functions
Function, make-builder: Public ordinary functions
Function, make-comment: Public ordinary functions
Function, make-document: Public ordinary functions
Function, make-document-type: Public ordinary functions
Function, make-element: Public ordinary functions
Function, make-processing-instruction: Public ordinary functions
Function, make-stp-namespace: Private ordinary functions
Function, make-text: Public ordinary functions
Function, map-attributes: Public ordinary functions
Function, map-extra-namespaces: Public ordinary functions
Function, map-recursively: Public ordinary functions
Function, maybe-fill-in-base-uri: Private ordinary functions
Function, maybe-uri->string: Private ordinary functions
Function, named-node-mixin: Private ordinary functions
Function, namep: Private ordinary functions
Function, namespaces-for-print: Private ordinary functions
Function, nc-name-p: Private ordinary functions
Function, next-sibling: Public ordinary functions
Function, non-empty-string: Private ordinary functions
Function, normalize-text-nodes!: Private ordinary functions
Function, nth-child: Public ordinary functions
Function, number-of-children: Public ordinary functions
Function, of-name: Public ordinary functions
Function, parent-node: Public ordinary functions
Function, prepend-child: Public ordinary functions
Function, pretty-print-node: Private ordinary functions
Function, previous-sibling: Public ordinary functions
Function, processing-instruction: Public ordinary functions
Function, qualified-name: Public ordinary functions
Function, qualified-of-name: Private ordinary functions
Function, remove-attribute: Public ordinary functions
Function, remove-extra-namespace: Public ordinary functions
Function, rename-attribute: Public ordinary functions
Function, root: Public ordinary functions
Function, sanitize-attribute-name: Private ordinary functions
Function, stp-error: Public ordinary functions
Function, stp-namespace-p: Private ordinary functions
Function, stp-namespace-parent: Private ordinary functions
Function, stp-namespace-prefix: Private ordinary functions
Function, stp-namespace-uri: Private ordinary functions
Function, text: Public ordinary functions
Function, ugly-print-node: Private ordinary functions
Function, vector->pipe: Private ordinary functions
Function, xml-characters-p: Private ordinary functions
Function, xor: Private ordinary functions

G
Generic Function, %attributes: Private generic functions
Generic Function, %base-uri: Private generic functions
Generic Function, %children: Private generic functions
Generic Function, %local-name: Private generic functions
Generic Function, %namespace-prefix: Private generic functions
Generic Function, %namespace-uri: Private generic functions
Generic Function, %namespaces: Private generic functions
Generic Function, (setf %attributes): Private generic functions
Generic Function, (setf %base-uri): Private generic functions
Generic Function, (setf %children): Private generic functions
Generic Function, (setf %local-name): Private generic functions
Generic Function, (setf %namespace-prefix): Private generic functions
Generic Function, (setf %namespace-uri): Private generic functions
Generic Function, (setf %namespaces): Private generic functions
Generic Function, (setf %parent): Private generic functions
Generic Function, (setf base-uri): Public generic functions
Generic Function, (setf builder-doctype): Private generic functions
Generic Function, (setf builder-internal-subset-sink): Private generic functions
Generic Function, (setf builder-nodes): Private generic functions
Generic Function, (setf collected-notations): Private generic functions
Generic Function, (setf data): Public generic functions
Generic Function, (setf dtd): Public generic functions
Generic Function, (setf internal-subset): Public generic functions
Generic Function, (setf local-name): Public generic functions
Generic Function, (setf namespace-declarations): Private generic functions
Generic Function, (setf public-id): Public generic functions
Generic Function, (setf root-element-name): Public generic functions
Generic Function, (setf system-id): Public generic functions
Generic Function, (setf target): Public generic functions
Generic Function, (setf value): Public generic functions
Generic Function, base-uri: Public generic functions
Generic Function, builder-doctype: Private generic functions
Generic Function, builder-internal-subset-sink: Private generic functions
Generic Function, builder-nodes: Private generic functions
Generic Function, check-deletion-allowed: Private generic functions
Generic Function, check-insertion-allowed: Private generic functions
Generic Function, collected-notations: Private generic functions
Generic Function, copy: Public generic functions
Generic Function, data: Public generic functions
Generic Function, delete-child-if: Public generic functions
Generic Function, detach: Public generic functions
Generic Function, dtd: Public generic functions
Generic Function, insert-child: Public generic functions
Generic Function, internal-subset: Public generic functions
Generic Function, local-name: Public generic functions
Generic Function, map-children: Public generic functions
Generic Function, namespace-declarations: Private generic functions
Generic Function, namespace-prefix: Public generic functions
Generic Function, namespace-uri: Public generic functions
Generic Function, parent: Public generic functions
Generic Function, public-id: Public generic functions
Generic Function, reconstruct: Private generic functions
Generic Function, replace-child: Public generic functions
Generic Function, root-element-name: Public generic functions
Generic Function, serialize: Public generic functions
Generic Function, slots-for-print-object: Private generic functions
Generic Function, string-value: Public generic functions
Generic Function, system-id: Public generic functions
Generic Function, target: Public generic functions
Generic Function, value: Public generic functions
get-element-by-id-using-navigator: Public standalone methods

H
hash-key-using-navigator: Public standalone methods

I
insert-child: Public generic functions
insert-child: Public generic functions
insert-child-after: Public ordinary functions
insert-child-before: Public ordinary functions
internal-entity-declaration: Public standalone methods
internal-subset: Public generic functions
internal-subset: Public generic functions

L
last-child: Public ordinary functions
list-attributes: Public ordinary functions
list-children: Public ordinary functions
local-name: Public generic functions
local-name: Public generic functions
local-name-using-navigator: Public standalone methods
local-name-using-navigator: Public standalone methods
local-name-using-navigator: Public standalone methods
local-name-using-navigator: Public standalone methods
local-name-using-navigator: Public standalone methods
local-name-using-navigator: Public standalone methods

M
Macro, defreader: Private macros
Macro, do-children: Public macros
Macro, do-recursively: Public macros
Macro, with-attributes: Public macros
make-attribute: Public ordinary functions
make-builder: Public ordinary functions
make-comment: Public ordinary functions
make-document: Public ordinary functions
make-document-type: Public ordinary functions
make-element: Public ordinary functions
make-processing-instruction: Public ordinary functions
make-stp-namespace: Private ordinary functions
make-text: Public ordinary functions
map-attributes: Public ordinary functions
map-children: Public generic functions
map-children: Public generic functions
map-children: Public generic functions
map-extra-namespaces: Public ordinary functions
map-recursively: Public ordinary functions
maybe-fill-in-base-uri: Private ordinary functions
maybe-uri->string: Private ordinary functions
Method, %attributes: Private generic functions
Method, %base-uri: Private generic functions
Method, %children: Private generic functions
Method, %children: Private generic functions
Method, %local-name: Private generic functions
Method, %namespace-prefix: Private generic functions
Method, %namespace-uri: Private generic functions
Method, %namespaces: Private generic functions
Method, (setf %attributes): Private generic functions
Method, (setf %base-uri): Private generic functions
Method, (setf %children): Private generic functions
Method, (setf %local-name): Private generic functions
Method, (setf %namespace-prefix): Private generic functions
Method, (setf %namespace-uri): Private generic functions
Method, (setf %namespaces): Private generic functions
Method, (setf %parent): Private generic functions
Method, (setf base-uri): Public generic functions
Method, (setf base-uri): Public generic functions
Method, (setf builder-doctype): Private generic functions
Method, (setf builder-internal-subset-sink): Private generic functions
Method, (setf builder-nodes): Private generic functions
Method, (setf collected-notations): Private generic functions
Method, (setf data): Public generic functions
Method, (setf data): Public generic functions
Method, (setf data): Public generic functions
Method, (setf data): Public generic functions
Method, (setf data): Public generic functions
Method, (setf data): Public generic functions
Method, (setf dtd): Public generic functions
Method, (setf dtd): Public generic functions
Method, (setf internal-subset): Public generic functions
Method, (setf internal-subset): Public generic functions
Method, (setf local-name): Public generic functions
Method, (setf local-name): Public generic functions
Method, (setf namespace-declarations): Private generic functions
Method, (setf public-id): Public generic functions
Method, (setf public-id): Public generic functions
Method, (setf root-element-name): Public generic functions
Method, (setf root-element-name): Public generic functions
Method, (setf system-id): Public generic functions
Method, (setf system-id): Public generic functions
Method, (setf target): Public generic functions
Method, (setf target): Public generic functions
Method, (setf value): Public generic functions
Method, (setf value): Public generic functions
Method, attribute-declaration: Public standalone methods
Method, attribute-pipe-using-navigator: Public standalone methods
Method, attribute-pipe-using-navigator: Public standalone methods
Method, attribute-pipe-using-navigator: Public standalone methods
Method, base-uri: Public generic functions
Method, base-uri: Public generic functions
Method, base-uri-using-navigator: Public standalone methods
Method, base-uri-using-navigator: Public standalone methods
Method, base-uri-using-navigator: Public standalone methods
Method, base-uri-using-navigator: Public standalone methods
Method, builder-doctype: Private generic functions
Method, builder-internal-subset-sink: Private generic functions
Method, builder-nodes: Private generic functions
Method, characters: Public standalone methods
Method, check-deletion-allowed: Private generic functions
Method, check-deletion-allowed: Private generic functions
Method, check-deletion-allowed: Private generic functions
Method, check-insertion-allowed: Private generic functions
Method, check-insertion-allowed: Private generic functions
Method, child-pipe-using-navigator: Public standalone methods
Method, child-pipe-using-navigator: Public standalone methods
Method, child-pipe-using-navigator: Public standalone methods
Method, child-pipe-using-navigator: Public standalone methods
Method, collected-notations: Private generic functions
Method, comment: Public standalone methods
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, data: Public generic functions
Method, data: Public generic functions
Method, data: Public generic functions
Method, delete-child-if: Public generic functions
Method, detach: Public generic functions
Method, detach: Public generic functions
Method, dtd: Public generic functions
Method, dtd: Private standalone methods
Method, element-declaration: Public standalone methods
Method, end-document: Public standalone methods
Method, end-document: Public standalone methods
Method, end-element: Public standalone methods
Method, end-internal-subset: Public standalone methods
Method, external-entity-declaration: Public standalone methods
Method, get-element-by-id-using-navigator: Public standalone methods
Method, hash-key-using-navigator: Public standalone methods
Method, insert-child: Public generic functions
Method, internal-entity-declaration: Public standalone methods
Method, internal-subset: Public generic functions
Method, local-name: Public generic functions
Method, local-name-using-navigator: Public standalone methods
Method, local-name-using-navigator: Public standalone methods
Method, local-name-using-navigator: Public standalone methods
Method, local-name-using-navigator: Public standalone methods
Method, local-name-using-navigator: Public standalone methods
Method, local-name-using-navigator: Public standalone methods
Method, map-children: Public generic functions
Method, map-children: Public generic functions
Method, namespace-declarations: Private generic functions
Method, namespace-pipe-using-navigator: Public standalone methods
Method, namespace-pipe-using-navigator: Public standalone methods
Method, namespace-pipe-using-navigator: Public standalone methods
Method, namespace-prefix: Public generic functions
Method, namespace-prefix-using-navigator: Public standalone methods
Method, namespace-prefix-using-navigator: Public standalone methods
Method, namespace-prefix-using-navigator: Public standalone methods
Method, namespace-prefix-using-navigator: Public standalone methods
Method, namespace-prefix-using-navigator: Public standalone methods
Method, namespace-uri: Public generic functions
Method, namespace-uri-using-navigator: Public standalone methods
Method, namespace-uri-using-navigator: Public standalone methods
Method, namespace-uri-using-navigator: Public standalone methods
Method, namespace-uri-using-navigator: Public standalone methods
Method, namespace-uri-using-navigator: Public standalone methods
Method, namespace-uri-using-navigator: Public standalone methods
Method, node-equal-using-navigator: Public standalone methods
Method, node-p-using-navigator: Public standalone methods
Method, node-p-using-navigator: Public standalone methods
Method, node-text-using-navigator: Public standalone methods
Method, node-text-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, node-type-p-using-navigator: Public standalone methods
Method, notation-declaration: Public standalone methods
Method, notation-declaration: Public standalone methods
Method, parent: Public generic functions
Method, parent-node-using-navigator: Public standalone methods
Method, parent-node-using-navigator: Public standalone methods
Method, perform: Public standalone methods
Method, print-object: Public standalone methods
Method, processing-instruction: Public standalone methods
Method, processing-instruction-target-using-navigator: Public standalone methods
Method, processing-instruction-target-using-navigator: Public standalone methods
Method, public-id: Public generic functions
Method, qualified-name-using-navigator: Public standalone methods
Method, qualified-name-using-navigator: Public standalone methods
Method, qualified-name-using-navigator: Public standalone methods
Method, qualified-name-using-navigator: Public standalone methods
Method, qualified-name-using-navigator: Public standalone methods
Method, qualified-name-using-navigator: Public standalone methods
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, reconstruct: Private generic functions
Method, replace-child: Public generic functions
Method, replace-child: Public generic functions
Method, root-element-name: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, serialize: Public generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, slots-for-print-object: Private generic functions
Method, start-document: Public standalone methods
Method, start-dtd: Public standalone methods
Method, start-element: Public standalone methods
Method, start-internal-subset: Public standalone methods
Method, start-prefix-mapping: Public standalone methods
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, string-value: Public generic functions
Method, system-id: Public generic functions
Method, target: Public generic functions
Method, unparsed-entity-declaration: Public standalone methods
Method, unparsed-entity-uri-using-navigator: Public standalone methods
Method, value: Public generic functions

N
named-node-mixin: Private ordinary functions
namep: Private ordinary functions
namespace-declarations: Private generic functions
namespace-declarations: Private generic functions
namespace-pipe-using-navigator: Public standalone methods
namespace-pipe-using-navigator: Public standalone methods
namespace-pipe-using-navigator: Public standalone methods
namespace-prefix: Public generic functions
namespace-prefix: Public generic functions
namespace-prefix-using-navigator: Public standalone methods
namespace-prefix-using-navigator: Public standalone methods
namespace-prefix-using-navigator: Public standalone methods
namespace-prefix-using-navigator: Public standalone methods
namespace-prefix-using-navigator: Public standalone methods
namespace-uri: Public generic functions
namespace-uri: Public generic functions
namespace-uri-using-navigator: Public standalone methods
namespace-uri-using-navigator: Public standalone methods
namespace-uri-using-navigator: Public standalone methods
namespace-uri-using-navigator: Public standalone methods
namespace-uri-using-navigator: Public standalone methods
namespace-uri-using-navigator: Public standalone methods
namespaces-for-print: Private ordinary functions
nc-name-p: Private ordinary functions
next-sibling: Public ordinary functions
node-equal-using-navigator: Public standalone methods
node-p-using-navigator: Public standalone methods
node-p-using-navigator: Public standalone methods
node-text-using-navigator: Public standalone methods
node-text-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
node-type-p-using-navigator: Public standalone methods
non-empty-string: Private ordinary functions
normalize-text-nodes!: Private ordinary functions
notation-declaration: Public standalone methods
notation-declaration: Public standalone methods
nth-child: Public ordinary functions
number-of-children: Public ordinary functions

O
of-name: Public ordinary functions

P
parent: Public generic functions
parent: Public generic functions
parent-node: Public ordinary functions
parent-node-using-navigator: Public standalone methods
parent-node-using-navigator: Public standalone methods
perform: Public standalone methods
prepend-child: Public ordinary functions
pretty-print-node: Private ordinary functions
previous-sibling: Public ordinary functions
print-object: Public standalone methods
processing-instruction: Public ordinary functions
processing-instruction: Public standalone methods
processing-instruction-target-using-navigator: Public standalone methods
processing-instruction-target-using-navigator: Public standalone methods
public-id: Public generic functions
public-id: Public generic functions

Q
qualified-name: Public ordinary functions
qualified-name-using-navigator: Public standalone methods
qualified-name-using-navigator: Public standalone methods
qualified-name-using-navigator: Public standalone methods
qualified-name-using-navigator: Public standalone methods
qualified-name-using-navigator: Public standalone methods
qualified-name-using-navigator: Public standalone methods
qualified-of-name: Private ordinary functions

R
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
reconstruct: Private generic functions
remove-attribute: Public ordinary functions
remove-extra-namespace: Public ordinary functions
rename-attribute: Public ordinary functions
replace-child: Public generic functions
replace-child: Public generic functions
replace-child: Public generic functions
root: Public ordinary functions
root-element-name: Public generic functions
root-element-name: Public generic functions

S
sanitize-attribute-name: Private ordinary functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
serialize: Public generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
slots-for-print-object: Private generic functions
start-document: Public standalone methods
start-dtd: Public standalone methods
start-element: Public standalone methods
start-internal-subset: Public standalone methods
start-prefix-mapping: Public standalone methods
stp-error: Public ordinary functions
stp-namespace-p: Private ordinary functions
stp-namespace-parent: Private ordinary functions
stp-namespace-prefix: Private ordinary functions
stp-namespace-uri: Private ordinary functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
string-value: Public generic functions
system-id: Public generic functions
system-id: Public generic functions

T
target: Public generic functions
target: Public generic functions
text: Public ordinary functions

U
ugly-print-node: Private ordinary functions
unparsed-entity-declaration: Public standalone methods
unparsed-entity-uri-using-navigator: Public standalone methods

V
value: Public generic functions
value: Public generic functions
vector->pipe: Private ordinary functions

W
with-attributes: Public macros

X
xml-characters-p: Private ordinary functions
xor: Private ordinary functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W   X  

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

A.3 Variables

Jump to:   %   *  
A   C   D   I   L   N   P   R   S   T   U   V  
Index Entry  Section

%
%base-uri: Public classes
%children: Public classes

*
*check-uri-syntax*: Public special variables
*serialize-canonical-notations-only-p*: Private special variables

A
attributes: Public classes

C
collected-notations: Private classes

D
data: Public classes
data: Public classes
data: Public classes
doctype: Private classes
dtd: Public classes
dtd: Private classes

I
internal-subset: Public classes
internal-subset: Private classes
internal-subset-sink: Private classes

L
local-name: Private classes

N
namespace-declarations: Private classes
namespace-uri: Private classes
namespaces: Public classes
nodes: Private classes

P
parent: Public classes
parent: Private structures
prefix: Private structures
prefix: Private classes
public-id: Public classes
public-id: Private classes

R
root-element-name: Public classes
root-element-name: Private classes

S
Slot, %base-uri: Public classes
Slot, %children: Public classes
Slot, attributes: Public classes
Slot, collected-notations: Private classes
Slot, data: Public classes
Slot, data: Public classes
Slot, data: Public classes
Slot, doctype: Private classes
Slot, dtd: Public classes
Slot, dtd: Private classes
Slot, internal-subset: Public classes
Slot, internal-subset: Private classes
Slot, internal-subset-sink: Private classes
Slot, local-name: Private classes
Slot, namespace-declarations: Private classes
Slot, namespace-uri: Private classes
Slot, namespaces: Public classes
Slot, nodes: Private classes
Slot, parent: Public classes
Slot, parent: Private structures
Slot, prefix: Private structures
Slot, prefix: Private classes
Slot, public-id: Public classes
Slot, public-id: Private classes
Slot, root-element-name: Public classes
Slot, root-element-name: Private classes
Slot, system-id: Public classes
Slot, system-id: Private classes
Slot, target: Public classes
Slot, uri: Private structures
Slot, value: Public classes
Special Variable, *check-uri-syntax*: Public special variables
Special Variable, *serialize-canonical-notations-only-p*: Private special variables
system-id: Public classes
system-id: Private classes

T
target: Public classes

U
uri: Private structures

V
value: Public classes

Jump to:   %   *  
A   C   D   I   L   N   P   R   S   T   U   V  

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

A.4 Data types

Jump to:   A   B   C   D   E   F   L   N   P   S   T   X  
Index Entry  Section

A
attribute: Public classes
attribute.lisp: The cxml-stp/attribute․lisp file

B
builder: Private classes
builder.lisp: The cxml-stp/builder․lisp file

C
Class, attribute: Public classes
Class, builder: Private classes
Class, closure-source-file: Private classes
Class, comment: Public classes
Class, document: Public classes
Class, document: Private classes
Class, document-type: Public classes
Class, document-type: Private classes
Class, element: Public classes
Class, leaf-node: Private classes
Class, named-node-mixin: Private classes
Class, node: Public classes
Class, notation-collector: Private classes
Class, parent-node: Public classes
Class, processing-instruction: Public classes
Class, text: Public classes
classes.lisp: The cxml-stp/classes․lisp file
closure-source-file: Private classes
comment: Public classes
comment.lisp: The cxml-stp/comment․lisp file
Condition, stp-error: Public conditions
cxml-stp: The cxml-stp system
cxml-stp: The cxml-stp package
cxml-stp-impl: The cxml-stp-impl package
cxml-stp-system: The cxml-stp-system package
cxml-stp.asd: The cxml-stp/cxml-stp․asd file

D
document: Public classes
document: Private classes
document-type: Public classes
document-type: Private classes
document-type.lisp: The cxml-stp/document-type․lisp file
document.lisp: The cxml-stp/document․lisp file

E
element: Public classes
element.lisp: The cxml-stp/element․lisp file

F
File, attribute.lisp: The cxml-stp/attribute․lisp file
File, builder.lisp: The cxml-stp/builder․lisp file
File, classes.lisp: The cxml-stp/classes․lisp file
File, comment.lisp: The cxml-stp/comment․lisp file
File, cxml-stp.asd: The cxml-stp/cxml-stp․asd file
File, document-type.lisp: The cxml-stp/document-type․lisp file
File, document.lisp: The cxml-stp/document․lisp file
File, element.lisp: The cxml-stp/element․lisp file
File, leaf-node.lisp: The cxml-stp/leaf-node․lisp file
File, node.lisp: The cxml-stp/node․lisp file
File, package.lisp: The cxml-stp/package․lisp file
File, parent-node.lisp: The cxml-stp/parent-node․lisp file
File, processing-instruction.lisp: The cxml-stp/processing-instruction․lisp file
File, text.lisp: The cxml-stp/text․lisp file
File, xpath.lisp: The cxml-stp/xpath․lisp file

L
leaf-node: Private classes
leaf-node.lisp: The cxml-stp/leaf-node․lisp file

N
named-node-mixin: Private classes
node: Public classes
node.lisp: The cxml-stp/node․lisp file
notation-collector: Private classes

P
Package, cxml-stp: The cxml-stp package
Package, cxml-stp-impl: The cxml-stp-impl package
Package, cxml-stp-system: The cxml-stp-system package
package.lisp: The cxml-stp/package․lisp file
parent-node: Public classes
parent-node.lisp: The cxml-stp/parent-node․lisp file
processing-instruction: Public classes
processing-instruction.lisp: The cxml-stp/processing-instruction․lisp file

S
stp-error: Public conditions
stp-namespace: Private structures
Structure, stp-namespace: Private structures
System, cxml-stp: The cxml-stp system

T
text: Public classes
text.lisp: The cxml-stp/text․lisp file

X
xpath.lisp: The cxml-stp/xpath․lisp file

Jump to:   A   B   C   D   E   F   L   N   P   S   T   X