The xpath Reference Manual

Table of Contents

The xpath Reference Manual

This is the xpath Reference Manual, version 0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Feb 19 21:20:16 2020 GMT+0.

1 Systems

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

1.1 xpath

Maintainer

Sharp Lispers <sharplispers@googlegroups.com>

Authors

Ivan Shvedunov
David Lichteblau

License

2 clause BSD

Description

An implementation of the XML Path Language (XPath) Version 1.0

Version

0.1

Dependencies

• cxml
• parse-number
• cl-ppcre
• yacc

Source

xpath.asd (file)

Components

• package.lisp (file)
• utils.lisp (file)
• pipes.lisp (file)
• protocol.lisp (file)
• xnum-ieee.lisp (file)
• types.lisp (file)
• extensions.lisp (file)
• environment.lisp (file)
• axes.lisp (file)
• node-tests.lisp (file)
• xpath.lisp (file)
• functions.lisp (file)
• lexer.lisp (file)
• parser.lisp (file)
• api.lisp (file)
• plx.lisp (file)
• xmls-compat.lisp (file)
• patterns.lisp (file)
• profile.lisp (file)

2 Files

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

2.1 Lisp

2.1.1 xpath.asd

Location

xpath.asd

Systems

xpath (system)

2.1.2 xpath/package.lisp

Parent

xpath (system)

Location

package.lisp

Packages

• xpath
• xpattern
• xpath-utils
• xpath-sys
• xpath-protocol

2.1.3 xpath/utils.lisp

Dependency

package.lisp (file)

Parent

xpath (system)

Location

utils.lisp

Exported Definitions

• concat (function)
• hypsym (function)
• maybe-progn (function)
• mklist (function)
• once-only (macro)
• proper-list-p (function)
• string-replace (function)
• trim (function)
• with-cache (macro)
• with-gensyms (macro)

2.1.4 xpath/pipes.lisp

Dependency

utils.lisp (file)

Parent

xpath (system)

Location

pipes.lisp

Internal Definitions

• %append-pipes (function)
• append-pipes (macro)
• empty-pipe (constant)
• enumerate (function)
• filter-pipe (function)
• find-in-pipe (function)
• find-in-pipe-if (function)
• force (function)
• make-pipe (macro)
• map-pipe (function)
• map-pipe-filtering (function)
• mappend-pipe (function)
• mappend-pipe-filtering (function)
• pipe-elt (function)
• pipe-empty-p (function)
• pipe-head (function)
• pipe-length (function)
• pipe-tail (function)
• subpipe-after (function)
• subpipe-before (function)

2.1.5 xpath/protocol.lisp

Dependency

pipes.lisp (file)

Parent

xpath (system)

Location

protocol.lisp

Exported Definitions

• *navigator* (special variable)
• attribute-pipe (function)
• attribute-pipe-using-navigator (generic function)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• base-uri (function)
• base-uri-using-navigator (generic function)
• base-uri-using-navigator (method)
• child-pipe (function)
• child-pipe-using-navigator (generic function)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• define-default-method (macro)
• get-element-by-id (function)
• get-element-by-id-using-navigator (generic function)
• get-element-by-id-using-navigator (method)
• hash-key (function)
• hash-key-using-navigator (generic function)
• hash-key-using-navigator (method)
• hash-key-using-navigator (method)
• local-name (function)
• local-name-using-navigator (generic function)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• namespace-pipe (function)
• namespace-pipe-using-navigator (generic function)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-prefix (function)
• namespace-prefix-using-navigator (generic function)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-uri (function)
• namespace-uri-using-navigator (generic function)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• node-equal (function)
• node-equal-using-navigator (generic function)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-p (function)
• node-p-using-navigator (generic function)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-text (function)
• node-text-using-navigator (generic function)
• node-text-using-navigator (method)
• node-text-using-navigator (method)
• node-type-p (function)
• node-type-p-using-navigator (generic function)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• parent-node (function)
• parent-node-using-navigator (generic function)
• parent-node-using-navigator (method)
• parent-node-using-navigator (method)
• parent-node-using-navigator (method)
• processing-instruction-target (function)
• processing-instruction-target-using-navigator (generic function)
• processing-instruction-target-using-navigator (method)
• qualified-name (function)
• qualified-name-using-navigator (generic function)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• unparsed-entity-uri (function)
• unparsed-entity-uri-using-navigator (generic function)
• unparsed-entity-uri-using-navigator (method)

Internal Definitions

• copy-dom-namespace (function)
• dom-namespace (structure)
• dom-namespace-p (function)
• dom-namespace-parent (function)
• (setf dom-namespace-parent) (function)
• dom-namespace-prefix (function)
• (setf dom-namespace-prefix) (function)
• dom-namespace-uri (function)
• (setf dom-namespace-uri) (function)
• make-dom-namespace (function)
• parent-pipe (function)
• vector->pipe (function)

2.1.6 xpath/xnum-ieee.lisp

Dependency

protocol.lisp (file)

Parent

xpath (system)

Location

xnum-ieee.lisp

Internal Definitions

• +nan+ (special variable)
• compare-numbers (function)
• finite-p (function)
• fmod (function)
• inf-p (function)
• long-to-double (function)
• nan-p (function)
• parse-xnum (function)
• preprocess-number-str (function)
• round-to-integer (function)
• with-float-traps-masked (macro)
• x-minusp (function)
• x-plusp (function)
• x-zerop (function)
• xnum (type)
• xnum-* (function)
• xnum-+ (function)
• xnum-- (function)
• xnum-/ (function)
• xnum->string (function)
• xnum-ceiling (function)
• xnum-floor (function)
• xnum-mod (function)
• xnum-p (function)
• xnum-round (function)

2.1.7 xpath/types.lisp

Dependency

xnum-ieee.lisp (file)

Parent

xpath (system)

Location

types.lisp

Exported Definitions

• boolean-value (function)
• context (class)
• context-node (function)
• (setf context-node) (function)
• context-position (function)
• (setf context-position) (function)
• context-size (function)
• (setf context-size) (function)
• context-starting-node (function)
• (setf context-starting-node) (function)
• make-context (function)
• node-set (class)
• node-set-empty-p (function)
• node-set-p (function)
• node-set-value (function)
• number-value (function)
• sort-node-set (function)
• string-value (function)

Internal Definitions

• compare-node-sets (function)
• compare-values (function)
• compare-with-node-set (function)
• compare/no-node-sets (function)
• get-node-id (function)
• get-node-index (function)
• get-node-text (function)
• make-node-set (function)
• node< (function)
• ordering-of (method)
• (setf ordering-of) (method)
• pipe-of (function)
• (setf pipe-of) (function)
• sort-nodes (function)
• sort-pipe (function)
• sorted-pipe-of (function)
• textually-first-node (function)

2.1.8 xpath/extensions.lisp

Dependency

types.lisp (file)

Parent

xpath (system)

Location

extensions.lisp

Internal Definitions

• %define-extension (function)
• %define-xpath-function/eager (macro)
• *extensions* (special variable)
• add-xpath-function (function)
• arg-count (function)
• compile-xpath-function-call (function)
• copy-extension (function)
• copy-xpath-function (function)
• define-extension (macro)
• define-xpath-function/eager (macro)
• define-xpath-function/lazy (macro)
• define-xpath-function/single-type (macro)
• extension (structure)
• extension-documentation (function)
• (setf extension-documentation) (function)
• extension-functions (function)
• (setf extension-functions) (function)
• extension-p (function)
• extension-uri (function)
• (setf extension-uri) (function)
• find-xpath-function (function)
• make-extension (function)
• make-xpath-function (function)
• xpath-function (structure)
• xpath-function-compiler (function)
• (setf xpath-function-compiler) (function)
• xpath-function-max-args (function)
• (setf xpath-function-max-args) (function)
• xpath-function-min-args (function)
• (setf xpath-function-min-args) (function)
• xpath-function-name (function)
• (setf xpath-function-name) (function)
• xpath-function-p (function)

2.1.9 xpath/environment.lisp

Dependency

extensions.lisp (file)

Parent

xpath (system)

Location

environment.lisp

Exported Definitions

• with-namespaces (macro)
• with-variables (macro)

Internal Definitions

• %namespace-binding-pair (function)
• %variable-binding-pair (function)
• *dynamic-namespaces* (special variable)
• *dynamic-var-bindings* (special variable)
• *initial-namespaces* (special variable)
• copy-dynamic-environment (function)
• copy-environment (function)
• copy-test-environment (function)
• decode-dynamic-qname (function)
• dynamic-environment (structure)
• dynamic-environment-namespaces (function)
• (setf dynamic-environment-namespaces) (function)
• dynamic-environment-p (function)
• environment (structure)
• environment-find-function (generic function)
• environment-find-function (method)
• environment-find-function (method)
• environment-find-namespace (generic function)
• environment-find-namespace (method)
• environment-find-namespace (method)
• environment-find-variable (generic function)
• environment-find-variable (method)
• environment-find-variable (method)
• environment-p (function)
• find-dynamic-namespace (function)
• make-dynamic-environment (function)
• make-environment (function)
• make-test-environment (function)
• test-environment (structure)
• test-environment-p (function)

2.1.10 xpath/axes.lisp

Dependency

environment.lisp (file)

Parent

xpath (system)

Location

axes.lisp

Internal Definitions

• axis-ancestor (function)
• axis-ancestor-or-self (function)
• axis-attribute (function)
• axis-child (function)
• axis-descendant (function)
• axis-descendant-or-self (function)
• axis-following (function)
• axis-following-sibling (function)
• axis-function (function)
• axis-namespace (function)
• axis-parent (function)
• axis-preceding (function)
• axis-preceding-sibling (function)
• axis-principal-node-type (function)
• axis-properties (function)
• axis-reverse-descendant-or-self (function)
• axis-root (function)
• axis-self (function)
• define-axis (macro)

2.1.11 xpath/node-tests.lisp

Dependency

axes.lisp (file)

Parent

xpath (system)

Location

node-tests.lisp

Internal Definitions

• node-test-comment (function)
• node-test-name (function)
• node-test-namespace (function)
• node-test-node (function)
• node-test-principal (function)
• node-test-processing-instruction (function)
• node-test-text-node (function)

2.1.12 xpath/xpath.lisp

Dependency

node-tests.lisp (file)

Parent

xpath (system)

Location

xpath.lisp

Internal Definitions

• compile-filter-path (function)
• compile-location-step (function)
• compile-node-test (function)
• compile-path (function)
• compile-predicates (function)
• compile-variable (function)
• compile-xpath/sexpr (function)
• decode-qname (function)
• find-namespace (function)
• make-location-path (function)
• make-location-step (function)
• xf-location-path (function)
• xf-true (function)
• xf-value (function)

2.1.13 xpath/functions.lisp

Dependency

xpath.lisp (file)

Parent

xpath (system)

Location

functions.lisp

Internal Definitions

• get-lang-attribute (function)
• xf-and (function)
• xf-equal (function)
• xf-or (function)
• xfd-* (function)
• xfd-+ (function)
• xfd-- (function)
• xfd-/ (function)
• xfd-/= (function)
• xfd-< (function)
• xfd-<= (function)
• xfd-= (function)
• xfd-> (function)
• xfd->= (function)
• xfd-and (function)
• xfd-boolean (function)
• xfd-ceiling (function)
• xfd-concat (function)
• xfd-contains (function)
• xfd-count (function)
• xfd-false (function)
• xfd-floor (function)
• xfd-id (function)
• xfd-lang (function)
• xfd-last (function)
• xfd-local-name (function)
• xfd-mod (function)
• xfd-name (function)
• xfd-namespace-uri (function)
• xfd-normalize-space (function)
• xfd-not (function)
• xfd-number (function)
• xfd-or (function)
• xfd-position (function)
• xfd-round (function)
• xfd-starts-with (function)
• xfd-string (function)
• xfd-string-length (function)
• xfd-substring (function)
• xfd-substring-after (function)
• xfd-substring-before (function)
• xfd-sum (function)
• xfd-translate (function)
• xfd-true (function)
• xfd-union (function)

2.1.14 xpath/lexer.lisp

Dependency

functions.lisp (file)

Parent

xpath (system)

Location

lexer.lisp

Internal Definitions

• define-fixup-lexer (macro)
• deflexer (macro)
• make-fixup-lexer (function)
• namep (function)
• nc-name-p (function)
• xpath-lexer (function)

2.1.15 xpath/parser.lisp

Dependency

lexer.lisp (file)

Parent

xpath (system)

Location

parser.lisp

Exported Definitions

parse-xpath (function)

Internal Definitions

• *xpath-parser* (special variable)
• lambda* (macro)
• make-function-name (function)

2.1.16 xpath/api.lisp

Dependency

parser.lisp (file)

Parent

xpath (system)

Location

api.lisp

Exported Definitions

• all-nodes (function)
• compile-xpath (function)
• do-node-set (macro)
• evaluate (compiler macro)
• evaluate (function)
• evaluate-compiled (function)
• first-node (function)
• list->node-set (function)
• make-node-set-iterator (function)
• map-node-set (function)
• map-node-set->list (function)
• node-set-iterator-current (function)
• node-set-iterator-end-p (function)
• node-set-iterator-next (function)
• xpath (macro)
• xpath-error (function)
• xpath-error (condition)

Internal Definitions

• %make-node-set-iterator (function)
• copy-node-set-iterator (function)
• map-node-sets->list (macro)
• namespaces-match-p (function)
• node-set-iterator (structure)
• node-set-iterator-p (function)
• node-set-iterator-pipe (function)
• (setf node-set-iterator-pipe) (function)
• same-expr-p (function)
• xpath-expr (type)

2.1.17 xpath/plx.lisp

Dependency

api.lisp (file)

Parent

xpath (system)

Location

plx.lisp

Exported Definitions

with-plx-extensions (macro)

Internal Definitions

• *plx-uri* (special variable)
• define-regex-function (macro)
• xfd-current (function)
• xfd-generate-id (function)
• xfd-matches (function)
• xfd-replace (function)

2.1.18 xpath/xmls-compat.lisp

Dependency

plx.lisp (file)

Parent

xpath (system)

Location

xmls-compat.lisp

Exported Definitions

• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• base-uri-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• get-element-by-id-using-navigator (method)
• hash-key-using-navigator (method)
• hash-key-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-text-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• parent-node-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• unparsed-entity-uri-using-navigator (method)

2.1.19 xpath/patterns.lisp

Dependency

xmls-compat.lisp (file)

Parent

xpath (system)

Location

patterns.lisp

Exported Definitions

• *allow-variables-in-patterns* (special variable)
• compute-patterns (function)
• make-pattern-matcher (function)
• make-pattern-matcher* (function)
• matching-value (function)
• matching-values (function)
• node-matches-p (compiler macro)
• node-matches-p (function)
• parse-pattern-expression (function)
• pattern (structure)
• pattern-case (macro)
• pattern-ecase (macro)
• pattern-priority (function)
• (setf pattern-priority) (function)
• pattern-value (function)
• (setf pattern-value) (function)

Internal Definitions

• %compile-subpattern (function)
• %make-pattern (function)
• compile-pattern-expression (function)
• compile-pattern-expression/sexpr (function)
• compile-subpattern (function)
• copy-pattern (function)
• make-reverse-location-path (function)
• make-reverse-location-step (function)
• make-reverse-predicate-check (function)
• node-type (function)
• pattern-expr (type)
• pattern-expression (function)
• (setf pattern-expression) (function)
• pattern-key (function)
• (setf pattern-key) (function)
• pattern-p (function)
• pattern-thunk (function)
• (setf pattern-thunk) (function)
• step-key (function)
• subpattern-key (function)
• valid-expression-p (function)

2.1.20 xpath/profile.lisp

Dependency

patterns.lisp (file)

Parent

xpath (system)

Location

profile.lisp

Internal Definitions

• *profiling-enabled-p* (special variable)
• *samples* (special variable)
• disable-profiling (function)
• enable-profiling (function)
• group-and-sort-samples (function)
• maybe-wrap-profiling (function)
• report (function)
• report-xpath (function)
• report-xpattern (function)
• stringify-pattern-expression (function)
• stringify-pattern-expressions (function)
• wrap-profiling (function)
• write-node-test (function)

3 Packages

Packages are listed by definition order.

3.1 xpath

Plexippus XPath is an XPath 1.0 implementation for Common Lisp.

@begin[Using XPath]{section}
Almost all uses of XPath involve the @code{evaluate} function, which can parse, compile, and invoke XPath expressions.

@aboutfun{evaluate}
@aboutmacro{xpath}
@end{section}
@begin[Compiling XPath dynamically]{section}
@code{compile-xpath} allows the compilation of XPath into a closure ahead of time, so that @code{evaluate} only needs to invoke that closure rather than having to re-compile it first.

Although @code{evaluate} itself already performs caching of compiled closures, explicit precompilation can aid optimizations if one
call site uses multiple XPath expressions.

Explicit compilation using @code{compile-xpath} is also required when using custom environment classes, since @code{evaluate} compiles expressions using the dynamic environment only.

@code{parse-xpath} can be used to translate the standard string representation of XPath into a Plexippus-specific sexp representation. Both @code{compile-xpath} and @code{evaluate} accept sexps instead of strings.

@aboutfun{parse-xpath}
@aboutfun{compile-xpath}
@end{section}
@begin[Type coercion]{section}
These correspond to the XPath functions boolean(),
string(), and number(). In addition, @code{node-set-value}
is provided, which turns nodes into node sets.

@aboutfun{boolean-value}
@aboutfun{string-value}
@aboutfun{number-value}
@aboutfun{node-set-value}
@end{section}
@begin[The dynamic environment]{section}
The default enviroment used by @code{evaluate} is the dynamic environment, backed by information bound in dynamic variables.
The following macros are used to bind these variables. They have dynamic scope. (The dynamic environment is currently not capable
of dynamic declarations for variables, but can be used with extension functions that are declared globally.)

(The XPATH-SYS defined an @a[xpath-sys.html]{environment protocol} for user-defined environment classes.)

@aboutmacro{with-namespaces}
@aboutmacro{with-variables}
@end{section}
@begin[The run-time context]{section}
Instead of passing a node to @code{evaluate}, user code can construct a full context object.

The context object specifies values to be returned by position(), current(), and last().

@aboutclass{context}
@aboutfun{make-context}
@aboutfun{context-node}
@aboutfun{context-starting-node}
@aboutfun{context-position}
@aboutfun{context-size}
@end{section}
@begin[Node sets]{section}
Node sets are the XPath data type used to represent the results of evaluations that select multiple nodes. As sets, they never contain duplicates.

In addition to the high-level functions defined here, the XPATH-SYS package defined several @a[xpath-sys.html]{low-level node set functions}. Please also refer to the description there for details on node set order.

@aboutfun{first-node}
@aboutfun{all-nodes}
@aboutfun{map-node-set}
@aboutfun{map-node-set->list}
@aboutmacro{do-node-set}
@aboutfun{make-node-set-iterator} @aboutfun{node-set-iterator-end-p} @aboutfun{node-set-iterator-next} @aboutfun{node-set-iterator-current}
@aboutfun{node-set-p}
@aboutfun{node-set-empty-p}
@aboutfun{node-set}
@aboutfun{list->node-set}
@aboutfun{sort-node-set}
@end{section}
@begin[Miscellaneous]{section}
Other useful functions, variables, and classes:

@aboutmacro{with-plx-extensions}
@aboutvar{*navigator*}
@aboutclass{xpath-error}
@end{section}

Source

package.lisp (file)

Use List

• xpath-utils
• xpattern
• common-lisp

Exported Definitions

• *navigator* (special variable)
• all-nodes (function)
• boolean-value (function)
• compile-xpath (function)
• context (class)
• context-node (function)
• (setf context-node) (function)
• context-position (function)
• (setf context-position) (function)
• context-size (function)
• (setf context-size) (function)
• context-starting-node (function)
• (setf context-starting-node) (function)
• do-node-set (macro)
• evaluate (compiler macro)
• evaluate (function)
• evaluate-compiled (function)
• first-node (function)
• list->node-set (function)
• make-context (function)
• make-node-set-iterator (function)
• map-node-set (function)
• map-node-set->list (function)
• node-set (class)
• node-set-empty-p (function)
• node-set-iterator-current (function)
• node-set-iterator-end-p (function)
• node-set-iterator-next (function)
• node-set-p (function)
• node-set-value (function)
• number-value (function)
• parse-xpath (function)
• sort-node-set (function)
• string-value (function)
• with-namespaces (macro)
• with-plx-extensions (macro)
• with-variables (macro)
• xpath (macro)
• xpath-error (function)
• xpath-error (condition)

Internal Definitions

• %append-pipes (function)
• %compile-subpattern (function)
• %define-extension (function)
• %define-xpath-function/eager (macro)
• %make-node-set-iterator (function)
• %make-pattern (function)
• %namespace-binding-pair (function)
• %variable-binding-pair (function)
• *dynamic-namespaces* (special variable)
• *dynamic-var-bindings* (special variable)
• *extensions* (special variable)
• *initial-namespaces* (special variable)
• *plx-uri* (special variable)
• *profiling-enabled-p* (special variable)
• *samples* (special variable)
• *xpath-parser* (special variable)
• +nan+ (special variable)
• add-xpath-function (function)
• append-pipes (macro)
• arg-count (function)
• axis-ancestor (function)
• axis-ancestor-or-self (function)
• axis-attribute (function)
• axis-child (function)
• axis-descendant (function)
• axis-descendant-or-self (function)
• axis-following (function)
• axis-following-sibling (function)
• axis-function (function)
• axis-namespace (function)
• axis-parent (function)
• axis-preceding (function)
• axis-preceding-sibling (function)
• axis-principal-node-type (function)
• axis-properties (function)
• axis-reverse-descendant-or-self (function)
• axis-root (function)
• axis-self (function)
• compare-node-sets (function)
• compare-numbers (function)
• compare-values (function)
• compare-with-node-set (function)
• compare/no-node-sets (function)
• compile-filter-path (function)
• compile-location-step (function)
• compile-node-test (function)
• compile-path (function)
• compile-pattern-expression (function)
• compile-pattern-expression/sexpr (function)
• compile-predicates (function)
• compile-subpattern (function)
• compile-variable (function)
• compile-xpath-function-call (function)
• compile-xpath/sexpr (function)
• copy-dom-namespace (function)
• copy-dynamic-environment (function)
• copy-environment (function)
• copy-extension (function)
• copy-node-set-iterator (function)
• copy-pattern (function)
• copy-test-environment (function)
• copy-xpath-function (function)
• decode-dynamic-qname (function)
• decode-qname (function)
• define-axis (macro)
• define-extension (macro)
• define-fixup-lexer (macro)
• define-regex-function (macro)
• define-xpath-function/eager (macro)
• define-xpath-function/lazy (macro)
• define-xpath-function/single-type (macro)
• deflexer (macro)
• disable-profiling (function)
• dom-namespace (structure)
• dom-namespace-p (function)
• dom-namespace-parent (function)
• (setf dom-namespace-parent) (function)
• dom-namespace-prefix (function)
• (setf dom-namespace-prefix) (function)
• dom-namespace-uri (function)
• (setf dom-namespace-uri) (function)
• dynamic-environment (structure)
• dynamic-environment-namespaces (function)
• (setf dynamic-environment-namespaces) (function)
• dynamic-environment-p (function)
• empty-pipe (constant)
• enable-profiling (function)
• enumerate (function)
• environment (structure)
• environment-find-function (generic function)
• environment-find-function (method)
• environment-find-function (method)
• environment-find-namespace (generic function)
• environment-find-namespace (method)
• environment-find-namespace (method)
• environment-find-variable (generic function)
• environment-find-variable (method)
• environment-find-variable (method)
• environment-p (function)
• extension (structure)
• extension-documentation (function)
• (setf extension-documentation) (function)
• extension-functions (function)
• (setf extension-functions) (function)
• extension-p (function)
• extension-uri (function)
• (setf extension-uri) (function)
• filter-pipe (function)
• find-dynamic-namespace (function)
• find-in-pipe (function)
• find-in-pipe-if (function)
• find-namespace (function)
• find-xpath-function (function)
• finite-p (function)
• fmod (function)
• force (function)
• get-lang-attribute (function)
• get-node-id (function)
• get-node-index (function)
• get-node-text (function)
• group-and-sort-samples (function)
• inf-p (function)
• lambda* (macro)
• long-to-double (function)
• make-dom-namespace (function)
• make-dynamic-environment (function)
• make-environment (function)
• make-extension (function)
• make-fixup-lexer (function)
• make-function-name (function)
• make-location-path (function)
• make-location-step (function)
• make-node-set (function)
• make-pipe (macro)
• make-reverse-location-path (function)
• make-reverse-location-step (function)
• make-reverse-predicate-check (function)
• make-test-environment (function)
• make-xpath-function (function)
• map-node-sets->list (macro)
• map-pipe (function)
• map-pipe-filtering (function)
• mappend-pipe (function)
• mappend-pipe-filtering (function)
• maybe-wrap-profiling (function)
• namep (function)
• namespaces-match-p (function)
• nan-p (function)
• nc-name-p (function)
• node-set-iterator (structure)
• node-set-iterator-p (function)
• node-set-iterator-pipe (function)
• (setf node-set-iterator-pipe) (function)
• node-test-comment (function)
• node-test-name (function)
• node-test-namespace (function)
• node-test-node (function)
• node-test-principal (function)
• node-test-processing-instruction (function)
• node-test-text-node (function)
• node-type (function)
• node< (function)
• ordering-of (generic function)
• ordering-of (method)
• (setf ordering-of) (method)
• (setf ordering-of) (generic function)
• parent-pipe (function)
• parse-xnum (function)
• pattern-expr (type)
• pattern-expression (function)
• (setf pattern-expression) (function)
• pattern-key (function)
• (setf pattern-key) (function)
• pattern-p (function)
• pattern-thunk (function)
• (setf pattern-thunk) (function)
• pipe-elt (function)
• pipe-empty-p (function)
• pipe-head (function)
• pipe-length (function)
• pipe-of (function)
• (setf pipe-of) (function)
• pipe-tail (function)
• preprocess-number-str (function)
• report (function)
• report-xpath (function)
• report-xpattern (function)
• round-to-integer (function)
• same-expr-p (function)
• sort-nodes (function)
• sort-pipe (function)
• sorted-pipe-of (function)
• step-key (function)
• stringify-pattern-expression (function)
• stringify-pattern-expressions (function)
• subpattern-key (function)
• subpipe-after (function)
• subpipe-before (function)
• test-environment (structure)
• test-environment-p (function)
• textually-first-node (function)
• valid-expression-p (function)
• vector->pipe (function)
• with-float-traps-masked (macro)
• wrap-profiling (function)
• write-node-test (function)
• x-minusp (function)
• x-plusp (function)
• x-zerop (function)
• xf-and (function)
• xf-equal (function)
• xf-location-path (function)
• xf-or (function)
• xf-true (function)
• xf-value (function)
• xfd-* (function)
• xfd-+ (function)
• xfd-- (function)
• xfd-/ (function)
• xfd-/= (function)
• xfd-< (function)
• xfd-<= (function)
• xfd-= (function)
• xfd-> (function)
• xfd->= (function)
• xfd-and (function)
• xfd-boolean (function)
• xfd-ceiling (function)
• xfd-concat (function)
• xfd-contains (function)
• xfd-count (function)
• xfd-current (function)
• xfd-false (function)
• xfd-floor (function)
• xfd-generate-id (function)
• xfd-id (function)
• xfd-lang (function)
• xfd-last (function)
• xfd-local-name (function)
• xfd-matches (function)
• xfd-mod (function)
• xfd-name (function)
• xfd-namespace-uri (function)
• xfd-normalize-space (function)
• xfd-not (function)
• xfd-number (function)
• xfd-or (function)
• xfd-position (function)
• xfd-replace (function)
• xfd-round (function)
• xfd-starts-with (function)
• xfd-string (function)
• xfd-string-length (function)
• xfd-substring (function)
• xfd-substring-after (function)
• xfd-substring-before (function)
• xfd-sum (function)
• xfd-translate (function)
• xfd-true (function)
• xfd-union (function)
• xnum (type)
• xnum-* (function)
• xnum-+ (function)
• xnum-- (function)
• xnum-/ (function)
• xnum->string (function)
• xnum-ceiling (function)
• xnum-floor (function)
• xnum-mod (function)
• xnum-p (function)
• xnum-round (function)
• xpath-expr (type)
• xpath-function (structure)
• xpath-function-compiler (function)
• (setf xpath-function-compiler) (function)
• xpath-function-max-args (function)
• (setf xpath-function-max-args) (function)
• xpath-function-min-args (function)
• (setf xpath-function-min-args) (function)
• xpath-function-name (function)
• (setf xpath-function-name) (function)
• xpath-function-p (function)
• xpath-lexer (function)

3.2 xpattern

The XPATTERN package implements pattern matching compatible with XSLT 1.0.

@begin[Utilities powered by pattern matchers]{section}
The following convenience functions and macros use patterns. They are implemented using the lower-level functions listed below.

@aboutfun{node-matches-p}
@aboutmacro{pattern-case}
@aboutmacro{pattern-ecase}
@end{section}
@begin[Compiling pattern matchers dynamically]{section}
Pattern are represented as objects:

@aboutclass{pattern}
@aboutfun{pattern-value}
@aboutfun{pattern-priority}
Use @code{compute-patterns} to parse a pattern expression into pattern objects:

@aboutfun{compute-patterns}
@code{make-pattern-matcher} builds a matcher functions from multiple pattern objects. The matcher will find the highest-priority match among them.

@aboutfun{make-pattern-matcher} @aboutfun{make-pattern-matcher*}
@end{section}
@begin[Applying pattern matchers]{section}
To invoke a matcher created by @code{make-pattern-matcher}, use @code{matching-value} or @code{matching-values}:

@aboutfun{matching-value}
@aboutfun{matching-values}
@end{section}

Source

package.lisp (file)

Used By List

xpath

Exported Definitions

• *allow-variables-in-patterns* (special variable)
• compute-patterns (function)
• make-pattern-matcher (function)
• make-pattern-matcher* (function)
• matching-value (function)
• matching-values (function)
• node-matches-p (compiler macro)
• node-matches-p (function)
• parse-pattern-expression (function)
• pattern (structure)
• pattern-case (macro)
• pattern-ecase (macro)
• pattern-priority (function)
• (setf pattern-priority) (function)
• pattern-value (function)
• (setf pattern-value) (function)

3.3 xpath-utils

Source

package.lisp (file)

Use List

common-lisp

Used By List

xpath

Exported Definitions

• concat (function)
• hypsym (function)
• maybe-progn (function)
• mklist (function)
• once-only (macro)
• proper-list-p (function)
• string-replace (function)
• trim (function)
• with-cache (macro)
• with-gensyms (macro)

3.4 xpath-sys

The XPATH-SYS package provides an API for extensions to Plexippus XPath.

@begin[Pipes]{section}
Pipes are lazy lists, inspired by their implementation in
Norvig’s ’Paradigms of Artificial Intelligence Programming’.

@aboutmacro{make-pipe}
@aboutfun{pipe-head}
@aboutfun{pipe-tail}
@end{section}
@begin[Node sets]{section}
Node sets are the XPath data type used to represent the results of evaluations that select multiple nodes. As sets, they never contain duplicates. Conceptually, they are unordered, with the most important order defined on them being the document order.

As a data structure though, node sets are backed by a pipe, and the order of elements in that pipe is well-documented: By default, the pipe of returned node sets is sorted into document order. When unordered results are requested, the order is usually not specified, but in some cases, are already sorted according to the axis being queried, which is usually sorted either in document order,or in reverse document order. See @fun{xpath:evaluate} for the @code{unordered} argument.

@aboutclass{node-set}
@aboutfun{make-node-set}
@aboutfun{pipe-of}
@end{section}
@begin[Implementing environments]{section}
Environments provide compilation-time configuration for XPath.
An environment is a CLOS object, which is queried by the compiler using generic functions that users can implement on their own subclasses
of @class{xpath::environment}.

The default environment class implements a ‘dynamic’ environment, backed by information bound in dynamic variables, so that typical uses of XPath work without special environment classes.

@aboutfun{environment-find-namespace} @aboutfun{environment-find-variable} @aboutfun{environment-find-function}
@end{section}
@begin[Defining extension functions]{section}
XPath defines built-in functions in the empty namespace. Using
the extension API, user code can implement XPath functions addressed using other namespaces.

@aboutmacro{define-extension} @aboutmacro{define-xpath-function/lazy} @aboutmacro{define-xpath-function/eager} @aboutmacro{define-xpath-function/single-type} @aboutfun{find-xpath-function}
@end{section}
@begin[Profiling support]{section}
The profiling facility records the run time of XPath evaluations
and pattern matching.

@aboutfun{enable-profiling}
@aboutfun{disable-profiling}
@aboutfun{report}
@end{section}
@begin[Miscellaneous functions]{section}
Other useful functions:

@aboutfun{get-node-id}
@end{section}

Source

package.lisp (file)

3.5 xpath-protocol

XPATH-PROTOCOL package contains generic functions that are used to support multiple representations of XML documents for XPath.

Source

package.lisp (file)

Exported Definitions

• attribute-pipe (function)
• attribute-pipe-using-navigator (generic function)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• attribute-pipe-using-navigator (method)
• base-uri (function)
• base-uri-using-navigator (generic function)
• base-uri-using-navigator (method)
• base-uri-using-navigator (method)
• child-pipe (function)
• child-pipe-using-navigator (generic function)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• child-pipe-using-navigator (method)
• define-default-method (macro)
• get-element-by-id (function)
• get-element-by-id-using-navigator (generic function)
• get-element-by-id-using-navigator (method)
• get-element-by-id-using-navigator (method)
• hash-key (function)
• hash-key-using-navigator (generic function)
• hash-key-using-navigator (method)
• hash-key-using-navigator (method)
• hash-key-using-navigator (method)
• hash-key-using-navigator (method)
• local-name (function)
• local-name-using-navigator (generic function)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• local-name-using-navigator (method)
• namespace-pipe (function)
• namespace-pipe-using-navigator (generic function)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-pipe-using-navigator (method)
• namespace-prefix (function)
• namespace-prefix-using-navigator (generic function)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-prefix-using-navigator (method)
• namespace-uri (function)
• namespace-uri-using-navigator (generic function)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• namespace-uri-using-navigator (method)
• node-equal (function)
• node-equal-using-navigator (generic function)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-equal-using-navigator (method)
• node-p (function)
• node-p-using-navigator (generic function)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-p-using-navigator (method)
• node-text (function)
• node-text-using-navigator (generic function)
• node-text-using-navigator (method)
• node-text-using-navigator (method)
• node-text-using-navigator (method)
• node-type-p (function)
• node-type-p-using-navigator (generic function)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• node-type-p-using-navigator (method)
• parent-node (function)
• parent-node-using-navigator (generic function)
• parent-node-using-navigator (method)
• parent-node-using-navigator (method)
• parent-node-using-navigator (method)
• parent-node-using-navigator (method)
• processing-instruction-target (function)
• processing-instruction-target-using-navigator (generic function)
• processing-instruction-target-using-navigator (method)
• qualified-name (function)
• qualified-name-using-navigator (generic function)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• qualified-name-using-navigator (method)
• unparsed-entity-uri (function)
• unparsed-entity-uri-using-navigator (generic function)
• unparsed-entity-uri-using-navigator (method)
• unparsed-entity-uri-using-navigator (method)

4 Definitions

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

4.1 Exported definitions

4.1.1 Special variables

Special Variable: *allow-variables-in-patterns*

If set to T, predicates in patterns are permitted to reference variables using $var syntax. If set to NIL, such variable references signal a compilation-time error. The default is T. Bind this variable to NIL to enable compatibility with XSLT 1.0.
@see{compute-patterns}

Package

xpattern

Source

patterns.lisp (file)

Special Variable: *navigator*

Package

xpath

Source

protocol.lisp (file)

4.1.2 Macros

Macro: define-default-method NAME (&rest ARGS) &body BODY

Package

xpath-protocol

Source

protocol.lisp (file)

Macro: do-node-set (VAR NODE-SET &optional RESULT) &body BODY

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

The operation is performed lazily, i.e. if it’s terminated via
a non-local exit it doesn’t necessarily cause the XPath engine to find out all nodes in the @class{node-set} internally.

Returns nil if @code{result} form isn’t specified.

Package

xpath

Source

api.lisp (file)

Macro: once-only (&rest NAMES) &body BODY

Package

xpath-utils

Source

utils.lisp (file)

Macro: pattern-case NODE &body CLAUSES

@arg[node]{any node implementing the XPath protocol} @arg[clauses]{cases of the form (expression &rest body)} @return{The value returned by the matching clause body, or nil.} @short{Match a node against static expressions.}

Evaluates @code{node}, and matches them against the specified XSLT patterns. The first matching pattern will be chosen, i.e. earlier clauses have higher priority that later clauses.

Expressions are compiled using the dynamic environment.

As a special case, the last expression can be @code{t}, in which case it matches unconditionally.

@see{with-namespaces}
@see{pattern-ecase}
@see{node-matches-p}
@see{with-variables}

Package

xpattern

Source

patterns.lisp (file)

Macro: pattern-ecase NODE &rest CLAUSES

@arg[node]{any node implementing the XPath protocol} @arg[clauses]{cases of the form (expression &rest body)} @return{The value returned by the matching clause body.} @short{Match a node against static expressions.}

Evaluates @code{node}, and matches them against the specified XSLT patterns. The first matching pattern will be chosen, i.e. earlier clauses have higher priority that later clauses.

Expressions are compiled using the dynamic environment.

If no clause matches, an error will be signalled.

@see{with-namespaces}
@see{pattern-case}
@see{node-matches-p}
@see{with-variables}

Package

xpattern

Source

patterns.lisp (file)

Macro: with-cache (&rest KEYS) &body COMPILATION-BODY

Package

xpath-utils

Source

utils.lisp (file)

Macro: with-gensyms SYMS &rest BODY

Execute the body binding syms to gensyms

Package

xpath-utils

Source

utils.lisp (file)

Macro: with-namespaces (&rest BINDINGS) &body BODY

@arg[bindings]{bindings in the form (PREFIX VALUE). PREFIXes and VALUEs are evaluated} @return{the tresult of evaluating @code{body}}
@short{Provides namespace bindings for XPath compilation}

Namespace bindings are used for compilation of XPath expressions.
nil is equivalent of "" prefix. Bindings provided by this macro
have dynamic scope.

Package

xpath

Source

environment.lisp (file)

Macro: with-plx-extensions &body BODY

@short{Binds plx prefix to Plexippus XPath extensions namespace.}

The following functions are currently available:

@pre{plx:matches(string, pattern, flags?)}
Returns true if @code{string} is matched by regular expression @code{pattern}, false otherwise. Optional @code{flags} specify modifiers (i, m, s). CL-PPCRE is used as regular expression engine.

@pre{plx:replace(string, pattern, replacement, flags?)}
Returns @code{string} with all matches of regular expression @code{pattern} replaced with @code{replacement}. Optional @code{flags} specify modifiers (i, m, s).

@pre{plx:current()}
Returns a @class{node-set} consisting of one node which was specifed
as context node for expression evaluation. Analagous to @code{current()} function of XSLT.

@pre{plx:generate-id(node-set?)}
Returns an alphanumeric string that uniquely identifies the first node of the @code{node-set} (or context node if @code{node-set} isn’t specified) within its document. Analagous to @code{generate-id()} of XSLT (except that the latter works across multiple documents).

Package

xpath

Source

plx.lisp (file)

Macro: with-variables (&rest BINDINGS) &body BODY

@arg[bindings]{bindings in the form (QNAME VALUE). QNAMEs and VALUEs are evaluated} @return{the tresult of evaluating @code{body}}
@short{Provides bindings for XPath variables}

Variable bindings are used for evaluation of compiled XPath expressions. Bindings provided by this macro have dynamic scope.

Package

xpath

Source

environment.lisp (file)

Macro: xpath FORM

@arg[form]{a sexpr-based XPath form}
@return{a list consisting of symbol XPATH and the @code{form}}
This macro is used to specify sexpr-based XPath expression for @fun{evaluate}

Package

xpath

Source

api.lisp (file)

4.1.3 Compiler macros

Compiler Macro: evaluate XPATH CONTEXT &optional UNORDERED-P

Package

xpath

Source

api.lisp (file)

Compiler Macro: node-matches-p NODE PATTERN

Package

xpattern

Source

patterns.lisp (file)

4.1.4 Functions

Function: all-nodes NODE-SET

@arg[node-set]{a @class{node-set}}
@return{a list of nodes}
Returns all nodes of the @code{node-set} as a list.

Package

xpath

Source

api.lisp (file)

Function: attribute-pipe NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: base-uri NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: boolean-value VALUE

@arg[value]{value of an XPath-supported type or an XML node}
@return{an XPath boolean}
@short{Returns the value of XPath boolean() function.}

For XML nodes returns the value of XPath boolean() function applied
to the result of calling @fun{string-value} for the specified @code{value}.

Package

xpath

Source

types.lisp (file)

Function: child-pipe NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: compile-xpath XPATH &optional ENVIRONMENT

@arg[xpath]{an XPath expression}
@return{a compiled XPath expression}
@short{Compiles an XPath expression}

The @code{xpath} expression is compiled using current environment if it isn’t compiled yet. @code{xpath} can be a string, a sexpr-based XPath epression or a compiled expression. In the latter case @code{xpath} argument value itself is returned.

Package

xpath

Source

api.lisp (file)

Function: compute-patterns EXPRESSION PRIORITY VALUE ENVIRONMENT

@arg[expression]{a string or s-expression}
@arg[priority]{an integer}
@arg[value]{an object}
@arg[environment]{an @code{environment}}
@return{a list of @class{pattern}s}
@short{Parse an XSLT pattern expression into one or more pattern objects.}

Parses an expression, resolves its namespace-, variable-, and function-references using the specified @code{environment}, and creates a @class{pattern} object for the expression (if it does not use a union) or one @class{pattern} object for each sub-expression that is being joined into the union.

The specified @code{priority} is used as the @fun{pattern-priority}, and the specified @code{value} is used as the @fun{pattern-value}.

@see{make-pattern-matcher*}
@see{make-pattern-matcher}

Package

xpattern

Source

patterns.lisp (file)

Function: concat &rest VALUES

Concatenate string representations (PRINC-TO-STRING) of VALUES

Package

xpath-utils

Source

utils.lisp (file)

Function: context-node CONTEXT

@arg[context]{an XPath context}
@return{an XML node}
Returns the context node of the XPath @code{context}.

Package

xpath

Source

types.lisp (file)

Writer

(setf context-node) (function)

Function: (setf context-node) NODE CONTEXT

@arg[node]{an XML node}
@arg[context]{an XPath context}
@return{the @code{node}}
Sets the context node of @code{context} and returns that node.

Package

xpath

Source

types.lisp (file)

Reader

context-node (function)

Function: context-position CONTEXT

@arg[context]{an XPath context}
@return{a positive integer}
Returns the current position of the XPath @code{context}.

Package

xpath

Source

types.lisp (file)

Writer

(setf context-position) (function)

Function: (setf context-position) POSITION CONTEXT

@arg[position]{context position, a positive integer} @arg[context]{an XPath context}
@return{the value of @code{position}}
Sets the position of the XPath @code{context} and returns it.

Package

xpath

Source

types.lisp (file)

Reader

context-position (function)

Function: context-size CONTEXT

@arg[context]{an XPath context}
@return{a non-negative number} @short{Returns the size of @code{context}} If the context size was specified as a function, the result of calling that function is returned.

Package

xpath

Source

types.lisp (file)

Writer

(setf context-size) (function)

Function: (setf context-size) SIZE CONTEXT

@arg[size]{context size, a non-negative integer or a function without arguments returning non-negative integer} @arg[context]{an XPath context}
@return{the value of @code{size}}
Sets the size of the XPath @code{context} and returns it.

Package

xpath

Source

types.lisp (file)

Reader

context-size (function)

Function: context-starting-node CONTEXT

@arg[context]{an XPath context}
@return{an XML node}
Returns the node for which the whole XPath expression is evaluated.

Package

xpath

Source

types.lisp (file)

Writer

(setf context-starting-node) (function)

Function: (setf context-starting-node) NODE CONTEXT

@arg[context]{an XPath context}
@return{the value of @code{node}}
Sets the node which is considered "starting" one, i.e. for which the whole XPath extension is evaluated.

Package

xpath

Source

types.lisp (file)

Reader

context-starting-node (function)

Function: evaluate XPATH CONTEXT &optional UNORDERED-P

@arg[xpath]{an XPath expression}
@arg[context]{an XPath context}
@arg[unordered-p]{specify true to get unordered node-set}
@return{the result of evaluating @code{xpath} within the @code{context}} @short{Evaluates an XPath expression}

@code{xpath} can be a string, a sexpr-based XPath epression or
a compiled expression. The @code{context} can be obtained using @fun{make-context}. As an alternative, a node can be specifed.

If @code{unordered-p} is false (default) and value being returned is a @class{node-set}, it will be sorted using @fun{sort-node-set} so its nodes will be in document
order. If @code{unordered-p} is true, the order of the nodes is unspecified. Unordered mode can be significantly faster in some cases (and never slower).

Package

xpath

Source

api.lisp (file)

Function: evaluate-compiled COMPILED-XPATH CONTEXT &optional UNORDERED-P

@arg[compiled-xpath]{a compiled XPath expression}
@arg[context]{an XPath context}
@arg[unordered-p]{specify true to get unordered node-set}
@return{the result of evaluating @code{compiled-xpath} within the @code{context}} @short{Evaluates a compiled XPath expression returned by @fun{compile-xpath}}

The @code{context} can be obtained using @fun{make-context}. As an alternative,
a node can be specifed.

If @code{unordered-p} is false (default) and value being returned is a @class{node-set}, it will be sorted using @fun{sort-node-set} so its nodes will be in document
order. If @code{unordered-p} is true, the order of the nodes is unspecified. Unordered mode can be significantly faster in some cases (and never slower).

Package

xpath

Source

api.lisp (file)

Function: first-node NODE-SET

@arg[node-set]{a @class{node-set}}
@return{a @class{node-set} or nil}
Returns the first node in the @code{node-set} or nil if it’s empty.

Package

xpath

Source

api.lisp (file)

Function: get-element-by-id NODE ID

Package

xpath-protocol

Source

protocol.lisp (file)

Function: hash-key NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: hypsym &rest PARTS

Assemble a symbol from PARTS interleaving them with hyphens

Package

xpath-utils

Source

utils.lisp (file)

Function: list->node-set LIST

@arg[list]{a list of nodes}
@return{a @class{node-set}}
Makes a @class{node-set} from the @code{list} of nodes.

Package

xpath

Source

api.lisp (file)

Function: local-name NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: make-context NODE &optional SIZE POSITION STARTING-NODE

@arg[node]{an XML node}
@arg[size]{context size, a non-negative integer or a function without arguments returning non-negative integer} @arg[position]{context position, a positive integer}
Makes a @class{context} object.

Package

xpath

Source

types.lisp (file)

Function: make-node-set-iterator NODE-SET

@arg[node-set]{a @class{node-set}}
@return{a node-set iterator}
@short{Creates a node set iterator for @code{node-set}}

Node set iterators can be used to iterate over node-sets. This can be done without causing the XPath engine to find out all their nodes and using non-local exits.

Package

xpath

Source

api.lisp (file)

Function: make-pattern-matcher PATTERNS

@arg[patterns]{a list of @class{pattern}s}
@return{the pattern matcher, a function}
@short{Create a pattern matcher that distinguishes between
multiple patterns.}

This function combines several patterns, and creates a matcher function for use with @fun{matching-value} or @fun{matching-values}.
The matcher function will compare a node against each pattern, and find the highest-priority pattern or patterns that match the node.

@see{compute-patterns}

Package

xpattern

Source

patterns.lisp (file)

Function: make-pattern-matcher* EXPRESSION ENVIRONMENT

@arg[expression]{a string or s-expression}
@arg[environment]{an @code{environment}}
@return{the pattern matcher, a function}
@short{Create a pattern matcher for a single pattern.}

This function is a convenience wrapper around @fun{compute-patterns} and @fun{make-pattern-matcher}.

The resulting matcher will return T if the specified @code{expression} matches, or NIL if it doesn’t.

@see{compute-patterns}
@see{matching-value}
@see{matching-values}

Package

xpattern

Source

patterns.lisp (file)

Function: map-node-set FUNC NODE-SET

@arg[func]{a function}
@arg[node-set]{a @class{node-set}}
@return{nil}
@short{Calls @code{func} for each node in @code{node-set}}

The operation is performed lazily, i.e. if it’s terminated via
a non-local exit it doesn’t necessarily cause the XPath engine to find out all nodes in the @class{node-set} internally.

Package

xpath

Source

api.lisp (file)

Function: map-node-set->list FUNC NODE-SET

@arg[func]{a function}
@arg[node-set]{a @class{node-set}}
@return{a list}
@short{Calls @code{func} for each node in @code{node-set} and conses up a list of its return values}

The operation is performed lazily, i.e. if it’s terminated via
a non-local exit it doesn’t necessarily cause the XPath engine to find out all nodes in the @class{node-set} internally.

Package

xpath

Source

api.lisp (file)

Function: matching-value MATCHER NODE &optional DEFAULT

@arg[matcher]{a pattern matching function}
@arg[node]{any node implementing the XPath protocol} @arg[default]{an object}
@return{an object}
@short{Apply a pattern matcher to node, and return exactly one value.}

For use with @code{matcher} functions that have been returned by @fun{make-pattern-matcher} or a higher-level function like @fun{make-pattern-matcher*}.

If exactly one pattern matches, or several patterns for the same value match, the user-specified values as determined by @fun{pattern-value} will be returned by this function.

If no pattern matches, @code{default} will be returned instead.

If more than one pattern of highest priority and different values match, an @code{xpath-error} will be signalled.

@see{node-matches-p}
@see{pattern-case}
@see{pattern-ecase}

Package

xpattern

Source

patterns.lisp (file)

Function: matching-values MATCHER NODE

@arg[matcher]{a pattern matching function}
@arg[node]{any node implementing the XPath protocol}
@return{an object}
@short{Apply a pattern matcher to node, and return one or more matching values.}

For use with @code{matcher} functions that have been returned by @fun{make-pattern-matcher} or a higher-level function like @fun{make-pattern-matcher*}.

The resulting list will contain the user-specified values as returned by @fun{pattern-value} on the patterns for this matcher, in any order. Duplicates under @code{eql} will have been removed from the list.

@see{node-matches-p}
@see{pattern-case}
@see{pattern-ecase}

Package

xpattern

Source

patterns.lisp (file)

Function: maybe-progn BODY

Wrap the BODY with PROGN if it contains more than one form. Otherwise return the first form or NIL if the body is empty

Package

xpath-utils

Source

utils.lisp (file)

Function: mklist VALUE

Package

xpath-utils

Source

utils.lisp (file)

Function: namespace-pipe NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: namespace-prefix NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: namespace-uri NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-equal NODE OTHER

Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-matches-p NODE PATTERN-EXPRESSION

@arg[node]{any node implementing the XPath protocol} @arg[pattern-expression]{a string or s-expression}
@return{a boolean}
@short{Determine whether @code{node} matches the pattern expression.}

The expression is compiled using the dynamic environment.

@see{with-namespaces}
@see{with-variables}
@see{pattern-case}
@see{pattern-ecase}

Package

xpattern

Source

patterns.lisp (file)

Function: node-p NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-set-empty-p NODE-SET

@arg[node-set]{a @class{node-set}} @return{a generalized boolean} Returns true if @code{node-set} is empty

Package

xpath

Source

types.lisp (file)

Function: node-set-iterator-current ITERATOR

@arg[iterator]{a node-set iterator returned by @fun{make-node-set-iterator}} @return{a node or nil}
Returns current node of @code{iterator} or nil if it’s at the end
of its node set.

Package

xpath

Source

api.lisp (file)

Function: node-set-iterator-end-p ITERATOR

@arg[iterator]{a node-set iterator returned by @fun{make-node-set-iterator}} @return{a generalized boolean}
Returns true if @code{iterator} points to the end of its node set

Package

xpath

Source

api.lisp (file)

Function: node-set-iterator-next ITERATOR

@arg[iterator]{a node-set iterator returned by @fun{make-node-set-iterator}} @return{the value of @code{iterator}}
Advances @code{iterator} if it’s not at the end of its node set,
does nothing otherwise.

Package

xpath

Source

api.lisp (file)

Function: node-set-p OBJECT

@arg[object]{a value of any type}
@return{a generalized boolean}
Returns true if @code{object} is a @class{node-set}

Package

xpath

Source

types.lisp (file)

Function: node-set-value VALUE

@arg[value]{value of an XPath-supported type or an XML node} @return{a @class{node-set}}
@short{Returns the value of XPath node-set() function.}

For XML nodes returns a @class{node-set} consisting of the single node specified by @code{value}.

Package

xpath

Source

types.lisp (file)

Function: node-text NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-type-p NODE TYPE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: number-value VALUE

@arg[value]{value of an XPath-supported type or an XML node}
@return{an XPath number}
@short{Returns the value of XPath number() function.}

For XML nodes returns the value of XPath number() function applied
to the result of calling @fun{string-value} for the specified @code{value}.

Package

xpath

Source

types.lisp (file)

Function: parent-node NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: parse-pattern-expression STR

@arg[str]{a string}
@return{a s-expression-based pattern expression} Parses an XSLT pattern into an s-expression.

Package

xpattern

Source

patterns.lisp (file)

Function: parse-xpath STR

@arg[str]{a string}
@return{a s-expression-based XPath expression}
Parses a string-based XPath expression into s-expression-based one.

Package

xpath

Source

parser.lisp (file)

Function: pattern-priority INSTANCE

@arg[instance]{a @class{pattern}}
@return{an integer}
@short{Return the priority of this pattern.}
When several patters would match the same node, the pattern matcher will only consider the patterns that have the highest priority. @see{matching-value}
@see{matching-values}

Package

xpattern

Source

patterns.lisp (file)

Writer

(setf pattern-priority) (function)

Function: (setf pattern-priority) VALUE INSTANCE

Package

xpattern

Source

patterns.lisp (file)

Reader

pattern-priority (function)

Function: pattern-value INSTANCE

@arg[instance]{a @class{pattern}}
@return{an object}
Return the user-specified value that will be returned by pattern matchers if this pattern matches. @see{matching-value}
@see{matching-values}

Package

xpattern

Source

patterns.lisp (file)

Writer

(setf pattern-value) (function)

Function: (setf pattern-value) VALUE INSTANCE

Package

xpattern

Source

patterns.lisp (file)

Reader

pattern-value (function)

Function: processing-instruction-target NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: proper-list-p LIST

True if the LIST is proper list

Package

xpath-utils

Source

utils.lisp (file)

Function: qualified-name NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Function: sort-node-set NODE-SET

@arg[node-set]{a @class{node-set}}
@return{a sorted version of @code{node-set}}
Sorts the @code{node-set} according to document order.

Package

xpath

Source

types.lisp (file)

Function: string-replace STRING SUBSTRING REPLACEMENT

Replace occurences of SUBSTRING in STRING with REPLACEMENT.

Package

xpath-utils

Source

utils.lisp (file)

Function: string-value VALUE

@arg[value]{value of an XPath-supported type or an XML node}
@return{an XPath string}
@short{Returns the value of XPath number() function.}

For XML nodes returns the value of @fun{xpath-protocol:node-text} applied to the specified @code{value}.

Package

xpath

Source

types.lisp (file)

Function: trim STR

Package

xpath-utils

Source

utils.lisp (file)

Function: unparsed-entity-uri NODE NAME

Package

xpath-protocol

Source

protocol.lisp (file)

Function: xpath-error FMT &rest ARGS

@arg[fmt]{format control string}
@arg[args]{format arguments}
Signals the @class{xpath-error} condition with specified message.

Package

xpath

Source

api.lisp (file)

4.1.5 Generic functions

Generic Function: attribute-pipe-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: attribute-pipe-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: attribute-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: attribute-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: attribute-pipe-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: attribute-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: attribute-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)

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

Generic Function: base-uri-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: base-uri-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

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

Generic Function: child-pipe-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: child-pipe-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: child-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: child-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: child-pipe-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)

Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE document)

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

Generic Function: get-element-by-id-using-navigator NAVIGATOR NODE ID

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: get-element-by-id-using-navigator (NAVI xpath-navigator) NODE ID

Source

xmls-compat.lisp (file)

Method: get-element-by-id-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node) ID

Generic Function: hash-key-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: hash-key-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: hash-key-using-navigator (NAVI xpath-navigator) NODE

Source

xmls-compat.lisp (file)

Method: hash-key-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: hash-key-using-navigator (NAVIGATOR (eql default-navigator)) NODE

Generic Function: local-name-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: local-name-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: local-name-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: local-name-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: local-name-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: local-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)

Method: local-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

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

Generic Function: namespace-pipe-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: namespace-pipe-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: namespace-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: namespace-pipe-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: namespace-pipe-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: namespace-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)

Method: namespace-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

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

Generic Function: namespace-prefix-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: namespace-prefix-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: namespace-prefix-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: namespace-prefix-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)

Method: namespace-prefix-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

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

Generic Function: namespace-uri-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: namespace-uri-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: namespace-uri-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: namespace-uri-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: namespace-uri-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: namespace-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)

Method: namespace-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

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

Generic Function: node-equal-using-navigator NAVIGATOR NODE OTHER

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: node-equal-using-navigator (NAVI xpath-navigator) (A xmls-namespace) (B xmls-namespace)

Source

xmls-compat.lisp (file)

Method: node-equal-using-navigator (NAVI xpath-navigator) (A string) (B string)

Source

xmls-compat.lisp (file)

Method: node-equal-using-navigator (NAVI xpath-navigator) (A cons) (B cons)

Source

xmls-compat.lisp (file)

Method: node-equal-using-navigator (NAVI xpath-navigator) A B

Source

xmls-compat.lisp (file)

Method: node-equal-using-navigator (NAVIGATOR (eql default-navigator)) (A dom-namespace) (B dom-namespace)

Method: node-equal-using-navigator (NAVIGATOR (eql default-navigator)) A B

Generic Function: node-p-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: node-p-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute)

Source

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVI xpath-navigator) (NODE cons)

Source

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVI xpath-navigator) NODE

Source

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)

Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) NODE

Generic Function: node-text-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: node-text-using-navigator (NAVI xpath-navigator) NODE

Source

xmls-compat.lisp (file)

Method: node-text-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: node-text-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)

Generic Function: node-type-p-using-navigator NAVIGATOR NODE TYPE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace) (TYPE (eql namespace))

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute) (TYPE (eql attribute))

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE cons) (TYPE (eql element))

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE string) (TYPE (eql text))

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace) TYPE

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE xmls-attribute) TYPE

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE string) TYPE

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVI xpath-navigator) (NODE cons) TYPE

Source

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE document) (TYPE (eql document))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace) (TYPE (eql namespace))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element) (TYPE (eql element))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE attr) (TYPE (eql attribute))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE text) (TYPE (eql text))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE processing-instruction) (TYPE (eql processing-instruction))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE comment) (TYPE (eql comment))

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace) TYPE

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node) TYPE

Generic Function: parent-node-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: parent-node-using-navigator (NAVI xpath-navigator) NODE

Source

xmls-compat.lisp (file)

Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)

Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE attr)

Generic Function: processing-instruction-target-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

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

Generic Function: qualified-name-using-navigator NAVIGATOR NODE

Package

xpath-protocol

Source

protocol.lisp (file)

Methods

Method: qualified-name-using-navigator (NAVI xpath-navigator) (NODE string)

Source

xmls-compat.lisp (file)

Method: qualified-name-using-navigator (NAVI xpath-navigator) (NODE xmls-namespace)

Source

xmls-compat.lisp (file)

Method: qualified-name-using-navigator (NAVI xpath-navigator) NODE

Source

xmls-compat.lisp (file)

Method: qualified-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)

Method: qualified-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)

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