gawk

GAWK(1)                        Utility Commands                        GAWK(1)



NOME
       gawk - linguaggio per il riconoscimento e il trattamento di espressioni
       regolari

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 è l'implementazione nell'ambito del Progetto GNU del linguaggio
       di programmazione AWK .  Si attiene alla definizione del linguaggio
       descritta nello Standard POSIX 1003.1.  Questa versione è basata a sua
       volta sulla descrizione contenuta in The AWK Programming Language, di
       Aho, Kernighan e Weinberger.  Gawk fornisce le funzionalità aggiuntive
       presenti nella versione corrente di awk
        di Brian Kernighan e diverse estensioni specifiche di GNU.

       La riga di comando contiene opzioni per gawk stesso, il testo del
       programma AWK (se non è stato fornito con le opzioni -f o --file ), e
       valori da rendere disponibili nelle variabili AWK predefinite ARGC e
       ARGV .

       Quando gawk è invocato con l'opzione --profile , inizia a raccogliere
       statistiche sul comportamento del programma durante l'esecuzione.  Gawk
       in questa modalità è più lento, e produce automaticamente un profilo
       di esecuzione nel file awkprof.out alla fine dell'esecuzione.  Si veda
       l'opzione --profile più avanti.

       Gawk ha anche una capacità integrata di debugging.  Una sessione
       interattiva di analisi degli errori (debug) può essere iniziata
       fornendo l'opzione --debug sulla riga di comando.  In questa modalitÃ
       di esecuzione, gawk carica il codice sorgente di AWK e poi richiede
       l'inserimento di comandi di debug.  Gawk può analizzare solo il
       sorgente di un programma AWK fornito tramite l'opzione -f.  Il debugger
       è documentato in GAWK: Effective AWK Programming.

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
       funzionalità specifiche di GNU, sia per quelle previste da POSIX.

       Le opzioni specifiche di Gawk sono usate normalmente nella forma lunga.
       Gli argomenti delle opzioni in forma lunga possono essere uniti ad esse
       da un segno =, senza spazi, oppure sono indicati nel successivo
       argomento della riga di comando.  Le opzioni lunghe possono essere
       abbreviate, sempre che l'abbreviazione rimanga univoca.

       In aggiunta, ogni opzione lunga ha una corrispondente opzione corta, in
       modo che la funzionalità dell'opzione possa essere usata all'interno
       di script #!  eseguibili.

OPZIONI
       Gawk accetta le seguenti opzioni.  Le opzioni standard sono elencate
       per prime, seguite dalle opzioni per le estensioni gawk, elencate
       nell'ordine alfabetico delle opzioni corte.

       -f file_di_programma
       --file file_di_programma
              Legge il sorgente del programma AWK dal file file_di_programma,
              invece che dal primo argomento della riga di comando.  Si
              possono specificare più opzioni -f (o --file).

       -F fs
       --separatore_di_campo fs
              Usa fs come separatore di campo in input (il valore della
              variabile predefinita FS).

       -v var=val
       --assign var=val
              Assegna il valore val alla variabile var, prima che inizi
              l'esecuzione del programma.  Questi valori delle variabili sono
              messi a disposizione della regola BEGIN di un programma AWK.

       -b
       --characters-as-bytes
              Tratta tutti i dati in input come caratteri costituiti da un
              solo byte.  In altre parole, non presta alcuna attenzione alle
              informazioni sulla localizzazione quando tenta di elaborare
              stringhe come caratteri multibyte.  L'opzione --posix ignora
              questo comportamento.

       -c
       --traditional
              Viene eseguito in modalità compatibile.  In questa modalità ,
              gawk si comporta esattamente come awk di Brian Kernighan; non
              viene riconosciuta nessuna delle estensioni specifiche di GNU.
              Si veda ESTENSIONI GNU, più avanti, per maggiori informazioni.

       -C
       --copyright
              Stampa sullo standard output la versione sintetica del messaggio
              di informazione sul copyright GNU ed esce senza segnalare
              errori.

       -d[file]
       --dump-variables[=file]
              Stampa un lista ordinata di variabili globali, specificandone il
              tipo e il valore finale in file.  Se file non viene specificato,
              gawk usa un file chiamato awkvars.out nella directory corrente.
              Avere una lista di tutte le variabili globali è un buon modo
              per cercare errori tipografici nei programmi.  Questa opzione
              potrebbe essere usata anche se si ha un grosso programma con
              tantissime funzioni, e ci si vuole assicurare che le funzioni
              non usino inavvertitamente variabili globali che sono supposte
              essere locali (è facile commettere questo errore quando si
              usano nomi di variabili semplici come i, j, e così via).

       -D[file]
       --debug[=file]
              Abilita il debugging di programmi AWK.  Se non diversamente
              specificato, l'analizzatore di errori [debugger] legge i comandi
              in maniera interattiva dalla tastiera (standard input).
              L'argomento opzionale file specifica un file contenente un
              elenco di comandi per il debugger da eseguire in maniera non
              interattiva.

       -e testo_del_programma
       --source testo_del_programma
              Usa testo_del_programma come codice sorgente del programma AWK.
              Quest'opzione permette di combinare in modo semplice funzioni di
              libreria (usate attraverso i file indicati dalle opzioni -f e
              --file) con codice sorgente immesso sulla riga di comando.  Ã
              rivolta principalmente a programmi  AWK di media e grande
              dimensione usati all'interno di script di shell.

       -E file
       --exec file
              Simile a -f, comunque, quest'opzione è l'ultima ad essere
              elaborata.  Dovrebbe essere usata con script #!, specialmente
              per applicazioni CGI [Common Gateway Interface], per evitare di
              passare opzioni o codice (!) sulla riga di comando da un URL.
              Quest'opzione disabilita gli assegnamenti di variabile da riga
              di comando.

       -g
       --gen-pot
              Esamina e analizza il programma AWK, e genera un file in formato
              GNU .pot (Portable Object Template) sullo standard output con
              elementi relativi a tutte le stringhe localizzabili nel
              programma.  Il programma in sé non viene eseguito.  Si veda la
              distribuzione GNU gettext per maggiori informazioni sui file
              .pot .

       -h
       --help Scrive sullo standard output un riassunto abbastanza breve delle
              opzioni disponibili.  (In linea con le convenzioni di codifica
              GNU Coding Standards, queste opzioni provocano un'uscita
              immediata e senza segnalazione di errore.

       -i include-file
       --include include-file
              Carica una libreria di sorgenti awk.  Cerca la libreria usando
              la variabile d'ambiente AWKPATH.  Se la ricerca iniziale non va
              a buon fine, viene fatto un altro tentativo dopo aver aggiunto
              il suffisso .awk .  Il file verrà caricato solo una volta
              (cioè vengono ignorati i duplicati), e il codice non
              costituisce il sorgente del programma principale.

       -l lib
       --load lib
              Carica una libreria condivisa lib.  Cerca la libreria usando la
              variabile d'ambiente AWKLIBPATH .  Se la ricerca iniziale non va
              a buon fine, viene fatto un altro tentativo dopo aver aggiunto
              il suffisso della libreria condivisa predefinita per la
              piattaforma.  La procedura di inizializzazione della libreria si
              suppone avere come nome dl_load().

       -L [valore]
       --lint[=valore]
              Emette messaggi d'avvertimento relativi a costrutti dubbi o non
              portabili su altre implementazioni di AWK.  Con l'argomento
              opzionale fatal, gli avvertimenti lint sono considerati come
              errori fatali.  Questo può essere drastico, ma incoraggerÃ
              sicuramente lo sviluppo di programmi AWK più corretti.  Con
              l'argomento opzionale invalid, vengono emessi solo gli
              avvertimenti relativi a quello che è effettivamente non valido
              (funzionalità non ancora completamente implementata).

       -M
       --bignum
              Forza il calcolo con precisione arbitraria sui numeri.
              Quest'opzione non ha effetto se gawk non è compilato per l'uso
              delle librerie GNU MPFR e MP.

       -n
       --non-decimal-data
              Riconosce valori ottali ed esadecimali nei dati in input.  Usare
              quest'opzione con molta cautela!

       -N
       --use-lc-numeric
              Forza gawk a usare il carattere di separazione decimale della
              localizzazione quando analizza i dati in input.  Sebbene lo
              standard POSIX richieda questo comportamento, e gawk faccia
              questo quando l'opzione --posix è attiva, il comportamento
              predefinito è quello tradizionale di usare il punto come
              separatore decimale, anche per le localizzazioni in cui il
              carattere di separazione non è il punto.  Quest'opzione ignora
              il comportamento predefinito, senza il rigore draconiano
              dell'opzione --posix .

       -o[file]
       --pretty-print[=file]
              Stampa una versione formattata graziosamente del programma su
              file.  Se non viene indicato un file, gawk usa un file di nome
              awkprof.out nella directory corrente.  Sottintende
              --no-optimize.

       -O
       --optimize
              Abilita le ottimizzazioni predefinite di gawk nella
              rappresentazione interna del programma.  Attualmente, questo
              comprende il calcolo di costanti, se possibile, al momento della
              compilazione, e l'eliminazione della chiamata di coda per
              funzioni ricorsive. Questa opzione è attiva in modo
              predefinito.

       -p[prof-file]
       --profile[=prof-file]
              Inizia una sessione di "profiling", e invia i dati tracciati al
              file prof-file.  Quello predefinito è awkprof.out.  Il profilo
              contiene il numero di esecuzioni di ogni istruzione sul margine
              sinistro e il conteggio delle chiamate di funzione per ogni
              funzione definita dall'utente.  Sottindende --no-optimize.

       -P
       --posix
              Quest'opzione attiva la modalità di compatibilità , con le
              seguenti restrizioni aggiuntive:

              · Le sequenze di protezione \x non vengono riconosciute.

              · Non è possibile continuare le righe dopo ?  e :.

              · Non viene riconosciuto il sinonimo func per la parola chiave
                function .

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

       -r
       --re-interval
              Abilita l'uso di espressioni di intervallo nelle espressioni
              regolari (si veda Espressioni regolari, più avanti).  Nel
              linguaggio AWK le espressioni di intervallo non sono mai state
              disponibili.  Lo standard POSIX le ha aggiunte, per rendere awk
              ed egrep coerenti tra di loro.  Sono abilitate in modalitÃ
              predefinita, però quest'opzione rimane per essere usata con
              l'opzione --traditional.

       -s
       --no-optimize
              Disabilita le ottimizzazioni predefinite di gawk nella
              rappresentazione interna del programma.

       -S
       --sandbox
              Esegue gawk in modalità "sandbox", disabilitando la funzione
              system(), la ridirezione dell'input con getline, la ridirezione
              sull'output con print e printf, e il caricamento delle
              estensioni dinamiche.  L'esecuzione di comandi (tramite
              pipeline) è anch'essa disabilitata.  Questo impedisce
              completamente l'accesso di uno script alle risorse locali
              (tranne che per i file specificati nella riga di comando).

       -t
       --lint-old
              Emette messaggi d'avvertimento relativi a costrutti non
              portabili sulla versione originale di awk per UNIX.

       -V
       --version
              Scrive sullo standard output la versione di questa particolare
              copia di gawk.  Ã utile principalmente per sapere se la copia di
              gawk attualmente installata è aggiornata rispetto a ciò che
              Free Software Foundation sta distribuendo.  Ã utile anche quando
              si devono segnalare degli errori.  (In linea con le convenzioni
              di codifica GNU Coding Standards, queste opzioni provocano
              un'uscita immediata e senza segnalazione di errore.)

       --     Segnala la fine delle opzioni. à utile perché permette di
              passare al programma AWK ulteriori argomenti [nomi di file] che
              iniziano con “-”.  Questo assicura una coerenza con le
              convenzioni di esame degli argomenti usato dalla maggior parte
              dei programmi POSIX .

       In modalità compatibile, qualsiasi altra opzione è contrassegnata
       come non valida e viene ignorata.  Nell'uso normale, sempre che sia
       stato fornito il testo del programma, le opzioni sconosciute sono
       passate al programma AWK nel vettore ARGV per l'elaborazione.  Questo
       è particolarmente utile per eseguire i programmi AWK attraverso il
       meccanismo dell'interprete eseguibile “#!”.

       Per compatibilità con POSIX, si può usare l'opzione -W , seguita dal
       nome di un'opzione lunga.

ESECUZIONE DEL PROGRAMMA AWK
       Un programma AWK consiste di una sequenza di istruzioni di tipo
       criterio-azione e di definizioni di funzione opzionali.

              @include "nome_del_file"
              @load "nome_del_file"
              criterio di ricerca { istruzioni di azione }
              function nome(lista di parametri) { istruzioni }

       Gawk prima legge il codice del programma dal/dai file_di_programma se
       specificato/i, dagli argomenti passati a --source, o dal primo
       argomento sulla riga di comando che non sia un'opzione.  Le opzioni -f
       e --source possono essere usate più volte nella riga di comando.  Gawk
       legge il testo del programma come se tutti i file_di_programma e i
       testi sorgenti della riga di comando fossero concatenati.  Questo
       permette di realizzare librerie di funzioni AWK senza bisogno di
       includerle in ogni nuovo programma AWK che le usi; inoltre si possono
       combinare funzioni di libreria con programmi provenienti dalla riga di
       comando.

       Oltre a ciò, le righe che iniziano con @include possono essere usate
       per includere altri file sorgenti nel programma, rendendo l'uso della
       libreria ancora più facile.  Questo è equivalente all'uso
       dell'opzione -i.

       Le righe che iniziano con @load possono essere usate per caricare
       librerie condivise nel programma.  Questo è equivalente all'uso
       dell'opzione -l.

       La variabile d'ambiente AWKPATH specifica il percorso lungo il quale
       cercare i file sorgenti indicati con le opzioni -f e -i.  Se questa
       variabile non esiste, il percorso predefinito è "/usr/local/share/awk"
       (la directory in questione può variare a seconda di come gawk è stato
       compilato e installato).  Se un nome di file dato con l'opzione -f
       contiene un carattere “/”, non viene eseguita nessuna ricerca sul
       percorso.

       La variabile d'ambiente AWKLIBPATH specifica il percorso lungo il quale
       cercare i file sorgenti indicati con l'opzione -l , Se questa variabile
       non esiste, il percorso predefinito è "/usr/local/lib/gawk" (la
       directory in questione può variare a seconda di come gawk è stato
       compilato e installato).

       Gawk esegue i programmi AWK nell'ordine seguente.  Per prima cosa,
       vengono effettuati tutti gli assegnamenti di variabile indicati
       dall'opzione -v.  Successivamente, gawk compila il programma in un
       formato interno.  Poi gawk esegue il codice nella regola/e BEGIN (se
       esistente/i), quindi procede con la lettura di ciascun file indicato
       nel vettore ARGV (fino a ARGV[ARGC]).  Se non ci  sono file indicati
       nella riga di comando, gawk legge dallo standard input.

       Se un nome di file nella riga di comando ha la forma var=val, è
       trattato come un assegnamento di variabile.  Alla variabile var sarÃ
       assegnato il valore val (questo accade dopo che ogni regola BEGIN è
       stata eseguita).  L'assegnamento di variabili da riga di comando è
       utilissima per assegnare dinamicamente valori alle variabili che AWK
       usa per controllare come l'input è organizzato in campi e record.  Ã
       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 file in input, se esiste una regola BEGINFILE, gawk esegue il
       codice associato prima di elaborare il contenuto del file.
       Similarmente, gawk esegue il codice associato a ENDFILE dopo
       l'elaborazione del file.

       Per ogni record in input, gawk controlla se c'è corrispondenza con
       qualche criterio di ricerca specificato nel programma AWK.  Per ogni
       criterio di ricerca a cui un record corrisponde, gawk esegue l'azione
       associata.  I criteri di ricerca sono verificati nell'ordine in cui
       appaiono nel programma.

       Infine, dopo che sono esauriti i dati in input, gawk esegue il codice
       nelle regola/e END (se esistente/i),

   Directory nella riga di comando
       Secondo POSIX, i file indicati sulla riga di comando di awk devono
       essere file di testo.  Se non lo sono il comportamento è
       ``indefinito''.  La maggior parte delle versioni di awk considerano una
       directory sulla riga di comando come un errore fatale.

       A partire dalla versione 4.0 di gawk, una directory sulla riga di
       comando produce solo un messaggio di avvertimento, senza conseguenze.
       Se sono date le opzioni --posix o --traditional gawk ritorna a trattare
       le directory sulla riga di comando come errore fatale.

VARIABILI, RECORD E CAMPI
       Le variabili di AWK sono dinamiche; iniziano a esistere la prima volta
       che vengono usate.  I loro valori sono numeri in virgola mobile, o
       stringhe, o entrambe le cose, a seconda di come sono usati la prima
       volta.  Inoltre AWK dispone di vettori monodimensionali; i vettori
       multidimensionali possono essere simulati [da vettori
       monodimensionali].  Gawk fornisce veri vettori di vettori; si veda
       Vettori, più avanti.  Al momento dell'esecuzione 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 assegnando valori
       alla variabile predefinita RS.  Se RS contiene un qualsiasi carattere
       singolo, tale carattere separa i record.  Altrimenti, se RS è
       un'espressione regolare, il testo nell'input che corrisponde a questa
       espressione regolare sarà il separatore di record.  Tuttavia, nella
       modalità compatibile è preso in considerazione solo il primo
       carattere della stringa risultante, 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, quale che esso 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
       carattere singolo, i campi sono separati da quel carattere.  Se FS è
       la stringa nulla, ogni singolo carattere diventa un campo a sé.
       Diversamente, si presume che FS sia un'espressione regolare completa.
       Nel caso particolare in cui FS sia un singolo spazio, i campi sono
       separati da sequenze di spazi, caratteri di tabulazione o newline.
       NOTA: Il valore di IGNORECASE (vedi più avanti) influenza anche il
       modo in cui i campi sono spezzati quando FS è un'espressione regolare,
       e come i record vengano separati quando RS è un'espressione regolare.

       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 o a FPAT si annulla
       l'effetto di FIELDWIDTHS.

       Similmente, se alla variabile FPAT è assegnata una stringa che
       rappresenta un'espressione regolare, ogni campo è composto di testo
       che corrisponde a quella espressione regolare.  In questo caso,
       l'espressione regolare descrive i campi stessi, invece che il testo che
       separa i campi.  Assegnando un nuovo valore a FS o a FIELDWIDTHS si
       annulla l'effetto di FPAT.

       Ogni campo nel record in input può essere individuato dalla sua
       posizione: $1, $2, e così via.  $0 è l'intero record.  Non è
       necessario che i campi siano indicati da costanti:

              n = 5
              print $n

       stampa il quinto campo del record in input.

       La variabile NF contiene il numero di campi nel record in input.

       Riferimenti a campi inesistenti (cioè campi dopo $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.

       L'assegnamento di un valore a un campo esistente provoca la
       ricostruzione dell'intero record quando si faccia riferimento a $0.
       Analogamente, assegnare un valore a $0 provoca una nuova divisione del
       record, creando nuovi valori per i suoi campi.

   Variabili predefinite
       Le variabili predefinite di gawk sono:

       ARGC        Il numero di argomenti da riga di comando (non include le
                   opzioni di gawk o il sorgente del programma).

       ARGIND      L'indice in ARGV del file correntemente in elaborazione.

       ARGV        Vettore degli argomenti della riga di comando.  Il vettore
                   è indicizzato da 0 ad ARGC - 1.  La modifica dinamica del
                   contenuto di ARGV può controllare i file usati per i dati.

       BINMODE     Su sistemi non-POSIX, specifica l'uso della modalitÃ
                   “binaria” per tutti i file I/O.  I valori numerici 1, 2 e 3
                   specificano che i file di input, i file di output e tutti i
                   file, rispettivamente, dovrebbero usare I/O binari.  I
                   valori di stringa "r" e "w" specificano che i file di input
                   e i file di output, rispettivamente, dovrebbero usare I/O
                   binari.  I valori di stringa "rw" e "wr" specificano che
                   tutti i file dovrebbero usare I/O binari.  Qualsiasi altro
                   valore di stringa è trattato come "rw", ma genera un
                   messaggio di avvertimento.

       CONVFMT     Il formato di conversione dei numeri, quello predefinito è
                   "%.6g".

       ENVIRON     Un vettore contenente i valori dell'ambiente corrente.  Il
                   vettore è indicizzato dalle variabili d'ambiente, e ogni
                   elemento è il valore di quella variabile (per esempio,
                   ENVIRON["HOME"] potrebbe essere "/home/arnold").

                   In modalità POSIX, la modifica di questo vettore non ha
                   effetto sull'ambiente ereditato dai programmi che gawk
                   esegue per ridirezione o tramite la funzione system().
                   Altrimenti, gawk aggiorna il suo ambiente reale in modo che
                   i programmi che eredita vedano le modifiche.

       ERRNO       Se ha luogo un errore di sistema durante una ridirezione
                   per una getline, o durante una lettura fatta con getline,
                   oppure in una close(), ERRNO conterrà una stringa che
                   descrive l'errore.  Il valore è passibile di traduzione
                   nelle localizzazioni diverse dall'inglese.  Se la stringa
                   in ERRNO corrisponde a un errore di sistema descritto nella
                   variabile errno(3), il corrispondente valore numerico può
                   essere trovato in PROCINFO["errno"].  Per errori non di
                   sistema, l'elemento PROCINFO["errno"] varrà zero.

       FIELDWIDTHS Una lista di dimensioni di campo separate da spazi. Se
                   impostato, gawk suddivide l'input secondo campi di
                   larghezza fissa, anziché usare il valore della variabile
                   FS come separatore di campo.  Si veda Campi, più sopra.

       FILENAME    Il nome del file di input corrente.  Se non sono
                   specificati file nella riga di comando, il valore di
                   FILENAME è “-”.  Tuttavia, FILENAME è indefinito
                   all'interno della regola BEGIN (a meno che non sia
                   impostato da getline).

       FNR         Il numero di record corrente del file in input corrente.

       FPAT        Un'espressione regolare che descrive il contenuto dei campi
                   in un record.  Se impostato, gawk suddivide l'input in
                   campi, dove i campi corrispondono all'espressione regolare,
                   invece di usare il valore della variabile FS come
                   separatore di campo.  Si veda Campi, più sopra.

       FS          Il separatore di campo, quello predefinito è uno spazio.
                   Si veda Campi, più sopra.

       FUNCTAB     Un vettore i cui indici e i corrispondenti valori sono i
                   nomi di tutte le funzioni definite dall'utente o funzioni
                   di estensione presenti nel programma.  NOTA: Si può non
                   usare l'istruzione delete applicandola al vettore FUNCTAB.

       IGNORECASE  Controlla la sensibilità alla distinzione tra maiuscole e
                   minuscole in tutte le espressioni regolari e nelle
                   operazioni sulle stringhe.  Se IGNORECASE ha un valore
                   diverso da zero, il confronto di stringhe e la ricerca di
                   corrispondenze nei criteri di ricerca, la separazione di
                   campi tramite FS e FPAT, la separazione di record tramite
                   RS, la ricerca di corrispondenze nelle espressioni regolari
                   con ~ e !~, e le funzioni predefinite gensub(), gsub(),
                   index(), match(), patsplit(), split(), e sub() ignoreranno
                   tutti la differenza tra maiuscole e minuscole nelle
                   operazioni con le espressioni regolari.  NOTA: Non ha
                   effetto sugli indici dei vettori.  Tuttavia, sulle funzioni
                   asort() e asorti() ha effetto.
                   Così, se IGNORECASE è diverso da zero, /aB/ corrisponde a
                   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 sulle espressioni
                   regolari e su stringhe normalmente distinguono tra
                   maiuscole e minuscole.

       LINT        Fornisce un controllo dinamico dell'opzione --lint
                   dall'interno di un programma AWK.  Quando il valore è
                   "vero", gawk stampa avvertimenti lint. Quando è "falso",
                   no.  Assegnando il valore di stringa "fatal", gli
                   avvertimenti lint sono considerati errori fatali,
                   esattamente come --lint=fatal.  Qualsiasi altro valore
                   "vero" stampa solo avvertimenti.

       NF          Il numero di campi nel record corrente.

       NR          Il numero totale di record incontrati finora.

       OFMT        Il formato d'uscita per i numeri, quello predefinito è
                   "%.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").

       PREC        La precisione di lavoro di numeri a virgola mobile con
                   precisione arbitraria, 53 [bit] è il valore predefinito.

       PROCINFO    Gli elementi di questo vettore forniscono accesso alle
                   informazioni sul programma  AWK in esecuzione.  Su alcuni
                   sistemi, ci possono essere elementi nel vettore, da
                   "gruppo1" a "gruppon" per qualsiasi n, che è il numero di
                   gruppi supplementari che ha il processo.  Usare l'operatore
                   in per verificare la presenza di questi elementi.  I
                   seguenti elementi sono sicuramente disponibili:

                   PROCINFO["egid"]     Il valore della chiamata di sistema
                                        getegid(2).

                   PROCINFO["errno"]    Il valore di errno(3) quando ERRNO è
                                        impostato al messaggio di errore
                                        associato.

                   PROCINFO["euid"]     Il valore della chiamata di sistema
                                        geteuid(2).

                   PROCINFO["FS"]       "FS" se la separazione in campi con FS
                                        è attiva, "FPAT" se la separazione in
                                        campi con FPAT è attiva, o
                                        "FIELDWIDTHS" se la separazione in
                                        campi con FIELDWIDTHS è attiva.

                   PROCINFO["gid"]      Il valore della chiamata di sistema
                                        getgid(2).

                   PROCINFO["identifiers"]
                                        Un sottovettore, avente come indici i
                                        nomi di tutti gli identificatori usati
                                        nel testo del programma AWK.  I valori
                                        indicano quello che gawk conosce degli
                                        identificatori dopo aver finito di
                                        analizzare il programma; essi non sono
                                        aggiornati durante l'esecuzione del
                                        programma.  Per ogni identificatore,
                                        il valore dell'elemento è uno fra
                                        questi:

                                        "array"     L'identificatore è un
                                                    vettore.

                                        "builtin"   L'identificatore è una
                                                    funzione predefinita.

                                        "extension" L'identificatore è una
                                                    funzione di estensione
                                                    caricata con @load o -l.

                                        "scalar"    L'identificatore è uno
                                                    scalare.

                                        "untyped"   L'identificatore non è
                                                    classificato (potrebbe
                                                    essere usato come scalare
                                                    o come vettore, gawk
                                                    ancora non lo sa).

                                        "user"      L'identificatore è una
                                                    funzione definita
                                                    dall'utente.

                   PROCINFO["pgrpid"]   Il process group ID del processo
                                        corrente.

                   PROCINFO["pid"]      L'ID di processo del processo
                                        corrente.

                   PROCINFO["ppid"]     Il process ID del "padre" [parent] del
                                        processo corrente.

                   PROCINFO["strftime"] La stringa di formato data/ora
                                        predefinita per strftime().

                   PROCINFO["uid"]      Il valore della chiamata di sistema
                                        getuid(2).

                   PROCINFO["version"]  la versione di gawk.

                   I seguenti elementi sono presenti se è disponibile il
                   caricamento delle estensioni dinamiche.

                   PROCINFO["api_major"]
                          La versione principale dell'estensione API.

                   PROCINFO["api_minor"]
                          La versione secondaria dell'estensione API.

                   I seguenti elementi sono disponibili se il supporto MPFR è
                   stato compilato in gawk:

                   PROCINFO["gmp_version"]
                          La versione della libreria GNU MP usata per il
                          supporto ai numeri con precisione arbitraria in
                          gawk.

                   PROCINFO["mpfr_version"]
                          La versione della libreria GNU MPFR usata per il
                          supporto ai numeri con precisione arbitraria in
                          gawk.

                   PROCINFO["prec_max"]
                          La massima precisione supportata dalla libreria GNU
                          MPFR per i numeri a virgola mobile con precisione
                          arbitraria.

                   PROCINFO["prec_min"]
                          La minima precisione supportata dalla libreria GNU
                          MPFR per i numeri a virgola mobile con precisione
                          arbitraria.

                   I seguenti elementi possono essere impostati da un
                   programma per cambiare il comportamento di gawk:

                   PROCINFO["NONFATAL"]
                          Se è presente, gli errori di I/O per tutte le
                          ridirezioni verso l'output diventano non fatali.

                   PROCINFO["nome_output", "NONFATAL"]
                          Rendono gli errori relativi a nome_output non
                          fatali.

                   PROCINFO["comando", "pty"]
                          Usa una pseudo-tty per una comunicazione
                          bidirezionale con comando invece di impostare due
                          "pipe" unidirezionali.

                   PROCINFO["input", "READ_TIMEOUT"]
                          Il tempo massimo a disposizione in millisecondi per
                          leggere i dati da input, dove input è una stringa
                          di ridirezione o un nome di file.  Un valore di zero
                          o o minore di zero significa nessun limite di tempo.

                   PROCINFO["input", "RETRY"]
                          Se un errore di I/O non fatale si verifica leggendo
                          dati da un file di input, e questo elemento di
                          vettore esiste, getline restituirà -2 invece di
                          restituire il valore previsto di -1 e di configurare
                          l'input in modo da non fornire ulteriori dati.  Un
                          errore di I/O non fatale si verifica quando errno(3)
                          ha il valore EAGAIN, EWOULDBLOCK, EINTR o ETIMEDOUT.
                          Questo può tornare utile nel caso si utilizzi
                          PROCINFO["input", "READ_TIMEOUT"] o in situazioni in
                          cui un descrittore di file è stato configurato in
                          modo da non bloccarsi in caso di errore.

                   PROCINFO["sorted_in"]
                          Se questo elemento esiste in PROCINFO, il suo valore
                          controlla l'ordine in cui gli elementi del vettore
                          sono attraversati nei cicli for.  I valori
                          supportati sono "@ind_str_asc", "@ind_num_asc",
                          "@val_type_asc", "@val_str_asc", "@val_num_asc",
                          "@ind_str_desc", "@ind_num_desc", "@val_type_desc",
                          "@val_str_desc", "@val_num_desc", e "@unsorted".  Il
                          valore può essere anche il nome (come stringa) di
                          una qualsiasi funzione di confronto definita nel
                          seguente modo:

                               function cmp_func(i1, v1, i2, v2)

                          dove i1 e i2 sono gli indici, e v1 e v2 sono i
                          valori corrispondenti dei due elementi che si stanno
                          confrontando.  Dovrebbe restituire un numero minore,
                          uguale o maggiore di 0, a seconda di come devono
                          essere ordinati gli elementi del vettore.


                   ROUNDMODE
                          La modalità di arrotondamento da usare per
                          operazioni sui numeri con precisione arbitraria,
                          quella predefinita è "N" (IEEE-754 roundTiesToEven
                          mode).  Sono accettati i valori "N" o "n" per
                          roundTiesToEven, "U" o "u" per roundTowardPositive,
                          "D" o "d" per roundTowardNegative, "Z" o "z" per
                          roundTowardZero e, se la versione della libreria GNU
                          MPFR in uso li supporta, "A" o "a" per
                          roundTiesToAway.

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

                   RT     Il terminatore di record.  Gawk pone RT uguale al
                          testo in input che corrisponde al carattere o alla
                          espressione regolare indicati in RS.

                   RSTART L'indice del primo carattere trovato da match(),
                          oppure 0 se non ci sono corrispondenze (questo
                          implica che gli indici dei caratteri inizino da
                          uno).

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

                   SUBSEP Il carattere usato per separare indici multipli
                          negli elementi di un vettore, quello predefinito è
                          "\034".

                   SYMTAB Un vettore i cui indici sono i nomi di tutti i
                          vettori e le variabili globali attualmente definite
                          presenti nel programma.  Il vettore può essere
                          usato per l'accesso indiretto in lettura e scrittura
                          del valore di una variabile:

                               foo = 5
                               SYMTAB["foo"] = 4
                               print foo    # stampa 4

                          La funzione isarray() può essere usata per
                          controllare se un elemento in SYMTAB è un vettore.
                          Non è possibile usare l'istruzione delete per il
                          vettore SYMTAB .

                   TEXTDOMAIN
                          Il dominio di testo del programma AWK ; usato per
                          trovare le traduzioni localizzate delle stringhe del
                          programma.

   Vettori
       I vettori hanno per indice 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, separati dal valore della
       variabile SUBSEP .  Questa modalità è usata 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 che è
       indicizzato dalla stringa "A\034B\034C".  In AWK, tutti i vettori sono
       associativi, cioè indicizzati da valori di tipo stringa.

       L'operatore speciale in può essere usato per controllare se un vettore
       contiene un certo valore come indice.

              if (val in vettore)
                   print vettore[val]

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

       Il costrutto in può anche essere usato in un ciclo for per iterare su
       tutti gli elementi di un vettore.  Comunque,  il costrutto (i, j) in
       vettore funziona solo nelle verifiche, non nei cicli for.

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

       gawk supporta veri vettori multidimensionali.  Non richiede che tali
       vettori siano ``rettangolare'' come in C or C++.  Per esempio:

              a[1] = 5
              a[2][1] = 6
              a[2][2] = 7

       NOTA: Si potrebbe aver necessità di dire a gawk che un elemento di un
       vettore è in realtà un sottovettore per usarlo dove gawk si aspetta
       di trovare un vettore (come nel secondo argomento di split()).  Si può
       fare questo creando un elemento nel sottovettore e cancellandolo poi
       con l'istruzione delete .

   Notazione e conversione delle variabili
       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 un numero; usato come stringa, sarà trattato come tale.

       Per far trattare una variabile come numero, le si sommi 0; per ottenere
       che venga trattata come come stringa, le si concateni la stringa nulla.

       Le variabili non inizializzate hanno sia il valore numerico 0 che il
       valore di stringa "" (la stringa nulla, o vuota).

       Quando una stringa deve essere convertita in un numero, la conversione
       è compiuta con strtod(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 in numeri 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".

       NOTA: Quando si opera in modalità POSIX (come con l'opzione --posix),
       bisogna fare attenzione che le impostazioni per la localizzazione
       possono interferire col modo in cui sono trattati i numeri decimali: il
       separatore decimale dei numeri che si forniscono a gawk deve essere
       conforme a quello che si aspetta la localizzazione in uso, che sia un
       punto (.) o una virgola (,).

       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 “stringa numerica,” sono
       pure confrontate numericamente.  Negli altri casi, gli eventuali valori
       numerici sono convertiti in stringhe, ed è eseguito un confronto tra
       stringhe.  Ovviamente, due stringhe sono confrontate come stringhe.

       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'input di getline, a FILENAME, agli elementi
       di ARGV di ENVIRON , ed agli elementi di un vettore creato da split() o
       da patsplit() che abbiano le caratteristiche di una stringa numerica.
       L'idea fondamentale è che i dati immessi dall'utente, e solo essi, se
       risultano essere numerici, saranno trattati come numeri.

   Costanti ottali ed esadecimali
       Nel codice sorgente del programma si possono usare costanti ottali ed
       esadecimali in stile C.  Per esempio, il valore ottale 011 è uguale al
       decimale 9, e il valore esadecimale 0x11 è uguale al decimale 17.

   Costanti di tipo stringa
       Le costanti stringa in AWK sono sequenze di caratteri racchiusi tra
       doppi apici (come "valore").  All'interno delle stringhe, sono
       riconosciute alcune sequenze di protezione, come in in C.  Queste sono:

       \\   Una barra inversa letterale.

       \a   Il carattere “alert”; in genere il carattere ASCII BEL.

       \b   Tasto di cancellazione all'indietro (backspace).

       \f   Salto pagina (form-feed).

       \n   Nuova riga (newline).

       \r   Ritorno carrello (CR).

       \t   Tabulazione orizzontale.

       \v   Tabulazione verticale.

       \xcifre_esa
            Il carattere rappresentato dalla stringa di cifre esadecimali dopo
            la \x.  Fino a due cifre esadecimali che seguono sono considerate
            parte della sequenza di protezione.  Per esempio, "\x1B" è il
            carattere ASCII ESC (escape).

       \ddd Il carattere rappresentato da una sequenza di 3 cifre ottali.  Per
            esempio, "\033" è il carattere ASCII ESC (escape).

       \c   Il carattere letterale c.

       Le sequenze di protezione possono essere usate anche all'interno di
       espressioni regolari utilizzate come costanti (per esempio,
       /[ \t\f\n\r\v]/ corrisponde a spazi vuoti).

       In modalità compatibile, i caratteri rappresentati da sequenze di
       protezione ottali ed esadecimali sono trattati letteralmente, se usati
       in costanti costituite da espressioni regolari.  Così, /a\52b/ è
       equivalente a /a\*b/.

CRITERI DI RICERCA E AZIONI
       AWK è un linguaggio che procede per righe.  Il criterio va a inizio
       riga, l'azione lo segue.  Le istruzioni dell'azione sono racchiuse tra
       { e }.  Sia il criterio che l'azione possono mancare ma, naturalmente,
       non entrambi.  Se manca il criterio, l'azione è eseguita per ogni
       record in input.  Omettere invece l'azione equivale a specificare

              { print }

       ossia stampare 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 alla fine della riga, a meno che non termini con
       una virgola, {, ?, :, &&, 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 il
       "newline" è ignorato.

       Si possono scrivere più istruzioni sulla stessa riga separandole con
       “;”.  Questo si applica sia alle istruzioni all'interno di un'azione
       (il caso più comune), sia ai gruppi criterio-azione stessi.

   Criteri di ricerca
       I criteri di ricerca di AWK possono assumere le forme seguenti:

              BEGIN
              END
              BEGINFILE
              ENDFILE
              /espressione regolare/
              espressione di relazione
              criterio && criterio
              criterio || criterio
              criterio ? criterio : criterio
              (criterio)
              ! criterio
              criterio1, criterio2

       BEGIN e END sono due tipi speciali di criteri di ricerca, che non
       dipendono dai dati in input.  Le azioni di tutti i criteri di ricerca
       BEGIN sono unite insieme, come se tutte le istruzioni fossero scritte
       in un'unica regola BEGIN , e sono eseguite prima che sia letto
       qualsiasi input.  Allo stesso modo, tutte le regole END sono fuse
       insieme, ed eseguite dopo che tutti i dati in input sono terminati o
       dopo che si è incontrata l'istruzione exit .  BEGIN e END non possono
       essere combinati con altri criteri in espressioni di ricerca.  I
       criteri BEGIN e END devono necessariamente essere seguiti
       dall'indicazione di un'azione

       BEGINFILE e ENDFILE sono altri criteri speciali il cui contenuto è
       eseguito prima della lettura del primo record di ogni file di input
       richiamato sulla riga di comando, e dopo la lettura dell'ultimo record
       di ognuno di questi file.  All'interno della regola BEGINFILE il valore
       di ERRNO sarà una stringa vuota se il file è stato aperto con
       successo.  Altrimenti, in caso di problemi col file il codice dovrebbe
       usare nextfile per saltarlo.  Se non lo fa, gawk emette il solito
       errore fatale per i file che non possono essere aperti.

       Per i criteri del tipo /espressione regolare/ l'azione associata è
       eseguita per ogni record in input che corrisponde all'espressione
       regolare.  Le espressioni regolari 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
       siano individuati da determinate espressioni regolari.

       Gli operatori &&, ||, e !  sono rispettivamente l'AND logico, l'OR
       logico e il NOT logico.  Come i loro equivalenti del linguaggio C, sono
       valutati 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 ricerca più
       semplici.  Come nella maggior parte dei linguaggi, si possono usare
       parentesi per cambiare l'ordine di valutazione.

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

       Un'espressione nella forma criterio1, criterio2 è detta criterio
       intervallo.  Essa individua tutti i record a partire da quello che ha
       corrispondenza con criterio1, fino a quello che corrisponde a
       criterio2, compreso.  Non può essere combinata con alcun'altra
       espressione.

   Espressioni regolari
       Le espressioni regolari sono del tipo esteso che si trova in egrep.
       Sono composte da caratteri secondo le regole seguenti:

       c          Corrisponde al carattere (non speciale) c.

       \c         Corrisponde al carattere c considerato letteralmente.

       .          Corrisponde a qualsiasi carattere, compreso "newline".

       ^          Corrisponde all'inizio di una stringa.

       $          Corrisponde alla fine di una stringa.

       [abc...]   Una lista di caratteri: corrisponde a uno qualsiasi dei
                  caratteri abc....  Si possono includere intervalli di
                  caratteri separandoli con un trattino.

       [^abc...]  Una lista di caratteri negata: corrisponde a qualsiasi
                  carattere eccetto abc....

       r1|r2      Alternativa: corrisponde a r1 oppure a r2.

       r1r2       Concatenazione: corrisponde a r1, e poi r2.

       r+         Corrisponde a una o più r.

       r*         Corrisponde a zero o più r.

       r?         Corrisponde a zero o una r.

       (r)        Raggruppamento: corrisponde a r.

       r{n}
       r{n,}
       r{n,m}     Uno o due numeri racchiusi tra parentesi graffe indicano una
                  espressione di intervallo.  Se c'è un numero tra parentesi
                  graffe, l'espressione regolare che precede r è ripetuta n
                  volte. Se tra parentesi 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.

       \y         Corrisponde alla stringa vuota all'inizio o alla fine di una
                  parola.

       \B         Corrisponde alla stringa vuota all'interno di una parola.

       \<         Corrisponde alla stringa vuota all'inizio di una parola.

       \>         Corrisponde alla stringa vuota alla fine di una parola.  \s
                  Corrisponde a qualsiasi spazio vuoto.

       \S         Corrisponde a qualsiasi carattere che non sia uno spazio
                  vuoto.

       \w         Corrisponde a un qualsiasi carattere che possa far parte di
                  una parola, cioè lettere, numeri o trattino basso).

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

       \`         Corrisponde alla stringa vuota all'inizio di una stringa.

       \'         Corrisponde alla stringa vuota alla fine di una stringa.

       Le sequenze di protezione valide all'interno delle costanti stringa (si
       veda Costanti di tipo stringa) sono ammesse anche nelle espressioni
       regolari.

       Le classi di caratteri sono una nuova funzionalità introdotta nello
       standard POSIX.  Una classe di caratteri è una speciale notazione per
       indicare liste di caratteri accomunati da uno specifico attributo, dove
       però i caratteri veri e propri possono variare a seconda della nazione
       e del set di caratteri.  Per esempio, la nozione di "carattere
       alfabetico" valida negli Stati Uniti è diversa da quella valida in
       Francia.

       Una classe di caratteri è ammessa solo all'interno delle parentesi
       quadre di una lista di caratteri di una espressione regolare.  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 set di caratteri vigente avesse compreso
       altri caratteri alfanumerici, l'espressione non li avrebbe
       riconosciuti, e se il set di caratteri fosse rappresentato in modo
       diverso da ASCII, non sarebbero riconosciuti neanche i caratteri
       alfanumerici ASCII.  Con le classi di caratteri POSIX, si può scrivere
       /[[:alnum:]]/, che troverà corrispondenza con i caratteri alfabetici e
       numerici previsti dal set di caratteri in uso, qualunque esso sia.

       Nelle liste di caratteri possono comparire due sequenze speciali
       aggiuntive. Esse si applicano ai set di caratteri non ASCII, i quali
       possono comprendere sia simboli singoli (chiamati elementi di
       collazione) rappresentati da più di un carattere, sia gruppi di
       caratteri tra loro equivalenti ai fini della collazione o
       dell'ordinamento.  Per esempio, in francese una “e” semplice ed una
       “e`” con l'accento grave sono equivalenti.

       Simboli di collazione
              Un simbolo di collazione è un elemento di confronto costituito
              da più di un carattere racchiuso tra [.  e .].  Per esempio, se
              ch è un elemento di collazione, allora [[.ch.]]  è
              l'espressione regolare che lo individua, mentre [ch] è
              un'espressione regolare che individua o il carattere c o il
              carattere h.

       Classi di Equivalenza
              Una classe di equivalenza è un nome, dipendente dalla
              localizzazione, associato a 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]] è
              un'espressione regolare 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 espressioni regolari riconoscono attualmente solo le
       classi di caratteri POSIX, non i simboli di collazione né le classi di
       equivalenza.

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

       Quelle che seguono sono le opzioni della riga di comando che
       controllano come gawk interpreta i caratteri nelle espressioni
       regolari.

       Nessuna opzione
              In assenza di indicazioni, gawk mette a disposizione tutte le
              facilitazioni caratteristiche delle espressioni regolari POSIX e
              degli operatori GNU descritti più sopra.

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

       --traditional
              Le espressioni regolari sono valutate secondo le regole del
              tradizionale awk per .  Gli operatori GNU non hanno un
              significato speciale, e le espressioni di intervallo non sono
              disponibili.  I caratteri descritti da sequenze ottali o
              esadecimali sono trattati letteralmente, anche se rappresentano
              metacaratteri di espressioni regolari.

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

   Azioni
       Le istruzioni di azione sono racchiuse tra parentesi graffe, { e }.
       L'insieme delle istruzioni di azione è formato dalle solite istruzioni
       di assegnamento, condizionali e iterative presenti nella maggior parte
       dei linguaggi.  Gli operatori, le strutture di controllo e le
       istruzioni di input/output ricalcano quelli corrispondenti nel
       linguaggio C.

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

       (...)       Raggruppamento

       $           Riferimento a campi.

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

       ^           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 della divisione.

       + -         Addizione e sottrazione.

       spazio      Concatenazione di stringhe.

       |   |&      I/O proveniente dall'output di comandi [pipe] per getline,
                   print, e printf.

       < > <= >= != ==
                   I normali operatori di relazione.

       ~ !~        Corrispondenza tra espressioni regolari, e nessuna
                   corrispondenza.  NOTA: Non usare un'espressione regolare
                   costante (/foo/) come operando di sinistra di ~ o !~.
                   Usare un'espressione regolare solo come operando di destra.
                   L'espressione /foo/ ~ exp equivale a richiedere (($0 ~
                   /foo/) ~ exp).  Di solito non è questo, quel che si
                   vorrebbe.

       in          Controllo di appartenenza a un vettore.

       &&          AND logico.

       ||          OR logico.

       ?:          L'espressione condizionale in stile C.  Ha la forma
                   espressione1 ? espressione2 : espressione3.  Se
                   espressione1 è vera, il valore dell'espressione è
                   espressione2, altrimenti è espressione3.  Viene calcolata
                   solo una delle due espressioni espressione2 ed espressione3

       = += -= *= /= %= ^=
                   Assegnamento. Sono permessi sia l'assegnamento assoluto
                   (var = valore) che quello con operatore (le altre forme).

   Istruzioni di controllo
       Le istruzioni di controllo sono le seguenti:

              if (condizione) istruzione [ else istruzione ]
              while (condizione) istruzione
              do istruzione while (condizione)
              for (espressione1; espressione2; espressione3) istruzione
              for (var in vettore) istruzione
              break
              continue
              delete vettore[indice]
              delete vettore
              exit [ espressione ]
              { istruzione }
              switch (espressione) {
              case valore|espressione_regolare : istruzione
              ...
              [ default: istruzione ]
              }

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

       close(file [, come])          Chiude un file, una pipe o un co-
                                     processo.  Il parametro facoltativo come
                                     dovrebbe essere usato solo per chiudere
                                     un'estremità di una pipe bi-direzionale
                                     aperta con un co-processo.  Il valore
                                     dev'essere una stringa, o "to" o "from".

       getline                       Imposta $0 usando la successiva riga di
                                     input; imposta NF, NR, FNR, RT.

       getline <file                 Imposta $0 usando la successiva riga di
                                     file; imposta NF, RT.

       getline variabile             Imposta variabile dalla successiva riga
                                     di input; imposta NR, FNR, RT.

       getline variabile <file       Imposta variabile dalla successiva riga
                                     di file, RT.

       comando | getline [variabile] Esegue comando dirigendo l'output [del
                                     comando] o in $0 o in variabile, come
                                     sopra, e RT.

       comando |& getline [variabile]
                                     Esegue comando come un co-processo
                                     dirigendo l'output [del comando] o in $0
                                     o in variabile, come sopra, e RT.  I co-
                                     processi sono un'estensione gawk.  (il
                                     comando può anche essere un socket.
                                     Vedere la sottosezione Nomi di file
                                     speciali, più avanti.)

       next                          Cessa l'elaborazione della riga di input
                                     corrente.  Ã letta la successiva, e
                                     l'elaborazione ricomincia dal primo
                                     criterio di ricerca del programma AWK.
                                     Se non ci sono più righe in input, gawk
                                     esegue i comandi delle regole END, se
                                     presenti.

       nextfile                      Cessa l'elaborazione del file di input
                                     corrente.  La prossima riga sarà letta
                                     dal file di input successivo.  Sono
                                     aggiornati FILENAME e ARGIND, FNR è
                                     reimpostato a 1, e l'elaborazione
                                     riprende dal primo criterio di ricerca
                                     del programma AWK.  Quando non ci sono
                                     più righe in input, gawk esegue i
                                     comandi delle regole END, se presenti.

       print                         Stampa il record corrente.  Alla fine
                                     della riga in output viene aggiunto il
                                     valore della variabile ORS.

       print lista-espressioni       Stampa le espressioni indicate.  Ogni
                                     espressione è separata dal valore della
                                     variabile OFS.  La riga prodotta termina
                                     col valore della variabile ORS.

       print lista-espressioni >file Stampa le espressioni indicate su file.
                                     Ogni espressione è separata dal valore
                                     della variabile OFS.  La riga prodotta
                                     termina col valore della variabile ORS.

       printf fmt, lista-espressioni Stampa secondo formato.  Vedere
                                     L'istruzione printf , più avanti.

       printf fmt, lista-espressioni >file
                                     Stampa secondo formato su file.

       system(riga-di-comando)       Esegue il comando riga-di-comando, e ne
                                     restituisce il valore d'uscita.  (può
                                     non essere disponibile sui sistemi non-
                                     POSIX).  Si veda il manuale per tutti i
                                     dettagli sullo stato d'uscita.

       fflush([file])                Scarica il contenuto di tutti i buffer
                                     associati ai file o alle pipe aperti in
                                     scrittura file.  Se file non è
                                     specificato o ha per valore la stringa
                                     nulla, l'operazione è eseguita su tutti
                                     i file e le pipe aperti in scrittura.

       Sono permessi anche altri tipi di ridirezione in scrittura per print e
       printf.

       print ... >> file
              Aggiunge righe alla fine di file.

       print ... | comando
              Scrive su una pipe.

       print ... |& comando
              Invia dati a un co-processo o a un socket.  (Vedere anche la
              sottosezione Nomi di file speciali, più avanti).

       Il comando getline restituirà 1 se tutto va bene, 0 in caso di fine
       file, e -1 in caso di errore.  Se il valore di errno(3) indica che
       l'operazione di I/O può essere ritentata, e PROCINFO["input", "RETRY"]
       è stato impostato, verrà restituito il valore -2 invece che -1, e
       ulteriori chiamate a getline possono essere effettuate.  A fronte di un
       errore ERRNO è impostato a una stringa che descrive il problema.

       NOTA: L'insuccesso nell'apertura di un socket bidirezionale genera un
       errore non fatale che viene restituito alla funzione chiamante.  Se si
       sta usando una pipe, un co-processo, o un socket per alimentare la
       getline, o da print o printf all'interno di un ciclo, si deve usare
       close() per creare una nuova istanza del comando o del socket.  AWK non
       chiude automaticamente pipe, socket, o co-processi quando questi
       restituiscono EOF.

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

       %c      Un singolo carattere.  Se l'argomento usato per %c è numerico,
               è considerato come un carattere e stampato.  Altrimenti, si
               suppone che l'argomento sia una stringa, e ne è stampato solo
               il primo carattere.

       %d, %i  Un numero decimale (solo la sua parte intera).

       %e, %E  Un numero in virgola mobile nella forma [-]d.dddddde[+-]dd.  Il
               formato %E usa E anziché e.

       %f, %F  Un numero in virgola mobile nella forma [-]ddd.dddddd.  Se la
               libreria di sistema lo supporta, il formato %F è pure
               disponibile.  Si comporta come %f, ma usa lettere maiuscole per
               i valori speciali “non un numero” e “infinito”. Se %F non è
               disponibile gawk usa %f.

       %g, %G  Usa la conversione %e o %f, (la più corta delle due),
               sopprimendo gli zeri non significativi.  Il formato %G usa %E
               invece che %e.

       %o      Un numero ottale senza segno (anche questo intero).

       %u      Un numero decimale senza segno (pure questo intero).

       %s      Una stringa di caratteri.

       %x, %X  Un numero esadecimale senza segno (un intero).  Il formato %X
               usa ABCDEF invece di abcdef.

       %%      Un singolo carattere % ; non c'è alcuna conversione di
               argomenti.

       Alcuni ulteriori parametri facoltativi possono comparire fra il % e la
       lettera che indica il tipo di visualizzazione richiesta:

       n$     Usa l'argomento n-esimo a questo punto della formattazione.
              Questo è detto uno specificatore posizionale ed è pensato per
              usato principalmente nelle versioni tradotte delle stringhe di
              formattazione, non nel testo originale [normalmente in inglese]
              di un programma AWK. Si tratta di un'estensione gawk

       -      L'espressione va allineata a sinistra all'interno del proprio
              campo.

       spazio Nelle conversioni numeriche, inserire uno spazio prima dei
              valori positivi, e un segno "meno" prima di quelli negativi.

       +      Il segno "più" usato prima del modificatore di dimensione (vedi
              più avanti) indica che nelle conversioni numeriche il segno
              deve essere sempre presente, anche se il valore da riportare è
              positivo.  + annulla l'effetto del modificatore "spazio".

       #      Usa una “forma alternativa” per alcune lettere di controllo.
              Associato a %o, aggiunge uno zero iniziale.  Con %x, e %X,
              aggiunge all'inizio rispettivamente 0x o 0X in caso di valore
              diverso da zero.  Con %e, %E, %f e %F, il risultato conterrÃ
              sempre il separatore decimale.  Con %g, e %G, gli zeri in coda
              non sono rimossi dal risultato.

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

       '      Un apice semplice chiede a gawk di inserire il separatore delle
              migliaia proprio della localizzazione, come pure di usare il
              separatore decimale proprio della localizzazione per i numeri in
              virgola mobile.  Ã richiesto che la libreria C supporti
              correttamente la localizzazione e che questa sia stata definita
              correttamente.

       ampiezza
              Il numero dovrebbe occupare questo numero di byte.  Il numero è
              normalmente preceduto da spazi.  In presenza del flag 0, è
              invece preceduto da zeri.

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

       La definizione dinamica di ampiezza e prec prevista dalle funzioni
       printf() dell'ISO C sono supportate.  Un * al posto sia di ampiezza che
       di prec farà sì che i loro valori siano presi dalla lista degli
       argomenti di printf o sprintf().  Per usare uno specificatore di
       posizione con una larghezza o una precisione dinamica inserire il
       contatore$ dopo il carattere * nella stringa di formattazione.  Per
       esempio, "%3$*2$.*1$s".

   Nomi di file speciali
       effettuando delle ridirezioni di print o printf in un file, o
       attraverso getline da un file, gawk riconosce internamente alcuni nomi
       di file speciali, che permettono di accedere a descrittori di file giÃ
       aperti ereditati dal processo genitore di gawk (la shell, solitamente).
       Questi nomi di file possono anche essere usati nella riga di comando
       per designare dei file di dati.  I nomi di file sono:

       -           Lo standard input.

       /dev/stdin  Lo standard input.

       /dev/stdout Lo standard output.

       /dev/stderr Lo standard error in output.

       /dev/fd/n   Il file associato al descrittore di file aperto n.

       Questi ultimi sono utili in particolare per i messaggi di errore. Per
       esempio:

              print "Ti è andata male!" > "/dev/stderr"

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

              print "Ti è andata male!" | "cat 1>&2"

       I seguenti nomi di file speciali si possono usare con l'operatore |& di
       co-processo per creare connessioni di rete TCP/IP:

       /inet/tcp/lport/rhost/rport
       /inet4/tcp/lport/rhost/rport
       /inet6/tcp/lport/rhost/rport
              File per una connessione TCP/IP su una porta locale lport verso
              un host remoto rhost sulla porta remota rport.  Si usi la porta
              numero 0 Per permettere al sistema di scegliere una porta.  Si
              usi /inet4 per richiedere una connessione IPv4, e /inet6 per
              richiedere una connessione IPv6.  Specificando semplicemente
              /inet usa quello predefinito del sistema (molto probabilmente
              sarà IPv4).

       /inet/udp/lport/rhost/rport
       /inet4/udp/lport/rhost/rport
       /inet6/udp/lport/rhost/rport
              Come sopra, ma usando porte UDP/IP invece che TCP/IP.

   Funzioni numeriche
       AWK ha le seguenti funzioni aritmetiche predefinite:

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

       cos(espressione)     Restituisce il coseno di espressione, in radianti.

       exp(espressione)     La funzione esponenziale.

       int(espressione)     Troncamento a numero intero.

       intdiv(numero, denominatore, risultato)
                            I numeri numero e denominatore vengono troncati a
                            numeri interi. Restituisce il quoziente di numero
                            diviso per denominatore in result["quotient"] e il
                            resto in in result["remainder"].  Questa è
                            un'estensione gawk, utile in particolare quando si
                            lavora con numeri molto grandi.

       log(espressione)     Logaritmo a base naturale.

       rand()               Restituisce un numero casuale N, tra 0 e 1, tale
                            che 0 ≤ N < 1.

       sin(espressione)     Restituisce il seno di espressione, in radianti.

       sqrt(espressione)    Restituisce la radice quadrata di espressione.

       srand([espressione]) usa espressione come nuovo seme per il generatore
                            di numeri casuali.  Se espressione non è
                            indicata, sarà utilizzata il tempo corrente,
                            misurato in secondi dal 1970.  Il valore
                            restituito è il valore precedente del seme.

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

       asort(s [, d [, come] ])        Restituisce il numero di elementi del
                                       vettore di partenza s.  Ordina i
                                       contenuti del vettore s usando le
                                       regole normali di gawk per confrontare
                                       fra loro i valori, e sostituisce gli
                                       indici dei valori ordinati di s con la
                                       sequenza dei numeri interi a partire da
                                       1.  Se viene specificato il vettore
                                       destinazione (facoltativo) d, dapprima
                                       il vettore s viene copiato in d, e poi
                                       viene ordinato d, senza modificare gli
                                       indici del vettore di partenza s.  La
                                       stringa facoltativa come controlla la
                                       direzione e il modo del confronto.
                                       Valori ammissibili per come sono quelli
                                       delle stringhe ammissibili per
                                       PROCINFO["sorted_in"].  Si può anche
                                       specificare il nome di una funzione di
                                       confronto definita dall'utente, come
                                       viene spiegato in
                                       PROCINFO["sorted_in"].

       asorti(s [, d [, come] ])       Restituisce il numero di elementi del
                                       vettore di partenza s.  Il
                                       comportamento è lo stesso di asort(),
                                       con la differenza che l'ordinamento è
                                       fatto usando gli indici del vettore, e
                                       non i valori.  Fatto l'ordinamento, il
                                       vettore è indicizzato numericamente, e
                                       i valori sono quelli degli indici di
                                       partenza.  I valori originali sono
                                       persi; quindi va utilizzato un secondo
                                       vettore se si vuole conservare il
                                       vettore di partenza.  Lo scopo della
                                       stringa facoltativa come è lo stesso
                                       descritto in asort() più sopra.

       gensub(r, s, h [, t])           Cerca nella stringa obiettivo t
                                       corrispondenze con l'espressione
                                       regolare 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 alla n-esima
                                       sottoespressione tra parentesi.  La
                                       sequenza \0 rappresenta tutto il testo
                                       corrispondente, e così pure il
                                       carattere &.  A differenza di sub() e
                                       gsub(), la stringa modificata è
                                       restituita come risultato della
                                       funzione, e la stringa obiettivo
                                       originale resta inalterata.

       gsub(r, s [, t])                Per ogni sottostringa conforme
                                       all'espressione regolare 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 corrispondente alla
                                       espressione regolare.  Si usi \& per
                                       indicare il carattere & inteso
                                       letteralmente (va scritto come "\\&";
                                       vedere GAWK: Effective AWK Programming
                                       per una trattazione più completa delle
                                       regole sull'uso delle & e delle barre
                                       inverse nel testo di rimpiazzo di
                                       sub(), gsub(), e gensub()).

       index(s, t)                     Restituisce la posizione della stringa
                                       t all'interno della stringa s, o 0 se
                                       la stringa t non è presente.  (Ciò
                                       implica che gli indici di una stringa
                                       di caratteri partono da 1.)  Ã un
                                       errore fatale usare una costante
                                       generata da un'espressione regolare per
                                       t.

       length([s])                     Restituisce la lunghezza della stringa
                                       s, oppure la lunghezza di $0 se s non
                                       è specificata.  Come estensione non-
                                       standard, se si fornisce come argomento
                                       un vettore, length() restituisce il
                                       numero di elementi del vettore.

       match(s, r [, a])               Restituisce la posizione in s in cui
                                       ricorre l'espressione regolare r,
                                       oppure 0 se r non è presente, e
                                       imposta i valori di RSTART e RLENGTH.
                                       Si noti che l'ordine degli argomenti è
                                       lo stesso in uso per l'operatore ~:
                                       stringa ~ espressione-regolare.  Se
                                       viene specificato il vettore a, a viene
                                       preventivamente svuotato e quindi i
                                       suoi elementi da 1 a n sono riempiti
                                       con le parti di s corrispondenti alle
                                       sottoespressioni fra parentesi presenti
                                       in r.  L'elemento di indice 0 di a
                                       contiene la parte di s corrispondente
                                       all'intera espressione regolare r.  Gli
                                       indici a[n, "inizio"], e a[n,
                                       "lunghezza"] contengono l'indice di
                                       inizio all'interno della stringa e la
                                       lunghezza, rispettivamente, di ogni
                                       sottostringa individuata.

       patsplit(s, a [, r [, seps] ])  Suddivide la stringa s nel vettore a e
                                       il vettore dei separatori seps
                                       nell'espressione regolare r, e
                                       restituisce il numero dei campi.  I
                                       valori di ogni elemento [del vettore]
                                       sono le parti di s che corrispondono a
                                       r.  Il valore di seps[i] è il
                                       separatore individuato davanti a
                                       a[i+1].  Se r è omesso, FPAT viene
                                       usato al suo posto.  I vettori a e seps
                                       sono svuotati all'inizio
                                       dell'operazione.  La suddivisione si
                                       comporta come la suddivisione in campi
                                       con FPAT, descritta sopra.

       split(s, a [, r [, seps] ])     Suddivide la stringa s nel vettore a e
                                       nel vettore di separatori seps
                                       individuati dall'espressione regolare
                                       r, e restituisce il numero di campi.
                                       Se r è omessa, il separatore
                                       utilizzato è FS.  I vettori a e seps
                                       sono svuotati all'inizio
                                       dell'operazione.  seps[i] è il
                                       separatore di campo individuato da r
                                       tra a[i] e a[i+1].  Se r è uno spazio
                                       singolo, gli eventuali spazi bianchi
                                       all'inizio di s vengono messi
                                       nell'elemento extra del vettore seps[0]
                                       e gli spazi bianchi alla fine vanno
                                       nell'elemento extra del vettore
                                       seps[n], dove n è il valore restituito
                                       da split(s, a, r, seps).  La
                                       suddivisione si comporta come la
                                       suddivisione in campi, descritta sopra.

       sprintf(fmt, lista-espressioni) Stampa lista-espressioni secondo quanto
                                       specificato dal formato fmt, e
                                       restituisce la stringa risultante.

       strtonum(str)                   Esamina str, e ne restituisce il valore
                                       numerico.  Se str inizia con uno 0, è
                                       considerato un numero ottale.  Se str
                                       inizia con uno 0x o 0X, è considerato
                                       un numero esadecimale.  Altrimenti,
                                       viene interpretato come numero
                                       decimale.

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

       substr(s, i [, n])              Restituisce una sottostringa, lunga al
                                       massimo n-caratteri, di s a partire
                                       dalla posizione i.  Se n è omesso, è
                                       usato il resto di s.

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

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

       Gawk gestisce i caratteri multi-byte.  Ciò implica che index(),
       length(), substr() e match() lavorano in termini di caratteri, non di
       byte.

   Funzioni di tempo
       Poiché uno dei principali campi di applicazione dei programmi AWK è
       l'elaborazione dei file di log contenenti informazioni relative alla
       data e all'ora [di un evento], gawk mette a disposizione le seguenti
       funzioni per ottenere data e ora e per formattarle come desiderato.

       mktime(datespec)
                 Traduce datespec In una marcatura temporale nello stesso
                 formato restituito dalla funzione [del linguaggio C]
                 systime(), e restituisce il risultato.  Il parametro datespec
                 è una stringa nella forma YYYY MM DD HH MM SS[ DST].  Il
                 contenuto della stringa consiste in sei o sette numeri che
                 rappresentano rispettivamente: l'anno, incluso il secolo, il
                 mese, da 1 a 12, il giorno del mese da 1 a 31, l'ora del
                 giorno da 0 a 23, il minuto da 0 a 59, il secondo da 0 a 60,
                 e un flag facoltativo riguardo all'ora legale.  I valori di
                 questi numeri non sono limitati agli intervalli sopra
                 descritti; per esempio, un'ora di -1 significa 1 ora prima di
                 mezzanotte.  Si suppone di lavorare con un calendario
                 gregoriano dotato di anno 0, con l'anno 0 prima dell'anno 1 e
                 l'anno -1 prima dell'anno 0.  L'ora del giorno è supposta
                 essere quella locale.  Se il flag dell'ora legale è
                 positivo, si suppone che ci si trovi in un periodo dell'anno
                 in cui vige l'ora legale; se vale zero, l'ora è ritenuta
                 essere quella standard [ora di Greenwich]; se è negativa
                 (questo è il comportamento predefinito), mktime() tenta di
                 determinare se è in vigore l'ora legale nel momento
                 specificato.  Se datespec non contiene sufficienti elementi o
                 se il tempo risultante è fuori intervallo, mktime()
                 restituisce -1.

       strftime([format [, timestamp[, utc-flag]]])
                 Formatta timestamp secondo quanto specificato in format.  Se
                 utc-flag è presente e diversa da zero o dalla stringa nulla,
                 il risultato è in UTC [ora di Greenwich], altrimenti il
                 risultato è nell'ora locale.  Il 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
                 dell'output del comando date(1).  Il formato predefinito è
                 disponibile in PROCINFO["strftime"].  Vedere le specifiche
                 per la funzione strftime() in ISO C per i formati di
                 conversione che sono sicuramente disponibili.

       systime() Restituisce l'ora corrente come numero di secondi a partire
                 da: (1970-01-01 00:00:00 UTC sui sistemi POSIX).

   Funzioni di manipolazione dei bit
       Gawk prevede le seguenti funzioni di manipolazione dei bit.  Sono
       realizzate dapprima convertendo valori in virgola mobile con precisione
       doppia in interi nel formato uintmax_t, eseguendo l'operazione
       indicata, e poi convertendo il risultato nuovamente in virgola mobile.
       Le funzioni sono:

       and(v1, v2 [, ...])     Restituisce il risultato derivante
                               dall'applicazione della funzione booleana AND
                               bit per bit ai valori degli argomenti della
                               lista degli argomenti.  Gli argomenti devono
                               essere almeno due.

       compl(val)              Restituisce il complemento bit per bit di val.

       lshift(val, contatore)  Restituisce il valore di val, spostato a
                               sinistra di contatore bit.

       or(v1, v2 [, ...])      Restituisce il risultato dell'applicare la
                               funzione booleana OR bit per bit ai valori
                               degli argomenti della lista degli argomenti.
                               Gli argomenti devono essere almeno due.

       rshift(val, contatore)  Restituisce il valore di val, spostato a destra
                               di contatore bit.

       xor(v1, v2 [, ...])     Restituisce il risultato derivante
                               dall'applicazione della funzione booleana XOR
                               bit per bit ai valori degli argomenti della
                               lista degli argomenti.  Gli argomenti devono
                               essere almeno due.

   Funzioni di tipo
       La funzione seguente va usata per vettori multidimensionali.

       isarray(x)
              Restituisce "Vero" se x è un vettore, altrimenti restituisce
              "Falso".  [0 e la stringa nulla significano "Falso". Qualsiasi
              altro valore sta per "Vero".]

       Ã possibile conoscere il tipo di qualsiasi variabile o elemento di
       vettore con la seguente funzione:

       typeof(x)
              Return a string indicating the type of x.  The string will be
              one of "array", "number", "regexp", "string", "strnum", or
              "undefined".

   Funzioni di internazionalizzazione
       Le seguenti funzioni possono essere usate all'interno di un programma
       AWK per tradurre stringhe in fase di esecuzione del programma.  Per
       informazioni più complete, vedere GAWK: Effective AWK Programming.

       bindtextdomain(directory [, dominio])
              Specifica la directory in cui gawk cerca i file .gmo, nel caso
              non si trovino o non si possano mettere nelle directory
              ``standard'' (per esempio, in fase di test).  Restituisce la
              directory a cui dominio è ``collegato''.
              Il valore predefinito per dominio è il valore della variabile
              TEXTDOMAIN.  Se directory è impostato alla stringa nulla (""),
              bindtextdomain() restituisce il collegamento corrente per il
              dato dominio.

       dcgettext(stringa [, dominio [, categoria]])
              Restituisce la traduzione della stringa nel dominio di testo
              dominio per la categoria di localizzazione categoria.  Il valore
              predefinito per dominio è il valore corrente della variabile
              TEXTDOMAIN.  Il valore predefinito per categoria è
              "LC_MESSAGES".
              Se si fornisce un valore per categoria, dev'essere una stringa
              uguale a una delle categorie di localizzazione note, come
              descritto in GAWK: Effective AWK Programming.  Occorre anche
              fornire un dominio di testo.  Si usi TEXTDOMAIN se ci si vuole
              servire del dominio corrente.

       dcngettext(stringa1, stringa2, numero [, dominio [, category]])
              Restituisce la forma plurale in uso per numero nella traduzione
              di stringa1 e stringa2 nel dominio di testo dominio per la
              categoria di localizzazione categoria.  Il valore predefinito
              per dominio è il valore corrente della variabile TEXTDOMAIN.
              Il valore predefinito per categoria è "LC_MESSAGES".
              Se si fornisce un valore per categoria, dev'essere una stringa
              uguale a una delle categorie di localizzazione note, come
              descritto in GAWK: Effective AWK Programming.  Occorre anche
              fornire un dominio di testo.  Si usi TEXTDOMAIN se ci si vuole
              servire del dominio corrente.

FUNZIONI DEFINITE DALL'UTENTE
       Le funzioni in AWK sono definite in questo modo:

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

       Le funzioni sono eseguite tramite chiamata dall'interno di espressioni,
       presenti sia all'interno di criteri di ricerca, che all'interno di
       azioni.  I parametri forniti al momento della chiamata sono sostituiti
       ai 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 variabili locali
              {
                   ...
              }

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

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

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

       Si usi return expr per restituire un valore da una funzione.  Il valore
       di ritorno è indefinito se non si fornisce alcun valore, o se la
       funzione ritorna automaticamente dopo aver eseguito l'ultima istruzione
       della funzione stessa, nella modalità  detta “falling off”.

       Come estensione gawk le funzioni possono essere chiamate
       indirettamente.  Per far ciò basta assegnare il nome della funzione da
       chiamare, in formato stringa, a una variabile.  Poi si usi la variabile
       come se fosse un nome di funzione, premettendole il segno @ come si
       può vedere qui sotto:
              function mia_funzione()
              {
                   print "mia_funzione è stata chiamata"
                   ...
              }

              {    ...
                   nome_funzione = "mia_funzione"
                   @nome_funzione()    # chiamata tramite nome_funzione di mia_funzione
                   ...
              }
       A partire dalla versione 4.1.2, questo vale per le funzioni definite
       dall'utente, per quelle predefinite e per le funzioni di estensione.

       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.  anche se questo
       modo di operare è deprecato.

CARICARE DINAMICAMENTE NUOVE FUNZIONI
       Si possono aggiungere dinamicamente nuove funzioni predefinite
       all'interpreter gawk con l'istruzione @load.  Una descrizione
       dettagliata non è possibile in questa pagina di manuale; vedere GAWK:
       Effective AWK Programming.

SEGNALI
       Il profilo gawk riconosce due segnali.  SIGUSR1 provoca la scrittura di
       un profilo e dello stack delle chiamate a funzione nel file di
       profilazione, che ha per nome awkprof.out, o qualsiasi nome sia stato
       fornito specificando l'opzione --profile.  Poi l'esecuzione del
       programma prosegue regolarmente.  SIGHUP chiede a gawk di scrivere il
       profilo e lo stack delle chiamate a funzione e di terminare
       l'esecuzione del programma.

INTERNAZIONALIZZAZIONE
       Le costanti di tipo stringa sono sequenze di caratteri racchiuse fra
       doppi apici.  In un ambiente dove non si parla inglese, è possibile
       segnare delle stringhe in un programma AWK per richiederne la
       traduzione nel linguaggio utilizzato in loco.  Tali stringhe sono
       precedute nel programma AWK da un carattere di sottolineatura (“_”).
       Per esempio,,

              gawk 'BEGIN { print "hello, world" }'

       stampa sempre il messaggio hello, world.  Ma,

              gawk 'BEGIN { print _"hello, world" }'

       potrebbe invece stampare bonjour, monde se eseguito in Francia.

       Parecchi passi sono necessari per produrre ed eseguire un programma AWK
       localizzabile.

       1.  Aggiungere un'azione BEGIN per assegnare un valore alla variabile
           TEXTDOMAIN per impostare il dominio del testo a un nome associato
           al programma in uso:

                BEGIN { TEXTDOMAIN = "mio_programma" }

           Ciò consente a gawk di trovare il file .gmo associato al vostro
           programma.  Se non si fa ciò, gawk usa il dominio di testo
           associato ai messaggi il quale, molto probabilmente, non contiene
           le traduzioni necessarie al programma in uso.

       2.  Far precedere a tutte le stringhe da tradurre il carattere "_".

       3.  Se è il caso, usare le funzioni dcgettext() e/o bindtextdomain()
           nel programma, secondo necessità .

       4.  Eseguite il comando gawk --gen-pot -f mio_programma.awk >
           mio_programma.pot per generare un file .pot per il programma
           [questo file contiene i messaggi da tradurre e la struttura in cui
           inserire la traduzione]

       5.  Preparare delle traduzioni appropriate dei messaggi, e costruire
           [con make] il corrispondente file .gmo [che contiene messaggi e
           traduzioni in formato accessibile da gawk].

       Le procedure da usare per la traduzione sono descritte in dettaglio in
       GAWK: Effective AWK Programming.

COMPATIBILITÃ POSIX
       Un obiettivo fondamentale di gawk è la compatibilità con lo standard
       POSIX, come pure con l'ultima versione di awk scritta da Brian
       Kernighan.  Per questa ragione gawk include le seguenti caratteristiche
       a disposizione dell'utente che non sono descritte nel libro di AWK, ma
       che fanno parte della versione di awk scritta da Brian Kernighan, e che
       sono incluse nello standard POSIX.

       Il libro indica che l'assegnazione delle variabili fornite sulla riga
       di comando è fatta subito prima che awk apra il primo file fra gli
       argomenti, il che avviene dopo che la regola BEGIN è stata eseguita.
       Peraltro, in implementazioni precedenti, quando una tale assegnazione
       compariva prima di un nome di file, l'assegnazione sarebbe avvenuta
       prima di eseguire la regola BEGIN .  Esistono applicazioni che
       dipendono da questa “funzionalità .”  Quando awk è stato cambiato per
       corrispondere alla sua documentazione l'opzione -v per assegnare valori
       alle variabili prima dell'inizio dell'esecuzione è stata aggiunta per
       tener conto delle applicazioni che dipendevano dal precedente
       comportamento.  (Questa funzionalità ha ottenuto l'approvazione sia
       dei Bell Laboratories che degli sviluppatori di GNU .)

       Nella scansione degli argomenti, gawk usa l'opzione speciale “--” per
       segnalare la fine degli argomenti.  In modalità compatibile, emette un
       messaggio e poi ignora le opzioni non disponibili.  Nella modalitÃ
       normale di operazione, siffatti argomenti sono passati al programma AWK
       per essere trattati.

       Il libro di AWK non definisce il valore restituito dalla funzione
       srand().  Lo standard POSIX richiede che restituisca il "seme" che è
       stato usato, per consentire di tener traccia delle sequenze di numeri
       casuali.  Pertanto srand() in gawk restituisce anche il suo "seme"
       corrente.

       Altre nuove funzionalità sono: L'uso di opzioni -f multiple (dalla
       versione MKS [Mortice Kern Systems] di awk); il vettore ENVIRON; le
       sequenze di protezione \a, e \v (provenienti originalmente da gawk e
       poi riversate nella versione Bell Laboratories); le funzioni
       predefinite tolower() e toupper() (dalla versione Bell Laboratories); e
       le specifiche di conversione ISO C in printf (presenti per prime nella
       versione Bell Laboratories).

FUNZIONALITÃ STORICHE
       C'è una caratteristica dell'implementazione storica di AWK che gawk
       supporta: Ã possibile chiamare la funzione predefinita length() non
       solo senza alcun argomento, ma perfino senza parentesi!  Quindi,

              a = length     # Sant'Algol 60, Batman!

       equivale sia a

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

       Usare questa funzionalità è una pratica deprecata, e gawk emette un
       messaggio di avvertimento se la si usa, qualora si sia specificato
       --lint sulla riga di comando.

ESTENSIONI GNU
       Gawk ha fin troppe estensioni rispetto alla versione POSIX di awk.
       Esse sono descritte in questa sezione.  Tutte le estensioni qui
       descritte possono essere disabilitate invocando gawk con le opzioni
       --traditional o --posix.

       Le seguenti funzionalità di gawk sono sono disponibili nella versione
       POSIX di awk.

       · Non viene fatta una ricerca nelle librerie per file richiamati
         tramite l'opzione -f.  Quindi la variabile d'ambiente AWKPATH non è
         speciale.

       · Non c'è modo di includere dei file da programma (il meccanismo gawk
         di @include).

       · Non c'è modo di aggiungere dinamicamente nuove funzioni scritte in C
         (meccanismo @load di gawk).

       · La sequenza di protezione \x.  (Disabilitata specificando --posix.)

       · La possibilità  di continuare delle righe dopo un ?  e i :.
         (Disabilita specificando --posix.)

       · Costanti ottali ed esadecimali nei programmi AWK.

       · Le variabili ARGIND, BINMODE, ERRNO, LINT, RT e TEXTDOMAIN non sono
         speciali.

       · La variabile IGNORECASE e i suoi effetti collaterali non sono
         disponibili.

       · La variabile FIELDWIDTHS e la suddivisione in campi di larghezza
         fissa e variabile.

       · La variabile FPAT e la suddivisione in campi sulla base dei valori di
         un campo.

       · Il vettore PROCINFO non è disponibile.

       · L'uso della variabile RS come espressione regolare.

       · I nomi di file speciali disponibili per ridirigere l'I/O non sono
         riconosciuti.

       · L'operatore |& utilizzabile per creare co-processi.

       · I criteri di confronto speciali BEGINFILE e ENDFILE non sono
         disponibili.

       · La possibilità  di separare fra loro singoli caratteri usando la
         stringa nulla come valore per la variabile FS, e come terzo argomento
         nella funzione split().

       · Un quarto argomento opzionale per split() che riceva i testi da usare
         come separatori.

       · Il secondo argomento opzionale della funzione close().

       · Il terzo argomento opzionale della funzione match().

       · La possibilità  di usare specificatori posizionali con printf e
         sprintf().

       · La possibilità  di avere un vettore come argomento alla funzione
         length().

       · Le funzioni and(), asort(), asorti(), bindtextdomain(), compl(),
         dcgettext(), dcngettext(), gensub(), lshift(), mktime(), or(),
         patsplit(), rshift(), strftime(), strtonum(), systime() e xor().

       · Stringhe traducibili in varie lingue.

       Il libro AWK non definisce il valore restituito dalla funzione close().
       Invece la funzione close() di Gawk restituisce il valore ottenuto da
       fclose(3) o pclose(3) alla chiusura, rispettivamente, di un file di
       output o di una pipe.  Alla chiusura di una pipe di input viene
       restituito lo stato di uscita del processo.  Il valore restituito è -1
       se il file, la pipe o il co-processo in questione non sono stati aperti
       con una ridirezione.

       Quando gawk è invocato con l'opzione --traditional, se l'argomento fs
       all'opzione -F è “t”, FS è impostato avendo come valore il carattere
       di tabulazione (<TAB>).  Si noti che immettendo gawk -F\t ...  si
       chiede alla shell di preservare “t,” e non di passare “\t” all'opzione
       -F.  Poiché questo è un caso speciale piuttosto antipatico, non è il
       comportamento predefinito.  Questo comportamento non viene seguito
       neppure quando si specifica --posix.  Per ottenere che un carattere
       <TAB> faccia da delimitatore di campo, è meglio usare apici singoli:
       gawk -F'\t' ....

VARIABILI D'AMBIENTE
       La variabile d'ambiente AWKPATH può essere usata per fornire una lista
       di directory che gawk esamina alla ricerca di file coi nomi indicati
       tramite le opzioni -f, --file, -i e --include.  Se la ricerca iniziale
       non ha successo, una seconda ricerca è effettuata accodando .awk al
       nome del file indicato.

       La variabile d'ambiente AWKLIBPATH può essere usata per fornire una
       lista di directory che gawk esamina alla ricerca di file coi nomi
       indicati tramite le opzioni -l e --load

       La variabile d'ambiente GAWK_READ_TIMEOUT può essere usata per
       specificare un tempo massimo in millisecondi per leggere input da un
       terminale, da una pipe o da una comunicazione bidirezionale, inclusi i
       socket.

       Per le connessioni a un host remoto via socket, GAWK_SOCK_RETRIES
       controlla il numero di tentativi di lettura, e GAWK_MSEC_SLEEP
       l'intervallo fra un tentativo di lettura e l'altro.  L'intervallo è in
       millisecondi.  Su sistemi che non supportano usleep(3), il valore è
       arrotondato a un numero intero di secondi.

       Se la variabile POSIXLY_CORRECT esiste nell'ambiente, gawk si comporta
       esattamente come se --posix fosse stato specificato sulla riga di
       comando.  Se --lint è stato specificato, gawk emette un messaggio di
       avvertimento riguardo a questo.

STATO DI USCITA
       Se l'istruzione exit è usata avendo come parametro un valore, gawk
       termina restituendo il valore numerico in questione.

       Altrimenti, se non sono stati riscontrati problemi in fase di
       esecuzione, gawk termina con il valore della costante C EXIT_SUCCESS.
       Questo valore è normalmente zero.

       In caso di errore, gawk termina con il valore della costante C
       EXIT_FAILURE.  Questo valore è normalmente uno.

       Se gawk termina a causa di un errore fatale, il valore restituito è 2.
       Su sistemi non-POSIX, questo valore può essere visualizzato come
       EXIT_FAILURE.

INFORMAZIONE SULLA VERSIONE
       Questa pagina man documenta gawk, versione 4.1.

AUTORI
       La versione originale di UNIX awk è stata progettata e implementata da
       Alfred Aho, Peter Weinberger, e Brian Kernighan dei Bell Laboratories.
       Brian Kernighan continua a mantenere e migliorare il programma.

       Paul Rubin e Jay Fenlason, della Free Software Foundation, hanno
       scritto gawk, in modo che fosse compatibile con la versione originale
       di awk distribuita con la Settima Edizione di UNIX.  John Woods ha
       contribuito con numerose correzioni di errori.  David Trueman, con
       contribuzioni da Arnold Robbins, ha reso gawk compatibile con la nuova
       versione di UNIX awk.  Arnold Robbins è il manutentore corrente.

       Vedere GAWK: Effective AWK Programming per una lista completa di
       contributori a gawk e alla sua documentazione.

       Vedere il file README nella distribuzione gawk per informazioni
       aggiornate riguardo ai manutentori e per sapere per quali sistemi
       operativi gawk è disponibile.

       Traduzione in italiano a cura di ILDP - Italian Linux Documentation
       Project http://www.pluto.it/ildp

SEGNALAZIONE DI ERRORI
       Se trovate un bug in gawk, siete pregati di inviare un messaggio di
       posta elettronica a bug-gawk@gnu.org.  Siete pregati di includere il
       vostro sistema operativo e la versione di gawk (da gawk --version),
       quale compilatore C avete usato per compilarlo, e un programma di test
       con anche i dati, ridotti allo stretto necessario, per riprodurre il
       problema.

       Prima di spedire un rapporto di errore fate quanto segue.  Per prima
       cosa, verificate che stiate usando l'ultima versione di gawk.  Molti
       bug (normalmente abbastanza difficili da incontrare) sono corretti in
       ogni nuova versione, e se la vostra versione è molto datata, il
       problema potrebbe essere già stato risolto.  Secondariamente, siete
       pregati di controllare se impostando la variabile d'ambiente LC_ALL a
       LC_ALL=C faccia sì che il problema scompaia.  Se così è, si tratta
       di un problema legato alla localizzazione, che può essere o meno un
       errore.  Infine, siete pregati di leggere questa man page e il manuale
       di riferimento con attenzione, per assicurarvi che quello che voi
       ritenete essere un errore lo sia veramente, invece di essere solo un
       comportamento strano del linguaggio.

       Qualsiasi cosa facciate, NON inviate un messaggio per segnalare
       l'errore a comp.lang.awk.  Anche se gli sviluppatori di gawk di tanto
       in tanto leggono questo forum, inviare qui messaggi di segnalazione di
       errore è una maniera poco affidabile per segnalare errori.  Siete
       invece pregati di usare l'indirizzo di posta elettronica scritto più
       sopra.  Veramente!

       Se state usando un sistema GNU/Linux o basato sulla distribuzione BSD,
       potreste rivolgervi a chi fornisce la vostra distribuzione software.
       Questo va bene, ma siete pregati di spedire una copia all'indirizzo
       email specificato, poiché non esiste alcune certezza che il vostro
       messaggio sia inoltrato al manutentore di gawk.

       Segnalare eventuali errori di traduzione a ildp@pluto.it

ERRORI
       L'opzione -F non è più necessaria, vista la possibilità di assegnare
       variabili nella riga di comando; viene mantenuta solo per
       compatibilità all'indietro.

VEDERE ANCHE
       egrep(1), sed(1), getpid(2), getppid(2), getpgrp(2), getuid(2),
       geteuid(2), getgid(2), getegid(2), getgroups(2), usleep(3)

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

       GAWK: Effective AWK Programming, Edition 4.1, disponibile con il codice
       sorgente gawk.  La versione originale corrente di questo documento è
       disponibile online a: http://www.gnu.org/software/gawk/manual.

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 riga all'inizio di ogni riga del file:

            { print FNR, $0 }

       Concatena e aggiunge numerazione (variazione sul tema):

            { print NR, $0 }

       Esegui un comando esterno per alcune linee di dati:

            tail -f access_log |
            awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'

RICONOSCIMENTI
       Brian Kernighan ha fornito valida assistenza durante il test e la
       correzione degli errori.  Lo ringraziamo.

COPYING PERMISSIONS
       Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
       2001, 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2011, 2012, 2013, 2014,
       2015, 2016 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
       Questa è una traduzione non ufficiale in italiano dei permessi di
       copia riportati nella precedente sezione "COPYING PERMISSIONS".  Non è
       una pubblicazione della Free Software Foundation, e non ha validitÃ
       legale per i termini di distribuzione della documentazione; solo il
       testo originale inglese ha tale validità .

       This is an unofficial translation into Italian of the above section
       "COPYING PERMISSIONS". It was not published by the Free Software
       Foundation, and does not legally state the distribution terms for this
       documentation; only the original English text does that.

       Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
       2001, 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2011, 2012, 2013, 2014,
       2015, 2016 Free Software Foundation, Inc.

       Ã permesso stampare e distribuire copie letterali di questa pagina di
       manuale, a patto che il copyright e questa nota di autorizzazione siano
       conservate e presenti in ogni copia.

       Ã 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 stampa
       identici a questi.

       Ã permesso copiare e distribuire traduzioni di questa pagina di 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.



Free Software Foundation          Jun 30 2016                          GAWK(1)