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

NOME

       regex - espressioni regolari POSIX.2

DESCRIZIONE

       Le  espressioni  regolari  (dette  "ER"),  così  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 compatibilità 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) è una(!) diramazione o più diramazioni non vuote*†, diramazioni, separati
       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  [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
       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 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'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 è 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 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  più  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 è 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
       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
       `=]' è 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 tutti 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 wctype(3).  Una localizzazione
       potrebbe fornirne altre.  Una classe di caratteri non può essere usata come estremo di una
       serie.

       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.
       Le sottoespressioni corrispondono anche alle sottostringhe più lunghe possibile,  a  patto
       che  l'intera  corrispondenza  sia  la  più  lunga  possibile, con 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, 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 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  più  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  funzionalità.   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, e `*'  è  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: `\' 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 è un pasticcio.

       Le specifiche attuali in POSIX.2 dicono che `)' è un carattere normale in mancanza  di  un
       corrispondente  `(': questo è 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  è pure ambigua: `a\(\(b\)*\2\)*d'
       corrisponde a `abbbd' o no? È 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» è 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 può  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   può   fare
       riferimento a http://www.pluto.it/ildp/collaborare/