XML Path Language (XPath)
Version 1.0

Empfehlung des W3C, 16. November 1999

Diese Version:

http://www.w3.org/TR/1999/REC-xpath-19991116
(verfügbar als XML oder HTML)

Aktuelle Version:

http://www.w3.org/TR/xpath

Vorherige Versionen:

http://www.w3.org/TR/1999/PR-xpath-19991008
http://www.w3.org/1999/08/WD-xpath-19990813
http://www.w3.org/1999/07/WD-xpath-19990709
http://www.w3.org/TR/1999/WD-xslt-19990421

Herausgeber:

James Clark <jjc@jclark.com>
Steve DeRose (Inso Corp. and Brown University) <Steven_DeRose@Brown.edu>

Copyright  ©  1999 W3C (MIT, INRIA, Keio), All Rights Reserved. Es gelten die W3C-Regeln zu Haftung, Warenzeichen und Verwendung des Dokuments sowie die Lizenzregeln für Software.

---

Zusammenfassung

Die Sprache XPath dient zur Adressierung von Teilen eines XML-Dokuments. Sie wurde für die Verwendung sowohl in XSLT als auch in XPointer entworfen.

Status dieses Dokuments

Dieses Dokument wurde von Mitgliedern des W3C und anderen Interessierten geprüft und vom Direktor als W3C-Empfehlung gebilligt. Es ist ein abgeschlossenes Dokument und darf als Referenzmaterial verwendet oder als normative Referenz von einem anderen Dokument zitiert werden. Die Rolle des W3C bei der Erstellung dieser Empfehlung ist es, die Spezifikation bekanntzumachen und ihre breite Anwendung zu fördern. Dies erhöht die Funktionsfähigkeit und Interoperabilität des Web.

Die Liste der bekannten Fehler in dieser Spezifikation ist unter http://www.w3.org/1999/11/REC-xpath-19991116-errata verfügbar.

Anmerkungen zu dieser Spezifikation können an www-xpath-comments@w3.org geschickt werden; alle Anmerkungen sind in einem Archiv verfügbar.

Die englische Version dieser Spezifikation ist die einzig normative Version. Allerdings werden Übersetzungen dieses Dokumentes unter http://www.w3.org/Style/XSL/translations.html aufgeführt.

Aktuelle W3C-Empfehlungen und weitere technische Dokumente sind unter http://www.w3.org/TR zu finden.

Diese Spezifikation ist das Ergebnis der gemeinsamen Arbeit der XSL- und der XML-Linking-Arbeitsgruppen und damit Teil der W3C Style Activity und der W3C XML Activity.

Inhaltsverzeichnis

Anhang

1 Einleitung

XPath ist das Ergebnis der Bemühungen, eine gemeinsame Syntax und Semantik für jene Funktionen bereitzustellen, die sowohl von XSL Transformations [XSLT] als auch von XPointer [XPointer] genutzt werden. Die primäre Aufgabe von XPath besteht in der Adressierung von Teilen eines XML-Dokuments [XML]. Zur Unterstützung dieser Aufgabe werden außerdem einfache Hilfsmittel für die Manipulation von Zeichenketten, Zahlen und booleschen Werten bereitgestellt. XPath benutzt eine kompakte nicht-XML-Syntax, um die Verwendung von XPath-Ausdrücken innerhalb von URIs und XML-Attributen zu erleichtern. XPath operiert auf der abstrakten, logischen Struktur eines XML-Dokuments, nicht auf seiner äußerlichen Syntax. Seinen Namen erhält XPath durch die Verwendung einer auch in URLs genutzten Pfad-Notation (path), mit der sich durch die hierarchische Struktur eines XML-Dokuments navigieren lässt.

Neben der Verwendung für die Adressierung wurde XPath so gestaltet, dass eine natürliche Teilmenge davon zum Matching (Testen, ob ein Knoten auf ein Muster passt) genutzt werden kann. Diese Anwendung von XPath ist in XSLT beschrieben.

XPath modelliert ein XML-Dokument als einen Baum, der aus Knoten besteht. Es gibt verschiedene Knotentypen, unter anderem Elementknoten, Attributknoten und Textknoten. XPath definiert, wie der Zeichenkettenwert für jeden Knotentyp berechnet wird. Einige Knoten besitzen zusätzlich einen Namen. XPath unterstützt in vollem Umfang XML-Namensräume [XML Names]. Daher wird der Name eines Knotens als ein Paar aus einem lokalem Bestandteil und einem gegebenenfalls leeren Namensraum-URI modelliert - dieses wird erweiterter Name genannt. Das Datenmodell ist detailliert in [5 Datenmodell] beschrieben.

Anmerkung des Übersetzers: Zur Veranschaulichung der durch XPath modellierten Baumstruktur soll folgendes Beispiel dienen: <?xml version="1.0"?> <!DOCTYPE rezept SYSTEM "rezept.dtd"> <?xml-stylesheet href="style.xsl" type="text/xml"?> <rezept> <zutat id="mehl">200g Mehl</zutat> <!-- weitere Zutaten --> <anleitung> Zuerst nehmen Sie das <zutat xmlns:xlink="http://www.w3.org/1999/xlink" xlink:type="simple" xlink:href="mehl">Mehl</zutat> und mischen es mit ... </anleitung> </rezept> Dieses recht kurze XML-Dokument besitzt bereits eine aus 23 Knoten bestehende Baumrepräsentation: Die XML-Deklaration sowie die Dokumenttyp-Deklaration finden sich in der Baumdarstellung nicht wieder, auf sie kann über einen XPath-Ausdruck auch nicht zugegriffen werden. Alle anderen Bestandteile des Dokuments (Wurzel, Elemente, Textinhalt, Attribute, Namensräume, Kommentare, Processing Instructions) werden durch entsprechende Knoten des Baumes repräsentiert. Die leeren Quadrate symbolisieren Textknoten, die ausschließlich Leerraumzeichen enthalten. Inwieweit sich solcher Leerraum in eigenen Textknoten wiederfindet, wird von der XPath nutzenden Anwendung bestimmt. Schließlich sei auf die implizit zu jedem Element gehörenden Namensraumknoten für den xml-Namensraum hingewiesen. Das Document Object Model [DOM] definiert ebenfalls eine Baumrepräsentation, die allerdings von der in XPath verwendeten in einigen Punkten abweicht. Auf diese Unterschiede wird innerhalb des Kapitels [5 Datenmodell] eingegangen.

Das primäre syntaktische Konstrukt in XPath ist der Ausdruck. Ein Ausdruck passt zu der Produktion Expr. Die Auswertung eines Ausdrucks ergibt ein Objekt, das zu einem der folgenden vier Grundtypen gehört:

• node-set (eine ungeordnete Menge von Knoten ohne Duplikate)
• boolean (wahr oder falsch)
• number (eine Gleitkommazahl)
• string (eine Zeichenkette bestehend aus UCS-Zeichen)

Ein Ausdruck wird immer bezüglich eines Kontextes ausgewertet. XSLT und XPointer spezifizieren, wie dieser Kontext bei der Verwendung von XPath-Ausdrücken in XSLT beziehungsweise XPointer bestimmt wird. Der Kontext besteht aus:

• einem Knoten (dem Kontextknoten)
• einem Paar von positiven ganzen Zahlen ungleich 0 (der Kontextposition und der Kontextgröße)
• einer Menge von Variablenbelegungen
• einer Funktionsbibliothek
• den Namensraum-Deklarationen, in deren Gültigkeitsbereich der Ausdruck liegt

Die Kontextposition ist immer kleiner oder gleich der Kontextgröße.

Die Variablenbelegungen bestehen aus einer Abbildung von Variablennamen auf Variablenwerte. Der Wert einer Variablen ist ein Objekt, welches von jedem beliebigen Typ sein kann, der für Ausdrücke möglich ist. Daneben sind auch weitere Typen möglich, die hier nicht spezifiziert werden.

<xsl:variable name="antwort">
   <antwort><xsl:value-of select="6 * 7" /></antwort>
</xsl:variable>

<xsl:variable name="var" select="expression" />

Die Funktionsbibliothek besteht aus einer Abbildung von Funktionsnamen auf Funktionen. Jede Funktion besitzt null oder mehr Argumente und liefert einen einzelnen Wert. Diese Spezifikation definiert eine Bibliothek von Grundfunktionen, die von allen XPath-Implementationen unterstützt werden muss (siehe [4 Bibliothek der Grundfunktionen]). Bei einer Grundfunktion gehören die Argumente und das Ergebnis einem der vier Grundtypen an. Sowohl XSLT als auch XPointer erweitern XPath um zusätzliche Funktionen, von denen einige auf den vier Grundtypen, andere auf zusätzlichen, durch XSLT und XPointer definierten Typen operieren.

Namensraum-Deklarationen bestehen aus einer Abbildung von Präfixen auf Namespace-URIs.

Die Variablenbelegungen, die Funktionsbibliothek und die Namensraum-Deklarationen, die benutzt werden, um einen Teilausdruck zu berechnen, sind immer dieselben, die auch für den umgebenden Ausdruck benutzt werden. Der Kontextknoten, die Kontextposition und die Kontextgröße, die zur Berechnung eines Teilausdrucks benutzt werden, sind dagegen zuweilen verschieden von denen des umgebenden Ausdrucks. Mehrere Arten von Ausdrücken ändern den Kontextknoten, aber nur Prädikate ändern die Kontextposition und die Kontextgröße (siehe [2.4 Prädikate]). Bei der Beschreibung, wie bestimmte Ausdrücke zu berechnen sind, wird immer explizit angegeben, ob sich der Kontextknoten, die Kontextposition oder die Kontextgröße bei der Berechnung von Teilausdrücken ändern. Wird nichts über Kontextknoten, Kontextposition und Kontextgröße ausgesagt, bleiben sie bei der Berechnung von Teilausdrücken dieser Ausdrücke gleich.

XPath-Ausdrücke erscheinen häufig in XML-Attributen. Die in diesem Abschnitt spezifizierte Grammatik wird auf Attributwerte nach ihrer Normalisierung gemäß XML 1.0 angewendet. Wenn beispielsweise die Grammatik das Zeichen < verwendet, so darf dieses nicht in der XML-Quelle als < auftreten, sondern muss gemäß den XML-1.0-Regeln notiert werden, zum Beispiel durch Eingabe als <. Innerhalb von Ausdrücken werden Zeichenkettenliterale durch einfache oder doppelte Anführungszeichen begrenzt, die ebenfalls zur Begrenzung von XML-Attributen verwendet werden. Um zu vermeiden, dass ein Anführungszeichen innerhalb eines Ausdrucks durch den XML-Prozessor als Abschluss des Attributwertes interpretiert wird, kann das Anführungszeichen als Zeichenreferenz eingegeben werden (" oder '). Alternativ können im Ausdruck einfache Anführungszeichen benutzt werden, falls das XML-Attribut durch doppelte Anführungszeichen begrenzt wird oder umgekehrt.

para="Sie fragte: "Wie geht's?""

<xsl:if test='para="Sie fragte: &quot;Wie geht&apos;s?&quot;"'>

para="Sie fragte: "Wie geht's?""

<xsl:variable name="string">Sie fragte: "Wie geht's?"</xsl:variable>

<xsl:if test="para=$string">

para=concat('Sie fragte: "Wie geht', "'", 's?"')

<xsl:if test="para=concat('Sie fragte: &quot;Wie geht',
                          &quot;'&quot;, 's?&quot;')">

Ein wichtiger spezieller Ausdruck ist der Lokalisierungspfad. Ein Lokalisierungspfad wählt eine Knotenmenge relativ zu einem Kontextknoten aus. Das Ergebnis der Berechnung eines Ausdrucks, der ein Lokalisierungspfad ist, ist genau die Knotenmenge, die die durch den Lokalisierungspfad ausgewählten Knoten enthält. Lokalisierungspfade können rekursiv Ausdrücke enthalten, die zum Filtern von Knotenmengen benutzt werden. Ein Lokalisierungspfad passt auf die Produktion LocationPath.

Die in der nachfolgenden Grammatik verwendeten Nichtterminale QName und NCName sind in [XML Names] definiert, S ist in [XML] definiert. Die Grammatik verwendet die gleiche EBNF-Notation wie in [XML] (mit der Ausnahme, dass Grammatiksymbole immer mit einem Großbuchstaben beginnen).

Ausdrücke werden geparst, indem die Zeichenfolge in einzelne Token zerlegt wird, und anschließend die entstehende Folge der Token geparst wird. Leerraumzeichen können beliebig zwischen Token verwendet werden. Der Zerlegungsprozess wird in [3.7 Lexikalische Struktur] beschrieben.

2 Lokalisierungspfade

Obwohl Lokalisierungspfade nicht das allgemeinste grammatische Konstrukt der Sprache darstellen (ein Lokalisierungspfad ist ein Spezialfall eines Ausdrucks), sind sie doch das wichtigste Konstrukt und werden deshalb als erstes beschrieben.

Jeder Lokalisierungspfad kann durch eine unkomplizierte und eher verbale Syntax ausgedrückt werden. Daneben gibt es eine Reihe von syntaktischen Abkürzungen, mit denen sich häufige Fälle kurz und prägnant ausdrücken lassen. Dieser Abschnitt erläutert die Semantik von Lokalisierungspfaden anhand der ausführlichen Syntax. Die abgekürzte Syntax wird im Anschluss daran erläutert, indem gezeigt wird, wie diese auf die ausführliche Syntax abgebildet wird (siehe [2.5 Abgekürzte Syntax]).

Es folgen einige Beispiele für Lokalisierungspfade unter Benutzung der ausführlichen Syntax:

• child::para wählt die Kindelemente para des Kontextknotens aus.

• child::* wählt alle Kindelemente des Kontextknotens aus.

• child::text() wählt alle Textknoten aus, die Kinder des Kontextknotens sind.

• child::node() wählt alle Kindknoten des Kontextknotens aus, unabhängig von ihrem Knotentyp.

  Anmerkung des Übersetzers: Obwohl sich sämtliche XPath-Lokalisierungspfade für Kontextknoten jedes Typs anwenden lassen, muss an dieser Stelle darauf hingewiesen werden, dass nur der Wurzelknoten sowie Elementknoten Kinder haben können. Diese Kinder können Element-, Text-, Kommentar- und Processing-Instruction-Knoten sein. Attribute und Namensraum-Knoten sind niemals Kinder anderer Knoten. Dieses Konzept wird noch einmal ausführlich in Kapitel [5 Datenmodell] beschrieben.

• attribute::name wählt das Attribut name des Kontextknotens aus.

• attribute::* wählt alle Attribute des Kontextknotens aus.

  Anmerkung des Übersetzers: Diese beiden Ausdrücke sind nur sinnvoll, wenn der Kontextknoten ein Elementknoten ist. Für alle anderen Knotentypen liefern sie die leere Knotenmenge.

• descendant::para wählt die para-Elemente aus, die Nachkommen des Kontextknotens sind.

• ancestor::div wählt alle div-Elemente aus, die Vorfahren des Kontextknotens sind.

• ancestor-or-self::div wählt alle div-Vorfahren des Kontextknotens aus, sowie auch den Kontextknoten selbst, falls dieser ein div-Element ist.

• descendant-or-self::para wählt alle para-Nachkommen des Kontextknotens aus, sowie auch den Kontextknoten selbst, falls dieser ein para-Element ist.

• self::para wählt den Kontextknoten aus, falls dieser ein para-Element ist, und ansonsten nichts.

• child::chapter/descendant::para wählt die para-Elemente aus, die Nachkommen der chapter-Kindelemente des Kontextknotens sind.

• child::*/child::para wählt alle para-Enkelelemente des Kontextknotens aus.

• / wählt die Wurzel des Dokuments aus (diese ist immer der Vater des Dokumentelementes).

  Anmerkung des Übersetzers: Der Begriff Wurzel unterscheidet sich hier vom dem in der XML-Spezifikation [XML, 2nd Edition] genutzten. Dort bezeichnen Wurzel und Dokumentelement das gleiche. In der XPath-Terminologie ist das Dokumentelement ein Kind des Wurzelknotens. Der Wurzelknoten entspricht damit dem Dokument-Entity, siehe [5.1 Wurzelknoten]. Das ist insofern wichtig, als der Wurzelknoten außerdem Kommentar- oder Processing-Instruction-Knoten als Kinder haben kann, die damit Geschwister des Dokumentelementes sind. Des Weiteren muss hier hinzugefügt werden, dass durch / die Wurzel des Dokuments ausgewählt wird, in dem sich der Kontextknoten befindet. Es lässt sich leicht eine Knotenmenge bilden, die Knoten aus verschiedenen Dokumenten enthält. Die in XSLT definierte Funktion document liefert beispielsweise den Wurzelknoten eines anderen Dokuments.

• /descendant::para wählt alle para-Elemente aus, die im gleichen Dokument wie der Kontextknoten enthalten sind.

  Anmerkung des Übersetzers: Genaugenommen werden alle para-Elemente ausgewählt, die Nachkommen der Wurzel des Dokuments sind, zu dem der Kontextknoten gehört.

• /descendant::olist/child::item wählt alle item-Elemente aus, die ein olist-Vaterelement besitzen und die sich im gleichen Dokument wie der Kontextknoten befinden.

  Anmerkung des Übersetzers: Die folgenden Beispiele zeigen Lokalisierungspfade, bei denen die ursprünglich ausgewählten Knotenmengen durch nachgestellte Filterausdrücke in eckigen Klammern, sogenannte Prädikate, weiter eingeschränkt werden.

• child::para[position()=1] wählt das erste para-Kindelement des Kontextknotens aus.

• child::para[position()=last()] wählt das letzte para-Kindelement des Kontextknotens aus.

• child::para[position()=last()-1] wählt das vorletzte para-Kindelement des Kontextknotens aus.

• child::para[position()>1] wählt alle para-Kindelemente des Kontextknotens aus, mit Ausnahme des ersten para-Kindelementes des Kontextknotens.

• following-sibling::chapter[position()=1] wählt das nächste chapter-Geschwisterelement des Kontextknotens aus.

• preceding-sibling::chapter[position()=1] wählt das vorhergehende chapter-Geschwisterelement des Kontextknotens aus.

  Anmerkung des Übersetzers: An dieser Stelle sei als kurzer Vorgriff darauf hingewiesen, dass sich die Position eines Knotens in der aktuellen Kontextkontenliste über die Funktion position bestimmen lässt, und diese Position offenbar von der Blickrichtung abhängt. Von allen vorhergehenden Geschwisterelementen befindet sich der unmittelbare Vorgänger an der Position 1.

• /descendant::figure[position()=42] wählt das zweiundvierzigste figure-Element im Dokument aus.

  Anmerkung des Übersetzers: Hier werden alle figure-Nachkommen des Wurzelknotens betrachtet. Ausgehend von ihrer natürlichen Reihenfolge im Dokument wird aus der gesamten Menge das zweiundvierzigste ausgewählt. Die Definition dieser natürliche Reihenfolge, der sogenannten Dokumentordnung, ist Bestandteil des Kapitels [5 Datenmodell].

• /child::doc/child::chapter[position()=5]/child::section[position()=2] wählt das zweite section-Element des fünften chapter-Elements des doc-Dokumentelementes aus.

• child::para[attribute::type="warning"] wählt alle para-Kindelemente des Kontextknotens aus, die ein type-Attribut mit dem Wert warning besitzen.

• child::para[attribute::type='warning'][position()=5] wählt das fünfte para-Kindelement des Kontextknotens aus, das ein Attribut type mit dem Wert warning besitzt.

• child::para[position()=5][attribute::type="warning"] wählt das fünfte para-Kindelement des Kontextknotens aus, wenn dieses Kind ein type-Attribut mit dem Wert warning besitzt.

  Anmerkung des Übersetzers: Die letzten beiden Beispiele zeigen, wie sich durch ein Prädikat Kontextgröße und -position ändern können. Das Prädikat [position()=5] liefert immer eine Knotenmenge, die maximal einen Knoten enthält, je nachdem, ob es einen fünften Knoten gibt oder nicht. Das erste der beiden Beispiele beschränkt zunächst die betrachtete Knotenmenge auf die para-Elemente mit dem Attribut type="warning" und wählt anschließend aus diesen das fünfte aus. Das zweite Beispiel wählt zuerst das fünfte para-Element und anschließend aus der verbleibenden Knotenmenge die Knoten mit dem gewünschten Attribut aus. Besitzt das fünfte para-Element also gerade kein Attribut type="warning", so ist das Ergebnis in diesem Fall die leere Knotenmenge.

• child::chapter[child::title='Introduction'] wählt die chapter-Kindelemente des Kontextknotens aus, die wenigstens ein title-Kindelement mit einem Zeichenkettenwert gleich Introduction besitzen.

• child::chapter[child::title] wählt die chapter-Kindelemente des Kontextknotens aus, die ein oder mehrere title-Kindelemente besitzen.

• child::*[self::chapter or self::appendix] wählt die chapter- und appendix-Kindelemente des Kontextknotens aus.

  Anmerkung des Übersetzers: Hier werden aus allen Kindern (child::*) diejenigen ausgewählt, die selbst (self::) entweder ein chapter- oder ein appendix-Element sind. Hier muss man etwas aufpassen, da der Ausdruck in den eckigen Klammern für einen anderen Kontextknoten ausgewertet wird als der Ausdruck vor den Klammern. Der Vergleich mit den beiden vorhergehenden Beispielen verdeutlicht den Unterschied. Die genaue Definition folgt in Kapitel [2.4 Prädikate].

• child::*[self::chapter or self::appendix][position()=last()] wählt das letzte chapter- oder appendix-Kindelement des Kontextknotens aus.

  Anmerkung des Übersetzers: Hier wird zunächst die Menge aller chapter- oder appendix-Kinder betrachtet und aus dieser dann das letzte ausgewählt. Die Ergebnisknotenmenge enthält damit (maximal) einen Knoten.

Es gibt zwei Arten Lokalisierungspfade: relative und absolute Lokalisierungspfade.

Ein relativer Lokalisierungspfad wird durch eine Folge aus einem oder mehreren Lokalisierungsschritten gebildet, die durch / voneinander getrennt sind. Die Schritte eines relativen Lokalisierungspfades werden von rechts nach links zusammengesetzt. Jeder Schritt wählt der Reihe nach eine Knotenmenge relativ zu einem Kontextknoten aus. Eine Anfangsfolge von Schritten wird mit einem folgenden Schritt wie folgt zusammengesetzt: Die Anfangsfolge von Schritten wählt eine Knotenmenge relativ zu einem Kontextknoten aus. Jeder Knoten in dieser Menge wird dann als Kontextknoten für den folgenden Schritt benutzt. Die durch diesen Schritt bestimmten Knotenmengen werden vereinigt. Die Vereinigung ist dann genau die Knotenmenge, die durch das Zusammensetzen der Schritte ausgewählt wird. Zum Beispiel wählt child::div/child::para die para-Kindelemente der div-Kindelemente des Kontextknotens aus, oder - mit anderen Worten - die para-Enkelelemente, die div-Elternelemente haben.

Ein absoluter Lokalisierungspfad besteht aus dem Zeichen / und einem optional folgenden relativen Lokalisierungspfad. Ein / allein wählt den Wurzelknoten des Dokuments aus, das den Kontextknoten enthält. Falls ein relativer Lokalisierungspfad folgt, so wählt der Lokalisierungspfad die Knotenmenge aus, die ein relativer Lokalisierungspfad relativ zum Wurzelknoten des den Kontextknoten enthaltenen Dokuments auswählen würde.

Lokalisierungspfade

2.1 Lokalisierungsschritte

Ein Lokalisierungsschritt hat drei Bestandteile:

• eine Achse, welche die Beziehung zwischen den durch den Lokalisierungsschritt ausgewählten Knoten und dem Kontextknoten innerhalb des Baumes spezifiziert,

• einen Knotentest, der den Knotentyp und den erweiterten Namen der durch den Lokalisierungsschritt ausgewählten Knoten spezifiziert, sowie

• null oder mehr Prädikate, die mittels beliebiger Ausdrücke die durch den Lokalisierungsschritt ausgewählte Knotenmenge weiter verfeinern können.

  Anmerkung des Übersetzers: Prädikate im mathematischen Sinn sind Aussagen über Eigenschaften, die für die betreffenden Objekte wahr oder falsch sein können. In diesem Sinn wählt ein Prädikat aus einer Knotenmenge genau diejenigen Knoten aus, für die die entsprechende Aussage zutrifft. Aber auch ohne Kenntnis der Begriffswelt der Prädikatenlogik kann man sich anhand der Begriffe »Prädikatswein« oder »Prädikatsexamen« verdeutlichen, dass hier jeweils eine bestimmte Eigenschaft bzw. Qualität des beschriebenen Objekts ausgedrückt wird.

Ein Lokalisierungsschritt besteht syntaktisch aus dem Namen der Achse, gefolgt von zwei Doppelpunkten und dem Knotentest, gefolgt von null oder mehr in eckigen Klammern eingeschlossenen Ausdrücken. Zum Beispiel enthält child::para[position()=1] die Achse child, den Knotentest para und ein Prädikat [position()=1].

Die durch den Lokalisierungspfad ausgewählte Knotenmenge ergibt sich aus der durch Achse und Knotentest bestimmten Ausgangsknotenmenge, indem dort der Reihe nach die einzelnen Prädikate angewendet werden.

Die Ausgangsknotenmenge enthält alle Knoten, die zum Kontextknoten in der durch die Achse angegebenen Beziehung stehen, und den im Knotentest spezifizierten Knotentyp und erweiterten Namen besitzen. Zum Beispiel wählt der Lokalisierungsschritt descendant::para alle para-Nachkommen des Kontextknotens aus: descendant besagt, dass jeder Knoten in der Ausgangsknotenmenge ein Nachkomme des Kontextknotens sein muss; para besagt, dass jeder Knoten in der Ausgangsknotenmenge ein Element mit dem Namen para sein muss. Die verfügbaren Achsen werden in [2.2 Achsen] beschrieben, die verfügbaren Knotentests in [2.3 Knotentests]. Die Bedeutung einiger Knotentests hängt von der jeweiligen Achse ab.

Die Ausgangsknotenmenge wird durch das erste Prädikat gefiltert und ergibt eine neue Knotenmenge. Diese wird anschließend durch das zweite Prädikat gefiltert und so weiter. Die resultierende Knotenmenge ist schließlich die Knotenmenge, die durch den Lokalisierungsschritt ausgewählt wird. Die Achse beeinflusst, wie der Ausdruck in jedem Prädikat berechnet wird. Die Semantik eines Prädikats ist damit bezüglich einer Achse definiert. Siehe [2.4 Prädikate].

child::para[attribute::type="warning"][position()=5]

child::para[position()=5][attribute::type="warning"]

Lokalisierungsschritte

2.2 Achsen

Es stehen die folgenden Achsen zur Verfügung:

• die Achse child enthält die Kinder des Kontextknotens.

  Anmerkung des Übersetzers: Die Kreise, die hier und bei den folgenden Achsen zur Darstellung der einzelnen Knoten genutzt werden, repräsentieren keine speziellen Knotentypen. Es könnte sich also sowohl um Elemente, als auch um Textknoten, Kommentare oder Processing Instructions handeln. Sie repräsentieren allerdings niemals Attribut- oder Namensraum-Knoten, da diese nur über eigens dafür definierte Achsen erreicht werden können. Insbesondere sind es keine Kinder anderer Knoten. Die Nummern geben die Näheposition der Knoten in der durch die Achse ausgewählten Knotenmenge an.

• die Achse descendant enthält die Nachkommen des Kontextknotens; ein Nachkomme ist ein Kind, oder ein Kind eines Kindes usw. Die Nachkommenachse enthält niemals Attribut- oder Namensraum-Knoten.

  Anmerkung des Übersetzers:

• die Achse parent enthält den Elternknoten des Kontextknotens, falls es einen gibt.

  Anmerkung des Übersetzers: Bis auf den Wurzelknoten besitzt jeder Knoten einen Elternknoten.

• die Achse ancestor enthält die Vorfahren des Kontextknotens; die Vorfahren des Kontextknotens bestehen aus dem Elternknoten des Kontextknotens, dessen Elternknoten usw. Die Vorfahrenachse enthält somit immer den Wurzelknoten, es sei denn, der Kontextknoten selbst ist der Wurzelknoten.

  Anmerkung des Übersetzers:

• die Achse following-sibling enthält alle nachfolgenden Geschwister des Kontextknotens; falls der Kontextknoten ein Attribut- oder Namensraum-Knoten ist, ist diese Achse leer.

  Anmerkung des Übersetzers: Geschwister sind die Knoten, die den gleichen Elternknoten wie der Kontextknoten besitzen.

• die Achse preceding-sibling enthält alle vorhergehenden Geschwister des Kontextknotens; falls der Kontextknoten ein Attribut- oder Namensraum-Knoten ist, ist diese Achse leer.

  Anmerkung des Übersetzers:

• die Achse following enthält alle Knoten im gleichen Dokument wie der Kontextknoten, die nach dem Kontextknoten in Dokumentordnung auftreten, und zwar ohne seine Nachkommen und ohne Attribut- und Namensraum-Knoten.

  Anmerkung des Übersetzers:

• die Achse preceding enthält alle Knoten im gleichen Dokument wie der Kontextknoten, die vor dem Kontextknoten in Dokumentordnung auftreten, und zwar ohne seine Vorfahren und ohne Attribut- und Namensraum-Knoten.

  Anmerkung des Übersetzers:

• die Achse attribute enthält die Attribute des Kontextknotens; diese Achse ist leer, es sei denn der Kontextknoten ist ein Elementknoten.

• die Achse namespace enthält alle Namensraum-Knoten des Kontextknotens; diese Achse ist leer, es sei denn der Kontextknoten ist ein Elementknoten.

• die Achse self enthält nur den Kontextknoten selbst.

  Anmerkung des Übersetzers:

• die Achse descendant-or-self enthält den Kontextknoten sowie die Nachkommen des Kontextknotens.

  Anmerkung des Übersetzers:

• die Achse ancestor-or-self enthält den Kontextknoten sowie die Vorfahren des Kontextknotens; diese Achse enthält somit immer den Wurzelknoten.

  Anmerkung des Übersetzers:

Anmerkung: Die Achsen ancestor, descendant, following, preceding und self partitionieren ein Dokument (unter Auslassung der Attribut- und Namensraum-Knoten): sie überschneiden sich nicht und enthalten zusammen alle Knoten des Dokuments.

Anmerkung des Übersetzers:

Achsen

2.3 Knotentests

Jede Achse besitzt einen Hauptknotentyp. Falls eine Achse Elemente enthalten kann, so ist der Hauptknotentyp der Elementtyp, ansonsten ist es genau der Typ der Knoten, die die Achse enthalten kann. Das bedeutet,

• Für die Attributachse ist der Hauptknotentyp der Attributtyp.
• Für die Namensraum-Achse ist der Hauptknotentyp der Namensraum-Typ.
• Für alle anderen Achsen ist der Hauptknotentyp der Elementtyp.

Ein Knotentest, der ein QName ist, ist genau dann erfüllt, wenn der Knotentyp (siehe [5 Datenmodell]) der Hauptknotentyp ist und einen erweiterten Namen besitzt, der gleich dem erweiterten Namen des QName ist. Beispielsweise wählt child::para die para-Kindelemente des Kontextknotens aus. Falls der Kontextknoten keine para-Kinder besitzt, ist das Ergebnis eine leere Knotenmenge. attribute::href wählt die href-Attribute des Kontextknotens aus. Falls der Kontextknoten keine href-Attribute besitzt, ist das Ergebnis eine leere Knotenmenge.

Ein QName im Knotentest wird in einen erweiterten Namen unter Verwendung der Namensraum-Deklarationen aus dem Kontext des Ausdrucks expandiert. Dies geschieht in der gleichen Weise wie bei Elementnamen in Start- und End-Tags, allerdings mit der Ausnahme, dass ein mit xmlns deklarierter voreingestellter Namensraum nicht genutzt wird: d.h. enthält QName kein Präfix, so ist der Namensraum-URI leer (das ist die gleiche Regel, nach der auch Attributnamen expandiert werden). Es ist ein Fehler, wenn der QName ein Präfix enthält, für den es keine Namensraum-Deklaration im Kontext des Ausdrucks gibt.

Ein Knotentest * ist für jeden Knoten des Hauptknotentyps erfüllt. Beispielsweise wählt child::* alle Kindelemente und attribute::* alle Attributknoten des Kontextknotens aus.

Ein Knotentest kann in der Form NCName:* auftreten. In diesem Fall wird das Präfix wie bei einem QName unter Verwendung der Namensraum-Deklarationen des Kontextes expandiert. Es ist ein Fehler, wenn es für das Präfix keine Namensraum-Deklaration im Kontext des Ausdrucks gibt. Der Knotentest ist erfüllt für jeden Knoten des Hauptknotentyps, dessen erweiterter Name den Namensraum-URI besitzt, zu dem das Präfix expandiert, unabhängig vom lokalen Bestandteil des Namens.

Der Knotentest text() ist erfüllt für jeden Textknoten. Zum Beispiel wählt child::text() alle Textknoten, die Kinder des Kontextknotens sind, aus. Analog ist der Knotentest comment() erfüllt für jeden Kommentarknoten und der Knotentest processing-instruction() erfüllt für jede Processing Instruction. Dem Test processing-instruction() kann ein Literal als Argument übergeben werden. In diesem Fall ist der Test für jede Processing Instruction erfüllt, deren Name gleich dem Wert des übergebenen Literals ist.

Der Knotentest node() ist für alle Knoten jedes beliebigen Typs erfüllt.

2.4 Prädikate

Eine Achse ist entweder vorwärts- oder rückwärtsgerichtet. Eine vorwärtsgerichtete Achse enthält immer nur den Kontextknoten oder Knoten, die nach dem Kontextknoten im Dokument auftreten. Eine rückwärtsgerichtete Achse enthält immer nur den Kontextknoten oder Knoten, die vor dem Kontextknoten im Dokument auftreten. Demzufolge sind die Achsen ancestor, ancestor-or-self, preceding und preceding-sibling rückwärtsgerichtete Achsen. Alle anderen Achsen sind vorwärtsgerichtet. Da die Achse self immer höchstens einen Knoten enthält, hat es keine Bedeutung, ob sie als vorwärts- oder rückwärtsgerichtete Achse betrachtet wird. Die Näheposition eines Knotens in einer Knotenmenge bezüglich einer Achse ist definiert als die Position des Knotens in dieser Knotenmenge, welche in Dokumentordnung geordnet ist, wenn es sich um eine vorwärtsgerichtete Achse handelt, und welche in umgekehrter Dokumentordnung geordnet ist, wenn es sich um eine rückwärtsgerichtete Achse handelt. Die erste Position ist 1.

string(following::p) = string(following::p[position()=1])

string(preceding::p) = string(preceding::p[position()=last()])

Ein Prädikat filtert eine Knotenmenge bezüglich einer Achse und produziert damit eine neue Knotenmenge. Für jeden zu filternden Knoten der Knotenmenge wird der dazugehörige Ausdruck PredicateExpr berechnet, und zwar mit diesem Knoten als Kontextknoten, der Anzahl der Knoten der Knotenmenge als Kontextgröße und mit der Näheposition des Knotens in der Knotenmenge bezüglich der Achse als Kontextposition. Falls die Berechnung von PredicateExpr für diesen Knoten wahr ergibt, wird der Knoten in die Ergebnisknotenmenge aufgenommen, andernfalls nicht.

ancestor::person[position() >= 2]

child::chapter[child::title][attribute::type="warning"]

child::chapter[child::title and attribute::type="warning"]

Ein PredicateExpr wird durch Berechnung des Expr und anschließender Konvertierung des Ergebnisses in einen booleschen Wert bestimmt. Falls das Ergebnis eine Zahl war, wird es für den Fall, dass diese Zahl gleich der Kontextposition ist, in den Wert wahr konvertiert, ansonsten in den Wert falsch. Wenn das Ergebnis keine Zahl war, dann wird es so konvertiert wie bei einem Aufruf der Funktion boolean. Damit ist ein Lokalisierungspfad para[3] äquivalent zu para[position()=3].

Prädikate

2.5 Abgekürzte Syntax

Zunächst einige Beispiel für Lokalisierungspfade, die die abgekürzte Syntax benutzen:

• para wählt die para-Kindelemente des Kontextknotens aus.

• * wählt alle Kindelemente des Kontextknotens aus.

• text() wählt alle Textknoten aus, die Kinder des Kontextknotens sind.

• @name wählt das Attribut name des Kontextknotens aus.

• @* wählt alle Attribute des Kontextknotens aus.

• para[1] wählt das erste para-Kindelement des Kontextknotens aus.

• para[last()] wählt das letzte para-Kindelement des Kontextknotens aus.

• */para wählt alle para-Enkelelemente des Kontextknotens aus.

• /doc/chapter[5]/section[2] wählt das zweite section-Element des fünften chapter-Elements von doc aus.

• chapter//para wählt die para-Elemente aus, die Nachkommen der chapter-Kindelemente des Kontextknotens sind.

• //para wählt alle para-Nachkommen der Dokumentwurzel aus und somit alle para-Elemente im gleichen Dokument wie der Kontextknoten.

• //olist/item wählt alle die item-Elemente aus dem gleichen Dokument wie der Kontextknoten aus, die ein olist-Elternelement besitzen.

• . wählt den Kontextknoten aus.

• .//para wählt die para-Elemente aus, die Nachkommen des Kontextknotens sind.

• .. wählt den Elternknoten des Kontextknotens aus.

• ../@lang wählt das Attribut lang des Elternknotens des Kontextknotens aus.

• para[@type="warning"] wählt alle para-Kindelemente des Kontextknotens aus, die ein Attribut type mit dem Wert warning besitzen.

• para[@type="warning"][5] wählt das fünfte para-Kindelement des Kontextknotens aus, das ein Attribut type mit dem Wert warning besitzt.

• para[5][@type="warning"] wählt das fünfte para-Kindelement des Kontextknotens aus, falls dieses Kind ein Attribut type mit dem Wert warning besitzt.

• chapter[title="Introduction"] wählt die chapter-Kindelemente des Kontextknotens aus, die ein oder mehrere title-Kindelemente mit einem Zeichenkettenwert gleich Introduction besitzen.

• chapter[title] wählt die chapter-Kindelemente des Kontextknotens aus, die ein oder mehrere title-Kindelemente besitzen.

• employee[@secretary and @assistant] wählt alle employee-Kindelemente des Kontextknotens aus, die sowohl ein Attribut secretary als auch ein Attribut assistant besitzen.

Die wichtigste Abkürzung besteht darin, dass child:: in einem Lokalisierungsschritt weggelassen werden kann. Die Standard-Achse ist also child. So steht beispielsweise ein Lokalisierungspfad div/para abkürzend für child::div/child::para.

Für Attribute gibt es ebenfalls eine Abkürzung: attribute:: kann zu @ abgekürzt werden. Ein Lokalisierungspfad para[@type="warning"] steht beispielsweise abkürzend für child::para[attribute::type="warning"] und wählt damit para-Kindelemente mit einem Attribut type aus, dessen Wert gleich warning ist.

// ist die Abkürzung für /descendant-or-self::node()/. Zum Beispiel steht //para abkürzend für /descendant-or-self::node()/child::para und wählt damit alle para-Elemente im Dokument aus (selbst ein para-Element, das ein Dokument-Element ist, wird durch //para ausgewählt, da der Dokument-Elementknoten ein Kind des Wurzelknotens ist). div//para steht abkürzend für div/descendant-or-self::node()/child::para und wählt daher alle para-Nachfolger von div-Kindern aus.

Anmerkung: Der Lokalisierungspfad //para[1] bedeutet nicht das Gleiche wie /descendant::para[1]. Der zweite wählt das erste Nachkommen-Element para aus, der erste wählt alle para-Nachkommen aus, die das erste Kind ihrer Eltern sind.

//para[1] = /descendant-or-self::node()/para[1]
          = /descendant-or-self::node()/child::para[1]

Ein Lokalisierungsschritt . steht abkürzend für self::node(). Das ist insbesondere in Verbindung mit // nützlich. Der Lokalisierungspfad .//para steht zum Beispiel abkürzend für

self::node()/descendant-or-self::node()/child::para

und wählt daher alle para-Elemente aus, die Nachkommen des Kontextknotens sind.

Analog steht der Lokalisierungsschritt .. abkürzend für parent::node(). Zum Beispiel steht ../title abkürzend für parent::node()/child::title und wählt damit die title-Kindelemente des Elternknotens des Kontextknotens aus.

Abkürzungen

3 Ausdrücke

3.1 Grundlagen

Eine Variablenreferenz (VariableReference) ergibt den Wert, der an den Variablennamen innerhalb der Menge der Variablenbelegungen des Kontexts gebunden ist. Es ist ein Fehler, falls dem Variablennamen in der Menge der Variablenbelegungen aus dem Kontext des Ausdrucks kein Wert zugewiesen wurde.

Zum Gruppieren können runde Klammern verwendet werden.

3.2 Funktionsaufrufe

Ein Ausdruck, der ein Funktionsaufruf (FunctionCall) ist, wird ausgewertet, indem anhand des Funktionsnamens (FunctionName) die Funktion in der Funktionsbibliothek des Ausdruckskontexts bestimmt wird, jedes der Argumente (Argument) berechnet und in den von der Funktion erwarteten Typ konvertiert wird, und schließlich die Funktion mit den konvertierten Argumenten aufgerufen wird. Es ist ein Fehler, wenn eine falsche Anzahl von Argumenten übergeben wird oder eines der Argumente nicht in den geforderten Typ konvertiert werden kann. Das Ergebnis des Funktionsaufrufes (FunctionCall) ist der von der Funktion zurückgelieferte Wert.

Die Konvertierung eines Arguments in den Typ string geschieht so wie bei beim Aufruf der der Funktion string. Die Konvertierung eines Arguments in den Typ number geschieht so wie bei beim Aufruf der der Funktion number. Die Konvertierung eines Arguments in den Typ boolean geschieht so wie bei beim Aufruf der der Funktion boolean. Ein Argument, das nicht vom Typ node-set ist, kann nicht in eine Knotenmenge konvertiert werden.

3.3 Knotenmengen

Ein Lokalisierungspfad kann als Ausdruck benutzt werden. Ein solcher Ausdruck liefert die durch den Pfad ausgewählte Knotenmenge.

Der Operator | berechnet die Vereinigung seiner Operanden, welche jeweils Knotenmengen sein müssen.

$a[count(.|$b) = count($b)]

$a[count(.|$b) != count($b)]

count(.|../@*) = count(../@*)

node-set1[boolean-test] | node-set2[not(boolean-test)]

Prädikate werden zum Filtern von Ausdrücken in der gleichen Weise wie in Lokalisierungspfaden benutzt. Es ist ein Fehler, falls das Ergebnis des zu filternden Ausdrucks keine Knotenmenge ist. Das Prädikat filtert die Knotenmenge bezüglich der Kindachse.

Anmerkung: Die Bedeutung eines Prädikats hängt entscheidend davon ab, welche Achse angewendet wird. Zum Beispiel liefert preceding::foo[1] das erste foo-Element in umgekehrter Dokumentordnung, weil die für das Prädikat [1] anzuwendende Achse die Vorgängerachse (preceding) ist. Demgegenüber liefert (preceding::foo)[1] das erste foo-Element in Dokumentordnung, weil die Achse, die in diesem Fall für das Prädikat [1] gilt, die Kindachse ist.

Die Operatoren / und // verbinden einen Ausdruck und einen relativen Lokalisierungspfad. Es ist ein Fehler, wenn die Berechnung des Ausdrucks keine Knotenmenge ergibt. Der Operator / arbeitet dabei in der gleichen Weise wie in einem Lokalisierungspfad. Ebenso wie in Lokalisierungspfaden steht // abkürzend für /descendant-or-self::node()/.

Es gibt keine Objekte, die in eine Knotenmenge konvertiert werden können.

3.4 Boolesche Werte

Ein Objekt vom Typ boolean kann zwei Werte annehmen, wahr und falsch.

Die Berechnung eines or-Ausdrucks erfolgt, indem jeder der Operanden berechnet und in einen booleschen Wert wie beim Aufruf der Funktion boolean konvertiert wird. Das Ergebnis ist der Wert wahr, wenn einer der beiden Werte wahr ist und andernfalls falsch. Der rechte Operand wird nicht mehr ausgewertet, wenn der linke Operand wahr ergibt.

Die Berechnung eines and-Ausdrucks erfolgt, indem jeder der Operanden berechnet und in einen booleschen Wert wie beim Aufruf der Funktion boolean konvertiert wird. Das Ergebnis ist der Wert wahr, wenn beide Werte wahr sind und andernfalls falsch. Der rechte Operand wird nicht mehr ausgewertet, wenn der linke Operand falsch ergibt.

Die Berechnung eines EqualityExpr-Ausdrucks (der nicht allein ein RelationalExpr-Ausdruck ist) oder eines RelationalExpr-Ausdrucks (der nicht allein ein AdditiveExpr-Ausdruck ist) geschieht, indem die Objekte miteinander verglichen werden, die im Ergebnis der Auswertung der beiden Operanden entstehen. Die folgenden drei Absätze definieren den Vergleich zwischen den daraus resultierenden Objekten. Erst werden Vergleiche, die Knotenmengen betreffen, über Vergleiche definiert, die keine Knotenmengen betreffen; dies geschieht einheitlich für =, !=, <=, <, >= und >. Dann werden Vergleiche, die keine Knotenmengen betreffen, für = und != definiert. Schließlich werden Vergleiche, die keine Knotenmengen betreffen, für <=, <, >= und > definiert.

Wenn beide zu vergleichenden Objekte Knotenmengen sind, so liefert ein Vergleich genau dann den Wert wahr, wenn es einen Knoten aus der ersten Knotenmenge und einen Knoten aus der zweiten Knotenmenge gibt, sodass das Ergebnis des Vergleichs der Zeichenkettenwerte dieser beiden Knoten wahr ergibt. Wenn eines der zu vergleichenden Objekte eine Knotenmenge und das andere eine Zahl ist, dann liefert ein Vergleich genau dann den Wert wahr, wenn wenn es einen Knoten in der Knotenmenge gibt, sodass der Vergleich zwischen der Zahl und dem Ergebnis der Konvertierung des Zeichenkettenwerts dieses Knotens zu einer Zahl über die Funktion number wahr ergibt. Wenn eines der zu vergleichenden Objekte eine Knotenmenge und das andere eine Zeichenkette ist, dann liefert ein Vergleich genau dann den Wert wahr, wenn wenn es einen Knoten in der Knotenmenge gibt, sodass der Vergleich zwischen der Zeichenkette und dem Zeichenkettenwert dieses Knotens wahr ergibt. Wenn eines der zu vergleichenden Objekte eine Knotenmenge und das andere ein boolescher Wert ist, dann liefert ein Vergleich genau dann den Wert wahr, wenn wenn es einen Knoten in der Knotenmenge gibt, sodass der Vergleich zwischen dem booleschen Wert und dem Ergebnis der Konvertierung des Zeichenkettenwerts dieses Knotens zu einer Zahl über die Funktion boolean wahr ergibt.

Wenn keines der zu vergleichenden Objekte eine Knotenmenge ist und als Operator = oder != vorkommt, so werden die Objekte wie nachfolgend beschrieben in einen gemeinsamen Typ konvertiert und anschließend verglichen. Wenn wenigstens eines der zu vergleichenden Objekte ein boolescher Wert ist, so wird jedes Objekt in einen booleschen Wert wie bei der Anwendung der Funktion boolean konvertiert. Andernfalls, wenn wenigstens eines der zu vergleichenden Objekte eine Zahl ist, so wird jedes Objekt in eine Zahl wie bei der Anwendung der Funktion number konvertiert. Andernfalls werden beide Objekte in Zeichenketten wie bei der Anwendung der Funktion string konvertiert. Der Vergleich = liefert als Ergebnis genau dann den Wert wahr, wenn beide Objekte gleich sind; der Vergleich != liefert als Ergebnis genau dann den Wert wahr, wenn beide Objekte ungleich sind. Zahlen werden gemäß IEEE 754 [IEEE 754] verglichen. Zwei boolesche Werte sind gleich, wenn sie entweder beide wahr oder beide falsch sind. Zwei Zeichenketten sind genau dann gleich, wenn sie aus derselben Folge von UCS Zeichen bestehen.

Anmerkung: Wenn $x mit einer Knotenmenge belegt ist, dann bedeutet $x="foo" nicht dasselbe wie not($x!="foo"): der erste Vergleich ergibt genau dann wahr, wenn ein Knoten in $x den Zeichenkettenwert foo hat; der zweite ergibt genau dann wahr, wenn alle Knoten in $x den Zeichenkettenwert foo haben.

Wenn keines der zu vergleichenden Objekte eine Knotenmenge ist und als Operator <=, <, >= oder > vorkommt, so werden beide Objekte in Zahlen konvertiert und anschließend gemäß IEEE 754 verglichen. Der Vergleich < ergibt genau dann den Wert wahr, wenn die erste Zahl kleiner als die zweite Zahl ist. Der Vergleich <= ergibt genau dann den Wert wahr, wenn die erste Zahl kleiner oder gleich der zweiten Zahl ist. Der Vergleich > ergibt genau dann den Wert wahr, wenn die erste Zahl größer als die zweite Zahl ist. Der Vergleich >= ergibt genau dann den Wert wahr, wenn die erste Zahl größer oder gleich der zweiten Zahl ist.

$set[not(. > $set)]

$set[number()=number() and not(. > $set)]

Anmerkung: Wenn ein XPath-Ausdruck in einem XML-Dokument vorkommt, so müssen alle < und <= Operatoren gemäß den XML 1.0 Regeln geschützt werden, zum Beispiel als < und <=. Im folgenden Beispiel ist der Wert des Attributes test ein XPath-Ausdruck:

<xsl:if test="@value &lt; 10">...</xsl:if>

Anmerkung: Mit der obigen Grammatik ergibt sich folgende Vorrangfolge (kleinster Vorrang zuerst):

• or

• and

• =, !=

• <=, <, >=, >

Alle Operatoren sind links-assoziativ. Beispielsweise ist 3 > 2 > 1 äquivalent zu (3 > 2) > 1, was den Wert falsch ergibt.

Anmerkung des Übersetzers: Der Vergleich 3 > 2 ergibt zunächst den Wert wahr. Dieses Ergebnis wird aufgrund des folgenden Vergleichsoperators > in die Zahl 1 konvertiert, sodass nun 1 > 1 berechnet wird, was den Wert falsch liefert. Auf analoge Weise kann man sich überlegen, dass der Ausdruck 2 = 1 = 0 wahr, hingegen der Ausdruck 0 = 0 = 0 falsch ergibt. Hier ist Vorsicht geboten, da solche Ausdrücke gemäß der XPath-Grammatik erlaubt sind, aber nicht die Semantik besitzen, die man auf den ersten Blick erwarten würde. Sie verhalten sich allerdings genauso wie beispielsweise in den Programmiersprachen C und C++.

3.5 Zahlen

Ein Wert vom Typ number repräsentiert eine Gleitkommazahl. Eine Zahl kann jeden beliebigen, doppelt-genauen 64-Bit Wert des Formats IEEE 754 [IEEE 754] annehmen. Dies beinhaltet den speziellen Wert "Not-a-Number" (NaN), positiv und negativ unendlich, sowie positiv und negativ null. Für eine Zusammenfassung der wichtigsten Regeln des IEEE 754 Standards siehe Abschnitt 4.2.3 in [JLS].

Die numerischen Operatoren konvertieren ihre Operanden in Zahlen so wie bei einem Aufruf der Funktion number.

Der Operator + addiert.

Der Operator - subtrahiert.

Anmerkung: Da XML innerhalb von Namen das Zeichen - erlaubt, muss der Operator - typischerweise von einem Leerraumzeichen angeführt werden. Zum Beispiel ergibt foo-bar eine Knotenmenge, die die Kindelemente namens foo-bar enthält; foo - bar ergibt die Differenz aus den Werten, die durch Konvertierung des Zeichenkettenwertes des ersten foo-Kindelements in eine Zahl und durch Konvertierung des Zeichenkettenwertes des ersten bar-Kindelements in eine Zahl entstehen.

Der Operator div berechnet eine Gleitkomma-Division gemäß IEEE 754.

Der Operator mod liefert den Rest einer ganzzahligen Division. Beispiele:

• 5 mod 2 ergibt 1

• 5 mod -2 ergibt 1

• -5 mod 2 ergibt -1

• -5 mod -2 ergibt -1

Anmerkung: mod berechnet dasselbe wie der Operator % in Java und ECMAScript.

Anmerkung: Er berechnet nicht dasselbe wie die IEEE 754 Rest-Operation, welche den Rest einer gerundeten Division liefert.

Numerische Ausdrücke

3.6 Zeichenketten

Zeichenketten bestehen aus einer Folge von null oder mehr Zeichen, wobei Zeichen so wie in der XML-Empfehlung [XML] definiert sind. Ein einzelnes XPath-Zeichen entspricht damit einem einzelnen abstrakten Unicode-Zeichen mit einem einzelnen korrespondierenden skalaren Wert (siehe [Unicode]); dies unterscheidet sich allerdings von einem 16-Bit-kodierten Unicode-Zeichen: die durch Unicode definierte kodierte Zeichenrepräsentation eines abstrakten Zeichens mit einem skalaren Wert größer als U+FFFF ist ein Paar von 16-Bit Unicode-Codes (ein Surrogat-Paar). In vielen Programmiersprachen wird eine Zeichenkette als Folge von 16-Bit-kodierten Unicode-Zeichen repräsentiert; XPath-Implementationen in solchen Sprachen müssen sicherstellen, dass ein Surrogat-Paar korrekt als einzelnes XPath-Zeichen behandelt wird.

Anmerkung: In Unicode ist es möglich, dass zwei Zeichenketten als identisch anzusehen sind, obwohl sie aus unterschiedlichen Folgen abstrakter Unicode-Zeichen bestehen. Zum Beispiel können einige Akzentzeichen entweder in einer vordefinierten (precomposed) oder einer zerlegten (decomposed) Form repräsentiert werden. Damit können XPath-Ausdrücke unerwartete Resultate liefern, es sei denn, sowohl die Zeichen im XPath-Ausdruck als auch die im XML-Dokument wurden zu einer kanonischen Form normalisiert. Siehe [Character Model].

3.7 Lexikalische Struktur

Beim Zerlegen in einzelne Token wird immer das längstmögliche Token zurückgeliefert.

Zur besseren Lesbarkeit können Leerraumzeichen innerhalb von Ausdrücken verwendet werden, auch wenn es nicht explizit durch die Grammatik erlaubt wurde: ExprWhitespace kann frei innerhalb von Ausdrücken vor oder nach beliebigen ExprToken eingefügt werden.

Die folgenden speziellen Regeln für die Zerlegung in Token müssen in der angegebenen Reihenfolge angewendet werden, um die Grammatik ExprToken eindeutig zu machen:

• Wenn es ein vorhergehendes Token gibt und dieses Token kein @, ::, (, [, , oder ein Operator ist, dann muss ein * als MultiplyOperator und ein NCName als OperatorName erkannt werden.

• Falls das einem NCName folgende Zeichen (möglicherweise nach dazwischenliegendem ExprWhitespace) das Zeichen ( ist, dann muss das Token als NodeType oder als FunctionName erkannt werden.

• Falls die einem NCName folgenden beiden Zeichen (möglicherweise nach dazwischenliegendem ExprWhitespace) die Zeichen :: sind, dann muss das Token als AxisName erkannt werden.

• Andernfalls darf das Token nicht als MultiplyOperator, als OperatorName, als NodeType, als FunctionName oder als AxisName erkannt werden.

Lexikalische Struktur von Ausdrücken

4 Bibliothek der Grundfunktionen

Dieser Abschnitt beschreibt die Funktionen, die bei einer XPath-Implementation immer in der bei der Auswertung von Ausdrücken benutzten Funktionsbibliothek enthalten sein müssen.

Jede Funktion in der Funktionsbibliothek wird über einen Funktionsprototypen spezifiziert, der den Rückgabetyp, den Namen der Funktion und die Typen der Argumente angibt. Falls ein Argument von einem Fragezeichen gefolgt wird, so ist es optional; andernfalls ist es obligatorisch.

4.1 Funktionen auf Knotenmengen

Funktion: number last()

Die Funktion last liefert eine Zahl, die gleich der Kontextgröße des Kontexts des ausgewerteten Ausdrucks ist.

Funktion: number position()

Die Funktion position liefert eine Zahl, die gleich der Kontextposition im Kontext des ausgewerteten Ausdrucks ist.

Funktion: number count(node-set)

Die Funktion count liefert die Anzahl der Knoten der übergebenen Knotenmenge.

count(para[@type="warning"]/preceding-sibling::para)+1

Funktion: node-set id(object)

Die Funktion id wählt Elemente anhand ihrer eindeutigen ID aus (siehe [5.2.1 Eindeutige IDs]). Wenn als Argument eine Knotenmenge übergeben wird, so ergibt sich das Ergebnis aus der Vereinigung der Knotenmengen, die durch den Aufruf von id mit dem Zeichenkettenwert jedes Knotens aus der übergebenen Knotenmenge berechnet werden. Ist das Argument der Funktion id von einem beliebigen anderen Typ, so wird es in eine Zeichenkette wie bei einem Aufruf der Funktion string konvertiert; die Zeichenkette wird in eine durch Leerraumzeichen getrennte Liste von Token aufgeteilt (Leerraumzeichen sind beliebige Folgen von Zeichen, die auf die Produktion S passen); das Ergebnis ist eine Knotenmenge, die die Elemente aus dem Dokument des Kontextknotens enthält, die eine eindeutige ID mit dem gleichen Wert wie eines der Token der Liste besitzen.

• id("foo") wählt die Elemente mit der eindeutigen ID foo aus.

• id("foo")/child::para[position()=5] wählt das fünfte para-Kindelement des Elementes mit der eindeutigen ID foo aus.

id("foo bar baz") = id("foo") | id("bar") | id("baz")

@*[id(.) and count(id(.)|..)=1]

Funktion: string local-name(node-set?)

Die Funktion local-name liefert den lokalen Teil des erweiterten Namens des ersten Knotens in der Argumentknotenmenge bezüglich der Dokumentordnung. Falls die übergebene Knotenmenge leer ist oder der erste Knoten keinen erweiterten Namen besitzt, wird eine leere Zeichenkette zurückgegeben. Wird kein Argument übergeben, wird stattdessen eine Knotenmenge mit dem Kontextknoten als einzigem Element benutzt.

local-name(xhtml:body) = "body"
local-name(@xlink:href) = "href"
local-name(para) = "para"

Funktion: string namespace-uri(node-set?)

Die Funktion namespace-uri liefert den Namensraum-URI des erweiterten Namens des ersten Knotens in der Argumentknotenmenge bezüglich der Dokumentordnung. Falls die übergebene Knotenmenge leer ist, der erste Knoten keinen erweiterten Namen besitzt oder der Namensraum-URI des erweiterten Namens leer ist, wird eine leere Zeichenkette zurückgegeben. Wird kein Argument übergeben, wird stattdessen eine Knotenmenge mit dem Kontextknoten als einzigem Element benutzt.

Anmerkung: Die von der Funktion namespace-uri zurückgegebene Zeichenkette ist außer für Element- oder Attributknoten immer leer.

Funktion: string name(node-set?)

Die Funktion name liefert eine Zeichenkette mit einem QName, die den erweiterten Namen des ersten Knotens in der Argumentknotenmenge bezüglich der Dokumentordnung repräsentiert. Der QName muss den erweiterten Namen unter Berücksichtigung der Namensraum-Deklarationen repräsentieren, die für den Knoten gültig sind, dessen erweiterter Name repräsentiert wird. Typischerweise ist das der QName, der in der XML-Quelle vorkommt. Das muss nicht der Fall sein, wenn es für den Knoten Namensraum-Deklarationen gibt, die dem gleichen Namensraum mehrere Präfixe zuordnen. Allerdings kann eine Implementation Informationen über das Originalpräfix speichern; in diesem Fall kann die Implementation sicherstellen, dass der zurückgegebene String immer der in der XML-Quelle benutzte QName ist. Falls die übergebene Knotenmenge leer ist oder der erste Knoten keinen erweiterten Namen besitzt, wird eine leere Zeichenkette zurückgegeben. Wird kein Argument übergeben, wird stattdessen eine Knotenmenge mit dem Kontextknoten als einzigem Element benutzt.

Anmerkung: Die von der Funktion name gelieferte Zeichenkette ist die gleiche wie die von der Funktion local-name gelieferte, außer für Element- und Attributknoten.

<x:foo xmlns:x="urn:bar" xmlns:y="urn:bar" />

descendant::*[local-name()=$lname and namespace-uri()=$uri]

4.2 Zeichenkettenfunktionen

Funktion: string string(object?)

Die Funktion string konvertiert ein Objekt in eine Zeichenkette wie folgt:

• Eine Knotenmenge wird in eine Zeichenkette konvertiert, indem der Zeichenkettenwert des ersten Knotens in Dokumentordnung zurückgegeben wird. Falls die Knotenmenge leer ist, wird eine leere Zeichenkette zurückgegeben.

  Anmerkung des Übersetzers: Der Zeichenkettenwert für jeden Knotentyp wird in Kapitel [5 Datenmodell] definiert. An dieser Stelle wird bereits zusammengefasst, welchen Wert die Funktion string abhängig vom jeweiligen Knotentyp zurückgibt. string [5.1 Wurzelknoten] Zeichenkettenwert des Dokument-Elementes (des einzigen Kindes des Wurzelknotens) [5.2 Elementknoten] Verkettung der Zeichenkettenwerte aller Element- und Text-Kindknoten [5.3 Attributknoten] normalisierter Attributwert [5.4 Namensraum-Knoten] URI, d.h. Name des Namensraumes [5.5 Processing-Instruction-Knoten] Inhalt, der dem Ziel der Processing Instruction folgt [5.6 Kommentarknoten] Kommentarinhalt [5.7 Textknoten] enthaltene Zeichendaten

• Eine Zahl wird wie folgt in eine Zeichenkette konvertiert:

  • NaN (Not a Number - keine gültige Zahl) wird in die Zeichenkette NaN konvertiert.

  • Eine positive Null wird in die Zeichenkette 0 konvertiert.

  • Eine negative Null wird in die Zeichenkette 0 konvertiert.

  • Positiv unendlich wird in die Zeichenkette Infinity konvertiert.

  • Negativ unendlich wird in die Zeichenkette -Infinity konvertiert.

  • Falls die Zahl ein Integer ist, wird sie in dezimaler Form als Number dargestellt, ohne Dezimalpunkt und führende Nullen, mit negativem Vorzeichen (-), falls die Zahl negativ ist.

  • Ansonsten wird die Zahl in Dezimalform als Number dargestellt, einschließlich Dezimalpunkt, wenigstens einer Ziffer vor und nach dem Dezimalpunkt sowie einem negativen Vorzeichen (-), falls die Zahl negativ ist; es dürfen keine führende Nullen vor dem Dezimalpunkt auftreten mit Ausnahme der eventuell erforderlichen Ziffer direkt vor dem Dezimalpunkt; abgesehen von der einen erforderlichen Ziffer nach dem Dezimalpunkt müssen dort so viele, aber nicht mehr, Ziffern auftreten, wie zur eindeutigen Unterscheidung von allen anderen IEEE 754 numerischen Werten notwendig sind.

• Der boolesche Wert falsch wird in die Zeichenkette false konvertiert. Der boolesche Wert wahr wird in die Zeichenkette true konvertiert.

• Die Konvertierung eines Objekt von einem anderen Typ als den vier Grundtypen hängt von diesem Typ ab.

Wird kein Argument übergeben, wird stattdessen eine Knotenmenge mit dem Kontextknoten als einzigem Element benutzt.

Anmerkung: Die Funktion string ist nicht dafür gedacht, Zahlen in Zeichenketten zu konvertieren, die an Nutzer ausgegeben werden. Die in [XSLT] definierte Funktion format-number und das ebenso dort definierte Element xsl:number stellen diese Funktionalität bereit.

Funktion: string concat(string, string, string*)

Die Funktion concat liefert die Verkettung ihrer Argumente.

Funktion: boolean starts-with(string, string)

Die Funktion starts-with liefert den logischen Wert wahr, falls die im ersten Argument übergebene Zeichenkette mit der im zweiten Argument übergebenen Zeichenkette beginnt, und andernfalls falsch.

Funktion: boolean contains(string, string)

Die Funktion contains liefert den logischen Wert wahr, falls die im ersten Argument übergebene Zeichenkette die im zweiten Argument übergebene Zeichenkette enthält, und andernfalls falsch.

Funktion: string substring-before(string, string)

Die Funktion substring-before liefert aus der im ersten Argument übergebenen Zeichenkette die Teilzeichenkette, die vor dem ersten Auftreten der im zweiten Argument übergebenen Zeichenkette steht, bzw. die leere Zeichenkette, falls die erste Zeichenkette nicht die zweite enthält. Zum Beispiel liefert substring-before("1999/04/01","/") das Ergebnis 1999.

Funktion: string substring-after(string, string)

Die Funktion substring-after liefert aus der im ersten Argument übergebenen Zeichenkette die Teilzeichenkette, die nach dem ersten Auftreten der im zweiten Argument übergebenen Zeichenkette steht, bzw. die leere Zeichenkette, falls die erste Zeichenkette nicht die zweite enthält. Zum Beispiel liefert substring-after("1999/04/01","/") das Ergebnis 04/01 und substring-after("1999/04/01","19") liefert 99/04/01.

Funktion: string substring(string, number, number?)

Die Funktion substring liefert aus der im ersten Argument übergebenen Zeichenkette die Teilzeichenkette, die an der im zweiten Argument angebenen Position beginnt und die im dritten Argument angebenene Länge besitzt. Zum Beispiel liefert substring("12345",2,3) das Ergebnis "234". Falls kein drittes Argument angegeben wird, liefert die Funktion die Teilzeichenkette, die an der im zweiten Argument angegebenen Position beginnt und bis zum Ende der Zeichenkette reicht. Zum Beispiel liefert substring("12345",2) das Ergebnis "2345".

Genauer gesagt wird für jedes Zeichen der Zeichenkette (siehe [3.6 Zeichenketten]) eine numerische Position angenommen: die Position des ersten Zeichens ist 1, die Position des zweiten Zeichens ist 2 und so weiter.

Anmerkung: Dies unterscheidet sich von Java und ECMAScript, in denen die Methode String.substring die Position des ersten Zeichens mit 0 definiert.

Die zurückgegebene Teilzeichenkette enthält die Zeichen, deren Position größer oder gleich dem gerundeten Wert des zweiten Arguments ist und, falls ein drittes Argument übergeben wurde, kleiner als die Summe des gerundeten Wertes des zweiten und des gerundeten Wertes des dritten Arguments; Vergleich und Addition folgen den Standardregeln von IEEE 754; die Rundung erfolgt so, wie durch die Funktion round. Die folgenden Beispiele illustrieren einige unübliche Fälle:

• substring("12345", 1.5, 2.6) liefert "234"

• substring("12345", 0, 3) liefert "12"

• substring("12345", 0 div 0, 3) liefert ""

• substring("12345", 1, 0 div 0) liefert ""

• substring("12345", -42, 1 div 0) liefert "12345"

• substring("12345", -1 div 0, 1 div 0) liefert ""

substring(string, 1 div boolean-test)

concat(substring(true-string, 1 div boolean-test),
       substring(false-string, 1 div not(boolean-test)))

Funktion: number string-length(string?)

Die Funktion string-length liefert die Anzahl der Zeichen der Zeichenkette (siehe [3.6 Zeichenketten]). Falls kein Argument übergeben wurde, wird der in eine Zeichenkette konvertierte Kontextknoten angenommen, mit anderen Worten der Zeichenkettenwert des Kontextknotens.

$str2 = substring($str1, string-length($str1) - string-length($str2) + 1)

concat(substring("                                             ",
                 1, $width - string-length($eingabe)), $eingabe)

Funktion: string normalize-space(string?)

Die Funktion normalize-space liefert als Ergebnis die übergebene Zeichenkette mit normalisiertem Leerraum zurück, d.h. führender und abschließender Leerraum wird entfernt, Folgen von mehreren Leerraumzeichen werden durch ein einzelnes Leerzeichen ersetzt. Leerraumzeichen sind jene, die durch die Produktion S in XML definiert sind. Falls kein Argument übergeben wurde, wird der in eine Zeichenkette konvertierte Kontextknoten angenommen, mit anderen Worten der Zeichenkettenwert des Kontextknotens.

<name>
   Otto Normal
</name>

.="Otto Normal"

normalize-space()="Otto Normal"

.="Otto Normal" and not(preceding-sibling::name="Otto Normal")

normalize-space()="Otto Normal" and
not(normalize-space(preceding-sibling::name)="Otto Normal")

normalize-space()="Otto Normal" and
not(preceding-sibling::name[normalize-space()="Otto Normal"])

Funktion: string translate(string, string, string)

Die Funktion translate liefert als Ergebnis die im ersten Argument übergebene Zeichenkette, wobei jedes Vorkommen eines Zeichens aus der im zweiten Argument übergebenen Zeichenkette ersetzt wird durch das Zeichen an der korrespondierenden Position aus der im dritten Argument übergebenen Zeichenkette. Zum Beispiel liefert translate("bar","abc","ABC") die Zeichenkette BAr. Wenn es im zweiten Argument ein Zeichen gibt, für das kein korrespondierendes Zeichen im dritten Argument existiert (weil das zweite Argument länger ist als das dritte), so werden alle Vorkommen dieses Zeichens im ersten Argument entfernt. Zum Beispiel liefert translate("--aaa--","abc-","ABC") das Ergebnis "AAA". Falls ein Zeichen mehrmals im zweiten Argument vorkommt, bestimmt das erste Auftreten das Ersetzungszeichen. Falls die im dritten Argument übergebene Zeichenkette länger ist als die zweite, so werden überzählige Zeichen ignoriert.

Anmerkung: Die Funktion translate ist keine ausreichende Lösung für die Umwandlung zwischen Groß- und Kleinschreibung in allen Sprachen. Eine zukünftige Version von XPath kann zusätzliche Funktionen für diese Umwandlung zur Verfügung stellen.

<xsl:variable name="upper-case" 
              select="'ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜ'" />
<xsl:variable name="lower-case"
              select="'abcdefghijklmnopqrstuvwxyzäöü'" />

...
<xsl:if test="translate(firma, $lower-case, $upper-case) = 'XYZ GMBH'">
   ...
</xsl:if>

concat(substring-before($string, $from), $to,
       substring-after($string, $from))

translate($string, $allowed-char, "") = ""

4.3 Boolesche Funktionen

Funktion: boolean boolean(object)

Die Funktion boolean konvertiert ihr Argument in einen Boolean-Wert wie folgt:

• Eine Zahl ergibt den Wert wahr genau dann, wenn sie weder positiv oder negativ Null noch NaN ist.

• Eine Knotenmenge ergibt den Wert wahr genau dann, wenn sie nicht leer ist.

  Anmerkung des Übersetzers: Aus diesem Grund lässt sich ein Test auf das Vorhandensein von Knoten sehr kompakt aufschreiben: img[@alt] bedeutet dasselbe wie img[boolean(@alt)]. Gesucht ist damit ein img-Element, das ein alt-Attribut besitzt.

• Eine Zeichenkette ergibt genau dann den Wert wahr, wenn ihre Länge ungleich Null ist.

  Anmerkung des Übersetzers: Zum Vergleich mit dem letzten Beispiel: img[string(@alt)] steht abkürzend für img[boolean(string(@alt))] und bedeutet jetzt, dass ein img-Element gesucht wird, dessen alt-Attribut einen nichtleeren Zeichenkettenwert besitzt. Für <img alt="" ... /> wäre der erste Test erfüllt, der zweite jedoch nicht.

• Die Konvertierung eines Objekt von einem anderen Typ als den vier Grundtypen hängt von diesem Typ ab.

Funktion: boolean not(boolean)

Die Funktion not liefert den Wert wahr wenn ihr Argument falsch ist und ansonsten falsch.

Funktion: boolean true()

Die Funktion true liefert den Wert wahr.

Funktion: boolean false()

Die Funktion false liefert den Wert falsch.

Funktion: boolean lang(string)

Die Funktion lang liefert einen Wert wahr oder falsch in Abhängigkeit davon, ob die durch xml:lang-Attribute angegebene Sprache des Kontextknotens die gleiche oder eine Untersprache der im Argument übergegebenen Zeichenkette ist. Die Sprache des Kontextknotens wird durch den Wert des Attributes xml:lang des Kontextknotens bestimmt oder, wenn der Kontextknoten kein Attribut xml:lang besitzt, durch den Wert des Attributes xml:lang beim nächsten Vorfahren des Kontextknotens, der ein Attribut xml:lang besitzt. Wenn es kein solches Attribut gibt, liefert lang den Wert falsch. Wenn es ein solches Attribut gibt, liefert lang den Wert wahr, wenn der Attributwert gleich dem Argument ist, unabhängig von der Groß- oder Kleinschreibung, oder wenn es ein mit - beginnendes Suffix derart gibt, dass der Attributwert gleich dem Argument ohne dieses Suffix ist, unabhängig von der Groß- oder Kleinschreibung. Beispielsweise würde lang("en") den Wert wahr liefern, wenn der Kontextknoten eines dieser fünf Elemente ist:

<para xml:lang="en"/>
<div xml:lang="en"><para/></div>
<para xml:lang="EN"/>
<para xml:lang="en-us"/>

<div xml:lang="en"><sect xml:lang="de"><para/></sect></div>

4.4 Zahlenfunktionen

Funktion: number number(object?)

Die Funktion number konvertiert ihr Argument in eine Zahl wie folgt:

• Eine Zeichenkette, die aus optionalem Leerraum besteht, gefolgt von einem optionalen Minuszeichen, gefolgt von einer Number gefolgt von Leerraum, wird in eine IEEE 754 Zahl konvertiert, die (entsprechend den Rundungsregeln in IEEE 754) dem mathematischen Wert am nächsten ist, der durch die Zeichenkette repräsentiert wird. Jede andere Zeichenkette wird zu NaN konvertiert.

• Der boolesche Wert wahr wird zu 1 konvertiert; der boolesche Wert falsch wird zu 0 konvertiert.

• Eine Knotenmenge wird zunächst in eine Zeichenkette wie beim Aufruf der Funktion string konvertiert und anschließend in der gleichen Weise wie eine Zeichenkette konvertiert.

• Die Konvertierung eines Objekt von einem anderen Typ als den vier Grundtypen hängt von diesem Typ ab.

Wird kein Argument übergeben, wird stattdessen eine Knotenmenge mit dem Kontextknoten als einzigem Element benutzt.

Anmerkung: Die Funktion number sollte nicht für die Konvertierung numerischer Daten in einem Element eines XML-Dokumentes benutzt werden, es sei denn, das Element ist von einem Typ, das numerische Daten in einem sprachunabhängigen Format repräsentiert (das typischerweise für die Präsentation für einen Anwender in ein sprachspezifisches Format umgewandelt würde). Darüber hinaus kann die Funktion number nur genutzt werden wenn das von dem Element genutzte sprachunabhängige Format mit der XPath-Syntax für Number konsistent ist.

Funktion: number sum(node-set)

Die Funktion sum liefert die Summe aller in eine Zahl konvertierten Zeichenkettenwerte der Knoten aus der Argumentknotenmenge.

Funktion: number floor(number)

Die Funktion floor liefert die größte Zahl (die am nächsten an positiv unendlich liegt), die nicht größer als das Argument und ganzzahlig ist.

Funktion: number ceiling(number)

Die Funktion ceiling liefert die kleinste Zahl (die am nächsten an negativ unendlich liegt), die nicht kleiner als das Argument und ganzzahlig ist.

Funktion: number round(number)

Die Funktion round liefert die Zahl, die am nächsten am Argument liegt und die ganzzahlig ist. Wenn es zwei solche Zahlen gibt, wird die Zahl geliefert, die näher an positiv unendlich liegt. Ist das Argument NaN, wird NaN zurückgegeben. Ist das Argument positiv unendlich, wird positiv unendlich zurückgegeben. Ist das Argument negativ unendlich, wird negativ unendlich zurückgegeben. Ist das Argument positiv Null, wird positiv Null zurückgegeben. Ist das Argument negativ Null, wird negativ Null zurückgegeben. Ist das Argument kleiner als Null aber größer oder gleich -0.5, wird negativ Null zurückgegeben.

Anmerkung: In den letzten beiden Fällen ist das Ergebnis des Aufrufs der Funktion round verschieden von der Addition von 0.5 und dem Aufruf der Funktion floor.

5 Datenmodell

XPath operiert auf der Baumrepräsentation eines XML-Dokuments. Das folgende Kapitel beschreibt, wie XPath ein XML-Dokument als Baum modelliert. Dieses Modell ist rein konzeptionell und schreibt keinerlei spezielle Implementation vor. Die Beziehung zwischen diesem Modell und dem XML Information Set [XML Infoset] wird in [B Abbildung auf das XML Information Set] beschrieben.

Die durch XPath verarbeiteten XML-Dokumente müssen sich nach der XML Namensraum-Empfehlung [XML Names] richten.

Der Baum enthält Knoten. Es gibt sieben Typen von Knoten:

• Wurzelknoten

• Elementknoten

• Textknoten

• Attributknoten

• Namensraum-Knoten

• Processing-Instruction-Knoten

• Kommentarknoten

Für jeden Knotentyp gibt es einen Weg, den Zeichenkettenwert eines Knotens dieses Typs zu bestimmen. Bei einigen Knotentypen ist der Zeichenkettenwert Teil des Knotens, bei anderen Knotentypen wird der Zeichenkettenwert aus den Zeichenkettenwerten der Nachkommen berechnet.

Anmerkung: Für Element- und Wurzelknoten ist der Zeichenkettenwert eines Knotens verschieden von der Zeichenkette, die von der DOM-Methode nodeValue zurückgegeben wird (siehe [DOM]).

Einige Knotentypen besitzen außerdem einen erweiterten Namen - ein Paar bestehend aus einem lokalen Teil und einem Namensraum-URI. Der lokale Teil ist eine Zeichenkette. Der Namensraum-URI ist entweder leer oder eine Zeichenkette. Der im XML-Dokument spezifizierte Namensraum-URI kann eine URI-Referenz sein, wie sie in [RFC2396] definiert ist; das bedeutet, sie kann einen Fragment-Bezeichner besitzen und sie kann relativ sein. Ein relativer URI sollte als absoluter URI während der Namensraum-Verarbeitung aufgelöst werden: die Namensraum-URIs der erweiterten Namen von Knoten im Datenmodell sollten absolut sein. Zwei erweiterte Namen sind gleich, wenn sie den gleichen lokalen Teil haben, und wenn beide einen leeren Namensraum-URI oder beide die gleichen, nichtleeren Namensraum-URIs besitzen.

Es existiert eine Ordnung, Dokumentordnung, die für alle Knoten im Dokument definiert ist und die zu der Ordnung korrespondiert, in der die ersten Zeichen der XML-Repräsentation aller Knoten in der XML-Repräsentation des Dokumentes nach der Expandierung allgemeiner Entities stehen. Der Wurzelknoten ist demzufolge der erste Knoten. Elementknoten stehen vor ihren Kindern. Das bedeutet, die Dokumentordnung ordnet Elementknoten in der Reihenfolge ihrer Start-Tags im XML-Dokument (nach der Expandierung von Entities). Attribut- und Namensraum-Knoten eines Elementes kommen vor den Kindern des Elementes. Namensraum-Knoten erscheinen per Definition vor den Attributknoten. Die relative Ordnung innerhalb der Namensraum-Knoten ist implementationsabhängig. Die relative Ordnung innerhalb der Attributknoten ist implementationsabhängig. Die umgekehrte Dokumentordnung ist die Umkehrung der Dokumentordnung.

Wurzel- und Elementknoten besitzen eine geordnete Liste von Kindknoten. Mehrere Knoten haben niemals gemeinsame Kinder: wenn ein Knoten von einem anderen Knoten verschieden ist, dann ist kein Kindknoten des einen Knotens mit einem der Kindknoten des anderen Knotens identisch. Jeder Knoten mit Ausnahme des Wurzelknotens besitzt genau einen Elternknoten, wobei dieser entweder ein Elementknoten oder der Wurzelknoten ist. Ein Wurzel- oder ein Elementknoten ist der Elternknoten jedes seiner Kindknoten. Die Nachkommen eines Knotens sind die Kinder des Knotens sowie die Nachkommen der Kinder des Knotens.

5.1 Wurzelknoten

Der Wurzelknoten ist die Wurzel des Baumes. Ein Wurzelknoten kommt nur als Wurzel des Baumes vor. Der Elementknoten für das Dokument-Element ist ein Kind des Wurzelknotens. Der Wurzelknoten hat als Kinder ebenfalls Processing-Instruction-Knoten und Kommentarknoten für Processing Instructions und Kommentare, die im Prolog oder hinter dem Ende des Dokument-Elementes auftreten.

Der Zeichenkettenwert des Wurzelknotens ergibt sich aus der Verkettung der Zeichenkettenwerte aller Textknoten in Dokumentordnung, die Nachkommen des Wurzelknotens sind.

string(/) = string(/*)

Der Wurzelknoten hat keinen erweiterten Namen.

5.2 Elementknoten

Für jedes Element im Dokument gibt es einen Elementknoten. Ein Elementknoten besitzt einen erweiterten Namen, der sich durch Expandierung des im Tag des Elementes spezifierten QName in Übereinstimmung mit der XML-Namensraum-Empfehlung [XML Names] ergibt. Der Namensraum-URI des erweiterten Namen des Elementes ist leer, wenn der QName kein Präfix enthält und es keinen anwendbaren voreingestellten Namensraum gibt.

Anmerkung: In der im Anhang A.3 von [XML Names] verwendeten Notation entspricht der lokale Teil des erweiterten Namens dem Attribut type des Elementes ExpEType; der Namensraum-URI des erweiterten Namens entspricht dem Attribut ns des Elementes ExpEType. Letzterer ist leer, wenn das Attribut ns des Elementes ExpEType weggelassen wurde.

Die Kinder eines Elementknotens sind die enthaltenen Elementknoten, Kommentarknoten, Processing-Instruction-Knoten und Textknoten. Entity-Referenzen zu internen und externen Entities werden expandiert. Zeichenreferenzen werden aufgelöst.

Der Zeichenkettenwert eines Elementknotens ergibt sich aus der Verkettung der Zeichenkettenwerte aller Textknoten, die Nachkommen des Elementknotens in Dokumentordnung sind.

5.2.1 Eindeutige IDs

Ein Elementknoten kann einen eindeutigen Bezeichner (ID) besitzen. Dies ist der Wert des Attributes, das in der DTD mit dem Typ ID deklariert wurde. Keine zwei Elemente in einem Dokument dürfen den gleichen eindeutigen Bezeichner besitzen. Falls ein XML-Prozessor zwei Elemente in einem Dokument mit dem gleichen eindeutigen Bezeichner meldet (was nur möglich ist, wenn das Dokument ungültig ist), dann muss das zweite Element in Dokumentordnung so behandelt werden, als habe es keinen eindeutigen Bezeichner.

Anmerkung: Wenn ein Dokument keine DTD besitzt, dann hat kein Element des Dokumentes einen eindeutigen Bezeichner.

5.3 Attributknoten

Jedes Element besitzt eine mit ihm verbundene Menge von Attributknoten; das Element ist der Elternknoten jedes dieser Attributknoten. Allerdings ist ein Attributknoten kein Kind seines Elternknotens.

Anmerkung: Dies unterscheidet sich vom DOM, welches ein Element nicht als Elternknoten seiner Attribute behandelt (siehe [DOM]).

Mehrere Elemente haben niemals gemeinsame Attributknoten: wenn ein Elementknoten verschieden von einem anderen Elementknoten ist, dann ist kein Attributknoten des einen Elementknotens mit einem der Attributknoten eines anderen Elementknotens identisch.

Anmerkung: Der Operator = testet, ob zwei Knoten den gleichen Wert haben, nicht ob es dieselben Knoten sind. Vergleicht man die Attribute von zwei verschiedenen Elementen mittels =, so kann sich Gleichheit ergeben, obwohl diese nicht dieselben Knoten sind.

Ein vorgegebenes Attribut wird genauso behandelt wie ein spezifiziertes Attribut. Falls für einen Elementtyp ein Attribut in der DTD deklariert wurde, der Vorgabewert jedoch als #IMPLIED deklariert wurde und das Attribut für das Element nicht angegeben wurde, so enthält die Attributmenge des Elements keinen Knoten für dieses Attribut.

<!DOCTYPE see [
<!ELEMENT see EMPTY>
<!ATTLIST see access (public|restricted) "public"
              ref    CDATA               #IMPLIED >
]>
<see />

Einige Attribute, wie xml:lang und xml:space, besitzen die Semantik, dass sie für alle Elemente gelten, die Nachkommen des Elementes sind, das das Attribut trägt, es sei denn sie wurden in einer Instanz eines Nachkommen-Elementes durch das gleiche Attribut überschrieben. Das wirkt sich allerdings nicht darauf aus, wo Attributknoten im Baum vorkommen: ein Element besitzt nur Attributknoten für die Attribute, die explizit im Start-Tag oder Leeres-Element-Tag dieses Elements angegeben wurden, oder die in der DTD explizit mit einem Vorgabewert deklariert wurden.

Ein Attributknoten hat einen erweiterten Namen und einen Zeichenkettenwert. Der erweiterte Name wird durch Expandierung des im Tag im XML-Dokument angegebenen QName in Übereinstimmung mit der XML-Namensraum-Empfehlung [XML Names] berechnet. Der Namensraum-URI des Attributnamens ist leer, falls der QName des Attributs kein Präfix enthält.

Anmerkung: In der im Anhang A.3 von [XML Names] verwendeten Notation entspricht der lokale Teil des erweiterten Namens dem Attribut name des Elementes ExpAName; der Namensraum-URI des erweiterten Namens entspricht den Attribut ns des Elementes ExpAName. Letzterer ist leer, wenn das Attribut ns des Elementes ExpAName weggelassen wurde.

Ein Attributknoten besitzt einen Zeichenkettenwert. Dieser Zeichenkettenwert ist der durch die XML-Empfehlung [XML] spezifizierte normalisierte Wert. Ein Attribut, dessen normalisierter Wert eine Zeichenkette der Länge null ist, wird nicht gesondert behandelt: es resultiert in einem Attributknoten, dessen Zeichenkettenwert eine Zeichenkette der Länge null ist.

Anmerkung: Es ist möglich, dass Attribute mit Vorgabewerten in einer externen DTD oder einem externen Parameter-Entity deklariert werden. Die XML-Empfehlung verlangt nicht, dass ein XML-Prozessor eine externe DTD oder ein externes Parameter-Entity einliest, es sei denn dieser ist validierend. Ein Stylesheet oder ein anderes Werkzeug, das annimmt, der XPath-Baum enthalte in einer externen DTD oder einem externen Parameter-Entity deklarierte Vorgabewerte, kann möglicherweise mit nicht-validierenden XML-Prozessoren nicht funktionieren.

Es gibt keine Attributknoten zu Attributen, die Namensräume deklarieren (siehe [XML Names]).

5.4 Namensraum-Knoten

Jedem Element ist eine Menge von Namensraum-Knoten zugeordnet, einer für jedes einzelne Namensraum-Präfix, der für das Element gültig ist (einschließlich des Präfix xml, das implizit durch die XML-Namensraum-Empfehlung deklariert wird) und einer für den voreingestellten Namensraum, falls einer für das Element gültig ist. Das Element ist der Elternknoten jedes dieser Namensraum-Knoten; ein Namensraum-Knoten ist allerdings kein Kind seines Elternelementes. Mehrere Elemente haben niemals gemeinsame Namensraum-Knoten: wenn ein Elementknoten verschieden von einem anderen Elementknoten ist, dann ist kein Namensraum-Knoten des einen Elementknotens mit einem der Namensraum-Knoten eines anderen Elementknotens identisch. Das bedeutet, ein Element besitzt einen Namensraum-Knoten:

• für jedes Attribut des Elementes, dessen Name mit xmlns: beginnt;

• für jedes Attribut eines Vorfahren-Elementes, dessen Name mit xmlns: beginnt, es sei denn das Element selbst oder ein näherer Vorfahre deklariert das Prefix um;

• für ein xmlns-Attribut, falls das Element oder ein Vorfahre ein xmlns-Attribut besitzt und der Wert des xmlns-Attributs beim nächsten dieser Elemente nicht leer ist.

  Anmerkung: Ein Attribut xmlns="" "undeklariert" den voreingestellten Namensraum (siehe [XML Names]).

<foo:e1 xmlns:foo="bar"><foo:e2 /></foo:e1>

<foo:e1 xmlns:foo="bar"><foo:e2 xmlns:foo="bar" /></foo:e1>

Ein Namensraum-Knoten besitzt einen erweiterten Namen: der lokale Teil ist das Namensraum-Präfix (dieser ist leer, falls der Namensraum-Knoten den voreingestellten Namensraum repräsentiert); der Namensraum-URI ist immer leer.

Der Zeichenkettenwert eines Namensraum-Knotens ist der Namensraum-URI, der an das Namensraum-Präfix gebunden ist; wenn dieser relativ ist, muss er wie ein Namensraum-URI in einem erweiterten Namen aufgelöst werden.

string(namespace::*[name()=substring-before(../@type,':')])

namespace::*[name()='']

5.5 Processing-Instruction-Knoten

Für jede Processing Instruction gibt es einen Processing-Instruction-Knoten, mit Ausnahme der Processing Instructions, die innerhalb der Dokumenttyp-Deklaration erscheinen.

Eine Processing Instruction besitzt einen erweiterten Namen: der lokale Teil ist das Ziel der Processing Instruction; der Namensraum-URI ist leer. Der Zeichenkettenwert eines Processing-Instruction-Knotens ist der Teil der Processing Instruction, der dem Ziel und allem Leerraum folgt. Dieser beinhalt nicht das abschließende ?>.

<?xml-stylesheet href='style.xsl' title='Hauptstylesheet'?>

Anmerkung: Die XML-Deklaration ist keine Processing Instruction. Daher gibt es auch keinen Processing-Instruction-Knoten für die XML-Deklaration.

5.6 Kommentarknoten

Für jeden Kommentar gibt es einen Kommentarknoten, mit Ausnahme der Kommentare, die innerhalb der Dokumenttyp-Deklaration erscheinen.

Der Zeichenkettenwert eines Kommentarknotens ist der Inhalt des Kommentars ohne die öffnenden Zeichen <!-- und die schließenden Zeichen -->.

Ein Kommentarknoten besitzt keinen erweiterten Namen.

5.7 Textknoten

Zeichendaten werden in Textknoten zusammengefasst. Dabei werden so viele Zeichen wie möglich in jedem Textknoten zusammengefasst: ein Textknoten hat niemals als direkten Vorgänger oder Nachfolger einen anderen Textknoten. Der Zeichenkettenwert eines Textknotens besteht aus den Zeichendaten. Ein Textknoten enthält immer wenigstens ein Zeichen.

Jedes Zeichen innerhalb eines CDATA-Abschnittes wird wie Zeichendaten behandelt. So wird <![CDATA[<]]> im Quelldokument genauso behandelt wie <. Beides ergibt das einzelne Zeichen < in einem Textknoten innerhalb des Baumes. Ein CDATA-Abschnitt wird damit so behandelt, als würden <![CDATA[ und ]]> entfernt und jedes Vorkommen von < und & durch < beziehungsweise & ersetzt werden.

<x>A</x>
<x><![CDATA[A]]></x>
<x>&#65;</x>
<x>&#x0041;</x>

<para>
   Hier folgen Beispiel &amp; Erklärung:
   <![CDATA[a > 10 and a < 20]]> bedeutet ...
</para>

Anmerkung: Wird ein Textknoten, der das Zeichen < enthält, als XML ausgegeben, so muss das Zeichen < geschützt werden, beispielsweise durch < oder durch Einschluss in einen CDATA-Abschnitt.

Zeichen innerhalb von Kommentaren, Processing Instructions und Attributwerten erzeugen keine Textknoten. Zeilenenden in externen Entities werden zu #xA normalisiert, so wie in der XML-Empfehlung [XML] spezifiziert.

<name>
   <anrede>Herr</anrede> Müller-Lüdenscheidt
</name>

Ein Textknoten besitzt keinen erweiterten Namen.

6 Konformität

XPath ist in erster Linie als Komponente gedacht, die von anderen Spezifikationen genutzt werden kann. Demzufolge verlässt sich XPath auf Spezifikationen, die XPath nutzen (etwa [XPointer] und [XSLT]), Kriterien für die Konformität von XPath zu spezifizieren und definiert selbst keinerlei Konformitätskriterien für unabhängige XPath-Implementationen.

A Referenzen

A.1 Normative Referenzen

IEEE 754

Institute of Electrical and Electronics Engineers. IEEE Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Std 754-1985.

RFC2396

T. Berners-Lee, R. Fielding, and L. Masinter. Uniform Resource Identifiers (URI): Generic Syntax. IETF RFC 2396. Siehe http://www.ietf.org/rfc/rfc2396.txt.

XML

World Wide Web Consortium. Extensible Markup Language (XML) 1.0. W3C Recommendation. Siehe http://www.w3.org/TR/1998/REC-xml-19980210

XML Names

World Wide Web Consortium. Namespaces in XML. W3C Recommendation. Siehe http://www.w3.org/TR/REC-xml-names

A.2 Andere Referenzen

Character Model

World Wide Web Consortium. Character Model for the World Wide Web. W3C Working Draft. Siehe http://www.w3.org/TR/WD-charmod

DOM

World Wide Web Consortium. Document Object Model (DOM) Level 1 Specification. W3C Recommendation. Siehe http://www.w3.org/TR/REC-DOM-Level-1

JLS

J. Gosling, B. Joy, and G. Steele. The Java Language Specification. Siehe http://java.sun.com/docs/books/jls/index.html.

ISO/IEC 10646

ISO (International Organization for Standardization). ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane. International Standard. Siehe http://www.iso.ch/cate/d18741.html.

TEI

C.M. Sperberg-McQueen, L. Burnard Guidelines for Electronic Text Encoding and Interchange. Siehe http://etext.virginia.edu/TEI.html.

Unicode

Unicode Consortium. The Unicode Standard. Siehe http://www.unicode.org/unicode/standard/standard.html.

XML Infoset

World Wide Web Consortium. XML Information Set. W3C Working Draft. Siehe http://www.w3.org/TR/xml-infoset

XPointer

World Wide Web Consortium. XML Pointer Language (XPointer). W3C Working Draft. Siehe http://www.w3.org/TR/WD-xptr

XQL

J. Robie, J. Lapp, D. Schach. XML Query Language (XQL). Siehe http://www.w3.org/TandS/QL/QL98/pp/xql.html

XSLT

World Wide Web Consortium. XSL Transformations (XSLT). W3C Recommendation. Siehe http://www.w3.org/TR/xslt

B Abbildung auf das XML Information Set (nicht normativ)

Die Knoten im XPath-Datenmodell lassen sich aus den durch das XML Information Set [XML Infoset] bereitgestellten Informationseinheiten wie folgt ableiten.

Anmerkung: Eine neue Version des XML Information Set Arbeitsentwurfs, die die Version vom 17. Mai ersetzen wird, war zu der Zeit als die Vorbereitung dieser Version der XPath-Spezifikation vollendet wurde, kurz vor der Fertigstellung. Ihre Veröffentlichung wurde zur gleichen Zeit oder kurz nach Veröffentlichung dieser Version von XPath erwartet. Die Abbildung wird für diese neue Version des XML Information Set Arbeitsentwurfs angegeben. Falls die neue Version des XML Information Set Arbeitsentwurfs noch nicht veröffentlicht worden sein sollte, so können W3C-Mitglieder die interne Arbeitsgruppenversion http://www.w3.org/XML/Group/1999/09/WD-xml-infoset-19990915.html (nur für Mitglieder) einsehen.

• Der Wurzelknoten folgt aus der Dokument-Informationseinheit. Die Kinder des Wurzelknotens folgen aus den Eigenschaften children und children - comments.

  Anmerkung des Übersetzers: Die Eigenschaft children - comments gibt es nicht mehr. Stattdessen folgen mögliche Kommentar-Kindknoten des Wurzelknotens ebenfalls unmittelbar aus der Eigenschaft children.

• Ein Elementknoten folgt aus einer Element-Informationseinheit. Die Kinder eines Elementknotens folgen aus den Eigenschaften children und children - comments. Die Attribute eines Elementknotens folgen aus der Eigenschaft attributes. Die Namensräume eines Elementknotens folgen aus der Eigenschaft in-scope namespaces. Der lokale Teil des erweiterten Namens eines Elementknotens folgt aus der Eigenschaft local name. Der Namensraum-URI des erweiterten Namens eines Elementknotens folgt aus der Eigenschaft namespace URI. Der eindeutige Bezeichner (ID) eines Elementknotens folgt aus der Eigenschaft children der Attribut-Informationseinheit in der Eigenschaft attributes, deren Eigenschaft attribute type gleich ID ist.

  Anmerkung des Übersetzers: Die Eigenschaft children - comments gibt es nicht mehr. Stattdessen folgen mögliche Kommentar-Kindknoten eines Elementknotens ebenfalls unmittelbar aus der Eigenschaft children. Der Namensraum-URI des erweiterten Namens eines Elementknotens folgt aus der Eigenschaft namespace name. Der eindeutige Bezeichner (ID) eines Elementknotens folgt aus der Eigenschaft normalized value der Attribut-Informationseinheit in der Eigenschaft attributes, deren Eigenschaft attribute type gleich ID ist.

• Ein Attributknoten folgt aus einer Attribut-Informationseinheit. Der lokale Teil des erweiterten Namens des Attributknotens folgt aus der Eigenschaft local name. Der Namensraum-URI des erweiterten Namens des Attributknotens folgt aus der Eigenschaft namespace URI. Der Zeichenkettenwert des Knotens folgt aus der Verkettung aller Eigenschaften character code jedes Bestandteils der Eigenschaft children.

  Anmerkung des Übersetzers: Der Namensraum-URI des erweiterten Namens eines Attributknotens folgt aus der Eigenschaft namespace name. Der Zeichenkettenwert des Knotens folgt aus der Eigenschaft normalized value. Attributwerte werden gemäß der aktuellen Version des XML Information Set nicht weiter in einzelne Zeichen-Informationseinheiten zerlegt.

• Ein Textknoten folgt aus einer Folge einer oder mehrerer aufeinander folgender Zeichen-Informationseinheiten. Der Zeichenkettenwert des Knotens folgt aus der Verkettung der Eigenschaften character code aller Zeichen-Informationseinheiten.

• Ein Processing-Instruction-Knoten folgt aus einer Processing-Instruction-Informationseinheit. Der lokale Teil des erweiterten Namens des Knotens folgt aus der Eigenschaft target. (Der Teil Namensraum-URI des erweiterten Namens des Knotens ist leer.) Der Zeichenkettenwert des Knotens folgt aus der Eigenschaft content. Es gibt keine Processing-Instruction-Knoten für Processing-Instruction-Informationseinheiten, die Kinder der Dokumenttyp-Deklarations-Informationseinheit sind.

• Ein Kommentarknoten folgt aus einer Kommentar-Informationseinheit. Der Zeichenkettenwert des Knotens folgt aus der Eigenschaft content. Es gibt keine Kommentarknoten für Kommentar-Informationseinheiten, die Kinder der Dokumenttyp-Deklarations-Informationseinheit sind.

• Ein Namensraum-Knoten folgt aus einer Namensraum-Deklarations-Informationseinheit. Der lokale Teil des erweiterten Namens des Knotens folgt aus der Eigenschaft prefix. (Der Teil Namensraum-URI des erweiterten Namens des Knotens ist leer.) Der Zeichenkettenwert des Knotens folgt aus der Eigenschaft namespace URI.

  Anmerkung des Übersetzers: Ein Namensraum-Knoten folgt aus einer Namensraum-Informationseinheit. Der Zeichenkettenwert des Knotens folgt aus der Eigenschaft namespace name.