Provided by: manpages-it_4.23.1-1_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 numerose 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  or --include), e valori da rendere disponibili nelle
       variabili AWK predefinite ARGC e ARGV.

PREFAZIONE

       Questa pagina di manuale è appositamente sintetica. Tutti i dettagli sono forniti in GAWK:
       Effective  AWK  Programming,  dove si deve cercare per la descrizione completa di tutte le
       caratteristiche. Dove possibile vengono forniti i collegamenti alla versione in linea  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à 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. I file letti come specificato da -f sono trattati come
              se iniziassero con la direttiva implicita @namespace "awk".

       -F fs, --field-separator 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 ingresso come caratteri di un singolo
              byte. L'opzione --posix prevale su questa.

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

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

       -D[file], --debug[=file]
              Abilita  il  debugging  di  programmi  AWK.  Per  default, l'analizzatore di errori
              [debugger] legge i comandi in maniera interattiva dalla tastiera (standard  input).
              L'argomento opzionale file specifica un file contenente un elenco di comandi per il
              debugger da eseguire in maniera non interattiva.
              In questa modalità d'esecuzione gawk  carica  il  codice  sorgente  AWK  e  attende
              comandi  di  debug.  Gawk può fare il debug solo di programmi AWK il cui sorgente è
              stato indicato da -f o --include. Il debugger è documentato in GAWK: Effective  AWK
              Programming;                                                                 vedere
              https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.

       -e testo_del_programma,
              --source testo_del_programma Usa testo_del_programma come sorgente di un  programma
              AWK.  Ogni  argomento  fornito  con  -e  viene  trattato  come  se iniziasse con la
              direttiva implicita @namespace "awk".

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

       -h,    --help  Scrive  sullo  standard  output un riassunto abbastanza breve delle opzioni
              disponibili. In base agli 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. 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,  man  mano  che  sono
              incontrati  nell'esecuzione  del  programma. Questa trace è stampata sullo standard
              error. Ogni “codice operativo” è preceduto da un segno + nell'output.

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

       -L [valore], --lint[=valore]
              Emette degli avvisi per  costrutti  che  siano  dubbi  o  non  portabile  su  altre
              implementazione                             AWK.                             Vedere
              https://www.gnu.org/software/gawk/manual/html_node/Options.html#Options   per    la
              lista dei possibili valori di valore.

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

              NOTA:  questa  caratteristica  non è assicurata. Lo sviluppatore principale di gawk
              non la supporta più, anche se uno degli sviluppatori del  team  lo  fa.  Se  questa
              situazione cambiasse, la caratteristica verrà rimossa da gawk.

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

       -N,    --use-lc-numeric Impone a gawk di usare il carattere per il  punto  decimale  della
              localizzazione durante l'interpretazione dei dati in ingresso.

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

       -O,    --optimize  Abilita  le  ottimizzazioni  predefinite di gawk nella rappresentazione
              interna del programma. Questa opzione è attivata automaticamente.

       -p[prof-file], --profile[=prof-file]
              Inizia una sessione di "profiling", e invia i dati  tracciati  al  file  prof-file.
              Quello  predefinito  è awkprof.out nella directory corrente. 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 è più lento in
              questa modalità. Quest'opzione attiva anche l'opzione --no-optimize.

       -P,    --posix Attiva la modalità  di  compatibilità  e  disabilita  parecchie  estensioni
              comuni.

       -r,    --re-interval  Abilita  l'utilizzo  di  espressioni  intervallo nella ricerca delle
              corrispondenze con espressioni regolari. Le espressioni intervallo  sono  abilitate
              automaticamente, ma quest'opzione rimane per compatibilità all'indietro.

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

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

       -t,    --lint-old  Emette  avvisi  relativi  a  costrutti  non  portabili  sulla  versione
              originale di awk per UNIX.

       -V,    --version Scrive le informazioni sulla versione per questa specifica copia di  gawk
              sullo  standard  output.  Questo  è  utile  quando si segnalano errori. Come da 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 “-”.

       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.

       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 direttive opzionali, istruzioni di tipo
       criterio-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ù 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.

       Oltre a ciò, le righe che iniziano con @include possono essere usate per  includere  altri
       file sorgenti nel programma.  Questo è equivalente all'uso dell'opzione --include.

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

       La variabile d'ambiente AWKPATH specifica il  percorso  lungo  il  quale  cercare  i  file
       sorgenti  indicati  con  le  opzioni  -f  e  --include. 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  --load.  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-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  è  trattato  come  un
       assegnamento di variabile.  Alla variabile var sarà assegnato il valore val (questo accade
       dopo che ogni regola BEGIN è stata eseguita).

       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
       alla regola 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.

       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 usate. Inoltre, gawk consente di avere variabili di tipo "espressione regolare".
       AWK  ha  anche  vettori  monodimensionali;  i  vettori  multidimensionali  possono  essere
       simulati. Gawk fornisce veri vettori di vettori. 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 dai caratteri a capo. Si può controllare  come  vengono
       separati   i   record   assegnando   valori   alla   variabile   predefinita   RS.  Vedere
       https://www.gnu.org/software/gawk/manual/html_node/Records.html per i dettagli.

   Campi
       Man mano che ogni record di ingresso è letto, gawk lo spezza in  campi  usando  il  valore
       della  variabile  FS come separatore dei campi. Inoltre possono essere usate FIELDWIDTHS e
       FPAT  per  controllare  la  separazione  dei  campi.  Vedere  i  dettagli  a  partire   da
       https://www.gnu.org/software/gawk/manual/html_node/Fields.html.

       Ogni  campo nel record in input può essere individuato dalla sua posizione: $1, $2, e così
       via. $0 è 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è  campi  dopo  $NF)  producono  la  stringa  vuota.
       Tuttavia,  l'assegnamento  ad  un  campo  inesistente  (per  esempio  $(NF+2) = 5) provoca
       l'incremento del valore di NF, crea tutti i campi intermedi  assegnando  loro  la  stringa
       nulla,  e  fa sì che il valore di $0 sia ricalcolato utilizzando OFS per separare i campi.
       Riferimenti a campi con indice negativo producono un errore fatale.  Il decremento  di  NF
       provoca  la  perdita dei campi di indice superiore al valore impostato, ed il ricalcolo di
       $0, utilizzando OFS per separare i campi.

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

   Variabili predefinite
       Le variabili predefinite di gawk sono elencate sotto. L'elenco è appositamente scarno. Per
       i                                      dettagli                                     vedere
       https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.

       ARGC        Il numero di argomenti sulla riga di comando.

       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.

       BINMODE     Sui sistemi non POSIX, indica l'utilizzo della modalità «binaria» per tutte le
                   scritture         e         letture          su          file.          Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html     per     i
                   dettagli.

       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.

       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
                   impostato a 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. Ogni larghezza di campo può
                   opzionalmente 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  è  “-”.  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 di FS come  separatore  di
                   campo.

       FS          Il   separatore   di   campo,   quello   predefinito   è  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
                   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  le  differenze  tra  maiuscole  e minuscole in tutte le espressioni
                   regolari      e      nelle      operazioni      su      stringhe.       Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html
                   per i dettagli.

       LINT        Offre un controllo dinamico dell'opzione --lint dall'interno di  un  programma
                   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 è "%.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 l'accesso alle informazioni sul
                   programma           AWK            in            esecuzione.            Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset      per     i
                   dettagli.

       ROUNDMODE   La  modalità  di  arrotondamento  da  usare  per  operazioni  sui  numeri  con
                   precisione  arbitraria,  quella  predefinita  è  "N" (IEEE-754 roundTiesToEven
                   mode).                                                                  Vedere
                   https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode
                   per i dettagli.

       RS          Il separatore di record in input (se non specificato è "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      La posizione del primo carattere della stringa trovata da match(); oppure 0 se
                   non ci sono corrispondenze.

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

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

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

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

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

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

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

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

              if (val in vettore)      print vettore[val]

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

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

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

       gawk  supporta  veri  vettori  multidimensionali.  Non  richiede  che  tali  vettori siano
       “rettangolari”         come         in         C          or          C++.          Vedere
       https://www.gnu.org/software/gawk/manual/html_node/Arrays per dettagli.

   Spazi-dei-nomi
       Gawk fornisce una semplice funzionalità, 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 è 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 è diverso da quello predefinito.

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

       I nomi delle funzioni interne predefinite standard 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/Namespaces.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à trattato come un  numero;
       usato come stringa, sarà trattato come tale.

       Per  far  trattare  una  variabile  come  numero, le si sommi zero; per ottenere che venga
       trattata 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 è 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.

       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.  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 è una sequenza di caratteri racchiusa tra barre
       (come /valore/).

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

       Gawk  consente  anche  di  usare  costanti  formate  da  espressioni  regolari  fortemente
       tipizzate.  I  nome  di  tali  costanti  sono preceduti da un simbolo @ (così: @/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 è stato assegnato in
       questo modo hanno come tipo quello di variabili di espressioni regolari.

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

       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 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 è 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).         Vedere
       https://www.gnu.org/software/gawk/manual/html_node/Regexp.html  per   i   dettagli   sulle
       espressioni regolari.

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

   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.

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

       * / %       Moltiplicazione, divisione e resto della divisione.

       + -         Addizione e sottrazione.

       space       Concatenazione di stringhe.

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

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

       ~ !~        Corrispondenza con espressione regolare, o sua negazione.

       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 e 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 ]
              { istruzioni }
              switch (espressione) { case valore|espressione_regolare : istruzione ... [ default: istruzione ]
              }

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

       close(file [, come])  Chiude  un  file, una pipe o un coprocesso. Il parametro facoltativo
                             come dovrebbe essere usato solo per  chiudere  un'estremità  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; imposta NR, FNR,
                             RT.

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

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

       comando |& getline [variabile]
                             Esegue comando come un coprocesso dirigendo l'output [del comando] o
                             in $0 o in variabile, come sopra, e RT. (Il comando può anche essere
                             un  socket.   Vedere  la  sottosezione  Nomi  di  file speciali, più
                             avanti.)

       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.

       next                  Cessa   l'elaborazione  della  riga  di  input  corrente.  Legge  la
                             successiva riga di input, e l'elaborazione ricomincia a partire  dal
                             primo  criterio  di  ricerca  del  programma AWK. Se non ci sono più
                             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à dal file di input  successivo.  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ù  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  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
                             Formatta e stampa.

       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). Vedere
                             https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions
                             per tutti i dettagli sul valore d'uscita.

       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ù 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ò essere ritentata, e
       PROCINFO["input",  "RETRY"] è stato impostato, viene restituito il valore -2 invece che -1
       e ulteriori chiamate a getline possono essere effettuate. A fronte di un  errore  ERRNO  è
       impostato a una stringa che descrive il problema.

       NOTA:  L'insuccesso  nell'apertura  di un socket bidirezionale genera un errore non fatale
       che viene restituito alla funzione chiamante.  Se si sta usando una pipe, un 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
       automaticamente pipe, socket, o coprocessi quando questi restituiscono EOF.

       Le  versioni di AWK dell'istruzione printf e della funzione sprintf() sono simili a quelle
       del C. Per dettagli vedere https://www.gnu.org/software/gawk/manual/html_node/Printf.html.

   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.

       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ò  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  è indicata, sarà utilizzata il tempo corrente, misurato in
                     secondi dal 1970. Il valore restituito è il valore precedente del seme.

   Funzioni di stringa
       Gawk ha le seguenti funzioni predefinite per le  stringhe;  i  dettagli  sono  forniti  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 interi successivi  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    descritti    in
                               https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions.
                               s  e  d  possono  anche essere lo stesso array, ma questo ha senso
                               solo se si specifica anche il terzo argomento.

       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 precedenza
                               per asort(). Anche qui, s  e  d   possono  specificare  lo  stesso
                               vettore;  la  cosa  ha  senso solo nel caso si specifichi anche il
                               terzo argomento.

       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
                               https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details
                               per una trattazione più 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 è presente. (Ciò 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  è  specificata.  Se  si fornisce come argomento un
                               vettore, length() restituisce il numero di elementi del vettore.

       match(s, r [, a])       Restituisce  la  posizione  in  s  in  cui  ricorre  l'espressione
                               regolare r, oppure zero se r non è 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.  Vedere
                               https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions
                               per una descrizione di come il vettore a sia riempito se indicato.

       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  (che
                               potrebbe  anche  essere  la  stringa  nulla) individuato davanti a
                               a[i]. Il valore di seps[0] è il separatore iniziale (che  potrebbe
                               anche essere la stringa nulla). 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.

       split(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. Se r è omesso, FS viene usato al suo posto. I vettori  a  e
                               seps  sono  svuotati  all'inizio  dell'operazione.  seps[i]  è  il
                               separatore di campi che corrisponde a r  tra  a[i]  e  a[i+1].  La
                               separazione diventa la stessa della separazione dei campi.

       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. 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 è 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
       Gawk offre le seguenti funzioni per ottenere  l'orario  e  formattarlo.  I  dettagli  sono
       forniti in https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.

       mktime(datespec [, utc-flag])
                 Converte  datespec  in  un  orario nella stessa forma restituita da systime(), e
                 restituisce il risultato. Se è presente utc-flag e non è zero e  neppure  nullo,
                 viene  assunto  che l'orario sia nel fuso UTC; altrimenti è assunto che l'orario
                 sia nel fuso locale. Se datespec non contiene sufficienti elementi o se l'orario
                 risultante     è     inammissibile,     mktime()    restituisce    -1.    Vedere
                 https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions
                 per i dettagli su datespec.

       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 offre 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. Passare valori negativi a queste funzioni causa un errore fatale.

       Le funzioni sono:

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

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

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

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

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

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

   Funzioni di tipo
       Le  seguenti  funzioni  forniscono  informazioni  relative agli argomenti che vengono loro
       passati.

       isarray(x) Restituisce vero se x è un vettore, altrimenti falso.

       typeof(x)  Restituisce una stringa che indica il tipo di x. La stringa sarà una di queste:
                  "array", "number", "regexp", "string", "strnum", "unassigned" o "undefined".

   Funzioni di internazionalizzazione
       Le  seguenti  funzioni  possono  essere usate all'interno di un programma AWK per tradurre
       stringhe in fase di esecuzione  del  programma.  Per  informazioni  più  complete,  vedere
       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 si trovino o non
              si possano mettere nelle directory  “standard”.  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".

       dcngettext(stringa1, stringa2, numero [, dominio [, categoria]])
              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".

   Funzioni con valori booleani
       Si  possono creare valori speciali di tipo booleano; vedere il manuale per come funzionano
       e come mai esistono.

       mkbool(espressione)
              In base al valore booleano di espressione restituisce il valore vero  o  falso.  Il
              valore vero ha valore numerico uno. Il valore falso ha valore numerico zero.

FUNZIONI DEFINITE DALL'UTENTE

       Le funzioni in AWK sono definite in questo modo:

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

       Le  funzioni  vengono  eseguite  se  chiamate  dall'interno  di  espressioni, presenti sia
       all'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.

       Le variabili locali sono dichiarate 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. Questa restrizione non si applica alle funzioni
       predefinite elencate sopra.

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

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

       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"   ... }

              {    ...  the_func = "mia_funzione"     @the_func()    # 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.

CARICARE DINAMICAMENTE NUOVE FUNZIONI

       Si  possono aggiungere dinamicamente nuove funzioni scritte in C o C++ all'interprete gawk
       in esecuzione tramite l'istruzione @load. Una descrizione dettagliata non è  possibile  in
       questa                pagina                di               manuale;               vedere
       https://www.gnu.org/software/gawk/manual/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, è 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        scrivere        salve,        mondo        in        Italia.        Vedere
       https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization
       per i passi da seguire per produrre ed eseguire un programma AWK localizzabile.

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
       estensioni possono essere disabilitate invocando  gawk  con  le  opzioni  --traditional  o
       --posix.

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,  e  tramite  la direttiva @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_PERSIST_FILE, se presente, specifica un file da usare come
       archivio di memoria persistente. Si tratta  di  una  caratteristica  sperimentale.  Vedere
       GAWK: Effective AWK Programming per i dettagli.

       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  quello
       successivo.  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 5.2.

AUTORI

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

       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.

NOTIFICA DEI "BUG"

       Se si trova un bug in gawk, usare il programma gawkbug(1) per segnalarlo.

       Le    istruzioni    complete    per    segnalare    un     bus     sono     fornite     in
       https://www.gnu.org/software/gawk/manual/html_node/Bugs.html.     Per    favore    leggere
       attentamente e seguire le istruzioni date lì. Questo semplificherà sia la segnalazione che
       la risoluzione. Veramente.

BUG

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

       Questa pagina di manuale è troppo lunga; gawk ha troppe funzionalità.

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,
       Addison-Wesley, 1988.  ISBN 0-201-07981-X.

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

       La      documentazione      di     gettext     GNU     è     disponibile     online     a:
       https://www.gnu.org/software/gettext.

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

COPYING PERMISSIONS

       Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,  2003,
       2004,  2005, 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020,
       2021, 2022 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 dimanuale in un'altra lingua,
       sotto le condizioni poste sopra per leversioni modificate,  salvo  che  quest'informazione
       suipermessi di copia e ristampa deve essere espressa in una traduzioneapprovata dalla Free
       Software Foundation.

TRADUZIONE

       La traduzione italiana di questa pagina di manuale è stata  creata  da  Giuseppe  Guerrini
       <giusguerrini@racine.ra.it>,  Antonio  Giovanni  Colombo <azc100@gmail.com>, Marco Curreli
       <marcocurreli@tiscali.it> e Giuseppe Sacco <eppesuig@debian.org>

       Questa traduzione è documentazione libera; leggere la GNU General Public License  Versione
       3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
       Non ci assumiamo alcuna responsabilità.

       Per segnalare errori nella traduzione di questa pagina di manuale inviare un  messaggio  a
       ⟨pluto-ildp@lists.pluto.it⟩.