The cxml-stp Reference Manual

Table of Contents

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

The cxml-stp Reference Manual

This is the cxml-stp Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:39:59 2018 GMT+0.


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

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/


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

2 Systems

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


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

2.1 cxml-stp

Dependencies
Source

cxml-stp.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 cxml-stp.asd

Location

cxml-stp.asd

Systems

cxml-stp (system)

Packages

cxml-stp-system

Internal Definitions

closure-source-file (class)


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

3.1.2 cxml-stp/package.lisp

Parent

cxml-stp (system)

Location

package.lisp

Packages

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

3.1.3 cxml-stp/classes.lisp

Dependency

package.lisp (file)

Parent

cxml-stp (system)

Location

classes.lisp

Exported Definitions
Internal Definitions

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

3.1.4 cxml-stp/node.lisp

Dependency

classes.lisp (file)

Parent

cxml-stp (system)

Location

node.lisp

Exported Definitions
Internal Definitions

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

3.1.5 cxml-stp/parent-node.lisp

Dependency

node.lisp (file)

Parent

cxml-stp (system)

Location

parent-node.lisp

Exported Definitions
Internal Definitions

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

3.1.6 cxml-stp/leaf-node.lisp

Dependency

parent-node.lisp (file)

Parent

cxml-stp (system)

Location

leaf-node.lisp

Exported Definitions

map-children (method)

Internal Definitions

%children (method)


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

3.1.7 cxml-stp/document.lisp

Dependency

leaf-node.lisp (file)

Parent

cxml-stp (system)

Location

document.lisp

Exported Definitions
Internal Definitions

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

3.1.8 cxml-stp/element.lisp

Dependency

document.lisp (file)

Parent

cxml-stp (system)

Location

element.lisp

Exported Definitions
Internal Definitions

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

3.1.9 cxml-stp/attribute.lisp

Dependency

element.lisp (file)

Parent

cxml-stp (system)

Location

attribute.lisp

Exported Definitions
Internal Definitions

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

3.1.10 cxml-stp/document-type.lisp

Dependency

attribute.lisp (file)

Parent

cxml-stp (system)

Location

document-type.lisp

Exported Definitions
Internal Definitions

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

3.1.11 cxml-stp/comment.lisp

Dependency

document-type.lisp (file)

Parent

cxml-stp (system)

Location

comment.lisp

Exported Definitions
Internal Definitions

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

3.1.12 cxml-stp/processing-instruction.lisp

Dependency

comment.lisp (file)

Parent

cxml-stp (system)

Location

processing-instruction.lisp

Exported Definitions
Internal Definitions

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

3.1.13 cxml-stp/text.lisp

Dependency

processing-instruction.lisp (file)

Parent

cxml-stp (system)

Location

text.lisp

Exported Definitions
Internal Definitions

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

3.1.14 cxml-stp/builder.lisp

Dependency

text.lisp (file)

Parent

cxml-stp (system)

Location

builder.lisp

Exported Definitions

make-builder (function)

Internal Definitions

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

3.1.15 cxml-stp/xpath.lisp

Dependency

builder.lisp (file)

Parent

cxml-stp (system)

Location

xpath.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 cxml-stp-system

Source

cxml-stp.asd

Use List
Internal Definitions

closure-source-file (class)


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

4.2 cxml-stp-impl

Source

package.lisp (file)

Use List
Internal Definitions

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

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

Nickname

stp

Use List

common-lisp

Used By List

cxml-stp-impl

Exported Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *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 (file)


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

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

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

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


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

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

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

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

Function: attribute &rest KEYS

@unexport{}

Package

cxml-stp

Source

attribute.lisp (file)

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

Writer

(setf attribute-value) (function)

Function: (setf attribute-value) NEWVAL ELEMENT NAME &optional URI
Package

cxml-stp

Source

element.lisp (file)

Reader

attribute-value (function)

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

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

Function: comment &rest KEYS

@unexport{}

Package

cxml-stp

Source

comment.lisp (file)

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

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

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

Function: delete-children PARENT

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

Package

cxml-stp

Source

element.lisp (file)

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

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

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

Writer

(setf document-element) (function)

Function: (setf document-element) NEWVAL DOCUMENT
Package

cxml-stp

Source

document.lisp (file)

Reader

document-element (function)

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

Writer

(setf document-type) (function)

Function: (setf document-type) NEWVAL DOCUMENT
Package

cxml-stp

Source

document.lisp (file)

Reader

document-type (function)

Function: element &rest KEYS

@unexport{}

Package

cxml-stp

Source

element.lisp (file)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Function: (setf namespace-prefix) NEWVAL ELEMENT
Package

cxml-stp

Source

element.lisp (file)

Reader

namespace-prefix (generic function)

Function: (setf namespace-uri) NEWVAL ELEMENT
Package

cxml-stp

Source

element.lisp (file)

Reader

namespace-uri (generic function)

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

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

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

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

Function: parent-node &rest KEYS

@unexport{}

Package

cxml-stp

Source

parent-node.lisp (file)

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

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

Function: processing-instruction &rest KEYS

@unexport{}

Package

cxml-stp

Source

processing-instruction.lisp (file)

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

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

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

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

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

Function: stp-error FMT &rest ARGS

@unexport{}

Package

cxml-stp

Source

node.lisp (file)

Function: text &rest KEYS

@unexport{}

Package

cxml-stp

Source

text.lisp (file)


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

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

Writer

(setf base-uri) (generic function)

Methods
Method: base-uri (NODE element)
Source

element.lisp (file)

Method: base-uri (DOCUMENT document)
Source

document.lisp (file)

Generic Function: (setf base-uri) NEWVAL 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 (file)

Reader

base-uri (generic function)

Methods
Method: (setf base-uri) NEWVAL (NODE element)
Source

element.lisp (file)

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

document.lisp (file)

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

Methods
Method: copy (NODE text)
Source

text.lisp (file)

Method: copy (NODE processing-instruction)
Source

processing-instruction.lisp (file)

Method: copy (NODE comment)
Source

comment.lisp (file)

Method: copy (NODE document-type)
Source

document-type.lisp (file)

Method: copy (NODE attribute)
Source

attribute.lisp (file)

Method: copy (NODE element)
Source

element.lisp (file)

Method: copy (NODE document)
Source

document.lisp (file)

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

Writer

(setf data) (generic function)

Methods
Method: data (TEXT text)

automatically generated reader method

Source

classes.lisp (file)

Method: data (PROCESSING-INSTRUCTION processing-instruction)

automatically generated reader method

Source

classes.lisp (file)

Method: data (COMMENT comment)

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf data) NEWVAL 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 (file)

Reader

data (generic function)

Methods
Method: (setf data) NEW-VALUE (TEXT text)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf data) NEW-VALUE (PROCESSING-INSTRUCTION processing-instruction)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf data) NEW-VALUE (COMMENT comment)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf data) NEWVAL (NODE text) around
Source

text.lisp (file)

Method: (setf data) NEWVAL (NODE processing-instruction) around
Source

processing-instruction.lisp (file)

Method: (setf data) NEWVAL (NODE comment) around
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 (file)

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

Methods
Method: detach (NODE attribute)
Source

attribute.lisp (file)

Method: detach (NODE node)
Generic Function: dtd OBJECT
Generic Function: (setf dtd) NEW-VALUE OBJECT
Package

cxml-stp

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

automatically generated reader method

Source

classes.lisp (file)

Method: (setf dtd) NEW-VALUE (DOCUMENT-TYPE document-type)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf dtd) NEWVAL (NODE document-type) before
Source

document-type.lisp (file)

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

Methods
Method: insert-child (PARENT parent-node) (CHILD node) I
Generic Function: 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 (file)

Writer

(setf internal-subset) (generic function)

Methods
Method: internal-subset (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf internal-subset) NEWVAL 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 (file)

Reader

internal-subset (generic function)

Methods
Method: (setf internal-subset) NEW-VALUE (DOCUMENT-TYPE document-type)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf internal-subset) NEWVAL (NODE document-type) around
Generic Function: 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 (file)

Writer

(setf local-name) (generic function)

Methods
Method: local-name (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf local-name) NEWVAL NODE
Package

cxml-stp

Source

element.lisp (file)

Reader

local-name (generic function)

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

attribute.lisp (file)

Method: (setf local-name) NEWVAL (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 (file)

Methods
Method: map-children RESULT-TYPE FN (NODE leaf-node)
Source

leaf-node.lisp (file)

Method: map-children RESULT-TYPE FN (NODE parent-node)
Source

parent-node.lisp (file)

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

Writer

(setf namespace-prefix) (function)

Methods
Method: namespace-prefix (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

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

Writer

(setf namespace-uri) (function)

Methods
Method: namespace-uri (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

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

Methods
Method: parent (NODE node)

automatically generated reader method

Source

classes.lisp (file)

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

Writer

(setf public-id) (generic function)

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

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf public-id) NEWVAL 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 (file)

Reader

public-id (generic function)

Methods
Method: (setf public-id) NEW-VALUE (DOCUMENT-TYPE document-type)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf public-id) NEWVAL (NODE document-type) around
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 (file)

Methods
Method: replace-child (PARENT document) OLD-CHILD NEW-CHILD
Source

document.lisp (file)

Method: replace-child (PARENT parent-node) OLD-CHILD NEW-CHILD
Generic Function: 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 (file)

Writer

(setf root-element-name) (generic function)

Methods
Method: root-element-name (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf root-element-name) NEWVAL 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 (file)

Reader

root-element-name (generic function)

Methods
Method: (setf root-element-name) NEW-VALUE (DOCUMENT-TYPE document-type)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf root-element-name) NEWVAL (NODE document-type) before
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 (file)

Methods
Method: serialize (NODE text) HANDLER
Source

text.lisp (file)

Method: serialize (NODE processing-instruction) HANDLER
Source

processing-instruction.lisp (file)

Method: serialize (NODE comment) HANDLER
Source

comment.lisp (file)

Method: serialize (NODE document-type) HANDLER
Source

document-type.lisp (file)

Method: serialize (NODE attribute) HANDLER
Source

attribute.lisp (file)

Method: serialize (NODE element) HANDLER
Source

element.lisp (file)

Method: serialize (NODE document) HANDLER
Source

document.lisp (file)

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

Methods
Method: string-value (NODE text)
Source

text.lisp (file)

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

processing-instruction.lisp (file)

Method: string-value (NODE comment)
Source

comment.lisp (file)

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

document-type.lisp (file)

Method: string-value (NODE attribute)
Source

attribute.lisp (file)

Method: string-value (NODE element)
Source

element.lisp (file)

Method: string-value (NODE document)
Source

document.lisp (file)

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

Writer

(setf system-id) (generic function)

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

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf system-id) NEWVAL 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 (file)

Reader

system-id (generic function)

Methods
Method: (setf system-id) NEW-VALUE (DOCUMENT-TYPE document-type)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf system-id) NEWVAL (NODE document-type) around
Generic Function: 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 (file)

Writer

(setf target) (generic function)

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

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf target) NEWVAL 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 (file)

Reader

target (generic function)

Methods
Method: (setf target) NEW-VALUE (PROCESSING-INSTRUCTION processing-instruction)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf target) NEWVAL (NODE processing-instruction) before
Generic Function: 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 (file)

Writer

(setf value) (generic function)

Methods
Method: value (ATTRIBUTE attribute)

automatically generated reader method

Source

classes.lisp (file)

Generic Function: (setf value) NEWVAL 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 (file)

Reader

value (generic function)

Methods
Method: (setf value) NEW-VALUE (ATTRIBUTE attribute)

automatically generated writer method

Source

classes.lisp (file)

Method: (setf value) NEWVAL (NODE attribute) before

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

5.1.5 Conditions

Condition: stp-error ()

The class of all STP errors.

Package

cxml-stp

Source

node.lisp (file)

Direct superclasses

simple-error (condition)


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

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

Direct superclasses
Direct methods
Direct slots
Slot: value
Readers

value (generic function)

Writers

(setf value) (generic function)

Class: comment ()

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

Package

cxml-stp

Source

classes.lisp (file)

Direct superclasses

leaf-node (class)

Direct methods
Direct slots
Slot: data
Initargs

:data

Readers

data (generic function)

Writers

(setf data) (generic function)

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

Direct superclasses

parent-node (class)

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

Direct superclasses

leaf-node (class)

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

root-element-name (generic function)

Writers

(setf root-element-name) (generic function)

Slot: system-id
Readers

system-id (generic function)

Writers

(setf system-id) (generic function)

Slot: public-id
Readers

public-id (generic function)

Writers

(setf public-id) (generic function)

Slot: internal-subset
Readers

internal-subset (generic function)

Writers

(setf internal-subset) (generic function)

Slot: dtd
Readers

dtd (generic function)

Writers

(setf dtd) (generic function)

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

Direct superclasses
Direct methods
Direct slots
Slot: attributes
Readers

%attributes (generic function)

Writers

(setf %attributes) (generic function)

Slot: namespaces
Readers

%namespaces (generic function)

Writers

(setf %namespaces) (generic function)

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

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • processing-instruction-target-using-navigator (method)
  • unparsed-entity-uri-using-navigator (method)
  • get-element-by-id-using-navigator (method)
  • node-type-p-using-navigator (method)
  • node-p-using-navigator (method)
  • node-text-using-navigator (method)
  • namespace-pipe-using-navigator (method)
  • attribute-pipe-using-navigator (method)
  • child-pipe-using-navigator (method)
  • base-uri-using-navigator (method)
  • qualified-name-using-navigator (method)
  • namespace-uri-using-navigator (method)
  • parent-node-using-navigator (method)
  • namespace-prefix-using-navigator (method)
  • local-name-using-navigator (method)
  • check-deletion-allowed (method)
  • check-deletion-allowed (method)
  • insert-child (method)
  • %base-uri (method)
  • %base-uri (method)
  • print-object (method)
  • detach (method)
  • (setf %parent) (method)
  • parent (method)
Direct slots
Slot: parent
Readers

parent (generic function)

Writers

(setf %parent) (generic function)

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

Direct superclasses

node (class)

Direct subclasses
Direct methods
Direct slots
Slot: %base-uri
Slot: %children
Readers

%children (generic function)

Writers

(setf %children) (generic function)

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

Direct superclasses

leaf-node (class)

Direct methods
  • processing-instruction-target-using-navigator (method)
  • namespace-uri-using-navigator (method)
  • qualified-name-using-navigator (method)
  • local-name-using-navigator (method)
  • namespace-prefix-using-navigator (method)
  • node-type-p-using-navigator (method)
  • reconstruct (method)
  • slots-for-print-object (method)
  • serialize (method)
  • (setf data) (method)
  • (setf target) (method)
  • string-value (method)
  • copy (method)
  • data (method)
  • data (method)
  • target (method)
  • target (method)
Direct slots
Slot: target
Initargs

:target

Readers

target (generic function)

Writers

(setf target) (generic function)

Slot: data
Initargs

:data

Readers

data (generic function)

Writers

(setf data) (generic function)

Class: text ()

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

Package

cxml-stp

Source

classes.lisp (file)

Direct superclasses

leaf-node (class)

Direct methods
Direct slots
Slot: data
Initargs

:data

Readers

data (generic function)

Writers

(setf data) (generic function)


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

5.2 Internal definitions


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

5.2.1 Special variables

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

cxml-stp-impl

Source

document-type.lisp (file)


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

5.2.2 Macros

Macro: defreader NAME (&rest ARGS) &body BODY
Package

cxml-stp-impl

Source

node.lisp (file)


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

5.2.3 Functions

Function: %add-attribute ATTRIBUTE ELEMENT
Package

cxml-stp-impl

Source

element.lisp (file)

Function: %nuke-nth-child PARENT I
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Function: %remove-attribute ATTRIBUTE
Package

cxml-stp-impl

Source

element.lisp (file)

Function: %unchecked-insert-child PARENT CHILD I
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Function: assert-orphan NODE
Package

cxml-stp-impl

Source

document.lisp (file)

Function: attributes-for-print ELT
Package

cxml-stp-impl

Source

element.lisp (file)

Function: builder-append BUILDER X
Package

cxml-stp-impl

Source

builder.lisp (file)

Function: check-namespace-uri URI
Package

cxml-stp-impl

Source

node.lisp (file)

Function: check-nc-name STR
Package

cxml-stp-impl

Source

element.lisp (file)

Function: check-uri-like NEWVAL
Package

cxml-stp-impl

Source

element.lisp (file)

Function: check-xml-name STR
Package

cxml-stp-impl

Source

document-type.lisp (file)

Function: childp A B
Package

cxml-stp-impl

Source

element.lisp (file)

Function: collect-local-namespaces ELEMENT
Package

cxml-stp-impl

Source

element.lisp (file)

Function: copy-attributes NEW OLD
Package

cxml-stp-impl

Source

element.lisp (file)

Function: copy-stp-namespace INSTANCE
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: document &rest KEYS

@unexport{}

Package

cxml-stp-impl

Source

document.lisp (file)

Function: document-type &rest KEYS

@unexport{}

Package

cxml-stp-impl

Source

document-type.lisp (file)

Function: escape-uri STRING
Package

cxml-stp-impl

Source

element.lisp (file)

Function: fill-in-base-uri REMOVED-CHILD
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Function: find-attribute-namespace PREFIX ELEMENT
Package

cxml-stp-impl

Source

element.lisp (file)

Function: find-base-uri NODE
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Function: make-stp-namespace PARENT PREFIX URI
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: maybe-fill-in-base-uri REMOVED-CHILD
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Function: maybe-uri->string THING
Package

cxml-stp-impl

Source

node.lisp (file)

Function: named-node-mixin &rest KEYS

@unexport{}

Package

cxml-stp-impl

Source

element.lisp (file)

Function: namep STR
Package

cxml-stp-impl

Source

document-type.lisp (file)

Function: namespaces-for-print ELEMENT
Package

cxml-stp-impl

Source

element.lisp (file)

Function: nc-name-p STR
Package

cxml-stp-impl

Source

element.lisp (file)

Function: non-empty-string X
Package

cxml-stp-impl

Source

element.lisp (file)

Function: normalize-text-nodes! NODE
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: pretty-print-node NODE STREAM
Package

cxml-stp-impl

Source

node.lisp (file)

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

Function: run-xpath-tests ()
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: sanitize-attribute-name ELEMENT NAME URI URIP
Package

cxml-stp-impl

Source

element.lisp (file)

Function: stp-namespace-p OBJECT
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: stp-namespace-parent INSTANCE
Function: (setf stp-namespace-parent) VALUE INSTANCE
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: stp-namespace-prefix INSTANCE
Function: (setf stp-namespace-prefix) VALUE INSTANCE
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: stp-namespace-uri INSTANCE
Function: (setf stp-namespace-uri) VALUE INSTANCE
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: ugly-print-node NODE STREAM
Package

cxml-stp-impl

Source

node.lisp (file)

Function: vector->pipe VECTOR &optional START
Package

cxml-stp-impl

Source

xpath.lisp (file)

Function: xml-characters-p STR
Package

cxml-stp-impl

Source

attribute.lisp (file)

Function: xor A B
Package

cxml-stp-impl

Source

attribute.lisp (file)


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

5.2.4 Generic functions

Generic Function: %attributes OBJECT
Generic Function: (setf %attributes) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: %attributes (ELEMENT element)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %attributes) NEW-VALUE (ELEMENT element)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: %base-uri NODE
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Writer

(setf %base-uri) (generic function)

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

cxml-stp-impl

Reader

%base-uri (generic function)

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

parent-node.lisp (file)

Generic Function: %children OBJECT
Generic Function: (setf %children) NEW-VALUE OBJECT
Package

cxml-stp-impl

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

leaf-node.lisp (file)

Method: %children (PARENT-NODE parent-node)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %children) NEW-VALUE (PARENT-NODE parent-node)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: %local-name OBJECT
Generic Function: (setf %local-name) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: %local-name (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %local-name) NEW-VALUE (NAMED-NODE-MIXIN named-node-mixin)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: %namespace-prefix OBJECT
Generic Function: (setf %namespace-prefix) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: %namespace-prefix (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %namespace-prefix) NEW-VALUE (NAMED-NODE-MIXIN named-node-mixin)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: %namespace-uri OBJECT
Generic Function: (setf %namespace-uri) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: %namespace-uri (NAMED-NODE-MIXIN named-node-mixin)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %namespace-uri) NEW-VALUE (NAMED-NODE-MIXIN named-node-mixin)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: %namespaces OBJECT
Generic Function: (setf %namespaces) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: %namespaces (ELEMENT element)

automatically generated reader method

Source

classes.lisp (file)

Method: (setf %namespaces) NEW-VALUE (ELEMENT element)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: (setf %parent) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: (setf %parent) NEW-VALUE (NODE node)

automatically generated writer method

Source

classes.lisp (file)

Generic Function: builder-doctype OBJECT
Generic Function: (setf builder-doctype) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: builder-doctype (BUILDER builder)

automatically generated reader method

Source

builder.lisp (file)

Method: (setf builder-doctype) NEW-VALUE (BUILDER builder)

automatically generated writer method

Source

builder.lisp (file)

Generic Function: builder-internal-subset-sink OBJECT
Generic Function: (setf builder-internal-subset-sink) NEW-VALUE OBJECT
Package

cxml-stp-impl

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

automatically generated reader method

Source

builder.lisp (file)

Method: (setf builder-internal-subset-sink) NEW-VALUE (BUILDER builder)

automatically generated writer method

Source

builder.lisp (file)

Generic Function: builder-nodes OBJECT
Generic Function: (setf builder-nodes) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: builder-nodes (BUILDER builder)

automatically generated reader method

Source

builder.lisp (file)

Method: (setf builder-nodes) NEW-VALUE (BUILDER builder)

automatically generated writer method

Source

builder.lisp (file)

Generic Function: check-deletion-allowed PARENT CHILD POSITION
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Methods
Method: check-deletion-allowed (PARENT element) (CHILD node) I
Source

element.lisp (file)

Method: check-deletion-allowed (PARENT document) (CHILD element) I
Source

document.lisp (file)

Method: check-deletion-allowed (PARENT document) (CHILD node) I
Source

document.lisp (file)

Generic Function: check-insertion-allowed PARENT CHILD POSITION
Package

cxml-stp-impl

Source

parent-node.lisp (file)

Methods
Method: check-insertion-allowed (PARENT element) CHILD I
Source

element.lisp (file)

Method: check-insertion-allowed (PARENT document) CHILD I
Source

document.lisp (file)

Generic Function: collected-notations OBJECT
Generic Function: (setf collected-notations) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: collected-notations (NOTATION-COLLECTOR notation-collector)

automatically generated reader method

Source

document-type.lisp (file)

Method: (setf collected-notations) NEW-VALUE (NOTATION-COLLECTOR notation-collector)

automatically generated writer method

Source

document-type.lisp (file)

Generic Function: namespace-declarations OBJECT
Generic Function: (setf namespace-declarations) NEW-VALUE OBJECT
Package

cxml-stp-impl

Methods
Method: namespace-declarations (BUILDER builder)

automatically generated reader method

Source

builder.lisp (file)

Method: (setf namespace-declarations) NEW-VALUE (BUILDER builder)

automatically generated writer method

Source

builder.lisp (file)

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

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: reconstruct (THIS text) &key DATA &allow-other-keys progn
Source

text.lisp (file)

Method: reconstruct (THIS processing-instruction) &key DATA TARGET &allow-other-keys progn
Source

processing-instruction.lisp (file)

Method: reconstruct (THIS comment) &key DATA &allow-other-keys progn
Source

comment.lisp (file)

Method: reconstruct (THIS document-type) &key ROOT-ELEMENT-NAME SYSTEM-ID PUBLIC-ID INTERNAL-SUBSET &allow-other-keys progn
Source

document-type.lisp (file)

Method: reconstruct (THIS attribute) &key VALUE &allow-other-keys progn
Source

attribute.lisp (file)

Method: reconstruct (THIS element) &key ATTRIBUTES EXTRA-NAMESPACES &allow-other-keys progn
Source

element.lisp (file)

Method: reconstruct (THIS named-node-mixin) &key LOCAL-NAME NAMESPACE-PREFIX NAMESPACE-URI &allow-other-keys progn
Source

element.lisp (file)

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

document.lisp (file)

Method: reconstruct (THIS parent-node) &key BASE-URI CHILDREN &allow-other-keys progn
Source

parent-node.lisp (file)

Generic Function: slots-for-print-object NODE
Package

cxml-stp-impl

Source

node.lisp (file)

Method Combination

append (short method combination)

Options: :most-specific-first

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

text.lisp (file)

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

processing-instruction.lisp (file)

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

comment.lisp (file)

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

document-type.lisp (file)

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

attribute.lisp (file)

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

element.lisp (file)

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

element.lisp (file)

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

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

5.2.5 Structures

Structure: stp-namespace ()
Package

cxml-stp-impl

Source

xpath.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
  • node-type-p-using-navigator (method)
  • node-type-p-using-navigator (method)
  • node-text-using-navigator (method)
  • namespace-uri-using-navigator (method)
  • qualified-name-using-navigator (method)
  • local-name-using-navigator (method)
  • parent-node-using-navigator (method)
  • namespace-pipe-using-navigator (method)
  • attribute-pipe-using-navigator (method)
  • child-pipe-using-navigator (method)
  • node-p-using-navigator (method)
  • base-uri-using-navigator (method)
  • hash-key-using-navigator (method)
  • node-equal-using-navigator (method)
Direct slots
Slot: parent
Readers

stp-namespace-parent (function)

Writers

(setf stp-namespace-parent) (function)

Slot: prefix
Readers

stp-namespace-prefix (function)

Writers

(setf stp-namespace-prefix) (function)

Slot: uri
Readers

stp-namespace-uri (function)

Writers

(setf stp-namespace-uri) (function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Classes

Class: builder ()
Package

cxml-stp-impl

Source

builder.lisp (file)

Direct superclasses

content-handler (class)

Direct methods
  • end-document (method)
  • comment (method)
  • processing-instruction (method)
  • characters (method)
  • end-element (method)
  • start-element (method)
  • start-prefix-mapping (method)
  • dtd (method)
  • end-internal-subset (method)
  • attribute-declaration (method)
  • element-declaration (method)
  • notation-declaration (method)
  • internal-entity-declaration (method)
  • external-entity-declaration (method)
  • unparsed-entity-declaration (method)
  • start-internal-subset (method)
  • start-dtd (method)
  • start-document (method)
  • builder-internal-subset-sink (method)
  • builder-internal-subset-sink (method)
  • namespace-declarations (method)
  • namespace-declarations (method)
  • builder-doctype (method)
  • builder-doctype (method)
  • builder-nodes (method)
  • builder-nodes (method)
Direct slots
Slot: nodes
Readers

builder-nodes (generic function)

Writers

(setf builder-nodes) (generic function)

Slot: doctype
Readers

builder-doctype (generic function)

Writers

(setf builder-doctype) (generic function)

Slot: namespace-declarations
Readers

namespace-declarations (generic function)

Writers

(setf namespace-declarations) (generic function)

Slot: internal-subset-sink
Readers

builder-internal-subset-sink (generic function)

Writers

(setf builder-internal-subset-sink) (generic function)

Class: closure-source-file ()
Package

cxml-stp-system

Source

cxml-stp.asd

Direct superclasses

cl-source-file (class)

Direct methods

perform (method)

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

Direct superclasses

parent-node (class)

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

Direct superclasses

leaf-node (class)

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

root-element-name (generic function)

Writers

(setf root-element-name) (generic function)

Slot: system-id
Readers

system-id (generic function)

Writers

(setf system-id) (generic function)

Slot: public-id
Readers

public-id (generic function)

Writers

(setf public-id) (generic function)

Slot: internal-subset
Readers

internal-subset (generic function)

Writers

(setf internal-subset) (generic function)

Slot: dtd
Readers

dtd (generic function)

Writers

(setf dtd) (generic function)

Class: leaf-node ()
Package

cxml-stp-impl

Source

classes.lisp (file)

Direct superclasses

node (class)

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

cxml-stp-impl

Source

classes.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: local-name
Readers
Writers

(setf %local-name) (generic function)

Slot: prefix
Readers
Writers

(setf %namespace-prefix) (generic function)

Slot: namespace-uri
Readers
Writers

(setf %namespace-uri) (generic function)

Class: notation-collector ()
Package

cxml-stp-impl

Source

document-type.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • end-document (method)
  • notation-declaration (method)
  • collected-notations (method)
  • collected-notations (method)
Direct slots
Slot: collected-notations
Readers

collected-notations (generic function)

Writers

(setf collected-notations) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cxml-stp.asd: The cxml-stp<dot>asd file
cxml-stp/attribute.lisp: The cxml-stp/attribute<dot>lisp file
cxml-stp/builder.lisp: The cxml-stp/builder<dot>lisp file
cxml-stp/classes.lisp: The cxml-stp/classes<dot>lisp file
cxml-stp/comment.lisp: The cxml-stp/comment<dot>lisp file
cxml-stp/document-type.lisp: The cxml-stp/document-type<dot>lisp file
cxml-stp/document.lisp: The cxml-stp/document<dot>lisp file
cxml-stp/element.lisp: The cxml-stp/element<dot>lisp file
cxml-stp/leaf-node.lisp: The cxml-stp/leaf-node<dot>lisp file
cxml-stp/node.lisp: The cxml-stp/node<dot>lisp file
cxml-stp/package.lisp: The cxml-stp/package<dot>lisp file
cxml-stp/parent-node.lisp: The cxml-stp/parent-node<dot>lisp file
cxml-stp/processing-instruction.lisp: The cxml-stp/processing-instruction<dot>lisp file
cxml-stp/text.lisp: The cxml-stp/text<dot>lisp file
cxml-stp/xpath.lisp: The cxml-stp/xpath<dot>lisp file

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

L
Lisp File, cxml-stp.asd: The cxml-stp<dot>asd file
Lisp File, cxml-stp/attribute.lisp: The cxml-stp/attribute<dot>lisp file
Lisp File, cxml-stp/builder.lisp: The cxml-stp/builder<dot>lisp file
Lisp File, cxml-stp/classes.lisp: The cxml-stp/classes<dot>lisp file
Lisp File, cxml-stp/comment.lisp: The cxml-stp/comment<dot>lisp file
Lisp File, cxml-stp/document-type.lisp: The cxml-stp/document-type<dot>lisp file
Lisp File, cxml-stp/document.lisp: The cxml-stp/document<dot>lisp file
Lisp File, cxml-stp/element.lisp: The cxml-stp/element<dot>lisp file
Lisp File, cxml-stp/leaf-node.lisp: The cxml-stp/leaf-node<dot>lisp file
Lisp File, cxml-stp/node.lisp: The cxml-stp/node<dot>lisp file
Lisp File, cxml-stp/package.lisp: The cxml-stp/package<dot>lisp file
Lisp File, cxml-stp/parent-node.lisp: The cxml-stp/parent-node<dot>lisp file
Lisp File, cxml-stp/processing-instruction.lisp: The cxml-stp/processing-instruction<dot>lisp file
Lisp File, cxml-stp/text.lisp: The cxml-stp/text<dot>lisp file
Lisp File, cxml-stp/xpath.lisp: The cxml-stp/xpath<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

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

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

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

A
add-attribute: Exported functions
add-extra-namespace: Exported functions
append-child: Exported functions
assert-orphan: Internal functions
attribute: Exported functions
attribute-value: Exported functions
attributes-for-print: Internal functions

B
base-uri: Exported generic functions
base-uri: Exported generic functions
base-uri: Exported generic functions
builder-append: Internal functions
builder-doctype: Internal generic functions
builder-doctype: Internal generic functions
builder-internal-subset-sink: Internal generic functions
builder-internal-subset-sink: Internal generic functions
builder-nodes: Internal generic functions
builder-nodes: Internal generic functions

C
check-deletion-allowed: Internal generic functions
check-deletion-allowed: Internal generic functions
check-deletion-allowed: Internal generic functions
check-deletion-allowed: Internal generic functions
check-insertion-allowed: Internal generic functions
check-insertion-allowed: Internal generic functions
check-insertion-allowed: Internal generic functions
check-namespace-uri: Internal functions
check-nc-name: Internal functions
check-uri-like: Internal functions
check-xml-name: Internal functions
child-position: Exported functions
child-position-if: Exported functions
childp: Internal functions
collect-local-namespaces: Internal functions
collected-notations: Internal generic functions
collected-notations: Internal generic functions
comment: Exported functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy-attributes: Internal functions
copy-stp-namespace: Internal functions
count-children: Exported functions
count-children-if: Exported functions

D
data: Exported generic functions
data: Exported generic functions
data: Exported generic functions
data: Exported generic functions
defreader: Internal macros
delete-child: Exported functions
delete-child-if: Exported generic functions
delete-child-if: Exported generic functions
delete-children: Exported functions
delete-nth-child: Exported functions
detach: Exported generic functions
detach: Exported generic functions
detach: Exported generic functions
do-children: Exported macros
do-recursively: Exported macros
document: Exported functions
document: Internal functions
document-element: Exported functions
document-type: Exported functions
document-type: Internal functions
dtd: Exported generic functions
dtd: Exported generic functions

E
element: Exported functions
escape-uri: Internal functions

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

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

I
insert-child: Exported generic functions
insert-child: Exported generic functions
insert-child-after: Exported functions
insert-child-before: Exported functions
internal-subset: Exported generic functions
internal-subset: Exported generic functions

L
last-child: Exported functions
list-attributes: Exported functions
list-children: Exported functions
local-name: Exported generic functions
local-name: Exported generic functions

M
Macro, defreader: Internal macros
Macro, do-children: Exported macros
Macro, do-recursively: Exported macros
Macro, with-attributes: Exported macros
make-attribute: Exported functions
make-builder: Exported functions
make-comment: Exported functions
make-document: Exported functions
make-document-type: Exported functions
make-element: Exported functions
make-processing-instruction: Exported functions
make-stp-namespace: Internal functions
make-text: Exported functions
map-attributes: Exported functions
map-children: Exported generic functions
map-children: Exported generic functions
map-children: Exported generic functions
map-extra-namespaces: Exported functions
map-recursively: Exported functions
maybe-fill-in-base-uri: Internal functions
maybe-uri->string: Internal functions
Method, %attributes: Internal generic functions
Method, %base-uri: Internal generic functions
Method, %children: Internal generic functions
Method, %children: Internal generic functions
Method, %local-name: Internal generic functions
Method, %namespace-prefix: Internal generic functions
Method, %namespace-uri: Internal generic functions
Method, %namespaces: Internal generic functions
Method, (setf %attributes): Internal generic functions
Method, (setf %base-uri): Internal generic functions
Method, (setf %children): Internal generic functions
Method, (setf %local-name): Internal generic functions
Method, (setf %namespace-prefix): Internal generic functions
Method, (setf %namespace-uri): Internal generic functions
Method, (setf %namespaces): Internal generic functions
Method, (setf %parent): Internal generic functions
Method, (setf base-uri): Exported generic functions
Method, (setf base-uri): Exported generic functions
Method, (setf builder-doctype): Internal generic functions
Method, (setf builder-internal-subset-sink): Internal generic functions
Method, (setf builder-nodes): Internal generic functions
Method, (setf collected-notations): Internal generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf dtd): Exported generic functions
Method, (setf dtd): Exported generic functions
Method, (setf internal-subset): Exported generic functions
Method, (setf internal-subset): Exported generic functions
Method, (setf local-name): Exported generic functions
Method, (setf local-name): Exported generic functions
Method, (setf namespace-declarations): Internal generic functions
Method, (setf public-id): Exported generic functions
Method, (setf public-id): Exported generic functions
Method, (setf root-element-name): Exported generic functions
Method, (setf root-element-name): Exported generic functions
Method, (setf system-id): Exported generic functions
Method, (setf system-id): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf value): Exported generic functions
Method, base-uri: Exported generic functions
Method, base-uri: Exported generic functions
Method, builder-doctype: Internal generic functions
Method, builder-internal-subset-sink: Internal generic functions
Method, builder-nodes: Internal generic functions
Method, check-deletion-allowed: Internal generic functions
Method, check-deletion-allowed: Internal generic functions
Method, check-deletion-allowed: Internal generic functions
Method, check-insertion-allowed: Internal generic functions
Method, check-insertion-allowed: Internal generic functions
Method, collected-notations: Internal generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, data: Exported generic functions
Method, data: Exported generic functions
Method, data: Exported generic functions
Method, delete-child-if: Exported generic functions
Method, detach: Exported generic functions
Method, detach: Exported generic functions
Method, dtd: Exported generic functions
Method, insert-child: Exported generic functions
Method, internal-subset: Exported generic functions
Method, local-name: Exported generic functions
Method, map-children: Exported generic functions
Method, map-children: Exported generic functions
Method, namespace-declarations: Internal generic functions
Method, namespace-prefix: Exported generic functions
Method, namespace-uri: Exported generic functions
Method, parent: Exported generic functions
Method, public-id: Exported generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, reconstruct: Internal generic functions
Method, replace-child: Exported generic functions
Method, replace-child: Exported generic functions
Method, root-element-name: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, serialize: Exported generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, slots-for-print-object: Internal generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, string-value: Exported generic functions
Method, system-id: Exported generic functions
Method, target: Exported generic functions
Method, value: Exported generic functions

N
named-node-mixin: Internal functions
namep: Internal functions
namespace-declarations: Internal generic functions
namespace-declarations: Internal generic functions
namespace-prefix: Exported generic functions
namespace-prefix: Exported generic functions
namespace-uri: Exported generic functions
namespace-uri: Exported generic functions
namespaces-for-print: Internal functions
nc-name-p: Internal functions
next-sibling: Exported functions
non-empty-string: Internal functions
normalize-text-nodes!: Internal functions
nth-child: Exported functions
number-of-children: Exported functions

O
of-name: Exported functions

P
parent: Exported generic functions
parent: Exported generic functions
parent-node: Exported functions
prepend-child: Exported functions
pretty-print-node: Internal functions
previous-sibling: Exported functions
processing-instruction: Exported functions
public-id: Exported generic functions
public-id: Exported generic functions

Q
qualified-name: Exported functions
qualified-of-name: Internal functions

R
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
reconstruct: Internal generic functions
remove-attribute: Exported functions
remove-extra-namespace: Exported functions
rename-attribute: Exported functions
replace-child: Exported generic functions
replace-child: Exported generic functions
replace-child: Exported generic functions
root: Exported functions
root-element-name: Exported generic functions
root-element-name: Exported generic functions
run-xpath-tests: Internal functions

S
sanitize-attribute-name: Internal functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
serialize: Exported generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
slots-for-print-object: Internal generic functions
stp-error: Exported functions
stp-namespace-p: Internal functions
stp-namespace-parent: Internal functions
stp-namespace-prefix: Internal functions
stp-namespace-uri: Internal functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
string-value: Exported generic functions
system-id: Exported generic functions
system-id: Exported generic functions

T
target: Exported generic functions
target: Exported generic functions
text: Exported functions

U
ugly-print-node: Internal functions

V
value: Exported generic functions
value: Exported generic functions
vector->pipe: Internal functions

W
with-attributes: Exported macros

X
xml-characters-p: Internal functions
xor: Internal functions

Jump to:   %   (  
A   B   C   D   E   F   G   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: Exported classes
%children: Exported classes

*
*check-uri-syntax*: Exported special variables
*serialize-canonical-notations-only-p*: Internal special variables

A
attributes: Exported classes

C
collected-notations: Internal classes

D
data: Exported classes
data: Exported classes
data: Exported classes
doctype: Internal classes
dtd: Exported classes
dtd: Internal classes

I
internal-subset: Exported classes
internal-subset: Internal classes
internal-subset-sink: Internal classes

L
local-name: Internal classes

N
namespace-declarations: Internal classes
namespace-uri: Internal classes
namespaces: Exported classes
nodes: Internal classes

P
parent: Exported classes
parent: Internal structures
prefix: Internal structures
prefix: Internal classes
public-id: Exported classes
public-id: Internal classes

R
root-element-name: Exported classes
root-element-name: Internal classes

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

T
target: Exported classes

U
uri: Internal structures

V
value: Exported 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   L   N   P   S   T  
Index Entry  Section

A
attribute: Exported classes

B
builder: Internal classes

C
Class, attribute: Exported classes
Class, builder: Internal classes
Class, closure-source-file: Internal classes
Class, comment: Exported classes
Class, document: Exported classes
Class, document: Internal classes
Class, document-type: Exported classes
Class, document-type: Internal classes
Class, element: Exported classes
Class, leaf-node: Internal classes
Class, named-node-mixin: Internal classes
Class, node: Exported classes
Class, notation-collector: Internal classes
Class, parent-node: Exported classes
Class, processing-instruction: Exported classes
Class, text: Exported classes
closure-source-file: Internal classes
comment: Exported classes
Condition, stp-error: Exported 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

D
document: Exported classes
document: Internal classes
document-type: Exported classes
document-type: Internal classes

E
element: Exported classes

L
leaf-node: Internal classes

N
named-node-mixin: Internal classes
node: Exported classes
notation-collector: Internal 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
parent-node: Exported classes
processing-instruction: Exported classes

S
stp-error: Exported conditions
stp-namespace: Internal structures
Structure, stp-namespace: Internal structures
System, cxml-stp: The cxml-stp system

T
text: Exported classes

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