The xpath Reference Manual

This is the xpath Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 06:32:29 2024 GMT+0.

Table of Contents


1 Systems

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


1.1 xpath

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

Maintainer

Sharp Lispers <>

Authors

Ivan Shvedunov
David Lichteblau

License

2 clause BSD

Version

0.1

Dependencies
  • cxml (system).
  • parse-number (system).
  • cl-ppcre (system).
  • yacc (system).
Source

xpath.asd.

Child Components

2 Files

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


2.1 Lisp


2.1.1 xpath/xpath.asd

Source

xpath.asd.

Parent Component

xpath (system).

ASDF Systems

xpath.


2.1.2 xpath/package.lisp

Source

xpath.asd.

Parent Component

xpath (system).

Packages

2.1.3 xpath/utils.lisp

Dependency

package.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface

2.1.4 xpath/pipes.lisp

Dependency

utils.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.5 xpath/protocol.lisp

Dependency

pipes.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.6 xpath/xnum-ieee.lisp

Dependency

protocol.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.7 xpath/types.lisp

Dependency

xnum-ieee.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.8 xpath/extensions.lisp

Dependency

types.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.9 xpath/environment.lisp

Dependency

extensions.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.10 xpath/axes.lisp

Dependency

environment.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.11 xpath/node-tests.lisp

Dependency

axes.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.12 xpath/xpath.lisp

Dependency

node-tests.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.13 xpath/functions.lisp

Dependency

xpath.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.14 xpath/lexer.lisp

Dependency

functions.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

2.1.15 xpath/parser.lisp

Dependency

lexer.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface

parse-xpath (function).

Internals

2.1.16 xpath/api.lisp

Dependency

parser.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.17 xpath/plx.lisp

Dependency

api.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface

with-plx-extensions (macro).

Internals

2.1.18 xpath/xmls-compat.lisp

Dependency

plx.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.19 xpath/patterns.lisp

Dependency

xmls-compat.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Public Interface
Internals

2.1.20 xpath/profile.lisp

Dependency

patterns.lisp (file).

Source

xpath.asd.

Parent Component

xpath (system).

Internals

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.

Use List
Public Interface
Internals

3.2 xpath-protocol

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

Source

package.lisp.

Public Interface

3.3 xpath-utils

Source

package.lisp.

Use List

common-lisp.

Used By List

xpath.

Public Interface

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.


3.5 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.

Used By List

xpath.

Public Interface

4 Definitions

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


4.1 Public Interface


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.

Special Variable: *navigator*
Package

xpath.

Source

protocol.lisp.


4.1.2 Macros

Macro: define-default-method (name (&rest args) &body body)
Package

xpath-protocol.

Source

protocol.lisp.

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.

Macro: once-only ((&rest names) &body body)
Package

xpath-utils.

Source

utils.lisp.

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.

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.

Macro: with-cache ((&rest keys) &body compilation-body)
Package

xpath-utils.

Source

utils.lisp.

Macro: with-gensyms (syms &rest body)

Execute the body binding syms to gensyms

Package

xpath-utils.

Source

utils.lisp.

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.

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.

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.

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.


4.1.3 Compiler macros

Compiler Macro: evaluate (xpath context &optional unordered-p)
Package

xpath.

Source

api.lisp.

Compiler Macro: node-matches-p (node pattern)
Package

xpattern.

Source

patterns.lisp.


4.1.4 Ordinary 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.

Function: attribute-pipe (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: base-uri (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

Function: child-pipe (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

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.

Function: concat (&rest values)

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

Package

xpath-utils.

Source

utils.lisp.

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.

Function: (setf context-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.

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.

Function: (setf context-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.

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.

Function: (setf context-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.

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.

Function: (setf context-starting-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.

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.

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.

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.

Function: get-element-by-id (node id)
Package

xpath-protocol.

Source

protocol.lisp.

Function: hash-key (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: hypsym (&rest parts)

Assemble a symbol from PARTS interleaving them with hyphens

Package

xpath-utils.

Source

utils.lisp.

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.

Function: local-name (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Function: mklist (value)
Package

xpath-utils.

Source

utils.lisp.

Function: namespace-pipe (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: namespace-prefix (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: namespace-uri (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: node-equal (node other)
Package

xpath-protocol.

Source

protocol.lisp.

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.

Function: node-p (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

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.

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.

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.

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.

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.

Function: node-text (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: node-type-p (node type)
Package

xpath-protocol.

Source

protocol.lisp.

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.

Function: parent-node (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

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.

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

Target Slot

priority.

Writer: (setf pattern-priority) (instance)
Package

xpattern.

Source

patterns.lisp.

Target Slot

priority.

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

Target Slot

value.

Writer: (setf pattern-value) (instance)
Package

xpattern.

Source

patterns.lisp.

Target Slot

value.

Function: processing-instruction-target (node)
Package

xpath-protocol.

Source

protocol.lisp.

Function: proper-list-p (list)

True if the LIST is proper list

Package

xpath-utils.

Source

utils.lisp.

Function: qualified-name (node)
Package

xpath-protocol.

Source

protocol.lisp.

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.

Function: string-replace (string substring replacement)

Replace occurences of SUBSTRING in STRING with REPLACEMENT.

Package

xpath-utils.

Source

utils.lisp.

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.

Function: trim (str)
Package

xpath-utils.

Source

utils.lisp.

Function: unparsed-entity-uri (node name)
Package

xpath-protocol.

Source

protocol.lisp.

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.


4.1.5 Generic functions

Generic Function: attribute-pipe-using-navigator (navigator node)
Package

xpath-protocol.

Source

protocol.lisp.

Methods
Method: attribute-pipe-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: attribute-pipe-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: attribute-pipe-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: attribute-pipe-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: base-uri-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: child-pipe-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: child-pipe-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: child-pipe-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: child-pipe-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: get-element-by-id-using-navigator ((navi xpath-navigator) node id)
Source

xmls-compat.lisp.

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.

Methods
Method: hash-key-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: hash-key-using-navigator ((navi xpath-navigator) node)
Source

xmls-compat.lisp.

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.

Methods
Method: local-name-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: local-name-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: local-name-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: local-name-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: namespace-pipe-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: namespace-pipe-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: namespace-pipe-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: namespace-pipe-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: namespace-prefix-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: namespace-prefix-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: namespace-uri-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: namespace-uri-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: namespace-uri-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: namespace-uri-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

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.

Methods
Method: node-equal-using-navigator ((navi xpath-navigator) (a xmls-namespace) (b xmls-namespace))
Source

xmls-compat.lisp.

Method: node-equal-using-navigator ((navi xpath-navigator) (a string) (b string))
Source

xmls-compat.lisp.

Method: node-equal-using-navigator ((navi xpath-navigator) (a cons) (b cons))
Source

xmls-compat.lisp.

Method: node-equal-using-navigator ((navi xpath-navigator) a b)
Source

xmls-compat.lisp.

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.

Methods
Method: node-p-using-navigator ((navi xpath-navigator) (node xmls-attribute))
Source

xmls-compat.lisp.

Method: node-p-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: node-p-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: node-p-using-navigator ((navi xpath-navigator) (node cons))
Source

xmls-compat.lisp.

Method: node-p-using-navigator ((navi xpath-navigator) node)
Source

xmls-compat.lisp.

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.

Methods
Method: node-text-using-navigator ((navi xpath-navigator) node)
Source

xmls-compat.lisp.

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.

Methods
Method: node-type-p-using-navigator ((navi xpath-navigator) (node xmls-namespace) (type (eql :namespace)))
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node xmls-attribute) (type (eql :attribute)))
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node cons) (type (eql :element)))
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node string) (type (eql :text)))
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node xmls-namespace) type)
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node xmls-attribute) type)
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node string) type)
Source

xmls-compat.lisp.

Method: node-type-p-using-navigator ((navi xpath-navigator) (node cons) type)
Source

xmls-compat.lisp.

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.

Methods
Method: parent-node-using-navigator ((navi xpath-navigator) node)
Source

xmls-compat.lisp.

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.

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.

Methods
Method: qualified-name-using-navigator ((navi xpath-navigator) (node string))
Source

xmls-compat.lisp.

Method: qualified-name-using-navigator ((navi xpath-navigator) (node xmls-namespace))
Source

xmls-compat.lisp.

Method: qualified-name-using-navigator ((navi xpath-navigator) node)
Source

xmls-compat.lisp.

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))
Generic Function: unparsed-entity-uri-using-navigator (navigator node name)
Package

xpath-protocol.

Source

protocol.lisp.

Methods
Method: unparsed-entity-uri-using-navigator ((navi xpath-navigator) node name)
Source

xmls-compat.lisp.

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

4.1.6 Standalone methods

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

types.lisp.


4.1.7 Conditions

Condition: xpath-error

The class of all xpath errors.

Package

xpath.

Source

api.lisp.

Direct superclasses

simple-error.


4.1.8 Structures

Structure: pattern

Represents a parsed XSLT pattern. @see-constructor{compute-patterns} @see-slot{pattern-value} @see-slot{pattern-priority} @see{make-pattern-matcher}

Package

xpattern.

Source

patterns.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: priority
Package

xpath.

Readers

pattern-priority.

Writers

(setf pattern-priority).

Slot: value
Package

xpath.

Readers

pattern-value.

Writers

(setf pattern-value).

Slot: key
Package

xpath.

Readers

pattern-key.

Writers

(setf pattern-key).

Slot: thunk
Package

xpath.

Readers

pattern-thunk.

Writers

(setf pattern-thunk).

Slot: expression
Package

xpath.

Readers

pattern-expression.

Writers

(setf pattern-expression).


4.1.9 Classes

Class: context

Represents XPath context

Package

xpath.

Source

types.lisp.

Direct slots
Slot: node
Initargs

:node

Slot: size
Initargs

:size

Slot: position
Package

common-lisp.

Initargs

:position

Slot: starting-node
Initargs

:starting-node

Class: node-set

Represents an XPath node set

@see-constructor{make-node-set}

Package

xpath.

Source

types.lisp.

Direct methods
Direct slots
Slot: pipe
Initform

xpath::empty-pipe

Initargs

:pipe

Slot: ordering
Initform

:unordered

Initargs

:ordering

Readers

ordering-of.

Writers

(setf ordering-of).


4.2 Internals


4.2.1 Constants

Constant: empty-pipe
Package

xpath.

Source

pipes.lisp.


4.2.2 Special variables

Special Variable: *dynamic-namespaces*
Package

xpath.

Source

environment.lisp.

Special Variable: *dynamic-var-bindings*
Package

xpath.

Source

environment.lisp.

Special Variable: *extensions*
Package

xpath.

Source

extensions.lisp.

Special Variable: *initial-namespaces*
Package

xpath.

Source

environment.lisp.

Special Variable: *plx-uri*
Package

xpath.

Source

plx.lisp.

Special Variable: *profiling-enabled-p*
Package

xpath.

Source

profile.lisp.

Special Variable: *samples*
Package

xpath.

Source

profile.lisp.

Special Variable: *xpath-parser*
Package

xpath.

Source

parser.lisp.

Special Variable: +nan+
Package

xpath.

Source

xnum-ieee.lisp.


4.2.3 Macros

Macro: %define-xpath-function/eager (ext name converter args &body body)
Package

xpath.

Source

extensions.lisp.

Macro: append-pipes (pipex pipey)

return a pipe that appends two pipes.

The evaluation style of this macro has been chosen to be consistent with MAKE-PIPE: The first argument is evaluated eagerly; the second argument lazily.

Package

xpath.

Source

pipes.lisp.

Macro: define-axis (name (ordering &optional principal-node-type) &body body)
Package

xpath.

Source

axes.lisp.

Macro: define-extension (name uri &optional documentation)

@arg[name]{the name of XPath extension (a symbol)}
@arg[uri]{URI corresponding to XPath extension (a string)} @arg[documentation]{documentation string for the XPath extension} @short{Defines an XPath extension with specified @code{name} and @code{uri}.}

An XPath extension is a collection of XPath functions that are defined using one of @fun{define-xpath-function/lazy}, @fun{define-xpath-function/eager} or @fun{define-xpath-function/single-type} macros. In order to use the extension, one must bind a prefix string to its @code{uri} using @fun{with-namespaces} macro.

Example:
@begin{pre}
(defparameter *my-namespace* "http://example.net/my-xpath-extension")

(xpath-sys:define-extension
my-ext *my-namespace*
"My Extension")

(xpath-sys:define-xpath-function/single-type my-ext add-quotes string (string) (concat "\"" string "\""))

(defun get-my-quoted-string(doc)
(with-namespaces (("my" *my-namespace*))
(evaluate "add-quotes(//some-element)" doc)))
@end{pre}

Package

xpath.

Source

extensions.lisp.

Macro: define-fixup-lexer (name &rest rules)
Package

xpath.

Source

lexer.lisp.

Macro: define-regex-function (name args &body body)
Package

xpath.

Source

plx.lisp.

Macro: define-xpath-function/eager (ext name args &body body)

@arg[ext]{name of an XPath extension (a symbol)}
@arg[name]{XPath function name}
@arg[args]{XPath function arguments}
@short{Defines an XPath function, "eager" style.}

The @code{body} is evaluated during evaluation of XPath
expressions each time the function being defined is called.
It’s passed a list of values corresponding to XPath function arguments and should return a value of one of XPath types (string, boolean, number, node set).

Example:
@begin{pre}
(define-xpath-function/eager my-ext join (delim node-set)
(reduce (lambda (a b) (concatenate ’string a delim b)) (map-node-set->list #’string-value node-set)))
@end{pre}
@see{define-xpath-extension}
@see{define-xpath-function/lazy} @see{define-xpath-function/single-type}

Package

xpath.

Source

extensions.lisp.

Macro: define-xpath-function/lazy (ext name args &body body)

@arg[ext]{name of an XPath extension (a symbol)}
@arg[name]{XPath function name}
@arg[args]{XPath function arguments}
@short{Defines an XPath function, "lazy" style.}

The @code{body} is evaluated during compilation of XPath
expressions each time the function being defined is referenced.
It’s passed a list of "thunks" corresponding to XPath function arguments and should return a new "thunk". A "thunk" is a function that takes an XPath @class{context} as argument and returns value of one of XPath types (string, boolean, number, node set).

Example:
@begin{pre}
(define-xpath-function/lazy my-ext my-if (v if-part else-part) #’(lambda (ctx)
(if (boolean-value (funcall v ctx))
(funcall if-part ctx)
(funcall else-part ctx))))
@end{pre}
@see{define-xpath-extension}
@see{define-xpath-function/eager} @see{define-xpath-function/single-type}

Package

xpath.

Source

extensions.lisp.

Macro: define-xpath-function/single-type (ext name type args &body body)

@arg[ext]{name of an XPath extension (a symbol)}
@arg[name]{XPath function name}
@arg[args]{XPath function arguments}
@short{Defines an XPath function, "eager" style with automatic type conversion.}

The @code{body} is evaluated during evaluation of XPath
expressions each time the function being defined is called.
It’s passed a list of values corresponding to XPath function arguments
and should return a value of one of XPath types (string, boolean, number,
node set). Argument values are automatically converted to specified XPath @code{type}.

Example:
@begin{pre}
(xpath-sys:define-xpath-function/single-type my-ext add-quotes string (string) (concat "\"" string "\""))
@end{pre}
@see{define-xpath-extension}
@see{define-xpath-function/lazy}
@see{define-xpath-function/eager}

Package

xpath.

Source

extensions.lisp.

Macro: deflexer (name-and-options &body rules)
Package

xpath.

Source

lexer.lisp.

Macro: lambda* ((&rest args) &body body)
Package

xpath.

Source

parser.lisp.

Macro: make-pipe (head tail)

@arg[head]{pipe head (evaluated)}
@arg[tail]{tail expression}
@return{a pipe}
@short{Constructs a pipe (lazy list).}

The @code{head} expression is evaluated immediatelly. The value of @code{head} will be returned by @fun{pipe-head} called for the pipe object returned by @code{make-pipe}. Evaluation of @code{tail} expression is delayed until @fun{pipe-tail} is called for the pipe returned by this function. Evaluation of @code{tail} expression should produce a pipe or a list.

Package

xpath.

Source

pipes.lisp.

Macro: map-node-sets->list (func &rest node-sets)

@arg[func]{a function}
@arg[node-sets]{@class{node-set}}
@return{a list}
@short{Calls @code{func} with N arguments for each N-tuple of nodes on the N lists of @code{node-sets} 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 the nodes in @code{node-sets} internally.

Package

xpath.

Source

api.lisp.

Macro: with-float-traps-masked ((&optional) &body body)
Package

xpath.

Source

xnum-ieee.lisp.


4.2.4 Ordinary functions

Function: %append-pipes (pipex pipey-fun)
Package

xpath.

Source

pipes.lisp.

Function: %compile-subpattern (subpattern environment)
Package

xpath.

Source

patterns.lisp.

Function: %define-extension (name uri documentation)
Package

xpath.

Source

extensions.lisp.

Function: %make-node-set-iterator (pipe)
Package

xpath.

Source

api.lisp.

Function: %make-pattern (key thunk priority value expression)
Package

xpath.

Source

patterns.lisp.

Function: %namespace-binding-pair (prefix uri)
Package

xpath.

Source

environment.lisp.

Function: %variable-binding-pair (qname value)
Package

xpath.

Source

environment.lisp.

Function: add-xpath-function (ext name func arglist)
Package

xpath.

Source

extensions.lisp.

Function: arg-count (arglist)
Package

xpath.

Source

extensions.lisp.

Function: axis-ancestor (node)
Package

xpath.

Source

axes.lisp.

Function: axis-ancestor-or-self (node)
Package

xpath.

Source

axes.lisp.

Function: axis-attribute (node)
Package

xpath.

Source

axes.lisp.

Function: axis-child (node)
Package

xpath.

Source

axes.lisp.

Function: axis-descendant (node)
Package

xpath.

Source

axes.lisp.

Function: axis-descendant-or-self (node)
Package

xpath.

Source

axes.lisp.

Function: axis-following (node)
Package

xpath.

Source

axes.lisp.

Function: axis-following-sibling (node)
Package

xpath.

Source

axes.lisp.

Function: axis-function (axis)
Package

xpath.

Source

axes.lisp.

Function: axis-namespace (node)
Package

xpath.

Source

axes.lisp.

Function: axis-parent (node)
Package

xpath.

Source

axes.lisp.

Function: axis-preceding (node)
Package

xpath.

Source

axes.lisp.

Function: axis-preceding-sibling (node)
Package

xpath.

Source

axes.lisp.

Function: axis-principal-node-type (axis)
Package

xpath.

Source

axes.lisp.

Function: axis-properties (axis)
Package

xpath.

Source

axes.lisp.

Function: axis-reverse-descendant-or-self (node)
Package

xpath.

Source

axes.lisp.

Function: axis-root (node)
Package

xpath.

Source

axes.lisp.

Function: axis-self (node)
Package

xpath.

Source

axes.lisp.

Function: compare-node-sets (op a b)
Package

xpath.

Source

types.lisp.

Function: compare-numbers (op a b)
Package

xpath.

Source

xnum-ieee.lisp.

Function: compare-values (op a b)
Package

xpath.

Source

types.lisp.

Function: compare-with-node-set (op node-set value)
Package

xpath.

Source

types.lisp.

Function: compare/no-node-sets (op a b)
Package

xpath.

Source

types.lisp.

Function: compile-filter-path (filter predicate path environment)
Package

xpath.

Source

xpath.lisp.

Function: compile-location-step (step-spec environment)
Package

xpath.

Source

xpath.lisp.

Function: compile-node-test (node-test environment attributep)
Package

xpath.

Source

xpath.lisp.

Function: compile-path (path environment)
Package

xpath.

Source

xpath.lisp.

Function: compile-pattern-expression (pattern environment)
Package

xpath.

Source

patterns.lisp.

Function: compile-pattern-expression/sexpr (pattern environment)
Package

xpath.

Source

patterns.lisp.

Function: compile-predicates (predicates environment)
Package

xpath.

Source

xpath.lisp.

Function: compile-subpattern (subpattern environment)
Package

xpath.

Source

patterns.lisp.

Function: compile-variable (name environment)
Package

xpath.

Source

xpath.lisp.

Function: compile-xpath-function-call (xpath-function argument-thunks)
Package

xpath.

Source

extensions.lisp.

Function: compile-xpath/sexpr (expr environment)
Package

xpath.

Source

xpath.lisp.

Function: copy-dom-namespace (instance)
Package

xpath.

Source

protocol.lisp.

Function: copy-dynamic-environment (instance)
Package

xpath.

Source

environment.lisp.

Function: copy-environment (instance)
Package

xpath.

Source

environment.lisp.

Function: copy-extension (instance)
Package

xpath.

Source

extensions.lisp.

Function: copy-node-set-iterator (instance)
Package

xpath.

Source

api.lisp.

Function: copy-pattern (instance)
Package

xpath.

Source

patterns.lisp.

Function: copy-test-environment (instance)
Package

xpath.

Source

environment.lisp.

Function: copy-xpath-function (instance)
Package

xpath.

Source

extensions.lisp.

Function: decode-dynamic-qname (qname)
Package

xpath.

Source

environment.lisp.

Function: decode-qname (qname environment attributep)
Package

xpath.

Source

xpath.lisp.

Function: disable-profiling ()

@return{nil}
@short{Disables profiling.}

Disables profiling for future XPath compilations, but keeps recorded profiling samples for @fun{report}.

Previously returned closures that were created with profiling enabled will not record samples until profiling is re-activated.

@see{enable-profiling}

Package

xpath.

Source

profile.lisp.

Function: dom-namespace-p (object)
Package

xpath.

Source

protocol.lisp.

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

xpath.

Source

protocol.lisp.

Target Slot

parent.

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

xpath.

Source

protocol.lisp.

Target Slot

prefix.

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

xpath.

Source

protocol.lisp.

Target Slot

uri.

Reader: dynamic-environment-namespaces (instance)
Writer: (setf dynamic-environment-namespaces) (instance)
Package

xpath.

Source

environment.lisp.

Target Slot

namespaces.

Function: dynamic-environment-p (object)
Package

xpath.

Source

environment.lisp.

Function: enable-profiling (&optional verbosep)

@return{nil}
@short{Enables profiling.}

Resets any existing profile samples and enables profiling for future XPath compilations.

Previously returned closures that were created with profiling disabled are not affected by this setting, but closures created during an earlier profiling session will start sampling again.

But note that @fun{evaluate}, @fun{node-matches-p}, and @fun{pattern-case} will recompile their cached closure when this setting has changed.

Profiling is not thread safe.

@see{disable-profiling}
@see{report}

Package

xpath.

Source

profile.lisp.

Function: enumerate (pipe &key count key result)

@arg[pipe]{a pipe}
@arg[count]{a non-negative integer}
@arg[key]{a function}
@arg[result]{an object}
@return{the value of @key{result} (the value of @code{pipe} by default)} Goes through all or @code{count} elements of pipe,
possibly applying the @code{key} function.

Package

xpath.

Source

pipes.lisp.

Function: environment-p (object)
Package

xpath.

Source

environment.lisp.

Reader: extension-documentation (instance)
Writer: (setf extension-documentation) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

documentation.

Reader: extension-functions (instance)
Writer: (setf extension-functions) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

functions.

Function: extension-p (object)
Package

xpath.

Source

extensions.lisp.

Reader: extension-uri (instance)
Writer: (setf extension-uri) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

uri.

Function: filter-pipe (function pipe)
Package

xpath.

Source

pipes.lisp.

Function: find-dynamic-namespace (prefix)
Package

xpath.

Source

environment.lisp.

Function: find-in-pipe (item pipe &key test key)
Package

xpath.

Source

pipes.lisp.

Function: find-in-pipe-if (pred pipe &key key)
Package

xpath.

Source

pipes.lisp.

Function: find-namespace (prefix environment attributep)
Package

xpath.

Source

xpath.lisp.

Function: find-xpath-function (local-name uri)

@arg[local-name]{local part of the function name} @arg[uri]{namespace URI of the function}
@return[uri]{an XPath function object}
@short{Performs an XPath function lookup using standard lookup rules}

All defined extensions for the namespace specified by @code{uri} are scanned for function with specified @code{local-name}.

Package

xpath.

Source

extensions.lisp.

Function: finite-p (num)
Package

xpath.

Source

xnum-ieee.lisp.

Function: fmod (f g)
Package

xpath.

Source

xnum-ieee.lisp.

Function: force (pipe)
Package

xpath.

Source

pipes.lisp.

Function: get-lang-attribute (node)
Package

xpath.

Source

functions.lisp.

Function: get-node-id (node-or-node-set)

@arg[node-or-node-set]{a @class{node-set} or a single XML node} @return{an alphanumeric string}
@short{Generates an unique identifier for the first node @code{node-set} (or, if a node is specified, for that node).}

This function is similar to the generate-id() XSLT function, but its results are unique only within its document, whereas XSLT also prepends an ID designating the document.

Package

xpath.

Source

types.lisp.

Function: get-node-index (node)
Package

xpath.

Source

types.lisp.

Function: get-node-text (node)
Package

xpath.

Source

types.lisp.

Function: group-and-sort-samples (group-identical-expressions)
Package

xpath.

Source

profile.lisp.

Function: inf-p (num)
Package

xpath.

Source

xnum-ieee.lisp.

Function: long-to-double (l)
Package

xpath.

Source

xnum-ieee.lisp.

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

xpath.

Source

protocol.lisp.

Function: make-dynamic-environment (namespaces)
Package

xpath.

Source

environment.lisp.

Function: make-environment (&key)
Package

xpath.

Source

environment.lisp.

Function: make-extension (uri documentation &optional functions)
Package

xpath.

Source

extensions.lisp.

Function: make-fixup-lexer (next-lexer)
Package

xpath.

Source

lexer.lisp.

Function: make-function-name (x)
Package

xpath.

Source

parser.lisp.

Function: make-location-path (steps)
Package

xpath.

Source

xpath.lisp.

Function: make-location-step (axis node-test predicates environment)
Package

xpath.

Source

xpath.lisp.

Function: make-node-set (pipe &optional ordering)

@arg[pipe]{a pipe}
@arg[ordering]{one of :document-order, :reverse-document-order, :unordered}
@return{a @class{node-set}}
Makes a @class{node-set} containing nodes from the @code{pipe} with specified @code{ordering}.

Package

xpath.

Source

types.lisp.

Function: make-reverse-location-path (starting-node-check steps predicate-checks)
Package

xpath.

Source

patterns.lisp.

Function: make-reverse-location-step (step environment)
Package

xpath.

Source

patterns.lisp.

Function: make-reverse-predicate-check (step environment)
Package

xpath.

Source

patterns.lisp.

Function: make-test-environment (&key)
Package

xpath.

Source

environment.lisp.

Function: make-xpath-function (compiler name min-args max-args)
Package

xpath.

Source

extensions.lisp.

Function: map-pipe (function pipe)
Package

xpath.

Source

pipes.lisp.

Function: map-pipe-filtering (fn pipe &optional filter-test)

Map fn over pipe, delaying all but the first fn call, collecting results

Package

xpath.

Source

pipes.lisp.

Function: mappend-pipe (fn pipe)

lazily map fn over pipe, appending results

Package

xpath.

Source

pipes.lisp.

Function: mappend-pipe-filtering (fn pipe &optional filter-test)

Map fn over pipe, delaying all but the first fn call, appending results, filtering along the way

Package

xpath.

Source

pipes.lisp.

Function: maybe-wrap-profiling (key fun)
Package

xpath.

Source

profile.lisp.

Function: namep (str)
Package

xpath.

Source

lexer.lisp.

Function: namespaces-match-p (old-bindings cur-bindings)
Package

xpath.

Source

api.lisp.

Function: nan-p (xnum)
Package

xpath.

Source

xnum-ieee.lisp.

Function: nc-name-p (str)
Package

xpath.

Source

lexer.lisp.

Function: node-set-iterator-p (object)
Package

xpath.

Source

api.lisp.

Reader: node-set-iterator-pipe (instance)
Writer: (setf node-set-iterator-pipe) (instance)
Package

xpath.

Source

api.lisp.

Target Slot

pipe.

Function: node-test-comment ()
Package

xpath.

Source

node-tests.lisp.

Function: node-test-name (local-name &optional uri)
Package

xpath.

Source

node-tests.lisp.

Function: node-test-namespace (uri)
Package

xpath.

Source

node-tests.lisp.

Function: node-test-node ()
Package

xpath.

Source

node-tests.lisp.

Function: node-test-principal ()
Package

xpath.

Source

node-tests.lisp.

Function: node-test-processing-instruction (&optional name)
Package

xpath.

Source

node-tests.lisp.

Function: node-test-text-node ()
Package

xpath.

Source

node-tests.lisp.

Function: node-type (node)
Package

xpath.

Source

patterns.lisp.

Function: node< (a b)

Compare nodes according to document order.

Package

xpath.

Source

types.lisp.

Function: parent-pipe (node)
Package

xpath.

Source

protocol.lisp.

Function: parse-xnum (str)
Package

xpath.

Source

xnum-ieee.lisp.

Reader: pattern-expression (instance)
Writer: (setf pattern-expression) (instance)
Package

xpath.

Source

patterns.lisp.

Target Slot

expression.

Reader: pattern-key (instance)
Writer: (setf pattern-key) (instance)
Package

xpath.

Source

patterns.lisp.

Target Slot

key.

Function: pattern-p (object)
Package

xpath.

Source

patterns.lisp.

Reader: pattern-thunk (instance)
Writer: (setf pattern-thunk) (instance)
Package

xpath.

Source

patterns.lisp.

Target Slot

thunk.

Function: pipe-elt (n pipe)
Package

xpath.

Source

pipes.lisp.

Function: pipe-empty-p (pipe)
Package

xpath.

Source

pipes.lisp.

Function: pipe-head (pipe)

@arg[pipe]{a pipe}
@return{an object}
Returns the head of the @code{pipe}.

Package

xpath.

Source

pipes.lisp.

Function: pipe-length (pipe)
Package

xpath.

Source

pipes.lisp.

Function: pipe-of (node-set)

@arg[node-set]{a @class{node-set}}
@return{a pipe}
Returns the pipe that contains the elements of the @code{node-set}.

Package

xpath.

Source

types.lisp.

Function: (setf pipe-of) (node-set)

@arg[pipe]{a pipe}
@arg[node-set]{a @class{node-set}}
@return{the value of @code{pipe}}
Sets the pipe that contains the element sof the @code{node-set}.

Package

xpath.

Source

types.lisp.

Function: pipe-tail (pipe)

@arg[pipe]{a pipe}
@return{an object}
@short{Returns the tail of the list.}

First time @code{pipe-tail} is called it causes pipe tail expression to be evaluated and remembered for later calls.

Package

xpath.

Source

pipes.lisp.

Function: preprocess-number-str (str)
Package

xpath.

Source

xnum-ieee.lisp.

Function: report (&key group-identical-expressions)

@arg[group-identical-expressions]{Boolean, indicates whether times recorded for closures that were compiled separately, but for the same expression, are to be summed together. Default is T.} @short{Shows profiling output.}

Shows cumulative run time and real time, number of calls, and average run time for each XPath expression or XPattern matcher that was invoked. @see{enable-profiling}
@see{disable-profiling}

Package

xpath.

Source

profile.lisp.

Function: report-xpath (grouped-samples)
Package

xpath.

Source

profile.lisp.

Function: report-xpattern (grouped-samples)
Package

xpath.

Source

profile.lisp.

Function: round-to-integer (a)
Package

xpath.

Source

xnum-ieee.lisp.

Function: same-expr-p (prev-expr xpath cur-bindings)
Package

xpath.

Source

api.lisp.

Function: sort-nodes (pipe)
Package

xpath.

Source

types.lisp.

Function: sort-pipe (pipe &optional ordering)
Package

xpath.

Source

types.lisp.

Function: sorted-pipe-of (node-set)
Package

xpath.

Source

types.lisp.

Function: step-key (step environment)
Package

xpath.

Source

patterns.lisp.

Function: stringify-pattern-expression (expr)
Package

xpath.

Source

profile.lisp.

Function: stringify-pattern-expressions (patterns)
Package

xpath.

Source

profile.lisp.

Function: subpattern-key (subpattern environment)
Package

xpath.

Source

patterns.lisp.

Function: subpipe-after (elt pipe &key test)
Package

xpath.

Source

pipes.lisp.

Function: subpipe-before (elt pipe &key test)
Package

xpath.

Source

pipes.lisp.

Function: test-environment-p (object)
Package

xpath.

Source

environment.lisp.

Function: textually-first-node (node-set)
Package

xpath.

Source

types.lisp.

Function: valid-expression-p (expr)
Package

xpath.

Source

patterns.lisp.

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

xpath.

Source

protocol.lisp.

Function: wrap-profiling (key fun)
Package

xpath.

Source

profile.lisp.

Function: write-node-test (node-test s)
Package

xpath.

Source

profile.lisp.

Function: x-minusp (xnum)
Package

xpath.

Source

xnum-ieee.lisp.

Function: x-plusp (xnum)
Package

xpath.

Source

xnum-ieee.lisp.

Function: x-zerop (xnum)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xf-and (exprs)
Package

xpath.

Source

functions.lisp.

Function: xf-equal (u v)
Package

xpath.

Source

functions.lisp.

Function: xf-location-path (path)
Package

xpath.

Source

xpath.lisp.

Function: xf-or (exprs)
Package

xpath.

Source

functions.lisp.

Function: xf-true ()
Package

xpath.

Source

xpath.lisp.

Function: xf-value (x)
Package

xpath.

Source

xpath.lisp.

Function: xfd-* (thunks-41)
Package

xpath.

Source

functions.lisp.

Function: xfd-+ (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-- (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-/ (thunks-81)
Package

xpath.

Source

functions.lisp.

Function: xfd-/= (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-< (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-<= (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-= (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-> (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd->= (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-and (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-boolean (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-ceiling (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-concat (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-contains (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-count (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-current (thunks-0)
Package

xpath.

Source

plx.lisp.

Function: xfd-false (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-floor (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-generate-id (thunks-0)
Package

xpath.

Source

plx.lisp.

Function: xfd-id (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-lang (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-last (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-local-name (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-matches (thunks-0)
Package

xpath.

Source

plx.lisp.

Function: xfd-mod (thunks-121)
Package

xpath.

Source

functions.lisp.

Function: xfd-name (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-namespace-uri (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-normalize-space (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-not (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-number (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-or (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-position (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-replace (thunks-0)
Package

xpath.

Source

plx.lisp.

Function: xfd-round (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-starts-with (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-string (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-string-length (thunks-0)
Package

xpath.

Source

functions.lisp.

Function: xfd-substring (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-substring-after (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-substring-before (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-sum (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-translate (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-true (thunks-1)
Package

xpath.

Source

functions.lisp.

Function: xfd-union (thunks-1)
Package

xpath.

Source

functions.lisp.

Reader: xmls-attribute-local-name (instance)
Writer: (setf xmls-attribute-local-name) (instance)
Package

cxml-xmls.

Source

xmls-compat.lisp.

Target Slot

local-name.

Reader: xmls-attribute-uri (instance)
Writer: (setf xmls-attribute-uri) (instance)
Package

cxml-xmls.

Source

xmls-compat.lisp.

Target Slot

uri.

Reader: xmls-attribute-value (instance)
Writer: (setf xmls-attribute-value) (instance)
Package

cxml-xmls.

Source

xmls-compat.lisp.

Target Slot

value.

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

cxml-xmls.

Source

xmls-compat.lisp.

Target Slot

parent.

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

cxml-xmls.

Source

xmls-compat.lisp.

Target Slot

uri.

Function: xnum-* (a b)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-+ (a b)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-- (a &optional b)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-/ (a b)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum->string (xnum)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-ceiling (a)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-floor (a)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-mod (f g)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-p (value)
Package

xpath.

Source

xnum-ieee.lisp.

Function: xnum-round (a)
Package

xpath.

Source

xnum-ieee.lisp.

Reader: xpath-function-compiler (instance)
Writer: (setf xpath-function-compiler) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

compiler.

Reader: xpath-function-max-args (instance)
Writer: (setf xpath-function-max-args) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

max-args.

Reader: xpath-function-min-args (instance)
Writer: (setf xpath-function-min-args) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

min-args.

Reader: xpath-function-name (instance)
Writer: (setf xpath-function-name) (instance)
Package

xpath.

Source

extensions.lisp.

Target Slot

name.

Function: xpath-function-p (object)
Package

xpath.

Source

extensions.lisp.

Function: xpath-lexer (str)
Package

xpath.

Source

lexer.lisp.


4.2.5 Generic functions

Generic Function: environment-find-function (environment local-name uri)

@arg[environment]{an XPath environment object}
@arg[local-name]{local part of expanded-name of the function} @arg[uri]{namespace URI of the function}
@return{an XPath function or nil if it cannot be found} @short{Finds an XPath function by @code{local-name} and @code{uri}}.

XPath function is a Lisp function that takes zero or more "thunks" as its arguments (corresponding to XPath expressions passed as function arguments) and returns a new "thunk". A "thunk" is a function
that takes an instance of @class{context} as its argument and returns the value of one of XPath types.

Package

xpath.

Source

environment.lisp.

Methods
Method: environment-find-function ((environment test-environment) lname uri)
Method: environment-find-function ((environment dynamic-environment) lname uri)
Generic Function: environment-find-namespace (environment prefix)

@arg[environment]{an XPath environment object} @arg[prefix]{prefix part of a QName}
Returns namespace URI for specified @code{prefix}.

Package

xpath.

Source

environment.lisp.

Methods
Method: environment-find-namespace ((environment test-environment) prefix)
Method: environment-find-namespace ((environment dynamic-environment) prefix)
Generic Function: environment-find-variable (environment local-name uri)

@arg[environment]{an XPath environment object} @arg[local-name]{local part of expanded-name of the function} @arg[uri]{namespace URI of the function}
@return{XPath variable "thunk"}
@short{Finds an XPath variable by @code{local-name} and @code{uri}}.
XPath variable is represented by a "thunk". A "thunk" is a function that takes an instance of @class{context} as its argument and returns the value of one of XPath types.

Package

xpath.

Source

environment.lisp.

Methods
Method: environment-find-variable ((environment test-environment) lname uri)
Method: environment-find-variable ((environment dynamic-environment) lname uri)
Generic Reader: ordering-of (object)
Package

xpath.

Methods
Reader Method: ordering-of ((node-set node-set))

automatically generated reader method

Source

types.lisp.

Target Slot

ordering.

Generic Writer: (setf ordering-of) (object)
Package

xpath.

Methods
Writer Method: (setf ordering-of) ((node-set node-set))

automatically generated writer method

Source

types.lisp.

Target Slot

ordering.


4.2.6 Structures

Structure: dom-namespace
Package

xpath.

Source

protocol.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: parent
Readers

dom-namespace-parent.

Writers

(setf dom-namespace-parent).

Slot: prefix
Readers

dom-namespace-prefix.

Writers

(setf dom-namespace-prefix).

Slot: uri
Readers

dom-namespace-uri.

Writers

(setf dom-namespace-uri).

Structure: dynamic-environment
Package

xpath.

Source

environment.lisp.

Direct superclasses

environment.

Direct methods
Direct slots
Slot: namespaces
Readers

dynamic-environment-namespaces.

Writers

(setf dynamic-environment-namespaces).

Structure: environment
Package

xpath.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct subclasses
Structure: extension
Package

xpath.

Source

extensions.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: uri
Readers

extension-uri.

Writers

(setf extension-uri).

Slot: documentation
Package

common-lisp.

Readers

extension-documentation.

Writers

(setf extension-documentation).

Slot: functions
Readers

extension-functions.

Writers

(setf extension-functions).

Structure: node-set-iterator
Package

xpath.

Source

api.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: pipe
Readers

node-set-iterator-pipe.

Writers

(setf node-set-iterator-pipe).

Structure: test-environment
Package

xpath.

Source

environment.lisp.

Direct superclasses

environment.

Direct methods
Structure: xmls-attribute
Package

cxml-xmls.

Source

xmls-compat.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: local-name
Readers

xmls-attribute-local-name.

Writers

(setf xmls-attribute-local-name).

Slot: uri
Readers

xmls-attribute-uri.

Writers

(setf xmls-attribute-uri).

Slot: value
Readers

xmls-attribute-value.

Writers

(setf xmls-attribute-value).

Structure: xmls-namespace
Package

cxml-xmls.

Source

xmls-compat.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: parent
Readers

xmls-namespace-parent.

Writers

(setf xmls-namespace-parent).

Slot: uri
Readers

xmls-namespace-uri.

Writers

(setf xmls-namespace-uri).

Structure: xpath-function
Package

xpath.

Source

extensions.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: compiler
Readers

xpath-function-compiler.

Writers

(setf xpath-function-compiler).

Slot: name
Readers

xpath-function-name.

Writers

(setf xpath-function-name).

Slot: min-args
Readers

xpath-function-min-args.

Writers

(setf xpath-function-min-args).

Slot: max-args
Readers

xpath-function-max-args.

Writers

(setf xpath-function-max-args).


4.2.7 Types

Type: pattern-expr ()
Package

xpath.

Source

patterns.lisp.

Type: xnum ()
Package

xpath.

Source

xnum-ieee.lisp.

Type: xpath-expr ()
Package

xpath.

Source

api.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%append-pipes: Private ordinary functions
%compile-subpattern: Private ordinary functions
%define-extension: Private ordinary functions
%define-xpath-function/eager: Private macros
%make-node-set-iterator: Private ordinary functions
%make-pattern: Private ordinary functions
%namespace-binding-pair: Private ordinary functions
%variable-binding-pair: Private ordinary functions

(
(setf context-node): Public ordinary functions
(setf context-position): Public ordinary functions
(setf context-size): Public ordinary functions
(setf context-starting-node): Public ordinary functions
(setf dom-namespace-parent): Private ordinary functions
(setf dom-namespace-prefix): Private ordinary functions
(setf dom-namespace-uri): Private ordinary functions
(setf dynamic-environment-namespaces): Private ordinary functions
(setf extension-documentation): Private ordinary functions
(setf extension-functions): Private ordinary functions
(setf extension-uri): Private ordinary functions
(setf node-set-iterator-pipe): Private ordinary functions
(setf ordering-of): Private generic functions
(setf ordering-of): Private generic functions
(setf pattern-expression): Private ordinary functions
(setf pattern-key): Private ordinary functions
(setf pattern-priority): Public ordinary functions
(setf pattern-thunk): Private ordinary functions
(setf pattern-value): Public ordinary functions
(setf pipe-of): Private ordinary functions
(setf xmls-attribute-local-name): Private ordinary functions
(setf xmls-attribute-uri): Private ordinary functions
(setf xmls-attribute-value): Private ordinary functions
(setf xmls-namespace-parent): Private ordinary functions
(setf xmls-namespace-uri): Private ordinary functions
(setf xpath-function-compiler): Private ordinary functions
(setf xpath-function-max-args): Private ordinary functions
(setf xpath-function-min-args): Private ordinary functions
(setf xpath-function-name): Private ordinary functions

A
add-xpath-function: Private ordinary functions
all-nodes: Public ordinary functions
append-pipes: Private macros
arg-count: Private ordinary functions
attribute-pipe: Public ordinary functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
attribute-pipe-using-navigator: Public generic functions
axis-ancestor: Private ordinary functions
axis-ancestor-or-self: Private ordinary functions
axis-attribute: Private ordinary functions
axis-child: Private ordinary functions
axis-descendant: Private ordinary functions
axis-descendant-or-self: Private ordinary functions
axis-following: Private ordinary functions
axis-following-sibling: Private ordinary functions
axis-function: Private ordinary functions
axis-namespace: Private ordinary functions
axis-parent: Private ordinary functions
axis-preceding: Private ordinary functions
axis-preceding-sibling: Private ordinary functions
axis-principal-node-type: Private ordinary functions
axis-properties: Private ordinary functions
axis-reverse-descendant-or-self: Private ordinary functions
axis-root: Private ordinary functions
axis-self: Private ordinary functions

B
base-uri: Public ordinary functions
base-uri-using-navigator: Public generic functions
base-uri-using-navigator: Public generic functions
base-uri-using-navigator: Public generic functions
boolean-value: Public ordinary functions

C
child-pipe: Public ordinary functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
child-pipe-using-navigator: Public generic functions
compare-node-sets: Private ordinary functions
compare-numbers: Private ordinary functions
compare-values: Private ordinary functions
compare-with-node-set: Private ordinary functions
compare/no-node-sets: Private ordinary functions
compile-filter-path: Private ordinary functions
compile-location-step: Private ordinary functions
compile-node-test: Private ordinary functions
compile-path: Private ordinary functions
compile-pattern-expression: Private ordinary functions
compile-pattern-expression/sexpr: Private ordinary functions
compile-predicates: Private ordinary functions
compile-subpattern: Private ordinary functions
compile-variable: Private ordinary functions
compile-xpath: Public ordinary functions
compile-xpath-function-call: Private ordinary functions
compile-xpath/sexpr: Private ordinary functions
Compiler Macro, evaluate: Public compiler macros
Compiler Macro, node-matches-p: Public compiler macros
compute-patterns: Public ordinary functions
concat: Public ordinary functions
context-node: Public ordinary functions
context-position: Public ordinary functions
context-size: Public ordinary functions
context-starting-node: Public ordinary functions
copy-dom-namespace: Private ordinary functions
copy-dynamic-environment: Private ordinary functions
copy-environment: Private ordinary functions
copy-extension: Private ordinary functions
copy-node-set-iterator: Private ordinary functions
copy-pattern: Private ordinary functions
copy-test-environment: Private ordinary functions
copy-xpath-function: Private ordinary functions

D
decode-dynamic-qname: Private ordinary functions
decode-qname: Private ordinary functions
define-axis: Private macros
define-default-method: Public macros
define-extension: Private macros
define-fixup-lexer: Private macros
define-regex-function: Private macros
define-xpath-function/eager: Private macros
define-xpath-function/lazy: Private macros
define-xpath-function/single-type: Private macros
deflexer: Private macros
disable-profiling: Private ordinary functions
do-node-set: Public macros
dom-namespace-p: Private ordinary functions
dom-namespace-parent: Private ordinary functions
dom-namespace-prefix: Private ordinary functions
dom-namespace-uri: Private ordinary functions
dynamic-environment-namespaces: Private ordinary functions
dynamic-environment-p: Private ordinary functions

E
enable-profiling: Private ordinary functions
enumerate: Private ordinary functions
environment-find-function: Private generic functions
environment-find-function: Private generic functions
environment-find-function: Private generic functions
environment-find-namespace: Private generic functions
environment-find-namespace: Private generic functions
environment-find-namespace: Private generic functions
environment-find-variable: Private generic functions
environment-find-variable: Private generic functions
environment-find-variable: Private generic functions
environment-p: Private ordinary functions
evaluate: Public compiler macros
evaluate: Public ordinary functions
evaluate-compiled: Public ordinary functions
extension-documentation: Private ordinary functions
extension-functions: Private ordinary functions
extension-p: Private ordinary functions
extension-uri: Private ordinary functions

F
filter-pipe: Private ordinary functions
find-dynamic-namespace: Private ordinary functions
find-in-pipe: Private ordinary functions
find-in-pipe-if: Private ordinary functions
find-namespace: Private ordinary functions
find-xpath-function: Private ordinary functions
finite-p: Private ordinary functions
first-node: Public ordinary functions
fmod: Private ordinary functions
force: Private ordinary functions
Function, %append-pipes: Private ordinary functions
Function, %compile-subpattern: Private ordinary functions
Function, %define-extension: Private ordinary functions
Function, %make-node-set-iterator: Private ordinary functions
Function, %make-pattern: Private ordinary functions
Function, %namespace-binding-pair: Private ordinary functions
Function, %variable-binding-pair: Private ordinary functions
Function, (setf context-node): Public ordinary functions
Function, (setf context-position): Public ordinary functions
Function, (setf context-size): Public ordinary functions
Function, (setf context-starting-node): Public ordinary functions
Function, (setf dom-namespace-parent): Private ordinary functions
Function, (setf dom-namespace-prefix): Private ordinary functions
Function, (setf dom-namespace-uri): Private ordinary functions
Function, (setf dynamic-environment-namespaces): Private ordinary functions
Function, (setf extension-documentation): Private ordinary functions
Function, (setf extension-functions): Private ordinary functions
Function, (setf extension-uri): Private ordinary functions
Function, (setf node-set-iterator-pipe): Private ordinary functions
Function, (setf pattern-expression): Private ordinary functions
Function, (setf pattern-key): Private ordinary functions
Function, (setf pattern-priority): Public ordinary functions
Function, (setf pattern-thunk): Private ordinary functions
Function, (setf pattern-value): Public ordinary functions
Function, (setf pipe-of): Private ordinary functions
Function, (setf xmls-attribute-local-name): Private ordinary functions
Function, (setf xmls-attribute-uri): Private ordinary functions
Function, (setf xmls-attribute-value): Private ordinary functions
Function, (setf xmls-namespace-parent): Private ordinary functions
Function, (setf xmls-namespace-uri): Private ordinary functions
Function, (setf xpath-function-compiler): Private ordinary functions
Function, (setf xpath-function-max-args): Private ordinary functions
Function, (setf xpath-function-min-args): Private ordinary functions
Function, (setf xpath-function-name): Private ordinary functions
Function, add-xpath-function: Private ordinary functions
Function, all-nodes: Public ordinary functions
Function, arg-count: Private ordinary functions
Function, attribute-pipe: Public ordinary functions
Function, axis-ancestor: Private ordinary functions
Function, axis-ancestor-or-self: Private ordinary functions
Function, axis-attribute: Private ordinary functions
Function, axis-child: Private ordinary functions
Function, axis-descendant: Private ordinary functions
Function, axis-descendant-or-self: Private ordinary functions
Function, axis-following: Private ordinary functions
Function, axis-following-sibling: Private ordinary functions
Function, axis-function: Private ordinary functions
Function, axis-namespace: Private ordinary functions
Function, axis-parent: Private ordinary functions
Function, axis-preceding: Private ordinary functions
Function, axis-preceding-sibling: Private ordinary functions
Function, axis-principal-node-type: Private ordinary functions
Function, axis-properties: Private ordinary functions
Function, axis-reverse-descendant-or-self: Private ordinary functions
Function, axis-root: Private ordinary functions
Function, axis-self: Private ordinary functions
Function, base-uri: Public ordinary functions
Function, boolean-value: Public ordinary functions
Function, child-pipe: Public ordinary functions
Function, compare-node-sets: Private ordinary functions
Function, compare-numbers: Private ordinary functions
Function, compare-values: Private ordinary functions
Function, compare-with-node-set: Private ordinary functions
Function, compare/no-node-sets: Private ordinary functions
Function, compile-filter-path: Private ordinary functions
Function, compile-location-step: Private ordinary functions
Function, compile-node-test: Private ordinary functions
Function, compile-path: Private ordinary functions
Function, compile-pattern-expression: Private ordinary functions
Function, compile-pattern-expression/sexpr: Private ordinary functions
Function, compile-predicates: Private ordinary functions
Function, compile-subpattern: Private ordinary functions
Function, compile-variable: Private ordinary functions
Function, compile-xpath: Public ordinary functions
Function, compile-xpath-function-call: Private ordinary functions
Function, compile-xpath/sexpr: Private ordinary functions
Function, compute-patterns: Public ordinary functions
Function, concat: Public ordinary functions
Function, context-node: Public ordinary functions
Function, context-position: Public ordinary functions
Function, context-size: Public ordinary functions
Function, context-starting-node: Public ordinary functions
Function, copy-dom-namespace: Private ordinary functions
Function, copy-dynamic-environment: Private ordinary functions
Function, copy-environment: Private ordinary functions
Function, copy-extension: Private ordinary functions
Function, copy-node-set-iterator: Private ordinary functions
Function, copy-pattern: Private ordinary functions
Function, copy-test-environment: Private ordinary functions
Function, copy-xpath-function: Private ordinary functions
Function, decode-dynamic-qname: Private ordinary functions
Function, decode-qname: Private ordinary functions
Function, disable-profiling: Private ordinary functions
Function, dom-namespace-p: Private ordinary functions
Function, dom-namespace-parent: Private ordinary functions
Function, dom-namespace-prefix: Private ordinary functions
Function, dom-namespace-uri: Private ordinary functions
Function, dynamic-environment-namespaces: Private ordinary functions
Function, dynamic-environment-p: Private ordinary functions
Function, enable-profiling: Private ordinary functions
Function, enumerate: Private ordinary functions
Function, environment-p: Private ordinary functions
Function, evaluate: Public ordinary functions
Function, evaluate-compiled: Public ordinary functions
Function, extension-documentation: Private ordinary functions
Function, extension-functions: Private ordinary functions
Function, extension-p: Private ordinary functions
Function, extension-uri: Private ordinary functions
Function, filter-pipe: Private ordinary functions
Function, find-dynamic-namespace: Private ordinary functions
Function, find-in-pipe: Private ordinary functions
Function, find-in-pipe-if: Private ordinary functions
Function, find-namespace: Private ordinary functions
Function, find-xpath-function: Private ordinary functions
Function, finite-p: Private ordinary functions
Function, first-node: Public ordinary functions
Function, fmod: Private ordinary functions
Function, force: Private ordinary functions
Function, get-element-by-id: Public ordinary functions
Function, get-lang-attribute: Private ordinary functions
Function, get-node-id: Private ordinary functions
Function, get-node-index: Private ordinary functions
Function, get-node-text: Private ordinary functions
Function, group-and-sort-samples: Private ordinary functions
Function, hash-key: Public ordinary functions
Function, hypsym: Public ordinary functions
Function, inf-p: Private ordinary functions
Function, list->node-set: Public ordinary functions
Function, local-name: Public ordinary functions
Function, long-to-double: Private ordinary functions
Function, make-context: Public ordinary functions
Function, make-dom-namespace: Private ordinary functions
Function, make-dynamic-environment: Private ordinary functions
Function, make-environment: Private ordinary functions
Function, make-extension: Private ordinary functions
Function, make-fixup-lexer: Private ordinary functions
Function, make-function-name: Private ordinary functions
Function, make-location-path: Private ordinary functions
Function, make-location-step: Private ordinary functions
Function, make-node-set: Private ordinary functions
Function, make-node-set-iterator: Public ordinary functions
Function, make-pattern-matcher: Public ordinary functions
Function, make-pattern-matcher*: Public ordinary functions
Function, make-reverse-location-path: Private ordinary functions
Function, make-reverse-location-step: Private ordinary functions
Function, make-reverse-predicate-check: Private ordinary functions
Function, make-test-environment: Private ordinary functions
Function, make-xpath-function: Private ordinary functions
Function, map-node-set: Public ordinary functions
Function, map-node-set->list: Public ordinary functions
Function, map-pipe: Private ordinary functions
Function, map-pipe-filtering: Private ordinary functions
Function, mappend-pipe: Private ordinary functions
Function, mappend-pipe-filtering: Private ordinary functions
Function, matching-value: Public ordinary functions
Function, matching-values: Public ordinary functions
Function, maybe-progn: Public ordinary functions
Function, maybe-wrap-profiling: Private ordinary functions
Function, mklist: Public ordinary functions
Function, namep: Private ordinary functions
Function, namespace-pipe: Public ordinary functions
Function, namespace-prefix: Public ordinary functions
Function, namespace-uri: Public ordinary functions
Function, namespaces-match-p: Private ordinary functions
Function, nan-p: Private ordinary functions
Function, nc-name-p: Private ordinary functions
Function, node-equal: Public ordinary functions
Function, node-matches-p: Public ordinary functions
Function, node-p: Public ordinary functions
Function, node-set-empty-p: Public ordinary functions
Function, node-set-iterator-current: Public ordinary functions
Function, node-set-iterator-end-p: Public ordinary functions
Function, node-set-iterator-next: Public ordinary functions
Function, node-set-iterator-p: Private ordinary functions
Function, node-set-iterator-pipe: Private ordinary functions
Function, node-set-p: Public ordinary functions
Function, node-set-value: Public ordinary functions
Function, node-test-comment: Private ordinary functions
Function, node-test-name: Private ordinary functions
Function, node-test-namespace: Private ordinary functions
Function, node-test-node: Private ordinary functions
Function, node-test-principal: Private ordinary functions
Function, node-test-processing-instruction: Private ordinary functions
Function, node-test-text-node: Private ordinary functions
Function, node-text: Public ordinary functions
Function, node-type: Private ordinary functions
Function, node-type-p: Public ordinary functions
Function, node<: Private ordinary functions
Function, number-value: Public ordinary functions
Function, parent-node: Public ordinary functions
Function, parent-pipe: Private ordinary functions
Function, parse-pattern-expression: Public ordinary functions
Function, parse-xnum: Private ordinary functions
Function, parse-xpath: Public ordinary functions
Function, pattern-expression: Private ordinary functions
Function, pattern-key: Private ordinary functions
Function, pattern-p: Private ordinary functions
Function, pattern-priority: Public ordinary functions
Function, pattern-thunk: Private ordinary functions
Function, pattern-value: Public ordinary functions
Function, pipe-elt: Private ordinary functions
Function, pipe-empty-p: Private ordinary functions
Function, pipe-head: Private ordinary functions
Function, pipe-length: Private ordinary functions
Function, pipe-of: Private ordinary functions
Function, pipe-tail: Private ordinary functions
Function, preprocess-number-str: Private ordinary functions
Function, processing-instruction-target: Public ordinary functions
Function, proper-list-p: Public ordinary functions
Function, qualified-name: Public ordinary functions
Function, report: Private ordinary functions
Function, report-xpath: Private ordinary functions
Function, report-xpattern: Private ordinary functions
Function, round-to-integer: Private ordinary functions
Function, same-expr-p: Private ordinary functions
Function, sort-node-set: Public ordinary functions
Function, sort-nodes: Private ordinary functions
Function, sort-pipe: Private ordinary functions
Function, sorted-pipe-of: Private ordinary functions
Function, step-key: Private ordinary functions
Function, string-replace: Public ordinary functions
Function, string-value: Public ordinary functions
Function, stringify-pattern-expression: Private ordinary functions
Function, stringify-pattern-expressions: Private ordinary functions
Function, subpattern-key: Private ordinary functions
Function, subpipe-after: Private ordinary functions
Function, subpipe-before: Private ordinary functions
Function, test-environment-p: Private ordinary functions
Function, textually-first-node: Private ordinary functions
Function, trim: Public ordinary functions
Function, unparsed-entity-uri: Public ordinary functions
Function, valid-expression-p: Private ordinary functions
Function, vector->pipe: Private ordinary functions
Function, wrap-profiling: Private ordinary functions
Function, write-node-test: Private ordinary functions
Function, x-minusp: Private ordinary functions
Function, x-plusp: Private ordinary functions
Function, x-zerop: Private ordinary functions
Function, xf-and: Private ordinary functions
Function, xf-equal: Private ordinary functions
Function, xf-location-path: Private ordinary functions
Function, xf-or: Private ordinary functions
Function, xf-true: Private ordinary functions
Function, xf-value: Private ordinary functions
Function, xfd-*: Private ordinary functions
Function, xfd-+: Private ordinary functions
Function, xfd--: Private ordinary functions
Function, xfd-/: Private ordinary functions
Function, xfd-/=: Private ordinary functions
Function, xfd-<: Private ordinary functions
Function, xfd-<=: Private ordinary functions
Function, xfd-=: Private ordinary functions
Function, xfd->: Private ordinary functions
Function, xfd->=: Private ordinary functions
Function, xfd-and: Private ordinary functions
Function, xfd-boolean: Private ordinary functions
Function, xfd-ceiling: Private ordinary functions
Function, xfd-concat: Private ordinary functions
Function, xfd-contains: Private ordinary functions
Function, xfd-count: Private ordinary functions
Function, xfd-current: Private ordinary functions
Function, xfd-false: Private ordinary functions
Function, xfd-floor: Private ordinary functions
Function, xfd-generate-id: Private ordinary functions
Function, xfd-id: Private ordinary functions
Function, xfd-lang: Private ordinary functions
Function, xfd-last: Private ordinary functions
Function, xfd-local-name: Private ordinary functions
Function, xfd-matches: Private ordinary functions
Function, xfd-mod: Private ordinary functions
Function, xfd-name: Private ordinary functions
Function, xfd-namespace-uri: Private ordinary functions
Function, xfd-normalize-space: Private ordinary functions
Function, xfd-not: Private ordinary functions
Function, xfd-number: Private ordinary functions
Function, xfd-or: Private ordinary functions
Function, xfd-position: Private ordinary functions
Function, xfd-replace: Private ordinary functions
Function, xfd-round: Private ordinary functions
Function, xfd-starts-with: Private ordinary functions
Function, xfd-string: Private ordinary functions
Function, xfd-string-length: Private ordinary functions
Function, xfd-substring: Private ordinary functions
Function, xfd-substring-after: Private ordinary functions
Function, xfd-substring-before: Private ordinary functions
Function, xfd-sum: Private ordinary functions
Function, xfd-translate: Private ordinary functions
Function, xfd-true: Private ordinary functions
Function, xfd-union: Private ordinary functions
Function, xmls-attribute-local-name: Private ordinary functions
Function, xmls-attribute-uri: Private ordinary functions
Function, xmls-attribute-value: Private ordinary functions
Function, xmls-namespace-parent: Private ordinary functions
Function, xmls-namespace-uri: Private ordinary functions
Function, xnum-*: Private ordinary functions
Function, xnum-+: Private ordinary functions
Function, xnum--: Private ordinary functions
Function, xnum-/: Private ordinary functions
Function, xnum->string: Private ordinary functions
Function, xnum-ceiling: Private ordinary functions
Function, xnum-floor: Private ordinary functions
Function, xnum-mod: Private ordinary functions
Function, xnum-p: Private ordinary functions
Function, xnum-round: Private ordinary functions
Function, xpath-error: Public ordinary functions
Function, xpath-function-compiler: Private ordinary functions
Function, xpath-function-max-args: Private ordinary functions
Function, xpath-function-min-args: Private ordinary functions
Function, xpath-function-name: Private ordinary functions
Function, xpath-function-p: Private ordinary functions
Function, xpath-lexer: Private ordinary functions

G
Generic Function, (setf ordering-of): Private generic functions
Generic Function, attribute-pipe-using-navigator: Public generic functions
Generic Function, base-uri-using-navigator: Public generic functions
Generic Function, child-pipe-using-navigator: Public generic functions
Generic Function, environment-find-function: Private generic functions
Generic Function, environment-find-namespace: Private generic functions
Generic Function, environment-find-variable: Private generic functions
Generic Function, get-element-by-id-using-navigator: Public generic functions
Generic Function, hash-key-using-navigator: Public generic functions
Generic Function, local-name-using-navigator: Public generic functions
Generic Function, namespace-pipe-using-navigator: Public generic functions
Generic Function, namespace-prefix-using-navigator: Public generic functions
Generic Function, namespace-uri-using-navigator: Public generic functions
Generic Function, node-equal-using-navigator: Public generic functions
Generic Function, node-p-using-navigator: Public generic functions
Generic Function, node-text-using-navigator: Public generic functions
Generic Function, node-type-p-using-navigator: Public generic functions
Generic Function, ordering-of: Private generic functions
Generic Function, parent-node-using-navigator: Public generic functions
Generic Function, processing-instruction-target-using-navigator: Public generic functions
Generic Function, qualified-name-using-navigator: Public generic functions
Generic Function, unparsed-entity-uri-using-navigator: Public generic functions
get-element-by-id: Public ordinary functions
get-element-by-id-using-navigator: Public generic functions
get-element-by-id-using-navigator: Public generic functions
get-element-by-id-using-navigator: Public generic functions
get-lang-attribute: Private ordinary functions
get-node-id: Private ordinary functions
get-node-index: Private ordinary functions
get-node-text: Private ordinary functions
group-and-sort-samples: Private ordinary functions

H
hash-key: Public ordinary functions
hash-key-using-navigator: Public generic functions
hash-key-using-navigator: Public generic functions
hash-key-using-navigator: Public generic functions
hash-key-using-navigator: Public generic functions
hash-key-using-navigator: Public generic functions
hypsym: Public ordinary functions

I
inf-p: Private ordinary functions

L
lambda*: Private macros
list->node-set: Public ordinary functions
local-name: Public ordinary functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
local-name-using-navigator: Public generic functions
long-to-double: Private ordinary functions

M
Macro, %define-xpath-function/eager: Private macros
Macro, append-pipes: Private macros
Macro, define-axis: Private macros
Macro, define-default-method: Public macros
Macro, define-extension: Private macros
Macro, define-fixup-lexer: Private macros
Macro, define-regex-function: Private macros
Macro, define-xpath-function/eager: Private macros
Macro, define-xpath-function/lazy: Private macros
Macro, define-xpath-function/single-type: Private macros
Macro, deflexer: Private macros
Macro, do-node-set: Public macros
Macro, lambda*: Private macros
Macro, make-pipe: Private macros
Macro, map-node-sets->list: Private macros
Macro, once-only: Public macros
Macro, pattern-case: Public macros
Macro, pattern-ecase: Public macros
Macro, with-cache: Public macros
Macro, with-float-traps-masked: Private macros
Macro, with-gensyms: Public macros
Macro, with-namespaces: Public macros
Macro, with-plx-extensions: Public macros
Macro, with-variables: Public macros
Macro, xpath: Public macros
make-context: Public ordinary functions
make-dom-namespace: Private ordinary functions
make-dynamic-environment: Private ordinary functions
make-environment: Private ordinary functions
make-extension: Private ordinary functions
make-fixup-lexer: Private ordinary functions
make-function-name: Private ordinary functions
make-location-path: Private ordinary functions
make-location-step: Private ordinary functions
make-node-set: Private ordinary functions
make-node-set-iterator: Public ordinary functions
make-pattern-matcher: Public ordinary functions
make-pattern-matcher*: Public ordinary functions
make-pipe: Private macros
make-reverse-location-path: Private ordinary functions
make-reverse-location-step: Private ordinary functions
make-reverse-predicate-check: Private ordinary functions
make-test-environment: Private ordinary functions
make-xpath-function: Private ordinary functions
map-node-set: Public ordinary functions
map-node-set->list: Public ordinary functions
map-node-sets->list: Private macros
map-pipe: Private ordinary functions
map-pipe-filtering: Private ordinary functions
mappend-pipe: Private ordinary functions
mappend-pipe-filtering: Private ordinary functions
matching-value: Public ordinary functions
matching-values: Public ordinary functions
maybe-progn: Public ordinary functions
maybe-wrap-profiling: Private ordinary functions
Method, (setf ordering-of): Private generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, attribute-pipe-using-navigator: Public generic functions
Method, base-uri-using-navigator: Public generic functions
Method, base-uri-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, child-pipe-using-navigator: Public generic functions
Method, environment-find-function: Private generic functions
Method, environment-find-function: Private generic functions
Method, environment-find-namespace: Private generic functions
Method, environment-find-namespace: Private generic functions
Method, environment-find-variable: Private generic functions
Method, environment-find-variable: Private generic functions
Method, get-element-by-id-using-navigator: Public generic functions
Method, get-element-by-id-using-navigator: Public generic functions
Method, hash-key-using-navigator: Public generic functions
Method, hash-key-using-navigator: Public generic functions
Method, hash-key-using-navigator: Public generic functions
Method, hash-key-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, local-name-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-pipe-using-navigator: Public generic functions
Method, namespace-prefix-using-navigator: Public generic functions
Method, namespace-prefix-using-navigator: Public generic functions
Method, namespace-prefix-using-navigator: Public generic functions
Method, namespace-prefix-using-navigator: Public generic functions
Method, namespace-prefix-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, namespace-uri-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-equal-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-p-using-navigator: Public generic functions
Method, node-text-using-navigator: Public generic functions
Method, node-text-using-navigator: Public generic functions
Method, node-text-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, node-type-p-using-navigator: Public generic functions
Method, ordering-of: Private generic functions
Method, parent-node-using-navigator: Public generic functions
Method, parent-node-using-navigator: Public generic functions
Method, parent-node-using-navigator: Public generic functions
Method, parent-node-using-navigator: Public generic functions
Method, print-object: Public standalone methods
Method, processing-instruction-target-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, qualified-name-using-navigator: Public generic functions
Method, unparsed-entity-uri-using-navigator: Public generic functions
Method, unparsed-entity-uri-using-navigator: Public generic functions
mklist: Public ordinary functions

N
namep: Private ordinary functions
namespace-pipe: Public ordinary functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-pipe-using-navigator: Public generic functions
namespace-prefix: Public ordinary functions
namespace-prefix-using-navigator: Public generic functions
namespace-prefix-using-navigator: Public generic functions
namespace-prefix-using-navigator: Public generic functions
namespace-prefix-using-navigator: Public generic functions
namespace-prefix-using-navigator: Public generic functions
namespace-prefix-using-navigator: Public generic functions
namespace-uri: Public ordinary functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespace-uri-using-navigator: Public generic functions
namespaces-match-p: Private ordinary functions
nan-p: Private ordinary functions
nc-name-p: Private ordinary functions
node-equal: Public ordinary functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-equal-using-navigator: Public generic functions
node-matches-p: Public compiler macros
node-matches-p: Public ordinary functions
node-p: Public ordinary functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-p-using-navigator: Public generic functions
node-set-empty-p: Public ordinary functions
node-set-iterator-current: Public ordinary functions
node-set-iterator-end-p: Public ordinary functions
node-set-iterator-next: Public ordinary functions
node-set-iterator-p: Private ordinary functions
node-set-iterator-pipe: Private ordinary functions
node-set-p: Public ordinary functions
node-set-value: Public ordinary functions
node-test-comment: Private ordinary functions
node-test-name: Private ordinary functions
node-test-namespace: Private ordinary functions
node-test-node: Private ordinary functions
node-test-principal: Private ordinary functions
node-test-processing-instruction: Private ordinary functions
node-test-text-node: Private ordinary functions
node-text: Public ordinary functions
node-text-using-navigator: Public generic functions
node-text-using-navigator: Public generic functions
node-text-using-navigator: Public generic functions
node-text-using-navigator: Public generic functions
node-type: Private ordinary functions
node-type-p: Public ordinary functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node-type-p-using-navigator: Public generic functions
node<: Private ordinary functions
number-value: Public ordinary functions

O
once-only: Public macros
ordering-of: Private generic functions
ordering-of: Private generic functions

P
parent-node: Public ordinary functions
parent-node-using-navigator: Public generic functions
parent-node-using-navigator: Public generic functions
parent-node-using-navigator: Public generic functions
parent-node-using-navigator: Public generic functions
parent-node-using-navigator: Public generic functions
parent-pipe: Private ordinary functions
parse-pattern-expression: Public ordinary functions
parse-xnum: Private ordinary functions
parse-xpath: Public ordinary functions
pattern-case: Public macros
pattern-ecase: Public macros
pattern-expression: Private ordinary functions
pattern-key: Private ordinary functions
pattern-p: Private ordinary functions
pattern-priority: Public ordinary functions
pattern-thunk: Private ordinary functions
pattern-value: Public ordinary functions
pipe-elt: Private ordinary functions
pipe-empty-p: Private ordinary functions
pipe-head: Private ordinary functions
pipe-length: Private ordinary functions
pipe-of: Private ordinary functions
pipe-tail: Private ordinary functions
preprocess-number-str: Private ordinary functions
print-object: Public standalone methods
processing-instruction-target: Public ordinary functions
processing-instruction-target-using-navigator: Public generic functions
processing-instruction-target-using-navigator: Public generic functions
proper-list-p: Public ordinary functions

Q
qualified-name: Public ordinary functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions
qualified-name-using-navigator: Public generic functions

R
report: Private ordinary functions
report-xpath: Private ordinary functions
report-xpattern: Private ordinary functions
round-to-integer: Private ordinary functions

S
same-expr-p: Private ordinary functions
sort-node-set: Public ordinary functions
sort-nodes: Private ordinary functions
sort-pipe: Private ordinary functions
sorted-pipe-of: Private ordinary functions
step-key: Private ordinary functions
string-replace: Public ordinary functions
string-value: Public ordinary functions
stringify-pattern-expression: Private ordinary functions
stringify-pattern-expressions: Private ordinary functions
subpattern-key: Private ordinary functions
subpipe-after: Private ordinary functions
subpipe-before: Private ordinary functions

T
test-environment-p: Private ordinary functions
textually-first-node: Private ordinary functions
trim: Public ordinary functions

U
unparsed-entity-uri: Public ordinary functions
unparsed-entity-uri-using-navigator: Public generic functions
unparsed-entity-uri-using-navigator: Public generic functions
unparsed-entity-uri-using-navigator: Public generic functions

V
valid-expression-p: Private ordinary functions
vector->pipe: Private ordinary functions

W
with-cache: Public macros
with-float-traps-masked: Private macros
with-gensyms: Public macros
with-namespaces: Public macros
with-plx-extensions: Public macros
with-variables: Public macros
wrap-profiling: Private ordinary functions
write-node-test: Private ordinary functions

X
x-minusp: Private ordinary functions
x-plusp: Private ordinary functions
x-zerop: Private ordinary functions
xf-and: Private ordinary functions
xf-equal: Private ordinary functions
xf-location-path: Private ordinary functions
xf-or: Private ordinary functions
xf-true: Private ordinary functions
xf-value: Private ordinary functions
xfd-*: Private ordinary functions
xfd-+: Private ordinary functions
xfd--: Private ordinary functions
xfd-/: Private ordinary functions
xfd-/=: Private ordinary functions
xfd-<: Private ordinary functions
xfd-<=: Private ordinary functions
xfd-=: Private ordinary functions
xfd->: Private ordinary functions
xfd->=: Private ordinary functions
xfd-and: Private ordinary functions
xfd-boolean: Private ordinary functions
xfd-ceiling: Private ordinary functions
xfd-concat: Private ordinary functions
xfd-contains: Private ordinary functions
xfd-count: Private ordinary functions
xfd-current: Private ordinary functions
xfd-false: Private ordinary functions
xfd-floor: Private ordinary functions
xfd-generate-id: Private ordinary functions
xfd-id: Private ordinary functions
xfd-lang: Private ordinary functions
xfd-last: Private ordinary functions
xfd-local-name: Private ordinary functions
xfd-matches: Private ordinary functions
xfd-mod: Private ordinary functions
xfd-name: Private ordinary functions
xfd-namespace-uri: Private ordinary functions
xfd-normalize-space: Private ordinary functions
xfd-not: Private ordinary functions
xfd-number: Private ordinary functions
xfd-or: Private ordinary functions
xfd-position: Private ordinary functions
xfd-replace: Private ordinary functions
xfd-round: Private ordinary functions
xfd-starts-with: Private ordinary functions
xfd-string: Private ordinary functions
xfd-string-length: Private ordinary functions
xfd-substring: Private ordinary functions
xfd-substring-after: Private ordinary functions
xfd-substring-before: Private ordinary functions
xfd-sum: Private ordinary functions
xfd-translate: Private ordinary functions
xfd-true: Private ordinary functions
xfd-union: Private ordinary functions
xmls-attribute-local-name: Private ordinary functions
xmls-attribute-uri: Private ordinary functions
xmls-attribute-value: Private ordinary functions
xmls-namespace-parent: Private ordinary functions
xmls-namespace-uri: Private ordinary functions
xnum-*: Private ordinary functions
xnum-+: Private ordinary functions
xnum--: Private ordinary functions
xnum-/: Private ordinary functions
xnum->string: Private ordinary functions
xnum-ceiling: Private ordinary functions
xnum-floor: Private ordinary functions
xnum-mod: Private ordinary functions
xnum-p: Private ordinary functions
xnum-round: Private ordinary functions
xpath: Public macros
xpath-error: Public ordinary functions
xpath-function-compiler: Private ordinary functions
xpath-function-max-args: Private ordinary functions
xpath-function-min-args: Private ordinary functions
xpath-function-name: Private ordinary functions
xpath-function-p: Private ordinary functions
xpath-lexer: Private ordinary functions


A.3 Variables

Jump to:   *   +  
C   D   E   F   K   L   M   N   O   P   S   T   U   V  
Index Entry  Section

*
*allow-variables-in-patterns*: Public special variables
*dynamic-namespaces*: Private special variables
*dynamic-var-bindings*: Private special variables
*extensions*: Private special variables
*initial-namespaces*: Private special variables
*navigator*: Public special variables
*plx-uri*: Private special variables
*profiling-enabled-p*: Private special variables
*samples*: Private special variables
*xpath-parser*: Private special variables

+
+nan+: Private special variables

C
compiler: Private structures
Constant, empty-pipe: Private constants

D
documentation: Private structures

E
empty-pipe: Private constants
expression: Public structures

F
functions: Private structures

K
key: Public structures

L
local-name: Private structures

M
max-args: Private structures
min-args: Private structures

N
name: Private structures
namespaces: Private structures
node: Public classes

O
ordering: Public classes

P
parent: Private structures
parent: Private structures
pipe: Public classes
pipe: Private structures
position: Public classes
prefix: Private structures
priority: Public structures

S
size: Public classes
Slot, compiler: Private structures
Slot, documentation: Private structures
Slot, expression: Public structures
Slot, functions: Private structures
Slot, key: Public structures
Slot, local-name: Private structures
Slot, max-args: Private structures
Slot, min-args: Private structures
Slot, name: Private structures
Slot, namespaces: Private structures
Slot, node: Public classes
Slot, ordering: Public classes
Slot, parent: Private structures
Slot, parent: Private structures
Slot, pipe: Public classes
Slot, pipe: Private structures
Slot, position: Public classes
Slot, prefix: Private structures
Slot, priority: Public structures
Slot, size: Public classes
Slot, starting-node: Public classes
Slot, thunk: Public structures
Slot, uri: Private structures
Slot, uri: Private structures
Slot, uri: Private structures
Slot, uri: Private structures
Slot, value: Public structures
Slot, value: Private structures
Special Variable, *allow-variables-in-patterns*: Public special variables
Special Variable, *dynamic-namespaces*: Private special variables
Special Variable, *dynamic-var-bindings*: Private special variables
Special Variable, *extensions*: Private special variables
Special Variable, *initial-namespaces*: Private special variables
Special Variable, *navigator*: Public special variables
Special Variable, *plx-uri*: Private special variables
Special Variable, *profiling-enabled-p*: Private special variables
Special Variable, *samples*: Private special variables
Special Variable, *xpath-parser*: Private special variables
Special Variable, +nan+: Private special variables
starting-node: Public classes

T
thunk: Public structures

U
uri: Private structures
uri: Private structures
uri: Private structures
uri: Private structures

V
value: Public structures
value: Private structures


A.4 Data types

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

A
api.lisp: The xpath/api․lisp file
axes.lisp: The xpath/axes․lisp file

C
Class, context: Public classes
Class, node-set: Public classes
Condition, xpath-error: Public conditions
context: Public classes

D
dom-namespace: Private structures
dynamic-environment: Private structures

E
environment: Private structures
environment.lisp: The xpath/environment․lisp file
extension: Private structures
extensions.lisp: The xpath/extensions․lisp file

F
File, api.lisp: The xpath/api․lisp file
File, axes.lisp: The xpath/axes․lisp file
File, environment.lisp: The xpath/environment․lisp file
File, extensions.lisp: The xpath/extensions․lisp file
File, functions.lisp: The xpath/functions․lisp file
File, lexer.lisp: The xpath/lexer․lisp file
File, node-tests.lisp: The xpath/node-tests․lisp file
File, package.lisp: The xpath/package․lisp file
File, parser.lisp: The xpath/parser․lisp file
File, patterns.lisp: The xpath/patterns․lisp file
File, pipes.lisp: The xpath/pipes․lisp file
File, plx.lisp: The xpath/plx․lisp file
File, profile.lisp: The xpath/profile․lisp file
File, protocol.lisp: The xpath/protocol․lisp file
File, types.lisp: The xpath/types․lisp file
File, utils.lisp: The xpath/utils․lisp file
File, xmls-compat.lisp: The xpath/xmls-compat․lisp file
File, xnum-ieee.lisp: The xpath/xnum-ieee․lisp file
File, xpath.asd: The xpath/xpath․asd file
File, xpath.lisp: The xpath/xpath․lisp file
functions.lisp: The xpath/functions․lisp file

L
lexer.lisp: The xpath/lexer․lisp file

N
node-set: Public classes
node-set-iterator: Private structures
node-tests.lisp: The xpath/node-tests․lisp file

P
Package, xpath: The xpath package
Package, xpath-protocol: The xpath-protocol package
Package, xpath-sys: The xpath-sys package
Package, xpath-utils: The xpath-utils package
Package, xpattern: The xpattern package
package.lisp: The xpath/package․lisp file
parser.lisp: The xpath/parser․lisp file
pattern: Public structures
pattern-expr: Private types
patterns.lisp: The xpath/patterns․lisp file
pipes.lisp: The xpath/pipes․lisp file
plx.lisp: The xpath/plx․lisp file
profile.lisp: The xpath/profile․lisp file
protocol.lisp: The xpath/protocol․lisp file

S
Structure, dom-namespace: Private structures
Structure, dynamic-environment: Private structures
Structure, environment: Private structures
Structure, extension: Private structures
Structure, node-set-iterator: Private structures
Structure, pattern: Public structures
Structure, test-environment: Private structures
Structure, xmls-attribute: Private structures
Structure, xmls-namespace: Private structures
Structure, xpath-function: Private structures
System, xpath: The xpath system

T
test-environment: Private structures
Type, pattern-expr: Private types
Type, xnum: Private types
Type, xpath-expr: Private types
types.lisp: The xpath/types․lisp file

U
utils.lisp: The xpath/utils․lisp file

X
xmls-attribute: Private structures
xmls-compat.lisp: The xpath/xmls-compat․lisp file
xmls-namespace: Private structures
xnum: Private types
xnum-ieee.lisp: The xpath/xnum-ieee․lisp file
xpath: The xpath system
xpath: The xpath package
xpath-error: Public conditions
xpath-expr: Private types
xpath-function: Private structures
xpath-protocol: The xpath-protocol package
xpath-sys: The xpath-sys package
xpath-utils: The xpath-utils package
xpath.asd: The xpath/xpath․asd file
xpath.lisp: The xpath/xpath․lisp file
xpattern: The xpattern package