An element object may have a unique identifier (ID). This is the value of the attribute which is declared in the DTD as type ID. No two elements in a document may have the same unique ID. If an XML processor reports two elements in a document as having the same unique ID (which is possible only if the document is invalid) then the second element must be treated as not having a unique ID.

An element node also has an associated URI called its base URI which is used for resolving attribute values that represent relative URIs into absolute URIs. If an element occurs in an external entity, the base URI of that element is the URI of the external entity. Otherwise the base URI is the base URI of the document.

An axis identifies a list of nodes based on the kind of tree relationship that the nodes have to the context node. For example, the children of the context node are one axis, the ancestors of the context node are another axis. Note that an axis identifies an ordered list, not a set. The order of nodes in an axis is in the direction away from the context node.

The following axes are defined:

In an axis identifier the name of the axis is preceded by from- to distinguish it from a function name.

A node test that is a QName tests whether the node is an element or attribute with the specified name. For example, from-attributes(href) selects the href attribute of the context node; if the context node has no href attribute, it will select an empty set of nodes.

A QName in the node test is expanded into a local name and a possibly null URI. This expansion is done using the namespace declarations from the expression context. This is the same way expansion is done for element type names in start and end-tags except that the default namespace declared with xmlns is not used: if the QName does not have a prefix, then the URI is null (this is the same way attribute names are expanded). The expanded names are then compared for equality. Two expanded names are equal if they have the same local part, and either both have no URI or both have the same URI.

A node test * is true for any element or attribute node. For example, from-children(*) will select all element children of the context node, and from-attributes(*) 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 context namespace declarations. The node test will be true for an element or attribute whose expanded name has the URI to which the prefix expands, whatever the local part of the name.

The node test text() is true for any text node. For example from-children(text()) will select the text node children of the context node. Similarly, the node test comment() is true for any comment node, and the node test pi() is true for any processing instruction. The pi() test may have an argument that is Literal; in this case it is true for any processing instruction that has a name equal to the value of the Literal.

A node test node() is true for any node.

A predicate filters a list of nodes to produce a new list of nodes. For each node in the list to be filtered, the PredicateExpr is evaluated with that node as the context node and with the complete list of nodes to be filtered as the context node list; if PredicateExpr evaluates to true for that node, the node is included in the new list; otherwise it is not included.

A PredicateExpr is evaluated by evaluating the Expr and converting the result to a boolean. If the result is a number, the result will be converted to true if the number is equal to the position of the context node in the context node list and will be converted to false otherwise; if the result is not a number, then the result will be converted as if by a call to the boolean() function. Thus a location path para[3] is equivalent to para[position()=3].

Here are some examples of location paths using abbreviated syntax:

The most important abbreviation is that when the axis is the children axis, the from-children and surrounding parentheses can be omitted. In effect the children axis is the default axis. For example, a location path div/para is short for from-children(div)/from-children(para).

There's also an abbreviation for the attributes axis. Instead of using from-attributes and parentheses around the node test, the node test can be preceded by @ to indicate the attributes axis. For example, a location path para[@type="warning"] is short for from-children(para[from-attributes(type)="warning"]) and so selects para children with a type attribute with value equal to warning.

// is short for /from-descendants-or-self(node())/. For example, //para is short for /from-descendants-or-self(node())/from-children(para) and so will select any para element in the document (even a para element that is a document element will be selected by //para since the document element node is a child of the root node); div//para is short for div/from-descendants-or-self(node())/from-children(para) and so will select all para descendants of div children.

A location step of . is short for from-self(node()). This is particularly useful in conjunction with //. For example, the location path .//para is short for

and so will select all para descendant elements of the context node.

Similarly a location step of .. is short for from-parent(node()). For example, ../title is short for from-parent(node())/from-children(title) and so will select the title children of the parent of the context node.

A VariableReference evaluates to the value to which the variable name is bound in the set of variable bindings in the context.

Parentheses may be used for grouping.

A location path can be used as an expression. The expression returns the set of nodes selected by the path.

The | operator computes the union of its operands which must be node-sets.

Square brackets are used to filter expressions in the same way that they are used in location paths. It is an error if the expression to be filtered does not evaluate to a node-set. The context node list used for evaluating the expression in square brackets is the node-set to be filtered listed in document order.

The / operator and // operators combine an arbitrary expression and a relative location path. It is an error if the expression does not evaluate to a node-set. The / operator does composition in the same way as when / is used in a location path. As in location paths, // is short for /from-descendants-or-self(node())/.

There are no types of objects that can be converted to node-sets. It is an error if evaluating a NodeSetExpr yields an object that is not a node-set.

The last() function returns the number of nodes in the context node list. The position() function returns the position of the context node in the context node list. The first position is 1, and so the last position will be equal to last().

The count() function returns the number of nodes in the argument node-set.

The id() and idref() functions select elements by their unique ID (see ). id() converts its argument to a string and returns a node-set containing the element in the same document as the context node with unique ID equal to that string, if there is such an element, and otherwise returns an empty node-set. idref() requires that its argument be a node-set; for each node in the node-set, the value is split into a whitespace-separated list of tokens; idref() returns a node-set containing the elements in the same document as the context node that have a unique ID equal to any of the tokens in the value of any of the nodes in the node-set. For example,

The key() and keyref() functions select a set of nodes using the node key function in the expression evaluation context. Both functions have a string as the first argument that specifies the name of the key and have an expression as the second argument. key() has a second argument that is a string and returns a node-set containing the nodes in the same document as the context node that have a value for the named key equal to this string. keyref() has a second argument that is a node-set and returns a node-set containing the nodes in the same document as the context node that have a value for the named key equal to the value of any of the nodes in the argument node-set. See for how to declare a key.

The doc() and docref() functions allow access to XML documents other than the initial source document. They both rely on the ability to treat a string as a URI reference that is mapped to a node-set; this mapping always takes places relative to a node that can be used to resolve a relative URI into an absolute URI. If the URI reference does not contain a fragment identifier, then it will be mapped to a node-set containing the root node in a tree representing the XML document whose document entity is the resource identified by the URI. If the URI reference contains a fragment identifier, then it will first map the URI to a tree representing the XML document whose document entity is the resource identified by the URI and then use the fragment identifier to select a set of nodes in that tree; the semantics of the fragment identifier is dependant on media type of the result of retrieving the URI. doc() takes a string argument which it treats as a URI reference which is mapped to a node-set relative to the element in the stylesheet containing the expression. Note that a zero-length URI reference is a reference to the document relative to which the URI reference is being resolved; thus doc("") refers to the root node of the stylesheet; the tree representation of the stylesheet is exactly the same as if the XML document containing the stylesheet was the initial source document. docref() takes a node-set argument; for each node in the node-set, docref() treats the value of the node as a URI reference that is mapped to a node-set relative to that same node; docref() returns the union of the resulting node-sets.

The local-part() function returns a string containing the local part of the name of the first node in the argument node-set. If the node-set is empty or the first node has no name, an empty string is returned. If the argument is omitted it defaults to the context node.

The namespace() function returns a string containing namespace of the name of the first node in the argument node-set. If the node-set is empty or the first node has no name or the name has no namespace, an empty string is returned. If the argument is omitted it defaults to the context node.

The qname() function returns a string containing a QName representing the name of the first node in the argument. The QName must represent the name with respect to the namespace declarations in effect on the node whose name is being represented. Typically this will be the form in which the name occurred in the XML source. This need not be the case if there are namespace declarations in effect on the node that associate multiple prefixes with the same namespace. However, an implementation may include information about the original prefix in its representation of nodes; in this case an implementation can ensure that the returned string is always the same as the QName used in the XML source. If the argument it omitted it defaults to the context node.

The generate-id() function returns a string that can be used as a unique identifier for the first node in the argument node-set. The unique identifier must consist of ASCII alphanumeric characters and must start with an alphabetic character. An implementation is free to generate an identifier in any convenient way provided that it always generates the same identifier for the same node and that different identifiers are always generated from different nodes. An implementation is under no obligation to generate the same identifiers each time a a document is transformed. If the argument node-set is empty, the empty string is returned. If the argument is omitted, it defaults to the context node.

An object of type boolean can have two values, true and false.

The boolean() function converts its argument to a boolean as follows:

If the argument is omitted, it defaults to the context node.

A BooleanExpr is evaluated by converting the result of evaluating the Expr to a boolean as if by a call to the boolean() function.

An = expression is evaluated as follows. If at least one operand is a boolean, then each operand is converted to a boolean as if by applying the boolean() function and the operands are compared as booleans. Otherwise, if at least one operand is a number, then each operand is converted to a number as if by applying the number() function and the operands are compared as numbers; positive and negative zero compare equal. Otherwise both operands are converted to strings as if by applying the string() function and the operands are compared as strings; two strings are equal if they contain the same sequence of UCS characters.

A <, >, <= or >= expression is evaluated by first converting each operand to a number as if by a call to the number() function and then comparing the two numbers.

An or expression is evaluated by evaluating each operand and converting its value to a boolean. The result is true if either value is true and false otherwise.

An and expression is evaluated by evaluating each operand and converting its value to a boolean. The result is true if both values are true and false otherwise.

The not() function returns true if its argument is false, and false otherwise.

The true() function returns true.

The false() function returns false.

The lang() function returns true or false depending on whether the language of the context node as specified by xml:lang attributes is the same as or is a sublanguage of the language specified by the argument string. The language of the context node is determined by the value of the xml:lang attribute on the context node, or, if the context node has no xml:lang attribute, by the value of the xml:lang attribute on the nearest ancestor of the context node that has an xml:lang attribute. If there is no such attribute, then lang() returns false. If there is such an attribute, then lang() returns true if the attribute value is equal to the argument ignoring case, or if there is some suffix starting with - such that the attribute value is equal to the argument ignoring that suffix of the attribute value and ignoring case. For example, lang("en") would return true if the context node is any of these five elements:

A number represents a floating point number. A number can have any double-precision 64-bit format IEEE 754 value. These include a special Not-a-Number (NaN) value, positive and negative infinity, and positive and negative zero.

A NumberExpr is evaluated by converting the result of evaluating the Expr to a number as if by a call to the number() function.

The number() function converts its argument to a number as follows:

If the argument is omitted, it defaults to the context node.

The div operator performs floating point division according to IEEE 754.

The quo operator performs a floating point division and then truncates the result to an integer. For example,

The mod operator returns the remainder from the quo operation. For example,

The sum() function returns the sum of the values of the nodes in the argument node-set.

The floor() function returns the largest (closest to positive infinity) number that is not greater than the argument and that is an integer.

The ceiling() function returns the smallest (closest to negative infinity) number that is not less than the argument and that is an integer.

The round() function returns the number that is closest to the argument and that is an integer. If there are two such numbers, then the one that is even is returned.

A string consists of a sequence of UCS characters.

A StringExpr is evaluated by converting the result of evaluating the Expr to a string as if by a call to the string() function.

The string() function converts an object to a string as follows:

If the argument is omitted, it defaults to the context node.

The concat() function returns the concatenation of its arguments.

The starts-with() function returns true if the first argument string starts with the second argument string, and otherwise returns false.

The contains() function returns true if the first argument string contains the second argument string, and otherwise returns false.

The substring-before() function returns the substring of the first argument string that precedes the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string. For example, substring-before("1999/04/01","/") returns 1999.

The substring-after() function returns the substring of the first argument string that follows the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string. For example, substring-after("1999/04/01","/") returns 04/01.

The normalize() function returns the argument string with white space normalized by stripping leading and trailing whitespace and replacing sequences of whitespace characters by a single space. Whitespace characters are the same allowed by the S production in XML. If the argument is omitted, it defaults to the context node converted to a string, in other words the value of the context node.

The translate() function returns the first argument string with occurrences of characters in the second argument string replaced by the corresponding characters from the third argument string. For example, translate("bar","abc","ABC") returns the string BAr.

The format-number() function converts its first argument to a string using the format pattern string specified by the second argument and the locale named by the third argument, or the default locale, if there is no third argument. The format pattern string is in the syntax specified by the JDK 1.1 DecimalFormat class. The format pattern string is in a localized notation: the locale determines what characters have a special meaning in the pattern (with the exception of the quote character, which is not localized). The format pattern must not contain the currency sign (#x00A4); support for this feature was added after the initial release of JDK 1.1. See for how to declare a locale.

The only operations that can be performed on a result tree fragment are to convert it to a string or a boolean. In particular, it is not permitted to use the /, //, and [] on result tree fragments.

Expressions can only return values of type result tree fragment by referencing variables of type result tree fragment or calling extension functions that return a result tree fragment.

The CName is expanded to a name using the namespace declarations from the evaluation context. The XSLT processor attempts to locate an implementation of the extension function with the specified name that it can use. The implementation may be provided by an xsl:functions element (see ) or the XSLT processor may be able to locate an implementation by other means not specified by XSLT. If the XSLT processor cannot locate such a function, then evaluating the expression is an error. Otherwise the implementation is called passing it the values of the expressions and the value returned by the function is the value of the expression. The function-available() function can be used to test whether an implementation of a particular function is available (see ). A XSLT processor is allowed always to give an error when evaluating an ExtensionFunctionCall (with such an XSLT processor the function-available() function would always return false). Therefore if an XSLT stylesheet includes an ExtensionFunctionCall and does not use the function-available() function to test for and handle the possibility that an implementation of the function is not available, then it may not be portable across all XSLT implementations.

For both these functions, the StringExpr must evaluate to a string that is a QName. The QName is expanded into a name using the namespace declarations in scope for the expression.

The system-property() function returns an object representing the value of the system property identified by the name. If the name has no namespace, then the system-property() function must return the string value of the operating system environment variable whose name is equal to the local part of the name. If there is no such system property, the empty string should be returned.

Implementations must provide the following system properties which are all in the XSLT namespace:

The function-available() function returns true if an implementation of the named extension function is available. For example:

When tokenizing, the longest possible token is always returned.

For readability, whitespace may be used in patterns even though not explicitly allowed by the grammar: ExprWhitespace may be freely added within patterns before or after any ExprToken.

A NodeType, FunctionName, CName or AxisIdentifier token is recognized only when the following token is (. An OperatorName token or MultiplyOperator token is recognized as such only when there is a preceding token and the preceding token is not one of @, (, [, , or an Operator.

The xsl:key element is used to declare keys. The name specifies the name of the key. The match attribute is a Pattern; a xsl:key element gives information about the keys of any node that match the pattern specified in the match attribute. The use attribute is a NodeSetExpr, which specifies the set of values for which the node has a key of the specified name. A node x has a key with name y and value z if and only if there is a xsl:key element such that:

Note that the NodeSetExpr may return a node-set with more than one node; all of the returned nodes serve as a key value. Note also that there may be more than one xsl:key element that matches a given node; all of the matching xsl:key elements are used.

Implementations of the extension functions in a namespace can be provided using the xsl:functions element. The required ns attribute specifies the namespace for which an implementation is being provided. The value of the ns attribute is a namespace prefix which is expanded to a namespace URI using the namespace declarations in effect on the xsl:functions element.

The implementation may be provided in two ways. If the code attribute is present, then its value is a URI that identifies a resource containing an implementation of the functions in the namespace; in this case a type attribute giving the MIME media type of the data providing the implementation may also be provided, so as to allow the XSLT processor to avoid fetching resources of types that it is unable to make use of. If the code attribute is not present, then the content of the xsl:functions element contains the implementation of the functions; in this case the type attribute must be present.

Multiple alternative implementations may be provided for the same namespace. For example,

The xsl:functions element may also have an archive attribute that specifies a whitespace-separated list of URIs of resources relevant to the provided implementation.

An XSLT processor is not required to be able to make use of implementations provided by xsl:functions elements. The MIME media types that an XSLT processor is able to make use of and the way the XSLT processor interfaces with implementations is dependent on the particular XSLT processor. Therefore if an XSLT stylesheet includes an ExtensionFunctionCall of an extension function in a namespace for which an implementation is provided by an xsl:functions element, then it may not be portable across all XSLT implementations.

The xsl:locale element declares a locale which controls the interpretation of a format pattern used by the format-number() function. If there is a name attribute then the element declares a named locale, otherwise it declares the default locale.

The other attributes on xsl:locale correspond to the methods on the JDK 1.1 DecimalFormatSymbols class. For each get/set method pair there is an attribute defined for the xsl:locale element. The default values are given in the XSLT DTD (see ).

The following attributes specify characters that may appear in the result of formatting the number and also control the interpretation of characters in the format pattern:

The following attributes control the interpretation of characters in the format pattern:

The following attributes specify strings that may appear in the result of formatting the number:

In a template an element in the stylesheet that does not belong to the XSLT namespace is instantiated to create an element node of the same type. The created element node will have the attribute nodes that were present on the element node in the stylesheet tree. The created element node will also have the namespace nodes that were present on the element node in the stylesheet tree with the exception of any namespace node whose value is the XSLT namespace URI (http://www.w3.org/XSL/Transform/1.0).

The value of an attribute of a literal result element is interpreted as an attribute value template: it can contain string expressions contained in curly braces ({}).

Namespace URIs that occur literally in the stylesheet and that are being used to create nodes in the result tree can be quoted. This applies to:

A namespace URI is quoted by prefixing it with the string quote:. This prefix will be removed when the template is instantiated to create the result element node with its associated attribute nodes and namespace nodes.

When literal result elements are being used to create element, attribute, or namespace nodes that use the XSLT namespace URI, the namespace must be quoted to avoid misinterpretation by the XSLT processor.

For example, the stylesheet

will generate an XSLT stylesheet from a document of the form:

The xsl:element element allows an element to be created with a computed name. The name of the element to be created is specified by a required name attribute and an optional namespace attribute. The content of the xsl:element element is a template for the attributes and children of the created element.

The name attribute is interpreted as an attribute value template; the string value from instantiating it must be a QName. If the namespace attribute is not present, then the QName is expanded into a name using the namespace declarations in effect for the xsl:element element, including any default namespace declaration.

If the namespace attribute is present, then it also interpreted as an attribute value template; the string value from instantiating it should be a URI reference. This is used as the namespace of the name of the element to be created. The local part of the QName specified by the name attribute is used as the local part of the name of the element to be created.

XSLT processors may make use of the prefix of the QName specified in the name attribute when selecting the prefix used for outputting the created element as XML. They are not however required to do so.

The xsl:attribute element can be used to add attributes to result elements whether created by literal result elements in the stylesheet or by instructions such as xsl:element. The name of the attribute to be created is specified by a required name attribute and an optional namespace attribute. Instantiating an xsl:attribute element adds an attribute node to the containing result element node. The content of the xsl:attribute element is a template for the value of the created attribute.

The name attribute is interpreted as an attribute value template; the string value from instantiating it must be a QName. If the namespace attribute is not present, then the QName is expanded into a name using the namespace declarations in effect for the xsl:attribute element, not including any default namespace declaration.

If the namespace attribute is present, then it also interpreted as an attribute value template; the string value from instantiating it should be a URI reference. This is used as the namespace of the name of the attribute to be created. The local part of the QName specified by the name attribute is used as the local part of the name of the attribute to be created.

XSLT processors may make use of the prefix of the QName specified in the name attribute when selecting the prefix used for outputting the created attribute as XML. They are not however required to do so.

The following are all errors:

The xsl:attribute-set element defines a named set of attributes. The name attribute specifies the name of the attribute set. The xsl:use element adds a named set of attributes to an element. It has a required attribute-set attribute that specifies the name of the attribute set. xsl:use is allowed in the same places as xsl:attribute. The content of the xsl:attribute-set consists of xsl:attribute elements that specify attributes; it may also contain xsl:use elements. The value of attributes in an attribute set is determined when the attribute set is used rather than when the attribute set is defined.

The following example creates a named attribute set title-style and uses it in a template rule.

Any attribute in a named attribute set specified by xsl:use is not added to an element if the element already has an attribute of that name.

Multiple definitions of an attribute set with the same name are merged. An attribute from a definition that is more important takes precedence over an attribute from a definition that is less important. It is an error if there are two attribute sets with the same name that are equally important and that both contain the same attribute unless there is a more important definition of the attribute set that also contains the attribute. An XSLT processor may signal the error; if it does not signal the error, it must recover by choosing from amongst the most important definitions that specify the attribute the one that was specified last in the stylesheet.