Provided by:
manpages-it_0.3.4-5_all 
NOME
regex - POSIX 1003.2: espressioni regolari
DESCRIZIONE
Le espressioni regolari (ER, «regular expression»), così come definite
da POSIX 1003.2, appaiono in due forme: ER moderne
(approssimativamente, quelle di egrep; 1003.2 le definisce ER «estese»)
e ER obsolete (approssimativamente, quelle di ed; ER «di base» in
1003.2). Le ER obsolete esistono per compatibilità con alcuni vecchi
programmi, e verranno discusse alla fine. 1003.2 lascia aperti alcuni
aspetti della sintassi o della semantica delle ER: ‘†’ denota scelte
che potrebbero non essere completamente portabili ad altre
implementazioni di 1003.2.
Una ER moderna è una†diramazione o più diramazioni non vuote†,
separate da ‘|’: l’ER corrisponde a qualsiasi cosa che corrisponda ad
una delle diramazioni.
Una diramazione è formata da uno†o più pezzi concatenati. Corrisponde
ad una corrispondenza per il primo pezzo, seguita da una corrispondenza
per il secondo, ecc.
Un pezzo è formato da un atomo, eventualmente seguito da un singoloâ€
‘*’, ‘+’, ‘?’ o limite. Un atomo seguito da ‘*’ corrisponde ad una
successione di 0 o più corrispondenze dell’atomo. Un atomo seguito da
‘+’ corrisponde ad una successione di 1 o più corrispondenze
dell’atomo. Un atomo seguito da ‘?’ corrisponde ad una successione di
0 o 1 corrispondenza dell’atomo.
Un limite («bound») [NdT: il termine è non-standard, Regular
Expressions di Jeffrey E F Friedl, O’Reilly, 1997, usa intervallo] è
formato da ‘{’ seguito da un intero decimale senza segno, eventualmente
seguito da ‘,’ eventualmente seguito da un altro intero decimale senza
segno, obbligatoriamente seguito da ‘}’. Gli interi devono essere
compresi fra 0 e ER_DUP_MAX (255†) inclusi, e se ce ne sono due, il
primo non deve essere maggiore del secondo. Un atomo seguito da un
limite contenente un intero i e nessuna virgola corrisponde ad una
successione di esattamente i corrispondenze dell’atomo. Un atomo
seguito da un limite contenente un intero i e una virgola corrisponde
ad una successione di i o più corrispondenze dell’atomo. Un atomo
seguito da un limite contenente due interi i e j corrisponde ad una
successione di i fino a j (inclusi) corrispondenze dell’atomo.
Un atomo è formato da un’ER racchiusa fra ‘()’ (corrispondente ad una
corrispondenza per l’ER), un insieme vuoto di ‘()’ (corrispondente alla
stringa nulla)†, un’espressione parentetica (vedi sotto), ‘.’
(corrispondente ad un qualsiasi carattere singolo), ‘^’ (corrispondente
alla stringa nulla a inizio riga), ‘$’ (corrispondente alla stringa
nulla a fine riga), una ‘\’ seguita da uno dei caratteri ‘^.[$()|*+?{\’
(corrispondente a quel carattere interpretato come un carattere
normale), una ‘\’ seguita da un qualsiasi altro carattereâ€
(corrispondente a quel carattere interpretato come un carattere
normale, come se la ‘\’ non fosse presente†) oppure un singolo
carattere privo di ulteriori significati (interpretato come se stesso).
Una ‘{’ seguita da un carattere che non sia una cifra è un carattere
normale, non l’inizio di un limite†. È vietato terminare un’ER con ‘\’.
Un’espressione parentetica è un elenco di caratteri racchiusi da ‘[]’.
Corrisponde di norma ad un qualsiasi singolo carattere fra quelli della
lista (ma vedi oltre). Se l’elenco inizia con ‘^’, l’espressione
corrisponde ad un qualsiasi singolo carattere non fra quelli della
lista (ma vedi oltre). Due caratteri nell’elenco separati da un ‘-’
formano un’abbreviazione per l’intera serie di caratteri compresi nella
sequenza di collazione fra i due caratteri (inclusi). Per es., ‘[0-9]’
corrisponde, in ASCII, ad una qualsiasi cifra decimale. Due serie non
possono†condividere un estremo, per es. ‘a-c-e’. Le serie dipendono
particolarmente dalla sequenza di collazione, e un programma, per
essere portabile, non dovrebbe dipenderne.
Se si vuole includere una ‘]’ nell’elenco, bisogna metterla al primo
posto (dopo un eventuale ‘^’). Se si vuole includere un ‘-’
nell’elenco, bisogna metterlo al primo o all’ultimo posto, o come
estremo destro di una serie. Se si vuole usare un ‘-’ come estremo
sinistro di una serie, bisogna trasformarlo in un elemento di
collazione racchiudendolo fra ‘[.’ e ‘.]’ (vedi sotto). Eccetto queste
combinazioni, e alcune altre con ‘[’ (vedi il prossimo paragrafo),
tutti gli altri caratteri speciali, inclusa la ‘\’, perdono il loro
significato speciale quando all’interno di un’espressione parentetica.
All’interno di un’espressione parentetica, un elemento di collazione
(un carattere o una sequenza di più caratteri che viene ordinata come
se fosse un carattere solo o una sequenza di collazione che sta per uno
dei due) racchiuso fra ‘[.’ e ‘.]’ rappresenta la sequenza di caratteri
dell’elemento di collazione. La sequenza è un unico argomento
dell’elenco nell’espressione parentetica. Pertanto, un’espressione che
contiene un elemento di collazione a più caratteri può corrispondere a
più di un carattere. Per es., se la sequenza di collazione include
l’elemento di collazione ‘ch’, allora l’ER ‘[[.ch.]]*c’ corrisponde ai
primi cinque caratteri di ‘chchcc’.
All’interno di un’espressione parentetica, un elemento di collazione
racchiuso fra ‘[=’ e ‘=]’ è una classe di equivalenza, cioè la sequenza
di caratteri di tutti gli elementi di collazione equivalenti, lui
incluso (se non ci sono altri elementi di collazione equivalenti, il
risultato è lo stesso che ci sarebbe se i segni di delimitazione
fossero ‘[.’ e ‘.]’). Per esempio, se o e ^ appartengono ad una classe
di equivalenza, allora ‘[[=o=]]’, ‘[[=^=]]’ e ‘[o^]’ sono sinonimi. Una
classe di equivalenza non può essere un estremo di una serie.
All’interno di un’espressione parentetica, il nome di una classe di
caratteri racchiusa fra ‘[:’ e ‘:]’ rappresenta l’elenco di tutti i
caratteri di quella classe. I nomi delle classi standard di caratteri
sono:
alnum digit punct
alpha graph space
blank lower upper
cntrl print xdigit
Questi rappresentano le classi di carattere definite in ctype(3). Una
localizzazione potrebbe fornirne altre. Una classe di caratteri non
può essere usata come estremo di una serie.
Ci sono due casi speciali†di espressioni parentetiche: le espressioni
‘[[:<:]]’ e ‘[[:>:]]’ corrispondono alla stringa nulla rispettivamente
all’inizio e alla fine di una parola. Una parola è definita come una
sequenza di caratteri di parola non seguita né preceduta da un
carattere di parola. Un carattere di parola è un carattere alfanumerico
alnum (come definito in ctype(3)) oppure un «underscore». Questa è
un’estensione, compatibile ma non specificata in POSIX 1003.2, che
dovrebbe essere usata con cautela in software che s’intende portare ad
altri sistemi.
Nel caso che un’ER possa corrispondere a più di una sotto-stringa di
una data stringa, l’ER corrisponde a quella che inizia per prima nella
stringa. Se l’ER può corrispondere a più sotto-stringhe che iniziano
nello stesso punto, l’ER corrisponde a quella più lunga. Anche le
sottoespressioni corrispondono alle sotto-stringhe più lunghe
possibile, dove le sottoespressioni che iniziano prima nell’ER hanno
priorità su quelle che iniziano dopo. Si noti che in particolare, le
sottoespressioni ad alto livello hanno la precedenza sulle loro
espressioni componenti, che sono di livello più basso.
La lunghezza di una corrispondenza è misurata in caratteri, non in
elementi di collazione. Una stringa nulla è considerata più lunga di
una corrispondenza mancata. Per esempio, ‘bb*’ corrisponde ai tre
caratteri di mezzo di ‘abbbc’, ‘(wee|week)(knights|nights)’ corrisponde
a tutti e dieci i caratteri di ‘weeknights’, se ‘(.*).*’ è corrisposto
a ‘abc’ la sottoespressione fra parentesi corrisponde ai tre caratteri,
e se ‘(a*)*’ è corrisposto a ‘bc’ sia l’intera ER che l’espressione tra
parentesi corrispondono alla stringa nulla.
Se viene richiesta una corrispondenza indipendente da maiuscole e
minuscole (case-independent matching), l’effetto è essenzialmente lo
stesso che si avrebbe togliendo ogni differenza fra maiuscole e
minuscole nell’alfabeto. Quando un carattere alfabetico che esiste sia
come maiuscola che come minuscola appare come carattere ordinario al di
fuori di un’espressione parentetica, viene, in pratica, trasformato
nell’espressione parentetica comprendente entrambi i casi: per es., ‘x’
diventa ‘[xX]’. Quando un simile carattere appare all’interno di
un’espressione parentetica, la controparte viene aggiunta
all’espressione: ad es., ‘[x]’ diventa ‘[xX]’, e ‘[^x]’ diventa
‘[^xX]’.
Non viene imposto nessun limite particolare alla lunghezza di un’ER†.
Ma un programma, per essere portatile, non dovrebbe impiegare ER più
lunghe di 256 byte, in quanto un’implementazione potrebbe rifiutare una
simile ER e rimanere conforme a POSIX.
Le espressioni regolari obsolete («basic ER») si differenziano in
diversi modi. ‘|’, ‘+’ e ‘?’ sono caratteri ordinari e non hanno nessun
equivalente. I delimitatori dei limiti sono ‘\{’ e ‘\}’, mentre ‘{’ e
‘}’ sono caratteri ordinari. Le parentesi delle sottoespressioni
annidate sono ‘\(’ e ‘\)’, mentre ‘(’ e ‘)’ sono caratteri ordinari.
‘^’ è un carattere normale tranne che all’inizio dell’ER o†all’inizio
di un’espressione parentetica, ‘$’ è un carattere normale tranne che
alla fine dell’ER o†alla fine di un’espressione parentetica, ‘*’ è un
carattere normale se appare all’inizio dell’ER o all’inizio di
un’espressione parentetica (eventualmente preceduto da un ‘^’
iniziale). Infine, c’è un nuovo tipo di atomo, una referenza
all’indietro («back reference»): ‘\’ seguita da una cifra decimale d
diversa da zero corrisponde alla stessa sequenza di caratteri a cui
corrisponde la d-esima espressione parentetica (contando, da sinistra
verso destra, le sottoespressioni in base alla posizione della loro
parentesi di destra), in modo che, ad es., ‘\([bc]\)\1’ corrisponda a
‘bb‘ o ‘cc‘ ma non a ‘bc‘.
VEDERE ANCHE
regex(3)
POSIX 1003.2, sezione 2.8 (Notazioni per le espressioni regolari).
BACHI
Avere due tipi di ER è un pasticcio.
Le specifiche attuali in 1003.2 dicono che ‘)’ è un carattere normale
in mancanza di un corrispondente ‘(’: questo è un risultato non voluto
di una scelta sbagliata di vocaboli, e sarà probabilmente modificato.
Non ci si affidi.
Le referenze all’indietro sono un casino incredibile, e rendono molto
difficile un’implementazione efficiente. La loro definizione è pure
ambigua: ‘a\(\(b\)*\2\)*d’ corrisponde a ‘abbbd’ o no? È meglio non
usarle.
Le specifiche in 1003.2 sulle corrispondenze indipendenti da
maiuscole/minuscole sono approssimative. La definizione data sopra di
«un caso implica tutti i casi» è quella al momento considerata corretta
dagli implementatori.
La sintassi per i confini di parola è veramente brutta,
AUTORE
Questa è una traduzione di una pagina di manuale tratta dal pacchetto
regex di Henry Spencer.
7 febbraio 1994 REGEX(7)