path: root/doc/it/gawk.1

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 `e 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  `e  basata a sua volta sulla descrizione contenuta in The AWK Programming
       Language, di Aho, Kernighan e Weinberger.  Gawk fornisce le funzionalit`a  aggiuntive  pre-
       senti nella versione corrente di awk
        di Brian Kernighan e numerose estensioni specifiche di GNU.

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

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

       Gawk ha anche una capacit`a integrata di debugging.  Una sessione  interattiva  di  analisi
       degli errori (debug) pu`o essere iniziata fornendo l'opzione --debug sulla riga di comando.
       In questa modalit`a di esecuzione, gawk carica il codice sorgente di  AWK  e  poi  richiede
       l'inserimento  di  comandi di debug.  Gawk pu`o analizzare solo il sorgente di un programma
       AWK fornito tramite l'opzione -f e --include.  Il debugger `e documentato in  GAWK:  Effec-
       tive 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`a 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, op-
       pure sono indicati nel successivo argomento della riga di comando.  Le opzioni lunghe pos-
       sono essere abbreviate, sempre che l'abbreviazione rimanga univoca.

       In  aggiunta,  ogni opzione lunga ha una corrispondente opzione corta, in modo che la fun-
       zionalit`a 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`u  opzioni  -f  (o
              --file).  I file letti come specificato da -f sono trattati come se iniziassero con
              la direttiva implicita @namespace "awk".

       -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 pro-
              gramma.  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`a compatibile.  In questa modalit`a, gawk si comporta esat-
              tamente  come  awk  di Brian Kernighan; non viene riconosciuta nessuna delle esten-
              sioni specifiche di GNU.  Si veda ESTENSIONI GNU, pi`u avanti, per  maggiori  infor-
              mazioni.

       -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 awk-
              vars.out nella directory corrente.
              Avere una lista di tutte le variabili globali `e un buon modo per cercare errori ti-
              pografici  nei  programmi.   Quest'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 (`e
              facile commettere questo errore quando si usano nomi di variabili semplici come  i,
              j, e cos`i via).

       -D[file]
       --debug[=file]
              Abilita  il debugging di programmi AWK.  Per default, l'analizzatore di errori [de-
              bugger] 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 per-
              mette  di  combinare in modo semplice funzioni di libreria (usate attraverso i file
              indicati dalle opzioni -f e --include) con codice sorgente immesso  sulla  riga  di
              comando.   `E  rivolta  principalmente a programmi  AWK di media e grande dimensione
              usati all'interno di script di shell.  Ogni argomento specificato da -e `e  trattato
              come se iniziasse con la direttiva implicita @namespace "awk".

       -E file
       --exec file
              Simile  a -f, comunque, quest'opzione `e l'ultima ad essere elaborata.  Dovrebbe es-
              sere usata con script #!, specialmente per applicazioni CGI [Common Gateway  Inter-
              face], 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'e 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 disponi-
              bili.  (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'ambi-
              ente AWKPATH.  Se la ricerca iniziale non va a buon fine, viene fatto un altro ten-
              tativo  dopo aver aggiunto il suffisso .awk.  Il file verr`a caricato solo una volta
              (cio`e vengono ignorati i duplicati), e il codice non costituisce  il  sorgente  del
              programma  principale.   I  file  letti come specificato da --include sono trattati
              come se iniziassero con la direttiva implicita @namespace "awk".

       -I
       --trace
              Stampa i nomi del codice-byte generato internamente, nell'ordine in cui sono incon-
              trati  durante  l'esecuzione del programma.  Questa trace `e stampata sullo standard
              error.  Ogni ``codice operativo'' `e preceduto da un segno + nell'output.

       -l lib
       --load lib
              Carica un'estensione gawk dalla 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 condi-
              visa predefinita per la piattaforma.  La procedura di inizializzazione della libre-
              ria 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`o essere  drastico,  ma  incoragger`a
              sicuramente  lo  sviluppo di programmi AWK pi`u corretti.  Con l'argomento opzionale
              invalid, vengono emessi solo gli avvertimenti relativi a quello  che  `e  effettiva-
              mente  non  valido  (funzionalit`a non ancora completamente implementata).  Specifi-
              cando l'argomento facoltativo no-ext, gli  avvertimenti  riguardo  alle  estensioni
              gawk sono disabilitati.

       -M
       --bignum
              Forza  il  calcolo  con precisione arbitraria sui numeri.  Quest'opzione non ha ef-
              fetto se gawk non `e compilato per utilizzare le librerie GNU MPFR e GMP.   (In  tal
              caso, gawk invia un messaggio di avvertimento.)

       -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  `e  attiva,  il  comportamento  pre-
              definito  `e  quello  tradizionale di usare il punto come separatore decimale, anche
              per le  localizzazioni  in  cui  il  carattere  di  separazione  non  `e  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.
              Quest'opzione attiva anche l'opzione --no-optimize.

       -O
       --optimize
              Abilita le ottimizzazioni predefinite di gawk nella  rappresentazione  interna  del
              programma.   Attualmente,  questo  comprende  il  semplice  calcolo delle costanti.
              Quest'opzione `e 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  `e 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.  Quest'opzione attiva anche l'opzione --no-op-
              timize.

       -P
       --posix
              Quest'opzione attiva la modalit`a di compatibilit`a, con le seguenti restrizioni  ag-
              giuntive:

              +o Le sequenze di protezione \x non vengono riconosciute.

              +o Non `e possibile continuare le righe dopo ?  e :.

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

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

       -r
       --re-interval
              Abilita  l'uso  di  espressioni  di  intervallo  nelle espressioni regolari (vedere
              Espressioni regolari, pi`u 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`a  predefinita,  per`o
              quest'opzione rimane per essere usata insieme all'opzione --traditional.

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

       -S
       --sandbox
              Esegue gawk in modalit`a "sandbox", disabilitando la  funzione  system(),  la  ridi-
              rezione dell'input con getline, la ridirezione sull'output con print e printf, e il
              caricamento delle estensioni dinamiche.  L'esecuzione di comandi (tramite pipeline)
              `e  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.  `E
              utile principalmente per sapere se la copia di gawk attualmente  installata  `e  ag-
              giornata rispetto a ci`o che Free Software Foundation sta distribuendo.  `E utile an-
              che quando si devono segnalare degli errori.  (In linea con le convenzioni di codi-
              fica  GNU  Coding  Standards,  queste opzioni provocano un'uscita immediata e senza
              segnalazione di errore.)

       --     Segnala la fine delle opzioni. `E utile perch'e permette di passare al programma  AWK
              ulteriori  argomenti  [nomi di file] che iniziano con "-".  Questo assicura una co-
              erenza con le convenzioni di esame degli argomenti usato dalla  maggior  parte  dei
              programmi POSIX .

       In  modalit`a compatibile, qualsiasi altra opzione `e 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 `e particolarmente utile per eseguire  i  programmi  AWK  attraverso  il  meccanismo
       dell'interprete eseguibile #!.

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

ESECUZIONE DEL PROGRAMMA AWK
       Un programma AWK consiste di una sequenza di direttive opzionali, istruzioni di tipo  cri-
       terio-azione e definizioni di funzione opzionali.

              @include "nome_del_file"
              @load "nome_del_file"
              @namespace "nome"
              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`u volte nella riga di co-
       mando.  Gawk legge il testo del programma come se tutti i file_di_programma e i testi sor-
       genti  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;  in-
       oltre  si  possono  combinare funzioni di libreria con programmi provenienti dalla riga di
       comando.

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

       Le righe che iniziano con @load possono essere usate per caricare funzioni  di  estensione
       nel programma.  Questo `e equivalente all'uso dell'opzione --load.

       La  variabile  d'ambiente AWKPATH specifica il percorso lungo il quale cercare i file sor-
       genti indicati con le opzioni -f e --include.  Se questa variabile non esiste, il percorso
       predefinito  `e  "/usr/local/share/awk" (la directory in questione pu`o variare a seconda di
       come gawk `e stato compilato e installato).  Se un nome di file dato con l'opzione -f  con-
       tiene 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 --load.  Se questa variabile non esiste, il percorso  pre-
       definito  `e "/usr/local/lib/gawk" (la directory in questione pu`o variare a seconda di come
       gawk `e 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 com-
       pila 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-1]).  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, `e trattato come un assegna-
       mento di variabile.  Alla variabile var sar`a assegnato il valore val (questo  accade  dopo
       che ogni regola BEGIN `e stata eseguita).  L'assegnamento di variabili da riga di comando `e
       utilissima per assegnare dinamicamente valori alle variabili che AWK usa  per  controllare
       come  l'input  `e organizzato in campi e record.  `E utile inoltre per controllare variabili
       di stato quando siano necessari pi`u passi di elaborazione su un singolo file di dati.

       Se il valore di un particolare elemento di ARGV `e 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'`e corrispondenza  con  qualche  criterio  di
       ricerca  specificato nel programma AWK.  Per ogni criterio di ricerca a cui un record cor-
       risponde, gawk esegue l'azione associata.  I criteri di ricerca sono  verificati  nell'or-
       dine 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 `e ``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 --tradi-
       tional 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,  gawk  consente  di  avere  variabili  di  tipo
       "espressione  regolare".  AWK ha anche vettori monodimensionali; i vettori multidimension-
       ali possono essere simulati [da vettori monodimensionali].  Gawk fornisce veri vettori  di
       vettori;  vedere  Vettori,  pi`u avanti.  Al momento dell'esecuzione del programma sono im-
       postate parecchie variabili predefinite; saranno descritte di volta in volta  quando  sar`a
       necessario, ed elencate pi`u avanti.

   Record
       Normalmente  i  record sono separati dal carattere newline.  Si pu`o controllare il modo in
       cui i record sono separati assegnando valori alla variabile predefinita RS.   Se  RS  con-
       tiene un qualsiasi carattere singolo, tale carattere separa i record.  Altrimenti, se RS `e
       un'espressione regolare, il testo nell'input che corrisponde a questa espressione regolare
       sar`a  il  separatore di record.  Tuttavia, nella modalit`a compatibile `e preso in consider-
       azione 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 `e un carattere singolo, i campi sono separati da  quel
       carattere.   Se  FS `e la stringa nulla, ogni singolo carattere diventa un campo a s'e.  Di-
       versamente, 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`u avanti) influenza anche il
       modo  in  cui  i  campi sono spezzati quando FS `e un'espressione regolare, e come i record
       vengano separati quando RS `e un'espressione regolare.

       Se alla variabile FIELDWIDTHS `e assegnata una lista di  numeri  separati  da  spazi,  ogni
       campo `e considerato di larghezza fissa, e gawk spezza il record secondo le larghezze spec-
       ificate.  Ogni larghezza di campo pu`o opzionalmente essere preceduta da un  valore,  sepa-
       rato da una virgola, che specifica il numero di caratteri da saltare prima di posizionarsi
       all'inizio del campo.  Il valore di FS `e ignorato.  Assegnando un nuovo valore a  FS  o  a
       FPAT si annulla l'effetto di FIELDWIDTHS.

       Similmente,  se alla variabile FPAT `e assegnata una stringa che rappresenta un'espressione
       regolare, ogni campo `e 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`o essere individuato dalla sua posizione: $1, $2, e cos`i
       via.  $0 `e l'intero record, compresi eventuali spazi bianchi iniziali  e  finali.   Non  `e
       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`e campi dopo $NF) producono la stringa vuota.  Tut-
       tavia, l'assegnamento ad un campo inesistente (per esempio $(NF+2) = 5)  provoca  l'incre-
       mento  del  valore di NF, crea tutti i campi intermedi assegnando loro la stringa nulla, e
       fa s`i che il valore di $0 sia ricalcolato utilizzando OFS per separare i  campi.   Riferi-
       menti 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,  uti-
       lizzando 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 `e indicizzato da  0
                   ad  ARGC  -  1.   La modifica dinamica del contenuto di ARGV pu`o controllare i
                   file usati per i dati.

       BINMODE     Su sistemi non-POSIX, specifica l'uso della modalit`a  "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 out-
                   put, rispettivamente, dovrebbero usare I/O binari.  I valori di stringa "rw" e
                   "wr"  specificano che tutti i file dovrebbero usare I/O binari.  Qualsiasi al-
                   tro valore di stringa `e trattato come "rw", ma genera un messaggio di avverti-
                   mento.

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

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

                   In  modalit`a 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 pro-
                   grammi 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 viene im-
                   postato a una stringa  che  descrive  l'errore.   Il  valore  `e  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 cor-
                   rispondente  valore numerico pu`o essere trovato in PROCINFO["errno"].  Per er-
                   rori non di sistema, l'elemento PROCINFO["errno"] varr`a zero.

       FIELDWIDTHS Una lista di dimensioni di campo separate da spazi. Se impostato, gawk  suddi-
                   vide  l'input  secondo campi di larghezza fissa, anzich'e usare il valore della
                   variabile FS come separatore di campo.  Ogni larghezza di campo pu`o  opzional-
                   mente essere preceduta da un valore, separato da una virgola, che specifica il
                   numero di caratteri da saltare prima di posizionarsi all'inizio del campo.  Si
                   veda Campi, pi`u sopra.

       FILENAME    Il  nome  del file di input corrente.  Se non sono specificati file nella riga
                   di comando, il valore di FILENAME `e  "-".   Tuttavia,  FILENAME  `e  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 di FS come separatore di
                   campo.  Si veda Campi, pi`u sopra.

       FS          Il separatore di campo, quello predefinito `e uno spazio.  Si veda  Campi,  pi`u
                   sopra.

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

       IGNORECASE  Controlla  la  sensibilit`a 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 corrispon-
                   denze nei criteri di ricerca, la separazione di campi tramite FS  e  FPAT,  la
                   separazione  di  record tramite RS, la ricerca di corrispondenze nelle espres-
                   sioni regolari con ~ e !~, e le funzioni  predefinite  gensub(),  gsub(),  in-
                   dex(),  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`i, se IGNORECASE `e  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 `e  zero,  cosicch'e  tutte  le  operazioni  sulle
                   espressioni regolari e su stringhe normalmente distinguono tra maiuscole e mi-
                   nuscole.

       LINT        Fornisce un controllo dinamico dell'opzione --lint  dall'interno  di  un  pro-
                   gramma  AWK.  Quando il valore `e "vero", gawk stampa avvertimenti lint. Quando
                   `e "falso", no.  I valori specificabili con l'opzione --lint possono anche  es-
                   sere  assegnati  alla  variabile  d'ambiente LINT, e hanno gli stessi effetti.
                   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 `e "%.6g".

       OFS         Il separatore di campi in uscita, normalmente `e 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] `e il valore predefinito.

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

                   PROCINFO["argv"]     Gli argomenti sulla riga di comando come  sono  visti  da
                                        gawk a livello di linguaggio C.  Gli indici partono dallo
                                        zero.

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

                   PROCINFO["errno"]    Il valore di errno(3) quando ERRNO `e impostato al messag-
                                        gio di errore associato.

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

                   PROCINFO["FS"]       "FS"  se  la separazione in campi con FS `e attiva, "FPAT"
                                        se la separazione in campi con  FPAT  `e  attiva,  "FIELD-
                                        WIDTHS"  se la separazione in campi con FIELDWIDTHS `e at-
                                        tiva, o "API" se la separazione in campi con  l'analizza-
                                        tore di input API `e 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 val-
                                        ori 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  `e  uno  fra
                                        questi:

                                        "array"     L'identificatore `e un vettore.

                                        "builtin"   L'identificatore `e una funzione predefinita.

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

                                        "scalar"    L'identificatore `e uno scalare.

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

                                        "user"      L'identificatore  `e  una  funzione   definita
                                                    dall'utente.

                   PROCINFO["pgrpid"]   Il valore dalla chiamata di sistema getpgrp(2).

                   PROCINFO["pid"]      Il valore dalla chiamata di sistema getpid(2).

                   PROCINFO["platform"] Una  stringa che indica la piattaforma sulla quale gawk `e
                                        stato  compilato.   Pu`o  essere  una  delle   alternative
                                        seguenti:

                                        "djgpp", "mingw"
                                               Microsoft   Windows,  compilato  tramite  DJGPP  o
                                               MinGW, rispettivamente.

                                        "os2"  OS/2.

                                        "posix"
                                               GNU/Linux, Cygwin, Mac OS  X,  e  i  sistemi  Unix
                                               precedenti.

                                        "vms"  OpenVMS o Vax/VMS.

                   PROCINFO["ppid"]     Il valore della chiamata di sistema getppid(2).

                   PROCINFO["strftime"] La  stringa  di  formato  data/ora  predefinita per strf-
                                        time().  Cambiandone il valore cambia anche il  modo  con
                                        cui strftime() visualizza i valori di data e ora se chia-
                                        mata senza specificare argomenti.

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

                   PROCINFO["version"]  La versione di gawk.

                   I seguenti elementi sono presenti se `e disponibile il caricamento delle esten-
                   sioni 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 `e stato compilato in
                   gawk:

                   PROCINFO["gmp_version"]
                          La versione della libreria GNU GMP 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 diventano non
                          fatali.

                   PROCINFO["nome", "NONFATAL"]
                          Rende gli errori relativi a nome non fatali.

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

                   PROCINFO["input", "READ_TIMEOUT"]
                          Il  tempo  massimo a disposizione in millisecondi per leggere i dati da
                          input, dove input `e 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 restituisce -2  in-
                          vece 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`o tornare utile nel caso si utilizzi PROCINFO["in-
                          put",  "READ_TIMEOUT"]  o in situazioni in cui un descrittore di file `e
                          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`o  essere  anche il nome (come stringa) di una qualsiasi fun-
                          zione 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`a  di  arrotondamento da usare per operazioni sui numeri con
                          precisione arbitraria, quella predefinita `e "N" (IEEE-754  roundTiesTo-
                          Even mode).  Sono accettati i valori:

                          "A" o "a"
                                 per arrotondamento lontano da zero (per eccesso).  Questi valori
                                 sono disponibili solo se la versione  della  libreria  GNU  MPFR
                                 supporta gli arrotondamenti lontano da zero.

                          "D" o "d" per roundTowardNegative.

                          "N" o "n" per roundTiesToEven.

                          "U" o "u" per roundTowardPositive.

                          "Z" o "z" per roundTowardZero.

                   RS     Il separatore di record in input (se non specificato `e "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 in-
                          izino da uno).

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

                   SUBSEP La stringa usata per separare indici multipli negli elementi di un vet-
                          tore, quella predefinita `e "\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`o
                          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 typeof() pu`o essere usata per controllare se un elemento in
                          SYMTAB `e un vettore.  Non `e possibile usare l'istruzione delete per  il
                          vettore  SYMTAB  e  neppure impostare elementi il cui indice non sia un
                          nome di variabile.

                   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
       `e formata da una lista di espressioni (expr, expr ...)  l'indice del vettore `e una stringa
       ottenuta  concatenando  i  valori (stringa) di ogni espressione, separati dal valore della
       variabile SUBSEP.  Questa modalit`a `e 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 `e indicizzato dalla
       stringa "A\034B\034C".  In AWK, tutti i vettori sono associativi, cio`e indicizzati da val-
       ori di tipo stringa.

       L'operatore  speciale  in pu`o 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`o 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`o essere cancellato  con  l'istruzione  delete.   L'istruzione
       delete  pu`o  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  ``ret-
       tangolare'' come in C or C++.  Per esempio:

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

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

   Spazi-dei-nomi
       Gawk fornisce una semplice funzionalit`a, namespace, (spazio-dei-nomi) per ovviare al fatto
       che tutte le variabili in AWK sono globali.

       Un  nome  qualificato  consiste di due identificativi semplici, congiunti da una coppia di
       due punti (::).  Il primo dei due identificativi designa  lo  spazio-dei-nomi  (namespace)
       mentre  il  secondo  `e il nome della variabile al suo interno.  Tutti i nomi semplici (non
       qualificati) sono considerati come  appartenenti  allo  spazio-dei-nomi  ``corrente'';  lo
       spazio-dei-nomi  predefinito  ha  nome  awk.  Comunque, gli identificativi i cui nomi sono
       composti solo da lettere maiuscole, vengono sempre considerati come  facenti  parte  dello
       spazio-dei-nomi awk, anche se lo spazio-dei-nomi corrente `e diverso da quello predefinito.

       Si pu`o cambiare lo spazio-dei-nomi corrente tramite la direttiva @namespace "nome".

       I  nomi  delle  funzioni  interne  predefinite  non  possono essere usati come nomi di uno
       spazio-dei-nomi.  I nomi di ulteriori funzioni, fornite da gawk possono essere usati  come
       nomi  di  uno spazio-dei-nomi o come semplici identificativi in altri spazi-dei-nomi.  Per
       ulteriori dettagli, vedere GAWK: Effective AWK Programming.

   Notazione e conversione delle variabili
       Le variabili e i campi possono essere numeri (in virgola mobile), stringhe, o entrambe  le
       cose.   Possono anche essere espressioni regolari.  Come sia interpretato il valore di una
       variabile dipende dal contesto.  In un'espressione numerica, sar`a trattato come un numero;
       usato come stringa, sar`a trattato come tale.

       Per far trattare una variabile come numero, le si sommi zero; per ottenere che venga trat-
       tata come come stringa, le si concateni la stringa nulla.

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

       Quando una stringa deve essere convertita in un numero, la conversione `e compiuta con str-
       tod(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`i, 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`a POSIX (come con l'opzione --posix), bisogna fare atten-
       zione 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 con-
       frontate numericamente.  Se una `e numerica e l'altra `e  una  stringa  interpretabile  come
       "stringa  numerica," sono pure confrontate numericamente.  Negli altri casi, gli eventuali
       valori numerici sono convertiti in stringhe, ed `e  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  `e 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 `e uguale al decimale 9, e il valore esadecimale 0x11
       `e 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" `e il carattere ASCII ESC (escape).

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

       \c   Il carattere letterale c.

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

   Costanti di tipo Regexp
       Una  costante di tipo espressione regolare `e una sequenza di caratteri racchiusa tra barre
       (come /valore/).  Come stabilire una corrispondenza  con  un'espressione  regolare  `e  de-
       scritto in maniera pi`u dettagliata pi`u avanti; vedere Espressioni regolari.

       Le  sequenze  di protezione descritte sopra si possono usare anche all'interno di costanti
       che sono espressioni regolari (p.es., /[ \t\f\n\r\v]/ corrisponde a tutti i caratteri  non
       stampabili [bianchi]).

       Gawk  consente  anche  di usare costanti formate da espressioni regolari fortemente tipiz-
       zate.  I nome di tali costanti sono preceduti da un simbolo @ (cos`i:  @/valore/).   Queste
       costanti  possono essere assegnare a scalari (variabili, elementi di un vettore) e passate
       a funzione definite dall'utente.  Le variabili il cui valore `e stato assegnato  in  questo
       modo hanno come tipo quello di variabili di espressioni regolari.

CRITERI DI RICERCA E AZIONI
       AWK  `e  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 `e 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 ||.  Anche  le  istruzioni  in  righe
       terminanti  con  do  o  else continuano automaticamente alla riga successiva.  Negli altri
       casi, un'istruzione pu`o continua sulla riga successiva se termina con "\", nel  qual  caso
       il "newline" `e ignorato.  Comunque, un "\" che venga dopo un carattere # non `e speciale.

       Si  possono  scrivere pi`u istruzioni sulla stessa riga separandole con ";".  Questo si ap-
       plica sia alle istruzioni all'interno di un'azione (il caso pi`u  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 `e 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 le cui azioni sono  eseguite  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  `e una stringa vuota se il file `e stato aperto con successo.  Altri-
       menti, 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 `e 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`u avanti.

       In  un'espressione  relazionale  si  pu`o  usare qualsiasi operatore definito nella sezione
       sulla azioni, pi`u avanti.  Generalmente l'espressione relazionale `e utilizzata per verifi-
       care 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  stret-
       tamente  necessario  a  decidere il risultato, a partire da quello pi`u a sinistra ("short-
       circuit evaluation").  Sono usati per combinare espressioni di ricerca pi`u semplici.  Come
       nella maggior parte dei linguaggi, si possono usare parentesi per cambiare l'ordine di va-
       lutazione.

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

       Un'espressione nella forma criterio1, criterio2 `e detta criterio intervallo.   Essa  indi-
       vidua  tutti  i  record  a  partire  da quello che ha corrispondenza con criterio1, fino a
       quello che corrisponde a criterio2, compreso.  Non pu`o 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.  Per ag-
                  giungere alla lista il carattere trattino, inserirlo  all'inizio  o  alla  fine
                  della lista stessa.

       [^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`u r.

       r*         Corrisponde a zero o pi`u 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 in-
                  tervallo.   Se  c'`e  un numero tra parentesi graffe, l'espressione regolare che
                  precede r `e ripetuta n volte. Se tra parentesi graffe ci sono due numeri  sepa-
                  rati da virgola, r `e ripetuta da n ad m volte.  Se c'`e un numero seguito da una
                  virgola, r `e 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 qual-
                  siasi 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`e
                  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  (vedere  Costanti  di
       tipo stringa) sono ammesse anche nelle espressioni regolari.

       Le  classi  di caratteri sono una nuova funzionalit`a introdotta nello standard POSIX.  Una
       classe di caratteri `e una speciale notazione per indicare liste di caratteri accomunati da
       uno  specifico  attributo,  dove  per`o 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 `e diversa da quella valida in Francia.

       Una  classe di caratteri `e 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 `e stampabile ma non
                  visibile, mentre a `e entrambe le cose).

       [:lower:]  Caratteri alfabetici minuscoli.

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

       [:punct:]  Caratteri  di punteggiatura (cio`e caratteri che non siano n'e lettere, n'e cifre,
                  n'e caratteri di controllo, n'e 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 scri-
       vere /[A-Za-z0-9]/ per individuare caratteri alfanumerici.  Qualora il  set  di  caratteri
       vigente  avesse  compreso  altri  caratteri alfanumerici, l'espressione non li avrebbe ri-
       conosciuti, 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`o scrivere /[[:alnum:]]/, che trover`a corrispondenza  con  i  caratteri  alfa-
       betici e numerici previsti dal set di caratteri in uso, qualunque esso sia.

       Nelle  liste  di caratteri possono comparire due sequenze speciali aggiuntive. Esse si ap-
       plicano ai set di caratteri non ASCII, i quali possono  comprendere  sia  simboli  singoli
       (chiamati  elementi  di  collazione)  rappresentati  da pi`u 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 `e un elemento di confronto costituito da pi`u di un carat-
              tere racchiuso tra [.  e .].  Per esempio, se ch `e un elemento di  collazione,  al-
              lora  [[.ch.]]  `e l'espressione regolare che lo individua, mentre [ch] `e un'espres-
              sione regolare che individua o il carattere c o il carattere h.

       Classi di Equivalenza
              Una classe di equivalenza `e un nome, dipendente dalla localizzazione,  associato  a
              una lista di caratteri tra loro equivalenti.  Il nome `e racchiuso tra [= e =].  Per
              esempio, il nome e potrebbe essere usato per rappresentare globalmente i  caratteri
              "e", "e'", ed "e`".  In questo caso, [[=e]] `e un'espressione regolare compatibile con
              uno qualsiasi dei caratteri e, 'e, ed `e.

       Queste funzionalit`a sono molto apprezzabili quando la lingua corrente non `e 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'e 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 inter-
       preta i caratteri nelle espressioni regolari.

       Nessuna opzione
              In assenza di indicazioni, gawk mette a disposizione tutte le facilitazioni  carat-
              teristiche delle espressioni regolari POSIX e degli operatori GNU descritti pi`u so-
              pra.

       --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  rego-
              lari.

       --re-interval
              Sono  permesse  le espressioni di intervallo, anche se `e stato specificato --tradi-
              tional.

   Azioni
       Le istruzioni di azione sono racchiuse tra parentesi  graffe,  {  e  }.   L'insieme  delle
       istruzioni di azione `e formato dalle solite istruzioni di assegnamento, condizionali e it-
       erative presenti nella maggior parte dei linguaggi.  Gli operatori, le strutture  di  con-
       trollo 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`o anche usare ** al suo posto, e **= nell'assegna-
                   mento con operatore).

       + - !       Pi`u 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'espres-
                   sione /foo/ ~ exp equivale a richiedere (($0 ~ /foo/) ~ exp).  Di solito non `e
                   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  ?  espres-
                   sione2  :  espressione3.  Se espressione1 `e vera, il valore dell'espressione `e
                   espressione2, altrimenti `e 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 coprocesso.  Il parametro  fa-
                                     coltativo  come  dovrebbe  essere  usato  solo  per chiudere
                                     un'estremit`a di una pipe bi-direzionale aperta con un copro-
                                     cesso.  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; imposta 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 coprocesso dirigendo l'output [del
                                     comando] o in $0 o in variabile, come sopra, e RT.  I copro-
                                     cessi sono un'estensione gawk.  (Il comando pu`o anche essere
                                     un socket.  Vedere la sottosezione Nomi  di  file  speciali,
                                     pi`u avanti.)

       next                          Cessa l'elaborazione della riga di input corrente.  Legge la
                                     successiva riga di input, e l'elaborazione ricomincia a par-
                                     tire  dal  primo  criterio di ricerca del programma AWK.  Se
                                     non ci sono pi`u righe in input, gawk  esegue  i  comandi  di
                                     ogni regola END, se presenti.

       nextfile                      Cessa   l'elaborazione  del  file  di  input  corrente.   La
                                     prossima riga letta proverr`a dal file di  input  successivo.
                                     Aggiorna  FILENAME  e  ARGIND, reimposta FNR a 1, e l'elabo-
                                     razione riprende dal primo criterio di ricerca del programma
                                     AWK.   Se  non ci sono pi`u righe in input, gawk esegue i co-
                                     mandi di ogni regola ENDFILE ed 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 `e 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 `e
                                     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`u
                                     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  val-
                                     ore  d'uscita.  (pu`o non essere disponibile sui sistemi non-
                                     POSIX).  Si veda GAWK: Effective AWK Programming 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 `e  specifi-
                                     cato  o  ha per valore la stringa nulla, l'operazione `e ese-
                                     guita 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 l'output alla fine di file.

       print ... | comando
              Scrive su una pipe.

       print ... |& comando
              Invia dati a un coprocesso o a un socket.  (Vedere anche la  sottosezione  Nomi  di
              file speciali, pi`u avanti).

       Il comando getline restituisce 1 se tutto va bene, zero 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`o essere  ritentata,
       e  PROCINFO["input",  "RETRY"] `e stato impostato, viene restituito il valore -2 invece che
       -1 e ulteriori chiamate a getline possono essere effettuate.  A fronte di un errore  ERRNO
       `e 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 coprocesso, 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 auto-
       maticamente pipe, socket, o coprocessi quando questi restituiscono EOF.

   L'istruzione printf
       Le versioni di AWK dell'istruzione printf e della funzione sprintf() (vedi pi`u avanti) ac-
       cettano i seguenti formati di richiesta conversione:

       %a, %A  Un numero a virgola mobile nel formato  [-]0xh.hhhhp+-dd  (formato  esadecimale  a
               virgola mobile di C99).  Per %A, si usano lettere maiuscole invece che lettere mi-
               nuscole.

       %c      Un singolo carattere.  Se l'argomento usato per %c `e numerico, `e considerato  come
               un  carattere e stampato.  Altrimenti, si suppone che l'argomento sia una stringa,
               e ne `e 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 e.

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

       %g, %G  Usa la conversione %e o %f, (la pi`u 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'`e 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 `e detto uno
              specificatore posizionale ed `e 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`u" usato prima del modificatore di dimensione (vedi pi`u avanti) indica
              che nelle conversioni numeriche il segno deve essere sempre presente, anche  se  il
              valore da riportare `e positivo.  + annulla l'effetto del modificatore "spazio".

       #      Usa  una  "forma alternativa" per alcune lettere di controllo.  Associato a %o, ag-
              giunge 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`a
              sempre il separatore decimale.  Con %g, e %G, gli zeri in coda non sono rimossi dal
              risultato.

       0      Uno  0  (zero) iniziale svolge una funzione di flag, per indicare che l'output deve
              essere preceduto da zeri anzich'e da spazi.  Questo vale solo per i formati numerici
              in  output..   Questo flag ha effetto solo quando la larghezza del campo `e 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 lo-
              calizzazione per i numeri in virgola mobile.  `E richiesto che la  libreria  C  sup-
              porti  correttamente  la  localizzazione  e che questa sia stata definita corretta-
              mente.

       ampiezza
              Il numero dovrebbe occupare questo numero di byte.  Il numero `e normalmente  prece-
              duto da spazi.  In presenza del flag 0, `e 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 sep-
              aratore  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 il formato %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`a s`i che i loro valori
       siano presi dalla lista degli argomenti di printf o sprintf().  Per usare  uno  specifica-
       tore  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`a aperti ereditati dal processo genitore di gawk (la shell,  soli-
       tamente).   Questi  nomi di file possono anche essere usati nella riga di comando per des-
       ignare 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 `e andata male!" > "/dev/stderr"

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

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

       I seguenti nomi di file speciali si possono usare con l'operatore  |&  di  coprocesso  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 IPv4).  Si pu`o usare solo con
              l'operatore bidirezionale di I/O |& .

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

       log(espressione)     Logaritmo a base naturale.

       rand()               Restituisce un numero casuale N, tra zero e uno, 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  `e  indicata, sar`a utilizzata il tempo corrente,
                            misurato in secondi dal 1970.   Il  valore  restituito  `e  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 nor-
                                       mali di gawk per confrontare fra loro i valori, e sostitu-
                                       isce 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 modi-
                                       ficare gli indici del vettore di partenza s.   La  stringa
                                       facoltativa come controlla la direzione e il modo del con-
                                       fronto.  Valori ammissibili per  come  sono  quelli  delle
                                       stringhe  ammissibili  per  PROCINFO["sorted_in"].  Si pu`o
                                       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 `e lo stesso di asort(), con la dif-
                                       ferenza che l'ordinamento `e fatto usando  gli  indici  del
                                       vettore,  e non i valori.  Fatto l'ordinamento, il vettore
                                       `e 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 `e lo stesso descritto in precedenza per asort().

       gensub(r, s, h [, t])           Cerca  nella  stringa  obiettivo  t   corrispondenze   con
                                       l'espressione  regolare  r.  Se h `e una stringa che inizia
                                       con g o G, tutte le corrispondenze con r  sono  sostituite
                                       con  s.   Altrimenti, h `e un numero che indica la partico-
                                       lare corrispondenza con r che si vuole sostituire.   Se  t
                                       non  `e  specificata, `e usato $0 al suo posto.  All'interno
                                       del testo di rimpiazzo s si pu`o utilizzare la sequenza \n,
                                       dove  n  `e  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 cor-
                                       rispondente, e cos`i pure il carattere &.  A differenza  di
                                       sub()  e  gsub(),  la stringa modificata `e 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 `e specificata, usa
                                       $0.  Una & nel testo di rimpiazzo `e 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`u  completa  delle  regole  sull'uso
                                       della  "e  commerciale"  (ampersand) 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  zero se la stringa t non `e presente.  (Ci`o
                                       implica che gli indici di una stringa di caratteri partono
                                       da  1.)  `E 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 `e 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 zero se r non `e presente, e  imposta  i
                                       valori  di  RSTART  e RLENGTH.  Si noti che l'ordine degli
                                       argomenti `e 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'ele-
                                       mento  di  indice  zero  di  a contiene la parte di s cor-
                                       rispondente 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, rispetti-
                                       vamente, di ogni sottostringa individuata.

       patsplit(s, a [, r [, seps] ])  Suddivide la stringa s nel vettore a e il vettore dei sep-
                                       aratori 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]  `e  il  separatore  (che  potrebbe anche essere la
                                       stringa nulla) individuato davanti a a[i].  Il  valore  di
                                       seps[0]  `e  il separatore iniziale (che potrebbe anche es-
                                       sere la stringa nulla).  Se r `e omesso, FPAT  viene  usato
                                       al suo posto.  I vettori a e seps sono svuotati all'inizio
                                       dell'operazione.  La suddivisione si comporta come la sud-
                                       divisione in campi con FPAT, descritta sopra.

       split(s, a [, r [, seps] ])     Suddivide la stringa s nel vettore a e nel vettore di sep-
                                       aratori seps individuati dall'espressione  regolare  r,  e
                                       restituisce il numero di campi.  Se r `e omessa, il separa-
                                       tore utilizzato `e FS.  I vettori a e  seps  sono  svuotati
                                       all'inizio  dell'operazione.   seps[i]  `e il separatore di
                                       campo individuato da r tra a[i] e  a[i+1].   Se  r  `e  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 `e il valore restituito da split(s,
                                       a, r, seps).  La suddivisione si comporta come la suddivi-
                                       sione in campi, descritta sopra.  Nel caso particolare  in
                                       cui r `e una stringa composta da un unico carattere, quella
                                       stringa fa da separatore,  anche  se  il  carattere  `e  un
                                       metacarattere di un'espressione regolare.

       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, `e considerato un numero ottale.  Se str
                                       inizia con uno 0x o 0X, `e considerato un  numero  esadeci-
                                       male.   Altrimenti,  viene  interpretato come numero deci-
                                       male.

       sub(r, s [, t])                 Si comporta come gsub(), ma `e  sostituita  solo  la  prima
                                       sottostringa trovata.  Viene restituito zero oppure uno.

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

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

       toupper(str)                    Restituisce una copia  della  stringa  str,  con  tutti  i
                                       caratteri  minuscoli  di  str  tradotti nei maiuscoli cor-
                                       rispondenti.   I  caratteri  non  alfabetici  restano  in-
                                       variati.

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

   Funzioni di tempo
       Poich'e uno dei principali campi di applicazione dei programmi  AWK  `e  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 [, utc-flag])
                 Traduce  datespec  In  una  marcatura  temporale nello stesso formato restituito
                 dalla funzione [del linguaggio C] systime(), e  restituisce  il  risultato.   Il
                 parametro datespec `e una stringa nella forma YYYY MM DD HH MM SS[ DST].  Il con-
                 tenuto della stringa consiste in sei o sette numeri che rappresentano  rispetti-
                 vamente:  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.
                 Se il flag utc-flag `e presente e diverso da zero e dalla stringa nulla, il tempo
                 `e supposto essere quello del fuso orario UTC [ora di Greenwich]; altrimenti,  si
                 suppone  che  il  tempo sia quello del fuso orario locale.  Se il flag DST (day-
                 light saving time - ora legale) `e positivo, si suppone che ci si trovi in un pe-
                 riodo  dell'anno in cui vige l'ora legale; se vale zero, l'ora `e ritenuta essere
                 quella standard [ora di Greenwich]; se `e negativa  (questo  `e  il  comportamento
                 predefinito),  mktime() tenta di determinare se `e in vigore l'ora legale nel mo-
                 mento specificato.  Se datespec non contiene sufficienti elementi o se il  tempo
                 risultante `e fuori intervallo, mktime() restituisce -1.

       strftime([format [, timestamp[, utc-flag]]])
                 Formatta timestamp secondo quanto specificato in format.  Se utc-flag `e presente
                 e diversa da zero o dalla stringa nulla, il risultato `e in UTC  [ora  di  Green-
                 wich],  altrimenti il risultato `e nell'ora locale.  Il timestamp dovrebbe essere
                 nella forma utilizzata da systime().  Se timestamp `e omesso, sono utilizzate  la
                 data  e  l'ora correnti.  Se format `e omesso, `e assunto un formato equivalente a
                 quello dell'output del comando date(1).  Il formato predefinito `e 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 con-
       vertendo 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 mo-
       bile.

       NOTA: Se a una delle funzioni seguenti si forniscono operandi negativi, il risultato `e  un
       errore fatale.

       Le funzioni sono:

       and(v1, v2 [, ...])     Restituisce  il  risultato  derivante dall'applicazione della fun-
                               zione 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  fun-
                               zione  booleana  XOR  bit  per bit ai valori degli argomenti della
                               lista degli argomenti.  Gli argomenti devono essere almeno due.

   Funzioni di tipo
       Le seguenti funzioni forniscono informazioni relative agli argomenti che vengono loro pas-
       sati.

       isarray(x) Restituisce  "Vero" se x `e un vettore, altrimenti restituisce "Falso".  [0 e la
                  stringa nulla significano "Falso". Qualsiasi  altro  valore  sta  per  "Vero".]
                  Questa  funzione `e destinata principalmente a essere usata con elementi di vet-
                  tori multidimensionali, e con parametri usati da funzioni.

       typeof(x)  Restituisce una stringa che indica il tipo  di  x.   La  stringa  sar`a  una  di
                  queste:  "array", "number", "regexp", "string", "strnum", "unassigned" o "unde-
                  fined".

   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`u 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 `e ``collegato''.
              Il valore predefinito per dominio `e il valore della variabile TEXTDOMAIN.   Se  di-
              rectory  `e  impostato alla stringa nulla (""), bindtextdomain() restituisce il col-
              legamento corrente per il dato dominio.

       dcgettext(stringa [, dominio [, categoria]])
              Restituisce la traduzione della stringa nel dominio di testo dominio per la catego-
              ria  di  localizzazione  categoria.   Il valore predefinito per dominio `e il valore
              corrente della  variabile  TEXTDOMAIN.   Il  valore  predefinito  per  categoria  `e
              "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  Program-
              ming.  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 `e il valore corrente della variabile  TEXTDOMAIN.
              Il valore predefinito per categoria `e "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  Program-
              ming.  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 vengono eseguite se chiamate dall'interno di espressioni, presenti sia all'in-
       terno  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'e  le  funzioni  non  erano in origine previste nel linguaggio AWK, la gestione delle
       variabili locali `e piuttosto goffa: sono dichiarate semplicemente come  parametri  in  pi`u
       nella  lista  dei parametri formali.  Per convenzione, si usa separare le variabili locali
       dai veri parametri con qualche spazio in pi`u 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`a sintattica con
       l'operatore di concatenazione [di stringhe].  Questa restrizione non si applica alle  fun-
       zioni 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  nu-
       mero zero al momento dell'invocazione.

       Si  usi  return expr per restituire un valore da una funzione.  Il valore di ritorno `e in-
       definito se non si fornisce alcun valore, o se la funzione  ritorna  automaticamente  dopo
       aver  eseguito  l'ultima  istruzione  della funzione stessa, nella modalit`a detta "falling
       off".

       Come estensione gawk le funzioni possono essere  chiamate  indirettamente.   Per  far  ci`o
       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`o vedere qui sotto:
              function mia_funzione()
              {
                   print "mia_funzione `e 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 `e stata data l'opzione --lint, gawk avvertir`a in caso di chiamate a funzioni indefinite
       al  momento  della  valutazione sintattica del programma anzich'e durante l'esecuzione.  La
       chiamata di una funzione indefinita in fase di esecuzione `e un errore fatale.

       Si pu`o usare la parola func al posto di function.  anche se questo modo di operare `e  dep-
       recato.

CARICARE DINAMICAMENTE NUOVE FUNZIONI
       Si  possono  aggiungere dinamicamente nuove funzioni scritte in C o C++ all'interpretatore
       gawk in esecuzione tramite l'istruzione @load.  Una descrizione dettagliata non  `e  possi-
       bile 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, `e possibile segnare delle stringhe in un programma AWK
       per  richiederne la traduzione nel linguaggio utilizzato in loco.  Tali stringhe sono pre-
       cedute 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  im-
           postare il dominio del testo a un nome associato al programma in uso:

                BEGIN { TEXTDOMAIN = "mio_programma" }

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

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

       3.  Se  `e  il caso, usare le funzioni dcgettext() e/o bindtextdomain() nel programma, sec-
           ondo necessit`a.

       4.  Eseguite il comando gawk --gen-pot -f mio_programma.awk > mio_programma.pot per gener-
           are  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  cor-
           rispondente  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`A POSIX
       Un  obiettivo fondamentale di gawk `e la compatibilit`a 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  in-
       cluse nello standard POSIX.

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

       Nella scansione degli argomenti, gawk usa l'opzione speciale "--" per  segnalare  la  fine
       degli argomenti.  In modalit`a compatibile, emette un messaggio e poi ignora le opzioni non
       disponibili.  Nella modalit`a 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 `e stato usato, per consentire di tener  trac-
       cia  delle  sequenze di numeri casuali.  Pertanto srand() in gawk restituisce anche il suo
       "seme" corrente.

       Altre funzionalit`a 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  pre-
       definite tolower() e toupper() (dalla versione Bell Laboratories); e le specifiche di con-
       versione ISO C in printf (presenti per prime nella versione Bell Laboratories).

FUNZIONALIT`A STORICHE
       C'`e una caratteristica dell'implementazione storica di AWK che gawk supporta: `E  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`a `e una pratica deprecata, e gawk emette un messaggio di  avverti-
       mento 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`a di gawk sono sono disponibili nella versione POSIX di awk.

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

       +o Non c'`e modo di includere dei file da programma (il meccanismo gawk di @include).

       +o Non c'`e modo di aggiungere dinamicamente nuove funzioni scritte in C  (meccanismo  @load
         di gawk).

       +o La sequenza di protezione \x.

       +o La possibilit`a di continuare delle righe dopo un ?  e i :.

       +o Costanti ottali ed esadecimali nei programmi AWK.

       +o Le  variabili  ARGIND,  BINMODE,  ERRNO, LINT, PREC, ROUNDMODE, RT e TEXTDOMAIN non sono
         speciali.

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

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

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

       +o I vettori FUNCTAB, SYMTAB, e PROCINFO non sono disponibili.

       +o L'uso della variabile RS come espressione regolare.

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

       +o L'operatore |& utilizzabile per creare coprocessi.

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

       +o La possibilit`a di separare fra loro singoli caratteri usando la stringa nulla come  val-
         ore per la variabile FS, e come terzo argomento nella funzione split().

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

       +o Il secondo argomento opzionale della funzione close().

       +o Il terzo argomento opzionale della funzione match().

       +o La possibilit`a di usare specificatori posizionali con printf e sprintf().

       +o La possibilit`a di avere un vettore come argomento alla funzione length().

       +o Le  funzioni  and(),  asort(), asorti(), bindtextdomain(), compl(), dcgettext(), dcnget-
         text(), gensub(), lshift(),  mktime(),  or(),  patsplit(),  rshift(),  strftime(),  str-
         tonum(), systime() e xor().

       +o Stringhe traducibili in varie lingue.

       +o Errore di I/O non-fatale.

       +o I/O ritentabile.

       Il  libro  AWK  non definisce il valore restituito dalla funzione close().  Invece la fun-
       zione 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 `e  -1  se
       il file, la pipe o il coprocesso in questione non sono stati aperti con una ridirezione.

       Quando  gawk  `e  invocato  con l'opzione --traditional, se l'argomento fs all'opzione -F `e
       "t", FS `e 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'e questo `e un caso speciale piuttosto antipatico, non `e il comporta-
       mento  predefinito.   Questo  comportamento  non viene seguito neppure quando si specifica
       --posix.  Per ottenere che un carattere <TAB> faccia da delimitatore di  campo,  `e  meglio
       usare apici singoli: gawk -F'\t' ....

VARIABILI D'AMBIENTE
       La  variabile  d'ambiente  AWKPATH pu`o 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,  e  tramite la direttiva @include.  Se la ricerca iniziale non ha successo, una
       seconda ricerca `e effettuata accodando .awk al nome del file indicato.

       La variabile d'ambiente AWKLIBPATH pu`o 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`o essere usata per specificare un tempo mas-
       simo 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  quello
       successivo.   L'intervallo `e in millisecondi.  Su sistemi che non supportano usleep(3), il
       valore `e 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 `e stato specificato,
       gawk emette un messaggio di avvertimento riguardo a questo.

STATO DI USCITA
       Se l'istruzione exit `e 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 `e normalmente zero.

       In caso di errore, gawk termina con il valore della costante C EXIT_FAILURE.  Questo  val-
       ore `e normalmente uno.

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

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

AUTORI
       La versione originale di UNIX awk `e 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 `e 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 `e 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 `e molto  datata,
       il problema potrebbe essere gi`a stato risolto.  Secondariamente, siete pregati di control-
       lare se impostando la variabile d'ambiente LC_ALL a LC_ALL=C faccia  s`i  che  il  problema
       scompaia.   Se cos`i `e, si tratta di un problema legato alla localizzazione, che pu`o essere
       o meno un errore.  Infine, siete pregati di leggere questa man page e il manuale di rifer-
       imento 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 mes-
       saggi di segnalazione di errore `e  una  maniera  poco  affidabile  per  segnalare  errori.
       Analogamente,  NON usare una comunit`a web (tipo Stack Overflow) per segnalare errori.  Si-
       ete invece pregati di usare gli indirizzi di posta elettronica riportati pi`u sopra.  Vera-
       mente!

       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'e 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 `e pi`u necessaria, vista la possibilit`a di assegnare variabili nella  riga
       di comando; viene mantenuta solo per compatibilit`a all'indietro.

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

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

       GAWK:  Effective  AWK  Programming, Edizione 5.1, disponibile con il codice sorgente gawk.
       La  versione  originale  corrente  di   questo   documento   `e   disponibile   online   a:
       https://www.gnu.org/software/gawk/manual.

       La documentazione di gettext GNU `e disponibile online a: https://www.gnu.org/software/get-
       text.

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

       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  dis-
       tribution terms for this documentation; only the original English text does that.

       Copyright  (C)  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 Foun-
       dation, Inc.

       `E 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.

       `E 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 dis-
       tribuito secondo permessi di stampa identici a questi.

       `E permesso copiare e distribuire traduzioni di questa pagina di manuale in  un'altra  lin-
       gua,  sotto  le  condizioni poste sopra per le versioni modificate, salvo che quest'infor-
       mazione sui permessi di copia e ristampa deve essere espressa in una traduzione  approvata
       dalla Free Software Foundation.

Free Software Foundation                   Aug 31 2020                                    GAWK(1)