# XML Path Language (XPath) 2.0

## W3C Working Draft 04 April 2005

This version:
http://www.w3.org/TR/2005/WD-xpath20-20050404/
http://www.w3.org/TR/xpath20/
Previous versions:
http://www.w3.org/TR/2005/WD-xpath20-20050211/ http://www.w3.org/TR/2004/WD-xpath20-20040723/ http://www.w3.org/TR/2003/WD-xpath20-20031112/ http://www.w3.org/TR/2003/WD-xpath20-20030822/ http://www.w3.org/TR/2003/WD-xpath20-20030502/
Editors:
Anders Berglund (XSL WG), IBM Research <alrb@us.ibm.com>
Scott Boag (XSL WG), IBM Research <scott_boag@us.ibm.com>
Mary F. Fern醤dez (XML Query WG), AT&T Labs <mff@research.att.com>
Michael Kay (XSL WG), Invited Expert
J閞鬽e Sim閛n (XML Query WG), IBM T.J. Watson Research Center <simeon@us.ibm.com>

## Abstract

XPath 2.0 is an expression language that allows the processing of values conforming to the data model defined in [XQuery 1.0 and XPath 2.0 Data Model]. The data model provides a tree representation of XML documents as well as atomic values such as integers, strings, and booleans, and sequences that may contain both references to nodes in an XML document and atomic values. The result of an XPath expression may be a selection of nodes from the input documents, or an atomic value, or more generally, any sequence allowed by the data model. The name of the language derives from its most distinctive feature, the path expression, which provides a means of hierarchic addressing of the nodes in an XML tree. XPath 2.0 is a superset of [XPath 1.0], with the added capability to support a richer set of data types, and to take advantage of the type information that becomes available when documents are validated using XML Schema. A backwards compatibility mode is provided to ensure that nearly all XPath 1.0 expressions continue to deliver the same result with XPath 2.0; exceptions to this policy are noted in [I Backwards Compatibility with XPath 1.0].

## Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This is a Last Call Working Draft for review by W3C Members and other interested parties. Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

XPath 2.0 has been defined jointly by the XML Query Working Group and the XSL Working Group (both part of the XML Activity). The XPath 2.0 and XQuery 1.0 Working Drafts are generated from a common source. These languages are closely related, sharing much of the same expression syntax and semantics, and much of the text found in the two Working Drafts is identical.

This draft includes many corrections and changes based on member-only and public comments on the Last Call Working Draft (http://www.w3.org/TR/2003/WD-xpath20-20031112/). The XML Query and XSL Working Groups wish to thank the people who have sent in comments for their close reading of the document.

This draft reflects decisions taken up to and including the joint meeting in Boston, MA during the week of February 28, 2005. These decisions are recorded in the Last Call issues list (http://www.w3.org/2005/04/xpath-issues.html). A list of changes introduced by this draft can be found in J Revision Log.

Public Last Call comments on this document are invited. Comments on this document are due by 13 May 2005. Comments should be entered into the last-call issue tracking system for this specification (instructions can be found at http://www.w3.org/XML/2005/04/qt-bugzilla). If access to that system is not feasible, you may send your comments to the W3C XSLT/XPath/XQuery mailing list, public-qt-comments@w3.org (archived at http://lists.w3.org/Archives/Public/public-qt-comments/), with “[XPath]” at the beginning of the subject field.

The patent policy for this document is the 5 February 2004 W3C Patent Policy. Patent disclosures relevant to this specification may be found on the XML Query Working Group's patent disclosure page and the XSL Working Group's patent disclosure page. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) with respect to this specification should disclose the information in accordance with section 6 of the W3C Patent Policy.

1 Introduction
2 Basics
2.1 Expression Context
2.1.1 Static Context
2.1.2 Dynamic Context
2.2 Processing Model
2.2.1 Data Model Generation
2.2.2 Schema Import Processing
2.2.3 Expression Processing
2.2.3.1 Static Analysis Phase
2.2.3.2 Dynamic Evaluation Phase
2.2.4 Serialization
2.2.5 Consistency Constraints
2.3 Error Handling
2.3.1 Kinds of Errors
2.3.2 Identifying and Reporting Errors
2.3.3 Handling Dynamic Errors
2.3.4 Errors and Optimization
2.4 Concepts
2.4.1 Document Order
2.4.2 Atomization
2.4.3 Effective Boolean Value
2.4.4 Input Sources
2.5 Types
2.5.1 Predefined Schema Types
2.5.2 Typed Value and String Value
2.5.3 SequenceType Syntax
2.5.4 SequenceType Matching
2.5.4.1 Matching a SequenceType and a Value
2.5.4.2 Matching an ItemType and an Item
2.5.4.3 Element Test
2.5.4.4 Schema Element Test
2.5.4.5 Attribute Test
2.5.4.6 Schema Attribute Test
3 Expressions
3.1 Primary Expressions
3.1.1 Literals
3.1.2 Variable References
3.1.3 Parenthesized Expressions
3.1.4 Context Item Expression
3.1.5 Function Calls
3.2 Path Expressions
3.2.1 Steps
3.2.1.1 Axes
3.2.1.2 Node Tests
3.2.2 Predicates
3.2.3 Unabbreviated Syntax
3.2.4 Abbreviated Syntax
3.3 Sequence Expressions
3.3.1 Constructing Sequences
3.3.2 Filter Expressions
3.3.3 Combining Node Sequences
3.4 Arithmetic Expressions
3.5 Comparison Expressions
3.5.1 Value Comparisons
3.5.2 General Comparisons
3.5.3 Node Comparisons
3.6 Logical Expressions
3.7 For Expressions
3.8 Conditional Expressions
3.9 Quantified Expressions
3.10 Expressions on SequenceTypes
3.10.1 Instance Of
3.10.2 Cast
3.10.3 Castable
3.10.4 Constructor Functions
3.10.5 Treat

### Appendices

A XPath Grammar
A.1 EBNF
A.1.1 Grammar Notes
A.2 Lexical structure
A.2.1 Terminal Types
A.2.2 Whitespace Rules
A.2.2.1 Default Whitespace Handling
A.2.2.2 Explicit Whitespace Handling
A.3 Reserved Function Names
A.4 Precedence Order
B Type Promotion and Operator Mapping
B.1 Type Promotion
B.2 Operator Mapping
C Context Components
C.1 Static Context Components
C.2 Dynamic Context Components
D Implementation-Defined Items
E References
E.1 Normative References
E.2 Non-normative References
E.3 Background Material
F Conformance
F.1 Static Typing Feature
F.1.1 Static Typing Extensions
G Error Conditions
H Glossary (Non-Normative)
I Backwards Compatibility with XPath 1.0 (Non-Normative)
I.1 Incompatibilities when Compatibility Mode is true
I.2 Incompatibilities when Compatibility Mode is false
I.3 Incompatibilities when using a Schema
J Revision Log (Non-Normative)
J.1 23 July 2004
J.2 29 Oct 2004
J.3 7 January 2005
J.4 21 February 2005
J.5 04 April 2005

## 1 Introduction

The primary purpose of XPath is to address the nodes of [XML 1.0] or [XML 1.1] trees. XPath gets its name from its use of a path notation for navigating through the hierarchical structure of an XML document. XPath uses a compact, non-XML syntax to facilitate use of XPath within URIs and XML attribute values.

[Definition: XPath operates on the abstract, logical structure of an XML document, rather than its surface syntax. This logical structure, known as the data model, is defined in the [XQuery 1.0 and XPath 2.0 Data Model] document.]

XPath is designed to be embedded in a host language such as [XSLT 2.0] or [XQuery]. XPath has a natural subset that can be used for matching (testing whether or not a node matches a pattern); this use of XPath is described in [XSLT 2.0].

XQuery Version 1.0 is an extension of XPath Version 2.0. Any expression that is syntactically valid and executes successfully in both XPath 2.0 and XQuery 1.0 will return the same result in both languages. Since these languages are so closely related, their grammars and language descriptions are generated from a common source to ensure consistency, and the editors of these specifications work together closely.

XPath also depends on and is closely related to the following specifications:

This document specifies a grammar for XPath, using the same Basic EBNF notation used in [XML 1.0]. Unless otherwise noted (see A.2 Lexical structure), whitespace is not significant in the grammar. Grammar productions are introduced together with the features that they describe, and a complete grammar is also presented in the appendix [A XPath Grammar]. The appendix is the normative version.

In the grammar productions in this document, nonterminal symbols are underlined and literal text is enclosed in double quotes. Certain productions (including the productions that define DecimalLiteral, DoubleLiteral, and StringLiteral) employ a regular-expression notation. The following example production describes the syntax of a function call:

 [47] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")"

The production should be read as follows: A function call consists of a QName followed by an open-parenthesis. The open-parenthesis is followed by an optional argument list. The argument list (if present) consists of one or more expressions, separated by commas. The optional argument list is followed by a close-parenthesis.

Certain aspects of language processing are described in this specification as implementation-defined or implementation-dependent.

• [Definition: Implementation-defined indicates an aspect that may differ between implementations, but must be specified by the implementor for each particular implementation.]

• [Definition: Implementation-dependent indicates an aspect that may differ between implementations, is not specified by this or any W3C specification, and is not required to be specified by the implementor for any particular implementation.]

A language aspect described in this specification as implementation-defined or implementation dependent may be further constrained by the specifications of a host language in which XPath is embedded.

This document normatively defines the dynamic semantics of XPath. The static semantics of XPath are normatively defined in [XQuery 1.0 and XPath 2.0 Formal Semantics]. In this document, examples and material labeled as "Note" are provided for explanatory purposes and are not normative.

## 2 Basics

The basic building block of XPath is the expression, which is a string of [Unicode] characters (the version of Unicode to be used is implementation-defined.) The language provides several kinds of expressions which may be constructed from keywords, symbols, and operands. In general, the operands of an expression are other expressions. XPath allows expressions to be nested with full generality.

Note:

This specification contains no assumptions or requirements regarding the character set encoding of strings of [Unicode] characters.

Like XML, XPath is a case-sensitive language. Keywords in XPath use lower-case characters and are not reserved—that is, names in XPath expressions are allowed to be the same as language keywords, except for certain unprefixed function-names listed in A.3 Reserved Function Names.

[Definition: In the data model, a value is always a sequence.] [Definition: A sequence is an ordered collection of zero or more items.] [Definition: An item is either an atomic value or a node.] [Definition: An atomic value is a value in the value space of an atomic type, as defined in [XML Schema].] [Definition: A node is an instance of one of the node kinds defined in [XQuery 1.0 and XPath 2.0 Data Model].] Each node has a unique node identity, a typed value, and a string value. In addition, some nodes have a name. The typed value of a node is a sequence of zero or more atomic values. The string value of a node is a value of type xs:string. The name of a node is a value of type xs:QName.

[Definition: A sequence containing exactly one item is called a singleton.] An item is identical to a singleton sequence containing that item. Sequences are never nested—for example, combining the values 1, (2, 3), and ( ) into a single sequence results in the sequence (1, 2, 3). [Definition: A sequence containing zero items is called an empty sequence.]

[Definition: The term data model instance is used, synonymously with the term value, to denote an unconstrained sequence of nodes and/or atomic values.]

Names in XPath are called QNames, and conform to the syntax in [XML Names]. [Definition: Lexically, a QName consists of an optional namespace prefix and a local name. If the namespace prefix is present, it is separated from the local name by a colon.] A lexical QName can be converted into an expanded QName by resolving its namespace prefix to a namespace URI, using the statically known namespaces [err:XPST0081]. [Definition: An expanded QName consists of an optional namespace URI and a local name. An expanded QName also retains its original namespace prefix (if any), to facilitate casting the expanded QName into a string.] The namespace URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema]. Two expanded QNames are equal if their namespace URIs are equal and their local names are equal (even if their namespace prefixes are not equal). Namespace URIs and local names are compared on a codepoint basis, without further normalization.

This document uses the following namespace prefixes to represent the namespace URIs with which they are listed. Use of these namespace prefix bindings in this document is not normative.

• xs = http://www.w3.org/2001/XMLSchema

• fn = http://www.w3.org/2005/04/xpath-functions

• xdt = http://www.w3.org/2005/04/xpath-datatypes

• err = http://www.w3.org/2004/07/xqt-errors (see 2.3.2 Identifying and Reporting Errors).

Element nodes have a property called in-scope namespaces. [Definition: The in-scope namespaces property of an element node is a set of namespace bindings, each of which associates a namespace prefix with a URI, thus defining the set of namespace prefixes that are available for interpreting QNames within the scope of the element. For a given element, one namespace binding may have an empty prefix; the URI of this namespace binding is the default namespace within the scope of the element.]

In [XPath 1.0], the in-scope namespaces of an element node are represented by a collection of namespace nodes arranged on a namespace axis. In XPath Version 2.0, the namespace axis is deprecated and need not be supported by a host language. A host language that does not support the namespace axis need not represent namespace bindings in the form of nodes.

### 2.1 Expression Context

[Definition: The expression context for a given expression consists of all the information that can affect the result of the expression.] This information is organized into two categories called the static context and the dynamic context.

#### 2.1.1 Static Context

[Definition: The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation.] This information can be used to decide whether the expression contains a static error. If analysis of an expression relies on some component of the static context that has not been assigned a value, a static error is raised [err:XPST0001].

The individual components of the static context are summarized below. A default initial value for each component may be specified by the host language. The scope of each component is specified in C.1 Static Context Components.

• [Definition: XPath 1.0 compatibility mode. This value is true if rules for backward compatibility with XPath Version 1.0 are in effect; otherwise it is false.]

• [Definition: Statically known namespaces. This is a set of (prefix, URI) pairs that define all the namespaces that are known during static processing of a given expression.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema]. Note the difference between in-scope namespaces, which is a dynamic property of an element node, and statically known namespaces, which is a static property of an expression.

• [Definition: Default element/type namespace. This is a namespace URI or "none". The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element or type name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema].

• [Definition: Default function namespace. This is a namespace URI or "none". The namespace URI, if present, is used for any unprefixed QName appearing in a position where a function name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema].

• [Definition: In-scope schema definitions. This is a generic term for all the element declarations, attribute declarations, and schema type definitions that are in scope during processing of an expression.] It includes the following three parts:

• [Definition: In-scope schema types. Each schema type definition is identified either by an expanded QName (for a named type) or by an implementation-dependent type identifier (for an anonymous type). The in-scope schema types include the predefined schema types described in 2.5.1 Predefined Schema Types. ]

• [Definition: In-scope element declarations. Each element declaration is identified either by an expanded QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration). ] An element declaration includes information about the element's substitution group affiliation.

[Definition: Substitution groups are defined in [XML Schema] Part 1, Section 2.2.2.2. Informally, the substitution group headed by a given element (called the head element) consists of the set of elements that can be substituted for the head element without affecting the outcome of schema validation.]

• [Definition: In-scope attribute declarations. Each attribute declaration is identified either by an expanded QName (for a top-level attribute declaration) or by an implementation-dependent attribute identifier (for a local attribute declaration). ]

• [Definition: In-scope variables. This is a set of (expanded QName, type) pairs. It defines the set of variables that are available for reference within an expression. The expanded QName is the name of the variable, and the type is the static type of the variable.]

An expression that binds a variable (such as a for, some, or every expression) extends the in-scope variables of its subexpressions with the new bound variable and its type.

• [Definition: Context item static type. This component defines the static type of the context item within the scope of a given expression.]

• [Definition: Function signatures. This component defines the set of functions that are available to be called from within an expression. Each function is uniquely identified by its expanded QName and its arity (number of parameters).] In addition to the name and arity, each function signature specifies the static types of the function parameters and result.

The function signatures include the signatures of constructor functions, which are discussed in 3.10.4 Constructor Functions.

• [Definition: Statically known collations. This is an implementation-defined set of (URI, collation) pairs. It defines the names of the collations that are available for use in processing expressions.] [Definition: A collation is a specification of the manner in which strings and URIs are compared and, by extension, ordered. For a more complete definition of collation, see [XQuery 1.0 and XPath 2.0 Functions and Operators].]

• [Definition: Default collation. This identifies one of the collations in statically known collations as the collation to be used by functions and operators for comparing and ordering values of type xs:string and xs:anyURI (and their subtypes) when no explicit collation is specified.]

• [Definition: Base URI. This is an absolute URI, used when necessary in the resolution of relative URIs (for example, by the fn:resolve-uri function.)] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema].

• [Definition: Statically known documents. This is a mapping from strings onto types. The string represents the absolute URI of a resource that is potentially available using the fn:doc function. The type is the static type of a call to fn:doc with the given URI as its literal argument. ] If the argument to fn:doc is a string literal that is not present in statically known documents, then the static type of fn:doc is document-node()?.

Note:

The purpose of the statically known documents is to provide static type information, not to determine which documents are available. A URI need not be found in the statically known documents to be accessed using fn:doc.

• [Definition: Statically known collections. This is a mapping from strings onto types. The string represents the absolute URI of a resource that is potentially available using the fn:collection function. The type is the type of the sequence of nodes that would result from calling the fn:collection function with this URI as its argument.] If the argument to fn:collection is a string literal that is not present in statically known collections, then the static type of fn:collection is node()*.

Note:

The purpose of the statically known collections is to provide static type information, not to determine which collections are available. A URI need not be found in the statically known collections to be accessed using fn:collection.

• [Definition: Statically known default collection type. This is the type of the sequence of nodes that would result from calling the fn:collection function with no arguments.] Unless initialized to some other value by an implementation, the value of statically known default collection type is node()*.

#### 2.1.2 Dynamic Context

[Definition: The dynamic context of an expression is defined as information that is available at the time the expression is evaluated.] If evaluation of an expression relies on some part of the dynamic context that has not been assigned a value, a dynamic error is raised [err:XPDY0002].

The individual components of the dynamic context are summarized below. Further rules governing the semantics of these components can be found in C.2 Dynamic Context Components.

The dynamic context consists of all the components of the static context, and the additional components listed below.

[Definition: The first three components of the dynamic context (context item, context position, and context size) are called the focus of the expression. ] The focus enables the processor to keep track of which items are being processed by the expression.

Certain language constructs, notably the path expression E1/E2 and the filter expression E1[E2], create a new focus for the evaluation of a sub-expression. In these constructs, E2 is evaluated once for each item in the sequence that results from evaluating E1. Each time E2 is evaluated, it is evaluated with a different focus. The focus for evaluating E2 is referred to below as the inner focus, while the focus for evaluating E1 is referred to as the outer focus. The inner focus exists only while E2 is being evaluated. When this evaluation is complete, evaluation of the containing expression continues with its original focus unchanged.

• [Definition: The context item is the item currently being processed. An item is either an atomic value or a node.][Definition: When the context item is a node, it can also be referred to as the context node.] The context item is returned by an expression consisting of a single dot (.). When an expression E1/E2 or E1[E2] is evaluated, each item in the sequence obtained by evaluating E1 becomes the context item in the inner focus for an evaluation of E2.

• [Definition: The context position is the position of the context item within the sequence of items currently being processed.] It changes whenever the context item changes. Its value is always an integer greater than zero. The context position is returned by the expression fn:position(). When an expression E1/E2 or E1[E2] is evaluated, the context position in the inner focus for an evaluation of E2 is the position of the context item in the sequence obtained by evaluating E1. The position of the first item in a sequence is always 1 (one). The context position is always less than or equal to the context size.

• [Definition: The context size is the number of items in the sequence of items currently being processed.] Its value is always an integer greater than zero. The context size is returned by the expression fn:last(). When an expression E1/E2 or E1[E2] is evaluated, the context size in the inner focus for an evaluation of E2 is the number of items in the sequence obtained by evaluating E1.

• [Definition: Variable values. This is a set of (expanded QName, value) pairs. It contains the same expanded QNames as the in-scope variables in the static context for the expression. The expanded QName is the name of the variable and the value is the dynamic value of the variable, which includes its dynamic type.]

• [Definition: Function implementations. Each function in function signatures has a function implementation that enables the function to map instances of its parameter types into an instance of its result type. ]

• [Definition: Current dateTime. This information represents an implementation-dependent point in time during the processing of an expression, and includes an explicit timezone. It can be retrieved by the fn:current-dateTime function. If invoked multiple times during the execution of an expression, this function always returns the same result.]

• [Definition: Implicit timezone. This is the timezone to be used when a date, time, or dateTime value that does not have a timezone is used in a comparison or arithmetic operation. The implicit timezone is an implementation-defined value of type xdt:dayTimeDuration. See [XML Schema] for the range of legal values of a timezone.]

• [Definition: Available documents. This is a mapping of strings onto document nodes. The string represents the absolute URI of a resource. The document node is the root of a tree that represents that resource using the data model. The document node is returned by the fn:doc function when applied to that URI.] The set of available documents is not limited to the set of statically known documents, and it may be empty.

• [Definition: Available collections. This is a mapping of strings onto sequences of nodes. The string represents the absolute URI of a resource. The sequence of nodes represents the result of the fn:collection function when that URI is supplied as the argument. ] The set of available collections is not limited to the set of statically known collections, and it may be empty.

• [Definition: Default collection. This is the sequence of nodes that would result from calling the fn:collection function with no arguments.] The value of default collection may be initialized by the implementation.

### 2.2 Processing Model

XPath is defined in terms of the data model and the expression context.

Figure 1: Processing Model Overview

Figure 1 provides a schematic overview of the processing steps that are discussed in detail below. Some of these steps are completely outside the domain of XPath; in Figure 1, these are depicted outside the line that represents the boundaries of the language, an area labeled external processing. The external processing domain includes generation of a data model instance that represents the data to be queried (see 2.2.1 Data Model Generation), schema import processing (see 2.2.2 Schema Import Processing) and serialization (see 2.2.4 Serialization). The area inside the boundaries of the language is known as the XPath processing domain, which includes the static analysis and dynamic evaluation phases (see 2.2.3 Expression Processing). Consistency constraints on the XPath processing domain are defined in 2.2.5 Consistency Constraints.

#### 2.2.1 Data Model Generation

Before an expression can be processed, its input data must be represented as a data model instance. This process occurs outside the domain of XPath, which is why Figure 1 represents it in the external processing domain. Here are some steps by which an XML document might be converted to a data model instance:

1. A document may be parsed using an XML parser that generates an XML Information Set (see [XML Infoset]). The parsed document may then be validated against one or more schemas. This process, which is described in [XML Schema], results in an abstract information structure called the Post-Schema Validation Infoset (PSVI). If a document has no associated schema, its Information Set is preserved. (See DM1 in Fig. 1.)

2. The Information Set or PSVI may be transformed into a data model instance by a process described in [XQuery 1.0 and XPath 2.0 Data Model]. (See DM2 in Fig. 1.)

The above steps provide an example of how a data model instance might be constructed. A data model instance might also be synthesized directly from a relational database, or constructed in some other way (see DM3 in Fig. 1.) XPath is defined in terms of the data model, but it does not place any constraints on how data model instances are constructed.

[Definition: Each element node and attribute node in a data model instance has a type annotation (referred to in [XQuery 1.0 and XPath 2.0 Data Model] as its type-name property.) The type annotation of a node is a schema type that describes the relationship between the string value of the node and its typed value.] If the data model instance was derived from a validated XML document as described in Section 3.3 Construction from a PSVIDM, the type annotations of the element and attribute nodes are derived from schema validation. XPath does not provide a way to directly access the type annotation of an element or attribute node.

The value of an attribute is represented directly within the attribute node. An attribute node whose type is unknown (such as might occur in a schemaless document) is given the type annotation xdt:untypedAtomic.

The value of an element is represented by the children of the element node, which may include text nodes and other element nodes. The type annotation of an element node indicates how the values in its child text nodes are to be interpreted. An element that has not been validated (such as might occur in a schemaless document) is annotated with the schema type xdt:untyped. An element that has been validated and found to be partially valid is annotated with the schema type xs:anyType. If an element node is annotated as xdt:untyped, all its descendant element nodes are also annotated as xdt:untyped. However, if an element node is annotated as xs:anyType, some of its descendant element nodes may have a more specific type annotation.

#### 2.2.2 Schema Import Processing

The in-scope schema definitions in the static context are provided by the host language (see step SI1 in Figure 1) and must satisfy the consistency constraints defined in 2.2.5 Consistency Constraints.

#### 2.2.3 Expression Processing

XPath defines two phases of processing called the static analysis phase and the dynamic evaluation phase (see Fig. 1). During the static analysis phase, static errors, dynamic errors, or type errors may be raised. During the dynamic evaluation phase, only dynamic errors or type errors may be raised. These kinds of errors are defined in 2.3.1 Kinds of Errors.

Within each phase, an implementation is free to use any strategy or algorithm whose result conforms to the specifications in this document.

##### 2.2.3.1 Static Analysis Phase

[Definition: The static analysis phase depends on the expression itself and on the static context. The static analysis phase does not depend on input data (other than schemas).]

During the static analysis phase, the XPath expression is parsed into an internal representation called the operation tree (step SQ1 in Figure 1). A parse error is raised as a static error [err:XPST0003]. The static context is initialized by the implementation (step SQ2). The static context is used to resolve schema type names, function names, namespace prefixes, and variable names (step SQ4). If a name of one of these kinds in the operation tree is not found in the static context, a static error ([err:XPST0008] or [err:XPST0017]) is raised (however, see exceptions to this rule in 2.5.4.3 Element Test and 2.5.4.5 Attribute Test.)

The operation tree is then normalized by making explicit the implicit operations such as atomization, type promotion, and extraction of Effective Boolean Values (step SQ5). The normalization process is described in [XQuery 1.0 and XPath 2.0 Formal Semantics].

Each expression is then assigned a static type (step SQ6). [Definition: The static type of an expression is a type such that, when the expression is evaluated, the resulting value will always conform to the static type.] If the Static Typing Feature is supported, the static types of various expressions are inferred according to the rules described in [XQuery 1.0 and XPath 2.0 Formal Semantics]. If the Static Typing Feature is not supported, the static types that are assigned are implementation-dependent.

During the static analysis phase, if the Static Typing Feature is in effect and an operand of an expression is found to have a static type that is not appropriate for that operand, a type error is raised [err:XPTY0004]. If static type checking raises no errors and assigns a static type T to an expression, then execution of the expression on valid input data is guaranteed either to produce a value of type T or to raise a dynamic error.

The purpose of the Static Typing Feature is to provide early detection of type errors and to infer type information that may be useful in optimizing the evaluation of an expression.

##### 2.2.3.2 Dynamic Evaluation Phase

[Definition: The dynamic evaluation phase is the phase during which the value of an expression is computed.] It occurs after completion of the static analysis phase.

The dynamic evaluation phase can occur only if no errors were detected during the static analysis phase. If the Static Typing Feature is in effect, all type errors are detected during static analysis and serve to inhibit the dynamic evaluation phase.

The dynamic evaluation phase depends on the operation tree of the expression being evaluated (step DQ1), on the input data (step DQ4), and on the dynamic context (step DQ5), which in turn draws information from the external environment (step DQ3) and the static context (step DQ2). The dynamic evaluation phase may create new data-model values (step DQ4) and it may extend the dynamic context (step DQ5)—for example, by binding values to variables.

[Definition: A dynamic type is associated with each value as it is computed. The dynamic type of a value may be more specific than the static type of the expression that computed it (for example, the static type of an expression might be xs:integer*, denoting a sequence of zero or more integers, but at evaluation time its value may have the dynamic type xs:integer, denoting exactly one integer.)]

If an operand of an expression is found to have a dynamic type that is not appropriate for that operand, a type error is raised [err:XPTY0004].

Even though static typing can catch many type errors before an expression is executed, it is possible for an expression to raise an error during evaluation that was not detected by static analysis. For example, an expression may contain a cast of a string into an integer, which is statically valid. However, if the actual value of the string at run time cannot be cast into an integer, a dynamic error will result. Similarly, an expression may apply an arithmetic operator to a value whose static type is xdt:untypedAtomic. This is not a static error, but at run time, if the value cannot be successfully cast to a numeric type, a dynamic error will be raised.

When the Static Typing Feature is in effect, it is also possible for static analysis of an expression to raise a type error, even though execution of the expression on certain inputs would be successful. For example, an expression might contain a function that requires an element as its parameter, and the static analysis phase might infer the static type of the function parameter to be an optional element. This case is treated as a type error and inhibits evaluation, even though the function call would have been successful for input data in which the optional element is present.

#### 2.2.4 Serialization

[Definition: Serialization is the process of converting a data model instance into a sequence of octets (step DM4 in Figure 1.) ] The general framework for serialization is described in [XSLT 2.0 and XQuery 1.0 Serialization].

The host language may provide a serialization option.

#### 2.2.5 Consistency Constraints

In order for XPath to be well defined, the input data model instance, the static context, and the dynamic context must be mutually consistent. The consistency constraints listed below are prerequisites for correct functioning of an XPath implementation. Enforcement of these consistency constraints is beyond the scope of this specification. This specification does not define the result of an expression under any condition in which one or more of these constraints is not satisfied.

Some of the consistency constraints use the term data model schema. [Definition: For a given node in a data model instance, the data model schema is defined as the schema from which the type annotation of that node was derived.] For a node that was constructed by some process other than schema validation, the data model schema consists simply of the schema type definition that is represented by the type annotation of the node.

### 2.3 Error Handling

#### 2.3.1 Kinds of Errors

As described in 2.2.3 Expression Processing, XPath defines a static analysis phase, which does not depend on input data, and a dynamic evaluation phase, which does depend on input data. Errors may be raised during each phase.

[Definition: A static error is an error that must be detected during the static analysis phase. A syntax error is an example of a static error.]

[Definition: A dynamic error is an error that must be detected during the dynamic evaluation phase and may be detected during the static analysis phase. Numeric overflow is an example of a dynamic error. ]

[Definition: A type error may be raised during the static analysis phase or the dynamic evaluation phase. During the static analysis phase, a type error occurs when the static type of an expression does not match the expected type of the context in which the expression occurs. During the dynamic evaluation phase, a type error occurs when the dynamic type of a value does not match the expected type of the context in which the value occurs. ]

The outcome of the static analysis phase is either success or one or more type errors, static errors, or statically-detected dynamic errors. The result of the dynamic evaluation phase is either a result value, a type error, or a dynamic error.

During the static analysis phase, if the Static Typing Feature is in effect and the static type assigned to an expression other than () or data(()) is void(), a static error is raised [err:XPST0005]. This catches cases in which a query refers to an element or attribute that is not present in the in-scope schema definitions, possibly because of a spelling error.

Independently of whether the Static Typing Feature is in effect, if an implementation can determine during the static analysis phase that an expression, if evaluated, would necessarily raise a type error or a dynamic error, the implementation may (but is not required to) report that error during the static analysis phase. However, the fn:error() function must not be evaluated during the static analysis phase.

[Definition: In addition to static errors, dynamic errors, and type errors, an XPath implementation may raise warnings, either during the static analysis phase or the dynamic evaluation phase. The circumstances in which warnings are raised, and the ways in which warnings are handled, are implementation-defined.]

In addition to the errors defined in this specification, an implementation may raise a dynamic error for a reason beyond the scope of this specification. For example, limitations may exist on the maximum numbers or sizes of various objects. Any such limitations, and the consequences of exceeding them, are implementation-dependent.

#### 2.3.2 Identifying and Reporting Errors

The errors defined in this specification are identified by QNames that have the form err:XPYYnnnn, where:

• err denotes the namespace for XPath and XQuery errors, http://www.w3.org/2004/07/xqt-errors. This binding of the namespace prefix err is used for convenience in this document, and is not normative.

• XP identifies the error as an XPath error.

• YY denotes the error category, using the following encoding:

• ST denotes a static error.

• DY denotes a dynamic error.

• TY denotes a type error.

• nnnn is a unique numeric code.

Note:

The namespace URI for XPath and XQuery errors is not expected to change from one version of XPath to another. However, the contents of this namespace may be extended to include additional error definitions.

The method by which an XPath processor reports error information to the external environment is implementation-defined.

An error can be represented by a URI reference that is derived from the error QName as follows: an error with namespace URI NS and local part LP can be represented as the URI reference NS#LP. For example, an error whose QName is err:XPST0017 could be represented as http://www.w3.org/2004/07/xqt-errors#XPST0017.

Note:

Along with a code identifying an error, implementations may wish to return additional information, such as the location of the error or the processing phase in which it was detected. If an implementation chooses to do so, then the mechanism that it uses to return this information is implementation-defined.

#### 2.3.3 Handling Dynamic Errors

Except as noted in this document, if any operand of an expression raises a dynamic error, the expression also raises a dynamic error. If an expression can validly return a value or raise a dynamic error, the implementation may choose to return the value or raise the dynamic error. For example, the logical expression expr1 and expr2 may return the value false if either operand returns false, or may raise a dynamic error if either operand raises a dynamic error.

If more than one operand of an expression raises an error, the implementation may choose which error is raised by the expression. For example, in this expression:

($x div$y) + xs:decimal($z) both the sub-expressions ($x div $y) and xs:decimal($z) may raise an error. The implementation may choose which error is raised by the "+" expression. Once one operand raises an error, the implementation is not required, but is permitted, to evaluate any other operands.

[Definition: In addition to its identifying QName, a dynamic error may also carry a descriptive string and one or more additional values called error values.] An implementation may provide a mechanism whereby an application-defined error handler can process error values and produce diagnostic messages.

A dynamic error may be raised by a built-in function or operator. For example, the div operator raises an error if its operands are xs:decimal values and its second operand is equal to zero. Errors raised by built-in functions and operators are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].

A dynamic error can also be raised explicitly by calling the fn:error function, which only raises an error and never returns a value. This function is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. For example, the following function call raises a dynamic error, providing a QName that identifies the error, a descriptive string, and a diagnostic value (assuming that the prefix app is bound to a namespace containing application-defined error codes):

fn:error(xs:QName("app:err057"), "Unexpected value", fn:string($v)) #### 2.3.4 Errors and Optimization Because different implementations may choose to evaluate or optimize an expression in different ways, certain aspects of the detection and reporting of dynamic errors are implementation-dependent, as described in this section. An implementation is always free to evaluate the operands of an operator in any order. In some cases, a processor can determine the result of an expression without accessing all the data that would be implied by the formal expression semantics. For example, the formal description of filter expressions suggests that $s[1] should be evaluated by examining all the items in sequence $s, and selecting all those that satisfy the predicate position()=1. In practice, many implementations will recognize that they can evaluate this expression by taking the first item in the sequence and then exiting. If $s is defined by an expression such as //book[author eq 'Berners-Lee'], then this strategy may avoid a complete scan of a large document and may therefore greatly improve performance. However, a consequence of this strategy is that a dynamic error or type error that would be detected if the expression semantics were followed literally might not be detected at all if the evaluation exits early. In this example, such an error might occur if there is a book element in the input data with more than one author subelement.

The extent to which a processor may optimize its access to data, at the cost of not detecting errors, is defined by the following rules.

Consider an expression Q that has an operand (sub-expression) E. In general the value of E is a sequence. At an intermediate stage during evaluation of the sequence, some of its items will be known and others will be unknown. If, at such an intermediate stage of evaluation, a processor is able to establish that there are only two possible outcomes of evaluating Q, namely the value V or an error, then the processor may deliver the result V without evaluating further items in the operand E. For this purpose, two values are considered to represent the same outcome if their items are pairwise the same, where nodes are the same if they have the same identity, and values are the same if they are equal and have exactly the same type.

There is an exception to this rule: a processor is required to establish that the actual value of the operand E does not violate any constraints on its cardinality. For example, the expression $e eq 0 results in a type error if the value of $e contains two or more items. A processor is not allowed to decide, after evaluating the first item in the value of $e and finding it equal to zero, that the only possible outcomes are the value true or a type error caused by the cardinality violation. It must establish that the value of $e contains no more than one item.

These rules apply to all the operands of an expression considered in combination: thus if an expression has two operands E1 and E2, it may be evaluated using any samples of the respective sequences that satisfy the above rules.

The rules cascade: if A is an operand of B and B is an operand of C, then the processor needs to evaluate only a sufficient sample of B to determine the value of C, and needs to evaluate only a sufficient sample of A to determine this sample of B.

The effect of these rules is that the processor is free to stop examining further items in a sequence as soon as it can establish that further items would not affect the result except possibly by causing an error. For example, the processor may return true as the result of the expression S1 = S2 as soon as it finds a pair of equal values from the two sequences.

Another consequence of these rules is that where none of the items in a sequence contributes to the result of an expression, the processor is not obliged to evaluate any part of the sequence. Again, however, the processor cannot dispense with a required cardinality check: if an empty sequence is not permitted in the relevant context, then the processor must ensure that the operand is not an empty sequence.

Examples:

• If an implementation can find (for example, by using an index) that at least one item returned by $expr1 in the following example has the value 47, it is allowed to return true as the result of the some expression, without searching for another item returned by $expr1 that would raise an error if it were evaluated.

some $x in$expr1 satisfies $x = 47 • In the following example, if an implementation can find (for example, by using an index) the product element-nodes that have an id child with the value 47, it is allowed to return these nodes as the result of the path expression, without searching for another product node that would raise an error because it has an id child whose value is not an integer. //product[id = 47] For a variety of reasons, including optimization, implementations are free to rewrite expressions into equivalent expressions. Other than the raising or not raising of errors, the result of evaluating an equivalent expression must be the same as the result of evaluating the original expression. Expression rewrite is illustrated by the following examples. • Consider the expression //part[color eq "Red"]. An implementation might choose to rewrite this expression as //part[color = "Red"][color eq "Red"]. The implementation might then process the expression as follows: First process the "=" predicate by probing an index on parts by color to quickly find all the parts that have a Red color; then process the "eq" predicate by checking each of these parts to make sure it has only a single color. The result would be as follows: • Parts that have exactly one color that is Red are returned. • If some part has color Red together with some other color, an error is raised. • The existence of some part that has no color Red but has multiple non-Red colors does not trigger an error. • The expression in the following example cannot raise a casting error if it is evaluated exactly as written (i.e., left to right). An implementation is permitted, however, to reorder the predicates to achieve better performance (for example, by taking advantage of an index). This reordering could cause the expression to raise an error. $N[@x castable as xs:date][xs:date(@x) gt xs:date("2000-01-01")]

To avoid unexpected errors caused by expression rewrite, tests that are designed to prevent dynamic errors should be expressed using conditional expressions. Conditional expressions raise only dynamic errors that occur in the branch that is actually selected. Thus, unlike the previous example, the following example cannot raise a dynamic error if @x is not castable into an xs:date:

[Definition: A variable reference is a QName preceded by a $-sign.] Two variable references are equivalent if their local names are the same and their namespace prefixes are bound to the same namespace URI in the statically known namespaces. An unprefixed variable reference is in no namespace. Every variable reference must match a name in the in-scope variables, which include variables from the following sources: 1. The in-scope variables may be augmented by implementation-defined variables. 2. A variable may be bound by an XPath expression. The kinds of expressions that can bind variables are for expressions (3.7 For Expressions) and quantified expressions (3.9 Quantified Expressions). Every variable binding has a static scope. The scope defines where references to the variable can validly occur. It is a static error [err:XPST0008] to reference a variable that is not in scope. If a variable is bound in the static context for an expression, that variable is in scope for the entire expression. If a variable reference matches two or more variable bindings that are in scope, then the reference is taken as referring to the inner binding, that is, the one whose scope is smaller. At evaluation time, the value of a variable reference is the value of the expression to which the relevant variable is bound. The scope of a variable binding is defined separately for each kind of expression that can bind variables. #### 3.1.3 Parenthesized Expressions  [45] ParenthesizedExpr ::= "(" Expr? ")" Parentheses may be used to enforce a particular evaluation order in expressions that contain multiple operators. For example, the expression (2 + 4) * 5 evaluates to thirty, since the parenthesized expression (2 + 4) is evaluated first and its result is multiplied by five. Without parentheses, the expression 2 + 4 * 5 evaluates to twenty-two, because the multiplication operator has higher precedence than the addition operator. Empty parentheses are used to denote an empty sequence, as described in 3.3.1 Constructing Sequences. #### 3.1.4 Context Item Expression  [46] ContextItemExpr ::= "." A context item expression evaluates to the context item, which may be either a node (as in the expression fn:doc("bib.xml")/books/book[fn:count(./author)>1]) or an atomic value (as in the expression (1 to 100)[. mod 5 eq 0]). If the context item is undefined, a context item expression raises a dynamic error [err:XPDY0002]. #### 3.1.5 Function Calls [Definition: The built-in functions supported by XPath are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].] Additional functions may be provided in the static context. XPath per se does not provide a way to declare functions, but a host language may provide such a mechanism.  [47] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")" A function call consists of a QName followed by a parenthesized list of zero or more expressions, called arguments. If the QName in the function call has no namespace prefix, it is considered to be in the default function namespace. If the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context, an error is raised (the host language environment may define this error as either a static or a dynamic error) [err:XPST0017]. A function call is evaluated as follows: 1. Argument expressions are evaluated, producing argument values. The order of argument evaluation is implementation-dependent and a function need not evaluate an argument if the function can evaluate its body without evaluating that argument. 2. Each argument value is converted by applying the function conversion rules listed below. 3. The function is evaluated using the converted argument values. The result is either an instance of the function's declared return type or a dynamic error. The dynamic type of a function result may be a type that is derived from the declared return type. Errors raised by functions are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The function conversion rules are used to convert an argument value to its expected type; that is, to the declared type of the function parameter. The expected type is expressed as a sequence type. The function conversion rules are applied to a given value as follows: • If XPath 1.0 compatibility mode is true and an argument is not of the expected type, then the following conversions are applied sequentially to the argument value V: 1. If the expected type calls for a single item or optional single item (examples: xs:string, xs:string?, xdt:untypedAtomic, xdt:untypedAtomic?, node(), node()?, item(), item()?), then the value V is effectively replaced by V[1]. 2. If the expected type is xs:string or xs:string?, then the value V is effectively replaced by fn:string(V). 3. If the expected type is xs:double or xs:double?, then the value V is effectively replaced by fn:number(V). • If the expected type is a sequence of an atomic type (possibly with an occurrence indicator *, +, or ?), the following conversions are applied: 1. Atomization is applied to the given value, resulting in a sequence of atomic values. 2. Each item in the atomic sequence that is of type xdt:untypedAtomic is cast to the expected atomic type. For built-in functions where the expected type is specified as numeric, arguments of type xdt:untypedAtomic are cast to xs:double. 3. For each numeric item in the atomic sequence that can be promoted to the expected atomic type using numeric promotion as described in B.1 Type Promotion, the promotion is done. 4. For each item of type xs:anyURI in the atomic sequence that can be promoted to the expected atomic type using URI promotion as described in B.1 Type Promotion, the promotion is done. • If, after the above conversions, the resulting value does not match the expected type according to the rules for SequenceType Matching, a type error is raised [err:XPTY0004]. Note that the rules for SequenceType Matching permit a value of a derived type to be substituted for a value of its base type. Since the arguments of a function call are separated by commas, any argument expression that contains a top-level comma operator must be enclosed in parentheses. Here are some illustrative examples of function calls: • my:three-argument-function(1, 2, 3) denotes a function call with three arguments. • my:two-argument-function((1, 2), 3) denotes a function call with two arguments, the first of which is a sequence of two values. • my:two-argument-function(1, ()) denotes a function call with two arguments, the second of which is an empty sequence. • my:one-argument-function((1, 2, 3)) denotes a function call with one argument that is a sequence of three values. • my:one-argument-function(( )) denotes a function call with one argument that is an empty sequence. • my:zero-argument-function( ) denotes a function call with zero arguments. ### 3.2 Path Expressions  [25] PathExpr ::= ("/" RelativePathExpr?)| ("//" RelativePathExpr)| RelativePathExpr [26] RelativePathExpr ::= StepExpr (("/" | "//") StepExpr)* [Definition: A path expression can be used to locate nodes within trees. A path expression consists of a series of one or more steps, separated by "/" or "//", and optionally beginning with "/" or "//".] An initial "/" or "//" is an abbreviation for one or more initial steps that are implicitly added to the beginning of the path expression, as described below. A path expression consisting of a single step is evaluated as described in 3.2.1 Steps. A "/" at the beginning of a path expression is an abbreviation for the initial step fn:root(self::node()) treat as document-node() (this is true even if the "/" is the entire path expression). The effect of this initial step is to begin the path at the root node of the tree that contains the context node. If the context item is not a node, a type error is raised [err:XPTY0020]. At evaluation time, if the root node above the context node is not a document node, a dynamic error is raised [err:XPDY0050]. A "//" at the beginning of a path expression is an abbreviation for the initial steps fn:root(self::node()) treat as document-node()/descendant-or-self::node()/. The effect of these initial steps is to establish an initial node sequence that contains the root of the tree in which the context node is found, plus all nodes descended from this root. This node sequence is used as the input to subsequent steps in the path expression. If the context item is not a node, a type error is raised [err:XPTY0020]. At evaluation time, if the root node above the context node is not a document node, a dynamic error is raised [err:XPDY0050]. Note: The descendants of a node do not include attribute nodes or namespace nodes. Each non-initial occurrence of "//" in a path expression is expanded as described in 3.2.4 Abbreviated Syntax, leaving a sequence of steps separated by "/". This sequence of steps is then evaluated from left to right. Each operation E1/E2 is evaluated as follows: Expression E1 is evaluated, and if the result is not a (possibly empty) sequence of nodes, a type error is raised [err:XPTY0019]. Each node resulting from the evaluation of E1 then serves in turn to provide an inner focus for an evaluation of E2, as described in 2.1.2 Dynamic Context. The sequences resulting from all the evaluations of E2 are combined as follows: 1. If every evaluation of E2 returns a (possibly empty) sequence of nodes, these sequences are combined, and duplicate nodes are eliminated based on node identity. The resulting node sequence is returned in document order. 2. If every evaluation of E2 returns a (possibly empty) sequence of atomic values, these sequences are concatenated, in order, and returned. 3. If the multiple evaluations of E2 return at least one node and at least one atomic value, a type error is raised [err:XPTY0018]. Note: Since each step in a path provides context nodes for the following step, in effect, only the last step in a path is allowed to return a sequence of atomic values. As an example of a path expression, child::div1/child::para selects the para element children of the div1 element children of the context node, or, in other words, the para element grandchildren of the context node that have div1 parents. Note: The "/" character can be used either as an individual token or as part of a pattern such as "/*". This can cause parsing difficulties when "/" appears on the left hand side of an operator. For example, "/*" and "/ *" are valid path expressions containing wildcards, but "/*5" and "/ * 5" raise parsing errors. Parentheses must be used when "/" is used as the first operand of an operator, as in "(/) * 5". Similarly, "4 + / * 5" raises a parsing error, but "4 + (/) * 5" is a valid expression. The expression "4 + /" is also valid, because / does not occur on the left hand side of the operator. #### 3.2.1 Steps  [27] StepExpr ::= AxisStep | FilterExpr [28] AxisStep ::= (ForwardStep | ReverseStep) PredicateList [29] ForwardStep ::= (ForwardAxis NodeTest) | AbbrevForwardStep [32] ReverseStep ::= (ReverseAxis NodeTest) | AbbrevReverseStep [39] PredicateList ::= Predicate* [Definition: A step is a part of a path expression that generates a sequence of items and then filters the sequence by zero or more predicates. The value of the step consists of those items that satisfy the predicates. A step may be either an axis step or a filter expression.] Filter expressions are described in 3.3.2 Filter Expressions. [Definition: An axis step returns a sequence of nodes that are reachable from the context node via a specified axis. Such a step has two parts: an axis, which defines the "direction of movement" for the step, and a node test, which selects nodes based on their kind, name, and/or type annotation.] If the context item is a node, an axis step returns a sequence of zero or more nodes; otherwise, a type error is raised [err:XPTY0020]. The resulting node sequence is returned in document order. An axis step may be either a forward step or a reverse step, followed by zero or more predicates. In the abbreviated syntax for a step, the axis can be omitted and other shorthand notations can be used as described in 3.2.4 Abbreviated Syntax. The unabbreviated syntax for an axis step consists of the axis name and node test separated by a double colon. The result of the step consists of the nodes reachable from the context node via the specified axis that have the node kind, name, and/or type annotation specified by the node test. For example, the step child::para selects the para element children of the context node: child is the name of the axis, and para is the name of the element nodes to be selected on this axis. The available axes are described in 3.2.1.1 Axes. The available node tests are described in 3.2.1.2 Node Tests. Examples of steps are provided in 3.2.3 Unabbreviated Syntax and 3.2.4 Abbreviated Syntax. ##### 3.2.1.1 Axes  [30] ForwardAxis ::= ("child" "::")| ("descendant" "::")| ("attribute" "::")| ("self" "::")| ("descendant-or-self" "::")| ("following-sibling" "::")| ("following" "::")| ("namespace" "::") [33] ReverseAxis ::= ("parent" "::")| ("ancestor" "::")| ("preceding-sibling" "::")| ("preceding" "::")| ("ancestor-or-self" "::") XPath defines a full set of axes for traversing documents, but a host language may define a subset of these axes. The following axes are defined: • The child axis contains the children of the context node, which are the nodes returned by the dm:children accessor in [XQuery 1.0 and XPath 2.0 Data Model]. Note: Only document nodes and element nodes have children. If the context node is any other kind of node, or if the context node is an empty document or element node, then the child axis is an empty sequence. The children of a document node or element node may be element, processing instruction, comment, or text nodes. Attribute, namespace, and document nodes can never appear as children. • the descendant axis is defined as the transitive closure of the child axis; it contains the descendants of the context node (the children, the children of the children, and so on) • the parent axis contains the sequence returned by the dm:parent accessor in [XQuery 1.0 and XPath 2.0 Data Model], which returns the parent of the context node, or an empty sequence if the context node has no parent Note: An attribute node may have an element node as its parent, even though the attribute node is not a child of the element node. • the ancestor axis is defined as the transitive closure of the parent axis; it contains the ancestors of the context node (the parent, the parent of the parent, and so on) Note: The ancestor axis includes the root node of the tree in which the context node is found, unless the context node is the root node. • the following-sibling axis contains the context node's following siblings, those children of the context node's parent that occur after the context node in document order; if the context node is an attribute or namespace node, the following-sibling axis is empty • the preceding-sibling axis contains the context node's preceding siblings, those children of the context node's parent that occur before the context node in document order; if the context node is an attribute or namespace node, the preceding-sibling axis is empty • the following axis contains all nodes that are descendants of the root of the tree in which the context node is found, are not descendants of the context node, and occur after the context node in document order • the preceding axis contains all nodes that are descendants of the root of the tree in which the context node is found, are not ancestors of the context node, and occur before the context node in document order • the attribute axis contains the attributes of the context node, which are the nodes returned by the dm:attributes accessor in [XQuery 1.0 and XPath 2.0 Data Model]; the axis will be empty unless the context node is an element • the self axis contains just the context node itself • the descendant-or-self axis contains the context node and the descendants of the context node • the ancestor-or-self axis contains the context node and the ancestors of the context node; thus, the ancestor-or-self axis will always include the root node • the namespace axis contains the namespace nodes of the context node, which are the nodes returned by the dm:namespaces accessor in [XQuery 1.0 and XPath 2.0 Data Model]; this axis is empty unless the context node is an element node. The namespace axis is deprecated in XPath 2.0. If XPath 1.0 compatibility mode is true, the namespace axis must be supported. If XPath 1.0 compatibility mode is false, then support for the namespace axis is implementation-defined. An implementation that does not support the namespace axis when XPath 1.0 compatibility mode is false must raise a static error [err:XPST0010] if it is used. Applications needing information about the in-scope namespaces of an element should use the functions fn:in-scope-prefixes and fn:namespace-uri-for-prefix defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. Axes can be categorized as forward axes and reverse axes. An axis that only ever contains the context node or nodes that are after the context node in document order is a forward axis. An axis that only ever contains the context node or nodes that are before the context node in document order is a reverse axis. The parent, ancestor, ancestor-or-self, preceding, and preceding-sibling axes are reverse axes; all other axes are forward axes. The ancestor, descendant, following, preceding and self axes partition a document (ignoring attribute and namespace nodes): they do not overlap and together they contain all the nodes in the document. [Definition: Every axis has a principal node kind. If an axis can contain elements, then the principal node kind is element; otherwise, it is the kind of nodes that the axis can contain.] Thus: • For the attribute axis, the principal node kind is attribute. • For the namespace axis, the principal node kind is namespace. • For all other axes, the principal node kind is element. In a sequence of nodes selected by an axis step, each node is assigned a context position that corresponds to its position in the sequence. If the axis is a forward axis, context positions are assigned to the nodes in document order, starting with 1. If the axis is a reverse axis, context positions are assigned to the nodes in reverse document order, starting with 1. This makes it possible to select a node from the sequence by specifying its position. Note: One example of an expression that uses the context position is a numeric predicate. The expression child::para[1] selects the first para element that is a child of the context node. ##### 3.2.1.2 Node Tests [Definition: A node test is a condition that must be true for each node selected by a step.] The condition may be based on the kind of the node (element, attribute, text, document, comment, or processing instruction), the name of the node, or (in the case of element, attribute, and document nodes), the type annotation of the node.  [35] NodeTest ::= KindTest | NameTest [36] NameTest ::= QName | Wildcard [37] Wildcard ::= "*"| (NCName ":" "*")| ("*" ":" NCName) [Definition: A node test that consists only of a QName or a Wildcard is called a name test.] A name test is true if and only if the kind of the node is the principal node kind for the step axis and the expanded QName of the node is equal (on a codepoint basis) to the expanded QName specified by the name test. For example, child::para selects the para element children of the context node; if the context node has no para children, it selects an empty set of nodes. attribute::abc:href selects the attribute of the context node with the QName abc:href; if the context node has no such attribute, it selects an empty set of nodes. A QName in a name test is resolved into an expanded QName using the statically known namespaces in the expression context. It is a static error [err:XPST0008] if the QName has a prefix that does not correspond to any statically known namespace. An unprefixed QName, when used as a name test on an axis whose principal node kind is element, has the namespace URI of the default element/type namespace in the expression context; otherwise, it has no namespace URI. A name test is not satisfied by an element node whose name does not match the expanded QName of the name test, even if it is in a substitution group whose head is the named element. A node test * is true for any node of the principal node kind of the step axis. For example, child::* will select all element children of the context node, and attribute::* will select all attributes of the context node. A node test can have the form NCName:*. In this case, the prefix is expanded in the same way as with a QName, using the statically known namespaces in the static context. If the prefix is not found in the statically known namespaces, a static error is raised [err:XPST0008]. The node test is true for any node of the principal node kind of the step axis whose expanded QName has the namespace URI to which the prefix is bound, regardless of the local part of the name. A node test can also have the form *:NCName. In this case, the node test is true for any node of the principal node kind of the step axis whose local name matches the given NCName, regardless of its namespace or lack of a namespace. [Definition: An alternative form of a node test called a kind test can select nodes based on their kind, name, and type annotation.] The syntax and semantics of a kind test are described in 2.5.3 SequenceType Syntax and 2.5.4 SequenceType Matching. When a kind test is used in a node test, only those nodes on the designated axis that match the kind test are selected. Shown below are several examples of kind tests that might be used in path expressions: • node() matches any node. • text() matches any text node. • comment() matches any comment node. • element() matches any element node. • schema-element(person) matches any element node whose name is person (or is in the substitution group headed by person), and whose type annotation is the same as (or is derived from) the declared type of the person element in the in-scope element declarations. • element(person) matches any element node whose name is person, regardless of its type annotation. • element(person, surgeon) matches any non-nilled element node whose name is person, and whose type annotation is surgeon or is derived from surgeon. • element(*, surgeon) matches any non-nilled element node whose type annotation is surgeon (or is derived from surgeon), regardless of its name. • attribute() matches any attribute node. • attribute(price) matches any attribute whose name is price, regardless of its type annotation. • attribute(*, xs:decimal) matches any attribute whose type annotation is xs:decimal (or is derived from xs:decimal), regardless of its name. • document-node() matches any document node. • document-node(element(book)) matches any document node whose content consists of a single element node that satisfies the kind test element(book), interleaved with zero or more comments and processing instructions. #### 3.2.2 Predicates  [40] Predicate ::= "[" Expr "]" [Definition: A predicate consists of an expression, called a predicate expression, enclosed in square brackets. A predicate serves to filter a sequence, retaining some items and discarding others.] For each item in the sequence to be filtered, the predicate expression is evaluated using an inner focus derived from that item, as described in 2.1.2 Dynamic Context. The result of the predicate expression is coerced to a xs:boolean value, called the predicate truth value, as described below. Those items for which the predicate truth value is true are retained, and those for which the predicate truth value is false are discarded. The predicate truth value is derived by applying the following rules, in order: 1. If the value of the predicate expression is a singleton atomic value of a numeric type or derived from a numeric type, the predicate truth value is true if the value of the predicate expression is equal (by the eq operator) to the context position, and is false otherwise. [Definition: A predicate whose predicate expression returns a numeric type is called a numeric predicate.] 2. Otherwise, the predicate truth value is the effective boolean value of the predicate expression. Here are some examples of axis steps that contain predicates: • This example selects the second chapter element that is a child of the context node: child::chapter[2] • This example selects all the descendants of the context node that are elements named "toy" and whose color attribute has the value "red": descendant::toy[attribute::color = "red"] • This example selects all the employee children of the context node that have both a secretary child element and an assistant child element: child::employee[secretary][assistant] When using predicates with a sequence of nodes selected using a reverse axis, it is important to remember that the the context positions for such a sequence are assigned in reverse document order. For example, preceding::foo[1] returns the first qualifying foo element in reverse document order, because the predicate is part of an axis step using a reverse axis. By contrast, (preceding::foo)[1] returns the first qualifying foo element in document order, because the parentheses cause (preceding::foo) to be parsed as a primary expression in which context positions are assigned in document order. Similarly, ancestor::*[1] returns the nearest ancestor element, because the ancestor axis is a reverse axis, whereas (ancestor::*)[1] returns the root element (first ancestor in document order). #### 3.2.3 Unabbreviated Syntax This section provides a number of examples of path expressions in which the axis is explicitly specified in each step. The syntax used in these examples is called the unabbreviated syntax. In many common cases, it is possible to write path expressions more concisely using an abbreviated syntax, as explained in 3.2.4 Abbreviated Syntax. • child::para selects the para element children of the context node • child::* selects all element children of the context node • child::text() selects all text node children of the context node • child::node() selects all the children of the context node. Note that no attribute nodes are returned, because attributes are not children. • attribute::name selects the name attribute of the context node • attribute::* selects all the attributes of the context node • parent::node() selects the parent of the context node. If the context node is an attribute node, this expression returns the element node (if any) to which the attribute node is attached. • descendant::para selects the para element descendants of the context node • ancestor::div selects all div ancestors of the context node • ancestor-or-self::div selects the div ancestors of the context node and, if the context node is a div element, the context node as well • descendant-or-self::para selects the para element descendants of the context node and, if the context node is a para element, the context node as well • self::para selects the context node if it is a para element, and otherwise returns an empty sequence • child::chapter/descendant::para selects the para element descendants of the chapter element children of the context node • child::*/child::para selects all para grandchildren of the context node • / selects the root of the tree that contains the context node, but raises a dynamic error if this root is not a document node • /descendant::para selects all the para elements in the same document as the context node • /descendant::list/child::member selects all the member elements that have a list parent and that are in the same document as the context node • child::para[fn:position() = 1] selects the first para child of the context node • child::para[fn:position() = fn:last()] selects the last para child of the context node • child::para[fn:position() = fn:last()-1] selects the last but one para child of the context node • child::para[fn:position() > 1] selects all the para children of the context node other than the first para child of the context node • following-sibling::chapter[fn:position() = 1]selects the next chapter sibling of the context node • preceding-sibling::chapter[fn:position() = 1]selects the previous chapter sibling of the context node • /descendant::figure[fn:position() = 42] selects the forty-second figure element in the document containing the context node • /child::book/child::chapter[fn:position() = 5]/child::section[fn:position() = 2] selects the second section of the fifth chapter of the book whose parent is the document node that contains the context node • child::para[attribute::type eq "warning"]selects all para children of the context node that have a type attribute with value warning • child::para[attribute::type eq 'warning'][fn:position() = 5]selects the fifth para child of the context node that has a type attribute with value warning • child::para[fn:position() = 5][attribute::type eq "warning"]selects the fifth para child of the context node if that child has a type attribute with value warning • child::chapter[child::title = 'Introduction']selects the chapter children of the context node that have one or more title children whose typed value is equal to the string Introduction • child::chapter[child::title] selects the chapter children of the context node that have one or more title children • child::*[self::chapter or self::appendix] selects the chapter and appendix children of the context node • child::*[self::chapter or self::appendix][fn:position() = fn:last()] selects the last chapter or appendix child of the context node #### 3.2.4 Abbreviated Syntax  [31] AbbrevForwardStep ::= "@"? NodeTest [34] AbbrevReverseStep ::= ".." The abbreviated syntax permits the following abbreviations: 1. The attribute axis attribute:: can be abbreviated by @. For example, a path expression para[@type="warning"] is short for child::para[attribute::type="warning"] and so selects para children with a type attribute with value equal to warning. 2. If the axis name is omitted from an axis step, the default axis is child unless the axis step contains an AttributeTest; in that case, the default axis is attribute. For example, the path expression section/para is an abbreviation for child::section/child::para, and the path expression section/@id is an abbreviation for child::section/attribute::id. Similarly, section/attribute(id) is an abbreviation for child::section/attribute::attribute(id). Note that the latter expression contains both an axis specification and a node test. 3. Each non-initial occurrence of // is effectively replaced by /descendant-or-self::node()/ during processing of a path expression. For example, div1//para is short for child::div1/descendant-or-self::node()/child::para and so will select all para descendants of div1 children. Note: The path expression //para[1] does not mean the same as the path expression /descendant::para[1]. The latter selects the first descendant para element; the former selects all descendant para elements that are the first para children of their respective parents. 4. A step consisting of .. is short for parent::node(). For example, ../title is short for parent::node()/child::title and so will select the title children of the parent of the context node. Note: The expression ., known as a context item expression, is a primary expression, and is described in 3.1.4 Context Item Expression. Here are some examples of path expressions that use the abbreviated syntax: • para selects the para element children of the context node • * selects all element children of the context node • text() selects all text node children of the context node • @name selects the name attribute of the context node • @* selects all the attributes of the context node • para[1] selects the first para child of the context node • para[fn:last()] selects the last para child of the context node • */para selects all para grandchildren of the context node • /book/chapter[5]/section[2] selects the second section of the fifth chapter of the book whose parent is the document node that contains the context node • chapter//para selects the para element descendants of the chapter element children of the context node • //para selects all the para descendants of the root document node and thus selects all para elements in the same document as the context node • //@version selects all the version attribute nodes that are in the same document as the context node • //list/member selects all the member elements in the same document as the context node that have a list parent • .//para selects the para element descendants of the context node • .. selects the parent of the context node • ../@lang selects the lang attribute of the parent of the context node • para[@type="warning"] selects all para children of the context node that have a type attribute with value warning • para[@type="warning"][5] selects the fifth para child of the context node that has a type attribute with value warning • para[5][@type="warning"] selects the fifth para child of the context node if that child has a type attribute with value warning • chapter[title="Introduction"] selects the chapter children of the context node that have one or more title children whose typed value is equal to the string Introduction • chapter[title] selects the chapter children of the context node that have one or more title children • employee[@secretary and @assistant] selects all the employee children of the context node that have both a secretary attribute and an assistant attribute • book/(chapter|appendix)/section selects every section element that has a parent that is either a chapter or an appendix element, that in turn is a child of a book element that is a child of the context node. • If E is any expression that returns a sequence of nodes, then the expression E/. returns the same nodes in document order, with duplicates eliminated based on node identity. ### 3.3 Sequence Expressions XPath supports operators to construct, filter, and combine sequences of items. Sequences are never nested—for example, combining the values 1, (2, 3), and ( ) into a single sequence results in the sequence (1, 2, 3). #### 3.3.1 Constructing Sequences  [2] Expr ::= ExprSingle ("," ExprSingle)* [11] RangeExpr ::= AdditiveExpr ( "to" AdditiveExpr )? [Definition: One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence.] Empty parentheses can be used to denote an empty sequence. A sequence may contain duplicate atomic values or nodes, but a sequence is never an item in another sequence. When a new sequence is created by concatenating two or more input sequences, the new sequence contains all the items of the input sequences and its length is the sum of the lengths of the input sequences. Note: In places where the grammar calls for ExprSingle, such as the arguments of a function call, any expression that contains a top-level comma operator must be enclosed in parentheses. Here are some examples of expressions that construct sequences: • The result of this expression is a sequence of five integers: (10, 1, 2, 3, 4) • This expression combines four sequences of length one, two, zero, and two, respectively, into a single sequence of length five. The result of this expression is the sequence 10, 1, 2, 3, 4. (10, (1, 2), (), (3, 4)) • The result of this expression is a sequence containing all salary children of the context node followed by all bonus children. (salary, bonus) • Assuming that $price is bound to the value 10.50, the result of this expression is the sequence 10.50, 10.50.

($price,$price)

A range expression can be used to construct a sequence of consecutive integers. Each of the operands of the to operator is converted as though it was an argument of a function with the expected parameter type xs:integer?. If either operand is an empty sequence, or if the integer derived from the first operand is greater than the integer derived from the second operand, the result of the range expression is an empty sequence. Otherwise, the result is a sequence containing the two integer operands and every integer between the two operands, in increasing order.

• This example uses a range expression as one operand in constructing a sequence. It evaluates to the sequence 10, 1, 2, 3, 4.

(10, 1 to 4)
• This example constructs a sequence of length one containing the single integer 10.

10 to 10
• The result of this example is a sequence of length zero.

15 to 10
• This example uses the fn:reverse function to construct a sequence of six integers in decreasing order. It evaluates to the sequence 15, 14, 13, 12, 11, 10.

fn:reverse(10 to 15)

#### 3.3.2 Filter Expressions

 [38] FilterExpr ::= PrimaryExpr PredicateList [39] PredicateList ::= Predicate*

[Definition: A filter expression consists simply of a primary expression followed by zero or more predicates. The result of the filter expression consists of all the items returned by the primary expression for which all the predicates are true.] If no predicates are specified, the result is simply the result of the primary expression. The ordering of the items returned by a filter expression is the same as their order in the result of the primary expression. Context positions are assigned to items based on their ordinal position in the result sequence. The first context position is 1.

Here are some examples of filter expressions:

• Given a sequence of products in a variable, return only those products whose price is greater than 100.

$products[price gt 100] • List all the integers from 1 to 100 that are divisible by 5. (See 3.3.1 Constructing Sequences for an explanation of the to operator.) (1 to 100)[. mod 5 eq 0] • The result of the following expression is the integer 25: (21 to 29)[5] • The following example illustrates the use of a filter expression as a step in a path expression. It returns the last chapter or appendix within the book bound to variable $book:

$book/(chapter | appendix)[fn:last()] • The following example also illustrates the use of a filter expression as a step in a path expression. It returns the element node within the specified document whose ID value is tiger: fn:doc("zoo.xml")/fn:id('tiger') #### 3.3.3 Combining Node Sequences  [14] UnionExpr ::= IntersectExceptExpr ( ("union" | "|") IntersectExceptExpr )* [15] IntersectExceptExpr ::= InstanceofExpr ( ("intersect" | "except") InstanceofExpr )* XPath provides the following operators for combining sequences of nodes: • The union and | operators are equivalent. They take two node sequences as operands and return a sequence containing all the nodes that occur in either of the operands. • The intersect operator takes two node sequences as operands and returns a sequence containing all the nodes that occur in both operands. • The except operator takes two node sequences as operands and returns a sequence containing all the nodes that occur in the first operand but not in the second operand. All these operators eliminate duplicate nodes from their result sequences based on node identity. The resulting sequence is returned in document order. If an operand of union, intersect, or except contains an item that is not a node, a type error is raised [err:XPTY0004]. Here are some examples of expressions that combine sequences. Assume the existence of three element nodes that we will refer to by symbolic names A, B, and C. Assume that the variables $seq1, $seq2 and $seq3 are bound to the following sequences of these nodes:

• $seq1 is bound to (A, B) • $seq2 is bound to (A, B)

$book1/author = "Kennedy" • The following example contains three general comparisons. The value of the first two comparisons is true, and the value of the third comparison is false. This example illustrates the fact that general comparisons are not transitive. (1, 2) = (2, 3)(2, 3) = (3, 4)(1, 2) = (3, 4) • The following example contains two general comparisons, both of which are true. This example illustrates the fact that the = and != operators are not inverses of each other. (1, 2) = (2, 3)(1, 2) != (2, 3) • Suppose that $a, $b, and $c are bound to element nodes with type annotation xdt:untypedAtomic, with string values "1", "2", and "2.0" respectively. Then ($a,$b) = ($c, 3.0) returns false, because $b and $c are compared as strings. However, ($a, $b) = ($c, 2.0) returns true, because $b and 2.0 are compared as numbers. #### 3.5.3 Node Comparisons Node comparisons are used to compare two nodes, by their identity or by their document order. The result of a node comparison is defined by the following rules: 1. The operands of a node comparison are evaluated in implementation-dependent order. 2. Each operand must be either a single node or an empty sequence; otherwise a type error is raised [err:XPTY0004]. 3. If either operand is an empty sequence, the result of the comparison is an empty sequence, and the implementation need not evaluate the other operand or apply the operator. However, an implementation may choose to evaluate the other operand in order to determine whether it raises an error. 4. A comparison with the is operator is true if the two operand nodes have the same identity, and are thus the same node; otherwise it is false. See [XQuery 1.0 and XPath 2.0 Data Model] for a definition of node identity. 5. A comparison with the << operator returns true if the left operand node precedes the right operand node in document order; otherwise it returns false. 6. A comparison with the >> operator returns true if the left operand node follows the right operand node in document order; otherwise it returns false. Here are some examples of node comparisons: • The following comparison is true only if the left and right sides each evaluate to exactly the same single node: /books/book[isbn="1558604820"] is /books/book[call="QA76.9 C3845"] • The following comparison is true only if the node identified by the left side occurs before the node identified by the right side in document order: /transactions/purchase[parcel="28-451"] << /transactions/sale[parcel="33-870"] ### 3.6 Logical Expressions A logical expression is either an and-expression or an or-expression. If a logical expression does not raise an error, its value is always one of the boolean values true or false.  [8] OrExpr ::= AndExpr ( "or" AndExpr )* [9] AndExpr ::= ComparisonExpr ( "and" ComparisonExpr )* The first step in evaluating a logical expression is to find the effective boolean value of each of its operands (see 2.4.3 Effective Boolean Value). The value of an and-expression is determined by the effective boolean values (EBV's) of its operands, as shown in the following table:  AND: EBV2 = true EBV2 = false error in EBV2 EBV1 = true true false error EBV1 = false false false if XPath 1.0 compatibility mode is true, then false; otherwise either false or error. error in EBV1 error if XPath 1.0 compatibility mode is true, then error; otherwise either false or error. error The value of an or-expression is determined by the effective boolean values (EBV's) of its operands, as shown in the following table:  OR: EBV2 = true EBV2 = false error in EBV2 EBV1 = true true true if XPath 1.0 compatibility mode is true, then true; otherwise either true or error. EBV1 = false true false error error in EBV1 if XPath 1.0 compatibility mode is true, then error; otherwise either true or error. error error If XPath 1.0 compatibility mode is true, the order in which the operands of a logical expression are evaluated is effectively prescribed. Specifically, it is defined that when there is no need to evaluate the second operand in order to determine the result, then no error can occur as a result of evaluating the second operand. If XPath 1.0 compatibility mode is false, the order in which the operands of a logical expression are evaluated is implementation-dependent. In this case, an or-expression can return true if the first expression evaluated is true, and it can raise an error if evaluation of the first expression raises an error. Similarly, an and-expression can return false if the first expression evaluated is false, and it can raise an error if evaluation of the first expression raises an error. As a result of these rules, a logical expression is not deterministic in the presence of errors, as illustrated in the examples below. Here are some examples of logical expressions: • The following expressions return true: 1 eq 1 and 2 eq 2 1 eq 1 or 2 eq 3 • The following expression may return either false or raise a dynamic error(in XPath 1.0 compatibility mode, the result must be false): 1 eq 2 and 3 idiv 0 = 1 • The following expression may return either true or raise a dynamic error(in XPath 1.0 compatibility mode, the result must be true): 1 eq 1 or 3 idiv 0 = 1 • The following expression must raise a dynamic error: 1 eq 1 and 3 idiv 0 = 1 In addition to and- and or-expressions, XPath provides a function named fn:not that takes a general sequence as parameter and returns a boolean value. The fn:not function is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The fn:not function reduces its parameter to an effective boolean value. It then returns true if the effective boolean value of its parameter is false, and false if the effective boolean value of its parameter is true. If an error is encountered in finding the effective boolean value of its operand, fn:not raises the same error. ### 3.7 For Expressions XPath provides an iteration facility called a for expression.  [4] ForExpr ::= SimpleForClause "return" ExprSingle [5] SimpleForClause ::= "for" "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* A for expression is evaluated as follows: 1. If the for expression uses multiple variables, it is first expanded to a set of nested for expressions, each of which uses only one variable. For example, the expression for$x in X, $y in Y return$x + $y is expanded to for$x in X return for $y in Y return$x + $y. 2. In a single-variable for expression, the variable is called the range variable, the value of the expression that follows the in keyword is called the binding sequence, and the expression that follows the return keyword is called the return expression. The result of the for expression is obtained by evaluating the return expression once for each item in the binding sequence, with the range variable bound to that item. The resulting sequences are concatenated (as if by the comma operator) in the order of the items in the binding sequence from which they were derived. The following example illustrates the use of a for expression in restructuring an input document. The example is based on the following input: <bib> <book> <title>TCP/IP Illustrated</title> <author>Stevens</author> <publisher>Addison-Wesley</publisher> </book> <book> <title>Advanced Programming in the Unix Environment</title> <author>Stevens</author> <publisher>Addison-Wesley</publisher> </book> <book> <title>Data on the Web</title> <author>Abiteboul</author> <author>Buneman</author> <author>Suciu</author> </book></bib> The following example transforms the input document into a list in which each author's name appears only once, followed by a list of titles of books written by that author. This example assumes that the context item is the bib element in the input document. for$a in fn:distinct-values(/bib/book/author)return ($a, /bib/book[author =$a]/title)


The result of the above expression consists of the following sequence of elements. The titles of books written by a given author are listed after the name of the author. The ordering of author elements in the result is implementation-dependent due to the semantics of the fn:distinct-values function.

<author>Stevens</author> <title>TCP/IP Illustrated</title><title>Advanced Programming in the Unix environment</title><author>Abiteboul</author><title>Data on the Web</title><author>Buneman</author><title>Data on the Web</title><author>Suciu</author><title>Data on the Web</title>

The following example illustrates a for expression containing more than one variable:

for $i in (10, 20),$j in (1, 2)return ($i +$j)


The result of the above expression, expressed as a sequence of numbers, is as follows: 11, 12, 21, 22

The scope of a variable bound in a for expression comprises all subexpressions of the for expression that appear after the variable binding. The scope does not include the expression to which the variable is bound. The following example illustrates how a variable binding may reference another variable bound earlier in the same for expression:

for $x in$z, $y in f($x)return g($x,$y)


Note:

The focus for evaluation of the return clause of a for expression is the same as the focus for evaluation of the for expression itself. The following example, which attempts to find the total value of a set of order-items, is therefore incorrect:

fn:sum(for $i in order-item return @price *@qty) Instead, the expression must be written to use the variable bound in the for clause: fn:sum(for$i in order-item    return $i/@price *$i/@qty)

### 3.8 Conditional Expressions

XPath supports a conditional expression based on the keywords if, then, and else.

 [7] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle

The expression following the if keyword is called the test expression, and the expressions following the then and else keywords are called the then-expression and else-expression, respectively.

The first step in processing a conditional expression is to find the effective boolean value of the test expression, as defined in 2.4.3 Effective Boolean Value.

The value of a conditional expression is defined as follows: If the effective boolean value of the test expression is true, the value of the then-expression is returned. If the effective boolean value of the test expression is false, the value of the else-expression is returned.

Conditional expressions have a special rule for propagating dynamic errors. If the effective value of the test expression is true, the conditional expression ignores (does not raise) any dynamic errors encountered in the else-expression. In this case, since the else-expression can have no observable effect, it need not be evaluated. Similarly, if the effective value of the test expression is false, the conditional expression ignores any dynamic errors encountered in the then-expression, and the then-expression need not be evaluated.

Here are some examples of conditional expressions:

• In this example, the test expression is a comparison expression:

if ($widget1/unit-cost <$widget2/unit-cost)   then $widget1 else$widget2
• In this example, the test expression tests for the existence of an attribute named discounted, independently of its value:

if ($part/@discounted) then$part/wholesale   else $part/retail ### 3.9 Quantified Expressions Quantified expressions support existential and universal quantification. The value of a quantified expression is always true or false.  [6] QuantifiedExpr ::= (("some" "$") | ("every" "$")) VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* "satisfies" ExprSingle

A quantified expression begins with a quantifier, which is the keyword some or every, followed by one or more in-clauses that are used to bind variables, followed by the keyword satisfies and a test expression. Each in-clause associates a variable with an expression that returns a sequence of items, called the binding sequence for that variable. The in-clauses generate tuples of variable bindings, including a tuple for each combination of items in the binding sequences of the respective variables. Conceptually, the test expression is evaluated for each tuple of variable bindings. Results depend on the effective boolean value of the test expressions, as defined in 2.4.3 Effective Boolean Value. The value of the quantified expression is defined by the following rules:

1. If the quantifier is some, the quantified expression is true if at least one evaluation of the test expression has the effective boolean value true; otherwise the quantified expression is false. This rule implies that, if the in-clauses generate zero binding tuples, the value of the quantified expression is false.

2. If the quantifier is every, the quantified expression is true if every evaluation of the test expression has the effective boolean value true; otherwise the quantified expression is false. This rule implies that, if the in-clauses generate zero binding tuples, the value of the quantified expression is true.

The scope of a variable bound in a quantified expression comprises all subexpressions of the quantified expression that appear after the variable binding. The scope does not include the expression to which the variable is bound.

The order in which test expressions are evaluated for the various binding tuples is implementation-dependent. If the quantifier is some, an implementation may return true as soon as it finds one binding tuple for which the test expression has an effective boolean value of true, and it may raise a dynamic error as soon as it finds one binding tuple for which the test expression raises an error. Similarly, if the quantifier is every, an implementation may return false as soon as it finds one binding tuple for which the test expression has an effective boolean value of false, and it may raise a dynamic error as soon as it finds one binding tuple for which the test expression raises an error. As a result of these rules, the value of a quantified expression is not deterministic in the presence of errors, as illustrated in the examples below.

Here are some examples of quantified expressions:

• This expression is true if every part element has a discounted attribute (regardless of the values of these attributes):

every $part in /parts/part satisfies$part/@discounted
• This expression is true if at least one employee element satisfies the given comparison expression:

#### 3.10.4 Constructor Functions

For every atomic type in the in-scope schema types that is in a namespace (except xs:NOTATION and xdt:anyAtomicType, which are not instantiable), a constructor function is implicitly defined. In each case, the name of the constructor function is the same as the name of its target type (including namespace). The signature of the constructor function for type T is as follows:

T($arg as xdt:anyAtomicType?) as T?  [Definition: The constructor function for a given type is used to convert instances of other atomic types into the given type. The semantics of the constructor function T($arg) are defined to be equivalent to the expression ($arg cast as T?).] The constructor functions for xs:QName and for types derived from xs:QName and xs:NOTATION require their arguments to be string literals; otherwise a static error [err:XPST0083] is raised. This rule is consistent with the semantics of cast expressions for these types, as defined in 3.10.2 Cast. The following examples illustrate the use of constructor functions: • This example is equivalent to ("2000-01-01" cast as xs:date?). xs:date("2000-01-01") • This example is equivalent to (($floatvalue * 0.2E-5) cast as xs:decimal?).

xs:decimal($floatvalue * 0.2E-5) • This example returns a xdt:dayTimeDuration value equal to 21 days. It is equivalent to ("P21D" cast as xdt:dayTimeDuration?). xdt:dayTimeDuration("P21D") • If usa:zipcode is a user-defined atomic type in the in-scope schema types, then the following expression is equivalent to the expression ("12345" cast as usa:zipcode?). usa:zipcode("12345") Note: An instance of an atomic type that is not in a namespace can be constructed in either of the following ways: #### 3.10.5 Treat  [17] TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )? XPath provides an expression called treat that can be used to modify the static type of its operand. Like cast, the treat expression takes two operands: an expression and a SequenceType. Unlike cast, however, treat does not change the dynamic type or value of its operand. Instead, the purpose of treat is to ensure that an expression has an expected dynamic type at evaluation time. The semantics of expr1 treat as type1 are as follows: • During static analysis: The static type of the treat expression is type1. This enables the expression to be used as an argument of a function that requires a parameter of type1. • During expression evaluation: If expr1 matches type1, using the rules for SequenceType matching, the treat expression returns the value of expr1; otherwise, it raises a dynamic error [err:XPDY0050]. If the value of expr1 is returned, its identity is preserved. The treat expression ensures that the value of its expression operand conforms to the expected type at run-time. • Example: $myaddress treat as element(*, USAddress)

The static type of $myaddress may be element(*, Address), a less specific type than element(*, USAddress). However, at run-time, the value of $myaddress must match the type element(*, USAddress) using rules for SequenceType matching; otherwise a dynamic error is raised [err:XPDY0050].

## A XPath Grammar

### A.1 EBNF

The following grammar uses the same simple Extended Backus-Naur Form (EBNF) notation as [XML 1.0] with the following minor differences. The notation "< ... >" is used to indicate a grouping of terminals that together may help disambiguate the individual symbols. To help readability, this "< ... >" notation is absent in the EBNF in the main body of this document. This appendix is the normative version of the EBNF.

Comments on grammar productions are between '/*' and '*/' symbols - please note that these comments are normative. A 'gn:' prefix means a 'Grammar Note', and is meant as a clarification for parsing rules, and is explained in A.1.1 Grammar Notes. A 'ws:' prefix explains the whitespace rules for the production, the details of which are explained in A.2.2 Whitespace Rules

 [1] XPath ::= Expr [2] Expr ::= ExprSingle ("," ExprSingle)* [3] ExprSingle ::= ForExpr| QuantifiedExpr| IfExpr| OrExpr [4] ForExpr ::= SimpleForClause "return" ExprSingle [5] SimpleForClause ::= <"for" "$"> VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* [6] QuantifiedExpr ::= (<"some" "$"> | <"every" "$">) VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* "satisfies" ExprSingle [7] IfExpr ::= <"if" "("> Expr ")" "then" ExprSingle "else" ExprSingle [8] OrExpr ::= AndExpr ( "or" AndExpr )* [9] AndExpr ::= ComparisonExpr ( "and" ComparisonExpr )* [10] ComparisonExpr ::= RangeExpr ( (ValueComp| GeneralComp| NodeComp) RangeExpr )? [11] RangeExpr ::= AdditiveExpr ( "to" AdditiveExpr )? [12] AdditiveExpr ::= MultiplicativeExpr ( ("+" | "-") MultiplicativeExpr )* [13] MultiplicativeExpr ::= UnionExpr ( ("*" | "div" | "idiv" | "mod") UnionExpr )* [14] UnionExpr ::= IntersectExceptExpr ( ("union" | "|") IntersectExceptExpr )* [15] IntersectExceptExpr ::= InstanceofExpr ( ("intersect" | "except") InstanceofExpr )* [16] InstanceofExpr ::= TreatExpr ( <"instance" "of"> SequenceType )? [17] TreatExpr ::= CastableExpr ( <"treat" "as"> SequenceType )? [18] CastableExpr ::= CastExpr ( <"castable" "as"> SingleType )? [19] CastExpr ::= UnaryExpr ( <"cast" "as"> SingleType )? [20] UnaryExpr ::= ("-" | "+")* ValueExpr [21] ValueExpr ::= PathExpr [22] GeneralComp ::= "=" | "!=" | "<" | "<=" | ">" | ">=" /* gn: lt */ [23] ValueComp ::= "eq" | "ne" | "lt" | "le" | "gt" | "ge" [24] NodeComp ::= "is" | "<<" | ">>" [25] PathExpr ::= ("/" RelativePathExpr?)| ("//" RelativePathExpr)| RelativePathExpr /* gn: leading-lone-slash */ [26] RelativePathExpr ::= StepExpr (("/" | "//") StepExpr)* [27] StepExpr ::= AxisStep | FilterExpr [28] AxisStep ::= (ForwardStep | ReverseStep) PredicateList [29] ForwardStep ::= (ForwardAxis NodeTest) | AbbrevForwardStep [30] ForwardAxis ::= <"child" "::">| <"descendant" "::">| <"attribute" "::">| <"self" "::">| <"descendant-or-self" "::">| <"following-sibling" "::">| <"following" "::">| <"namespace" "::"> [31] AbbrevForwardStep ::= "@"? NodeTest [32] ReverseStep ::= (ReverseAxis NodeTest) | AbbrevReverseStep [33] ReverseAxis ::= <"parent" "::">| <"ancestor" "::">| <"preceding-sibling" "::">| <"preceding" "::">| <"ancestor-or-self" "::"> [34] AbbrevReverseStep ::= ".." [35] NodeTest ::= KindTest | NameTest [36] NameTest ::= QName | Wildcard [37] Wildcard ::= "*"| | <"*" ":" NCName> /* ws: explicit */ [38] FilterExpr ::= PrimaryExpr PredicateList [39] PredicateList ::= Predicate* [40] Predicate ::= "[" Expr "]" [41] PrimaryExpr ::= Literal | VarRef | ParenthesizedExpr | ContextItemExpr | FunctionCall [42] Literal ::= NumericLiteral | StringLiteral [43] NumericLiteral ::= IntegerLiteral | DecimalLiteral | DoubleLiteral [44] VarRef ::= "$" VarName [45] ParenthesizedExpr ::= "(" Expr? ")" [46] ContextItemExpr ::= "." [47] FunctionCall ::=  (ExprSingle ("," ExprSingle)*)? ")" /* gn: parens */ /* gn: reserved-function-names */ [48] SingleType ::= AtomicType "?"? [49] SequenceType ::= (ItemType OccurrenceIndicator?)| <"void" "(" ")"> [50] OccurrenceIndicator ::= "?" | "*" | "+" /* gn: occurrence-indicators */ [51] ItemType ::= AtomicType | KindTest | <"item" "(" ")"> [52] AtomicType ::= QName [53] KindTest ::= DocumentTest| ElementTest| AttributeTest| SchemaElementTest| SchemaAttributeTest| PITest| CommentTest| TextTest| AnyKindTest [54] AnyKindTest ::= <"node" "("> ")" [55] DocumentTest ::= <"document-node" "("> (ElementTest | SchemaElementTest)? ")" [56] TextTest ::= <"text" "("> ")" [57] CommentTest ::= <"comment" "("> ")" [58] PITest ::= <"processing-instruction" "("> (NCName | StringLiteral)? ")" [59] AttributeTest ::= <"attribute" "("> (AttribNameOrWildcard ("," TypeName)?)? ")" [60] AttribNameOrWildcard ::= AttributeName | "*" [61] SchemaAttributeTest ::= <"schema-attribute" "("> AttributeDeclaration ")" [62] AttributeDeclaration ::= AttributeName [63] ElementTest ::= <"element" "("> (ElementNameOrWildcard ("," TypeName "?"?)?)? ")" [64] ElementNameOrWildcard ::= ElementName | "*" [65] SchemaElementTest ::= <"schema-element" "("> ElementDeclaration ")" [66] ElementDeclaration ::= ElementName [67] AttributeName ::= QName [68] ElementName ::= QName [69] TypeName ::= QName
 [70] IntegerLiteral ::= Digits [71] DecimalLiteral ::= ("." Digits) | (Digits "." [0-9]*) /* ws: explicit */ [72] DoubleLiteral ::= (("." Digits) | (Digits ("." [0-9]*)?)) [eE] [+-]? Digits /* ws: explicit */ [73] StringLiteral ::= ('"' (('"' '"') | [^"])* '"') | ("'" (("'" "'") | [^'])* "'") /* ws: explicit */ [74] VarName ::= QName [75] Digits ::= [0-9]+ [76] Comment ::= "(:" (CommentContents | Comment)* ":)" /* ws: explicit */ /* gn: comments */ [77] CommentContents ::= (Char+ - (Char* ':)' Char*)) [78] QName ::= [http://www.w3.org/TR/REC-xml-names/#NT-QName]Names /* gn: xml-version */ [79] NCName ::= [http://www.w3.org/TR/REC-xml-names/#NT-NCName]Names /* gn: xml-version */ [80] Char ::= [http://www.w3.org/TR/REC-xml#NT-Char]XML /* gn: xml-version */

The following term definitions will be helpful in defining precisely this exposition.

[Definition: Each rule in the grammar defines one symbol, in the form]

symbol ::= expression

[Definition: A terminal is a single unit of the grammar that can not be further subdivided, and is specified in the EBNF by a character or characters in quotes, or a regular expression.] The following expressions are used to match strings of one or more characters in a terminal:

#xN

where N is a hexadecimal integer, the expression matches the character in [ISO/IEC 10646] whose canonical (UCS-4) code value, when interpreted as an unsigned binary number, has the value indicated. The number of leading zeros in the #xN form is insignificant; the number of leading zeros in the corresponding code value is governed by the character encoding in use and is not significant for XML.

[a-zA-Z], [#xN-#xN]

matches any Char with a value in the range(s) indicated (inclusive).

[abc], [#xN#xN#xN]

matches any Char with a value among the characters enumerated. Enumerations and ranges can be mixed in one set of brackets.

[^a-z], [^#xN-#xN]

matches any Char with a value outside the range indicated.

[^abc], [^#xN#xN#xN]

matches any Char with a value not among the characters given. Enumerations and ranges of forbidden values can be mixed in one set of brackets.

"string"

matches a literal string matching that given inside the double quotes.

'string'

matches a literal string matching that given inside the single quotes.

[http://www.w3.org/TR/REC-example/#NT-Example]

matches a production defined in the external specification as per the provided reference. For the purposes of this secification, the entire unit is defined as a terminal.

[Definition: A production combines symbols to form more complex patterns. ] The following productions serve as examples, where A and B represent simple expressions:

(expression)

expression is treated as a unit and may be combined as described in this list.

A?

matches A or nothing; optional A.

A B

matches A followed by B. This operator has higher precedence than alternation; thus A B | C D is identical to (A B) | (C D).

A | B

matches A or B but not both.

A - B

matches any string that matches A but does not match B.

A+

matches one or more occurrences of A.Concatenation has higher precedence than alternation; thus A+ | B+ is identical to (A+) | (B+).

A*

matches zero or more occurrences of A. Concatenation has higher precedence than alternation; thus A* | B* is identical to (A*) | (B*)

#### A.1.1 Grammar Notes

This section contains general notes on the EBNF productions, which may be helpful in understanding how to create a parser based on this EBNF, how to read the EBNF, and generally call out issues with the syntax. The notes below are referenced from the right side of the production, with the notation: /* gn: <id> */.

grammar-note: parens

A look-ahead of one character is required to distinguish function patterns from a QName or keyword followed by a Comment. For example: address (: this may be empty :) may be mistaken for a call to a function named "address" unless this lookahead is employed. Another example is for (: whom the bell :) $tolls = 3 return$tolls, where the keyword "for" must not be mistaken for a function name.

grammar-note: lt

A tokenizer must be aware of the context in which the "<" pattern appears, in order to distinguish the "<" comparison operator from the "<" tag open symbol. The "<" comparison operator can not occur in the same places as a "<" tag open pattern.

The "/" presents an issue because it occurs either as a stand alone unit or as a leading prefix that expects a pattern to follow such as a QName or "*". Both of these patterns also may occur as patterns which are recognized in contexts where operators may occur. Thus, expressions such as "/ * 5" can easily be confused with the path expression "/*". Therefore, a stand-alone slash on the right hand side of an operator, will need to be parenthesized in order to stand alone, as in "(/) * 5". "5 * /", on the other hand, is legal syntax.

Expression comments are allowed inside expressions everywhere that ignorable whitespace is allowed.

Comments can nest within each other, as long as all "(:" and ":)" patterns are balanced, no matter where they occur within the outer comment.

Note:

Lexical analysis may typically handle nested comments by incrementing a counter for each "(:" pattern, and decrementing the counter for each ":)" pattern. The comment does not terminate until the counter is back to zero.

Following are some illustrative examples:

• for (: set up loop :) $i in$x return $i will parse correctly, ignoring the comment. • 5 instance (: strange place for a comment :) of xs:integer will also parse correctly, ignoring the comment. See Comments for further information and examples. grammar-note: xml-version An implementation's choice to support the [XML 1.0] and [XML Names], or [XML 1.1] and [XML Names 1.1] lexical specification determines the external document from which to obtain the definition for this production. For convenience, XML 1.0 references are always used. In some cases, the XML 1.0 and XML 1.1 definitions may be exactly the same. Also please note that these external productions follow the whitespace rules of their respective specifications, and not the rules of this specification, in particular A.2.2.1 Default Whitespace Handling. Thus prefix : localname is not a valid QName for purposes of this specification, just as it is not permitted in a textual XML document. Also, comments are not permissible on either side of the colon. grammar-note: reserved-function-names Some unprefixed function names may be confused with expression syntax by the parser. For instance, if(foo) could either be a function name invocation or an incomplete IfExpr. Therefore it is not legal syntax for a user to invoke functions with these names. See A.3 Reserved Function Names for a list of these names. grammar-note: occurrence-indicators The '+' and '*' Kleene operators are tightly bound to the SequenceType expression, and have higher precedence than other uses of these symbols. Any occurrence of '+' and '*', as well as '?', following a sequence type is assumed to be an occurrence indicator. Thus, 4 treat as item() + - 5 is interpreted as (4 treat as item()+) - 5, so that the '+' would be an occurrence operator, and the '-' in this case would be a subtraction operator. To have this interpreted as an addition operator of a negative number, the form (4 treat as item()) + -5 would have to be used, so that the SequenceType expression is bounded by a parenthesis. ### A.2 Lexical structure A host language may choose whether the lexical rules of [XML 1.0] and [XML Names] are followed, or alternatively, the lexical rules of [XML 1.1] and [XML Names 1.1] are followed. When patterns are simple string matches, the strings are embedded directly into the EBNF. In other cases, named terminals are used. It is up to an implementation to decide on the exact tokenization strategy, which may be different depending on the parser construction. In the EBNF, the notation "< ... >" is used to indicate a grouping of terminals that together may help disambiguate the individual symbols. When tokenizing, the longest possible match that is valid in the current context is preferred . All keywords are case sensitive. Keywords are not reserved—that is, any QName may duplicate a keyword except as noted in A.3 Reserved Function Names. #### A.2.1 Terminal Types The entire set of terminals in XPath 2.0 may be divided into two major classes, those that can act as terminal delimiters, and those that can not. [Definition: A delimiting terminal may delimit adjacent non-delimiting terminals.] The following is the list of delimiting terminals: "::", "*", "$", "?", "(", ")", ":", "/", "//", "=", "!=", "<=", "<<", ">=", ">>", "<", ">", "-", "+", "|", "@", "[", "]", ",", ".", "..", Comment, "(:", ":)"

[Definition: Non-delimiting terminals generally start and end with alphabetic characters or digits. Adjacent non-delimiting terminals must be delimited by a delimiting terminal.] The following is the list of non-delimiting terminals:

DecimalLiteral, DoubleLiteral, StringLiteral, "child", "descendant", "parent", "attribute", "self", "descendant-or-self", "ancestor", "following-sibling", "preceding-sibling", "following", "preceding", "namespace", "ancestor-or-self", "or", "and", "div", "idiv", "mod", "in", "satisfies", "return", "then", "else", "to", "intersect", "union", "except", "instance", "of", "castable", "as", "item", "element", "schema-element", "schema-attribute", "void", "is", "eq", "ne", "gt", "ge", "lt", "le", "some", "every", "for", "cast", "treat", Digits, "document-node", "node", "comment", "text", "processing-instruction", "if", CommentContents, QName, NCName

#### A.2.2 Whitespace Rules

##### A.2.2.1 Default Whitespace Handling

[Definition: Whitespace characters are defined by [http://www.w3.org/TR/REC-xml#NT-S] when these characters occur outside of a StringLiteral.]

[Definition: Unless otherwise specified (see A.2.2.2 Explicit Whitespace Handling), Ignorable whitespace may occur between terminals, and is not significant to the parse tree. For readability, whitespace may be used in most expressions even though not explicitly notated in the EBNF. All allowable whitespace that is not explicitly specified in the EBNF is ignorable whitespace, and converse, this term does not apply to whitespace that is explicitly specified. ] Whitespace is allowed before the first terminal and after the last terminal of an expression module. Whitespace is optional between delimiting terminals. Whitespace is required to prevent two adjacent non-delimiting terminals from being (mis-)recognized as one. Comments may also act as "whitespace" to prevent two adjacent terminals from being recognized as one. Some illustrative examples are as follows:

• foo- foo is a syntax error. "foo-" would be recognized as a QName.

• foo -foo parses the same as foo - foo, two QNames separated by a subtraction operator. The parser would match the first "foo" as a QName. The parser would then expect a to match an operator, which is satisfied by "-" (but not "-foo"). The last foo would then be matched as another QName.

• foo(: This is a comment :)- foo also parses the same as foo - foo. This is because the comment prevents the two adjacent terminals from being recognized as one.

• foo-foo parses as a single QName. This is because "-" is a valid character in a QName. When used as an operator after the characters of a name, the "-" must be separated from the name, e.g. by using whitespace or parentheses.

• 10div 3 results in a syntax error, since the "10" and the "div" would both be non-delimiting terminals and must be separated by delimiting terminals in order to be recognized.

• 10 div3 also results in a syntax error, since the "div" and the "3" would both be non-delimiting terminals and must be separated by delimiting terminals in order to be recognized.

• 10div3 also results in a syntax error, since the "10", "div" and the "3" would all be non-delimiting terminals and must be separated by delimiting terminals in order to be recognized.

##### A.2.2.2 Explicit Whitespace Handling

Explict whitespace notation is specified with the EBNF productions, when it is different from the default rules, as follows. These notations do not inherit. In other words, if EBNF rule is marked as /* ws: explicit */, the rule does not automatically apply to all the 'child' EBNF productions of that rule.

ws:explicit

"ws: explicit" means that the EBNF notation S explicitly notates where whitespace is allowed. In productions with this notation, A.2.2.1 Default Whitespace Handling does not apply. Comments are also not allowed in these productions.

Comments are allowed to nest, though the content of a comment must have balanced comment delimiters without regard to structure. Some illustrative examples:

• (: commenting out a (: comment :) may be confusing, but often helpful :) is a legal Comment, since balanced nesting of comments is allowed.

• "this is just a string :)" is a legal expression. However, (: "this is just a string :)" :) will cause a syntax error. Likewise, "this is another string (:" is a legal expression, but (: "this is another string (:" :) will cause a syntax error. It is a limitation of nested comments that literal content can cause unbalanced nesting of comments.

### A.3 Reserved Function Names

The following names are not recognized as function names in an unprefixed form because expression syntax takes precedence.

• attribute

• comment

• document-node

• element

• item

• if

• item

• node

• processing-instruction

• schema-attribute

• schema-element

• text

• typeswitch

Note:

Although the keyword typeswitch is not used in XPath, it is considered a reserved function name for compatibility with XQuery.

• void

### A.4 Precedence Order

The grammar defines built-in precedence among the operators of XPath. These operators are summarised here in order of their precedence from lowest to highest. Operators that have a lower precedence number cannot be contained by operators with a higher precedence number. The associativity column indicates the order in which operators of equal precedence in an expression are applied.

# Operator Associativity
1 , (comma) left-to-right
3 for, some, every, if left-to-right
4 or left-to-right
5 and left-to-right
6 eq, ne, lt, le, gt, ge, =, !=, <, <=, >, >=, is, <<, >> left-to-right
7 to left-to-right
8 +, - left-to-right
9 *, div, idiv, mod left-to-right
10 union, | left-to-right
11 intersect, except left-to-right
12 instance of left-to-right
13 treat left-to-right
14 castable left-to-right
15 cast left-to-right
16 -(unary), +(unary) right-to-left
17 ?, *(OccurrenceIndicator), +(OccurrenceIndicator) left-to-right
18 /, // left-to-right
19 [ ], ( ), {} left-to-right

## B Type Promotion and Operator Mapping

### B.1 Type Promotion

[Definition: Under certain circumstances, an atomic value can be promoted from one type to another. Type promotion is used in evaluating function calls (see 3.1.5 Function Calls) and operators that accept numeric or string operands (see B.2 Operator Mapping).] The following type promotions are permitted:

1. Numeric type promotion:

1. A value of type xs:float (or any type derived by restriction from xs:float) can be promoted to the type xs:double. The result is the xs:double value that is the same as the original value.

2. A value of type xs:decimal (or any type derived by restriction from xs:decimal) can be promoted to either of the types xs:float or xs:double. The result of this promotion is created by casting the original value to the required type. This kind of promotion may cause loss of precision.

2. URI type promotion: A value of type xs:anyURI (or any type derived by restriction from xs:anyURI) can be promoted to the type xs:string. The result of this promotion is created by casting the original value to the type xs:string.

Note:

Since xs:anyURI values can be promoted to xs:string, functions and operators that compare strings using the default collation also compare xs:URI values using the default collation. This ensures that orderings that include strings, xs:URI values, or any combination of the two types are consistent and well-defined.

Note that type promotion is different from subtype substitution. For example:

• A function that expects a parameter $p of type xs:float can be invoked with a value of type xs:decimal. This is an example of type promotion. The value is actually converted to the expected type. Within the body of the function, $p instance of xs:decimal returns false.

• A function that expects a parameter $p of type xs:decimal can be invoked with a value of type xs:integer. This is an example of subtype substitution. The value retains its original type. Within the body of the function, $p instance of xs:integer returns true.

### B.2 Operator Mapping

The operator mapping tables in this section list the combinations of types for which the various operators of XPath are defined. [Definition: For each operator and valid combination of operand types, the operator mapping tables specify a result type and an operator function that implements the semantics of the operator for the given types.] The definitions of the operator functions are given in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The result of an operator may be the raising of an error by its operator function, as defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. In some cases, the operator function does not implement the full semantics of a given operator. For the definition of each operator (including its behavior for empty sequences or sequences of length greater than one), see the descriptive material in the main part of this document.

The and and or operators are defined directly in the main body of this document, and do not occur in the operator mapping tables.

Any operator listed in the operator mapping tables may be validly applied to an operand of type AT if the table calls for an operand of type ET and type-matches(ET, AT) is true (see 2.5.4 SequenceType Matching). For example, a table entry indicates that the gt operator may be applied to two xs:date operands, returning xs:boolean. Therefore, the gt operator may also be applied to two (possibly different) subtypes of xs:date, also returning xs:boolean.

[Definition: When referring to a type, the term numeric denotes the types xs:integer, xs:decimal, xs:float, and xs:double.] An operator whose operands and result are designated as numeric might be thought of as representing four operators, one for each of the numeric types. For example, the numeric + operator might be thought of as representing the following four operators:

 Operator First operand type Second operand type Result type + xs:integer xs:integer xs:integer + xs:decimal xs:decimal xs:decimal + xs:float xs:float xs:float + xs:double xs:double xs:double

A numeric operator may be validly applied to an operand of type AT if type-matches(ET, AT) is true where ET is any of the four numeric types. If the result type of an operator is listed as numeric, it means "the first type in the ordered list (xs:integer, xs:decimal, xs:float, xs:double) into which all operands can be converted by subtype substitution and type promotion." As an example, suppose that the type hatsize is derived from xs:integer and the type shoesize is derived from xs:float. Then if the + operator is invoked with operands of type hatsize and shoesize, it returns a result of type xs:float. Similarly, if + is invoked with two operands of type hatsize it returns a result of type xs:integer.

[Definition: In the operator mapping tables, the term Gregorian refers to the types xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gDay, and xs:gMonth.] For binary operators that accept two Gregorian-type operands, both operands must have the same type (for example, if one operand is of type xs:gDay, the other operand must be of type xs:gDay.)

Binary Operators
Operator Type(A) Type(B) Function Result type
A + B numeric numeric op:numeric-add(A, B) numeric
A + B xs:date xdt:yearMonthDuration op:add-yearMonthDuration-to-date(A, B) xs:date
A + B xdt:yearMonthDuration xs:date op:add-yearMonthDuration-to-date(B, A) xs:date
A + B xs:date xdt:dayTimeDuration op:add-dayTimeDuration-to-date(A, B) xs:date
A + B xdt:dayTimeDuration xs:date op:add-dayTimeDuration-to-date(B, A) xs:date
A + B xs:time xdt:dayTimeDuration op:add-dayTimeDuration-to-time(A, B) xs:time
A + B xdt:dayTimeDuration xs:time op:add-dayTimeDuration-to-time(B, A) xs:time
A + B xs:dateTime xdt:yearMonthDuration op:add-yearMonthDuration-to-dateTime(A, B) xs:dateTime
A + B xdt:yearMonthDuration xs:dateTime op:add-yearMonthDuration-to-dateTime(B, A) xs:dateTime
A + B xs:dateTime xdt:dayTimeDuration op:add-dayTimeDuration-to-dateTime(A, B) xs:dateTime
A + B xdt:dayTimeDuration xs:dateTime op:add-dayTimeDuration-to-dateTime(B, A) xs:dateTime
A + B xdt:yearMonthDuration xdt:yearMonthDuration op:add-yearMonthDurations(A, B) xdt:yearMonthDuration
A + B xdt:dayTimeDuration xdt:dayTimeDuration op:add-dayTimeDurations(A, B) xdt:dayTimeDuration
A - B numeric numeric op:numeric-subtract(A, B) numeric
A - B xs:date xs:date fn:subtract-dates-yielding-dayTimeDuration(A, B) xdt:dayTimeDuration
A - B xs:date xdt:yearMonthDuration op:subtract-yearMonthDuration-from-date(A, B) xs:date
A - B xs:date xdt:dayTimeDuration op:subtract-dayTimeDuration-from-date(A, B) xs:date
A - B xs:time xs:time op:subtract-times(A, B) xdt:dayTimeDuration
A - B xs:time xdt:dayTimeDuration op:subtract-dayTimeDuration-from-time(A, B) xs:time
A - B xs:dateTime xs:dateTime fn:subtract-dateTimes-yielding-dayTimeDuration(A, B) xdt:dayTimeDuration
A - B xs:dateTime xdt:yearMonthDuration op:subtract-yearMonthDuration-from-dateTime(A, B) xs:dateTime
A - B xs:dateTime xdt:dayTimeDuration op:subtract-dayTimeDuration-from-dateTime(A, B) xs:dateTime
A - B xdt:yearMonthDuration xdt:yearMonthDuration op:subtract-yearMonthDurations(A, B) xdt:yearMonthDuration
A - B xdt:dayTimeDuration xdt:dayTimeDuration op:subtract-dayTimeDurations(A, B) xdt:dayTimeDuration
A * B numeric numeric op:numeric-multiply(A, B) numeric
A * B xdt:yearMonthDuration numeric op:multiply-yearMonthDuration(A, B) xdt:yearMonthDuration
A * B numeric xdt:yearMonthDuration op:multiply-yearMonthDuration(B, A) xdt:yearMonthDuration
A * B xdt:dayTimeDuration numeric op:multiply-dayTimeDuration(A, B) xdt:dayTimeDuration
A * B numeric xdt:dayTimeDuration op:multiply-dayTimeDuration(B, A) xdt:dayTimeDuration
A idiv B numeric numeric op:numeric-integer-divide(A, B) xs:integer
A div B numeric numeric op:numeric-divide(A, B) numeric; but xs:decimal if both operands are xs:integer
A div B xdt:yearMonthDuration numeric op:divide-yearMonthDuration(A, B) xdt:yearMonthDuration
A div B xdt:dayTimeDuration numeric op:divide-dayTimeDuration(A, B) xdt:dayTimeDuration
A div B xdt:yearMonthDuration xdt:yearMonthDuration op:divide-yearMonthDuration-by-yearMonthDuration (A, B) xs:decimal
A div B xdt:dayTimeDuration xdt:dayTimeDuration op:divide-dayTimeDuration-by-dayTimeDuration (A, B) xs:decimal
A mod B numeric numeric op:numeric-mod(A, B) numeric
A eq B numeric numeric op:numeric-equal(A, B) xs:boolean
A eq B xs:boolean xs:boolean op:boolean-equal(A, B) xs:boolean
A eq B xs:string xs:string op:numeric-equal(fn:compare(A, B), 0) xs:boolean
A eq B xs:date xs:date op:date-equal(A, B) xs:boolean
A eq B xs:time xs:time op:time-equal(A, B) xs:boolean
A eq B xs:dateTime xs:dateTime op:datetime-equal(A, B) xs:boolean
A eq B xdt:yearMonthDuration xdt:yearMonthDuration op:yearMonthDuration-equal(A, B) xs:boolean
A eq B xdt:dayTimeDuration xdt:dayTimeDuration op:dayTimeDuration-equal(A, B) xs:boolean
A eq B Gregorian Gregorian op:gYear-equal(A, B) etc. xs:boolean
A eq B xs:hexBinary xs:hexBinary op:hex-binary-equal(A, B) xs:boolean
A eq B xs:base64Binary xs:base64Binary op:base64-binary-equal(A, B) xs:boolean
A eq B xs:anyURI xs:anyURI op:numeric-equal(fn:compare(A, B), 0) xs:boolean
A eq B xs:QName xs:QName op:QName-equal(A, B) xs:boolean
A eq B xs:NOTATION xs:NOTATION op:NOTATION-equal(A, B) xs:boolean
A ne B numeric numeric fn:not(op:numeric-equal(A, B)) xs:boolean
A ne B xs:boolean xs:boolean fn:not(op:boolean-equal(A, B)) xs:boolean
A ne B xs:string xs:string fn:not(op:numeric-equal(fn:compare(A, B), 0)) xs:boolean
A ne B xs:date xs:date fn:not(op:date-equal(A, B)) xs:boolean
A ne B xs:time xs:time fn:not(op:time-equal(A, B)) xs:boolean
A ne B xs:dateTime xs:dateTime fn:not(op:datetime-equal(A, B)) xs:boolean
A ne B xdt:yearMonthDuration xdt:yearMonthDuration fn:not(op:yearMonthDuration-equal(A, B)) xs:boolean
A ne B xdt:dayTimeDuration xdt:dayTimeDuration fn:not(op:dayTimeDuration-equal(A, B) xs:boolean
A ne B Gregorian Gregorian fn:not(op:gYear-equal(A, B)) etc. xs:boolean
A ne B xs:hexBinary xs:hexBinary fn:not(op:hex-binary-equal(A, B)) xs:boolean
A ne B xs:base64Binary xs:base64Binary fn:not(op:base64-binary-equal(A, B)) xs:boolean
A ne B xs:anyURI xs:anyURI fn:not(op:numeric-equal(fn:compare(A, B), 0)) xs:boolean
A ne B xs:QName xs:QName fn:not(op:QName-equal(A, B)) xs:boolean
A ne B xs:NOTATION xs:NOTATION fn:not(op:NOTATION-equal(A, B)) xs:boolean
A gt B numeric numeric op:numeric-greater-than(A, B) xs:boolean
A gt B xs:boolean xs:boolean op:boolean-greater-than(A, B) xs:boolean
A gt B xs:string xs:string op:numeric-greater-than(fn:compare(A, B), 0) xs:boolean
A gt B xs:date xs:date op:date-greater-than(A, B) xs:boolean
A gt B xs:time xs:time op:time-greater-than(A, B) xs:boolean
A gt B xs:dateTime xs:dateTime op:datetime-greater-than(A, B) xs:boolean
A gt B xdt:yearMonthDuration xdt:yearMonthDuration op:yearMonthDuration-greater-than(A, B) xs:boolean
A gt B xdt:dayTimeDuration xdt:dayTimeDuration op:dayTimeDuration-greater-than(A, B) xs:boolean
A lt B numeric numeric op:numeric-less-than(A, B) xs:boolean
A lt B xs:boolean xs:boolean op:boolean-less-than(A, B) xs:boolean
A lt B xs:string xs:string op:numeric-less-than(fn:compare(A, B), 0) xs:boolean
A lt B xs:date xs:date op:date-less-than(A, B) xs:boolean
A lt B xs:time xs:time op:time-less-than(A, B) xs:boolean
A lt B xs:dateTime xs:dateTime op:datetime-less-than(A, B) xs:boolean
A lt B xdt:yearMonthDuration xdt:yearMonthDuration op:yearMonthDuration-less-than(A, B) xs:boolean
A lt B xdt:dayTimeDuration xdt:dayTimeDuration op:dayTimeDuration-less-than(A, B) xs:boolean
A ge B numeric numeric op:numeric-greater-than(A, B) or op:numeric-equal(A, B) xs:boolean
A ge B xs:boolean xs:boolean fn:not(op:boolean-less-than(A, B)) xs:boolean
A ge B xs:string xs:string op:numeric-greater-than(fn:compare(A, B), -1) xs:boolean
A ge B xs:date xs:date fn:not(op:date-less-than(A, B)) xs:boolean
A ge B xs:time xs:time fn:not(op:time-less-than(A, B)) xs:boolean
A ge B xs:dateTime xs:dateTime fn:not(op:datetime-less-than(A, B)) xs:boolean
A ge B xdt:yearMonthDuration xdt:yearMonthDuration fn:not(op:yearMonthDuration-less-than(A, B)) xs:boolean
A ge B xdt:dayTimeDuration xdt:dayTimeDuration fn:not(op:dayTimeDuration-less-than(A, B)) xs:boolean
A le B numeric numeric op:numeric-less-than(A, B) or op:numeric-equal(A, B) xs:boolean
A le B xs:boolean xs:boolean fn:not(op:boolean-greater-than(A, B)) xs:boolean
A le B xs:string xs:string op:numeric-less-than(fn:compare(A, B), 1) xs:boolean
A le B xs:date xs:date fn:not(op:date-greater-than(A, B)) xs:boolean
A le B xs:time xs:time fn:not(op:time-greater-than(A, B)) xs:boolean
A le B xs:dateTime xs:dateTime fn:not(op:datetime-greater-than(A, B)) xs:boolean
A le B xdt:yearMonthDuration xdt:yearMonthDuration fn:not(op:yearMonthDuration-greater-than(A, B)) xs:boolean
A le B xdt:dayTimeDuration xdt:dayTimeDuration fn:not(op:dayTimeDuration-greater-than(A, B)) xs:boolean
A is B node() node() op:is-same-node(A, B) xs:boolean
A << B node() node() op:node-before(A, B) xs:boolean
A >> B node() node() op:node-after(A, B) xs:boolean
A union B node()* node()* op:union(A, B) node()*
A | B node()* node()* op:union(A, B) node()*
A intersect B node()* node()* op:intersect(A, B) node()*
A except B node()* node()* op:except(A, B) node()*
A to B xs:integer xs:integer op:to(A, B) xs:integer*
A , B item()* item()* op:concatenate(A, B) item()*
Unary Operators
Operator Operand type Function Result type
+ A numeric op:numeric-unary-plus(A) numeric
- A numeric op:numeric-unary-minus(A) numeric

## C Context Components

The tables in this section describe the scope (range of applicability) of the various components in the static context and dynamic context.

### C.1 Static Context Components

The following table describes the components of the static context. For each component, "global" indicates that the value of the component applies throughout an XPath expression, whereas "lexical" indicates that the value of the component applies only within the subexpression in which it is defined.

Static Context Components
Component Scope
XPath 1.0 Compatibility Mode global
Statically known namespaces global
Default element/type namespace global
Default function namespace global
In-scope schema types global
In-scope element declarations global
In-scope attribute declarations global
In-scope variables lexical; for-expressions and quantified expressions can bind new variables
Context item static type lexical
Function signatures global
Statically known collations global
Default collation global
Base URI global
Statically known documents global
Statically known collections global
Statically known default collection type global

### C.2 Dynamic Context Components

The following table describes how values are assigned to the various components of the dynamic context. All these components are initialized by mechanisms defined by the host language. For each component, "global" indicates that the value of the component remains constant throughout evaluation of the XPath expression, whereas "dynamic" indicates that the value of the component can be modified by the evaluation of subexpressions.

Dynamic Context Components
Component Scope
Context item dynamic; changes during evaluation of path expressions and predicates
Context position dynamic; changes during evaluation of path expressions and predicates
Context size dynamic; changes during evaluation of path expressions and predicates
Variable values dynamic; for-expressions and quantified expressions can bind new variables
Current date and time global; must be initialized by implementation
Implicit timezone global; must be initialized by implementation
Available documents global; must be initialized by implementation
Available collections global; must be initialized by implementation
Default collection global; overwriteable by implementation

## D Implementation-Defined Items

The following items are implementation-defined:

1. The version of Unicode that is used to construct expressions.

2. The statically-known collations.

3. The implicit timezone.

4. The circumstances in which warnings are raised, and the ways in which warnings are handled.

5. The method by which errors are reported to the external processing environment.

6. Whether the implementation is based on the rules of [XML 1.0] and [XML Names] or the rules of [XML 1.1] and [XML Names 1.1].

7. Whether the implementation supports the namespace axis.

8. Any static typing extensions supported by the implementation, if the Static Typing Feature is supported.

## E References

### E.1 Normative References

RFC 2119
S. Bradner. Key Words for use in RFCs to Indicate Requirement Levels. IETF RFC 2119. See http://www.ietf.org/rfc/rfc2119.txt.
RFC2396
T. Berners-Lee, R. Fielding, and L. Masinter. Uniform Resource Identifiers (URI): Generic Syntax. IETF RFC 2396. See http://www.ietf.org/rfc/rfc2396.txt.
ISO/IEC 10646
ISO (International Organization for Standardization). ISO/IEC 10646-1:2000. Information technology—Universal Multiple-Octet Coded Character Set (UCS)—Part 1: Architecture and Basic Multilingual Plane and ISO/IEC 10646-2:2001. Information technology—Universal Multiple-Octet Coded Character Set (UCS)—Part 2: Supplementary Planes, as, from time to time, amended, replaced by a new edition, or expanded by the addition of new parts. [Geneva]: International Organization for Standardization. (See http://www.iso.ch for the latest version.)
Unicode
The Unicode Consortium. The Unicode Standard Reading, Mass.: Addison-Wesley, 2003, as updated from time to time by the publication of new versions. See http://www.unicode.org/unicode/standard/versions for the latest version and additional information on versions of the standard and of the Unicode Character Database. The version of Unicode to be used is implementation-defined, but implementations are recommended to use the latest Unicode version.
XML 1.0
World Wide Web Consortium. Extensible Markup Language (XML) 1.0. W3C Recommendation. See http://www.w3.org/TR/2000/REC-xml-20001006
XML 1.1
World Wide Web Consortium. Extensible Markup Language (XML) 1.1. W3C Recommendation. See http://www.w3.org/TR/xml11/
XML Names
World Wide Web Consortium. Namespaces in XML. W3C Recommendation. See http://www.w3.org/TR/REC-xml-names/
XML Names 1.1
World Wide Web Consortium. Namespaces in XML 1.1. W3C Recommendation. See http://www.w3.org/TR/xml-names11/
XML Schema
World Wide Web Consortium. XML Schema, Parts 0, 1, and 2. W3C Recommendation, 2 May 2001. See http://www.w3.org/TR/2001/REC-xmlschema-0-20010502/, http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/, and http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/.
XQuery 1.0 and XPath 2.0 Data Model
World Wide Web Consortium. XQuery 1.0 and XPath 2.0 Data Model. W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xpath-datamodel/.
XQuery 1.0 and XPath 2.0 Formal Semantics
World Wide Web Consortium. XQuery 1.0 and XPath 2.0 Formal Semantics. W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xquery-semantics/.
XQuery 1.0 and XPath 2.0 Functions and Operators
World Wide Web Consortium. XQuery 1.0 and XPath 2.0 Functions and Operators W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xpath-functions/.
XSLT 2.0 and XQuery 1.0 Serialization
World Wide Web Consortium. XSLT 2.0 and XQuery 1.0 Serialization. W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xslt-xquery-serialization/.

### E.2 Non-normative References

XPath 2.0 Requirements
World Wide Web Consortium. XPath Requirements Version 2.0. W3C Working Draft 22 August 2003. See http://www.w3.org/TR/xpath20req.
XQuery
World Wide Web Consortium. XQuery 1.0: An XML Query Language. W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xquery/.
XSLT 2.0
World Wide Web Consortium. XSL Transformations (XSLT) 2.0. W3C Working Draft, 04 April 2005. See http://www.w3.org/TR/xslt20/
Document Object Model
World Wide Web Consortium. Document Object Model (DOM) Level 3 Core Specification. W3C Recommendation, April 7, 2004. See http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/.
XML Infoset
World Wide Web Consortium. XML Information Set. W3C Recommendation 24 October 2001. See http://www.w3.org/TR/xml-infoset/
XPath 1.0
World Wide Web Consortium. XML Path Language (XPath) Version 1.0. W3C Recommendation, Nov. 16, 1999. See http://www.w3.org/TR/xpath.html
XPointer
World Wide Web Consortium. XML Pointer Language (XPointer). W3C Last Call Working Draft 8 January 2001. See http://www.w3.org/TR/WD-xptr

### E.3 Background Material

Character Model
World Wide Web Consortium. Character Model for the World Wide Web. W3C Working Draft. See http://www.w3.org/TR/charmod/.
XSLT 1.0
World Wide Web Consortium. XSL Transformations (XSLT) 1.0. W3C Recommendation. See http://www.w3.org/TR/xslt
Building a Tokenizer for XPath or XQuery
Building a Tokenizer for XPath or XQuery, Scott Boag, Editor. World Wide Web Consortium, 4 Apr 2005. This version is http://www.w3.org/TR/2005/WD-xquery-xpath-parsing-20050404/. The latest version is available at http://www.w3.org/TR/xquery-xpath-parsing/.

## F Conformance

XPath is intended primarily as a component that can be used by other specifications. Therefore, XPath relies on specifications that use it (such as [XPointer] and [XSLT 2.0]) to specify conformance criteria for XPath in their respective environments. Specifications that set conformance criteria for their use of XPath must not change the syntactic or semantic definitions of XPath as given in this specification, except by subsetting and/or compatible extensions.

### F.1 Static Typing Feature

[Definition: The Static Typing Feature is an optional feature of XPath that provides support for the static semantics defined in [XQuery 1.0 and XPath 2.0 Formal Semantics], and requires implementations to detect and report type errors during the static analysis phase.] Specifications that use XPath may specify conformance criteria for use of the Static Typing Feature.

If an implementation does not support the Static Typing Feature, but can nevertheless determine during the static analysis phase that an expression will necessarily raise a type error if evaluated at run time, the implementation may raise that error during the static analysis phase. The choice of whether to raise such an error at analysis time is implementation dependent.

#### F.1.1 Static Typing Extensions

In some cases, the static typing rules defined in [XQuery 1.0 and XPath 2.0 Formal Semantics] are not very precise (see, for example, the type inference rules for the ancestor axes—parent, ancestor, and ancestor-or-self—and for the function fn:root). Some implementations may wish to support more precise static typing rules.

A conforming implementation that implements the Static Typing Feature may also provide one or more static typing extensions. [Definition: A static typing extension is an implementation-defined type inference rule that infers a more precise static type than that inferred by the type inference rules in [XQuery 1.0 and XPath 2.0 Formal Semantics].] See Section 6.1.1 Static Typing ExtensionsFS for a formal definition of the constraints on static typing extensions.

## G Error Conditions

err:XPST0001

It is a static error if analysis of an expression relies on some component of the static context that has not been assigned a value.

err:XPDY0002

It is a dynamic error if evaluation of an expression relies on some part of the dynamic context that has not been assigned a value.

err:XPST0003

It is a static error if an expression is not a valid instance of the grammar defined in A.1 EBNF.

err:XPTY0004

It is a type error if, during the static analysis phase, an expression is found to have a static type that is not appropriate for the context in which the expression occurs, or during the dynamic evaluation phase, the dynamic type of a value does not match a required type as specified by the matching rules in 2.5.4 SequenceType Matching.

err:XPST0005

During the analysis phase, it is a static error if the static type assigned to an expression other than the expression () or data(()) is void().

err:XPTY0006

(Not currently used.)

err:XPTY0007

(Not currently used.)

err:XPST0008

It is a static error if an expression refers to an element name, attribute name, schema type name, namespace prefix, or variable name that is not defined in the static context, except within an ElementTest or an AttributeTest.

err:XPST0010

An implementation must raise a static error if it encounters a reference to an axis that it does not support.

err:XPST0017

It is an error (the host language environment may define this error as either a static error or a dynamic error) if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context.

err:XPTY0018

It is a type error if the result of the last step in a path expression contains both nodes and atomic values.

err:XPTY0019

It is a type error if the result of an step (other than the last step) in a path expression contains an atomic value.

err:XPTY0020

It is a type error if in an axis expression, the context item is not a node.

err:XPDY0021

(Not currently used.)

err:XPDY0050

It is a dynamic error if the dynamic type of the operand of a treat expression does not match the sequence type specified by the treat expression.

err:XPST0051

It is a static error if a QName that is used as an AtomicType in a SequenceType is not defined in the in-scope schema types as an atomic type.

err:XPST0080

The target type of a cast or castable expression must be an atomic type that is in the in-scope schema types and is not xs:NOTATION or xdt:anyAtomicType, optionally followed by the occurrence indicator "?"; otherwise a static error is raised.

err:XPST0081

It is a static error if a QName used in a expression contains a namespace prefix that cannot be expanded into a namespace URI by using the statically known namespaces.

err:XPST0083

It is a static error if the target type of a cast expression or constructor function is xs:QName or a type derived from xs:QName or xs:NOTATION, and the argument of the cast expression or constructor function is not a string literal.

## H Glossary (Non-Normative)

atomic value

An atomic value is a value in the value space of an atomic type, as defined in [XML Schema].

atomization

Atomization of a sequence is defined as the result of invoking the fn:data function on the sequence, as defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].

available collections

Available collections. This is a mapping of strings onto sequences of nodes. The string represents the absolute URI of a resource. The sequence of nodes represents the result of the fn:collection function when that URI is supplied as the argument.

available documents

Available documents. This is a mapping of strings onto document nodes. The string represents the absolute URI of a resource. The document node is the root of a tree that represents that resource using the data model. The document node is returned by the fn:doc function when applied to that URI.

axis step

An axis step returns a sequence of nodes that are reachable from the context node via a specified axis. Such a step has two parts: an axis, which defines the "direction of movement" for the step, and a node test, which selects nodes based on their kind, name, and/or type annotation.

base URI

Base URI. This is an absolute URI, used when necessary in the resolution of relative URIs (for example, by the fn:resolve-uri function.)

built-in function

The built-in functions supported by XPath are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].

collation

A collation is a specification of the manner in which strings and URIs are compared and, by extension, ordered. For a more complete definition of collation, see [XQuery 1.0 and XPath 2.0 Functions and Operators].

comma operator

One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence.

constructor function

The constructor function for a given type is used to convert instances of other atomic types into the given type. The semantics of the constructor function T($arg) are defined to be equivalent to the expression ($arg cast as T?).

context item

The context item is the item currently being processed. An item is either an atomic value or a node.

context item static type

Context item static type. This component defines the static type of the context item within the scope of a given expression.

context node

When the context item is a node, it can also be referred to as the context node.

context position

The context position is the position of the context item within the sequence of items currently being processed.

context size

The context size is the number of items in the sequence of items currently being processed.

current dateTime

Current dateTime. This information represents an implementation-dependent point in time during the processing of an expression, and includes an explicit timezone. It can be retrieved by the fn:current-dateTime function. If invoked multiple times during the execution of an expression, this function always returns the same result.

data model

XPath operates on the abstract, logical structure of an XML document, rather than its surface syntax. This logical structure, known as the data model, is defined in the [XQuery 1.0 and XPath 2.0 Data Model] document.

data model instance

The term data model instance is used, synonymously with the term value, to denote an unconstrained sequence of nodes and/or atomic values.

data model schema

For a given node in a data model instance, the data model schema is defined as the schema from which the type annotation of that node was derived.

default collation

Default collation. This identifies one of the collations in statically known collations as the collation to be used by functions and operators for comparing and ordering values of type xs:string and xs:anyURI (and their subtypes) when no explicit collation is specified.

default collection

Default collection. This is the sequence of nodes that would result from calling the fn:collection function with no arguments.

default element/type namespace

Default element/type namespace. This is a namespace URI or "none". The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element or type name is expected.

default function namespace

Default function namespace. This is a namespace URI or "none". The namespace URI, if present, is used for any unprefixed QName appearing in a position where a function name is expected.

Delimiting Terminal

A delimiting terminal may delimit adjacent non-delimiting terminals.

document order

Informally, document order is the order in which nodes appear in the XML serialization of a document.

dynamic context

The dynamic context of an expression is defined as information that is available at the time the expression is evaluated.

dynamic error

A dynamic error is an error that must be detected during the dynamic evaluation phase and may be detected during the static analysis phase. Numeric overflow is an example of a dynamic error.

dynamic evaluation phase

The dynamic evaluation phase is the phase during which the value of an expression is computed.

dynamic type

A dynamic type is associated with each value as it is computed. The dynamic type of a value may be more specific than the static type of the expression that computed it (for example, the static type of an expression might be xs:integer*, denoting a sequence of zero or more integers, but at evaluation time its value may have the dynamic type xs:integer, denoting exactly one integer.)

effective boolean value

The effective boolean value of a value is defined as the result of applying the fn:boolean function to the value, as defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].

empty sequence

A sequence containing zero items is called an empty sequence.

error value

In addition to its identifying QName, a dynamic error may also carry a descriptive string and one or more additional values called error values.

expanded QName

An expanded QName consists of an optional namespace URI and a local name. An expanded QName also retains its original namespace prefix (if any), to facilitate casting the expanded QName into a string.

expression context

The expression context for a given expression consists of all the information that can affect the result of the expression.

filter expression

A filter expression consists simply of a primary expression followed by zero or more predicates. The result of the filter expression consists of all the items returned by the primary expression for which all the predicates are true.

focus

The first three components of the dynamic context (context item, context position, and context size) are called the focus of the expression.

function implementation

Function implementations. Each function in function signatures has a function implementation that enables the function to map instances of its parameter types into an instance of its result type.

function signature

Function signatures. This component defines the set of functions that are available to be called from within an expression. Each function is uniquely identified by its expanded QName and its arity (number of parameters).

Gregorian

In the operator mapping tables, the term Gregorian refers to the types xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gDay, and xs:gMonth.

Ignorable whitespace

Unless otherwise specified (see A.2.2.2 Explicit Whitespace Handling), Ignorable whitespace may occur between terminals, and is not significant to the parse tree. For readability, whitespace may be used in most expressions even though not explicitly notated in the EBNF. All allowable whitespace that is not explicitly specified in the EBNF is ignorable whitespace, and converse, this term does not apply to whitespace that is explicitly specified.

implementation defined

Implementation-defined indicates an aspect that may differ between implementations, but must be specified by the implementor for each particular implementation.

implementation dependent

Implementation-dependent indicates an aspect that may differ between implementations, is not specified by this or any W3C specification, and is not required to be specified by the implementor for any particular implementation.

implicit timezone

Implicit timezone. This is the timezone to be used when a date, time, or dateTime value that does not have a timezone is used in a comparison or arithmetic operation. The implicit timezone is an implementation-defined value of type xdt:dayTimeDuration. See [XML Schema] for the range of legal values of a timezone.

in-scope attribute declarations

In-scope attribute declarations. Each attribute declaration is identified either by an expanded QName (for a top-level attribute declaration) or by an implementation-dependent attribute identifier (for a local attribute declaration).

in-scope element declarations

In-scope element declarations. Each element declaration is identified either by an expanded QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration).

in-scope namespaces

The in-scope namespaces property of an element node is a set of namespace bindings, each of which associates a namespace prefix with a URI, thus defining the set of namespace prefixes that are available for interpreting QNames within the scope of the element. For a given element, one namespace binding may have an empty prefix; the URI of this namespace binding is the default namespace within the scope of the element.

in-scope schema definitions

In-scope schema definitions. This is a generic term for all the element declarations, attribute declarations, and schema type definitions that are in scope during processing of an expression.

in-scope schema type

In-scope schema types. Each schema type definition is identified either by an expanded QName (for a named type) or by an implementation-dependent type identifier (for an anonymous type). The in-scope schema types include the predefined schema types described in 2.5.1 Predefined Schema Types.

in-scope variables

In-scope variables. This is a set of (expanded QName, type) pairs. It defines the set of variables that are available for reference within an expression. The expanded QName is the name of the variable, and the type is the static type of the variable.

item

An item is either an atomic value or a node.

kind test

An alternative form of a node test called a kind test can select nodes based on their kind, name, and type annotation.

literal

A literal is a direct syntactic representation of an atomic value.

name test

A node test that consists only of a QName or a Wildcard is called a name test.

node

A node is an instance of one of the node kinds defined in [XQuery 1.0 and XPath 2.0 Data Model].

node test

A node test is a condition that must be true for each node selected by a step.

Non-delimiting Terminal

Non-delimiting terminals generally start and end with alphabetic characters or digits. Adjacent non-delimiting terminals must be delimited by a delimiting terminal.

numeric

When referring to a type, the term numeric denotes the types xs:integer, xs:decimal, xs:float, and xs:double.

numeric predicate

A predicate whose predicate expression returns a numeric type is called a numeric predicate.

operator function

For each operator and valid combination of operand types, the operator mapping tables specify a result type and an operator function that implements the semantics of the operator for the given types.

path expression

A path expression can be used to locate nodes within trees. A path expression consists of a series of one or more steps, separated by "/" or "//", and optionally beginning with "/" or "//".

predicate

A predicate consists of an expression, called a predicate expression, enclosed in square brackets. A predicate serves to filter a sequence, retaining some items and discarding others.

primary expression

Primary expressions are the basic primitives of the language. They include literals, variable references, context item expressions, and function calls. A primary expression may also be created by enclosing any expression in parentheses, which is sometimes helpful in controlling the precedence of operators.

principal node kind

Every axis has a principal node kind. If an axis can contain elements, then the principal node kind is element; otherwise, it is the kind of nodes that the axis can contain.

production

A production combines symbols to form more complex patterns.

QName

Lexically, a QName consists of an optional namespace prefix and a local name. If the namespace prefix is present, it is separated from the local name by a colon.

reverse document order

The node ordering that is the reverse of document order is called reverse document order.

schema type

A schema type is a type that is (or could be) defined using the facilities of [XML Schema] (including the built-in types of [XML Schema]).

sequence

A sequence is an ordered collection of zero or more items.

sequence type

A sequence type is a type that can be expressed using the SequenceType syntax. Sequence types are used whenever it is necessary to refer to a type in an XPath expression. The term sequence type suggests that this syntax is used to describe the type of an XPath value, which is always a sequence.

SequenceType matching

During evaluation of an expression, it is sometimes necessary to determine whether a value with a known dynamic type "matches" an expected sequence type. This process is known as SequenceType matching.

serialization

Serialization is the process of converting a data model instance into a sequence of octets (step DM4 in Figure 1.)

singleton

A sequence containing exactly one item is called a singleton.

stable

Document order is stable, which means that the relative order of two nodes will not change during the processing of a given expression, even if this order is implementation-dependent.

statically known collations

Statically known collations. This is an implementation-defined set of (URI, collation) pairs. It defines the names of the collations that are available for use in processing expressions.

statically known collections

Statically known collections. This is a mapping from strings onto types. The string represents the absolute URI of a resource that is potentially available using the fn:collection function. The type is the type of the sequence of nodes that would result from calling the fn:collection function with this URI as its argument.

statically known default collection type

Statically known default collection type. This is the type of the sequence of nodes that would result from calling the fn:collection function with no arguments.

statically known documents

Statically known documents. This is a mapping from strings onto types. The string represents the absolute URI of a resource that is potentially available using the fn:doc function. The type is the static type of a call to fn:doc with the given URI as its literal argument.

statically known namespaces

Statically known namespaces. This is a set of (prefix, URI) pairs that define all the namespaces that are known during static processing of a given expression.

static analysis phase

The static analysis phase depends on the expression itself and on the static context. The static analysis phase does not depend on input data (other than schemas).

static context

The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation.

static error

A static error is an error that must be detected during the static analysis phase. A syntax error is an example of a static error.

static type

The static type of an expression is a type such that, when the expression is evaluated, the resulting value will always conform to the static type.

static typing extension

A static typing extension is an implementation-defined type inference rule that infers a more precise static type than that inferred by the type inference rules in [XQuery 1.0 and XPath 2.0 Formal Semantics].

static typing feature

The Static Typing Feature is an optional feature of XPath that provides support for the static semantics defined in [XQuery 1.0 and XPath 2.0 Formal Semantics], and requires implementations to detect and report type errors during the static analysis phase.

step

A step is a part of a path expression that generates a sequence of items and then filters the sequence by zero or more predicates. The value of the step consists of those items that satisfy the predicates. A step may be either an axis step or a filter expression.

string value

The string value of a node is a string and can be extracted by applying the fn:string function to the node.

substitution group

Substitution groups are defined in [XML Schema] Part 1, Section 2.2.2.2. Informally, the substitution group headed by a given element (called the head element) consists of the set of elements that can be substituted for the head element without affecting the outcome of schema validation.

subtype substitution

The use of a value whose dynamic type is derived from an expected type is known as subtype substitution.

symbol

Each rule in the grammar defines one symbol, in the form

terminal

A terminal is a single unit of the grammar that can not be further subdivided, and is specified in the EBNF by a character or characters in quotes, or a regular expression.

type annotation

Each element node and attribute node in a data model instance has a type annotation (referred to in [XQuery 1.0 and XPath 2.0 Data Model] as its type-name property.) The type annotation of a node is a schema type that describes the relationship between the string value of the node and its typed value.

typed value

The typed value of a node is a sequence of atomic values and can be extracted by applying the fn:data function to the node.

type error

A type error may be raised during the static analysis phase or the dynamic evaluation phase. During the static analysis phase, a type error occurs when the static type of an expression does not match the expected type of the context in which the expression occurs. During the dynamic evaluation phase, a type error occurs when the dynamic type of a value does not match the expected type of the context in which the value occurs.

type promotion

Under certain circumstances, an atomic value can be promoted from one type to another. Type promotion is used in evaluating function calls (see 3.1.5 Function Calls) and operators that accept numeric or string operands (see B.2 Operator Mapping).

value

In the data model, a value is always a sequence.

variable reference

A variable reference is a QName preceded by a $-sign. variable values Variable values. This is a set of (expanded QName, value) pairs. It contains the same expanded QNames as the in-scope variables in the static context for the expression. The expanded QName is the name of the variable and the value is the dynamic value of the variable, which includes its dynamic type. warning In addition to static errors, dynamic errors, and type errors, an XPath implementation may raise warnings, either during the static analysis phase or the dynamic evaluation phase. The circumstances in which warnings are raised, and the ways in which warnings are handled, are implementation-defined. Whitespace Whitespace characters are defined by [http://www.w3.org/TR/REC-xml#NT-S] when these characters occur outside of a StringLiteral. xdt:anyAtomicType xdt:anyAtomicType is an atomic type that includes all atomic values (and no values that are not atomic). xdt:dayTimeDuration xdt:dayTimeDuration is derived by restriction from xs:duration. The lexical representation of xdt:dayTimeDuration is restricted to contain only day, hour, minute, and second components. xdt:untyped xdt:untyped is used as the type annotation of an element node that has not been validated, or has been validated in skip mode. xdt:untypedAtomic xdt:untypedAtomic is an atomic type that is used to denote untyped atomic data, such as text that has not been assigned a more specific type. xdt:yearMonthDuration xdt:yearMonthDuration is derived by restriction from xs:duration. The lexical representation of xdt:yearMonthDuration is restricted to contain only year and month components. XPath 1.0 compatibility mode XPath 1.0 compatibility mode. This value is true if rules for backward compatibility with XPath Version 1.0 are in effect; otherwise it is false. ## I Backwards Compatibility with XPath 1.0 (Non-Normative) This appendix provides a summary of the areas of incompatibility between XPath 2.0 and [XPath 1.0]. Three separate cases are considered: 1. Incompatibilities that exist when source documents have no schema, and when running with XPath 1.0 compatibility mode set to true. This specification has been designed to reduce the number of incompatibilities in this situation to an absolute minumum, but some differences remain and are listed individually. 2. Incompatibilities that arise when XPath 1.0 compatibility mode is set to false. In this case, the number of expressions where compatibility is lost is rather greater. 3. Incompatibilities that arise when the source document is processed using a schema (whether or not XPath 1.0 compatibility mode is set to true). Processing the document with a schema changes the way that the values of nodes are interpreted, and this can cause an XPath expression to return different results. ### I.1 Incompatibilities when Compatibility Mode is true The list below contains all known areas, within the scope of this specification, where an XPath 2.0 processor running with compatibility mode set to true will produce different results from an XPath 1.0 processor evaluating the same expression, assuming that the expression was valid in XPath 1.0, and that the nodes in the source document have no type annotations other than xdt:untyped and xdt:untypedAtomic. Incompatibilities in the behavior of individual functions are not listed here, but are included in an appendix of [XQuery 1.0 and XPath 2.0 Functions and Operators]. Since both XPath 1.0 and XPath 2.0 leave some aspects of the specification implementation-defined, there may be incompatiblities in the behavior of a particular implementation that are outside the scope of this specification. Equally, some aspects of the behavior of XPath are defined by the host language. 1. Consecutive comparison operators such as A < B < C were supported in XPath 1.0, but are not permitted by the XPath 2.0 grammar. In most cases such comparisons in XPath 1.0 did not have the intuitive meaning, so it is unlikely that they have been widely used in practice. If such a construct is found, an XPath 2.0 processor will report a syntax error, and the construct can be rewritten as (A < B) < C 2. When converting strings to numbers (either explicitly when using the number function, or implicitly say on a function call), certain strings that converted to the special value NaN under XPath 1.0 will convert to values other than NaN under XPath 2.0. These include any number written with a leading + sign, any number in exponential floating point notation (for example 1.0e+9), and the strings INF and -INF. 3. XPath 2.0 does not allow a token starting with a letter to follow immediately after a numeric literal, without intervening whitespace. For example, 10div 3 was permitted in XPath 1.0, but in XPath 2.0 must be written as 10 div 3. 4. The namespace axis is deprecated in XPath 2.0. Implementations may support the namespace axis for backward compatibility with XPath 1.0, but they are not required to do so. (XSLT 2.0 requires that if XPath backwards compatibility mode is supported, then the namespace axis must also be supported; but other host languages may define the conformance rules differently.) ### I.2 Incompatibilities when Compatibility Mode is false Even when the setting of the XPath 1.0 compatibility mode is false, many XPath expressions will still produce the same results under XPath 2.0 as under XPath 1.0. The exceptions are described in this section. In all cases it is assumed that the expression in question was valid under XPath 1.0, that XPath 1.0 compatibility mode is false, and that all elements and attributes are annotated with the types xdt:untyped and xdt:untypedAtomic respectively. In the description below, the terms node-set and number are used with their XPath 1.0 meanings, that is, to describe expressions which according to the rules of XPath 1.0 would have generated a node-set or a number respectively. 1. When a node-set containing more than one node is supplied as an argument to a function or operator that expects a single node or value, the XPath 1.0 rule was that all nodes after the first were discarded. Under XPath 2.0, a type error occurs if there is more than one node. The XPath 1.0 behavior can always be restored by using the predicate [1] to explicitly select the first node in the node-set. 2. In XPath 1.0, the < and > operators, when applied to two strings, attempted to convert both the strings to numbers and then made a numeric comparison between the results. In XPath 2.0, these operators perform a string comparison using the default collating sequence. (If either value is numeric, however, the results are compatible with XPath 1.0) 3. When an empty node-set is supplied as an argument to a function or operator that expects a number, the value is no longer converted implicitly to NaN. The XPath 1.0 behavior can always be restored by using the number function to perform an explicit conversion. 4. More generally, the supplied arguments to a function or operator are no longer implicitly converted to the required type, except in the case where the supplied argument is of type xdt:untypedAtomic (which will commonly be the case when a node in a schemaless document is supplied as the argument). For example, the function call substring-before(10 div 3, ".") raises a type error under XPath 2.0, because the arguments to the substring-before function must be strings rather than numbers. The XPath 1.0 behavior can be restored by performing an explicit conversion to the required type using a constructor function or cast. 5. The rules for comparing a node-set to a boolean have changed. In XPath 1.0, an expression such as $node-set = true() was evaluated by converting the node-set to a boolean and then performing a boolean comparison: so this expression would return true if $node-set was non-empty. In XPath 2.0, this expression is handled in the same way as other comparisons between a sequence and a singleton: it is true if $node-set contains at least one node whose value, after atomization and conversion to a boolean using the casting rules, is true.

This means that if $node-set is empty, the result under XPath 2.0 will be false regardless of the value of the boolean operand, and regardless of which operator is used. If $node-set is non-empty, then in most cases the comparison with a boolean is likely to fail, giving a dynamic error. But if a node has the value "0", "1", "true", or "false", evaluation of the expression may succeed.

6. Comparisons of a number to a boolean, a number to a string, or a string to a boolean are not allowed in XPath 2.0: they result in a type error. In XPath 1.0 such comparisons were allowed, and were handled by converting one of the operands to the type of the other. So for example in XPath 1.0 4 = true() was true; 4 = "+4" was false (because the string +4 converts to NaN), and false = "false" was false (because the string "false" converts to the boolean true). In XPath 2.0 all these comparisons are type errors.

7. Additional numeric types have been introduced, with the effect that arithmetic may now be done as an integer, decimal, or single- or double-precision floating point calculation where previously it was always performed as double-precision floating point. The result of the div operator when dividing two integers is now a value of type decimal rather than double. The expression 10 div 0 raises an error rather than returning positive infinity.

8. The rules for converting numbers to strings have changed. These may affect the way numbers are displayed in the output of a stylesheet. For numbers whose absolute value is in the range 1E-6 to 1E+6, the result should be the same, but outside this range, scientific format is used for non-integral xs:float and xs:double values.

9. The rules for converting strings to numbers have changed. In addition to the changes that apply when XPath 1.0 compatibility mode is true, when compatibility mode is false the strings Infinity and -Infinity are no longer recognized as representations of positive and negative infinity. Note also that while the number function continues to convert all unrecognized strings to NaN, operations that cast a string to a number react to such strings with a dynamic error.

10. Many operations in XPath 2.0 produce an empty sequence as their result when one of the arguments or operands is an empty sequence. Where the operation expects a string, an empty sequence is usually considered equivalent to a zero-length string, which is compatible with the XPath 1.0 behavior. Where the operation expects a number, however, the result is not the same. For example, if @width returns an empty sequence, then in XPath 1.0 the result of @width+1 was NaN, while with XPath 2.0 it is (). This has the effect that a filter expression such as item[@width+1 != 2] will select items having no width attribute under XPath 1.0, and will not select them under XPath 2.0.

11. The typed value of a comment node, processing instruction node, or namespace node under XPath 2.0 is of type xs:string, not xdt:untypedAtomic. This means that no implicit conversions are applied if the value is used in a context where a number is expected. If a processing-instruction node is used as an operand of an arithmetic operator, for example, XPath 1.0 would attempt to convert the string value of the node to a number (and deliver NaN if unsuccessful), while XPath 2.0 will report a type error.

12. In XPath 1.0, it was defined that with an expression of the form A and B, B would not be evaluated if A was false. Similarly in the case of A or B, B would not be evaluated if A was true. This is no longer guaranteed with XPath 2.0: the implementation is free to evaluate the two operands in either order or in parallel. This change has been made to give more scope for optimization in situations where XPath expressions are evaluated against large data collections supported by indexes. Implementations may choose to retain backwards compatibility in this area, but they are not obliged to do so.

### I.3 Incompatibilities when using a Schema

An XPath expression applied to a document that has been processed against a schema will not always give the same results as the same expression applied to the same document in the absence of a schema. Since schema processing had no effect on the result of an XPath 1.0 expression, this may give rise to further incompatibilities. This section gives a few examples of the differences that can arise.

Suppose that the context node is an element node derived from the following markup: <background color="red green blue"/>. In XPath 1.0, the predicate [@color="blue"] would return false. In XPath 2.0, if the color attribute is defined in a schema to be of type xs:NMTOKENS, the same predicate will return true.

Similarly, consider the expression @birth < @death applied to the element <person birth="1901-06-06" death="1991-05-09"/>. With XPath 1.0, this expression would return false, because both attributes are converted to numbers, which returns NaN in each case. With XPath 2.0, in the presence of a schema that annotates these attributes as dates, the expression returns true.

Once schema validation is applied, elements and attributes cannot be used as operands and arguments of expressions that expect a different data type. For example, it is no longer possible to apply the substring function to a date to extract the year component, or to a number to extract the integer part. Similarly, if an attribute is annotated as a boolean then it is not possible to compare it with the strings "true" or "false". All such operations lead to type errors. The remedy when such errors occur is to introduce an explicit conversion, or to do the computation in a different way. For example, substring-after(@temperature, "-") might be rewritten as abs(@temperature).

In the case of an XPath 2.0 implementation that provides the static typing feature, many further type errors will be reported in respect of expressions that worked under XPath 1.0. For example, an expression such as round(../@price) might lead to a static type error because the processor cannot infer statically that ../@price is guaranteed to be numeric.

Schema validation will in many cases perform whitespace normalization on the contents of elements (depending on their type). This will change the result of operations such as the string-length function.

Schema validation augments the data model by adding default values for omitted attributes and empty elements.

## J Revision Log (Non-Normative)

This log records the changes that have been made to this document since the Last Call Draft of 12 November 2003.

### J.1 23 July 2004

1. The SequenceType syntax has been simplified. SchemaContextPath is no longer part of the SequenceType syntax. Also, the section on SequenceType Matching has been rewritten to make its terminology more consistent with the Formal Semantics document.

2. The term xdt:untypedAny is changed to xdt:untyped.

3. xs:anyType is no longer an abstract type, but is now used to denote the type of a partially validated element node. Since there is no longer a meaningful distinction between abstract types and concrete types, these terms are no longer used in this document.

4. Value comparisons now return () if either operand is ().

5. The typed value of a namespace node is an instance of xs:string, not xdt:untypedAtomic.

6. The name of the Predicates grammar production has been changed to PredicateList.

7. The grammar production formerly called a FilterStep is now called a FilterExpression and is described in a separate section rather than as part of a path expression.

8. The precedence of the cast and treat operators in the grammar has been increased.

9. The precedence of unary arithmetic operators has been increased.

10. The appendix containing a list of error messages has been made non-normative.

11. A new component has been added to the static context: context item static type.

12. The expression data(()) no longer raises a static error, although its static type is empty.

13. If a dynamic implementation detects a static error, the dynamic evaluation phase is optional.

14. XPath allows host languages to specify whether they recognize the concept of a namespace node. XQuery does not recognize namespace nodes. Instead, it recognizes an "in-scope namespaces" property of an element node.

15. The specification now clearly distinguishes between "statically-known namespaces" (a static property of an expression) and "in-scope namespaces" (a dynamic property of an element).

16. The names of certain components in the static and dynamic contexts have been changed to make them more consistent and descriptive.

17. Corrections have been made to the rules for XPath 1.0 Compatibility Mode in the semantics of function calls.

18. The definition of the idiv operator has been made consistent with the Functions and Operators document. The idiv operator accepts operands of any numeric types, performs a division, and truncates the result to an integer.

19. Certain grammar productions have been renamed and reordered to make the grammar easier to read.

20. The section on constructor functions has been edited to make it more consistent with the definition of constructor functions in the Functions and Operators document.

21. The Comments section has been moved out of the Primary Expressions section, because a comment is not a primary expression.

22. Various minor changes, both editorial and substantive, have been made in response to public comments and working group discussions.

### J.2 29 Oct 2004

1. The last step in a path expression is now allowed to return a sequence of atomic values or a sequence of nodes (mixed nodes and atomic values are not allowed.)

2. A value of type xs:QName is now defined to consist of a "triple": a namespace prefix, a namespace URI, and a local name. Including the prefix as part of the QName value makes it possible to cast any QName into a string when needed.

3. XPath 1.0 compatibility mode has been extensively revised to make it closer to XPath 1.0. Very few incompatibilities remain when operating in compatibility mode.

4. In the static context, "current date" and "current time" have been replaced by "current dateTime", which is defined to include a timezone. Also, an implementation is required to initialize the current dateTime and implicit timezone.

5. The div operator can now be used to divide two yearMonthDurations or two dayTimeDurations. In either case, the result is of type xs:decimal.

6. Additional signatures have been added to the fn:error function.

7. The to operator now accepts an empty sequence as an operand, and returns empty sequence.

8. Support for XML 1.1 and Namespaces 1.1 have been bundled together and defined as an optional feature. Various aspects of query processing and serialization that depend on this optional feature have been identified.

9. Descriptions of the arithmetic and logical operators have been edited to eliminate dependencies on the order of operand evaluation.

10. A new zero-argument version of fn:collection has been defined, to provide access to an implementation-dependent default sequence.

11. The operator mapping for numeric ge and le operators has been changed.

12. The section on typed values and string values has been edited to clarify that an implementation may store either value and derive the other. Also, an example has been added to illustrate the typed value of a union type.

13. Various minor changes, both editorial and substantive, have been made in response to public comments and working group discussions.

### J.3 7 January 2005

1. The definition of Effective Boolean Value has changed.

2. Values of type xs:anyURI are now promotable to the type xs:string, and are compared and ordered using the same default collation used for strings.

3. Constructor functions are now defined for types that are in no namespace.

4. Type-related terms such as "schema type", "sequence type", "static type", "dynamic type", and "type annotation" have been given better definitions and more consistent usage.

5. Several error codes have been redefined or deleted.

6. Minor corrections have been made to the Operator Precedence Table.

7. Various minor changes, both editorial and substantive, have been made in response to public comments and working group discussions.

### J.4 21 February 2005

1. Error codes have been expanded from six characters to eight characters. Several error codes have been added, deleted, or modified.

2. New rules and examples have been added to the section on Errors and Optimization.

3. A new consistency constraint has been added: the value of the context item must match its static type.

4. Text has been added clarifying that, if the Static Typing Feature is not in effect, expressions have an implementation-dependent static type.

5. A subsection on Static Typing Extensions has been added to the Conformance section.

6. The References section has been reorganized.

7. A new appendix has been added, enumerating all the implementation-defined items.

8. Various minor changes, both editorial and substantive, have been made in response to public comments and working group discussions.

### J.5 04 April 2005

1. The keyword empty has been changed to void in the SequenceType grammar, in order to avoid conflict with the built-in function named empty.

2. The section on constructor functions has been rewritten. The semantics of constructor functions are now defined as equivalent to a cast expression.

3. The version of Unicode that is supported by an XPath implementation is now implementation-defined.

4. The format in which errors are reported by an XPath implementation is now implementation-defined.

5. Various minor changes, both editorial and substantive, have been made in response to public comments and working group discussions.

#### What's XPath(XML Path language)?

2012-09-29 17:24:09

#### java中的xpath，读取xml文档。

2014-01-07 00:34:31

#### XML Path Language (XPath) 2.0标准.pdf

2009年05月14日 1.77MB 下载

#### XPath Language 1.0

2008年10月21日 139KB 下载

#### XPath在QT中的使用（QXmlQuery读取XML文件）

2011-08-03 17:50:17

#### XPath 1.0 与 XPath 2.0 简介

2004-11-28 15:18:00

#### XML Path Language (XPath).pdf

2011年02月12日 114KB 下载

#### Go-XPath解析

2014-07-11 19:15:24

#### java中使用xPath读取xml中的数据

2017-01-05 14:22:24

#### dom4j解析XML时使用XPath直接定位至标签实例

2012-09-22 13:06:38

## 不良信息举报

XML Path Language (XPath) 2.0