This document does not specify interfaces for initiating an STX transformation. Instead, these interfaces are implementation defined. This section describes the minimum amount of information that must be supplied to execute a transformation:

There is a contextual information available at each point during processing. It includes the data arriving with the current event and other data related to the state of processing. The contextual information at any particular instant during the processing is called the current context. The context information consists of the following parts:

Each incoming event can invoke a template within the stx-sheet by means of precedence categories and a match pattern (see ). The template that is used to process the current node is called the current template. Templates can be separated into groups (see ). Top-level templates are considered to be members of the default group. The group containing the current template is referred to as the current group.

Templates are classed into the precedence categories according to their visibility from a base group. The base group can be either the current group or the group explicitly specified in the group attribute of current process statement. The visibility is defined using the visibility and public attributes for each template (see ).

There are three precedence categories (listed with decreasing precedence):

The first precedence category is searched for the best matching template by means of a match pattern (see ). If there is no matching template in the first precedence category, the second category is searched. If neither the first nor the second category contain a matching template, the third category is searched.

STX uses an expression language called STXPath that is defined later in this specification (see ).

Expressions are used in match patterns, to specify conditions for different ways of processing of the current node, to generate text to be inserted to an output stream, or to access data from the ancestor stack.

An STXPath expression may occur as the value of certain attributes on STX elements, and also within curly braces in attribute value templates (see ). The context within an stx-sheet where an STXPath expression appears may specify a required data type; the type of value that the expression is expected to return.

STXPath expressions can include built-in functions whose expanded names are identified by a specific namespace which is referred to as the STX function namespace. This document uses the 'sf' prefix as a shortcut for referring to the built-in STXPath functions

It is a static error if the value of an expression attribute does not match the STXPath production expression. It is a dynamic error if any STXPath expression is evaluated and raises an error, or when it raises an error when converting to the required data type.

The attribute stxpath-default-namespace of the stx:transform element (see ) may be used to define the namespace that will be used for an unprefixed name used as a name test within a step of an STXPath expression or pattern. The value of the attribute is the namespace URI to be used.

This default namespace URI applies only to elements; it does not apply to attributes. In the absence of this attribute, an unqualified name test matches an element whose namespace URI is null: the default namespace of XML document (as defined by an xmlns="some-uri" declaration) is not used.

A match pattern specifies a set of conditions on the current context. If the current context satisfies the conditions the current node matches the pattern; if the current context does not satisfy the conditions the current node does not match the pattern. The syntax for STX patterns is a subset of the syntax for STXPath expressions. In particular, patterns are in form of location paths that meet certain restrictions.

Here are some examples of patterns:

A match pattern is a set of location path patterns separated with |. A location path pattern is a location path whose steps are separated either by the / (child axis) operator or by the // operator (descendant axis). Up to one predicate is allowed in each step. Predicate expressions are STXPath expressions (see ).

Predicate expressions are evaluated using the current context. If the result is a number, the result will be converted to true if the number is equal to the context position and will be converted to false otherwise. Thus a location path p[3] is equivalent to p[sf:position()=3]. Otherwise the result will be converted to a boolean using the type conversion rules described in . If the result of evaluating and converting the predicate expression is false, the pattern does not match the current node.

If there is no matching template available a default rule is applied. One of three default rules, specified in the pass-through attribute of stx:transform or stx:group element can be used: none (to skip the current node), all (to pass through the current node), and text (to pass through the current node only if it is a text node). All these three default rules process all children of the current node, thus the processing does not stop when a default rule is applied. The default rule can be set for the stx-sheet (see ) or for a group (see ). This feature enables copying of documents with only a few changes, and to straightforwardly select just a few items from a document. The default behavior is to ignore all not matching events (value none) on the stx-sheet level. Groups inherit the pass-through behavior from their parent group when not specified explicitly.

It is possible that the current context matches more than one rule within a precedence category. Each rule has a computed priority value. The computed priority can be overridden with a 'priority' attribute value (see ).

The rule with the highest priority is used. If there is more than one matching template rule with the highest priority, an STX processor must select the rule that occurs the last in the stx-sheet.

In an attribute that is designated as an attribute value template an STXPath expression can be used by surrounding the expression with curly braces ({}).

An attribute value template consists of an alternating sequence of fixed parts and variable parts. A variable part consists of an STXPath expression enclosed in curly braces ({}). A fixed part may contain any characters, except that a left curly brace must be written as {{ and a right curly brace must be written as }}.

The result of evaluating an attribute value template is obtained by concatenating the expansions of the fixed and variable parts. The expansion of a fixed part is obtained by replacing any double curly braces ({{ or }}) by the corresponding single curly brace. The expansion of a variable part is obtained by evaluating the enclosed STXPath expression and converting the resulting value to a string.

If a left curly brace appears in an attribute value template without a matching right curly brace, or if a right curly brace occurs in an attribute value template outside an expression without being followed by a second right curly brace, a processor must signal a static error.

All errors that can occur during an STX transformation belong to one of the following categories:

This specification does not define how to issue a warning or an error. Implementations are free to use either the standard output or standard error output, or any convenient error handler.

The aspects of the that are dependent on W3C XML Schema are not used in STX.

A set of accessors is defined on all nodes in . These accessors are shown with the prefix 'dm'. Additional, STX specific, accessors are shown with the prefix 'stxdm'. The prefixes are not bound to namespaces as both kinds of accessor are abstract, not directly accessible functions.

The following accessors are never used during STX transformations on any node:

The dm:string-value accessor defined in is replaced with an STX specific accessor stxdm:string-value. The way in which the string value accessor of different kinds of nodes is computed is the following:

In addition to the kinds of nodes defined in STX recognizes two more kinds: document type nodes and cdata nodes.

Document type (doctype) nodes represent an information contained in document type declarations. Doctype has the following properties:

Doctype nodes must satisfy these constrains:

The properties of doctype nodes are exposed by the following accessors defined in .

Moreover, two extra STX accessors are defined for doctype nodes:

Cdata nodes encapsulate XML character content enclosed within CDATA boundaries. Cdata nodes have the same properties and accessors as text nodes defined in with the only exception of the dm:node-kind accessor which returns "cdata" for cdata nodes.

Namespace nodes are not directly accessible in STX; they are not exposed as nodes. The information held in namespace nodes is instead made available using two functions: sf:get-in-scope-namespaces and sf:get-namespace-uri-for-prefix. Properties of namespace nodes that are not exposed by these two functions can not be accessed by STX processors.

In , atomic values belong to the value space of W3C XML Schema atomic types; this is, primitive simple types or types derived by restriction from a primitive simple type. The STX data model recognizes only three atomic types:

Source documents and an stx-sheet may contain whitespace nodes (text nodes consisting solely of whitespace characters: #x20, #x9, #xD or #xA). Such whitespace nodes may be removed according to the following rules. This process is referred to as whitespace stripping.

Whitespace nodes are stripped from source documents if the strip-space attribute of stx:transform (see ) or stx:group (see ) is set to yes. Otherwise they are preserved and treated as any other text nodes.

For stx-sheets, whitespace text nodes are preserved only if an ancestor element of this text node has the xml:space attribute set to preserve, and no closer ancestor element has xml:space set to default. All other whitespace nodes are removed from the stx-sheet.

The STX elements stx:text and stx:cdata have the default xml:space attribute set to preserve which may be overridden in the stx-sheet. xml:space attributes on literal result elements will not be stripped from these elements.

The STX namespace has the URI &STXNS;.

The STX functions namespace has the URI &STXFNS;.

These two namespaces are recognized as reserved namespaces in STX transformation sheets, and may be used only for purposes specified in this document.

stx:transform

STX transformation sheets are required to use the root element stx:transform.

The version attribute contains a version number to distinguish language versions; this attribute is mandatory and its value must be 1.0 for this version of STX.

The other attributes make it possible to set global properties of the transformation. Some of these properties (pass-through, recognize-cdata, strip-space) can also be set on the group level.

An stx:transform element can contain the following children from the STX namespace. These elements are called top-level elements:

All top-level elements may occur multiple times. stx:namespace-alias element is allowed as top-level element only.

Templates can be organized into groups using the stx:group element. Groups of templates play a role in template matching (precedence categories are defined for groups) and determine the scoping of variables.

Each stx-sheet has a virtual default group (represented by stx:transform) that is considered to be the parent of top-level groups. Explicit groups represented by stx:group are not mandatory; many transformations can be done without grouping templates. On the other hand, templates separated to groups make it possible to define more precise transformation rules and to run safer complex transformations, especially on a well-known, regular input data.

stx:group

This element must be a child of either the stx:transform or the stx:group element. The optional name attribute contains a qualified name that must be unique in the stx-sheet. The name can be referenced by the group attribute of any of stx:process-children, stx:process-attributes, stx:process-self, stx:process-siblings, stx:process-document or stx:process-buffer instructions. In this event, the referenced group is used instead of the current group for matching. It is not possible to reference the default group.

It is a static error if an stx-sheet contains more than one group of the same name.

The attributes pass-through, recognize-cdata, and strip-space are optional, and they set transformation properties specific for this group. Their meaning is exactly the same as the meaning of global properties of the same name specified on the stx:transform element (see ). The only difference is that the group attributes have the additional value inherit. This is the default value; it specifies that the value of the same property of the nearest ancestor group should be used. In other words, the value of the property stems from the nearest ancestor group that has the corresponding attribute set to a value distinct from inherit, or from the default value of the stx:transform element, if no such attribute was specified. At each point of the processing, properties of the current base group apply.

An stx-sheet may include another stx-sheet using the stx:include element.

stx:include

This declaration is used to insert additional stx-sheet modules into the principal stx-sheet module. A circular inclusion is prohibited.

This element must be top-level or a child of the stx:group element. stx:include is replaced with the stx:transform element of the included stx-sheet whereupon the included stx:transform then becomes an stx:group element. There is one exception: an stx:namespace-alias instruction from the included stx-sheet is always inserted as a top-level element. The resulting stx-sheet must meet the criteria for being a valid STX transformation sheet (for example concerning unique group and procedure names).

The rules for attributes of the imported stx:transform element are as follows:

There is no difference between templates from the principal stx-sheet module and included templates in terms of matching precedence.

stx:namespace-alias

Namespaces of literal elements and attributes in stx-sheets can be mapped to different namespaces in result streams using the stx:namespace-alias element. Both attributes are mandatory and can contain either a prefix bound to a namespace or the #default keyword for the default namespace.

stx:template

Rules to process input events are written in templates. The stx:template element must be a child of either the stx:transform or the stx:group element. Templates match to the events by means of precedence categories and a pattern in the mandatory match attribute. The optional priority attribute can contain an explicit priority value used for matching (see ).

Two optional attributes; visibility and public; control whether the template is visible from other groups (and thus can match to the next event) or not. See for meaning of the two attributes. The default value of the visibility attribute is local. The default value of the public attribute for top-level templates is yes, for group templates it is no. Whether a top-level template is public or not is important only when the stx-sheet is included into another stx-sheet, because every top-level template then becomes a group template, see .

The optional new-scope attribute specifies whether the template creates new instances of group variables. The default value is no. A new set of group variables is created for each instantiated template with new-scope="yes". These variables shadow their former values and exist as long as the template is being processed.

The content of templates may include both STX instructions and declarations, and literal elements. Literal elements are simply copied to the output.

A text template is defined as the content of some elements (stx:attribute, stx:variable, stx:param, stx:assign, stx:with-param, stx:cdata, stx:processing-instruction, stx:comment, stx:message). This is a part of template that is supposed to generate nothing but character events to the current output stream. If an event of another type is emitted, an STX processor is required either (1) to issue a run-time error or (2) to serialize the event or (3) to ignore the event according to the value of markup attribute. See for details.

stx:procedure

Procedures are sub-templates that can be called by names (with the stx:call-procedure instruction). The optional visibility, public, and new-scope attributes have the same meaning and default values as for templates. Only visible procedures can be called by name, the new-scope must be set to yes to create new copies of group variables. It is a static error if an stx-sheet contains more than one visible procedure with the same name within the same precedence category.

The content of procedures may be the same as the content of templates.

stx:call-procedure

The stx:call-procedure element makes it possible to invoke a procedure by its name. The name attribute is mandatory. The optional group attribute allows to use the specified group instead of the current group as a base group for calling the procedure.

The target procedure will be determined according to the precedence categories described in . If the first category does not contain a procedure with the requested name, then the second category will be searched. If neither the first nor the second category contain such procedure, the third category is searched. It is a static error if none of the three precedence categories contain the requested procedure.

Values can be passed to stx-sheets or to their templates and procedures as parameters. Parameters are variables (see ) with the additional property that their value can be set by the caller of the stx-sheet, the template, or the procedure. Stx-sheet parameters behave in the same way as group variables, they may be shadowed by variables or parameters of the same name in descendant groups. Note that a parameter that is only visible in a certain group will be initialized with the value passed to the stx-sheet anyway, regardless whether there is a shadowed parameter of the same name or not. Template/procedure parameters behave in the same way as local variables; thus they are only visible within the template or procedure they are passed to. There are two elements available to work with parameters:

stx:with-param

Parameters are passed to templates or procedures using the stx:with-param element. The required name attribute specifies the name of the parameter. The value of the parameter is either the result returned by the expression located in the optional select attribute or the content of this element if the select attribute is missing. If neither the select attribute nor the content is present the parameter value is the empty string.

The stx:with-param instruction is allowed as a child of the elements stx:process-children, stx:process-attributes, stx:process-self, stx:process-siblings, stx:process-document, stx:process-buffer, or stx:call-procedure, and must not have any of these elements in its content.

stx:param

The stx:param element is allowed as a top-level or group element (indicating an stx-sheet parameter) and in templates or procedures (as a child of stx:template or stx:procedure). The required name attribute specifies the name of the parameter. The optional select attribute or the content of this element specifies a default value, which is both evaluated and used only when there is no value specified using the select attribute or the content of the appropriate stx:with-param element. Should both the select attribute and the content be missing, the parameter defaults to the empty string.

Stx-sheet parameters are statically initialized while parsing the stx-sheet; only the static context information is available during the initialization. Template/procedure parameters are initialized at run-time. Since there is no current source stream available during the static initialization, it is an error if an stx-sheet parameter has an stx:process-children, stx:process-attributes, stx:process-self, or stx:process-siblings instruction in its content.

The optional required attribute may be used to indicate that a parameter is mandatory. The default value is no, indicating that the parameter is optional. If the value of the required attribute is yes, the stx:param element must be empty, and must have no select attribute. It is a dynamic error if the caller does not supply a value with stx:with-param for a required parameter.

stx:copy

The stx:copy element is used to copy the current node to the output. The optional attributes attribute contains a pattern. These attributes of the current node that match the pattern are copied to the output. If the attributes attribute is not present no attributes are copied with the current node.

Thus, attributes="@*" copies all attributes, attributes="@foo|@bar" copies the foo and bar attributes only, attributes="@*[not(name()='foo')]" copies all but the foo attribute, and attributes="@*[false()]" does not copy any attributes as if the attributes attribute is missing at all.

If the stx:copy instruction applies to a node other than element the attributes attribute is ignored.

stx:process-children

The instruction stx:process-children suspends the processing of the current template by processing the children of the current node.

There must be always at most one stx:process-children instruction executed during the processing of a template. Moreover, it is an error if stx:process-children is encountered after an stx:process-self instruction or an stx:process-siblings instruction.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

The optional filter-method and filter-src attributes can be used to direct the processing of children to an external filter, see .

stx:process-attributes

This instruction is used to apply templates to attributes of an element node.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

stx:process-siblings

The stx:process-siblings instruction suspends the processing of the current template and processes the following siblings of the current node. The processing can be terminated by one of while or until conditions, or because of the end of the parent element or the current buffer (see stx:process-buffer).

The optional while attribute contains a pattern. The next siblings are processed as long as they match the specified pattern. The first non-matching node stops the processing; this node is not processed by this stx:process-siblings instruction.. The while attribute defaults to node().

The optional until attribute contains a pattern. The next siblings are processed until a node matching the pattern is encountered; this node is not processed by this stx:process-siblings instruction. The until attribute defaults to node()[false()].

If both while and until attributes have been specified then both conditions have to be met. For example <stx:process-siblings while="foo" until="foo"/> does not process any siblings. Variable bindings used within the patterns will be interpreted with regard to the current context. That means changed group variables affect the evaluation, whereas new instances of group variables or local variables are not visible.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

The optional filter-method and filter-src attributes can be used to direct the processing of siblings to an external filter, see .

An stx:process-siblings instruction encountered during the processing of siblings does not affect the while and until conditions of the previous stx:process-siblings. In other words: nested stx:process-siblings instructions process at most the siblings chosen in the preceding stx:process-siblings. That means stx:process-siblings also returns if there are no more siblings in the input available or a preceding stx:process-siblings terminates.

Though multiple stx:process-siblings instructions may appear within the same template it is an error if an stx:process-children or stx:process-self instruction will be encountered after stx:process-siblings.

stx:process-self

This instruction is used to process the current node using the template that would have been chosen if the current template was not present in the stx-sheet. The current template will not be instantiated again for this node, even in a chain of calls to stx:process-self. There must be always at most one stx:process-self instruction executed during the processing of a template. Moreover it is an error if an stx:process-self instruction is encountered after an stx:process-children or an stx:process-siblings instruction in a template.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

The optional filter-method and filter-src attributes can be used to direct the processing of the context node to an external filter, see .

stx:value-of

This instructions emits characters to the result stream. The mandatory select attribute contains an STXPath expression whose value may be any sequence of items. The optional separator attribute defaults to a single space character. This element is always empty.

The result of this instruction is the concatenation of the string values of the items in the sequence from the select attribute, with each of these string values except the last being followed by the string that is the effective value of the separator attribute. If the effective value of the separator attribute is a zero-length string, then all items in the sequence are processed and the results are concatenated with no separator.

stx:text

This instruction emits literal character data to the result stream.

The optional markup attribute determines how non-text nodes in the content of stx:text should be handled: error causes the processor to raise a run-time error for such nodes, ignore ignores any markup by emitting only the string value of the contents to the result stream, serialize emits any markup serialized as text. The default value is error.

The stx:text element has an implicit xml:space attribute with the default value preserve. Thus the content is normally neither normalized nor stripped should it contain whitespace characters only.

stx:cdata

This instructions emits literal data as a CDATA section to the result stream.

The stx:cdata element has an implicit xml:space attribute with the default value preserve. Thus the content is normally neither normalized nor stripped should it contain whitespace characters only.

stx:element

This instruction is used to generate an element. It has the same meaning as in .

stx:start-element

stx:end-element

There are separate instructions available to output an element start tag and end tag. The name attribute is required for both instructions. The both elements must be empty.

A compliant STX processor is required to produce a well-formed XML output. An attempt to create an end-tag without a matching start-tag must be reported as an error by the STX processor.

stx:attribute

This instruction is used to generate an attribute. It has the same meaning as in . Alternatively, the value of the generated attribute may be specified in the optional select attribute. It is a static error if this instruction has a select attribute and is not empty.

stx:attribute must follow an element-starting instruction (stx:element, stx:start-element, stx:copy, or a literal element) and no other output-generating instructions are allowed between the element-starting instruction and stx:attribute. Otherwise, an STX processor is required to issues an error.

stx:processing-instruction

This instruction is used to generate a processing instruction. It has the same meaning as in . Alternatively, the value of the generated processing instruction may be specified in the optional select attribute. It is a static error if this instruction has a select attribute and is not empty.

stx:comment

This instruction is used to generate a comment. It has the same meaning as in . Alternatively, the value of the generated comment may be specified in the optional select attribute. It is a static error if this instruction has a select attribute and is not empty.

stx:doctype

This instruction is used to generate a document type declaration that contains or points to markup declarations. The system-id attribute contains a system identifier. The public-id attribute contains a public identifier. Both attributes are optional. This element must be either empty or it must contain a valid internal subset of markup declarations (see ).

stx:if

The mandatory test attribute contains an STXPath expression evaluating to boolean. The content template is instantiated if and only if the test attribute has evaluated to true.

stx:else

This instruction must follow immediately after stx:if; a static error must be reported otherwise. The content template is instantiated if and only if the test attribute of the preceding stx:if instruction has evaluated to false.

stx:choose

The same meaning as in .

stx:for-each-item

The stx:for-each-item instruction contains a template that is instantiated for each item of the sequence specified by the mandatory select attribute.

The mandatory name attribute specifies a name of local variable that is declared automatically for each item, and that contains the current item.

Neither the current node (accessed with .) nor sf:position() change inside stx:for-each-item.

stx:while

The mandatory test attribute contains an STXPath expression evaluating to boolean. The contents of the stx:while element is instantiated repeatedly as long as the test attribute evaluates to true.

stx:process-document

An stx-sheet can process further source streams in addition to this supplied when the transformation is invoked (the principal source stream). The current source stream can be changed with the stx:process-document instruction. When this instruction is instantiated the expression in the mandatory href attribute will be evaluated, each item in the resulting sequence will be converted sequentially to a string (a URI), and its value will be used to identify and to process a new source stream. When new source streams for all items are processed, the execution of the template containing the stx:process-document instruction continues with the original source stream.

If a URI is a relative URI then the base URI will be derived from the type of item in the sequence that represents this URI. In case this item is a node then its base URI will be used, otherwise the base URI of the stx-sheet will be used. Alternatively, the optional base attribute can be used to specify explicitly which base URI should be used. Its value must be either an absolute URI, the string #input in which case the base URI of the current input stream will be used, or the string #stylesheet in which case the base URI of the principal stx-sheet will be used.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

The optional filter-method and filter-src attributes can be used to direct the processing of document to an external filter, see .

stx:result-document

An stx-sheet can produce further result streams in addition to the principal result stream. The current result stream can be changed with the stx:result-document instruction. Events generated as the result of executing instructions contained within the stx:result-document element are emitted to a new current result stream identified with the URI which is specified by an attribute value template in the required href attribute. Then, the execution of instructions behind the end of the stx:result-document element continues to emit events into the original result stream.

If the href attribute contains a relative URI, the base output URI is used to resolve the URI. The base output URI is implementation defined; it can be provided through an interface or otherwise specified by an STX processor.

The optional attributes output-method and output-encoding can be used to specify a preferred output method and an output encoding for the new result stream. Their semantics is the same as for stx:transform, see . If one of these attributes is not present then the values will be used that are in effect for the principal result stream.

A sequence of events can be stored into an object called a buffer. The stored events can be emitted and processed later, in the same way as events emitted from a source stream. The events are emitted from a buffer in the same order as they were stored in. In other words, the buffers are temporary storages of the 'first in first out' type. The events stored in a buffer must represent a well-formed external general parsed entity (the restriction on a single root node is relaxed).

There are two types of buffers:

A buffer must be declared before it can be used. The same rules as for variables (see ) apply for the the visibility of buffers, their shadowing, and the creating of new instances for new-scope templates (see ).

stx:buffer

The stx:buffer element declares a buffer. The mandatory name attribute contains a qualified name identifying the declared buffer. The buffer is initialized with events generated as a result of evaluation of the content of the stx:buffer declaration. If the content is empty (stx:buffer element has no children) the buffer is empty.

For group buffers, the content of stx:buffer element is evaluated statically. It is a static error if the element stx:buffer declaring a group buffer contains an stx:process-children, stx:process-self, stx:process-siblings, stx:process-attributes, stx:process-document, stx:process-buffer, or call-procedure instruction in its content.

stx:result-buffer

The stx:result-buffer instruction directs events emitted by its content into the buffer specified with the mandatory name attribute rather than to the current result stream. The buffer must be declared with stx:buffer before it can be employed in stx:result-buffer.

If the buffer specified with the name attribute already contains a sequence of events, the new sequence of events is appended behind the last event in the previously stored sequence normally. If the stx:result-buffer element has the optional clear attribute with the value of yes, the previously stored events are removed from the buffer before the new sequence of events is stored in. The clear attribute defaults to no.

The events stored in a buffer will not be available for a following stx:process-buffer before the stx:result-buffer instruction has terminated. Until then the previous contents is accessible. Thus for processing a buffer and storing the result in the same buffer again use ]]>

It is an error if this instruction is executed for a buffer that acts already as (current or suspended) result buffer.

stx:process-buffer

The stx:process-buffer instruction emits the events currently stored in the buffer specified by the mandatory name attribute to the STX processor. The events are processed in the same way as events supplied by source streams. When the very last event from the buffer is processed, the processing in the current template continues with an instruction, declaration or literal next to the stx:process-buffer instruction.

The optional group attribute makes it possible to use the specified group instead of the current group as the base for matching (see ). It is a static error if the group of the specified name is not available.

The optional filter-method and filter-src attributes can be used to direct the processing of buffer's contents to an external filter, see .

The processing of events from a buffer does not mean the emptying of this buffer. Once a sequence of events is stored in the buffer, it can be processed repeatedly.

The main task of an STX processor is to transform a stream of source XML events into a stream of result XML events (see ). Using this paradigm, an STX processor can be seen as a typical representative of a filter of XML events.

Moreover, STX can as well direct any XML event stream to an external filter process and incorporate the result of this processing into the current result stream. Thus an STX process may split a large XML document into smaller fragments, pass each of these fragments to an external filter (for example an XSLT processor), and combine the results into a large XML result document.

Each event stream directed to an external filter represents a well-formed XML fragment.

STX provides two attributes for identifying the external filter: filter-method and filter-src. Both attributes can be used on stx:process-children (), stx:process-siblings (), stx:process-self (), stx:process-document (), and stx:process-buffer ().

The optional filter-method attribute contains a URI that identifies a filter method to be used. This specification cannot provide a complete list of filters and their URIs. However, if a filter method is described using an XML vocabulary in a well-known namespace, its namespace URI is the recommended value for the filter-method attribute, see for a list of currently recommended URIs. A conformant STX processor does not have to support any external filters. The function sf:filter-available may be used to check, whether the current STX processor supports the requested filter.

It is a static error to specify both filter-method and group attributes. It is a run-time error if the requested filter is not supported by the processor.

The optional filter-src attribute provides additional information about the source to initialize the desired filter. There are two kinds of values allowed for this attribute:

It is a static error, if the filter-src attribute is present without a filter-method attribute. However, the specification of a filter-method attribute does not require necessarily a filter-src attribute.

stx:message

The stx:message instruction generates a separate result stream whose handling is implementation dependent. It can be directed to a log, or to a special message resolver, etc. However, all instructions of the content of the stx:message element must processed even if the message stream is ignored. Alternatively, the value of the generated message may be specified in the optional select attribute. It is a static error if this instruction has a select attribute and is not empty.

A literal is a direct syntactic representation of an atomic value. STXPath supports two kinds of literals: string literals and numeric literals.

The value of a string literal is a singleton sequence containing an item whose atomic type is string and whose value is the string denoted by the characters between the delimiting quotation marks.

The value of a numeric literal is a singleton sequence containing an item whose type is number and whose value is obtained by parsing the numeric literal according to the rules for string to numbers conversion (see ).

STX has full-featured re-assignable variables. The STX elements stx:variable and stx:assign are used to declare and initialize variables, and to assign new values to them. Visible variables can be referenced in STXPath expressions.

STX variables are scoped statically according to the literal structure of stx-sheets. The grouping of templates is used to make the sharing of other than global variables possible.

There are two types of variables:

A group variable is visible for the group where the variable is declared, for all descendant groups and for all templates belonging to these groups. A local variable is visible for all following siblings of the variable declaration and their descendants. Group variables may be shadowed (another variable with the same name is visible) by descendant group variables and by local variables. It is a static error to redeclare a variable with the same name in the same group or template.

Variables always contain a sequence. STX instructions stx:variable and stx:assign are used to evaluate an expression and store its value into a variable.

Since variables are re-assignable, each variable must be declared using the stx:variable element before it is used (assigned, referenced). Group variables are statically initialized while parsing an stx-sheet. Only the static context information is available during the initialization of group variables. Local variables are initialized at run-time. A variable declared with no value is initialized with a singleton sequence containing the empty string.

stx:variable

This instruction is used to declare and initialize a variable. The mandatory name attribute contains the name of the variable. An expression in the select attribute is evaluated and the variable is initialized with its result. The select attribute is optional; a variable is initialized with the string resulting from the content of the stx:variable element if the select attribute is missing. If the content is empty (stx:variable element has no children) the variable is initialized with the empty string.

It is a static error if the element stx:variable declaring a group variable contains an stx:process-children, stx:process-self, stx:process-siblings, stx:process-attributes, stx:process-document, stx:process-buffer, or call-procedure instruction in its content.

The optional keep-value attribute specifies whether a new instance of the variable created by instantiating a template having its new-scope attribute set to yes is initialized with the value of the shadowed variable (yes) or not (no). This attribute is allowed only for group variables. The default value is no. If there is no shadowed variable (a variable with the same name declared in an ancestor group) yet, the keep-value attribute is ignored.

stx:assign

This instruction is used to assign a new value to a previously declared variable. The mandatory name attribute contains the name of the variable. The expression in the optional select attribute is evaluated and its result is assigned to the variable. The string resulting from the content of the stx:assign element is assigned to the variable if the select attribute is missing. If the content is empty, the empty string is assigned to the variable.

Parentheses may be used to enforce a particular evaluation order in expressions that contain multiple operators.

Parentheses are also used as delimiters in constructing a sequence, as described in .

Parenthesized Expressions in STXPath are equivalent to Parenthesized Expressions in .

The context item expression evaluates to the current node.

A function call consists of a function qualified name followed by a parenthesized list of zero or more expressions. The expressions inside the parentheses provide arguments of the function call. The number of arguments must be equal to the number of function parameters; otherwise a static error is raised.

A function call is evaluated as follows:

STXPath function names are contained in the reserved namespace &STXFNS;. The sf: prefix is used to refer to this namespace in this document. The default function namespace is assigned to this reserved namespace in STX. Thus, the functions namespace does not need to be declared in stx-sheets and STXPath functions can be invoked without any namespace prefix.

Some STXPath functions have the same definitions as their counterparts (functions with the same local name) in XPath 2.0. These functions are not re-defined in this section. Instead, original definitions in are referenced. Other STXPath functions are either different from their XPath 2.0 counterparts or have no such counterparts; these functions are defined in this section.

A path expression can be used to locate nodes within the ancestor stack. It evaluates to a sequence of nodes from the stack. A path expression consists of a series of one or more axis steps, separated by / or //, and optionally beginning with / or //.

This sequence of axis steps is evaluated from left to right. Each operation E1/E2 is evaluated as follows: Expression E1 is evaluated into a sequence of nodes. Each node resulting from the evaluation of E1 then serves to provide an inner context for evaluation of E2. Each evaluation of E2 results in a (possibly empty) sequence of nodes. The sequences of nodes resulting from all the evaluations of E2 are combined, eliminating duplicate nodes based on node identity and sorting the result in document order.

A / at the beginning of a path expression is an abbreviation for the initial step. The effect of this initial step is to begin the path at the root node of the current ancestor stack.

A // at the beginning of a path expression is an abbreviation for the initial steps. The effect of these initial steps is to establish an initial node sequence that contains the root of the current ancestor stack, plus all nodes descended from this root. This node sequence is used as an input to subsequent steps in the path expression.

An axis step generates a sequence of nodes from the ancestor stack and then filters the sequence using up to one predicate. The value of the step consists of those nodes that satisfy the predicate. Predicates are described in . Nodes are always returned in the document order. An axis step may be either an abbreviated forward step or an abbreviated reverse step, followed by no or one predicate. An axis step might be thought of as beginning at the context node and navigating to those nodes that are reachable from the context node via a specified axis. STXPath has abbreviated syntax only. The result of an abbreviated forward step consists of the nodes reachable from the context node via the specified axis (either child or attribute) that have the node kind or name specified by a node test.

In addition to common names (QNames and wildcards) and kind tests known from , STXPath has two more kind tests: