Provided by: manpages-it_2.80-3_all bug

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/