path: root/doc/it/gawk.1

GAWK(1)                                  Utility Commands                                 GAWK(1)

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

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

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

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

PREMESSA
       Questa  pagina  di manuale `e intenzionalmente il pi`u possibile concisa.  La documentazione
       completa `e disponibile in GAWK: Effective AWK Programming, ed `e l`a che si dovrebbe  andare
       a  cercare  la  descrizione completa di ogni singola funzionalit`a.  Quando possibile, sono
       forniti dei link alla versione online del manuale.

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

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

       In aggiunta, ogni opzione lunga ha una corrispondente opzione corta, in modo che  la  fun-
       zionalit`a dell'opzione possa essere usata all'interno di script #!  eseguibili.

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

       -f file_di_programma
              --file file_di_programma Legge il sorgente del programma AWK dal file  file_di_pro-
              gramma,  invece che dal primo argomento della riga di comando.  Si possono specifi-
              care pi`u opzioni -f I file letti come specificato da -f sono trattati come  se  in-
              iziassero con la direttiva implicita @namespace "awk".

       -F fs  --separatore_di_campo  fs Usa fs come separatore di campo in input (il valore della
              variabile predefinita FS).  -v var=val, --assign var=val Assegna il valore val alla
              variabile  var,  prima  che  inizi l'esecuzione del 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.  L'opzione --posix ignora questo comportamento.

       -c, --traditional
              Viene eseguito in modalit`a compatibile.  In questa modalit`a, gawk si comporta esat-
              tamente  come  awk  di Brian Kernighan; non viene riconosciuta nessuna delle esten-
              sioni specifiche di GNU.

       -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.  If file di default `e awkvars.out nella directory corrente.

       -D[file], --debug[=file]
              Abilita il debugging di programmi AWK.  Per default, l'analizzatore di errori  [de-
              bugger]  legge  i  comandi  in maniera interattiva dalla tastiera (standard input).
              L'argomento opzionale file specifica un file contenente un elenco di comandi per il
              debugger da eseguire in maniera non interattiva.
              In questo modo di esecuzione, gawk carica il codice sorgente AWK e quindi chiede di
              immettere comandi di debug.  Gawk pu`o solo fare il debug di programmi sorgenti  AWK
              specificati tramite le opzioni -f e --include .  Il debugger `e documentato in GAWK:
              Effective   AWK    Programming;    vedere    https://www.gnu.org/software/gawk/man-
              ual/html_node/Debugger.html#Debugger.

       -e testo_del_programma,"--source testo_del_programma
              Usa  testo_del_programma  come  codice  sorgente del programma AWK.  Ogni argomento
              specificato da -e `e trattato come se iniziasse con la  direttiva  implicita  @name-
              space "awk".

       -E file, --exec file
              Simile  a -f, comunque, quest'opzione `e l'ultima ad essere elaborata.  Dovrebbe es-
              sere usata con script #! , specialmente per applicazioni CGI [Common Gateway Inter-
              face], per evitare di passare opzioni o codice (!) sulla riga di comando da un URL.
              Quest'opzione disabilita gli assegnamenti di variabile da  riga  di  comando.   -g,
              --gen-pot Esamina e analizza il programma AWK, e genera un file in formato GNU .pot
              (Portable Object Template) sullo standard output con elementi relativi a  tutte  le
              stringhe localizzabili nel programma.  Il programma in s'e non viene eseguito.

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

       -i include-file, --include include-file
              Carica una libreria di sorgenti awk.  Cerca la libreria usando la variabile d'ambi-
              ente AWKPATH.  Se la ricerca iniziale non va a buon fine, viene fatto un altro ten-
              tativo  dopo aver aggiunto il suffisso .awk.  Il file verr`a caricato solo una volta
              (cio`e vengono ignorati i duplicati), e il codice non costituisce  il  sorgente  del
              programma  principale.   I  file  letti come specificato da --include sono trattati
              come se iniziassero con la direttiva implicita @namespace "awk".

       -I, --trace
              Stampa i nomi del codice-byte generato internamente, nell'ordine in cui sono incon-
              trati  durante  l'esecuzione del programma.  Questa trace `e stampata sullo standard
              error.  Ogni ``codice operativo'' `e preceduto da un segno + nell'output.   -l  lib,
              --load lib Carica un'estensione gawk dalla libreria condivisa lib.  Cerca la libre-
              ria 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 li-
              breria 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 Vedere https://www.gnu.org/soft-
              ware/gawk/manual/html_node/Options.html#Options  per  la  lista di valori possibili
              per valore.

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

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

       -N, --use-lc-numeric
              Forza gawk a usare il carattere di separazione decimale della localizzazione quando
              analizza i dati in input.

       -o[file], --pretty-print[=file]
              Stampa una versione formattata graziosamente del programma su file.  Il file di de-
              fault `e awkprof.out nella directory corrente.  Quest'opzione attiva anche l'opzione
              --no-optimize.

       -O, --optimize
              Abilita le ottimizzazioni predefinite di gawk nella  rappresentazione  interna  del
              programma.  Quest'opzione `e attiva in modo predefinito.

       -p[prof-file], --profile[=prof-file]
              Inizia  una  sessione  di  "profiling", e invia i dati tracciati al file prof-file.
              Quello predefinito `e awkprof.out .  Il profilo contiene il numero di esecuzioni  di
              ogni  istruzione sul margine sinistro e il conteggio delle chiamate di funzione per
              ogni funzione definita dall'utente.  Gawk viene eseguito pi`u lentamente  in  questo
              modo.  Quest'opzione attiva anche l'opzione --no-optimize.

       -P, --posix
              Quest'opzione  attiva la modalit`a di compatibilit`a, e disabilita un certo numero di
              estensioni comuni.

       -r, --re-interval
              Abilita l'uso di espressioni di intervallo nelle espressioni regolari.  Le  espres-
              sioni  di intervallo sono rese disponibili per default, ma quest'opzione viene las-
              ciata per compatibilit`a all'indietro.

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

       -S, --sandbox
              Esegue  gawk  in  modalit`a  "sandbox", disabilitando la funzione system(), la ridi-
              rezione dell'input con getline, la ridirezione sull'output con print e printf, e il
              caricamento delle estensioni dinamiche.  L'esecuzione di comandi (tramite pipeline)
              `e anch'essa disabilitata.

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

       -V, --version
              Scrive  sullo  standard  output la versione di questa particolare copia di gawk.  `E
              utile principalmente per segnalare bug.  In linea con le  convenzioni  di  codifica
              GNU  Coding  Standards,  queste  opzioni provocano un'uscita immediata e senza seg-
              nalazione di errore.

       --     Segnala la fine delle opzioni. `E utile perch'e permette di passare al programma  AWK
              ulteriori argomenti [nomi di file] che iniziano con "-".

       In  modalit`a compatibile, qualsiasi altra opzione `e contrassegnata come non valida e viene
       ignorata.  Nell'uso normale, sempre che sia stato  fornito  il  testo  del  programma,  le
       opzioni sconosciute sono passate al programma AWK nel vettore ARGV per l'elaborazione.

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

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

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

       Gawk prima legge il codice del programma dal/dai file_di_programma se specificato/i, dagli
       argomenti passati a --source, o dal primo argomento sulla riga  di  comando  che  non  sia
       un'opzione.   Le  opzioni  -f  e --source possono essere usate pi`u volte nella riga di co-
       mando.  Gawk legge il testo del programma come se tutti i file_di_programma e i testi sor-
       genti della riga di comando fossero concatenati.

       Oltre  a  ci`o, le righe che iniziano con @include possono essere usate per includere altri
       file sorgenti nel vostro programma.  Ci`o equivale a usare l'opzione --include.

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

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

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

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

       Se  un nome di file nella riga di comando ha la forma var=val, `e trattato come un assegna-
       mento di variabile.  Alla variabile var sar`a assegnato il valore val (questo  accade  dopo
       che ogni regola BEGIN `e stata eseguita).

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

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

       Per  ogni  record  in  input, gawk controlla se c'`e corrispondenza con qualche criterio di
       ricerca specificato nel programma AWK.  Per ogni criterio di ricerca a cui un record  cor-
       risponde,  gawk  esegue l'azione associata.  I criteri di ricerca sono verificati nell'or-
       dine in cui appaiono nel programma.

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

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

       Per  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,  gawk  consente di avere variabili di tipo
       "espressione regolare".  AWK ha anche vettori monodimensionali; i vettori  multidimension-
       ali  possono essere simulati [da vettori monodimensionali].  Gawk fornisce veri vettori di
       vettori.  All'inizio dell'esecuzione del programma vengono impostate  parecchie  variabili
       predefinite;  saranno  descritte di volta in volta quando sar`a necessario, ed elencate pi`u
       avanti.

   Record
       Normalmente i record sono separati dal carattere newline.  Si pu`o controllare il  modo  in
       cui  i  record  sono  separati  assegnando  valori  alla variabile predefinita RS.  Vedere
       https://www.gnu.org/software/gawk/manual/html_node/Records.html per i dettagli.

   Campi
       Ogni record letto in input `e diviso da gawk in campi, usando il valore della variabile  FS
       come  separatore  di campo.  Inoltre, le variabile FIELDWIDTHS e PATH possono essere usate
       per controllare la divisione in  campi  dell'input.   Vedere  i  dettagli,  a  partire  da
       https://www.gnu.org/software/gawk/manual/html_node/Fields.html.

       Ogni  campo nel record in input pu`o essere individuato dalla sua posizione: $1, $2, e cos`i
       via.  $0 `e l'intero record, compresi eventuali spazi bianchi iniziali e finali.

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

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

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

   Variabili predefinite
       Le variabili predefinite di gawk sono listate qui sotto.  La lista `e volutamente  concisa.
       Per dettagli, vedere https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Vari-
       ables.

       ARGC        Il numero di argomenti da riga di comando

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

       ARGV        Vettore degli argomenti della riga di comando.  Il vettore `e indicizzato da  0
                   ad ARGC - 1.

       BINMODE     Su sistemi non-POSIX, specifica l'uso della modalit`a "binaria" per tutto l'I/O
                   da   e   verso   i   file.    Vedere    https://www.gnu.org/software/gawk/man-
                   ual/html_node/PC-Using.html per i dettagli.

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

       ENVIRON     Un  vettore contenente i valori dell'ambiente corrente.  Il vettore `e indiciz-
                   zato dalle variabili d'ambiente, e ogni elemento `e il valore di  quella  vari-
                   abile.

       ERRNO       Se  ha  luogo  un errore di sistema durante una ridirezione per una getline, o
                   durante una lettura fatta con getline, oppure in una close(), ERRNO viene  im-
                   postato  a  una  stringa  che  descrive  l'errore.   Il  valore `e passibile di
                   traduzione nelle localizzazioni diverse dall'inglese.

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

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

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

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

       FS          Il   separatore   di   campo,   quello   predefinito  `e  uno  spazio.   Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html per i
                   dettagli.

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

       IGNORECASE  Controlla  la  sensibilit`a alla distinzione tra maiuscole e minuscole in tutte
                   le  espressioni  regolari  e  nelle   operazioni   sulle   stringhe.    Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html
                   per i dettagli.

       LINT        Fornisce un controllo dinamico dell'opzione --lint  dall'interno  di  un  pro-
                   gramma AWK.

       NF          Il numero di campi nel record corrente.

       NR          Il numero totale di record incontrati finora.

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

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

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

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

       PROCINFO    Gli  elementi  di questo vettore forniscono accesso alle informazioni sul pro-
                   gramma   AWK  in  esecuzione.   Vedere  https://www.gnu.org/software/gawk/man-
                   ual/html_node/Auto_002dset per i dettagli.

       ROUNDMODE   La  modalit`a  di  arrotondamento da usare per operazioni sui numeri con preci-
                   sione arbitraria, quella predefinita `e "N"  (IEEE-754  roundTiesToEven  mode).
                   Vedere   https://www.gnu.org/software/gawk/manual/html_node/Setting-the-round-
                   ing-mode per i dettagli.

       RS          Il separatore di record in input, per default "newline".

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

       RSTART      L'indice  del primo carattere trovato da match(), oppure 0 se non ci sono cor-
                   rispondenze

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

       SUBSEP      La  stringa  usata  per separare indici multipli negli elementi di un vettore,
                   quella predefinita `e "\034".

       SYMTAB      Un vettore i cui indici sono i nomi di tutti i vettori e le variabili  globali
                   attualmente   definite   presenti   nel  programma.   Non  `e  possibile  usare
                   l'istruzione delete per il vettore SYMTAB e neppure impostare elementi il  cui
                   indice non sia un nome di variabile.

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

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

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

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

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

              if (val in vettore)
                   print vettore[val]

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

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

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

       gawk  supporta veri vettori multidimensionali.  Non richiede che tali vettori siano ``ret-
       tangolare''   come   in   C   or   C++.    Vedere   https://www.gnu.org/software/gawk/man-
       ual/html_node/Arrays per i dettagli.

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

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

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

       I nomi delle funzioni interne predefinite non  possono  essere  usati  come  nomi  di  uno
       spazio-dei-nomi.   I nomi di ulteriori funzioni, fornite da gawk possono essere usati come
       nomi di uno spazio-dei-nomi o come semplici identificativi in altri  spazi-dei-nomi.   Per
       ulteriori    dettagli,   vedere   https://www.gnu.org/software/gawk/manual/html_node/Name-
       spaces.html#Namespaces.

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

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

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

       Quando una stringa deve essere convertita in un numero, la conversione `e compiuta con str-
       tod(3).  I numeri sono convertiti a stringhe usando sprintf(3) col valore di CONVFMT  come
       stringa  di  formato e 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.

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

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

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

   Costanti di tipo stringa
       Le costanti stringa in AWK sono sequenze di caratteri  racchiusi  tra  doppi  apici  (come
       "valore").   All'interno  delle stringhe, sono riconosciute alcune sequenze di protezione,
       come in C.  Vedere https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences per
       i dettagli.

   Costanti di tipo Regexp
       Una  costante di tipo espressione regolare `e una sequenza di caratteri racchiusa tra barre
       (come /valore/).

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

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

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

              { print }

       ossia stampare l'intero record.

       I commenti cominciano col carattere #, e continuano fino a fine riga.  Si possono separare
       le istruzioni con righe vuote.  Un'istruzione finisce normalmente alla fine della riga,  a
       meno  che  non  termini  con una virgola, {, ?, :, &&, o ||.  Anche le istruzioni in righe
       terminanti con do o else continuano automaticamente alla  riga  successiva.   Negli  altri
       casi,  un'istruzione  pu`o continua sulla riga successiva se termina con "\", nel qual caso
       il "newline" `e ignorato.  Comunque, un "\" che venga dopo un carattere # non `e speciale.

       Si possono scrivere pi`u istruzioni sulla stessa riga separandole con ";".  Questo  si  ap-
       plica  sia  alle  istruzioni  all'interno di un'azione (il caso pi`u comune), sia ai gruppi
       criterio-azione stessi.

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

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

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

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

       Per i criteri del tipo /espressione regolare/  l'azione  associata  `e  eseguita  per  ogni
       record  in  input che corrisponde all'espressione regolare.  Le espressioni regolari hanno
       la stessa forma  di  quelle  di  egrep(1),  Vedere  https://www.gnu.org/software/gawk/man-
       ual/html_node/Regexp.html per i dettagli sulle espressioni regolari

       In  un'espressione  relazionale  si  pu`o  usare qualsiasi operatore definito nella sezione
       sulle azioni, pi`u avanti.  Generalmente l'espressione relazionale `e utilizzata per verifi-
       care se certi campi sono individuati da determinate espressioni regolari.

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

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

       Un'espressione nella forma criterio1, criterio2 `e detta criterio intervallo.   Essa  indi-
       vidua  tutti  i  record  a  partire  da quello che ha corrispondenza con criterio1, fino a
       quello che corrisponde a criterio2, compreso.  Non pu`o essere  combinata  con  alcun'altra
       espressione.

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

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

       (...)       Raggruppamento

       $           Riferimento a campi.

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

       ^           Elevamento a potenza.

       + - !       Pi`u e meno unari, e negazione logica.

       * / %       Moltiplicazione, divisione e resto della divisione.

       + -         Addizione e sottrazione.

       spazio      Concatenazione di stringhe.

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

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

       ~ !~        Corrispondenza tra espressioni regolari, e nessuna corrispondenza.

       in          Controllo di appartenenza a un vettore.

       &&          AND logico.

       ||          OR logico.

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

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

   Istruzioni di controllo
       Le istruzioni di controllo sono le seguenti:

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

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

       close(file [, come])              Chiude un file, una pipe o  un  coprocesso  aperti.   Il
                                         parametro  facoltativo  come  dovrebbe essere usato solo
                                         per chiudere un'estremit`a  di  una  pipe  bi-direzionale
                                         aperta  con  un  coprocesso.   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;  im-
                                         posta NR, FNR, RT.

       getline variabile <file           Imposta variabile dalla successiva riga di file; imposta
                                         RT.

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

       comando |& getline [variabile]    Esegue  comando  come  un  coprocesso dirigendo l'output
                                         [del comando] o in $0 o in variabile, come sopra, e  RT.
                                         (Il  comando pu`o anche essere un socket.  Vedere la sot-
                                         tosezione  Nomi   di   file   speciali,   pi`u   avanti.)
                                         fflush([file])  Scrive qualsiasi buffer associato con il
                                         file di output o la pipe file.  Se file non  `e  specifi-
                                         cato  o `e la stringa nulla, vengono scritti tutti i file
                                         in output e le pipe.

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

       nextfile                          Cessa l'elaborazione del file  di  input  corrente.   La
                                         prossima  riga  letta proverr`a dal file di input succes-
                                         sivo.  Aggiorna FILENAME e ARGIND, reimposta FNR a 1,  e
                                         l'elaborazione  riprende  dal  primo criterio di ricerca
                                         del programma AWK.  Se non ci sono pi`u righe  in  input,
                                         gawk  esegue i comandi di ogni regola ENDFILE ed END, se
                                         presenti.

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

       print lista-espressioni           Stampa le espressioni indicate.  Ogni espressione `e sep-
                                         arata 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 espres-
                                         sione `e separata dal valore  della  variabile  OFS.   La
                                         riga prodotta termina col valore della variabile ORS.

       printf formato, lista-espressioni Stampa usando il formato specificato.

       printf formato, lista-espressioni >file
                                         Stampa usando il formato specificato su file.

       system(riga-di-comando)           Esegue  il  comando riga-di-comando, e ne restituisce il
                                         valore d'uscita.  (pu`o non essere disponibile  sui  sis-
                                         temi   non-POSIX).    Vedere   https://www.gnu.org/soft-
                                         ware/gawk/manual/html_node/I_002fO-Func-
                                         tions.html#I_002fO-Functions  per  tutti  i dettagli sul
                                         valore restituito dal comando eseguito.

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

       print ... >> file
              Aggiunge l'output alla fine di file.

       print ... | comando
              Scrive su una pipe.

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

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

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

       Le versioni di AWK dell'istruzione printf e della funzione sprintf() soono simili a quelle
       del  linguaggio  C.  Per   i   dettagli,   vedere   https://www.gnu.org/software/gawk/man-
       ual/html_node/Printf.html.

   Nomi di file speciali
       Effettuando  delle  ridirezioni  di  print o printf su un file, o attraverso getline da un
       file, gawk riconosce internamente alcuni nomi di file speciali, che permettono di accedere
       a  descrittori di file gi`a aperti ereditati dal processo genitore di gawk (la shell, soli-
       tamente).  Questi nomi di file possono anche essere usati nella riga di comando  per  des-
       ignare dei file di dati.  I nomi di file sono:

       -           Lo standard input.

       /dev/stdin  Lo standard input.

       /dev/stdout Lo standard output.

       /dev/stderr Lo standard error in output.

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

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

       /inet/tcp/lport/rhost/rport
       /inet4/tcp/lport/rhost/rport
       /inet6/tcp/lport/rhost/rport
              File per una connessione TCP/IP su una porta locale  lport  verso  un  host  remoto
              rhost sulla porta remota rport.  Si usi la porta numero 0 Per permettere al sistema
              di scegliere una porta.  Si usi /inet4  per  richiedere  una  connessione  IPv4,  e
              /inet6  per  richiedere una connessione IPv6.  Specificando semplicemente /inet usa
              quello predefinito del sistema (molto probabilmente IPv4).  Si pu`o usare  solo  con
              l'operatore bidirezionale di I/O |& .

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

   Funzioni numeriche
       AWK ha le seguenti funzioni aritmetiche predefinite:

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

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

       exp(espressione)     La funzione esponenziale.

       int(espressione)     Troncamento a numero intero.

       log(espressione)     Logaritmo a base naturale.

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

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

       sqrt(espressione)    Restituisce la radice quadrata di espressione.

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

   Funzioni di stringa
       Gawk offre le seguenti funzioni di stringa seguenti  predefinite;  ulteriori  dettagli  in
       https://www.gnu.org/software/gawk/manual/html_node/String-Functions.

       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 (facolta-
                                           tivo)  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.   Val-
                                           ori   ammissibili   per   come   sono   descritti   in
                                           https://www.gnu.org/software/gawk/man-
                                           ual/html_node/String-Functions.html#String-Functions.
                                           s e d possono specificare lo stesso vettore;  la  cosa
                                           ha  senso  nel caso si specifichi anche il terzo argo-
                                           mento.

       asorti(s [, d [, come] ])           Restituisce il  numero  di  elementi  del  vettore  di
                                           partenza  s.  Il comportamento `e lo stesso di asort(),
                                           con la differenza che l'ordinamento `e fatto usando gli
                                           indici  del  vettore, e non i valori.  Fatto l'ordina-
                                           mento, il vettore `e  indicizzato  numericamente,  e  i
                                           valori sono quelli degli indici di partenza.  I valori
                                           originali sono persi; quindi va utilizzato un  secondo
                                           vettore se si vuole conservare il vettore di partenza.
                                           Lo scopo della stringa facoltativa come  `e  lo  stesso
                                           che  in  asort().  Anche qui s e d possono specificare
                                           lo stesso vettore; la cosa ha senso nel caso si speci-
                                           fichi anche il terzo argomento.

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

       gsub(r, s [, t])                    Per  ogni  sottostringa conforme all'espressione rego-
                                           lare r nella stringa t, sostituisce la  stringa  s,  e
                                           restituisce  il  numero  di  sostituzioni.  Se t non `e
                                           specificata, usa $0.  Una & nel testo di  rimpiazzo  `e
                                           sostituita   dal  testo  trovato  corrispondente  alla
                                           espressione regolare.   Si  usi  \&  per  indicare  il
                                           carattere  &  inteso  letteralmente  (va  scritto come
                                           "\\&";  vedere  https://www.gnu.org/software/gawk/man-
                                           ual/html_node/Gory-Details.html#Gory-Details  per  una
                                           trattazione pi`u completa delle regole  sull'uso  della
                                           "e  commerciale" (ampersand) e delle barre inverse nel
                                           testo di rimpiazzo di sub(), gsub(), e gensub()).

       index(s, t)                         Restituisce la posizione della stringa  t  all'interno
                                           della  stringa  s,  o  zero se la stringa t non `e pre-
                                           sente.  (Ci`o implica che gli indici di una stringa  di
                                           caratteri partono da 1.)

       length([s])                         Restituisce  la  lunghezza  della stringa s, oppure la
                                           lunghezza di $0 se s non `e specificata.   Se  si  for-
                                           nisce  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'espres-
                                           sione  regolare  r, oppure zero se r non `e presente, e
                                           imposta i valori di RSTART e  RLENGTH.   Si  noti  che
                                           l'ordine  degli argomenti `e lo stesso in uso per l'op-
                                           eratore ~:  stringa  ~  espressione-regolare.   Vedere
                                           https://www.gnu.org/software/gawk/man-
                                           ual/html_node/String-Functions.html#String-Functions
                                           per  una  descrizione di come il vettore a viene riem-
                                           pito, se specificato.

       patsplit(s, a [, r [, seps] ])      Suddivide la stringa s nel vettore a e il vettore  dei
                                           separatori  seps nell'espressione regolare r, e resti-
                                           tuisce il numero dei campi.  I valori di ogni elemento
                                           [del  vettore]  sono le parti di s che corrispondono a
                                           r.  Il valore di seps[i] `e il separatore (che potrebbe
                                           anche  essere  la stringa nulla) individuato davanti a
                                           a[i].  Il valore di seps[0] `e il  separatore  iniziale
                                           (che  potrebbe anche essere la stringa nulla).  Se r `e
                                           omesso, FPAT viene usato al suo posto.  I vettori a  e
                                           seps  sono  svuotati  all'inizio  dell'operazione.  La
                                           suddivisione si comporta come la 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 `e omessa,
                                           il separatore utilizzato `e FS.  I  vettori  a  e  seps
                                           sono  svuotati  all'inizio dell'operazione.  seps[i] `e
                                           il separatore di campo individuato da  r  tra  a[i]  e
                                           a[i+1].   La  divisione viene effettuata con le stesse
                                           regole con cui vengono divisi i campi.

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

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

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

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

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

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

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

   Funzioni di tempo
       Gawk  mette  a disposizione le seguenti funzioni per ottenere data e ora e per formattarle
       come  desiderato.  I  dettagli  si   trovano   in   https://www.gnu.org/software/gawk/man-
       ual/html_node/Time-Functions.

       mktime(datespec [, utc-flag])
                 Traduce  datespec  In  una  marcatura  temporale nello stesso formato restituito
                 dalla funzione [del linguaggio C] systime(), e restituisce il risultato.  Se  il
                 flag  utc-flag  `e  presente  e diverso da zero e dalla stringa nulla, il tempo `e
                 supposto essere quello del fuso orario UTC [ora di  Greenwich];  altrimenti,  si
                 suppone  che  il  tempo sia quello del fuso orario locale.  Se datespec non con-
                 tiene sufficienti elementi o se il tempo risultante `e fuori intervallo, mktime()
                 restituisce -1.  Vedere https://www.gnu.org/software/gawk/manual/html_node/Time-
                 Functions.html#Time-Functions per i dettagli di datespec.

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

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

   Funzioni di manipolazione dei bit
       Gawk prevede le seguenti funzioni di manipolazione dei bit.  Sono realizzate dapprima con-
       vertendo  valori  in virgola mobile con precisione doppia in interi nel formato uintmax_t,
       eseguendo l'operazione indicata, e poi convertendo il risultato nuovamente in virgola  mo-
       bile.  Se a una delle funzioni seguenti si forniscono operandi negativi, il risultato `e un
       errore fatale.

       Le funzioni sono:

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

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

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

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

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

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

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

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

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

   Funzioni di internazionalizzazione
       Le  seguenti  funzioni  possono  essere usate all'interno di un programma AWK per tradurre
       stringhe in fase di  esecuzione  del  programma.   Per  informazioni  dettagliate,  vedere
       https://www.gnu.org/software/gawk/manual/html_node/I18N-Functions.html#I18N-Functions.

       bindtextdomain(directory [, dominio])
              Specifica  la  directory in cui gawk cerca i file .gmo, nel caso non siano o non si
              possano mettere nelle directory ``standard''.  Restituisce la directory a  cui  do-
              minio `e ``collegato''.
              Il  valore  predefinito per dominio `e il valore della variabile TEXTDOMAIN.  Se di-
              rectory `e impostato alla stringa nulla (""), bindtextdomain() restituisce  il  col-
              legamento corrente per il dato dominio.

       dcgettext(stringa [, dominio [, categoria]])
              Restituisce la traduzione della stringa nel dominio di testo dominio per la catego-
              ria di localizzazione categoria.  Il valore predefinito per  dominio  `e  il  valore
              corrente  della  variabile  TEXTDOMAIN.   Il  valore  predefinito  per  categoria `e
              "LC_MESSAGES".

       dcngettext(stringa1, stringa2, numero [, dominio [, category]])
              Restituisce la forma plurale in uso per  numero  nella  traduzione  di  stringa1  e
              stringa2 nel dominio di testo dominio per la categoria di localizzazione categoria.
              Il valore predefinito per dominio `e il valore corrente della variabile  TEXTDOMAIN.
              Il valore predefinito per categoria `e "LC_MESSAGES".

   Funzioni con valori booleani
       `E  possibile  creare  valori  speciali di tipo booleani; vedere il manuale per sapere come
       funzionano e perch'e sono stati resi disponibili.

       mkbool(espressione)
              A seconda del valore booleano di espressione restituisce un valore di true [vero] o
              false  [falso].   True  ha come valore numerico uno.  False ha come valore numerico
              zero.

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

              function nome(lista-parametri) { istruzioni }

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

       Le  variabili locali sono dichiarate come parametri in pi`u nella lista dei parametri.  Per
       convenzione, si usa separare le variabili locali dai veri parametri con qualche spazio  in
       pi`u nella lista. Per esempio:

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

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

       La  parentesi  sinistra  che indica una chiamata deve seguire immediatamente il nome della
       funzione chiamata, senza spazi in mezzo.  Questa restrizione non si applica alle  funzioni
       predefinite elencate sopra.

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

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

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

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

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

CARICARE DINAMICAMENTE NUOVE FUNZIONI
       Si possono aggiungere dinamicamente nuove funzioni scritte in C o  C++  all'interpretatore
       gawk  in  esecuzione tramite l'istruzione @load.  Una descrizione dettagliata non `e possi-
       bile  in  questa  pagina   di   manuale;   vedere   https://www.gnu.org/software/gawk/man-
       ual/html_node/Dynamic-Extensions.html#Dynamic-Extensions.

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

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

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

       stampa sempre il messaggio hello, world.  Ma,

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

       potrebbe invece stampare bonjour, monde se eseguito in Francia.

       Vedere https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Inter-
       nationalization  per i passi necessari per produrre ed eseguire un programma AWK localizz-
       abile.

ESTENSIONI GNU
       Gawk ha fin troppe estensioni rispetto alla versione POSIX di awk.  Esse sono descritte in
       https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html.   Tutte  le  esten-
       sioni possono essere disabilitate invocando gawk con le opzioni --traditional o --posix.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SEGNALAZIONE DI ERRORI
       Se trovate un bug in gawk, siete pregati di usare il  programma  bug-gawk@gnu.org.   gawk-
       bug(1) per segnalarlo.

       Istruzioni    dettagliate    per    segnalare    un    bug    sono   disponibili   in   IR
       https://www.gnu.org/software/gawk/manual/html_node/Bugs.html .  Per piacere,  leggete  at-
       tentamente  e seguite le istruzioni l`a disponibili.  Ci`o faciliter`a la segnalazione di er-
       rori e la loro risoluzione per tutte le persone coinvolte.  Veramente!

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

       Questa man page `e troppo lunga; gawk ha troppe funzionalit`a.

VEDERE ANCHE
       egrep(1), sed(1), gawkbug(1), printf(3), e strftime(3),

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

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

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

ESEMPI
       Stampa e 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") }'

COPYING PERMISSIONS
       Copyright  (C)  1989,  1991,  1992,  1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,
       2003, 2004, 2005, 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018,  2019,
       2020, 2021, 2022 Free Software Foundation, Inc.

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

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

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

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

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

       Copyright  (C)  1989,  1991,  1992,  1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,
       2003, 2004, 2005, 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018,  2019,
       2020, 2021, 2022 Free Software Foundation, Inc.

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

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

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

Free Software Foundation                  Marzo 01 2022                                   GAWK(1)