The plexippus-xpath Reference Manual

Table of Contents

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

The plexippus-xpath Reference Manual

This is the plexippus-xpath Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:25:33 2018 GMT+0.


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

1 Systems

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


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

1.1 xpath

Author

Ivan Shvedunov, David Lichteblau

Version

0.1

Dependencies
Source

xpath.asd (file)

Components

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

2 Files

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


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

2.1 Lisp


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

2.1.1 xpath.asd

Location

xpath.asd

Systems

xpath (system)

Packages

xpath.system


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

2.1.2 xpath/package.lisp

Parent

xpath (system)

Location

package.lisp

Packages

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

2.1.3 xpath/utils.lisp

Dependency

package.lisp (file)

Parent

xpath (system)

Location

utils.lisp

Internal Definitions

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

2.1.4 xpath/test.lisp

Dependency

utils.lisp (file)

Parent

xpath (system)

Location

test.lisp

Internal Definitions

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

2.1.5 xpath/pipes.lisp

Dependency

test.lisp (file)

Parent

xpath (system)

Location

pipes.lisp

Internal Definitions

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

2.1.6 xpath/protocol.lisp

Dependency

pipes.lisp (file)

Parent

xpath (system)

Location

protocol.lisp

Exported Definitions
Internal Definitions

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

2.1.7 xpath/xnum-ieee.lisp

Dependency

protocol.lisp (file)

Parent

xpath (system)

Location

xnum-ieee.lisp

Internal Definitions

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

2.1.8 xpath/types.lisp

Dependency

xnum-ieee.lisp (file)

Parent

xpath (system)

Location

types.lisp

Exported Definitions
Internal Definitions

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

2.1.9 xpath/extensions.lisp

Dependency

types.lisp (file)

Parent

xpath (system)

Location

extensions.lisp

Internal Definitions

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

2.1.10 xpath/environment.lisp

Dependency

extensions.lisp (file)

Parent

xpath (system)

Location

environment.lisp

Exported Definitions
Internal Definitions

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

2.1.11 xpath/axes.lisp

Dependency

environment.lisp (file)

Parent

xpath (system)

Location

axes.lisp

Internal Definitions

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

2.1.12 xpath/node-tests.lisp

Dependency

axes.lisp (file)

Parent

xpath (system)

Location

node-tests.lisp

Internal Definitions

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

2.1.13 xpath/xpath.lisp

Dependency

node-tests.lisp (file)

Parent

xpath (system)

Location

xpath.lisp

Internal Definitions

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

2.1.14 xpath/functions.lisp

Dependency

xpath.lisp (file)

Parent

xpath (system)

Location

functions.lisp

Internal Definitions

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

2.1.15 xpath/lexer.lisp

Dependency

functions.lisp (file)

Parent

xpath (system)

Location

lexer.lisp

Internal Definitions

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

2.1.16 xpath/parser.lisp

Dependency

lexer.lisp (file)

Parent

xpath (system)

Location

parser.lisp

Exported Definitions

parse-xpath (function)

Internal Definitions

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

2.1.17 xpath/api.lisp

Dependency

parser.lisp (file)

Parent

xpath (system)

Location

api.lisp

Exported Definitions
Internal Definitions

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

2.1.18 xpath/plx.lisp

Dependency

api.lisp (file)

Parent

xpath (system)

Location

plx.lisp

Exported Definitions

with-plx-extensions (macro)

Internal Definitions

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

2.1.19 xpath/xmls-compat.lisp

Dependency

plx.lisp (file)

Parent

xpath (system)

Location

xmls-compat.lisp

Exported Definitions

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

2.1.20 xpath/patterns.lisp

Dependency

xmls-compat.lisp (file)

Parent

xpath (system)

Location

patterns.lisp

Exported Definitions
Internal Definitions

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

2.1.21 xpath/profile.lisp

Dependency

patterns.lisp (file)

Parent

xpath (system)

Location

profile.lisp

Internal Definitions

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

2.1.22 xpath/xpath-test.lisp

Dependency

profile.lisp (file)

Parent

xpath (system)

Location

xpath-test.lisp

Internal Definitions

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

3 Packages

Packages are listed by definition order.


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

3.1 xpath.system

Source

xpath.asd

Use List

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

3.2 xpath-sys

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

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

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

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

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

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

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

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

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

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

Source

package.lisp (file)


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

3.3 xpath

Plexippus XPath is an XPath 1.0 implementation for Common Lisp.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

3.4 xpattern

The XPATTERN package implements pattern matching compatible with XSLT 1.0.

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

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

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

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

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

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

Source

package.lisp (file)

Used By List

xpath

Exported Definitions

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

3.5 xpath-protocol

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

Source

package.lisp (file)

Exported Definitions

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

4 Definitions

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


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

4.1 Exported definitions


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

4.1.1 Special variables

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

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

Package

xpattern

Source

patterns.lisp (file)

Special Variable: *navigator*
Package

xpath

Source

protocol.lisp (file)


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

4.1.2 Macros

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

xpath-protocol

Source

protocol.lisp (file)

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

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

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

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

Package

xpath

Source

api.lisp (file)

Macro: pattern-case NODE &body CLAUSES

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

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

Expressions are compiled using the dynamic environment.

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

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

Package

xpattern

Source

patterns.lisp (file)

Macro: pattern-ecase NODE &rest CLAUSES

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

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

Expressions are compiled using the dynamic environment.

If no clause matches, an error will be signalled.

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

Package

xpattern

Source

patterns.lisp (file)

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

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

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

Package

xpath

Source

environment.lisp (file)

Macro: with-plx-extensions &body BODY

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

The following functions are currently available:

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

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

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

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

Package

xpath

Source

plx.lisp (file)

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

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

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

Package

xpath

Source

environment.lisp (file)

Macro: xpath FORM

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

Package

xpath

Source

api.lisp (file)


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

4.1.3 Compiler macros

Compiler Macro: evaluate XPATH CONTEXT &optional UNORDERED-P
Package

xpath

Source

api.lisp (file)

Compiler Macro: node-matches-p NODE PATTERN
Package

xpattern

Source

patterns.lisp (file)


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

4.1.4 Functions

Function: all-nodes NODE-SET

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

Package

xpath

Source

api.lisp (file)

Function: attribute-pipe NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: base-uri NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: boolean-value VALUE

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

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

Package

xpath

Source

types.lisp (file)

Function: child-pipe NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: compile-xpath XPATH &optional ENVIRONMENT

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

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

Package

xpath

Source

api.lisp (file)

Function: compute-patterns EXPRESSION PRIORITY VALUE ENVIRONMENT

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

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

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

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

Package

xpattern

Source

patterns.lisp (file)

Function: context-node CONTEXT

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

Package

xpath

Source

types.lisp (file)

Writer

(setf context-node) (function)

Function: (setf context-node) NODE CONTEXT

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

Package

xpath

Source

types.lisp (file)

Reader

context-node (function)

Function: context-position CONTEXT

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

Package

xpath

Source

types.lisp (file)

Writer

(setf context-position) (function)

Function: (setf context-position) POSITION CONTEXT

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

Package

xpath

Source

types.lisp (file)

Reader

context-position (function)

Function: context-size CONTEXT

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

Package

xpath

Source

types.lisp (file)

Writer

(setf context-size) (function)

Function: (setf context-size) SIZE CONTEXT

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

Package

xpath

Source

types.lisp (file)

Reader

context-size (function)

Function: context-starting-node CONTEXT

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

Package

xpath

Source

types.lisp (file)

Writer

(setf context-starting-node) (function)

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

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

Package

xpath

Source

types.lisp (file)

Reader

context-starting-node (function)

Function: evaluate XPATH CONTEXT &optional UNORDERED-P

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

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

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

Package

xpath

Source

api.lisp (file)

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

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

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

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

Package

xpath

Source

api.lisp (file)

Function: first-node NODE-SET

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

Package

xpath

Source

api.lisp (file)

Function: get-element-by-id NODE ID
Package

xpath-protocol

Source

protocol.lisp (file)

Function: hash-key NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: list->node-set LIST

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

Package

xpath

Source

api.lisp (file)

Function: local-name NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

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

Package

xpath

Source

types.lisp (file)

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

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

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

Package

xpath

Source

api.lisp (file)

Function: make-pattern-matcher PATTERNS

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

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

@see{compute-patterns}

Package

xpattern

Source

patterns.lisp (file)

Function: make-pattern-matcher* EXPRESSION ENVIRONMENT

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

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

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

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

Package

xpattern

Source

patterns.lisp (file)

Function: map-node-set FUNC NODE-SET

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

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

Package

xpath

Source

api.lisp (file)

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

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

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

Package

xpath

Source

api.lisp (file)

Function: matching-value MATCHER NODE &optional DEFAULT

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

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

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

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

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

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

Package

xpattern

Source

patterns.lisp (file)

Function: matching-values MATCHER NODE

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

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

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

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

Package

xpattern

Source

patterns.lisp (file)

Function: namespace-pipe NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: namespace-prefix NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: namespace-uri NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-equal NODE OTHER
Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-matches-p NODE PATTERN-EXPRESSION

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

The expression is compiled using the dynamic environment.

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

Package

xpattern

Source

patterns.lisp (file)

Function: node-p NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

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

Package

xpath

Source

types.lisp (file)

Function: node-set-iterator-current ITERATOR

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

Package

xpath

Source

api.lisp (file)

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

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

Package

xpath

Source

api.lisp (file)

Function: node-set-iterator-next ITERATOR

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

Package

xpath

Source

api.lisp (file)

Function: node-set-p OBJECT

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

Package

xpath

Source

types.lisp (file)

Function: node-set-value VALUE

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

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

Package

xpath

Source

types.lisp (file)

Function: node-text NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: node-type-p NODE TYPE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: number-value VALUE

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

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

Package

xpath

Source

types.lisp (file)

Function: parent-node NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: parse-pattern-expression STR

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

Package

xpattern

Source

patterns.lisp (file)

Function: parse-xpath STR

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

Package

xpath

Source

parser.lisp (file)

Function: pattern-priority INSTANCE

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

Package

xpattern

Source

patterns.lisp (file)

Writer

(setf pattern-priority) (function)

Function: (setf pattern-priority) VALUE INSTANCE
Package

xpattern

Source

patterns.lisp (file)

Reader

pattern-priority (function)

Function: pattern-value INSTANCE

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

Package

xpattern

Source

patterns.lisp (file)

Writer

(setf pattern-value) (function)

Function: (setf pattern-value) VALUE INSTANCE
Package

xpattern

Source

patterns.lisp (file)

Reader

pattern-value (function)

Function: processing-instruction-target NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: qualified-name NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Function: sort-node-set NODE-SET

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

Package

xpath

Source

types.lisp (file)

Function: string-value VALUE

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

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

Package

xpath

Source

types.lisp (file)

Function: unparsed-entity-uri NODE NAME
Package

xpath-protocol

Source

protocol.lisp (file)

Function: xpath-error FMT &rest ARGS

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

Package

xpath

Source

api.lisp (file)


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

4.1.5 Generic functions

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

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: attribute-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: attribute-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)
Method: attribute-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: base-uri-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

Method: base-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: child-pipe-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)
Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE document)
Method: child-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: get-element-by-id-using-navigator NAVIGATOR NODE ID
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

Method: get-element-by-id-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node) ID
Generic Function: hash-key-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: hash-key-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: hash-key-using-navigator (NAVIGATOR (eql default-navigator)) NODE
Generic Function: local-name-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: local-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)
Method: local-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: local-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: namespace-pipe-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: namespace-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element)
Method: namespace-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: namespace-pipe-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: namespace-prefix-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: namespace-prefix-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)
Method: namespace-prefix-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: namespace-prefix-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: namespace-uri-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: namespace-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)
Method: namespace-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: namespace-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: node-equal-using-navigator NAVIGATOR NODE OTHER
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: node-equal-using-navigator (NAVIGATOR (eql default-navigator)) (A dom-namespace) (B dom-namespace)
Method: node-equal-using-navigator (NAVIGATOR (eql default-navigator)) A B
Generic Function: node-p-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Method: node-p-using-navigator (NAVIGATOR (eql default-navigator)) NODE
Generic Function: node-text-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE document) (TYPE (eql document))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace) (TYPE (eql namespace))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE element) (TYPE (eql element))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE attr) (TYPE (eql attribute))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE text) (TYPE (eql text))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE processing-instruction) (TYPE (eql processing-instruction))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE comment) (TYPE (eql comment))
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace) TYPE
Method: node-type-p-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node) TYPE
Generic Function: parent-node-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Method: parent-node-using-navigator (NAVIGATOR (eql default-navigator)) (NODE attr)
Generic Function: processing-instruction-target-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

Methods
Method: processing-instruction-target-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: qualified-name-using-navigator NAVIGATOR NODE
Package

xpath-protocol

Source

protocol.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

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

xmls-compat.lisp (file)

Method: qualified-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE character-data)
Method: qualified-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE dom-namespace)
Method: qualified-name-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node)
Generic Function: unparsed-entity-uri-using-navigator NAVIGATOR NODE NAME
Package

xpath-protocol

Source

protocol.lisp (file)

Methods
Method: unparsed-entity-uri-using-navigator (NAVI xpath-navigator) NODE NAME
Source

xmls-compat.lisp (file)

Method: unparsed-entity-uri-using-navigator (NAVIGATOR (eql default-navigator)) (NODE node) NAME

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

4.1.6 Conditions

Condition: xpath-error ()

The class of all xpath errors.

Package

xpath

Source

api.lisp (file)

Direct superclasses

simple-error (condition)


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

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

Direct superclasses

structure-object (structure)

Direct slots
Slot: priority
Readers

pattern-priority (function)

Writers

(setf pattern-priority) (function)

Slot: value
Readers

pattern-value (function)

Writers

(setf pattern-value) (function)

Slot: key
Readers

pattern-key (function)

Writers

(setf pattern-key) (function)

Slot: thunk
Readers

pattern-thunk (function)

Writers

(setf pattern-thunk) (function)

Slot: expression
Readers

pattern-expression (function)

Writers

(setf pattern-expression) (function)


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

4.1.8 Classes

Class: context ()

Represents XPath context

Package

xpath

Source

types.lisp (file)

Direct superclasses

standard-object (class)

Direct slots
Slot: node
Initargs

:node

Slot: size
Initargs

:size

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

Direct superclasses

standard-object (class)

Direct methods
  • print-object (method)
  • ordering-of (method)
  • ordering-of (method)
Direct slots
Slot: pipe
Initargs

:pipe

Initform

xpath::empty-pipe

Slot: ordering
Initargs

:ordering

Initform

:unordered

Readers

ordering-of (generic function)

Writers

(setf ordering-of) (generic function)


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

4.2 Internal definitions


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

4.2.1 Constants

Constant: empty-pipe
Package

xpath

Source

pipes.lisp (file)


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

4.2.2 Special variables

Special Variable: *document-element*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *dom-builder*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *dynamic-namespaces*
Package

xpath

Source

environment.lisp (file)

Special Variable: *dynamic-var-bindings*
Package

xpath

Source

environment.lisp (file)

Special Variable: *extensions*
Package

xpath

Source

extensions.lisp (file)

Special Variable: *initial-namespaces*
Package

xpath

Source

environment.lisp (file)

Special Variable: *plx-uri*
Package

xpath

Source

plx.lisp (file)

Special Variable: *profiling-enabled-p*
Package

xpath

Source

profile.lisp (file)

Special Variable: *sample-xml*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *sample-xml-2*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *sample-xml-3*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *sample-xml-4*
Package

xpath

Source

xpath-test.lisp (file)

Special Variable: *samples*
Package

xpath

Source

profile.lisp (file)

Special Variable: *tests*
Package

xpath

Source

test.lisp (file)

Special Variable: *xpath-parser*
Package

xpath

Source

parser.lisp (file)

Special Variable: +nan+
Package

xpath

Source

xnum-ieee.lisp (file)


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

4.2.3 Macros

Macro: %define-xpath-function/eager EXT NAME CONVERTER ARGS &body BODY
Package

xpath

Source

extensions.lisp (file)

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

Macro: assert* &rest EXPRESSIONS
Package

xpath

Source

test.lisp (file)

Macro: assert-equal EXPECTED ACTUAL

Check whether two values are equal

Package

xpath

Source

test.lisp (file)

Macro: assert-equal* &rest PAIRS
Package

xpath

Source

test.lisp (file)

Macro: assert-float-equal EXPECTED ACTUAL

Check whether two floating-point values are equal

Package

xpath

Source

xnum-ieee.lisp (file)

Macro: assert-float-equal* &rest PAIRS
Package

xpath

Source

xnum-ieee.lisp (file)

Macro: define-axis NAME (ORDERING &optional PRINCIPAL-NODE-TYPE) &body BODY
Package

xpath

Source

axes.lisp (file)

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

Macro: define-fixup-lexer NAME &rest RULES
Package

xpath

Source

lexer.lisp (file)

Macro: define-regex-function NAME ARGS &body BODY
Package

xpath

Source

plx.lisp (file)

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

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

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

Macro: define-xpath-test NAME &body BODY
Package

xpath

Source

xpath-test.lisp (file)

Macro: deflexer NAME-AND-OPTIONS &body RULES
Package

xpath

Source

lexer.lisp (file)

Macro: deftest NAME &body BODY
Package

xpath

Source

test.lisp (file)

Macro: lambda* (&rest ARGS) &body BODY
Package

xpath

Source

parser.lisp (file)

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

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

xpath

Source

utils.lisp (file)

Macro: verify-xpath* XML &rest ITEMS
Package

xpath

Source

xpath-test.lisp (file)

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

xpath

Source

utils.lisp (file)

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

xpath

Source

xnum-ieee.lisp (file)

Macro: with-gensyms SYMS &rest BODY

Execute the body binding syms to gensyms

Package

xpath

Source

utils.lisp (file)


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

4.2.4 Functions

Function: %append-pipes PIPEX PIPEY-FUN
Package

xpath

Source

pipes.lisp (file)

Function: %compile-subpattern SUBPATTERN ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: %define-extension NAME URI DOCUMENTATION
Package

xpath

Source

extensions.lisp (file)

Function: %make-node-set-iterator PIPE
Package

xpath

Source

api.lisp (file)

Function: %make-pattern KEY THUNK PRIORITY VALUE EXPRESSION
Package

xpath

Source

patterns.lisp (file)

Function: %namespace-binding-pair PREFIX URI
Package

xpath

Source

environment.lisp (file)

Function: %variable-binding-pair QNAME VALUE
Package

xpath

Source

environment.lisp (file)

Function: add-xpath-function EXT NAME FUNC ARGLIST
Package

xpath

Source

extensions.lisp (file)

Function: arg-count ARGLIST
Package

xpath

Source

extensions.lisp (file)

Function: axis-ancestor NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-ancestor-or-self NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-attribute NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-child NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-descendant NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-descendant-or-self NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-following NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-following-sibling NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-function AXIS
Package

xpath

Source

axes.lisp (file)

Function: axis-namespace NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-parent NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-preceding NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-preceding-sibling NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-principal-node-type AXIS
Package

xpath

Source

axes.lisp (file)

Function: axis-properties AXIS
Package

xpath

Source

axes.lisp (file)

Function: axis-reverse-descendant-or-self NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-root NODE
Package

xpath

Source

axes.lisp (file)

Function: axis-self NODE
Package

xpath

Source

axes.lisp (file)

Function: compare-node-sets OP A B
Package

xpath

Source

types.lisp (file)

Function: compare-numbers OP A B
Package

xpath

Source

xnum-ieee.lisp (file)

Function: compare-values OP A B
Package

xpath

Source

types.lisp (file)

Function: compare-with-node-set OP NODE-SET VALUE
Package

xpath

Source

types.lisp (file)

Function: compare/no-node-sets OP A B
Package

xpath

Source

types.lisp (file)

Function: compile-filter-path FILTER PREDICATE PATH ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: compile-location-step STEP-SPEC ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: compile-node-test NODE-TEST ENVIRONMENT ATTRIBUTEP
Package

xpath

Source

xpath.lisp (file)

Function: compile-path PATH ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: compile-pattern-expression PATTERN ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: compile-pattern-expression/sexpr PATTERN ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: compile-predicates PREDICATES ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: compile-subpattern SUBPATTERN ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: compile-variable NAME ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: compile-xpath-function-call XPATH-FUNCTION ARGUMENT-THUNKS
Package

xpath

Source

extensions.lisp (file)

Function: compile-xpath/sexpr EXPR ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

Function: concat &rest VALUES

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

Package

xpath

Source

utils.lisp (file)

Function: copy-dom-namespace INSTANCE
Package

xpath

Source

protocol.lisp (file)

Function: copy-dynamic-environment INSTANCE
Package

xpath

Source

environment.lisp (file)

Function: copy-environment INSTANCE
Package

xpath

Source

environment.lisp (file)

Function: copy-extension INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: copy-node-set-iterator INSTANCE
Package

xpath

Source

api.lisp (file)

Function: copy-pattern INSTANCE
Package

xpath

Source

patterns.lisp (file)

Function: copy-test-environment INSTANCE
Package

xpath

Source

environment.lisp (file)

Function: copy-xpath-function INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: decode-dynamic-qname QNAME
Package

xpath

Source

environment.lisp (file)

Function: decode-qname QNAME ENVIRONMENT ATTRIBUTEP
Package

xpath

Source

xpath.lisp (file)

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

Function: dom-namespace-p OBJECT
Package

xpath

Source

protocol.lisp (file)

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

xpath

Source

protocol.lisp (file)

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

xpath

Source

protocol.lisp (file)

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

xpath

Source

protocol.lisp (file)

Function: dribble-tests ()
Package

xpath

Source

parser.lisp (file)

Function: dynamic-environment-namespaces INSTANCE
Function: (setf dynamic-environment-namespaces) VALUE INSTANCE
Package

xpath

Source

environment.lisp (file)

Function: dynamic-environment-p OBJECT
Package

xpath

Source

environment.lisp (file)

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

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

Function: environment-p OBJECT
Package

xpath

Source

environment.lisp (file)

Function: extension-documentation INSTANCE
Function: (setf extension-documentation) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: extension-functions INSTANCE
Function: (setf extension-functions) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: extension-p OBJECT
Package

xpath

Source

extensions.lisp (file)

Function: extension-uri INSTANCE
Function: (setf extension-uri) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: filter-pipe FUNCTION PIPE
Package

xpath

Source

pipes.lisp (file)

Function: find-dynamic-namespace PREFIX
Package

xpath

Source

environment.lisp (file)

Function: find-in-pipe ITEM PIPE &key TEST KEY
Package

xpath

Source

pipes.lisp (file)

Function: find-in-pipe-if PRED PIPE &key KEY
Package

xpath

Source

pipes.lisp (file)

Function: find-namespace PREFIX ENVIRONMENT ATTRIBUTEP
Package

xpath

Source

xpath.lisp (file)

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

Function: finite-p NUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: fmod F G
Package

xpath

Source

xnum-ieee.lisp (file)

Function: force PIPE
Package

xpath

Source

pipes.lisp (file)

Function: get-lang-attribute NODE
Package

xpath

Source

functions.lisp (file)

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

Function: get-node-index NODE
Package

xpath

Source

types.lisp (file)

Function: get-node-text NODE
Package

xpath

Source

types.lisp (file)

Function: group-and-sort-samples GROUP-IDENTICAL-EXPRESSIONS
Package

xpath

Source

profile.lisp (file)

Function: hypsym &rest PARTS

Assemble a symbol from PARTS interleaving them with hyphens

Package

xpath

Source

utils.lisp (file)

Function: inf-p NUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: join-xpath-result RESULT
Package

xpath

Source

xpath-test.lisp (file)

Function: long-to-double L
Package

xpath

Source

xnum-ieee.lisp (file)

Function: make-dom-namespace PARENT PREFIX URI
Package

xpath

Source

protocol.lisp (file)

Function: make-dynamic-environment NAMESPACES
Package

xpath

Source

environment.lisp (file)

Function: make-environment &key
Package

xpath

Source

environment.lisp (file)

Function: make-extension URI DOCUMENTATION &optional FUNCTIONS
Package

xpath

Source

extensions.lisp (file)

Function: make-fixup-lexer NEXT-LEXER
Package

xpath

Source

lexer.lisp (file)

Function: make-function-name X
Package

xpath

Source

parser.lisp (file)

Function: make-location-path STEPS
Package

xpath

Source

xpath.lisp (file)

Function: make-location-step AXIS NODE-TEST PREDICATES ENVIRONMENT
Package

xpath

Source

xpath.lisp (file)

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

Function: make-reverse-location-path STARTING-NODE-CHECK STEPS PREDICATE-CHECKS
Package

xpath

Source

patterns.lisp (file)

Function: make-reverse-location-step STEP ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: make-reverse-predicate-check STEP ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: make-test-environment &key
Package

xpath

Source

environment.lisp (file)

Function: make-xpath-function COMPILER NAME MIN-ARGS MAX-ARGS
Package

xpath

Source

extensions.lisp (file)

Function: map-pipe FUNCTION PIPE
Package

xpath

Source

pipes.lisp (file)

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

Function: mappend-lazy ()
Package

xpath

Source

xpath-test.lisp (file)

Function: mappend-pipe FN PIPE

lazily map fn over pipe, appending results

Package

xpath

Source

pipes.lisp (file)

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

Function: maybe-progn BODY

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

Package

xpath

Source

utils.lisp (file)

Function: maybe-wrap-profiling KEY FUN
Package

xpath

Source

profile.lisp (file)

Function: mklist VALUE
Package

xpath

Source

utils.lisp (file)

Function: namep STR
Package

xpath

Source

lexer.lisp (file)

Function: namespaces-match-p OLD-BINDINGS CUR-BINDINGS
Package

xpath

Source

api.lisp (file)

Function: nan-p XNUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: nc-name-p STR
Package

xpath

Source

lexer.lisp (file)

Function: node-set-iterator-p OBJECT
Package

xpath

Source

api.lisp (file)

Function: node-set-iterator-pipe INSTANCE
Function: (setf node-set-iterator-pipe) VALUE INSTANCE
Package

xpath

Source

api.lisp (file)

Function: node-test-comment ()
Package

xpath

Source

node-tests.lisp (file)

Function: node-test-name LOCAL-NAME &optional URI
Package

xpath

Source

node-tests.lisp (file)

Function: node-test-namespace URI
Package

xpath

Source

node-tests.lisp (file)

Function: node-test-node ()
Package

xpath

Source

node-tests.lisp (file)

Function: node-test-principal ()
Package

xpath

Source

node-tests.lisp (file)

Function: node-test-processing-instruction &optional NAME
Package

xpath

Source

node-tests.lisp (file)

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

xpath

Source

node-tests.lisp (file)

Function: node-type NODE
Package

xpath

Source

patterns.lisp (file)

Function: node< A B

Compare nodes according to document order.

Package

xpath

Source

types.lisp (file)

Function: parent-pipe NODE
Package

xpath

Source

protocol.lisp (file)

Function: parse-xnum STR
Package

xpath

Source

xnum-ieee.lisp (file)

Function: pattern-expression INSTANCE
Function: (setf pattern-expression) VALUE INSTANCE
Package

xpath

Source

patterns.lisp (file)

Function: pattern-key INSTANCE
Function: (setf pattern-key) VALUE INSTANCE
Package

xpath

Source

patterns.lisp (file)

Function: pattern-p OBJECT
Package

xpath

Source

patterns.lisp (file)

Function: pattern-thunk INSTANCE
Function: (setf pattern-thunk) VALUE INSTANCE
Package

xpath

Source

patterns.lisp (file)

Function: pipe-elt N PIPE
Package

xpath

Source

pipes.lisp (file)

Function: pipe-empty-p PIPE
Package

xpath

Source

pipes.lisp (file)

Function: pipe-head PIPE

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

Package

xpath

Source

pipes.lisp (file)

Function: pipe-length PIPE
Package

xpath

Source

pipes.lisp (file)

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

Writer

(setf pipe-of) (function)

Function: (setf pipe-of) PIPE 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 (file)

Reader

pipe-of (function)

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

Function: preprocess-number-str STR
Package

xpath

Source

xnum-ieee.lisp (file)

Function: proper-list-p LIST

True if the LIST is proper list

Package

xpath

Source

utils.lisp (file)

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

Function: report-xpath GROUPED-SAMPLES
Package

xpath

Source

profile.lisp (file)

Function: report-xpattern GROUPED-SAMPLES
Package

xpath

Source

profile.lisp (file)

Function: round-to-integer A
Package

xpath

Source

xnum-ieee.lisp (file)

Function: run-all-tests ()
Package

xpath

Source

test.lisp (file)

Function: same-expr-p PREV-EXPR XPATH CUR-BINDINGS
Package

xpath

Source

api.lisp (file)

Function: sample-node-set &optional XML
Package

xpath

Source

xpath-test.lisp (file)

Function: sort-nodes PIPE
Package

xpath

Source

types.lisp (file)

Function: sort-pipe PIPE &optional ORDERING
Package

xpath

Source

types.lisp (file)

Function: sorted-pipe-of NODE-SET
Package

xpath

Source

types.lisp (file)

Function: step-key STEP ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: string-replace STRING SUBSTRING REPLACEMENT

Replace occurences of SUBSTRING in STRING with REPLACEMENT.

Package

xpath

Source

utils.lisp (file)

Function: stringify-pattern-expression EXPR
Package

xpath

Source

profile.lisp (file)

Function: stringify-pattern-expressions PATTERNS
Package

xpath

Source

profile.lisp (file)

Function: subpattern-key SUBPATTERN ENVIRONMENT
Package

xpath

Source

patterns.lisp (file)

Function: subpipe-after ELT PIPE &key TEST
Package

xpath

Source

pipes.lisp (file)

Function: subpipe-before ELT PIPE &key TEST
Package

xpath

Source

pipes.lisp (file)

Function: test-comparison ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-computed-with-variables ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-eager-with-variable-evaluation ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-environment-p OBJECT
Package

xpath

Source

environment.lisp (file)

Function: test-filtering ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-following ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-lexer STR
Package

xpath

Source

parser.lisp (file)

Function: test-node-matches-p ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-node-set-api ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-pattern-case ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-plx-extensions ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-values ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-namespaces-0 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-namespaces-1 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-namespaces-2 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-namespaces-3 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-namespaces-4 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-variables-1 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-variables-2 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-with-variables-3 ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-xmls ()
Package

xpath

Source

xpath-test.lisp (file)

Function: test-xnum ()
Package

xpath

Source

xnum-ieee.lisp (file)

Function: test-xpath ()
Package

xpath

Source

xpath-test.lisp (file)

Function: textually-first-node NODE-SET
Package

xpath

Source

types.lisp (file)

Function: trim STR
Package

xpath

Source

utils.lisp (file)

Function: valid-expression-p EXPR
Package

xpath

Source

patterns.lisp (file)

Function: vector->pipe VECTOR &optional START
Package

xpath

Source

protocol.lisp (file)

Function: wrap-profiling KEY FUN
Package

xpath

Source

profile.lisp (file)

Function: write-node-test NODE-TEST S
Package

xpath

Source

profile.lisp (file)

Function: x-minusp XNUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: x-plusp XNUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: x-zerop XNUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xf-and EXPRS
Package

xpath

Source

functions.lisp (file)

Function: xf-equal U V
Package

xpath

Source

functions.lisp (file)

Function: xf-location-path PATH
Package

xpath

Source

xpath.lisp (file)

Function: xf-or EXPRS
Package

xpath

Source

functions.lisp (file)

Function: xf-true ()
Package

xpath

Source

xpath.lisp (file)

Function: xf-value X
Package

xpath

Source

xpath.lisp (file)

Function: xfd-* THUNKS-29
Package

xpath

Source

functions.lisp (file)

Function: xfd-+ THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-- THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-/ THUNKS-57
Package

xpath

Source

functions.lisp (file)

Function: xfd-/= THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-< THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-<= THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-= THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-> THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd->= THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-and THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-boolean THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-ceiling THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-concat THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-contains THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-count THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-current THUNKS-0
Package

xpath

Source

plx.lisp (file)

Function: xfd-false THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-floor THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-generate-id THUNKS-0
Package

xpath

Source

plx.lisp (file)

Function: xfd-id THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-lang THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-last THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-local-name THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-matches THUNKS-0
Package

xpath

Source

plx.lisp (file)

Function: xfd-mod THUNKS-85
Package

xpath

Source

functions.lisp (file)

Function: xfd-name THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-namespace-uri THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-normalize-space THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-not THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-number THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-or THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-position THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-replace THUNKS-0
Package

xpath

Source

plx.lisp (file)

Function: xfd-round THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-starts-with THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-string THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-string-length THUNKS-0
Package

xpath

Source

functions.lisp (file)

Function: xfd-substring THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-substring-after THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-substring-before THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-sum THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-translate THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-true THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xfd-union THUNKS-1
Package

xpath

Source

functions.lisp (file)

Function: xnum-* A B
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-+ A B
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-- A &optional B
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-/ A B
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum->string XNUM
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-ceiling A
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-floor A
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-mod F G
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-p VALUE
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xnum-round A
Package

xpath

Source

xnum-ieee.lisp (file)

Function: xpath-function-compiler INSTANCE
Function: (setf xpath-function-compiler) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: xpath-function-max-args INSTANCE
Function: (setf xpath-function-max-args) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: xpath-function-min-args INSTANCE
Function: (setf xpath-function-min-args) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: xpath-function-name INSTANCE
Function: (setf xpath-function-name) VALUE INSTANCE
Package

xpath

Source

extensions.lisp (file)

Function: xpath-function-p OBJECT
Package

xpath

Source

extensions.lisp (file)

Function: xpath-lexer STR
Package

xpath

Source

lexer.lisp (file)


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

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

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

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

Methods
Method: environment-find-variable (ENVIRONMENT test-environment) LNAME URI
Method: environment-find-variable (ENVIRONMENT dynamic-environment) LNAME URI
Generic Function: ordering-of OBJECT
Generic Function: (setf ordering-of) NEW-VALUE OBJECT
Package

xpath

Methods
Method: ordering-of (NODE-SET node-set)

automatically generated reader method

Source

types.lisp (file)

Method: (setf ordering-of) NEW-VALUE (NODE-SET node-set)

automatically generated writer method

Source

types.lisp (file)


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

4.2.6 Structures

Structure: dom-namespace ()
Package

xpath

Source

protocol.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: parent
Readers

dom-namespace-parent (function)

Writers

(setf dom-namespace-parent) (function)

Slot: prefix
Readers

dom-namespace-prefix (function)

Writers

(setf dom-namespace-prefix) (function)

Slot: uri
Readers

dom-namespace-uri (function)

Writers

(setf dom-namespace-uri) (function)

Structure: dynamic-environment ()
Package

xpath

Source

environment.lisp (file)

Direct superclasses

environment (structure)

Direct methods
Direct slots
Slot: namespaces
Readers

dynamic-environment-namespaces (function)

Writers

(setf dynamic-environment-namespaces) (function)

Structure: environment ()
Package

xpath

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Structure: extension ()
Package

xpath

Source

extensions.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: uri
Readers

extension-uri (function)

Writers

(setf extension-uri) (function)

Slot: documentation
Readers

extension-documentation (function)

Writers

(setf extension-documentation) (function)

Slot: functions
Readers

extension-functions (function)

Writers

(setf extension-functions) (function)

Structure: node-set-iterator ()
Package

xpath

Source

api.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: pipe
Readers

node-set-iterator-pipe (function)

Writers

(setf node-set-iterator-pipe) (function)

Structure: test-environment ()
Package

xpath

Source

environment.lisp (file)

Direct superclasses

environment (structure)

Direct methods
Structure: xpath-function ()
Package

xpath

Source

extensions.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: compiler
Readers

xpath-function-compiler (function)

Writers

(setf xpath-function-compiler) (function)

Slot: name
Readers

xpath-function-name (function)

Writers

(setf xpath-function-name) (function)

Slot: min-args
Readers

xpath-function-min-args (function)

Writers

(setf xpath-function-min-args) (function)

Slot: max-args
Readers

xpath-function-max-args (function)

Writers

(setf xpath-function-max-args) (function)


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

4.2.7 Types

Type: pattern-expr ()
Package

xpath

Source

patterns.lisp (file)

Type: xnum ()
Package

xpath

Source

xnum-ieee.lisp (file)

Type: xpath-expr ()
Package

xpath

Source

api.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   X  
Index Entry  Section

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

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

X
xpath.asd: The xpath<dot>asd file
xpath/api.lisp: The xpath/api<dot>lisp file
xpath/axes.lisp: The xpath/axes<dot>lisp file
xpath/environment.lisp: The xpath/environment<dot>lisp file
xpath/extensions.lisp: The xpath/extensions<dot>lisp file
xpath/functions.lisp: The xpath/functions<dot>lisp file
xpath/lexer.lisp: The xpath/lexer<dot>lisp file
xpath/node-tests.lisp: The xpath/node-tests<dot>lisp file
xpath/package.lisp: The xpath/package<dot>lisp file
xpath/parser.lisp: The xpath/parser<dot>lisp file
xpath/patterns.lisp: The xpath/patterns<dot>lisp file
xpath/pipes.lisp: The xpath/pipes<dot>lisp file
xpath/plx.lisp: The xpath/plx<dot>lisp file
xpath/profile.lisp: The xpath/profile<dot>lisp file
xpath/protocol.lisp: The xpath/protocol<dot>lisp file
xpath/test.lisp: The xpath/test<dot>lisp file
xpath/types.lisp: The xpath/types<dot>lisp file
xpath/utils.lisp: The xpath/utils<dot>lisp file
xpath/xmls-compat.lisp: The xpath/xmls-compat<dot>lisp file
xpath/xnum-ieee.lisp: The xpath/xnum-ieee<dot>lisp file
xpath/xpath-test.lisp: The xpath/xpath-test<dot>lisp file
xpath/xpath.lisp: The xpath/xpath<dot>lisp file

Jump to:   F   L   X  

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

A.2 Functions

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

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

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

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

B
base-uri: Exported functions
base-uri-using-navigator: Exported generic functions
base-uri-using-navigator: Exported generic functions
base-uri-using-navigator: Exported generic functions
boolean-value: Exported functions

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

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

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

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

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

H
hash-key: Exported functions
hash-key-using-navigator: Exported generic functions
hash-key-using-navigator: Exported generic functions
hash-key-using-navigator: Exported generic functions
hash-key-using-navigator: Exported generic functions
hash-key-using-navigator: Exported generic functions
hypsym: Internal functions

I
inf-p: Internal functions

J
join-xpath-result: Internal functions

L
lambda*: Internal macros
list->node-set: Exported functions
local-name: Exported functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
local-name-using-navigator: Exported generic functions
long-to-double: Internal functions

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

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

O
once-only: Internal macros
ordering-of: Internal generic functions
ordering-of: Internal generic functions

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

Q
qualified-name: Exported functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions
qualified-name-using-navigator: Exported generic functions

R
report: Internal functions
report-xpath: Internal functions
report-xpattern: Internal functions
round-to-integer: Internal functions
run-all-tests: Internal functions

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

T
test-comparison: Internal functions
test-computed-with-variables: Internal functions
test-eager-with-variable-evaluation: Internal functions
test-environment-p: Internal functions
test-filtering: Internal functions
test-following: Internal functions
test-lexer: Internal functions
test-node-matches-p: Internal functions
test-node-set-api: Internal functions
test-pattern-case: Internal functions
test-plx-extensions: Internal functions
test-values: Internal functions
test-with-namespaces-0: Internal functions
test-with-namespaces-1: Internal functions
test-with-namespaces-2: Internal functions
test-with-namespaces-3: Internal functions
test-with-namespaces-4: Internal functions
test-with-variables-1: Internal functions
test-with-variables-2: Internal functions
test-with-variables-3: Internal functions
test-xmls: Internal functions
test-xnum: Internal functions
test-xpath: Internal functions
textually-first-node: Internal functions
trim: Internal functions

U
unparsed-entity-uri: Exported functions
unparsed-entity-uri-using-navigator: Exported generic functions
unparsed-entity-uri-using-navigator: Exported generic functions
unparsed-entity-uri-using-navigator: Exported generic functions

V
valid-expression-p: Internal functions
vector->pipe: Internal functions
verify-xpath*: Internal macros

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

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

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

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

A.3 Variables

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

*
*allow-variables-in-patterns*: Exported special variables
*document-element*: Internal special variables
*dom-builder*: Internal special variables
*dynamic-namespaces*: Internal special variables
*dynamic-var-bindings*: Internal special variables
*extensions*: Internal special variables
*initial-namespaces*: Internal special variables
*navigator*: Exported special variables
*plx-uri*: Internal special variables
*profiling-enabled-p*: Internal special variables
*sample-xml*: Internal special variables
*sample-xml-2*: Internal special variables
*sample-xml-3*: Internal special variables
*sample-xml-4*: Internal special variables
*samples*: Internal special variables
*tests*: Internal special variables
*xpath-parser*: Internal special variables

+
+nan+: Internal special variables

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

D
documentation: Internal structures

E
empty-pipe: Internal constants
expression: Exported structures

F
functions: Internal structures

K
key: Exported structures

M
max-args: Internal structures
min-args: Internal structures

N
name: Internal structures
namespaces: Internal structures
node: Exported classes

O
ordering: Exported classes

P
parent: Internal structures
pipe: Exported classes
pipe: Internal structures
position: Exported classes
prefix: Internal structures
priority: Exported structures

S
size: Exported classes
Slot, compiler: Internal structures
Slot, documentation: Internal structures
Slot, expression: Exported structures
Slot, functions: Internal structures
Slot, key: Exported structures
Slot, max-args: Internal structures
Slot, min-args: Internal structures
Slot, name: Internal structures
Slot, namespaces: Internal structures
Slot, node: Exported classes
Slot, ordering: Exported classes
Slot, parent: Internal structures
Slot, pipe: Exported classes
Slot, pipe: Internal structures
Slot, position: Exported classes
Slot, prefix: Internal structures
Slot, priority: Exported structures
Slot, size: Exported classes
Slot, starting-node: Exported classes
Slot, thunk: Exported structures
Slot, uri: Internal structures
Slot, uri: Internal structures
Slot, value: Exported structures
Special Variable, *allow-variables-in-patterns*: Exported special variables
Special Variable, *document-element*: Internal special variables
Special Variable, *dom-builder*: Internal special variables
Special Variable, *dynamic-namespaces*: Internal special variables
Special Variable, *dynamic-var-bindings*: Internal special variables
Special Variable, *extensions*: Internal special variables
Special Variable, *initial-namespaces*: Internal special variables
Special Variable, *navigator*: Exported special variables
Special Variable, *plx-uri*: Internal special variables
Special Variable, *profiling-enabled-p*: Internal special variables
Special Variable, *sample-xml*: Internal special variables
Special Variable, *sample-xml-2*: Internal special variables
Special Variable, *sample-xml-3*: Internal special variables
Special Variable, *sample-xml-4*: Internal special variables
Special Variable, *samples*: Internal special variables
Special Variable, *tests*: Internal special variables
Special Variable, *xpath-parser*: Internal special variables
Special Variable, +nan+: Internal special variables
starting-node: Exported classes

T
thunk: Exported structures

U
uri: Internal structures
uri: Internal structures

V
value: Exported structures

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

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

A.4 Data types

Jump to:   C   D   E   N   P   S   T   X  
Index Entry  Section

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

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

E
environment: Internal structures
extension: Internal structures

N
node-set: Exported classes
node-set-iterator: Internal structures

P
Package, xpath: The xpath package
Package, xpath-protocol: The xpath-protocol package
Package, xpath-sys: The xpath-sys package
Package, xpath.system: The xpath<dot>system package
Package, xpattern: The xpattern package
pattern: Exported structures
pattern-expr: Internal types

S
Structure, dom-namespace: Internal structures
Structure, dynamic-environment: Internal structures
Structure, environment: Internal structures
Structure, extension: Internal structures
Structure, node-set-iterator: Internal structures
Structure, pattern: Exported structures
Structure, test-environment: Internal structures
Structure, xpath-function: Internal structures
System, xpath: The xpath system

T
test-environment: Internal structures
Type, pattern-expr: Internal types
Type, xnum: Internal types
Type, xpath-expr: Internal types

X
xnum: Internal types
xpath: The xpath system
xpath: The xpath package
xpath-error: Exported conditions
xpath-expr: Internal types
xpath-function: Internal structures
xpath-protocol: The xpath-protocol package
xpath-sys: The xpath-sys package
xpath.system: The xpath<dot>system package
xpattern: The xpattern package

Jump to:   C   D   E   N   P   S   T   X