REC-xpath-19991116-it

REC-xpath-19991116-it

XML Path Language (XPath) 1.0


Questo documento è la traduzione in italiano della Recommendation del W3C "XML Path Language (XPath) 1.0".

Traduttore

Avvertenze

Si ricorda che la versione in lingua inglese è l'unico riferimento normativo ed è consultabile al: http://www.w3.org/TR/1999/REC-xpath-19991116.html
La traduzione in lingua italiana può essere consultata all'indirizzo: #path-19991116-it.html

Ogni errore trovato in questa traduzione può essere segnalato scrivendo a dario@xmlblog.it Si ringrazia per la collaborazione la dott.ssa Paola Carrara dell'istituto ITIM - CNR di Milano e la dott.ssa Sabrina Di Monte.

Copyright  ©  1999 W3C (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.



W3C

XML Path Language (XPath) Versione 1.0

Recommendation del W3C del 16 Novembre 1999


Questa versione:
http://www.w3.org/TR/1999/REC-xpath-19991116
(disponibile in XML o HTML)

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

Versioni precedenti:
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

Curatori:
James Clark mailto:jjc@jclark.com
Steve DeRose (Inso Corp. and Brown University) mailto:Steven_DeRose@Brown.edu

Copyright  ©  1999 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.

Riassunto

XPath è un linguaggio per l'indirizzamento di parti di un documento XML, pensato per essere utilizzato sia da XSLT che da XPointer.

Stato di questo documento

Questo documento è stato rivisto dai membri del W3C e da altri gruppi interessati ed è stato approvato dal Direttore come una Recommendation del W3C. E' un documento stabile e può essere utilizzato come materiale di riferimento o citato come norma di riferimento in altri documenti. Il ruolo del W3C è di segnalare le specifiche e di promuoverne l'impiego più ampio e diffuso. Questo incrementa la funzionalità e l'interoperabilità del Web.

La lista degli errori noti in questa specifica è disponibile al sito: http://www.w3.org/1999/11/REC-xpath-19991116-errata.

I commenti su questa specifica posso essere inviati all'indirizzo: www-xpath-comments@w3.org; sono disponibili gli archivi dei commenti.

La versione inglese di questa specifica è l'unica versione normativa. Eventualmente, per le traduzioni di questo documento, vedi il sito: http://www.w3.org/Style/XSL/translations.html.

Una lista delle Recommendation W3C e di altri documenti tecnici può essere consultata al sito: http://www.w3.org/TR.

Queste specifica è frutto del lavoro del XSL Working Group e del XML Linking Working Group ed è quindi parte del W3C Style activity e del W3C XML activity.

Indice dei contenuti

1 Introduzione
2 Percorsi di Posizionamento
    2.1 Passi di Posizionamento
    2.2 Assi
    2.3 Controlli Nodo
    2.4 Predicati
    2.5 Sintassi Abbreviata
3 Espressioni
    3.1 Fondamentali
    3.2 Chiamate di Funzione
    3.3 Insiemi Nodo
    3.4 Booleani
    3.5 Numeri
    3.6 Stringhe
    3.7 Struttura Lessicale
4 Libreria delle Funzioni Principali
    4.1 Funzioni dell'Insieme Nodo
    4.2 Funzioni Stringa
    4.3 Funzioni Booleane
    4.4 Funzioni Numeriche
5 Modello dei Dati
    5.1 Nodi Radice
    5.2 Nodi Elemento
        5.2.1 ID univoci
    5.3 Nodi Attributo
    5.4 Nodi Namespace
    5.5 Nodi Istruzioni di Processo
    5.6 Nodi Commento
    5.7 Nodi Testo
6 Conformità

Appendici

A Riferimenti
    A.1 Riferimenti Normativi
    A.2 Altri Riferimenti
B XML Information Set Mapping (Non-Normativo)

1 Introduzione

XPath è il risultato di un sforzo atto a fornire una sintassi e una semantica comune per le funzionalità che vengono condivise tra XSL Transformations [XSLT] e XPointer [XPointer]. Lo scopo primario di XPath è di indirizzare parti di un documento XML [XML]. A supporto di questa funzione, fornisce anche dei strumenti di base che facilitano la manipolazione di stringhe, numeri e booleani. XPath utilizza una sintassi compatta e non-XML per favorirne l'uso all'interno degli URI e dei valori degli attributi XML. XPath si basa sulla struttura astratta e logica di un documento XML e non sulla sua sintassi formale. XPath è così denominato dall'utilizzo della notazione di percorso come accade negli URL per la navigazione nella struttura gerarchica di un documento XML.

In aggiunta all'utilizzo per l'indirizzamento, XPath è stato pensato per fornire anche un sottoinsieme naturale che può essere utilizzato per il matching (ovvero per verificare se un nodo corrisponde o meno ad una struttura); questo utilizzo è descritto in XSLT.

XPath modella un documento XML come un albero di nodi. Esistono diverse tipologie di nodi che includono i nodi elemento, i nodi attributo e i nodi testo. XPath definisce una modalità per elaborare un string-value per ciascuna tipologia di nodo. Alcuni tipi di nodi hanno anche dei nomi. XPath supporta completamente XML Namespaces [XML Names]. Quindi, il nome di un nodo è modellato come una coppia che consiste di una parte locale e di una parte di namespaces URI che può essere nulla; questa è chiamata expanded-name. Il modello dei dati è descritto in dettaglio nel [5 Modello dei Dati].

Il construtto sintattico primario in XPath è l' espressione. Un'espressione corrisponde alla produzione Expr. Un'espressione è valutata per restituire un oggetto che appartiene a una delle quattro tipologie base:

La valutazione di un'espressione avviene rispetto ad un contesto. XSLT e XPointer specificano come il contesto sia definito per le espressioni XPath usate rispettivamente in XSLT e in XPointer. Il contesto è costituito da:

La posizione contesto è sempre inferiore o uguale alla dimensione contesto.

I legami delle variabili consistono da una mappatura che va dai nomi delle variabili ai valori delle variabili. Il valore di una variabile è un oggetto che può essere uno qualsiasi dei tipi possibili per il valore di un'espressione e può anche appartenere ad uno dei tipi addizionali che non vengono qui specificati.

La libreria di funzioni consiste in una mappatura che va dai nomi delle funzioni alle funzioni medesime. Ciascuna funzione prende zero a più argomenti e restituisce un unico risultato. Questo documento definisce una libreria di funzioni principali che tutte le implementazioni di XPath devono supportare (vedi [4 Libreria delle Funzioni Principali ]). Per una funzione nella libreria di funzioni principali, argomenti e risultato appartengono a uno dei quattro tipi base. Sia XSLT che XPointer estendono XPath definendo funzioni addizionali; alcune di queste funzioni operano su i quattro tipi base; altre operano su tipi di dati addizionali definiti da XSLT e XPointer.

Le dichiarazioni namespace consistono in una mappatura che va dai prefissi agli URI dei namespaces.

I legami delle variabili, la libreria di funzioni e le dichiarazioni namespace utilizzate per valutare una sottoespressione sono sempre gli stessi di quelli usati per valutare l'espressione che la contiene. Invece il nodo contesto, la posizione contesto e la dimensione contesto usati per valutare una sottoespressione sono talvolta differenti da quelli utilizzati per valutare l'espressione nel suo insieme. Molti tipi di espressioni cambiano il nodo contesto; solo i predicati cambiano la posizione contesto e la dimensione contesto (vedi [2.4 Predicati]). Quando viene descritta la valutazione di un tipo di espressione, sarà sempre esplicitamente dichiarato se il nodo contesto, la posizione contesto e la dimensione contesto cambiano nella valutazione delle sottoespressioni; se niente è detto sul nodo contesto, sulla posizione contesto e sulla dimensione contesto, essi non cambiano nella valutazione delle sottoespressioni di quel tipo particolare di espressione.

Espressioni di XPath compaiono spesso negli attributi XML. La grammatica specificata in questa sezione si riferisce al valore dell'attributo secondo la normativa XML 1.0. Perciò, ad esempio, se la grammatica usa il carattere <, questo non deve apparire nella sorgente XML come < ma deve essere contrassegnato secondo le regole di XML 1.0 digitandolo, ad esempio, come &lt;. All'interno delle espressioni le stringhe letterali vengono delimitate da virgolette singole o doppie che vengono anche utilizzate per delimitare gli attributi XML. Per evitare che una virgolettatura all'interno di un'espressione sia interpretata dal processore XML come la parte che delimita il valore dell'attributo, le virgolette possono essere inserite come un riferimento a carattere (&quot; o &apos;). In alternativa, l'espressione può utilizzare singole virgolette se l'attributo XML viene delimitato da doppie virgolette o viceversa.

Un'importante forma di espressione è un location path. Un location path seleziona un insieme di nodi relativi ad un context node. Il risultato che deriva dalla valutazione di un'espressione che è un location path, è il node-set ovvero l'insieme dei nodi selezionati dal location path. I location path possono contenere in modo ricorsivo espressioni che vengono utilizzate per filtrare insiemi di nodi. Una location path corrisponde alla produzione LocationPath.

Nella grammatica seguente, i non-terminali QName e NCName vengono definiti in [XML Names], e S è definito in [XML]. La grammatica utilizza la stessa notazione di EBNF come [XML] (salvo che i simboli grammaticali hanno sempre le lettere iniziali maiuscole).

Le espressioni vengono analizzate prima dividendo la stringa dei caratteri da analizzare in token e poi analizzando la sequenza risultante di token. Gli spazi bianchi possono essere utilizzati liberamente tra i token. Il processo di divisione in token è descritto nel [3.7 Struttura Lessicale].

2 Percorsi di Posizionamento

Sebbene i percorsi di posizionamento non siano il costrutto grammaticale più generale nel linguaggio (un LocationPath è un caso speciale di un Expr), sono comunque il più importante e perciò verranno descritti per primi.

Ogni location path può essere espresso utilizzando una sintassi semplice ma piuttosto prolissa. Ci sono pure un certo numero di abbreviazioni sintattiche che permettono di esprimere i casi comuni in modo conciso. Questa sezione spiegherà la semantica dei location path utilizzando la sintassi non abbreviata. La sintassi abbreviata sarà poi spiegata mostrando come si espanda nella sintassi non abbreviata (vedi [2.5 Sintassi Abbreviata]).

Qui vengono riportati alcuni esempi di location path che utilizzano la sintassi non abbreviata:

Ci sono due tipi di location path: location path relativi ed assoluti.

Un location path relativo è una sequenza di uno o più location step (passi di posizionamento) separati da una /. I passi in un location path relativo si compongono da sinistra verso destra. Ciascun passo seleziona a sua volta un'insieme di nodi relativi ad un context node. Una sequenza iniziale di passi si compone come segue: la sequenza iniziale seleziona un insieme di nodi relativi ad un context node. Ciascun nodo in quel insieme è utilizzato come un context node per il passo successivo. Gli insiemi di nodi identificati da quel passo vengono composti attraverso l'unione. L'insieme di nodi identificati dalla composizione dei passi è questa unione. Per esempio, child::div/child::para seleziona gli elementi para figli degli elementi div figli del context node, oppure, in altre parole, seleziona gli elementi para nipoti del context node che hanno come genitori un elemento div.

Un location path assoluto è costituito da una / seguita eventualmente da un location path relativo. Una singola / seleziona l'elemento radice del documento contenente il context node. Se essa è seguita da un location path relativo, allora il location path seleziona il node-set che verrebbero selezionati da un location path relativo al nodo radice del documento che contiene il context node.

Location Path
[1]    LocationPath    ::=    RelativeLocationPath
| AbsoluteLocationPath
[2]    AbsoluteLocationPath    ::=    '/' RelativeLocationPath?
| AbbreviatedAbsoluteLocationPath
[3]    RelativeLocationPath    ::=    Step
| RelativeLocationPath '/' Step
| AbbreviatedRelativeLocationPath

2.1 Passi di Posizionamento

Un passo di posizionamento (location step) si compone di tre parti:

La sintassi di un location step è determinata dal nome dell'asse e dal controllo separati da una coppia di due punti, seguiti da zero o più espressioni, ciascuna tra parentesi quadre. Ad esempio, nel child::para[position()=1], child è il nome dell'asse , para è il controllo e [position()=1] è un predicato.

L'insieme dei nodi selezionati dal location step è l'insieme dei nodi risultante dalla generazione di un insieme iniziale a partire dall'asse e dal controllo e poi filtrando quell'insieme dai nodi di volta in volta tramite ciascuno dei predicati.

L'insieme dei nodi iniziale è costituito da nodi che sono in relazione al context node come specificato dall'asse che hanno il node type e l' expanded-name specificato dal controllo. Ad esempio, un location step descendant::para seleziona gli elementi para discendenti del context node: descendant specifica che ciascun nodo nell'insieme nodo iniziale deve essere un discendente del contesto; para specifica che ciascun nodo nell'insieme deve essere un elemento di nome para. Gli assi disponibili vengono descritti in [2.2 Assi]. I controlli disponibili vengono descritti in [2.3 Controlli]. Il significato di alcuni node-test è dipendente dall'asse.

L'insieme dei nodi iniziale è filtrato dal primo predicato per generare un nuovo insieme di nodi; questo nuovo insieme è quindi filtrato usando il secondo predicato e così via di seguito. L'insieme finale è l'insieme dei nodi selezionati dal location step. L'asse influenza la valutazione dell'espressione in ciascun predicato e così la semantica di un predicato viene definita rispetto un asse. Vedi [2.4 Predicati].

Location Step
[4]    Step    ::=    AxisSpecifier NodeTest Predicate*
| AbbreviatedStep
[5]    AxisSpecifier    ::=    AxisName '::'
| AbbreviatedAxisSpecifier

2.2 Assi

Sono disponibili i seguenti assi:

NOTA: Gli assi ancestor, descendant, following, preceding e self generano una ripartizione partizione del documento (ignorando i nodi attributi e namespaces): non si sovrappongono e insieme contengono tutti i nodi del documento.
Axis
[6]    AxisName    ::=    'ancestor'
| 'ancestor-or-self'
| 'attribute'
| 'child'
| 'descendant'
| 'descendant-or-self'
| 'following'
| 'following-sibling'
| 'namespace'
| 'parent'
| 'preceding'
| 'preceding-sibling'
| 'self'

2.3 Controlli Nodo

Ogni asse ha un tipo di nodo principale (principal node type). Se un asse può contenere elementi, allora il principal node type è elemento; in caso contrario è il tipo dei nodi che l'asse può contenere. Quindi,

Un controllo che è un QName è vero se e solo se il tipo del nodo (vedi [5 Modello dei Dati]) è il principal node type e ha un expanded-name uguale all' expanded-name specificato dal QName. Ad esempio, child::para seleziona gli elementi para figli del context node; se il context node non ha figli para ,selezionerà un insieme vuoto di nodi. attribute::href seleziona l'attributo href del context node; se il context node non ha attributi href selezionerà un insieme vuoto di nodi.

Un QName nel controllo si espande in un expanded-name utilizzando le dichiarazioni namespace dal contesto d'espressione. Si usa lo stesso metodo per i nomi dei tipi d'elemento nei tag d'inizio e fine eccetto che non si utilizza la dichiarazione di default xmlns per namespace: se il QName non ha un prefisso, allora il namespace URI è nullo ( è la stessa modalità con cui si espandono i nomi d'attributo). E' un errore se il QName ha un prefisso che non corrisponde alla dichiarazione namespace nel contesto d'espressione.

Un controllo * è vero per qualsiasi nodo del principal node type. Ad esempio, child::* selezionerà tutti gli elementi figli del context node, e attribute::* selezionerà tutti gli attributi del context node.

Un controllo può avere la forma NCName:*. In questo caso, il prefisso è espanso allo stesso modo come per un QName, utilizzando le dichiarazioni del context namespace. E' un errore se nel contesto d'espressione una dichiarazione namespace compare per il prefisso. Il controllo sarà vero da ogni nodo del principal type il cui expanded-name ha il namespace URI ove si espande il prefisso, indipendentemente dalla parte locale del nome.

Il controllo text() è vero per ogni nodo testo. Ad esempio, child::text() selezionerà il nodo testo figlio del context node. Allo stesso modo, il controllo comment() è vero per ogni nodo commento, e il controllo processing-instruction() è vero per ogni istruzione di processo. I controlli processing-instruction() possono avere un argomento che è Literal; in questo caso, questo è vero per ogni istruzione di processo che ha un nome uguale al valore del Literal.

Un controllo node() è vero per ogni nodo di qualsiasi tipo.

[7]    NodeTest    ::=    NameTest
| NodeType '(' ')'
| 'processing-instruction' '(' Literal ')'

2.4 Predicati

Un asse può essere sia un asse diretto (forward axis) che un asse inverso (reverse axis). Un asse è un forward axis se contiene il context node e i nodi che lo seguono secondo l'ordine del document order . Un asse è reverse axis se contiene il context node e i nodi che lo precedono secondo l'ordine del document order. Quindi, l'ancestor, l'ancestor-or-self, il preceding, e i preceding-sibling axes sono tutti reverse axes; i rimanenti sono forward axes. Dato che il self axis contiene al massimo un nodo, può essere sia un forward che un reverse axis. La posizione relativa (o proximity position) di un membro di un insieme nodo riferito ad un asse è definita come la posizione del nodo nell'insieme nodo secondo l'ordine del documento se l'asse è un forward axis e ordinato in ordine inverso al documento se l'asse è un reverse axis. La prima posizione è 1.

Un predicato filtra un insieme nodo rispetto ad un asse per produrre un nuovo insieme. Per ciascun nodo che deve essere filtrato nell'insieme nodo, il PredicateExpr viene valutato con quel nodo come il context node, con il numero dei nodi nell'insieme nodo come il context size, e con la proximity position del nodo nell'insieme nodo riferito all'asse come il context position; se PredicateExpr risulta vera per quel nodo, il nodo viene incluso nel nuovo insieme; altrimenti, non viene incluso.

Si valuta una PredicateExpr valutando l' Expr e convertendo il risultato ad un booleano. Se il risultato è un numero, il risultato verrà convertito a vero, se il numero risultante è uguale al context position e verrà convertito a falso in caso contrario; se il risultato non è un numero, allora il risultato verrà convertito come se si chiamasse la funzione boolean. Quindi una location path para[3] è equivalente ad un para[position()=3].

Predicates
[8]    Predicate    ::=    '[' PredicateExpr ']'
[9]    PredicateExpr    ::=    Expr

2.5 Sintassi Abbreviata

Ecco alcuni esempi di location path che utilizzano la sintassi abbreviata:

La più importante abbreviazione è quella che child:: può essere omesso da un location step. In effetti, child è l'asse di default. Ad esempio, un location path div/para è un'abbreviazione per child::div/child::para.

Esiste pure un'abbreviazione per gli attributi: attribute:: può essere abbreviato a @. Ad esempio, un location path para[@type="warning"] è l'abbreviazione di child::para[attribute::type="warning"] e così selezionerà i figli para con un attributo type di valore uguale a warning.

// è l'abbreviazione di /descendant-or-self::node()/. Ad esempio, //para è l'abbreviazione di /descendant-or-self::node()/child::para e così selezionerà ogni elemento para nel documento (anche un elemento para che è un elemento documento verrà selezionato da //para per il fatto che il nodo dell'elemento documento è un figlio del nodo radice); div//para è l'abbreviazione di div/descendant-or-self::node()/child::para e così selezionerà tutti i discendenti para dei figli div.

NOTA: Il location path //para[1] non ha il medesimo significato del location path /descendant::para[1]. Questo ultimo seleziona il primo elemento discendente para ; il primo invece seleziona tutti gli elementi discendenti para che sono i primi figli para dei loro genitori.

Un location step di . è l'abbreviazione di self::node(). Questo è particolarmente utile se usato con //. Ad esempio, il location path .//para è l'abbreviazione di 

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

e così selezionerà tutti gli elementi discendenti para del context node.

In maniera simile, un location step di .. è l'abbreviazione di parent::node(). Ad esempio, ../title è l'abbreviazione di parent::node()/child::title e così selezionerà i figli title del genitore del context node.

Abbreviations
[10]    AbbreviatedAbsoluteLocationPath    ::=    '//' RelativeLocationPath
[11]    AbbreviatedRelativeLocationPath    ::=    RelativeLocationPath '//' Step
[12]    AbbreviatedStep    ::=    '.'
| '..'
[13]    AbbreviatedAxisSpecifier    ::=    '@'?

3 Espressioni

3.1 Fondamentali

Una VariableReference valuta il valore al quale il nome della variabile è legata nell'insieme dei legami di varabile nel contesto. Si commette un errore se il nome della variabile non è legato a nessun valore nell'insieme dei legami di variabile nel contesto dell'espressione.

Si possono utilizzare le parentesi per raggruppare.

[14]    Expr    ::=    OrExpr
[15]    PrimaryExpr    ::=    VariableReference
| '(' Expr ')'
| Literal
| Number
| FunctionCall

3.2 Chiamate di Funzione

Un'espressione FunctionCall viene valutata usando la FunctionName per identificare una funzione nella libreria di funzioni di contesto per la valutazione delle espressioni, valutando ciascuno degli Argument, convertendo ciascun argomento al tipo richiesto dalla funzione e richiamando la funzione stessa, passandone gli argomenti convertiti. E' un errore se è errato il numero degli argomenti oppure se un argomento non può essere convertito secondo il tipo richiesto. Il risultato di una espressione FunctionCall è il risultato restituito dalla funzione.

Si converte un argomento ad un tipo stringa desiderato chiamando la funzione string. Si converte un argomento ad un tipo numero chiamando la funzione number. Si converte un argomento ad un tipo booleano chiamando la funzione boolean. Un argomento che non è del tipo insieme nodo, non può essere convertito in un insieme nodo.

[16]    FunctionCall    ::=    FunctionName '(' ( Argument ( ',' Argument )* )? ')'
[17]    Argument    ::=    Expr

3.3 Insiemi Nodo

Un location path può essere utilizzato come un'espressione. L'espressione restituisce l'insieme dei nodi selezionati dal path.

L'operatore | calcola l'unione dei suoi operandi, che devono essere dei node-set.

I Predicates vengono usati per filtrare espressioni allo stesso modo in cui vengono utilizzati nei location path. E' un errore se l'espressione da filtrare non equivale al node-set. Il Predicate filtra il node-set rispetto ad un asse figlio.

NOTA: Il significato di un Predicate dipende fondalmentalmente dall'asse su cui viene applicato. Ad esempio, preceding::foo[1] restituisce il primo elemento foo nell' ordine inverso del documento, perché l'asse che viene applicato al predicato [1] è l'asse preceding; al contrario, (preceding::foo)[1] restituisce il primo elemento foo nel document order, perchè l'asse applicato al predicato [1] è l'asse figlio.

Gli operatori / e // compongono un'espressione e la location path relativa. E' un errore se l'espressione non viene considerata rispetto ad un node-set. L'operatore / compone allo stesso modo come nel caso / si usa in un location path. Come nei location path, // è l'abbreviazione di /descendant-or-self::node()/.

Non ci sono tipi di oggetti che possono essere convertiti ad un insieme nodo.

[18]    UnionExpr    ::=    PathExpr
| UnionExpr '|' PathExpr
[19]    PathExpr    ::=    LocationPath
| FilterExpr
| FilterExpr '/' RelativeLocationPath
| FilterExpr '//' RelativeLocationPath
[20]    FilterExpr    ::=    PrimaryExpr
| FilterExpr Predicate

3.4 Booleani

Un oggetto di tipo booleano può possedere uno dei due valori vero o falso.

Una espressione or si valuta valutando ciascun operando e convertendo il rispettivo valore ad un booleano richiamando la funzione boolean. Il risultato è vero se almeno un valore è vero, altrimenti è falso. L'operando destro non viene valutato se l'operando sinistro è vero.

Un'espressione and si valuta valutando ciascun operando e convertendo il rispettivo valore ad un booleano richiamando la funzione boolean. Il risultato è vero se entrambi i valori sono veri, altrimenti è falso. Non si valuta l'operatore destro se l'operatore sinistro è falso.

Una EqualityExpr (che non è solo una RelationalExpr) o una RelationalExpr (che non è solo una AdditiveExpr) viene valutata confrontando gli oggetti che vengono restituiti dalla valutazione dei due operandi. Il confronto degli oggetti restituiti è definito nei successivi tre paragrafi. Il primo paragrafo definisce i confronti che coinvolgono node-set in termini di confronti che non coinvolgono node-set; questo viene definito uniformente per =, !=, <=, <, >= e >. Nel secondo paragrafo i confronti che non coinvolgono node-set vengono definiti per = e !=. Nel terzo i confronti che non coinvolgono node-set vengono definiti per <=, <, >= e >.

Se tutti e due gli oggetti da comparare sono dei node-set, allora il confronto sarà vero se e solo se sono presenti e un nodo nel primo node-set e un nodo nel secondo node-set in modo che il risultato della comparazione su i string-value dei due nodi sia vero. Se un oggetto da comparare è un node-set e l'altro è un numero, allora il confronto sarà vero se e solo se è presente un nodo nel node-set tale che il risultato del confronto sul numero e sul risultato della conversione del string-value di quel nodo ad un numero utilizzando la funzione number sia vero. Se un oggetto da comparare è un node-set e l'altro è una stringa, allora il confronto sarà vero se e solo se è presente un nodo nel insieme nodo tale che il risultato della comparazione sul string-value del nodo e con l'altra stringa sia vero. Se un oggetto da comparare è un insieme nodo e l'altro è un booleano, allora il confronto sarà vero se e solo se il risultato della comparazione sul booleano e sul risultato della conversione del node-set ad un booleano usando la funzione boolean è vero.

Quando nessun oggetto da comparare è un insieme nodo e l'operatore è = o !=, allora gli oggetti vengono confrontati convertendoli ad un tipo comune come segue e poi confrontandoli. Se almeno un oggetto da comparare è un booleano, allora ciascun oggetto da confrontare viene convertito ad un booleano come se fosse applicata la funzione boolean. Altrimenti, se almeno un oggetto da comparare è un numero, allora ciascun oggetto da confrontare viene convertito ad un numero come se fosse applicata la funzione number. Altrimenti tutte e due gli oggetti da confrontare vengono convertiti a stringhe come se applicassimo la funzione string. Il confronto = sarà vero se e solo se gli oggetti sono uguali; il confronto != sarà vero se e solo se gli oggetti non sono uguali. I numeri vengono confrontati per uguaglianza secondo le IEEE 754 [IEEE 754]. Due booleani sono uguali se o entrambi sono veri o entrambi sono falsi. Due stringhe sono uguali se e solo se sono costituite dalla stessa sequenza di caratteri UCS

NOTA: Se $x è legato ad un insieme nodo, allora $x="foo" non ha il medesimo significato di not($x!="foo"): il primo è vero se e solo se qualche nodo nel $x ha la string-value foo; il secondo è vero se e solo se tutti i nodi nel $x hanno lo string-value foo.

Quando nessun oggetto da confrontare è un insieme nodo e l'operatore è <=, <, >= o >, allora gli oggetti vengono confrontati dalla conversione di entrambi gli oggetti a numeri e confrontando i numeri secondo le IEEE 754. Il confronto < sarà vero se e solo se il primo numero è minore del secondo numero. Il confronto <= sarà vero se e solo se il primo numero è minore o uguale al secondo. Il confronto > sarà vero se e solo se il primo numero è più grande del secondo. Il confronto >= sarà vero se e solo se il primo numero è più grande o eguale al secondo.

NOTA: Quando compare un'espressione XPath in un documento XML, ogni operatore < e <= deve essere codificato secondo le regole di XML 1.0 usando, ad esempio, &lt; e &lt;=. Nell'esempio seguente il valore dell'attributo test è un'espressione XPath: 
<xsl:if test="@value &lt; 10">...</xsl:if>
[21]    OrExpr    ::=    AndExpr
| OrExpr 'or' AndExpr
[22]    AndExpr    ::=    EqualityExpr
| AndExpr 'and' EqualityExpr
[23]    EqualityExpr    ::=    RelationalExpr
| EqualityExpr '=' RelationalExpr
| EqualityExpr '!=' RelationalExpr
[24]    RelationalExpr    ::=    AdditiveExpr
| RelationalExpr '<' AdditiveExpr
| RelationalExpr '>' AdditiveExpr
| RelationalExpr '<=' AdditiveExpr
| RelationalExpr '>=' AdditiveExpr
NOTA: L'effetto della grammatica di cui sopra consiste che l'ordine della priorità è (prima la più bassa priorità) e gli operatori vengono tutti lasciati come associativi a sinistra. Ad esempio, 3 > 2 > 1 è equivalente a (3 > 2) > 1, che viene considerato falso.

3.5 Numeri

Un numero rappresenta un numero a virgola mobile. Un numero può avere qualsiasi valore e doppia precisione 64-bit formato IEEE 754 [IEEE 754]. Queste specifiche includono un valore speciale "Not-a-Number" (NaN), l'infinito positivo e negativo e lo zero positivo e negativo. Vedi Section 4.2.3 del [JLS] per un riassunto delle regole chiave dello standard IEEE 754.

Gli operatori numerici convertono i rispettivi operandi in numeri come se si chiamasse la funzione number .

L'operatore + esegue l'addizione.

L'operatore - esegue la sottrazione.

NOTA: Poiché XML permette di usare - nei nomi, l'operatore - deve essere preceduto da uno spazio bianco. Ad esempio, foo-bar equivale ad un insieme nodo che contiene gli elementi figli di nome foo-bar; foo - bar equivale alla differenza del risultato di conversione ad un numero dello string-value del primo elemento figlio foo e il risultato di conversione ad un numero dello string-value del primo figlio bar.

L'operatore div realizza la divisione "floating-point" secondo le IEEE 754.

L'operatore mod restituisce il resto da una divisione di troncamento. Ad esempio,

NOTA: Accade lo stesso con l'operatore % in Java e in ECMAScript.
NOTA: Non è lo stesso con l'operazione resto IEEE 754, che restituisce il resto da una divisione arrotondata.
Numeric Expressions
[25]    AdditiveExpr    ::=    MultiplicativeExpr
| AdditiveExpr '+' MultiplicativeExpr
| AdditiveExpr '-' MultiplicativeExpr
[26]    MultiplicativeExpr    ::=    UnaryExpr
| MultiplicativeExpr MultiplyOperator UnaryExpr
| MultiplicativeExpr 'div' UnaryExpr
| MultiplicativeExpr 'mod' UnaryExpr
[27]    UnaryExpr    ::=    UnionExpr
| '-' UnaryExpr

3.6 Stringhe

Le stringhe sono costituite da una sequenza di zero o più caratteri, dove un carattere viene definito come nella raccomandazione XML [XML]. Di conseguenza un singolo carattere XPath corrisponde ad un singolo carattere astratto Unicode con un singolo valore scalare Unicode corrispondente (vedi [Unicode]); non è la stessa cosa che accade con il valore del codice 16-bit Unicode: la rappresentazione del carattere codificato Unicode per un carattere astratto con il valore scalare Unicode più grande del U+FFFF è una coppia di valori di codice 16-bit Unicode (una coppia surrogato). In molti linguaggi di programmazione, una stringa viene rappresentata da una sequenza di valori di codice 16-bit Unicode; le implementazioni di XPath in questi linguaggi devono assicurarsi che una coppia surrogato sia trattata correttamente come un singolo carattere XPath.

NOTA: E' possibile nell' Unicode che ci siano due stringhe che dovrebbero essere trattate come identiche anche se consistono di sequenze distinte di caratteri astratti Unicode . Ad esempio, alcuni caratteri accentati possono essere rappresentati sia in una forma precomposta che in una forma scomposta. Quindi le espressioni XPath possono restituire risultati inaspettati a meno che sia i caratteri nell'espressione XPath che quelli nel documento XML vengano normalizzati in una forma canonica. Vedi [Character Model].

3.7 Strutture Lessicali

Quando decomponiamo in token, si ottiene sempre il token più lungo possibile.

Per leggibilità, gli spazi bianchi possono essere utilizzati nelle espressioni anche se non vengono esplicitamente permessi dalla grammatica: ExprWhitespace possono essere liberamente aggiunte all'interno di patterns prima o dopo qualsiasi ExprToken.

Le particolari regole di divisione in token che seguono devono essere applicate nell'ordine specificato per togliere ambiguità alla grammatica ExprToken:

Expression Lexical Structure
[28]    ExprToken    ::=    '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
| NameTest
| NodeType
| Operator
| FunctionName
| AxisName
| Literal
| Number
| VariableReference
[29]    Literal    ::=    '"' [^"]* '"'
| "'" [^']* "'"
[30]    Number    ::=    Digits ('.' Digits?)?
| '.' Digits
[31]    Digits    ::=    [0-9]+
[32]    Operator    ::=    OperatorName
| MultiplyOperator
| '/' | '//' | '|' | '+' | '-' | '=' | '!=' | '<' | '<=' | '>' | '>='
[33]    OperatorName    ::=    'and' | 'or' | 'mod' | 'div'
[34]    MultiplyOperator    ::=    '*'
[35]    FunctionName    ::=    QName - NodeType
[36]    VariableReference    ::=    '$' QName
[37]    NameTest    ::=    '*'
| NCName ':' '*'
| QName
[38]    NodeType    ::=    'comment'
| 'text'
| 'processing-instruction'
| 'node'
[39]    ExprWhitespace    ::=    S

4 Libreria delle Funzioni Principali

Questa sezione descrive delle funzioni che le implementazioni XPath devono sempre includere nella libreria delle funzioni che viene utilizzata per valutare le espressioni.

Ciascuna funzione nella libreria è specificata usando un prototipo di funzione, che dà il tipo di ritorno, il nome della funzione, e il tipo degli argomenti. Se un tipo di argomento è seguito da un punto interrogativo, allora l'argomento è opzionale ; in caso contrario, è richiesto l' argomento.

4.1 Funzioni dell' Insieme Nodo

Function: number last()

La funzione last restituisce un numero uguale al context size dal contesto di valutazione dell'espressione.

Function: number position()

La funzione position restituisce un numero uguale al context position dal contesto di valutazione dell'espressione.

Function: number count(node-set)

La funzione count restituisce il numero dei nodi nell'argomento del node-set.

Function: node-set id(object)

La funzione id seleziona gli elementi secondo il loro unico ID (vedi [5.2.1 Unique IDs]). Quando l'argomento id è un node-set, il risultato è l'unione o somma del risultato derivato dall'applicazione di (o del valore) id allo string-value di ciascuno dei nodi nell'argomento del node-set. Quando l'argomento id è uno degli altri tipi , l'argomento viene convertito ad una stringa come se chiamasse la funzione string; la stringa è divisa in una lista di token separati da whitespace (è una qualsiasi sequenza di caratteri che incontrano la produzione S); il risultato è un node-set che contiene gli elementi nello stesso documento come il context node che ha un unico ID equivalente a uno qualsiasi dei token nella lista.

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

La funzione local-name restituisce la parte locale dell' expanded-name del nodo nell'argomento del node-set che è il primo nel document order. Se l'argomento del node-set è vuoto o il primo nodo non ha expanded-name, viene restituita una stringa vuota. Se l'argomento viene omesso, rimane di default il node-set con il context node come suo unico membro.

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

La funzione namespace-uri restituisce il namespace URI dell' expanded-name del nodo nell'argomento del node-set che è primo nel document order. Se l'argomento del node-set è vuoto, il primo nodo non ha nessun expanded-name, o se il namespace URI dell' expanded-name è nullo, viene restituta una stringa vuota. Se viene omesso l'argomento, rimane di default il node-set con il context node come suo unico membro.

NOTA: La stringa restituita dalla funzione namespace-uri sarà vuota eccetto per gli element-node e gli attribute-node.

Function: string name(node-set?)

La funzione name restituisce una stringa contenente un QName che rappresenta l'expanded-name del nodo nell'argomento del node-set che è primo nel document order. Il QName deve rappresentare l' expanded-name secondo le dichiarazioni namespace del nodo di cui l' expanded-name viene rappresentato. Tipicamente questo sarà il QName che compare nella sorgente XML. Questo non è il caso ove siano presenti delle dichiarazioni namespace sul nodo che associno prefissi multipli con i medesimi namespaces. Comunque, un'implementazione può includere l'informazione sul prefisso originale nella rappresentazione dei nodi; in questo caso, un'implementazione può assicurare che la stringa restituita sia sempre la stessa del QName che viene utilizzato nella sorgente XML. Se l'argomento del node-set è vuoto o il primo nodo non ha nessun expanded-name, viene restituita una stringa vuota. Se l'argomento viene omesso, rimane di default il node-set con il context node come suo unico membro.

NOTA: La stringa restituita dalla funzione name sarà la stessa della stringa restituita dalla funzione local-name eccetto per i nodi elemento e i nodi attributo.

4.2 Funzioni Stringa

Function: string string(object?)

La funzione string converte un oggetto in una stringa nel modo seguente:

Se viene omesso l'argomento, rimane di default il node-set con il context node come suo unico membro.

NOTA: La funzione string non è concepita per convertire i numeri in stringhe per la presentazione ad utenti. La funzione format-number e l'elemento xsl:number nel [XSLT] forniscono questa funzionalità.

Function: string concat(string, string, string*)

La funzione concat restituisce la concatenazione dei suoi argomenti.

Function: boolean starts-with(string, string)

La funzione starts-with restituisce vero se il primo argomento stringa inizia con un secondo argomento stringa, altrimenti restituisce falso.

Function: boolean contains(string, string)

La funzione contains restituisce vero se il primo argomento stringa contiene il secondo argomento stringa, altrimenti restituisce falso.

Function: string substring-before(string, string)

La funzione substring-before restituisce le sottostringhe del primo argomento stringa che precede la prima comparsa del secondo argomento nel primo argomento stringa, oppure la stringa vuota se il primo argomento stringa non contiene il secondo argomento stringa. Ad esempio, substring-before("1999/04/01","/") restituisce 1999.

Function: string substring-after(string, string)

La funzione substring-after restituisce la sottostringa del primo argomento stringa che segue la prima comparsa del secondo argomento stringa nel primo argomento stringa, oppure la stringa vuota se il primo argomento stringa non contiene il secondo argomento stringa. Ad esempio, substring-after("1999/04/01","/") restituisce 04/01, e substring-after("1999/04/01","19") restituisce 99/04/01.

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

La funzione substring restituisce la sottostringa del primo argomento partendo dalla posizione specificata nel secondo argomento con lunghezza specificata nel terzo argomento. Ad esempio,substring("12345",2,3) restituisce "234".Se il terzo argomento non viene specificato, restituisce la sottostringa partendo dalla posizione specificata nel secondo argomento continuando fino alla fine della stringa. Ad esempio, substring("12345",2) restituisce "2345".

Più precisamente si considera che ciascun carattere nella stringa (vedi [3.6 Stringhe]) abbia una posizione numerica: la posizione del primo carattere è 1, la posizione del secondo carattere è 2 e così via.

NOTA: Questo differisce da Java e ECMAScript, nel quale il metodo String.substring considera la posizione del primo carattere come 0.

La sottostringa restituita contiene quei caratteri per i quali la posizione del carattere è maggiore o uguale al valore arrotondato del secondo argomento e minore della somma tra il valore arrotondato del secondo argomento e il valore arrotondato del terzo argomento, se viene specificato il terzo argomento: i confronti e l'addizione utilizzati qui sopra seguono le regole dello standard IEEE 754 ; l'arrotondamento viene eseguito utilizzando la funzione round. Gli esempi seguenti illustrano alcuni casi poco frequenti:

Function: number string-length(string?)

La funzione string-length restituisce il numero dei caratteri nella stringa (vedi [3.6 Stringhe]). Se l'argomento viene omesso, rimane di default il context node convertito ad una stringa, in altre parole il string-value del context node.

Function: string normalize-space(string?)

La funzione normalize-space restituisce l'argomento stringa togliendo gli spazi bianchi all'inizio e alla fine e rimpiazzando sequenze di caratteri bianchi con un singolo spazio. I caratteri spazi bianchi sono i medesimi che compaiono nella produzione S in XML. Se l'argomento viene omesso, rimane di default il context node convertito in una stringa, in altre parole la string-value del context node.

Function: string translate(string, string, string)

La funzione translate restituisce il primo argomento stringa con le ricorrenze dei caratteri della stringa del secondo argomento rimpiazzate dal carattere che si trova nella stringa del terzo argomento alla posizione corrispondente. Ad esempio, translate("bar","abc","ABC") restituisce la stringa BAr. Se è presente un carattere nella stringa del secondo argomento con nessun carattere nella posizione corrispondente nella stringa del terzo argomento (perché la stringa del secondo argomento è più lunga della stringa del terzo), allora le occorrenze di quel carattere nella stringa del primo argomento vengono rimosse. Ad esempio, translate("--aaa--","abc-","ABC") restituisce "AAA". Se un carattere occorre più di una volta nella stringa del secondo argomento, allora la prima occorrenza determina il carattere di sostituzione. Se la stringa del terzo argomento é più lunga della stringa del secondo, allora vengono ignorati i caratteri in eccesso.

NOTA: La funzione translate non è una soluzione sufficiente per la conversione maiuscolo-minuscolo in tutte le lingue. Una versione futura di XPath potrà fornire funzionalità aggiuntive per questo caso.

4.3 Funzioni Booleane

Function: boolean boolean(object)

La funzione boolean converte il suo argomento in un booleano come segue:

Function: boolean not(boolean)

La funzione not restituisce vero se il suo argomento è falso, e falso in caso contrario.

Function: boolean true()

La funzione true restituisce vero.

Function: boolean false()

La funzione false restituisce falso.

Function: boolean lang(string)

La funzione lang restituisce vero o falso a seconda che il linguaggio del context node come specificato da gli attributi xml:lang, sia lo stesso oppure sia un sottolinguaggio del linguaggio specificato dall'argomento stringa. Il linguaggio del context node viene determinato dal valore dell'attributo xml:lang del context node, oppure, se il context node non ha attributo xml:lang , dal valore dell'attributo xml:lang dell'antenato più vicino del context node che ha un attributo xml:lang. Se non esiste tale attributo, allora lang restituisce falso. Se esiste tale attributo, allora lang restituisce vero se il valore dell'attributo è uguale all'argomento ignorando la trasformazione maiuscolo-minuscolo, oppure se esiste un suffisso che inizia con - tale che il valore dell'attributo sia uguale all'argomento ignorando il suffisso del valore dell'attributo e della trasformazione maiuscolo-minuscolo. lang("en") restituirebbe vero se il context node fosse qualsiasi di questi cinque elementi:

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

4.4 Funzioni Numeriche

Function: number number(object?)

La funzione number converte il suo argomento in un numero come segue:

Se l'argomento viene omesso, è di default l'insieme nodo con il context node come suo unico membro.

NOTA: Non si dovrebbe utilizzare la funzione number per la conversione di dati numerici che compaiono in un elemento all'interno di un documento XML a meno che l'elemento non sia del tipo che rappresenta dati numerici in un formato language-neutral (che verrebbe solitamente transformato in un formato di linguaggio specifico per la rappresentazione ad un utente). Inoltre la funzione number non può essere utilizzata a meno che il formato indipendente dal linguaggio usato dall'elemento segua la sintassi XPath per un Number.

Function: number sum(node-set)

La funzione sum restituisce la somma, per ciascun nodo nell' argomento dell' insieme nodo, del risultato della conversione del string-value del nodo in un numero.

Function:number floor(number)

La funzione floor restituisce il numero più alto (il più vicino all'infinito positivo) che non sia maggiore dell'argomento e che sia un intero.

Function: number ceiling(number)

La funzione ceiling restituisce il numero più basso (il più vicino ad un infinito negativo) che non sia minore dell'argomento e che sia un intero.

Function: number round(number)

La funzione round restituisce il numero che è più vicino all'argomento e che è intero. Se esistono due numeri di questo tipo, allora viene restituito quello che più vicino all'infinito positivo. Se l'argomento è NaN, allora viene restituito NaN. Se l'argomento è infinito positivo, allora viene restituito infinito positivo. Se l'argomento è infinito negativo, allora viene restituito infinito negativo. Se l'argomento è zero positivo, allora viene restituito zero positivo. Se l'argomento è zero negativo, allora viene restituito zero negativo. Se l'argomento è minore di zero, ma maggiore o uguale a -0.5, allora viene restituito zero negativo.

NOTA: Per questi due ultimi casi, il risultato della chiamata della funzione round non è lo stesso del risultato che deriva dall'addizionare 0.5 per poi utilizzare la funzione floor.

5 Modello dei Dati

Questa sezione descrive come XPath opera su un documento XML come un albero. Questo modello è solo concettuale e non demanda a nessuna particolare implementazione. La relazione di questo modello con XML Information Set [XML Infoset] viene descritta nel [B XML Information Set Mapping].

I documenti XML elaborati da XPath devono essere conformi alle XML Namespaces Recommendation [XML Names].

L'albero contiene dei nodi. Esistono sette tipologie di nodi:

Per ciascun tipo di nodo, c'è il modo di determinare un string-value per un nodo di quel tipo. Per alcuni tipi di nodo, lo string-value è parte del nodo; per gli altri tipi, lo string-value è calcolato dallo string-value dei nodi discendenti.

NOTA: Per i nodi elemento e i nodi radice, il string-value di un nodo non è lo stesso della stringa che viene restituita dal metodo DOM nodeValue (vedi [DOM]).

Alcuni tipi di nodi hanno anche un expanded-name, che è una coppia costituita da una parte locale e da un namespace URI. La parte locale è una stringa. Il namespace URI può essere sia nullo sia una stringa. Il namespace URI specificato nel documento XML può essere un riferimento URI come viene definito nel [RFC2396]; questo sta a significare che può avere un identificatore di frammenti e che può essere relativo. Un URI relativo dovrebbe essere risolto in un URI assoluto durante l'elaborazione namespace: i namespace URI dell' expanded-name dei nodi nel data model dovrebbero essere assoluti. Due expanded-name sono uguali se hanno la stessa parte locale e se hanno entrambi un namespace URI nullo o un uguale namespace URI non nullo.

Esiste un ordinamento, il document order, definito da tutti i nodi nel documento come corrispondente all'ordine nel quale il primo carattere della rappresentazione XML di ciascun nodo compare dopo l'espansione delle entità generali. Quindi, il nodo radice sarà il primo nodo. I nodi elemento compariranno prima dei rispettivi figli. Quindi, il document order ordina i nodi elemento secondo l'ordine delle riccorrenze dei loro tag d'inizio nel XML (dopo l'espansione delle entità). I nodi attributo e i nodi namespace di un elemento compaiono prima dei figli dell'elemento. I nodi namespace vengono definiti per apparire prima dei nodi attributo. L'ordine relativo dei nodi namespace dipende dall'implementazione. L'ordine relativo dei nodi attributo dipende dall'implementazione. Il Reverse document order è il contrario del document order .

I nodi radice e i nodi elemento hanno una lista ordinata di nodi figli. I nodi non hanno mai in condivisione figli: se un nodo è diverso da un altro, nessuno dei figli dell'uno sarà uguale ad alcuno dei figli dell'altro. Ciascun nodo diverso dall'elemento radice ha esattamente un parent, che è o nodo elemento o nodo radice. Un nodo radice o un nodo elemento è il genitore di ciascuno dei suoi nodi figlio. I descendants di un nodo sono i figli del nodo e i discendenti dei figli del nodo.

5.1 Nodo Radice

Il nodo radice è la radice dell'albero. Un nodo radice non compare eccetto che come radice dell'albero. Il nodo elemento per l'elemento documento è un figlio del nodo radice. Il nodo radice ha anche come figli delle istruzioni di processo e dei nodi commento per istruzioni di processo e commenti che occorrono nel prologo e dopo la fine dell'elemento documento.

Il string-value del nodo radice è la concatenazione del string-value di tutti i nodi testo descendants del nodo radice nell'ordine del documento.

Il nodo radice non ha un expanded-name.

5.2 Nodi Elemento

Esiste un nodo elemento per ciascun elemento del documento. Un nodo elemento ha un expanded-name valutato espandendo il QName dell' elemento specificato nel tag secondo le XML Namespaces Recommendation [XML Names]. Il namespace URI dell' expanded-name degli elementi saranno nulli se il QName non ha prefisso e non esistono namespace di default applicabili.

NOTA: Nell' annotazione dell'Appendice A.3 del [XML Names], la parte locale dell'expanded-name corrisponde all'attributo type dell'elemento ExpEType ; il namespace URI dell' expanded-name corrisponde all'attributo ns dell'elemento ExpEType , ed è nullo se viene omesso l'attributo ns dell'elemento ExpEType .

I figli di un nodo elemento sono i nodi elemento, i nodi commento, i nodi processo di elaborazione ed i nodi testo del rispettivo contenuto. I riferimenti ad entità vengono espansi sia alle entità interne che esterne. I riferimenti a caratteri vengono risolti.

Il string-value di un nodo elemento è la concatenazione del string-value di tutti i nodi testodescendants del nodo elemento nell'ordine del documento.

5.2.1 ID Univoci

Un nodo elemento può avere un unico identificatore (ID). Questo è il valore dell'attributo che è dichiarato nella DTD come tipo ID. Due elementi non possono avere in un documento lo stesso unico ID. Se un processore XML elabora due elementi in un documento con il medesimo unico ID (che è possibile solo se il documento non è valido) allora il secondo elemento nell'ordine del documento dovrà essere trattato come se non avesse un unico ID.

NOTA: Se un documento non ha un DTD, allora nessun elemento nel documento avrà un unico ID.

5.3 Nodi Attributo

Ciascun nodo elemento ha un insieme associato di nodi attributo; l'elemento è il parent di ciascuno di questi nodi attributo; tuttavia, un nodo attributo non è figlio del suo elemento genitore.

NOTA: Questo differisce dal DOM, che non considera l'elemento che porta un attributo come il genitore dell' attributo (vedi [DOM]).

Gli elementi non condividono mai i nodi attributo: se due nodi elemento sono diversi, allora nessuno dei nodi attributo di uno sarà lo stesso nodo attributo dell'altro.

NOTA: L'operatore = verifica se due nodi hanno lo stesso valore non se sono lo stesso nodo. Quindi gli attributi di due elementi diversi possono essere considerati come uguali usando =, anche se non appartengono allo stesso nodo.

Un attributo di default viene trattato allo stesso modo di un attributo specificato. Se si dichiara un attributo per il tipo elemento nel DTD, ma il valore di default viene dichiarato come #IMPLIED, e non si specifica l'attributo dell' elemento, allora l'insieme attributo dell'elemento non contiene un nodo per l'attributo.

Alcuni attributi, come xml:lang e xml:space, hanno la semantica che applicano a tutti gli elementi discendenti dell'elemento che porta l' attributo, a meno che non sia sovrapposto da una istanza del medesimo attributo su un altro elemento discendente. Tuttavia, questo non influisce ove i nodi attributo compaiono in un albero: un elemento ha dei nodi attributo solo per gli attributi che sono stati esplicitamente specificati nel tag d'inizio o nel tag dell'elemento vuoto di quell'elemento o che sono stati esplicitamente dichiarati nel DTD con un valore di default.

Un nodo attributo ha un expanded-name e un string-value. L' expanded-name viene calcolato espandendo QName specificato nel tag nel documento XML secondo le specifiche XML Namespaces [XML Names]. Il namespace URI del nome dell'attributo sarà nullo se il QName dell'attributo non ha prefisso.

NOTA: Nella notazione dell'Appendice A.3 di [XML Names], la parte locale dell'expanded-name corrisponde all'attributo name dell'elemento ExpAName ; il namespace URI dell'expanded-name corrisponde all'attributo ns dell'elemento ExpAName , ed è nullo se viene omesso l'attributo ns dell'elemento ExpAName .

Un nodo attributo ha un string-value. Il string-value è il valore normalizzato come specificato dalle Recommandation XML [XML]. Un attributo, il cui valore normalizzato é una stringa di lunghezza zero, non è trattato in modo speciale: si risolve in un nodo attributo il cui attributo string-value è una stringa di lunghezza zero.

NOTA: E' possibile che gli attributi di default vengano dichiarati in in una DTD esterna o in una entità parametrica esterna. Le Recommandation XML non richiedono un processore XML per leggere una DTD esterna o un parametro esterno a meno che non sia validante. Un foglio di stile o un'altra facilitazione che assuma che l'albero XPath contenga i valori degli attributi di default dichiarati in un DTD esterno o in una entità parametrica non può lavorare con alcuni processori XML non validanti .

Non esistono nodi attributo che corrispondono ad attributi che dichiarano namespaces ( vedi [XML Names]).

5.4 Nodi Namespace

Ciascun elemento ha un insieme associato di nodi namespace, uno per ciascun prefisso distinto namespace, che è finalizzato all'elemento (includendo il prefisso xml , che è implicitamente dichiarato dalle Recommandation XML Namespaces [XML Names]) e uno per il namespace di default se è finalizzato all'elemento. L'elemento è il parent di ciascuno di questi nodi namespace; tuttavia, un nodo namespace non è un figlio del suo elemento genitore. Gli elementi non condividono mai i nodi namespace: se il nodo elemento uno non è lo stesso nodo come un altro nodo elemento, allora nessuno dei nodi namespace del nodo elemento uno sarà lo stesso nodo come il nodo namespaces di un altro nodo elemento. Questo significa che un elemento avrà un nodo namespace:

Un nodo namespace ha un expanded-name: la parte locale è il prefisso namespace (questo è vuoto se il nodo namespace è il default namespace); il namespace URI è sempre nullo.

Il string-value di un nodo namespace è il namespace URI che è legato al prefisso namespace; se è relativo, deve essere risolto proprio come un namespace URI in un expanded-name.

5.5 Nodi Istruzioni di Processo

Esiste un nodo istruzioni di processo per ogni istruzioni di processo, ad eccezione di ogni istruzione di processo che compaia all'interno della document type declaration.

Una istruzione di processo ha un expanded-name: la parte locale è la finalità della istruzione di processo; il namespace URI è nullo. Il string-value di un nodo istruzione di processo è la parte della istruzione di processo che segue la finalità e ogni spazio bianco. Non include il?>.

NOTA: La dichiarazione XML non è una istruzione di processo. Perciò non esiste un nodo istruzione di processo che corrisponda alla dichiarazione XML.

5.6 Nodi Commento

Esiste un nodo commento per ciascun commento, ad eccezione di ogni commento che compaia all'interno del document type declaration.

Il string-value del commento è il contenuto del commento che non include in apertura <!-- o in chiusura -->.

Un nodo commento non ha un expanded-name.

5.7 Nodi Testo

Character data vengono raggruppati in nodi testo. I character data vengono raggruppati il più possibile in nel nodo testo: un nodo testo non ha mai un un nodo testo fratello che lo segua o lo preceda immediatamente. Il string-value di un nodo testo è il character data. Un nodo testo ha sempre almeno un character data.

Ciascun carattere all'interno di una sezione CDATA viene trattato come character data. Quindi, <![CDATA[<]]> nella sorgente documento verrà trattata allo stesso modo di &lt;. Entrambi compariranno in un singolo carattere< in un nodo testo nell'albero. Quindi, una sezione CDATA viene trattata come se venissero rimossi il <![CDATA[ e il ]]> e ogni riccorrenza di < e & venissero rimpiazzati rispettivamente da &lt; e &amp; .

NOTA: Quando un nodo testo che contiene un carattere < viene evidenziato come XML, il carattere < viene aggirato usando, ad esempio, &lt;, o includendolo in una sezione CDATA.

I Caratteri all'interno dei commenti, delle istruzioni di processo e dei valori degli attributi non producono dei nodi testo. Line-endings nelle entità esterne vengono normalizzati a #xA come specificato nella Recommandation XML [XML].

Un nodo testo non ha un expanded-name.

6 Conformità

XPath viene concepito in prima istanza come un componente che può essere utilizzato per altre specifiche. Quindi, XPath si basa su specifiche che usano XPath (come [XPointer] e [XSLT]) per chiarire criteri di conformità delle implementazioni di XPath e non definisce nessun criterio di conformità per le implementazioni independenti da XPath.

A Riferimenti

A.1 Riferimenti Normativi

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. Vedi http://www.ietf.org/rfc/rfc2396.txt.
XML
World Wide Web Consortium. Extensible Markup Language (XML) 1.0. W3C Recommendation. Vedi http://www.w3.org/TR/1998/REC-xml-19980210
XML Names
World Wide Web Consortium. Namespaces in XML. W3C Recommendation. Vedi http://www.w3.org/TR/REC-xml-names

A.2 Altri Riferimenti

Character Model
World Wide Web Consortium. Character Model for the World Wide Web. W3C Working Draft. Vedi http://www.w3.org/TR/WD-charmod
DOM
World Wide Web Consortium. Document Object Model (DOM) Level 1 Specification. W3C Recommendation. Vedi http://www.w3.org/TR/REC-DOM-Level-1
JLS
J. Gosling, B. Joy, and G. Steele. The Java Language Specification. Vedi 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. Vedi http://www.iso.ch/cate/d18741.html.
TEI
C.M. Sperberg-McQueen, L. Burnard Guidelines for Electronic Text Encoding and Interchange. Vedi http://etext.virginia.edu/TEI.html.
Unicode
Unicode Consortium. The Unicode Standard. Vedi http://www.unicode.org/unicode/standard/standard.html.
XML Infoset
World Wide Web Consortium. XML Information Set. W3C Working Draft. Vedi http://www.w3.org/TR/xml-infoset
XPointer
World Wide Web Consortium. XML Pointer Language (XPointer). W3C Working Draft. Vedi http://www.w3.org/TR/WD-xptr
XQL
J. Robie, J. Lapp, D. Schach. XML Query Language (XQL). Vedi http://www.w3.org/TandS/QL/QL98/pp/xql.html
XSLT
World Wide Web Consortium. XSL Transformations (XSLT). W3C Recommendation. Vedi http://www.w3.org/TR/xslt

B XML Information Set Mapping (Non-Normativo)

I nodi nel modello dei dati di XPath possono provenire da information items forniti dal XML Information Set [XML Infoset] come segue:

NOTA: Una nuova versione del XML Information Set Working Draft, che sostituirà la versione del 17 Maggio, era in fase di completamento nel periodo in cui fu finita la preparazione di questa versione di XPath. Si attendeva che venisse pubblicata nello stesso periodo o poco dopo la pubblicazione di questa versione di XPath. E' disponibile la mappatura di questa nuova versione del XML Information Set Working Draft e nel caso che la nuova versione di XML Information Set Working non sia stata ancora pubblicata, i membri del W3C possono consultare la versione interna del Working Group http://www.w3.org/XML/Group/1999/09/WD-xml-infoset-19990915.html (members only).