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

NOME

       gawk - linguaggio di ricerca ed elaborazione di configurazioni di testo
       (o "pattern", come diremo d’ora in poi).

SINTASSI

       gawk [ opzioni in stile POSIX o GNU ] -f file-di-programma [ -- ]  file
       ...
       gawk  [  opzioni in stile POSIX o GNU ] [ -- ] testo-del-programma file
       ...

DESCRIZIONE

       Gawk è la realizzazione dell’interprete del linguaggio  AWK  dello  GNU
       Project.   È  conforme  alla  definizione del linguaggio prevista dallo
       standard  "POSIX  1003.2   Command   Language   And   Utilities".    In
       particolare,  questa  versione  è basata sulla descrizione contenuta in
       The AWK Programming Language, di Aho, Kernighan e  Weinberger,  con  le
       prestazioni  aggiuntive  che  si  trovano nella versione di awk di UNIX
       System V Release 4.  Gawk mette a disposizione  inoltre  le  estensioni
       del  più recente awk dei Bell Labs ed alcune funzionalità specifiche di
       GNU.

       La linea di comando consiste in opzioni di gawk stesso,  il  testo  del
       programma  AWK  (a  meno  che non sia contenuto in un file indicato con
       l’opzione -f o --file),  e  valori  che  saranno  resi  disponibili  al
       programma nelle variabili predefinite ARGC e ARGV.

FORMATO DELLE OPZIONI

       Le  opzioni  di  Gawk possono essere sia nella tradizionale forma a una
       lettera di POSIX, sia nella forma estesa  tipica  di  GNU.  Le  opzioni
       POSIX  cominciano  con un "-" singolo, quelle in forma lunga cominciano
       con  "--".   Sono  disponibili  opzioni  in  forma  lunga  sia  per  le
       prestazioni specifiche di GNU, sia per quelle previste da POSIX.

       Conformemente  allo  standard POSIX, le opzioni specifiche di gawk sono
       indicate come argomenti  dell’opzione  -W.   Si  possono  indicare  più
       opzioni  -W.   Ogni opzione -W ha un equivalente in forma lunga, come è
       spiegato più avanti.   Gli  argomenti  delle  opzioni  in  forma  lunga
       possono essere uniti ad esse da un =, senza spazi, oppure sono indicati
       nel successivo campo della linea di comando.

       Gawk riconosce le seguenti opzioni.

       -F fs
       --field-separator fs
              Usa fs come separatore  dei  campi  in  ingresso  ("input  field
              separator"). È il valore della variabile predefinita FS.

       -v var=val
       --assign var=val
              Assegna  il  valore  val  alla  variabile  var prima di iniziare
              l’esecuzione del programma.  I valori dati in questo  modo  alle
              variabili  sono  quindi  disponibili  già  nel  blocco BEGIN dei
              programmi AWK.

       -f file-di-programma
       --file file-di-programma
              Legge il programma AWK dal file  file-di-programma  anziché  dal
              primo  argomento  della  linea  di comando.  Si possono dare più
              opzioni -f (o --file).

       -mf NNN
       -mr NNN
              Fissa al valore NNN  certi  limiti  di  memoria.   f  decide  il
              massimo numero di campi, ed r la massima dimensione di una linea
              (o, più propriamente,  di  un  record).  Questi  due  indicatori
              ("flag"),  e  l’opzione -m, sono ereditati della versione di awk
              per UNIX dei Bell Labs.  gawk li ignora, dato che non ha  limiti
              predefiniti.
       -W traditional
       -W compat
       --traditional
       --compat
              Con    quest’opzione   gawk   funziona   in   modo   compatibile
              ("compatibility mode"), cioè si comporta esattamente  come  UNIX
              awk.   Non sarà riconosciuta alcuna estensione specifica di GNU.
              La forma --traditional è preferibile alle altre.  Per  ulteriori
              informazioni, si consulti il paragrafo ESTENSIONI GNU.

       -W copyleft
       -W copyright
       --copyleft
       --copyright
              Scrive su "standard output" la versione concisa del messaggio di
              copyright di GNU e termina con successo.

       -W help
       -W usage
       --help
       --usage
              Scrive su "standard  output"  un  sommario  relativamente  breve
              delle  opzioni  disponibili.  In  linea  con  le  convenzioni di
              codifica GNU, ("GNU Coding Standards"), queste opzioni provocano
              un’uscita immediata e senza segnalazione di errore.

       -W lint
       --lint Sono  prodotti  messaggi  d’avvertimento  ("warning") relativi a
              costrutti dubbi o non trasportabili su altre versioni di AWK.

       -W lint-old
       --lint-old
              Sono prodotti messaggi  d’avvertimento  ("warning")  relativi  a
              costrutti  non trasportabili sulla versione originale di awk per
              Unix.

       -W posix
       --posix
              Quest’opzione imposta il "compatibility mode", con  le  seguenti
              restrizioni aggiuntive :

              · Non sono riconosciute le sequenze \x.

              · Quando  a  FS  è  assegnato un sigolo spazio, solo spazi e TAB
                fungono da separatori di campo, il carattere "newline"  invece
                no.

              · Non  è  riconosciuto  il  sinonimo  func  della  parola chiave
                function.

              · Non si possono usare gli operatori ** e **= al posto di ^  and
                ^=.

              · La funzione fflush() non è disponibile.

       -W re-interval
       --re-interval
              Permette  l’indicazione  di  espressioni intervallari ("interval
              expression")  nella  valutazione  di  espressioni  formali  (che
              chiameremo  d’ora in poi "regular expression"; sono descritte in
              dettaglio in un apposito capitolo, più avanti).  Le  espressioni
              intervallari   non   erano   tradizionalmente   disponibili  nel
              linguaggio AWK. Lo standard POSIX le ha aggiunte per rendere awk
              ed egrep coerenti tra loro.  Con questa prestazione, tuttavia, i
              vecchi programmi  AWK  probabilmente  non  funzionano  più.  Per
              questo  gawk  riconosce  le  espressioni  intervallari  solo  se
              espressamente  richieste  specificando  questa  opzione   oppure
              --posix.

       -W source testo-del-programma
       --source testo-del-programma
              Usa  testo-del-programma come codice sorgente del programma AWK.
              Quest’opzione permette di aggiungere in modo  semplice  funzioni
              di  libreria  (raccolte  in  file  indicati  dalle  opzioni -f e
              --file) con codice sorgente dato  nella  linea  di  comando.   È
              stata  pensata  per programmi di media e grande dimensione usati
              all’interno di procedure di shell ("shell script").

       -W version
       --version
              Scrive su "standard output" la versione  di  questa  particolare
              copia di gawk.  È utile principalmente per sapere se la copia di
              gawk installata correntemente è aggiornata rispetto  a  ciò  che
              Free  Software  Foundation  sta  distribuendo.   In linea con le
              convenzioni di codifica GNU  ("GNU  Coding  Standards"),  queste
              opzioni  provocano  un’uscita  immediata e senza segnalazione di
              errore.

       --     Indica la fine delle opzioni. Permette di passare  al  programma
              AWK  stesso  argomenti  che comincino con "-", e quindi conformi
              alla convenzione di passaggio dei parametri della maggior  parte
              delle applicazioni UNIX.

       In  modalità  compatibile,  tutte  le altre opzioni sono segnalate come
       illegali, e  per  il  resto  ignorate.   Nell’uso  normale  le  opzioni
       sconosciute   sono   passate   al   programma   nel  vettore  ARGV  per
       l’elaborazione, purché il testo del programma sia dato in qualche modo.
       Ciò  è  utile  in  particolare  nel lancio del programma AWK tramite il
       meccanismo di esecuzione automatica dell’interprete,  realizzato  dalla
       sequenza "#!" all’inizio del file eseguibile.

ESECUZIONE DEL PROGRAMMA AWK

       Un  programma  AWK consiste in una sequenza di istruzioni ("statement")
       del tipo "pattern-azione" ed, opzionalmente, definizioni di funzioni.

              pattern   { azione istruzioni }
              function nome(lista di parametri) { istruzioni }

       Gawk legge prima di tutto il programma sorgente da file-di-programma se
       specificato,  dagli argomenti di --source, o dal primo argomento non di
       tipo opzione della linea di comando.  Le opzioni -f e --source  possono
       essere  usate  più volte nella linea di comando.  Gawk leggerà il testo
       del programma come se tutti i file-di-programma  e  il  testo  sorgente
       della  linea  di  comando  fossero  concatenati.   Questo  permette  di
       realizzare librerie di funzioni AWK senza bisogno di includerle in ogni
       nuovo  programma  che  le  usi;  inoltre  si  possono unire funzioni di
       libreria a programmi provenienti dalla linea di comando.

       La variabile di ambiente AWKPATH specifica il percorso lungo  il  quale
       cercare  i file sorgenti indicati dall’opzione -f.  Se questa variabile
       non esiste,  è  utilizzato  il  percorso  ".:/usr/local/share/awk"  (ma
       questo  percorso può variare a seconda di come gawk sia stato compilato
       ed installato).  Se un nome di file dato  all’opzione  -f  contiene  il
       carattere "/", non è eseguita alcuna ricerca tramite percorso.

       Gawk esegue i programmi nell’ordine seguente.  Per prima cosa, realizza
       tutti gli  assegnamenti  indicati  dall’opzione  -v.   Successivamente,
       converte  i  programmi in un formato interno.  A questo punto esegue il
       codice dei blocchi  BEGIN,  se  presenti,  infine  legge  ciascun  file
       indicato  nel vettore ARGV.  Se non ne è indicato alcuno, gawk legge da
       "standard input".

       Se un nome di file nella linea  di  comando  ha  la  forma  var=val,  è
       trattato  come  un  assegnamento  di variabile. Alla variabile var sarà
       assegnato il valore val.  Quest’azione, che ha luogo dopo che  tutti  i
       blocchi BEGIN sono stati eseguiti, è utilissima per agire dinamicamente
       sulle variabili che AWK usa per decidere come  isolare  i  campi  ed  i
       record in ingresso.  È utile inoltre per controllare variabili di stato
       quando siano necessari più passi di elaborazione su un singolo file  di
       dati.

       Se  il  valore  di  un  particolare elemento di ARGV è la stringa vuota
       (""), gawk lo salta.

       Per ogni record in ingresso, gawk controlla se soddisfi qualcuna  delle
       configurazioni  ("pattern"),  specificate  nel programma AWK.  Per ogni
       pattern compatibile col record, è eseguita la corrispondente azione.  I
       pattern sono controllati nell’ordine in cui appaiono nel programma.

       Infine,  dopo  che  sono  esauriti  i  dati in ingresso, gawk esegue il
       codice negli eventuali blocchi END.

VARIABILI, RECORD E CAMPI

       Le variabili di AWK sono dinamiche; iniziano ad esistere la prima volta
       che le si usa. I loro valori sono numeri in virgola mobile, o stringhe,
       o entrambe le cose, a seconda di come sono usati.  Inoltre AWK  dispone
       di vettori monodimensionali; i vettori multidimensionali possono essere
       simulati.  Al lancio del programma sono impostate  parecchie  variabili
       predefinite;   saranno   descritte   di  volta  in  volta  quando  sarà
       necessario, ed elencate più avanti.

   Record
       Normalmente i record sono separati dal  carattere  "newline".   Si  può
       controllare il modo in cui i record sono separati grazie alla variabile
       predefinita RS.  Se RS contiene un qualsiasi  carattere  singolo,  tale
       carattere  separerà i record.  Altrimenti, RS può essere un’espressione
       formale ("regular expression"): i record saranno separati  della  parte
       di  testo  in  ingresso compatibile con l’espressione.  Tuttavia, nella
       modalità compatibile ("compatibility mode") è preso  in  considerazione
       solo  il primo carattere della stringa come separatore.  Se RS contiene
       la stringa nulla, i record sono separati da  righe  vuote.   Quando  RS
       contiene la stringa nulla, il carattere "newline" ha sempre la funzione
       di separatore di campo in aggiunta a quello  indicato  dalla  variabile
       FS, qualunque sia.

   Campi
       Ogni  volta  che  gawk  legge  un  record lo spezza in campi, usando il
       valore della variabile FS come separatore di campo.  Se FS è un singolo
       carattere, i campi sono separati da quel carattere.  Se FS è la stringa
       nulla, ogni singolo carattere del  record  diventa  un  diverso  campo.
       Diversamente,  si  presume  che FS sia un’espressione formale ("regular
       expression") completa.  Nel caso particolare in cui  FS  è  un  singolo
       spazio,  i  campi sono separati da sequenze di spazi, "tab" o "newline"
       (ma si veda più avanti la discussione dell’opzione --posix).   Si  noti
       che  il  valore  di  IGNORECASE (vedi) influenza anche il modo in cui i
       campi sono spezzati quando FS è una regular expression, e come i record
       vengano separati quando RS è una regular expression.

       Se  alla variabile FIELDWIDTHS è assegnata una lista di numeri separati
       da spazi, ogni campo è considerato di lunghezza fissa, e gawk spezza il
       record  secondo  le  ampiezze  specificate. Il valore di FS è ignorato.
       Assegnando un nuovo valore a FS, si annulla l’effetto di FIELDWIDTHS, e
       si ripristina il comportamento ordinario.

       Ogni  campo  nel  record  in  ingresso può essere individuato dalla sua
       posizione : $1, $2, e così via.  $0 è  l’intero  record.  Nello  stesso
       modo,  si  può anche assegnare un valore ad un campo.  Non è necessario
       che i campi siano indicati da costanti:

              n = 5
              print $n

       stampa il quinto campo del record d’ingresso.  La variabile NF contiene
       il numero di campi nel record corrente.

       Riferimenti  a  campi  inesistenti  (cioè campi oltre $NF) producono la
       stringa vuota. Tuttavia, l’assegnamento ad un  campo  inesistente  (per
       esempio  $(NF+2) = 5) provoca l’incremento del valore di NF, crea tutti
       i campi intermedi assegnando loro la stringa nulla,  e  fa  sì  che  il
       valore  di  $0  sia  ricalcolato  utilizzando OFS per separare i campi.
       Riferimenti a campi con indice negativo producono un errore fatale.  Il
       decremento  di  NF  provoca la perdita dei campi di indice superiore al
       valore impostato, ed il ricalcolo di $0, utilizzando OFS per separare i
       campi.

   Variabili predefinite
       Le variabili predefinite di gawk sono:

       ARGC        Il  numero  di argomenti della linea di comando (escluse le
                   opzioni proprie di gawk ed il programma sorgente).

       ARGIND      L’indice in ARGV del file correntemente elabolato.

       ARGV        Vettore degli argomenti della  linea  di  comando.  Il  suo
                   indice  va  da 0 ad ARGC - 1.  La modifica del contenuto di
                   ARGV permette di variare dinamicamente i file dei dati.

       CONVFMT     Il  formato  di  conversione  dei  numeri,  d’ufficio  vale
                   "%.6g".

       ENVIRON     Un    vettore    contenente    i    valori    dell’ambiente
                   ("environment") corrente.  Gli indici del  vettore  sono  i
                   nomi  delle variabili d’ambiente, e gli elementi contengono
                   i  valori  corrispondenti  (per  esempio,   ENVIRON["HOME"]
                   potrebbe valere qualcosa come "/home/arnold").  La modifica
                   di  questo  vettore  non   si   riflette   sull’environment
                   ereditato  dai  programmi che gawk lancia per redirezione o
                   con la funzione system()  (ciò  potrebbe  cambiare  in  una
                   futura versione di gawk).

       ERRNO       Se  ha  luogo  un errore di sistema in un redirezione o una
                   lettura fatte con getline, oppure  in  una  close(),  ERRNO
                   conterrà una stringa descrivente l’errore.

       FIELDWIDTHS Una  lista  di  ampiezze  di  campo  separate  da spazi. Se
                   impostato,  gawk  analizza  l’ingresso  secondo  campi   di
                   lunghezza fissa, anziché usare il valore della variabile FS
                   come separatore di  campo.   Questa  prestazione  è  ancora
                   nella fase sperimentale; la sua semantica potrebbe cambiare
                   con l’evolvere di gawk.

       FILENAME    Il nome  del  file  di  ingresso  corrente.   Se  non  sono
                   specificati  file  nella  linea  di  comando,  il valore di
                   FILENAME  è   "-".    Tuttavia,   FILENAME   è   indefinito
                   all’interno del blocco BEGIN.

       FNR         L’indice del record nel file di ingresso corrente.

       FS          Il  separatore  di  campo, normalmente uno spazio.  Si veda
                   Campi, sopra.

       IGNORECASE  Controlla la sensibilità alla distinzione tra  maiuscole  e
                   minuscole  ("case-sensitivity")  nella valutazione di tutte
                   le  regular  expression  e  nelle  operazioni  coinvolgenti
                   stringhe.  Se  IGNORECASE  ha  un  valore  diverso da zero,
                   allora il confronto di pattern nelle regole,  il  confronto
                   di  stringhe,  la  separazione  di  campi  tramite  FS,  la
                   separazione di record tramite RS, gli operatori ~ e  !~,  e
                   le  funzioni predefinte gensub(), gsub(), index(), match(),
                   split(),  e  sub()  ignoreranno  tutti  la  differenza  tra
                   maiuscole e minuscole nelle operazioni coinvolgenti regular
                   expression.  Così, se IGNORECASE è diverso da zero, /aB/ si
                   accorda  con  tutte  queste  stringhe : "ab", "aB", "Ab", e
                   "AB".  Come per  tutte  le  variabili  di  AWK,  il  valore
                   iniziale di IGNORECASE è zero, cosicché tutte le operazioni
                   su regular expression e su stringhe normalmente distinguono
                   tra  maiuscole e minuscole.  Su Unix, è utilizzato l’intero
                   insieme di caratteri ISO 8852-1 Latin-1 quando  è  ignorata
                   la  distinzione  tra  maiuscole  e  minuscole.  NOTA: Nelle
                   versioni di gawk precedenti la 3.0, IGNORECASE  influenzava
                   solo  le  operazioni riguardanti regular expression. Ora ha
                   effetto anche sul confronto fra stringhe.

       NF          Il numero di campi nel record corrente.

       NR          Il numero totale di record incontrati finora.

       OFMT        Il formato d’uscita per i numeri, d’ufficio vale "%.6g".

       OFS         Il separatore di campi in uscita, normalmente è uno spazio.

       ORS         Il  separatore di record in uscita, normalmente la sequenza
                   di fine linea ("newline").

       RS          Il separatore di record in ingresso, normalmente "newline".

       RT          Il  terminatore di record.  gwak pone RT uguale al testo in
                   ingresso  che  corrisponde  al  carattere  o  alla  regular
                   expression indicati in RS.

       RSTART      L’indice  del  primo carattere trovato conforme da match(),
                   oppure 0 se non ci sono corrispondenze.

       RLENGTH     la lunghezza della stringa  trovata  conforme  da  match();
                   oppure -1 se non ci sono corrispondenze.

       SUBSEP      Il  carattere  usato  per  separare  indici  multipli negli
                   elementi di un vettore, d’ufficio è "\034".

   Vettori
       I vettori sono indicizzati da un’espressione tra parentesi quadre ([  e
       ]).  Se l’espressione è formata da una lista di espressioni (expr, expr
       ...)  l’indice del vettore è una stringa ottenuta concatenando i valori
       (stringa)  di  ogni  espressione,  sepati  dal  valore  della variabile
       SUBSEP.   Questa  prestazione  è   sfruttata   per   simulare   vettori
       multidimensionali.  Per esempio:

              i = "A"; j = "B"; k = "C"
              x[i, j, k] = "hello, world\n"

       assegna  la  stringa "hello, world\n" all’elemento del vettore x il cui
       indice è la stringa  "A\034B\034C".   In  AWK,  tutti  i  vettori  sono
       associativi, cioè indicizzati da valori di tipo stringa.

       L’operatore  in può essere usato in istruzioni if o while per sapere se
       un vettore preveda un certo valore come indice.

              if (val in array)
                   print array[val]

       Se il vettore ha indici multipli, si usi (i, j) in array.

       Il costrutto in può anche essere usato in un ciclo for per  iterare  su
       tutti gli elementi di un vettore.

       Un  elemento  di  un  vettore  può  essere  cancellato con l’istruzione
       delete.   delete  può  anche  essere  usato  per  cancellare   l’intero
       contenuto  di  un vettore, basta specificare il nome del vettore stesso
       senza indici.

   Tipi Di Variabili E Conversioni
       Le variabili e  i  campi  possono  essere  numeri  in  virgola  mobile,
       stringhe,  o  entrambe le cose.  Come sia interpretato il valore di una
       variabile dipende  dal  contesto.   In  un’espressione  numerica,  sarà
       trattato come numero; usato come stringa, sarà trattato come tale.

       Per  fare  in  modo  che  una variabile sia trattata come numero, le si
       sommi 0; per ottenere il trattamento come stringa, le si  concateni  la
       stringa nulla.

       Quando  una  stringa  deve essere convertita a numero, la conversione è
       compiuta con atof(3).  I  numeri  sono  convertiti  a  stringhe  usando
       sprintf(3)  col  valore di CONVFMT come stringa di formato ed il valore
       numerico della variabile come argomento.  Tuttavia, anche  se  tutti  i
       numeri  in  AWK  sono  in  virgola  mobile ("float"), i valori privi di
       decimali sono sempre convertiti come interi. Così, dati

              CONVFMT = "%2.2f"
              a = 12
              b = a ""

       la variabile b ha un valore di tipo stringa di "12" e non "12.00".

       Gawk esegue i confronti  nel  modo  seguente:  Se  due  variabili  sono
       numeriche, sono confrontate numericamente.  Se una è numerica e l’altra
       è  una  stringa  interpretabile  come  numero,  sono  pure  confrontate
       numericamente.   Negli  altri  casi, gli eventuali valori numerici sono
       convertiti in stringhe,  ed  è  eseguito  un  confronto  tra  stringhe.
       Secondo  lo standard POSIX, il confronto numerico dovrebbe aversi anche
       quando entrambe le variabili fossero stringhe  convertibili  a  numeri.
       Tuttavia, questo è chiaramente sbagliato, e gawk non lo fa.

       Si  noti  che  le  costanti  stringa,  come  "57",  non  sono  stringhe
       numeriche, ma solo costanti stringa. L’idea di  "stringa  numerica"  si
       applica  solo  ai  campi,  all’ingresso  di  getline,  a FILENAME, agli
       elementi di ARGV e di ENVIRON, ed agli elmenti di un vettore creato  da
       split() che abbiano le caratteristiche di una stringa numerica.  L’idea
       fondamentale è che debbano essere trattati in questo modo solo  i  dati
       forniti dall’utente ("user input"), e non altri.

       Le  variabili  non  inizializzate  hanno come valore numerico 0, e come
       valore di stringa "" (cioè la stringa vuota, o stringa nulla).

PATTERN ED AZIONI

       AWK è un linguaggio orientato alla linea.  Il  pattern  va  all’inizio,
       l’azione  a  seguire.  Le istruzioni dell’azione sono chiuse tra { e }.
       Sia il pattern che  l’azione  possono  mancare  ma,  naturalmente,  non
       entrabi.   Se  manca il pattern, l’azione è eseguita per ogni record in
       ingresso.  Omettere invece l’azione equivale a specificare

              { print }

       che stampa l’intero record.

       I commenti cominciano col carattere "#", e continuano fino a fine riga.
       Si  possono  separare  le  istruzioni  con  righe vuote.  Un’istruzione
       finisce normalmente con la fine della riga, a meno che non  termini  in
       ",",  {,  ?,  :,  &&, o ||.  Le istruzioni in righe terminanti con do o
       else continuano automaticamente  alla  riga  successiva.   Negli  altri
       casi,  una  riga  terminante  con  un  "\"  continua alla successiva, e
       "newline" è ignorato.

       Si possono scrivere più istruzioni sulla stessa linea  separandole  con
       ";".   Questo  si  applica sia alle istruzioni all’interno di un’azione
       (il caso più comune), sia ai gruppi pattern-azione stessi.

   Pattern
       I pattern di AWK possono assume le forme seguenti:

              BEGIN
              END
              /regular expression/
              espressione di relazione
              pattern && pattern
              pattern || pattern
              pattern ? pattern : pattern
              (pattern)
              ! pattern
              pattern1, pattern2

       BEGIN e END sono due tipi speciali di pattern, che  non  dipendono  dai
       dati  in  ingresso.   Le  azioni  di  tutti  i pattern BEGIN sono unite
       insieme, come se tutte le istruzioni fossero scritte in un unico blocco
       BEGIN, e sono eseguite prima che sia letto alcunché dall’igresso.  Allo
       stesso modo, tutti i blocchi END sono fusi insieme,  ed  eseguiti  dopo
       che  tutti  i  dati  in  ingresso  sono  terminati  o  si  è incontrata
       l’istruzione exit.  BEGIN e END non possono essere combinati con  altri
       pattern   in   espressioni,   inoltre  l’azione  associata  ad  essi  è
       obbligatoria.

       Per i pattern nella forma /regular  expression/  l’azione  associata  è
       eseguita  per  ogni  record  in  ingresso che sia conforme alla regular
       expression.  Le "regular expression" hanno la stessa forma di quelle di
       egrep(1), e sono descritte più avanti.

       In un’espressione relazionale si può usare qualsiasi operatore definito
       nella sezione sulla azioni,  più  avanti.   Generalmente  l’espressione
       relazionale è utilizzata per verificare se certi campi si accordino con
       determinate regular expression.

       Gli operatori &&, ||, e !   sono  rispettivamnete  l’AND  logico,  l’OR
       logico,  ed  il  NOT logico.  Come i loro equivalenti del linguaggio C,
       valutano solo il numero di operandi strettamente necessario a  decidere
       il  risultato,  a  partire  da  quello  più  a sinistra ("short-circuit
       evaluation"). Sono usati  per  combinare  espressioni  di  pattern  più
       semplici.  Come  nella  maggior  parte  dei linguaggi, si possono usare
       parentesi per cambiare l’ordine di valutazione.

       L’operatore ?: è simile allo  stesso  operatore  del  C:  se  il  primo
       pattern  è vero, allora il pattern utilizzato per il test è il secondo,
       altrimenti è il terzo. Dei pattern  secondo  e  terzo,  ne  è  valutato
       sempre solo uno.

       Un’espressione  nella  forma  pattern1, pattern2 è detta range pattern.
       Essa considera compatibili tutti i record a partire da uno  conforme  a
       pattern1,  fino  ad  uno  conforme a pattern2, compreso. Non può essere
       combinata con alcun’altra espressione.

   Regular Expressions ("Espressioni Formali")
       Le regular expression sono del tipo esteso che si trova in egrep.  Sono
       composte da caratteri secondo le regole seguenti:

       c          accetta il carattere (non speciale) c.

       \c         accetta il carattere c considerato letteralmente.

       .          accetta qualsiasi carattere, compreso "newline".

       ^          accetta l’inizio di una stringa.

       $          accetta la fine di una stringa.

       [abc...]   lista  di  caratteri,  accetta  uno  qualsiasi dei caratteri
                  abc....

       [^abc...]  lista  di  caratteri  negata,  accetta  qualsiasi  carattere
                  eccetto abc....

       r1|r2      alternativa: accetta r1 oppure r2.

       r1r2       concatenazione: accetta r1, e poi r2.

       r+         accetta uno o più r.

       r*         accetta zero o più r.

       r?         accetta un r o nessuno.

       (r)        raggruppamento: accetta r.

       r{n}
       r{n,}
       r{n,m}     Uno   o   due   numeri   racchiusi   tra   graffe   indicano
                  un’"espressione intervallare" ("interval  expression").   Se
                  c’è un numero tra graffe, la regular expression precedente r
                  è ripetuta n  volte.  Se  tra  graffe  ci  sono  due  numeri
                  separati  da  virgola, r è ripetuta da n ad m volte.  Se c’è
                  un numero seguito da una virgola,  r  è  ripetuta  almeno  n
                  volte.
                  Le  espresioni intervallari sono ammesse solo se nella linea
                  di  comando   è   specificata   l’opzione   --posix   oppure
                  --re-interval.

       \y         accetta  la  stringa  vuota  all’inizio  o  alla fine di una
                  parola.

       \B         accetta la stringa vuota all’interno di una parola.

       \<         accetta la stringa vuota all’inizio di una parola.

       \>         accetta la stringa vuota alla fine di una parola.

       \w         accetta un qualsiasi carattere che possa far  parte  di  una
                  parola, cioè lettere, numeri o "_" ("underscore").

       \W         accetta  un  qualsiasi  carattere che non possa far parte di
                  una parola.

       è          accetta la stringa vuota all’inizio di una stringa.

       \’         accetta la stringa vuota alla fine di una stringa.

       Le sequenze "\x" ("escape sequence") valide all’interno delle  stringhe
       (vedere oltre) sono ammesse anche nelle regular expression.

       Le  classi  di  caratteri  sono  una nuova prestazione introdotta nello
       standard POSIX.  Una classe di caratteri è una speciale  notazione  per
       indicare  liste  di  caratteri accomunati da uno specifico attributo, i
       costituenti delle quali possono variare a seconda della  nazionalità  e
       dell’insieme  di caratteri di sistema (detto comunenmente character set
       o charset per brevità) correntemente attivi.  Per esempio,  la  nozione
       di  "carattere alfabetico" valida negli Stati Uniti è diversa da quella
       valida in Francia.

       Una classe di caratteri è  ammessa  solo  allinterno  delle  parentesi
       quadre  di una lista di caratteri di una regular expression.  Le classi
       di caratteri si rappresentano con [:, una parola  chiave  indicante  la
       classe,  e  :].   Queste  sono  le  classi  di caratteri definite dallo
       standard POSIX:

       [:alnum:]
              Caratteri alfanumerici.

       [:alpha:]
              Caratteri alfabetici.

       [:blank:]
              Caratteri "spazio" e "tab".

       [:cntrl:]
              Caratteri di controllo.

       [:digit:]
              Caratteri numerici.

       [:graph:]
              Caratteri che siano sia stampabili che visibili  (uno  spazio  è
              stampabile ma non visibile, mentre a è entrambe le cose).

       [:lower:]
              Caratteri alfabetici minuscoli.

       [:print:]
              Caratteri   stampabili   (cioè   caratteri   che  non  siano  di
              controllo).

       [:punct:]
              Caratteri di punteggiatura (cioè  caratteri  che  non  siano  né
              lettere,  né  cifre,  né caratteri di controllo, né caratteri di
              spaziatura).

       [:space:]
              Caratteri di spaziatura (come lo spazio, "tab", "formfeed",  per
              citarne solo alcuni).

       [:upper:]
              Caratteri alfabetici maiuscoli.

       [:xdigit:]
              Cifre esadecimali.

       Per  fare  un  esempio, prima dell’introduzione dello standard POSIX si
       sarebbe  dovuto  scrivere  /[A-Za-z0-9]/  per   individuare   caratteri
       alfanumerici.  Qualora il "character set" vigente avesse compreso altri
       caratteri alfanumerici, l’espressione non li avrebbe riconosciuti.  Con
       le  classi  di  caratteri  POSIX,  si  può  scrivere /[[:alnum:]]/, che
       troverà corrispondenza con tutti  i  caratteri  alfabetici  e  numerici
       previsti dal charset correntemente in uso.

       Nelle  liste  di  caratteri  possono  comparire  due  sequenze speciali
       aggiuntive. Esse si applicano ai charset non  ASCII,  i  quali  possono
       comprendere  sia  simboli  singoli,  chiamati  "elementi  di  confronto
       testuale" ("collating elements") rappresentati da più di un  carattere,
       sia  gruppi  di  caratteri  tra  loro equivalenti ai fini del confronto
       testuale ("collating") o dell’ordinamento.  Per  esempio,  in  francese
       una "e" semplice ed una con l’accento grave sono equivalenti.

       Simboli di Confronto Testuale ("Collating Symbols")
              Un  simbolo  di confronto testuale è un elemento di confronto di
              più di un carettere chiuso tra [.  e .].  Per esempio, se  ch  è
              un elemento di confronto testuale, allora [[.ch.]]  è la regular
              expression  che  lo  individua,  mentre  [ch]  è   una   regular
              expression che individua o il carattere c, o il carattere h.

       Classi di Equivalenza ("Equivalence Classes")
              Una  classe di equivalenza è un nome, dipendente dalla località,
              associato ad una lista di caratteri tra  loro  equivalenti.   Il
              nome  è  racchiuso tra [= e =].  Per esempio, il nome e potrebbe
              essere usato per rappresentare globalmente i caratteri e,  è  ed
              é.   In questo caso, [[=e]] è una regular expression compatibile
              con uno qualsiasi dei caratteri e, é, ed è.

       Queste funzionalità sono molto apprezzabili quando la  lingua  corrente
       non   è  l’inglese.   Le  funzioni  di  libreria  che  gawk  usa  nella
       valutazione di regular  exopression  riconoscono  attualmente  solo  le
       classi  di  caratteri  POSIX, non i simboli di confronto testuale né le
       classi di equivalenza.

       Gli operatori \y, \B, \<, \>, \w, \W, è,  ed  \’  sono  specificità  di
       gawk;  queste  estensioni  sono  possibili  grazie  alle  facilitazioni
       derivanti dall’uso della libreria "regexp" di GNU.

       Quelle  che  seguono  sono  le  opzioni  della  linea  di  comando  che
       controllano  come gawk interpreti i caratteri nella regular expression.

       Nessuna opzione
              In assenza di indicazioni, gawk mette a  disposizione  tutte  le
              facilitazioni  caratteristiche  delle regular expression POSIX e
              degli operatori GNU descritti prima.  Tuttavia,  le  espressioni
              intervallari non funzionano.

       --posix
              Sono  riconosciute  solo  le  regular  expression POSIX, non gli
              operatori GNU (per esempio, \w individua il carattere w).   Sono
              ammesse le espressioni intervallari.

       --traditional
              Le  regular  expression  sono  valutate  secondo  le  regole del
              tradizionale  awk  per  Unix.   Nè  gli  operatori  GNU,  né  le
              espressioni  intervallari,  né  le  classi  di  caratteri  POSIX
              ([[:alnum:]] e simili) funzionano.   I  caratteri  descritti  da
              sequenze ottali o esadecimali sono trattati letteralmente, anche
              se rappresentano metacaratteri di regular expression.

       --re-interval
              Sono permesse le espressioni  intervallari,  anche  se  è  stato
              specificato --traditional.

   Azioni
       Le  istruzioni  di  azione  sono  rinchiuse  tra  graffe,  {  e  }.  Le
       istruzioni del  costrutto  di  azione  possono  essere  assegnamenti  o
       istruzioni condizionali o iterative come si trovano nella maggior parte
       dei  linguaggi.   Gli  operatori,  le  strutture  di  controllo  e   le
       istruzioni  di  input/output ricalcano le corrispondenti del linguaggio
       C.

   Operatori
       Gli operatori di AWK, in ordine decrescente di precedenza, sono

       (...)       Raggruppamento

       $           Riferimento a campi.

       ++ --       Incremento e decremento, sia prefisso che postfisso.

       ^           Elevamento a potenza (si può anche usare ** al suo posto, e
                   **= nell’assegnamento con operatore).

       + - !       Più e meno unari, e negazione logica.

       * / %       Moltiplicazione, divisione e resto.

       + -         Addizione e sottrazione.

       spazio      Concatenazione di stringhe.

       < >
       <= >=
       != ==       I ben noti operatori di relazione.

       ~ !~        Controllo di conformità ("match") tra regular expression, e
                   controllo di non conformità.  NOTA: Non usare  una  regular
                   expression  costante (/foo/) come operando di sinistra di ~
                   o  !~.   Si  indichi  sempre  la  regular  expression  come
                   operando di destra.  L’espressione /foo/ ~ exp ha lo stesso
                   significato di (($0 ~ /foo/) ~  exp).   Non  è  questo,  in
                   genere, che ci si aspetta.

       in          Controllo di appartenenza ad un vettore.

       &&          AND logico.

       ||          OR logico.

       ?:          L’espressione  condizionale in stile C. Ha la forma expr1 ?
                   expr2 : expr3. Se expr1 è vera, il valore  dell’espressione
                   è expr2, altrimenti è expr3.  È valutata solo una delle due
                   espressioni expr2 ed expr3.

       = += -=
       *= /= %= ^= Assegnamento. Sono riconosciuti sia l’assegnamento assoluto
                   (var = value) sia quello con operatore (le altre forme).

   Istruzioni di controllo
       Le istruzioni di controllo di AWK sono:

              if (condizione) istruzione [ else istruzione ]
              while (condizione) istruzione
              do istruzione while (condizione)
              for (expr1; expr2; expr3) istruzione
              for (var in vettore) istruzione
              break
              continue
              delete vettore[indice]
              delete vettore
              exit [ espressione ]
              { istruzione }

   Istruzioni di I/O
       Le istruzioni di input/output sono le seguenti:

       close(file)           Chiude  un  file  (o  una pipe, come si vedrà più
                             avanti).

       getline               Copia in  $0  la  prossima  linea  d’ingresso,  e
                             ricalcola NF, NR, FNR.

       getline <file         Copia   in  $0  la  prossima  linea  di  file,  e
                             ricalcola NF.

       getline var           Copia in var  la  prossima  linea  d’ingresso,  e
                             ricalcola NR ed FNR.

       getline var <file     Copia in var la prossima linea di file.

       next                  Cessa   l’elaborazione   della  linea  d’ingresso
                             corrente. È letta la successiva, e l’elaborazione
                             ricomincia  dal  primo pattern del programma AWK.
                             Se non  ci  sono  più  righe  in  ingresso,  sono
                             eseguiti i blocchi END, se presenti.

       nextfile              Cessa   l’eleborazione   del   file  di  ingresso
                             corrente. La prossima linea sarà letta  dal  file
                             di ingresso successivo.  Sono aggiornati FILENAME
                             ed ARGIND, FNR è riportato ad 1, e l’elaborazione
                             riprende  dal primo pattern del programma AWK. Se
                             non ci sono più dati in ingresso,  sono  eseguiti
                             gli   eventuali   blocchi   END.    NOTA:   Nelle
                             precedenti versioni di gawk  si  usavano  le  due
                             distinte  parole next file.  Quest’ultima forma è
                             ancora riconosciuta, ma potrebbe non  esserlo  in
                             futuro;  per  il momento essa provoca l’emissione
                             di un messaggio di avvertimento.

       print                 Stampa il record  corrente,  seguito  dal  valore
                             della variabile ORS.

       print expr-list       Stampa  le  espressioni  indicate,  separate  dal
                             valore della variabile OFS.   La  linea  prodotta
                             termina col valore della variabile ORS.

       print expr-list >file Stampa   su   file   le   espressioni   indicate,
                             separandole col valore della variabile  OFS.   La
                             linea prodotta termina col valore della variabile
                             ORS.

       printf fmt, expr-list Stampa secondo formato.

       printf fmt, expr-list >file
                             Stampa secondo formato su file.

       system(cmd-line)      Esegue il comando cmd-line, e ne  restituisce  il
                             valore d’uscita.  (può non essere disponibile sui
                             sistemi non-POSIX).

       fflush([file])        Scarica il contenuto di tutti i buffer  associati
                             al file o alla pipe aperti in scrittura file.  Se
                             file non è specificato,  è  assunto  lo  standard
                             output.  Se file è la stringa vuota, l’operazione
                             è eseguita su tutti i file e le  pipe  aperti  in
                             scrittura.

       Sono  permessi  anche  altri  tipi  di redirezione. Per print e printf,
       >>file accoda i caratteri prodotti a file, metre |  command  scrive  su
       una  pipe.   Allo  stesso  modo,  command  |  getline legge da una pipe
       l’uscita di "command".  L’istruzione getline restituirà 0  in  caso  di
       fine file, e -1 in caso di errore.

   Listruzione printf
       Le  versioni  di  AWK dell’istruzione printf e della funzione sprintf()
       (vedi più avanti) accettano i seguenti formati di conversione:

       %c     Un carattere ASCII .  Se l’argomento usato per %c è numerico,  è
              trattato come un carattere e stampato.  Altrimenti l’argomento è
              di tipo stringa, e ne è stampato solo il primo carattere.

       %d
       %i     Un numero decimale (parte intera).

       %e
       %E     Un numero in virgola mobile nella forma [-]d.dddddde[+-]dd.  Con
              %E si ottiene E anziché e.

       %f     Un numero in virgola mobile nella forma [-]ddd.dddddd.

       %g
       %G     Usa il più corto tra i formati e ed f (o E ed f, nel caso di %G)
              e sopprime gli zeri non significativi.

       %o     Un numero ottale senza segno (di nuovo, un intero).

       %s     Una stringa di caratteri.

       %x
       %X     Un numero esadecimale senza segno (intero).  %x usa i  caratteri
              abcdef, mentre %X usa ABCDEF.

       %%     Un singolo carattere %; nessun argomento è convertito.

       Tra  %  e  la  lettera  di controllo possono comparire alcuni parametri
       opzionali:

       -      L’espressione   dovrebbe   essere   giustificata   a    sinistra
              all’interno del proprio campo.

       spazio Nelle conversioni numeriche, fa precedere ai valori positivi uno
              spazio, ed ai valori negativi il segno "meno".

       +      Il segno "più" prima del modificatore di ampiezza (descritto più
              avanti)  indica  che  nelle  conversioni numeriche il segno deve
              essere sempre prodotto, anche se il valore del dato è  positivo.
              + annulla l’effetto dello spazio.

       #      Usa una "forma alternativa" con certe lettere di controllo.  Con
              %o è aggiunto uno zero iniziale;  con  %x  e  %X  sono  aggiunti
              rispettivamente  0x  e 0X in caso di valore diverso da zero; con
              %e, %E, e %f, il risultato conterrà sempre  il  punto  decimale;
              con %g, e %G, gli zeri in coda non sono rimossi.

       0      Uno  0  (zero)  iniziale  indica  che la stringa risultante deve
              essere completata da zeri anziché spazi.  Questo vale anche  per
              i  formati  non  numerici.   Questo  indicatore  ha effetto solo
              quando la larghezza del campo è maggiore di quella necessaria  a
              contenere il valore da stampare.

       ampiezza
              Un  numero  indicante  l’ampiezza  che  il campo dovrebbe avere.
              Normalmente il carattere di riempimento è uno spazio, ma se si è
              usato l’indicatore 0, il carattere di riempimento è lo zero.

       .prec  Un  numero  indicante  la precisione da utilizzare nella stampa.
              Con i formati %e, %E, e %f, specifica il  numero  di  cifre  che
              dovranno  comparire  a destra del punto decimale.  Con i formati
              %g, e %G, specifica il massimo numero  di  cifre  significative.
              Con  i  formati  %d,  %o,  %i, %u, %x, e %X, specifica il numero
              minimo di cifre da stampare.   Con  le  stringhe,  specifica  il
              massimo  numero  di  caratteri della stringa che potranno essere
              stampati.

       È permessa la definizione dinamica di ampiezza e  prec  prevista  dalla
       funzione  printf()  dell’ANSI C.  Un * al posto di ampiezza o prec farà
       sì che i loro valori siano presi dalla lista degli argomenti di  printf
       o sprintf().

   Nomi di file speciali
       Nelle  redirezioni  di  print  o  printf in un file, o di getline da un
       file, gawk riconosce internamente certi  nomi  di  file  speciali,  che
       permettono  di  accedere  a  file  descriptor  ereditati  dal  processo
       genitore  di  gawk  (la  shell,  in  genere),  oppure  ad  informazioni
       riguardanti il processo gawk corrente.  I nomi speciali sono:

       /dev/pid    La  lettura  di  questo  file  fornisce il PID del processo
                   corrente, in forma decimale e terminante con "newline".

       /dev/ppid   La lettura di questo file fornisce il PID del genitore  del
                   processo  corrente,  in  forma  decimale  e  terminante con
                   "newline".

       /dev/pgrpid La lettura di questo file fornisce il  "process  group  ID"
                   del  processo  corrente, in forma decimale e terminante con
                   "newline".

       /dev/user   La lettura di questo file fornisce una linea terminante con
                   "newline",  i  cui  campi  sono separati da spazi.  $1 è il
                   valore della system call  getuid(2),  $2  è  il  valore  di
                   geteuid(2),  $3  è il valore di getgid(2), e $4 è il valore
                   di getegid(2).  Se ci sono campi addizionali, sono i "group
                   ID"  dati  da  getgroups(2).  I gruppi multipli possono non
                   essere realizzati su tutti i sistemi.

       /dev/stdin  Lo "standard input".

       /dev/stdout Lo "standard output".

       /dev/stderr Lo "standard error".

       /dev/fd/n   Il file associato al file descriptor aperto n.

       Questi ultimi sono utili in  particolare  nell’emissione  di  messaggi.
       Per esempio, si può scrivere:

              print "Che sf...ortuna!" > "/dev/stderr"

       laddove,  per  ottenere lo stesso effetto, si sarebbe stati costretti a
       scrivere

              print "Che sf...ortuna!" | "cat 1>&2"

       Questi nomi di file possono essere anche dati nella  linea  di  comando
       come nomi di file di dati.

   Funzioni Numeriche
       AWK ha le seguenti funzioni aritmetiche predefinite:

       atan2(y, x)   l’arcotangente di y/x in radianti.

       cos(expr)     coseno di expr (si aspetta radianti).

       exp(expr)     esponenziale.

       int(expr)     troncamento ad intero.

       log(expr)     logaritmo naturale.

       rand()        fornisce un numero casuale tra 0 ed 1.

       sin(expr)     seno di expr (si aspetta radianti).

       sqrt(expr)    radice quadrata.

       srand([expr]) usa  expr  come  nuovo  seme  per il generatore di numeri
                     casuali. Se expr non è indicata, sarà utilizzata la  data
                     corrente.   Il  valore  di ritorno è il valore precedente
                     del seme.

   Funzioni su Stringhe
       Gawk offre le seguenti funzioni di stringa predefinite:

       gensub(r, s, h [, t])   cerca nella stringa obiettivo t  corrispondenze
                               con  la  regular  expression  r.   Se  h  è una
                               stringa  che  inizia  con  g  o  G,  tutte   le
                               corrispondenze  con  r  sono  sostituite con s;
                               altrimenti,  h  è  un  numero  che  indica   la
                               particolare  corrispondenza  con r che si vuole
                               sostituire.  Se t non è specificata, è usato $0
                               al   suo   posto.   All’interno  del  testo  di
                               rimpiazzo s si può utilizzare la  sequenza  \n,
                               dove  n  è una cifra tra 1 e 9, per indicare la
                               parte  di  testo  che  corrisponde  all’n-esima
                               sottoespressione tra parentesi.  La sequenza \0
                               rappresenta  il  testo  ricoperto   dall’intera
                               espressione,  e  così  pure  il carattere &.  A
                               differenza  di  sub()  e  gsub(),  la   stringa
                               modificata   è   data   come  risulatato  della
                               funzione; l’originale resta inalterata.

       gsub(r, s [, t])        per ogni  sottostringa  conforme  alla  regular
                               expression  r  nella  stringa t, sostituisce la
                               stringa  s,  e   restituisce   il   numero   di
                               sostituzioni.   Se t non è specificata, usa $0.
                               Una & nel testo di rimpiazzo è  sostituita  dal
                               testo   trovato   conforme   con   la   regular
                               expression.   Si  usi  \&   per   indicare   il
                               carattere  & inteso letteralmente.  Si veda AWK
                               Language  Programming   per   una   più   ampia
                               discussione  circa le regole che riguardano & e
                               i "backslash" nel testo di rimpiazzo di  sub(),
                               gsub(), e gensub().

       index(s, t)             trova  l’indice  posizionale  della  stringa  t
                               nella stringa s, o 0 se t non è presente.

       length([s])             la  lunghezza  della  stringa  s,   oppure   la
                               lunghezza di $0 se s non è specificata.

       match(s, r)             trova  la  posizione  in  s  del  tratto che si
                               conforma alla regular expression r, oppure 0 se
                               non  ci  sono  conformtà. I valori di RSTART ed
                               RLENGTH sono modificati di conseguenza.

       split(s, a [, r])       spezza la stringa s nel vettore  a  utilizzando
                               il   metodo   di  separazione  descritto  dalla
                               regular expression r, e restituisce  il  numero
                               di   campi.   Se  r  è  omessa,  il  separatore
                               utilizzato è FS.  Il precedente  contenuto  del
                               vettore  a  è  cancellato.  La divisione di una
                               stringa in parti e l’isolamento dei  campi  nei
                               record,    descritto   prima,   sono   compiuti
                               esattamente allo stesso modo.

       sprintf(fmt, expr-list) stampa (in modo fittizio) expr-list secondo  il
                               formato   fmt,   e   restituisce   la   stringa
                               risultante.

       sub(r, s [, t])         come gsub(), ma  è  sostituita  solo  la  prima
                               sottostringa trovata.

       substr(s, i [, n])      restituisce la sottostringa di s di n caratteri
                               alpiù che inizia nella posizione  i.   Se  n  è
                               omesso, è usato il resto di s.

       tolower(str)            restituisce  una  copia  della stringa str, con
                               tutti  i  caratteri  maiuscoli   tradotti   nei
                               minuscoli   corrispondenti.   I  caratteri  non
                               alfabetici restano invariati.

       toupper(str)            restituisce una copia della  stringa  str,  con
                               tutti   i   caratteri  minuscoli  tradotti  nei
                               maiuscoli  corrispondenti.   I  caratteri   non
                               alfabetici restano invariati.

   Funzioni di Tempo
       Poiché  uno  dei  principali  campi di applicazione dei programmi AWK è
       l’elaborazione  di   file   di   traccia   ("log   files")   contenenti
       informazioni   di   tipo   marcatempo  ("time  stamp"),  gawk  mette  a
       disposizione le seguenti due funzioni per ottenere marcatori di tempo e
       per manipolarli.

       systime() restituisce la data e l’ora correnti, espresse come numero di
                 secondi  trascorsi  da  una  certa  data  convenzionale   (la
                 mezzanotte del 1/1/1970 sui sistemi POSIX).

       strftime([format [, timestamp]])
                 Applica  il  formato  format a timestamp.  timestamp dovrebbe
                 essere nella forma utilizzata da systime().  Se  timestamp  è
                 omesso,  sono utilizzate la data e l’ora correnti.  Se format
                 è  omesso,  è  assunto  un  formato  equivalente   a   quello
                 utilizzato  dal comando date(1).  Per sapere quali formati di
                 conversione siano disponibili,  si  faccia  riferimento  alle
                 specifiche   della  funzione  strftime()  del  C  ANSI.   Una
                 versione di pubblico dominio di  strftime(3)  e  le  relative
                 pagine  di manuale sono distribuite con gawk; se gawk è stato
                 compilato  utilizzando  tale  versione  di  strftime,   potrà
                 eseguire   tutte   le   conversioni   descritte  nel  manuale
                 associato.

   Constanti di tipo Stringa
       Le costanti di tipo stringa in AWK sono sequenze  di  caratteri  chiuse
       tra  doppi  apici  (").  All’interno  delle stringhe, sono riconosciute
       certe sequenze di escape ("escape sequences"), come nel linguaggio C :

       \\   Un carattere "\" singolo.

       \a   Il carattere "alert"; di solito si tratta del carattere ASCII  BEL
            (^G).

       \b   backspace : ASCII BS (^H).

       \f   form-feed : ASCII FF (^L).

       \n   newline (^J).

       \r   carriage return (^M).

       \t   horizontal tab (^I).

       \v   vertical tab (^V).

       \xhex digits
            Il  carattere rappresentato dalla stringa di cifre esadecimali che
            segue \x.  Come nel C ANSI, tutte le  cifre  esadecimali  seguenti
            sono  considerate parte della sequenza (questa prestazione la dice
            lunga  su  come  il  comitato  abbia  redatto  le  specifiche  del
            linguaggio).   Per  esempio,  "\x1B"  è  il  carattere  ASCII  ESC
            (escape).

       \ddd Il carattere rappresentato dalla sequenza di una, due o tre  cifre
            ottali.  Esempio: "\033" è il carattere ASCII ESC (escape).

       \c   Il carattere c, così com’è.

       Le  sequenze  di  escape possono anche essere utilizzate all’interno di
       regular expression (per esempio, /[ \t\f\n\r\v]/ descrive  i  caratteri
       di spaziatura).

       In modalità compatibile i caratteri rappresentati da sequenze ottali ed
       esadecimali  sono  trattati  letteralmente  quando  usati  in  costanti
       contenenti regular expression. Così, /a\52b/ equivale a /a\*b/.

FUNZIONI

       Le funzioni in AWK sono definite in questo modo:

              function nome(lista-di-parametri) { istruzioni }

       Le  funzioni  sono  eseguite  in  seguito  a  chiamate  dall’interno di
       espressioni, che possono comparire  sia  all’interno  di  pattern,  sia
       all’interno  di  azioni.   I  parametri  attuali  dati al momento della
       chiamata istanziano i parametri formali dichiarati nella  funzione.   I
       vettori sono passati per riferimento, le altre variabili per valore.

       Poiché le funzioni non erano in origine previste nel linguaggio AWK, la
       gestione delle variabili locali  è  piuttosto  goffa:  sono  dichiarate
       semplicemente  come parametri in più nella lista dei parametri formali.
       Per convenzione, si usa separare le variabili locali dai veri parametri
       con qualche spazio in più nella lista. Per esempio:

              function  f(p, q,     a, b)     # "a" e "b" sono locali
              {
                   .....
              }

              /abc/   { ... ; f(1, 2) ; ... }

       La parentesi di sinistra di una chiamata deve seguire immediatamente il
       nome  della  funzione,  senza  spazi  in  mezzo;  questo  per   evitare
       l’ambiguità  sintattica  con  l’operatore  di  concatenazione.   Questa
       restrizione non si applica alle funzioni predefinite elencate prima.

       Le funzioni possono chiamare a loro volta  altre  funzioni,  e  possono
       essere  ricorsive.   I  parametri utilizzati come variabili locali sono
       inizializzati  alla  stringa  nulla  ed  al  numero  zero  al   momento
       dell’invocazione.

       Se  è stata data l’opzione --lint, gawk avvertirà in caso di chiamate a
       funzioni  indefinite  al  momento  della  valutazione  sintattica   del
       programma  anziché  durante  l’esecuzione.  La chiamata di una funzione
       indefinita in fase di esecuzione è un errore fatale.

       Si può usare la parola func al posto di function.

ESEMPI

       Stampa ed ordina i nomi di login di tutti gli utenti:

            BEGIN   { FS = ":" }
                 { print $1 | "sort" }

       Conta le righe di un file:

                 { nlines++ }
            END     { print nlines }

       Aggiunge il numero di linea alle righe di un file:

            { print FNR, $0 }

       Variazione sul tema:

            { print NR, $0 }

VEDERE ANCHE

       egrep(1), getpid(2),  getppid(2),  getpgrp(2),  getuid(2),  geteuid(2),
       getgid(2), getegid(2), getgroups(2)

       The  AWK Programming Language, Alfred V. Aho, Brian W. Kernighan, Peter
       J. Weinberger, Addison-Wesley, 1988. ISBN 0-201-07981-X.

       AWK Language Programming, Edition  1.0,  pubblicata  da  Free  Software
       Foundation, 1995.

COMPATIBILITÀ POSIX

       Un  obiettivo di primaria importanza per gawk è la compatibilità con lo
       standard POSIX, così come con la più recente versione di awk per  UNIX.
       A  tal  fine,  gawk incorpora le seguenti prestazioni non descritte nel
       manuale del linguaggio, ma facenti parte della versione dei  Bell  Labs
       di awk, e previste dallo standard POSIX.

       L’opzione  -v per l’assegnamento di variabili prima dell’esecuzione del
       programma è una novità.  Secondo il libro, l’assegnamento di  variabili
       da  linea  di  comando  ha  luogo  nel  momento  in  cui  awk  utilizza
       l’argomento come eventuale nome di file da aprire in lettura,  la  qual
       cosa  avviene  dopo  che  sono  stati  eseguiti  tutti i blocchi BEGIN.
       Tuttavia, nelle versioni più recenti, gli assegnamenti avvengono  prima
       dell’esecuzione  di  BEGIN,  a patto che precedano tutti i nomi di file
       nella linea di comando.  Le applicazioni hanno finito col dipendere  da
       questa  "prestazione".   Quando awk fu modificato per allinearlo con la
       sua documentazione, fu aggiunta quest’opzione per venire incontro  alle
       applicazioni   che  confidavano  nel  vecchio  comportamento.   (questa
       funzionalità è stata accolta sia dagli sviluppatori  di  AT&T,  sia  da
       quelli di GNU).

       L’opzione -W per l’attivazione di prestazioni specifiche della versione
       proviene dallo standard POSIX.

       Nell’esame degli argomenti, gawk  interpreta  l’opzione  speciale  "--"
       come  marcatore  della  fine  della  lista.   In  modalità  compatibile
       segnala, ma per il resto ignora, le opzioni indefinite.  Nella modalità
       ordinaria,  tali  argomenti  sono passati al programma AWK perché possa
       elaborarli.

       Il manuale di AWK non definisce il valore di ritorno  di  srand().   Lo
       standard  POSIX  prevede  che la funzione restituisca il seme corrente,
       per poter controllare la sequenza di generazione  dei  numeri  casuali.
       Perciò, anche srand() di gawk restituisce il seme corrente.

       Nuove prestazioni sono anche le seguenti: l’uso di più di un’opzione -f
       (da MKS  awk);  il  vettore  ENVIRON;  le  escape  sequence  \a,  e  \v
       (originali  di  gawk ma aggiunte in seguito anche da AT&T); le funzioni
       predefinite tolower()  e  toupper()  (da  AT&T);  e  le  specifiche  di
       conversione del C ANSI per printf (da AT&T).

ESTENSIONI GNU

       Gawk  aggiunge  alcune  estensioni  a  POSIX  awk,  descritte in questa
       sezione.  Tutte  le   estensioni   qui   documentate   possono   essere
       disabilitate con l’opzione --traditional.

       Le seguenti funzionalità di gawk non sono disponibili in POSIX awk.

              · L’escape sequence \x.  (disabilitata con --posix).

              · La funzione fllush().  (disabilitata con --posix).

              · Le funzioni systime(), strftime() e gensub().

              · I nomi di file speciali per la redirezione dell’I/O.

              · Le variabili ARGIND, ERRNO ed RT.

              · La variabile IGNORECASE, con i suoi effetti collaterali.

              · La  variabile FIELDWIDTHS e la possibilità di isolare campi di
                lunghezza fissa.

              · L’uso di RS come regular expression.

              · La possibilità di isolare i singoli  caratteri  assegnando  la
                strimga vuota ad FS ed al terzo argomento di split().

              · La  ricerca  tramite  percorso predefinito per i file indicati
                con l’opzione -f, e la variabile AWKPATH.

              · Il costrutto nextfile per abbandonare l’elaborazione del  file
                corrente.

              · Il costrutto delete array per cancellare l’intero contenuto di
                un vettore.

       Il manuale di AWK non definisce il valore di ritorno di  close().   Per
       Gawk,  close()  restituisce  il valore di fclose(3), per la chiusura di
       file ordinari, o pclose(3), per la chiusura di pipe.

       Quando gawk è lanciato con l’opzione --traditional,  e  l’argomento  fs
       dell’opzione  -F  è "t", ad FS è assegnato il carattere "tab".  Si noti
       che se si digita gawk -F\t ...  si ottiene solo di forzare la  shell  a
       considerare  "t"  alla  lettera,  e non di passare "\t" all’opzione -F.
       Poiché si tratta di  un  caso  particolare  abbastanza  brutto,  questo
       comportamento  non  ha luogo nella modalità ordinaria, e neppure quando
       si specifichi --posix.   Il  modo  migliore  per  definire  davvero  un
       carattere "tab" come separatore di campo è usare gli apici: gawk -F\t....

PRESTAZIONI STORICHE

       Gawk supporta due prestazioni caratteristiche delle prime realizzazioni
       di  AWK.  La prima è la possibilità di chiamare la funzione predefinita
       length() non solo senza argomenti, ma anche senza parentesi !  Così

              a = length     # Il sacro Algol 60, Batman!

       equivale a

              a = length()
              a = length($0)

       Questa prestazione è segnalata come "deprecabile" nello standard POSIX,
       e  gawk  emette  un  messaggio di avvertimento riguardo il suo uso se è
       specificata l’opzione --lint.

       La seconda prestazione "storica" è l’uso delle  istruzioni  continue  e
       break  fuori  dal  corpo  di  cicli  while,  for,  o  do.   Le versioni
       tradizionali  di   AWK   consideravano   tali   costrutti   equivalenti
       all’istruzione  next.   Gawk  permette questa sintassi se è specificato
       --traditional.

VARIABILI DAMBIENTE
       Se esiste la variabile d’ambiente POSIXLY_CORRECT, gawk  si  comporterà
       esattamente  come  se  fosse  stato  specificato --posix nella linea di
       comando.  Se è  specificato  --lint,  gawk  emetterà  un  messaggio  di
       avvertimento consono.

       Si  può  utilizzare  la  variabile di ambiente AWKPATH per indicare una
       lista di directory dove gawk cercherà i file indicati dalle opzioni  -f
       e --file.

BACHI

       L’opzione  -F  non  è necessaria, dato che è possibile l’assegnamento a
       variabili qualsiasi da linea di comando; rimane solo per  compatibilità
       all’indietro.

       Se  il  sistema  operativo  fornisce  un supporto per /dev/fd ed i file
       associati /dev/stdin, /dev/stdout, e  /dev/stderr,  gawk  può  produrre
       dati  in  uscita diversi da quelli che si avrebbero su sistemi privi di
       tale  supporto.   Quando  gawk  interpreta  quei   file   internamente,
       sincronizza  la  scrittura  sullo  standard  output con la scrittura su
       /dev/stdout, mentre su di  un  sistema  che  riconosca  quei  file,  la
       scrittura è attualmente diretta verso file descriptor diversi.  "Caveat
       emptor".

       I programmi contenenti singoli caratteri sintatticamente errati tendono
       a  riempire  lo  stack  dell’analizzatore  grammaticale,  generando  un
       messaggio  di  scarsa  utilità.  Programmi  di   questo   genere   sono
       sorprendentemente  difficili  da  diagnosticare nel caso generale, e lo
       sforzo per farlo non vale davvero il risultato.

INFORMAZIONI SULLA VERSIONE

       Questo manuale documenta gawk, versione 3.02.

AUTORI

       La versione originale di awk per UNIX è stata progettata  e  realizzata
       da  Alfred  Aho,  Peter  Weinberger,  e Brian Kernighan degli AT&T Bell
       Labs. Brian Kernighan ne continua la manutenzione ed il  miglioramento.

       Paul  Rubin  e  Jay  Fenlason,  della  Free  Software Foundation, hanno
       scritto  gawk  facendo  riferimeto  per  compatibilità  alla   versione
       originale  di  awk distribuita con Seventh Edition UNIX.  John Woods ha
       contribuito correggendo un buon numero di errori.  David  Trueman,  col
       contributo  di  Arnold  Robbins,  ha reso gawk compatibile con la nuova
       versione di UNIX awk.  Arnold Robbins è l’attuale manutentore.

       Il trasporto su DOS è stato fatto inizialmente da Conrad Kwok  e  Scott
       Garfinkle.   Scott  Deifik  è l’attuale responsabile della versione per
       DOS.  Pat Rankin ha curato il trasporto su  VMS,  e  Michal  Jaegermann
       quello  su  Atari  ST.  Il trasporto su OS/2  è stato realizzato da Kai
       Uwe Rommel, con l’aiuto di Darrel Hankerson.  Fred Fish ha prodotto  la
       versione per Amiga.

       Documentazione        tradotta        da        Giuseppe       Guerrini
       (giusguerrini@racine.ra.it).

SEGNALAZIONE DEI BACHI

       Chi trovasse bachi in gawk, può  segnalarli  per  posta  elettronica  a
       bug-gnu-util@prep.ai.mit.edu,       con       "carbon      copy"      a
       arnold@gnu.ai.mit.edu.  Si prega di specificare il tipo e  la  versione
       del  proprio  sistema  operativo,  la  versione di gawk, il compilatore
       utilizzato per compilarlo, ed un programma di prova completo  di  dati,
       il più corto possibile, che evidenzi il problema.

       Prima  di  inviare  una  segnalazione  di  baco, bisogna fare due cose.
       Innanzi tutto, verificare se si sta usando la versione più  recente  di
       gawk:  ogni  nuova  distribuzione corregge molti bachi, in genere i più
       subdoli; se quella in uso non è aggiornata, è probabile che il problema
       sia  già stato risolto.  La seconda cosa da fare è leggere attentamente
       queste pagine ed il manuale di riferimento, per essere sicuri  che  ciò
       che si pensa un errore non sia piuttosto un cavillo del linguaggio.

       Si  prega di NON inviare segnalazioni di bachi a comp.lang.awk.  Benché
       gli sviluppatori di gawk frequentino occasionalmente questo  newsgroup,
       inviare  lì le segnalazioni di bachi non è affidabile. Invitiamo invece
       tutti ad utilizzare gli indirizzi di posta elettronica dati sopra.

RINGRAZIAMENTI

       Ringraziamo Brian Kernighan dei Bell Labs, che  ha  dato  consideravole
       assistenza durante le fasi di test e debug.

COPYING PERMISSIONS (PERMESSI DI COPIA/RISTAMPA)

       NOTA  DEL  TRADUTTORE:  Il  testo  seguente   lasciato nella sua forma
       originale perch manca lapprovazione ufficiale della sua traduzione da
       parte  di  Free  Software  Foundation.  In  coda  alloriginale abbiamo
       aggiunto una versione in italiano, che per  da considerare  informale
       e   legalmente  non  valida.  Il  solo  testo  la  cui  presenza  renda
       ridistribuibile il documento, e la cui assenza configuri una violazione
       della licenza,  quello in lingua inglese.

       Copyright © 1996 Free Software Foundation, Inc.

       Permission  is  granted  to make and distribute verbatim copies of this
       manual page provided the copyright notice and  this  permission  notice
       are preserved on all copies.

       Permission  is granted to copy and distribute modified versions of this
       manual page under the conditions for verbatim  copying,  provided  that
       the  entire  resulting derived work is distributed under the terms of a
       permission notice identical to this one.

       Permission is granted to  copy  and  distribute  translations  of  this
       manual  page  into  another  language,  under  the above conditions for
       modified versions, except that this permission notice may be stated  in
       a translation approved by the Foundation.

PERMESSI DI COPIA/RISTAMPA [Traduzione non ufficiale, N.d.T.]

       Copyright  ©  1996 Free Software Foundation, Inc.  Proprietà letteraria
       della Free Software Foundation, 1996.

       È permesso stampare e distribure copie letterali di questa  pagina  del
       manuale, a patto che la nota di proprietà letteraria e questa parte sui
       permessi di ristampa siano preservate in tutte le copie.

       È permesso copiare e distribuire versioni modificate di  questa  pagina
       del  manuale, sotto le condizioni poste per la copia letterale, a patto
       che l’intero  lavoro  derivato  sia  distribuito  secondo  permessi  di
       ristampa identici a questi.

       È  permesso  copiare  e  distribuire  traduzioni  di  questa pagina del
       manuale in un’altra lingua, sotto le  condizioni  poste  sopra  per  le
       versioni modificate, salvo che quest’informazione sui permessi di copia
       e ristampa deve essere espressa in una traduzione approvata dalla  Free
       Software Foundation.