Provided by: manpages-it_4.23.1-1_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(1);  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, e così
       via.

       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 (o quantificatore) è 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 and '*' è 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".

BUG

       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.

AUTORE

       Questa pagina è tratta dal pacchetto sulle espressioni regolari di Henry Spencer.

VEDERE ANCHE

       grep(1), regex(3)

       POSIX.2, sezione 2.8 (Notazione per le espressioni regolari).

TRADUZIONE

       La  traduzione  italiana  di  questa  pagina di manuale è stata creata da Ottavio G. Rizzo
       <rizzo@pluto.linux.it>, Giulio Daprelà <giulio@pluto.it>, Elisabetta  Galli  <lab@kkk.it>,
       Marco Curreli <marcocurreli@tiscali.it> e Giuseppe Sacco <eppesuig@debian.org>

       Questa  traduzione è documentazione libera; leggere la GNU General Public License Versione
       3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
       Non ci assumiamo alcuna responsabilità.

       Per  segnalare  errori nella traduzione di questa pagina di manuale inviare un messaggio a
       ⟨pluto-ildp@lists.pluto.it⟩.