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 allindietro: ‘\’
       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/