Provided by:
manpages-it_2.80-3_all 
NOME
regex - espressioni regolari POSIX.2
DESCRIZIONE
Le espressioni regolari (dette "ER"), cosi come definite da POSIX.2,
appaiono in due forme: ER moderne (approssimativamente, quelle di
egrep; POSIX.2 le definisce ER "estese") e ER obsolete
(approssimativamente quelle di ed(1); ER di "base" in POSIX.2). Le ER
obsolete esistono per compatibilita con alcuni vecchi programmi, e
verranno discusse alla fine. POSIX.2 lascia aperti alcuni aspetti
della sintassi e della semantica delle ER: `(!)' denota scelte che
potrebbero non essere completamente portabili ad altre implementazioni
di POSIX.2.
Una ER (moderna) e una(!) diramazione o piu diramazioni non vuote*-,
diramazioni, separati da `|'. L'ER corrisponde a qualsiasi cosa che
corrisponda ad una delle diramazioni.
Una diramazione e formata da uno(!) o piu pezzi concatenati.
Corrisponde ad una corrispondenza per il primo pezzo, seguita da una
corrispondenza per il secondo, ecc.
Un pezzo e formato da un atomo, eventualmente seguito da un singolo(!)
`*', `+', `?' o limite. Un atomo seguito da `*' corrisponde ad una
successione di 0 o piu corrispondenze dell'atomo. Un atomo seguito da
`+' corrisponde ad una successione di 1 o piu corrispondenze
dell'atomo. Un atomo seguito da `?' corrisponde ad una successione di
0 o 1 corrispondenza dell'atomo.
Un limite [NdT: il termine e non-standard, Regular Expressions di
Jeffrey E F Friedl, O'Reilly, 1997, usa intervallo] e 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 RE_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 piu 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 e formato da un'espressione regolare racchiusa fra `()'
(corrispondente ad una corrispondenza per l'espressione regolare), 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 e un carattere normale, non l'inizio di
un limite(!). E vietato terminare un'ER con `\'.
Un'espressione parentetica e 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 esempio,
`[0-9]' corrisponde, in ASCII, ad una qualsiasi cifra decimale. Due
serie non possono(!) condividere un estremo, per esempio `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 piu caratteri che viene ordinata come
se fosse un carattere singolo 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 e un unico
argomento dell'elenco nell'espressione parentetica. Pertanto,
un'espressione che contiene un elemento di collazione a piu caratteri
puo corrispondere a piu di un carattere. Per esempio, 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 `=]' e una classe di equivalenza, cioe la sequenza
di caratteri di tutti gli elementi di collazione equivalenti, lui
incluso (se non ci sono altri elementi di collazione equivalenti, il
risultato e 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 tutti
sinonimi. Una classe di equivalenza non puo 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 wctype(3). Una
localizzazione potrebbe fornirne altre. Una classe di caratteri non
puo essere usata come estremo di una serie.
Nel caso che un'ER possa corrispondere a piu di una sotto-stringa di
una data stringa, l'ER corrisponde a quella che inizia per prima nella
stringa. Se l'ER puo corrispondere a piu sotto-stringhe che iniziano
nello stesso punto, l'ER corrisponde a quella piu lunga. Le
sottoespressioni corrispondono anche alle sottostringhe piu lunghe
possibile, a patto che l'intera corrispondenza sia la piu lunga
possibile, con le sottoespressioni che iniziano prima nell'ER hanno
priorita 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 piu basso.
La lunghezza di una corrispondenza e misurata in caratteri, non in
elementi di collazione. Una stringa nulla e considerata piu 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 `(.*).*' e corrisposto
a `abc' la sottoespressione fra parentesi corrisponde ai tre caratteri,
e se `(a*)*' e 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, l'effetto e 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 esempio, `x' diventa
`[xX]'. Quando un simile carattere appare all'interno di
un'espressione parentetica, la controparte viene aggiunta
all'espressione: ad esempio, `[x]' diventa `[xX]', e `[^x]' diventa
`[^xX]'.
Non viene imposto nessun limite particolare alla lunghezza delle ER(!).
I programmi, per essere portabili, non dovrebbero impiegare ER piu
lunghe di 256 byte, in quanto un'implementazione potrebbe rifiutare una
simile ER e rimanere conforme a POSIX.
Le espressioni regolari obsolete si differenziano in diversi modi.
`|', `+' e `?' sono caratteri ordinari e non hanno nessun equivalente
per le loro funzionalita. I delimitatori dei limiti sono `\{' e `\}',
mentre `{' e `}' sono caratteri ordinari. Le parentesi delle
sottoespressioni annidate sono `\(' e `\)', mentre `(' e `)' sono
caratteri ordinari. `^' e un carattere normale tranne che all'inizio
dell'ER o(!) all'inizio di un'espressione parentetica, `$' e un
carattere normale tranne che alla fine dell'ER o(!) alla fine di
un'espressione parentetica, e `*' e un carattere normale se appare
all'inizio dell'ER o all'inizio di un'espressione parentetica
(eventualmente preceduto da un `^' iniziale).
Infine, c'e un nuovo tipo di atomo, una referenza all'indietro: `\'
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
esempio, `\([bc]\)\1' corrisponda a `bb` o `cc` ma non a `bc`.
BACHI
Avere due tipi di ER e un pasticcio.
Le specifiche attuali in POSIX.2 dicono che `)' e un carattere normale
in mancanza di un corrispondente `(': questo e un risultato non voluto
di una scelta sbagliata di vocaboli, e sarebbe meglio cambiarlo. Non
fare affidamento su questo.
Le referenze all'indietro sono un casino incredibile, e rendono molto
difficile un'implementazione efficiente. La loro definizione e pure
ambigua: `a\(\(b\)*\2\)*d' corrisponde a `abbbd' o no? E meglio non
usarle.
Le specifiche in POSIX.2 sulle corrispondenze indipendenti da
maiuscole/minuscole sono approssimative. La definizione data sopra di
<<un caso implica tutti i casi>> e quella al momento considerata
corretta dagli implementatori.
VEDERE ANCHE
grep(1), regex(3)
POSIX.2, sezione 2.8 (Notazione per le espressioni regolari).
COLOPHON
Questa pagina fa parte del rilascio 2.79 del progetto man-pages di
Linux. Si puo trovare una descrizione del progetto, e informazioni su
come riportare bachi, presso http://www.kernel.org/doc/man-pages/. Per
la traduzione in italiano si puo fare riferimento a
http://www.pluto.it/ildp/collaborare/