Provided by: manpages-it_0.3.4-5_all bug

NOME

       regex - POSIX 1003.2: espressioni regolari

DESCRIZIONE

       Le  espressioni regolari (ER, «regular expression»), così come definite
       da   POSIX   1003.2,   appaiono    in    due    forme:    ER    moderne
       (approssimativamente, quelle di egrep; 1003.2 le definisce ER «estese»)
       e ER obsolete (approssimativamente, quelle  di  ed;  ER  «di  base»  in
       1003.2).  Le  ER  obsolete esistono per compatibilità con alcuni vecchi
       programmi, e verranno discusse alla fine. 1003.2 lascia  aperti  alcuni
       aspetti  della  sintassi  o della semantica delle ER: ‘†’ denota scelte
       che  potrebbero   non   essere   completamente   portabili   ad   altre
       implementazioni di 1003.2.

       Una  ER  moderna  è  una†  diramazione  o  più  diramazioni non vuote†,
       separate 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  («bound»)  [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  ER_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’ER racchiusa fra ‘()’ (corrispondente  ad  una
       corrispondenza per l’ER), 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 es., ‘[0-9]’
       corrisponde, in ASCII, ad una qualsiasi cifra decimale.  Due serie  non
       possono†  condividere  un estremo, per es. ‘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 solo 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  es., 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 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 ctype(3).  Una
       localizzazione potrebbe fornirne altre.  Una classe  di  caratteri  non
       può essere usata come estremo di una serie.

       Ci  sono due casi speciali† di espressioni parentetiche: le espressioni
       ‘[[:<:]]’ e ‘[[:>:]]’ corrispondono alla stringa nulla  rispettivamente
       all’inizio  e  alla  fine di una parola. Una parola è definita come una
       sequenza di  caratteri  di  parola  non  seguita  né  preceduta  da  un
       carattere di parola. Un carattere di parola è un carattere alfanumerico
       alnum (come definito in ctype(3))  oppure  un  «underscore».  Questa  è
       un’estensione,  compatibile  ma  non  specificata  in POSIX 1003.2, che
       dovrebbe essere usata con cautela in software che s’intende portare  ad
       altri sistemi.

       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.  Anche  le
       sottoespressioni   corrispondono   alle   sotto-stringhe   più   lunghe
       possibile, dove 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  (case-independent  matching),  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 es., ‘x’
       diventa  ‘[xX]’.  Quando  un  simile  carattere  appare  all’interno di
       un’espressione   parentetica,    la    controparte    viene    aggiunta
       all’espressione:  ad  es.,  ‘[x]’  diventa  ‘[xX]’,  e  ‘[^x]’  diventa
       ‘[^xX]’.

       Non viene imposto nessun limite particolare alla lunghezza  di  un’ER†.
       Ma  un  programma,  per essere portatile, non dovrebbe 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  («basic  ER»)  si differenziano in
       diversi modi. ‘|’, ‘+’ e ‘?’ sono caratteri ordinari e non hanno nessun
       equivalente.  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, ‘*’ è  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 («back reference»): ‘\’ 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 es., ‘\([bc]\)\1’  corrisponda  a
       ‘bb‘ o ‘cc‘ ma non a ‘bc‘.

VEDERE ANCHE

       regex(3)

       POSIX 1003.2, sezione 2.8 (Notazioni per le espressioni regolari).

BACHI

       Avere due tipi di ER è un pasticcio.

       Le  specifiche  attuali in 1003.2 dicono che ‘)’ è un carattere normale
       in mancanza di un corrispondente ‘(’: questo è un risultato non  voluto
       di  una  scelta sbagliata di vocaboli, e sarà probabilmente modificato.
       Non ci si affidi.

       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   1003.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.

       La sintassi per i confini di parola è veramente brutta,

AUTORE

       Questa è una traduzione di una pagina di manuale tratta  dal  pacchetto
       regex di Henry Spencer.

                                7 febbraio 1994                       REGEX(7)