Provided by: manpages-it_3.73-2_all bug

NOME

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

SINTASSI

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

DESCRIZIONE

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

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

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

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

FORMATO DELLE OPZIONI

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

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

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

OPZIONI

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       -O
       --optimize
              Abilita  ottimizzazioni nella rappresentazione interna del programma.  Attualmente,
              questo  comprende  il  calcolo  di  costanti,  se  possibile,  al   momento   della
              compilazione,  e  l'eliminazione della chiamata di coda per funzioni ricorsive.  Il
              manutentore di gawk spera di aggiungere nel tempo ulteriori ottimizzazioni.

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

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

              · Le sequenze di protezione \x non vengono riconosciute.

              · Quando a FS è assegnato come valore un singolo spazio, solo spazio e TAB  fungono
                da separatori di campo, il newline invece no.

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

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

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

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

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

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

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

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

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

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

ESECUZIONE DEL PROGRAMMA AWK

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

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

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

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

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

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

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

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

       Se  un  nome  di  file  nella  riga  di  comando  ha  la forma var=val, è trattato come un
       assegnamento di variabile.  Alla variabile var sarà assegnato il valore val (questo accade
       dopo  che  ogni  regola  BEGIN  è stata eseguita).  L'assegnamento di variabili da riga di
       comando è utilissima per assegnare dinamicamente valori alle variabili  che  AWK  usa  per
       controllare come l'input è organizzato in campi e record.  È utile inoltre per controllare
       variabili di stato quando siano necessari più passi di elaborazione su un singolo file  di
       dati.

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

       Per  ogni  file  in input, se esiste una regola BEGINFILE, gawk esegue il codice associato
       prima di elaborare il contenuto del file.  Similarmente, gawk esegue il codice associato a
       ENDFILE dopo l'elaborazione del file.

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

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

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

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

VARIABILI, RECORD E CAMPI

       Le variabili di AWK sono dinamiche; iniziano a esistere la prima volta che vengono  usate.
       I  loro valori sono numeri in virgola mobile, o stringhe, o entrambe le cose, a seconda di
       come sono usati la prima volta.   Inoltre  AWK  dispone  di  vettori  monodimensionali;  i
       vettori  multidimensionali  possono  essere  simulati [da vettori monodimensionali].  Gawk
       fornisce veri vettori di vettori; si veda Vettori, più avanti.  Al momento dell'esecuzione
       del  programma  sono impostate parecchie variabili predefinite; saranno descritte di volta
       in volta quando sarà necessario, ed elencate più avanti.

   Record
       Normalmente i record sono separati dal carattere newline.  Si può controllare il  modo  in
       cui  i  record  sono  separati  assegnando  valori  alla  variabile incorporata RS.  Se RS
       contiene un qualsiasi carattere singolo, tale carattere separa i record.   Altrimenti,  se
       RS  è  un'espressione  regolare,  il testo nell'input che corrisponde a questa espressione
       regolare sarà il separatore di record.  Tuttavia, nella modalità compatibile  è  preso  in
       considerazione  solo  il primo carattere della stringa risultante, come separatore.  Se RS
       contiene la stringa nulla, i record sono separati da righe vuote.  Quando RS  contiene  la
       stringa  nulla,  il  carattere  newline  ha  sempre  la funzione di separatore di campo in
       aggiunta a quello indicato dalla variabile FS, quale che esso sia.

   Campi
       Ogni volta che gawk legge un record lo spezza in campi, usando il valore  della  variabile
       FS  come separatore di campo.  Se FS è un carattere singolo, i campi sono separati da quel
       carattere.  Se FS è la stringa nulla, ogni  singolo  carattere  diventa  un  campo  a  sé.
       Diversamente,   si  presume  che  FS  sia  un'espressione  regolare  completa.   Nel  caso
       particolare in cui FS sia un singolo spazio, i campi sono separati da sequenze  di  spazi,
       caratteri di tabulazione o newline (ma si veda la sezione COMPATIBILITÀ POSIX più avanti).
       NOTA: Il valore di IGNORECASE (vedi più avanti) influenza anche il modo  in  cui  i  campi
       sono spezzati quando FS è un'espressione regolare, e come i record vengano separati quando
       RS è un'espressione regolare.

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

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

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

              n = 5
              print $n

       stampa il quinto campo del record in input.

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

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

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

   Variabili incorporate
       Le variabili incorporate di gawk sono:

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

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

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

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

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

       ENVIRON     Un  vettore  contenente  i  valori  dell'ambiente  corrente.   Il  vettore   è
                   indicizzato  dalle variabili d'ambiente, e ogni elemento è il valore di quella
                   variabile (per esempio, ENVIRON["HOME"] potrebbe essere  "/home/arnold").   La
                   modifica  di  questo  vettore  non  ha  effetto  sull'ambiente  ereditato  dai
                   programmi che gawk esegue per ridirezione o tramite la funzione system().

       ERRNO       Se ha luogo un errore di sistema durante una ridirezione per  una  getline,  o
                   durante  una  lettura fatta con getline, oppure in una close(), ERRNO conterrà
                   una stringa che descrive l'errore.  Il valore è passibile di traduzione  nelle
                   localizzazioni diverse dall'inglese.

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

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

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

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

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

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

       IGNORECASE  Controlla  la  sensibilità alla distinzione tra maiuscole e minuscole in tutte
                   le espressioni regolari e nelle operazioni sulle stringhe.  Se  IGNORECASE  ha
                   un  valore  diverso  da  zero,  il  confronto  di  stringhe  e  la  ricerca di
                   corrispondenze nei criteri di ricerca, la separazione di campi  tramite  FS  e
                   FPAT,  la separazione di record tramite RS, la ricerca di corrispondenze nelle
                   espressioni regolari con ~ e !~, e le funzioni incorporate  gensub(),  gsub(),
                   index(), match(), patsplit(), split(), e sub() ignoreranno tutti la differenza
                   tra maiuscole e minuscole nelle operazioni con le espressioni regolari.  NOTA:
                   Non  ha  effetto sugli indici dei vettori.  Tuttavia, sulle funzioni asort() e
                   asorti() ha effetto.
                   Così, se IGNORECASE è  diverso  da  zero,  /aB/  corrisponde  a  tutte  queste
                   stringhe  :  "ab", "aB", "Ab", e "AB".  Come per tutte le variabili di AWK, il
                   valore iniziale di IGNORECASE è  zero,  cosicché  tutte  le  operazioni  sulle
                   espressioni  regolari  e  su  stringhe normalmente distinguono tra maiuscole e
                   minuscole.

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

       NF          Il numero di campi nel record corrente.

       NR          Il numero totale di record incontrati finora.

       OFMT        Il formato d'uscita per i numeri, quello predefinito è "%.6g".

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

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

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

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

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

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

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

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

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

                                       "array"
                                              L'identificatore è un vettore.

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

                                       "scalar"
                                              L'identificatore è uno scalare.

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

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

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

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

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

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

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

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

                                            function cmp_func(i1, v1, i2, v2)

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

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

                   PROCINFO["mpfr_version"]
                                       La versione della libreria GNU MPFR usata per il  supporto
                                       ai  numeri con precisione arbitraria in gawk.  Questa voce
                                       non è presente se il supporto MPFR non è  stato  compilato
                                       in gawk.

                   PROCINFO["gmp_version"]
                                       La versione della libreria GNU MP usata per il supporto ai
                                       numeri con precisione arbitraria in gawk.  Questa voce non
                                       è  presente  se  il supporto MPFR non è stato compilato in
                                       gawk.

                   PROCINFO["prec_max"]
                                       La massima precisione supportata dalla libreria  GNU  MPFR
                                       per  i  numeri a virgola mobile con precisione arbitraria.
                                       Questa voce non è presente se il supporto MPFR non è stato
                                       compilato in gawk.

                   PROCINFO["prec_min"]
                                       La  minima  precisione  supportata dalla libreria GNU MPFR
                                       per i numeri a virgola mobile con  precisione  arbitraria.
                                       Questa voce non è presente se il supporto MPFR non è stato
                                       compilato in gawk.

                   PROCINFO["api_major"]
                                       La versione principale dell'estensione API.   Questa  voce
                                       non  è  presente se non è disponibile il caricamento delle
                                       estensioni dinamiche.

                   PROCINFO["api_minor"]
                                       La versione secondaria dell'estensione API.   Questa  voce
                                       non  è  presente se non è disponibile il caricamento delle
                                       estensioni dinamiche.

                   PROCINFO["version"] la versione di gawk.

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

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

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

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

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

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

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

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

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

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

   Vettori
       I vettori hanno per indice un'espressione tra parentesi quadre ([ e ]).  Se  l'espressione
       è formata da una lista di espressioni (expr, expr ...)  l'indice del vettore è una stringa
       ottenuta concatenando i valori (stringa) di ogni espressione, separati  dal  valore  della
       variabile  SUBSEP  .  Questa modalità è usata per simulare vettori multidimensionali.  Per
       esempio:

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

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

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

              if (val in vettore)
                   print vettore[val]

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

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

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

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

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

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

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

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

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

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

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

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

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

       Gawk  esegue  i  confronti  nel  modo  seguente:  Se  due  variabili  sono numeriche, sono
       confrontate numericamente.  Se una è numerica e l'altra è una stringa interpretabile  come
       “stringa  numerica,” sono pure confrontate numericamente.  Negli altri casi, gli eventuali
       valori numerici sono convertiti in stringhe, ed è  eseguito  un  confronto  tra  stringhe.
       Ovviamente, due stringhe sono confrontate come stringhe.

       Si  noti che le costanti stringa, come "57", non sono stringhe numeriche, ma solo costanti
       stringa.  L'idea di “stringa numerica” si applica solo ai campi, all'input di  getline,  a
       FILENAME,  agli  elementi  di  ARGV  di ENVIRON , ed agli elementi di un vettore creato da
       split() o da patsplit() che abbiano le caratteristiche di una  stringa  numerica.   L'idea
       fondamentale  è che i dati immessi dall'utente, e solo essi, se risultano essere numerici,
       saranno trattati come numeri.

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

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

       \\   Una barra inversa letterale.

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

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

       \f   Salto pagina (form-feed).

       \n   Nuova riga (newline).

       \r   Ritorno carrello (CR).

       \t   Tabulazione orizzontale.

       \v   Tabulazione verticale.

       \xcifre_esa
            Il carattere rappresentato dalla stringa di cifre esadecimali dopo la  \x.   Come  in
            ISO  C,  tutte le cifre esadecimali che seguono sono considerate parte della sequenza
            di protezione.  (Questa "funzionalità" la dice lunga riguardo alla  progettazione  di
            un linguaggio da parte di un comitato.)  Per esempio, "\x1B" è il carattere ASCII ESC
            (escape).

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

       \c   Il carattere letterale c.

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

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

CRITERI DI RICERCA E AZIONI

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

              { print }

       ossia stampare l'intero record.

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

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

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

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

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

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

       Per  i  criteri  del  tipo  /espressione  regolare/ l'azione associata è eseguita per ogni
       record in input che corrisponde all'espressione regolare.  Le espressioni  regolari  hanno
       la stessa forma di quelle di egrep(1), e sono descritte più avanti.

       In  un'espressione  relazionale  si  può  usare qualsiasi operatore definito nella sezione
       sulla azioni,  più  avanti.   Generalmente  l'espressione  relazionale  è  utilizzata  per
       verificare se certi campi siano individuati da determinate espressioni regolari.

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

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

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

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

       c          Corrisponde al carattere (non speciale) c.

       \c         Corrisponde al carattere c considerato letteralmente.

       .          Corrisponde a qualsiasi carattere, compreso "newline".

       ^          Corrisponde all'inizio di una stringa.

       $          Corrisponde alla fine di una stringa.

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

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

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

       r1r2       Concatenazione: corrisponde a r1, e poi r2.

       r+         Corrisponde a una o più r.

       r*         Corrisponde a zero o più r.

       r?         Corrisponde a zero o una r.

       (r)        Raggruppamento: corrisponde a r.

       r{n}
       r{n,}
       r{n,m}     Uno o due numeri racchiusi tra parentesi graffe  indicano  una  espressione  di
                  intervallo.   Se c'è un numero tra parentesi graffe, l'espressione regolare che
                  precede r è ripetuta n volte. Se  tra  parentesi  graffe  ci  sono  due  numeri
                  separati da virgola, r è ripetuta da n ad m volte.  Se c'è un numero seguito da
                  una virgola, r è ripetuta almeno n volte.

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

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

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

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

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

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

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

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

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

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

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

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

       [:alnum:]  Caratteri alfanumerici.

       [:alpha:]  Caratteri alfabetici.

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

       [:cntrl:]  Caratteri di controllo.

       [:digit:]  Caratteri numerici.

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

       [:lower:]  Caratteri alfabetici minuscoli.

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

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

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

       [:upper:]  Caratteri alfabetici maiuscoli.

       [:xdigit:] Cifre esadecimali.

       Per  fare  un  esempio,  prima  dell'introduzione  dello  standard POSIX si sarebbe dovuto
       scrivere  /[A-Za-z0-9]/  per  individuare  caratteri  alfanumerici.   Qualora  il  set  di
       caratteri  vigente  avesse  compreso  altri  caratteri  alfanumerici, l'espressione non li
       avrebbe riconosciuti, e se il set di caratteri fosse  rappresentato  in  modo  diverso  da
       ASCII,  non  sarebbero riconosciuti neanche i caratteri alfanumerici ASCII.  Con le classi
       di caratteri POSIX, si può  scrivere  /[[:alnum:]]/,  che  troverà  corrispondenza  con  i
       caratteri alfabetici e numerici previsti dal set di caratteri in uso, qualunque esso sia.

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

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

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

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

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

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

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

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

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

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

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

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

       (...)       Raggruppamento

       $           Riferimento a campi.

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

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

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

       * / %       Moltiplicazione, divisione e resto della divisione.

       + -         Addizione e sottrazione.

       spazio      Concatenazione di stringhe.

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

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

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

       in          Controllo di appartenenza a un vettore.

       &&          AND logico.

       ||          OR logico.

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

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

   Istruzioni di controllo
       Le istruzioni di controllo sono le seguenti:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       system(riga-di-comando)       Esegue il  comando  riga-di-comando,  e  ne  restituisce  il
                                     valore  d'uscita.   (può  non essere disponibile sui sistemi
                                     non-POSIX).

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

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

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

       print ... | comando
              Scrive su una pipe.

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

       Il comando getline restituirà 1 se tutto va bene, 0 in caso di fine file, e -1 in caso  di
       errore.  ERRNO è impostato a una stringa che descrive il problema.

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

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

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

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

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

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

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

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

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

       %s      Una stringa di caratteri.

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

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

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

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

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

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

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

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

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

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

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

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

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

       -           Lo standard input.

       /dev/stdin  Lo standard input.

       /dev/stdout Lo standard output.

       /dev/stderr Lo standard error in output.

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

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

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

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

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

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

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

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

   Funzioni numeriche
       AWK ha le seguenti funzioni aritmetiche incorporate:

       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 0 e 1, tale che 0 ≤ N < 1.

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

       sqrt(espressione)    Restituisce la radice quadrata di espressione.

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

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

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

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

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

       gsub(r, s [, t])                Per  ogni sottostringa conforme all'espressione regolare r
                                       nella stringa t, sostituisce la stringa s,  e  restituisce
                                       il  numero  di  sostituzioni.  Se t non è specificata, usa
                                       $0.  Una & nel testo di rimpiazzo è sostituita  dal  testo
                                       trovato  corrispondente alla espressione regolare.  Si usi
                                       \& per indicare il carattere &  inteso  letteralmente  (va
                                       scritto come "\\&"; vedere GAWK: Effective AWK Programming
                                       per una trattazione più  completa  delle  regole  sull'uso
                                       delle  &  e  delle barre inverse nel testo di rimpiazzo di
                                       sub(), gsub(), e gensub()).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       strftime([format [, timestamp[, utc-flag]]])
                 Formatta timestamp secondo quanto specificato in format.  Se utc-flag è presente
                 e  diversa  da  zero  o  dalla  stringa  nulla,  il  risultato  è in UTC [ora di
                 Greenwich], altrimenti il risultato è nell'ora locale.   Il  timestamp  dovrebbe
                 essere  nella  forma  utilizzata  da  systime().   Se  timestamp  è omesso, sono
                 utilizzate la data e l'ora correnti.  Se format è omesso, è assunto  un  formato
                 equivalente  a quello dell'output del comando date(1).  Il formato predefinito è
                 disponibile in PROCINFO["strftime"].   Vedere  le  specifiche  per  la  funzione
                 strftime()  in  ISO  C  per  i  formati  di  conversione  che  sono  sicuramente
                 disponibili.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FUNZIONI DEFINITE DALL'UTENTE

       Le funzioni in AWK sono definite in questo modo:

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

       Le funzioni sono eseguite tramite  chiamata  dall'interno  di  espressioni,  presenti  sia
       all'interno  di  criteri  di  ricerca,  che all'interno di azioni.  I parametri forniti al
       momento della chiamata sono sostituiti ai parametri formali dichiarati nella funzione.   I
       vettori sono passati per riferimento, le altre variabili per valore.

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

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

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

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

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

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

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

              {    ...
                   nome_funzione = "mia_funzione"
                   @nome_funzione()    # chiamata tramite nome_funzione di mia_funzione
                   ...
              }

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

       Si  può  usare  la  parola  func  al posto di function.  anche se questo modo di operare è
       deprecato.

CARICARE DINAMICAMENTE NUOVE FUNZIONI

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

SEGNALI

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

INTERNAZIONALIZZAZIONE

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

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

       stampa sempre il messaggio hello, world.  Ma,

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

       potrebbe invece stampare bonjour, monde se eseguito in Francia.

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

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

                BEGIN { TEXTDOMAIN = "mio_programma" }

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

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

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

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

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

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

COMPATIBILITÀ POSIX

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

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

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

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

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

FUNZIONALITÀ STORICHE

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

              a = length     # Sant'Algol 60, Batman!

       equivale sia a

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

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

ESTENSIONI GNU

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

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

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

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

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

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

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

       · Costanti ottali ed esadecimali nei programmi AWK.

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

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

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

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

       · Il vettore PROCINFO non è disponibile.

       · L'uso della variabile RS come espressione regolare.

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

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

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

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

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

       · Il secondo argomento opzionale della funzione close().

       · Il terzo argomento opzionale della funzione match().

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

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

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

       · Stringhe traducibili in varie lingue.

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

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

VARIABILI D'AMBIENTE

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

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

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

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

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

STATO DI USCITA

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

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

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

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

INFORMAZIONE SULLA VERSIONE

       Questa pagina man documenta gawk, versione 4.1.

AUTORI

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

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

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

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

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

SEGNALAZIONE DI ERRORI

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

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

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

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

       Segnalare eventuali errori di traduzione a ildp@pluto.it

ERRORI

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

       Può  capitare  che  dei  programmi contenenti singoli caratteri sintatticamente non validi
       tendano a esaurire la stack di analisi, generando un  messaggio  di  poca  utilità.   Tali
       programmi sono sorprendentemente difficili da riconoscere nel caso più generale possibile,
       e lo sforzo richiesto per fare ciò non è veramente giustificato.

VEDERE ANCHE

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

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

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

ESEMPI

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

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

       Conta le righe di un file:

                 { nlines++ }
            END  { print nlines }

       Aggiunge il numero di riga all'inizio di ogni riga del file:

            { print FNR, $0 }

       Concatena e aggiunge numerazione (variazione sul tema):

            { print NR, $0 }

       Esegui un comando esterno per alcune linee di dati:

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

RICONOSCIMENTI

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

COPYING PERMISSIONS

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

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

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

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

PERMESSI DI COPIA

       Questa  è  una  traduzione non ufficiale in italiano dei permessi di copia riportati nella
       precedente sezione "COPYING PERMISSIONS".  Non è una  pubblicazione  della  Free  Software
       Foundation,  e non ha validità legale per i termini di distribuzione della documentazione;
       solo il testo originale inglese ha tale validità.

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

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

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

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

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