Provided by: manpages-it_4.19.0-7_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.

PREFACE

       This manual page is intentionally as terse as possible.   Full  details  are  provided  in
       GAWK:  Effective  AWK  Programming,  and  you  should look there for the full story on any
       specific feature.  Where possible, links to the online version of the manual are provided.

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 program-file Read the AWK program source from the file program-file, instead
              of  from  the first command line argument.  Multiple -f options may be used.  Files
              read with -f are treated as  if  they  begin  with  an  implicit  @namespace  "awk"
              statement.

       -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 Treat all input data as single-byte characters.  The  --posix
              option overrides this one.

       -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]
              Print a sorted list of global variables, their types and final values to file.  The
              default file is awkvars.out in the current directory.

       -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 this mode of execution, gawk loads the AWK source  code  and  then  prompts  for
              debugging  commands.   Gawk  can only debug AWK program source provided with the -f
              and  --include  options.   The  debugger  is  documented  in  GAWK:  Effective  AWK
              Programming;                                                                    see
              https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.

       -e testo_del_programma,
              --source program-text Use program-text as AWK program source code.   Each  argument
              supplied  via  -e  is  treated  as  if  it begins with an implicit @namespace "awk"
              statement.

       -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,    Scrive   sullo   standard  output  un  riassunto  abbastanza  breve  delle  opzioni
              disponibili. In linea con le convenzioni di codifica GNU Coding  Standards,  queste
              opzioni provocano un'uscita immediata e senza segnalazione di errore.

       -i include-file, --include include-file
              Carica  una  libreria  di  sorgenti  awk.  Cerca  la  libreria  usando la variabile
              d'ambiente AWKPATH. Se la ricerca iniziale non va a buon fine, viene fatto un altro
              tentativo  dopo  aver  aggiunto  il  suffisso .awk. Il file verrà caricato solo una
              volta (cioè vengono ignorati i duplicati), e il codice non costituisce il  sorgente
              del  programma principale. 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  incontrati  durante l'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]
              Provide warnings about constructs that are dubious or  non-portable  to  other  AWK
              implementations.                                                                See
              https://www.gnu.org/software/gawk/manual/html_node/Options.html#Options   for   the
              list of possible values for value.

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

              NOTE:  This  feature  is  on  parole.   The  primary  gawk  maintainer is no longer
              supporting it, although there is a member of the development team who is.  If  this
              situation changes, the feature will be removed from gawk.

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

       -N,    --use-lc-numeric Force gawk to  use  the  locale's  decimal  point  character  when
              parsing input data.

       -o[file], --pretty-print[=file]
              Output  a  pretty  printed  version  of  the  program to file.  The default file is
              awkprof.out in the current directory.  This option implies --no-optimize.

       -O,    --optimize Enable gawk's default optimizations upon the internal representation  of
              the program.  This option is on by default.

       -p[prof-file], --profile[=prof-file]
              Start  a  profiling session, and send the profiling data to prof-file.  The default
              is awkprof.out in the current directory.  The profile contains execution counts  of
              each  statement in the program in the left margin and function call counts for each
              user-defined function.  Gawk runs more slowly in this mode.   This  option  implies
              --no-optimize.

       -P,    --posix  This  turns  on  compatibility  mode,  and  disables  a  number  of common
              extensions.

       -r,    --re-interval  Enable  the  use  of  interval  expressions  in  regular  expression
              matching.  Interval expressions are enabled by default, but this option remains for
              backwards compatibility.

       -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 messaggi d'avvertimento relativi a costrutti non portabili  sulla
              versione originale di awk per UNIX.

       -V,    --version  Print  version  information  for  this  particular  copy  of gawk on the
              standard output.   This  is  useful  when  reporting  bugs.   Per  the  GNU  Coding
              Standards, these options cause an immediate, successful exit.

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

       For each input file, if a BEGINFILE rule exists, gawk executes the associated code  before
       processing  the  contents  of  the file. Similarly, gawk executes the code associated with
       ENDFILE rules after processing the 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.

       For gawk, a directory on the command line produces a warning, but  is  otherwise  skipped.
       If  either of the --posix or --traditional options is given, then gawk reverts to treating
       directories on the command line as a fatal error.

VARIABILI, RECORD E CAMPI

       AWK variables are dynamic; they come into existence  when  they  are  first  used.   Their
       values  are either floating-point numbers or strings, or both, depending upon how they are
       used.  Additionally, gawk allows variables to have regular-expression type.  AWK also  has
       one  dimensional  arrays; arrays with multiple dimensions may be simulated.  However, gawk
       provides true arrays of arrays.  Several pre-defined variables are set as a program  runs;
       these are described as needed and summarized below.

   Record
       Normally,  records  are  separated by newline characters.  You can control how records are
       separated    by    assigning    values    to    the    built-in    variable    RS.     See
       https://www.gnu.org/software/gawk/manual/html_node/Records.html for the details.

   Campi
       As  each  input record is read, gawk splits the record into fields, using the value of the
       FS variable as the field separator.  Additionally, FIELDWIDTHS and FPAT  may  be  used  to
       control     input     field     splitting.      See     the     details,    starting    at
       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
       Gawk's  built-in  variables  are listed below.  This list is purposely terse. For details,
       see https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.

       ARGC        The number of command line arguments.

       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     On  non-POSIX  systems,  specifies use of “binary” mode for all file I/O.  See
                   https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html    for    the
                   details.

       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          The    input    field    separator,    a    space     by     default.      See
                   https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html   for
                   the details.

       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  Controls the case-sensitivity of all regular expression and string operations.
                   See
                   https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html
                   for details.

       LINT        Provides dynamic control of the --lint option from within an AWK program.

       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    The elements of this array provide access to information about the running AWK
                   program.  See  https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset
                   for the details.

       ROUNDMODE   The  rounding  mode  to  use for arbitrary precision arithmetic on numbers, by
                   default      "N"       (IEEE-754       roundTiesToEven       mode).        See
                   https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode
                   for the details.

       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      The index of the first character matched by match(); 0 if no match.

       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      An array whose indices are the names of all currently defined global variables
                   and arrays in the program.  You may not use  the  delete  statement  with  the
                   SYMTAB  array,  nor  assign  to  elements with an index that is not a variable
                   name.

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

   Array
       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 supports true multidimensional arrays. It  does  not  require  that  such  arrays  be
       “rectangular”           as           in          C          or          C++.           See
       https://www.gnu.org/software/gawk/manual/html_node/Arrays for details.

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

       The  standard  predefined  builtin function names may not be used as namespace names.  The
       names of additional functions provided by gawk may be used as namespace names or as simple
       identifiers      in      other      namespaces.       For      more      details,      see
       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
       String constants in AWK are sequences of characters enclosed between double  quotes  (like
       "value").   Within  strings,  certain  escape  sequences  are  recognized,  as  in C.  See
       https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences for the details.

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

       The  escape  sequences  described  in  the manual may also be used inside constant regular
       expressions (e.g., /[ \t\f\n\r\v]/ matches whitespace characters).

       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.

       For  /regular  expression/  patterns,  the associated statement is executed for each input
       record that matches the regular expression.  Regular expressions are essentially the  same
       as  those in egrep(1).  See https://www.gnu.org/software/gawk/manual/html_node/Regexp.html
       for the details on regular expressions.

       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.

       ^           Exponentiation.

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

       ~ !~        Regular expression match, negated match.

       in          Controllo di appartenenza a un vettore.

       &&          AND logico.

       ||          OR logico.

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

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

   Istruzioni di controllo
       Le istruzioni di controllo sono le seguenti:

              if (condizione) istruzione [ else istruzione ]
              while (condizione) istruzione
              do istruzione while (condizione)
              for (espressione1; espressione2; espressione3) istruzione
              for (var in vettore) istruzione
              break
              continue
              delete vettore[indice]
              delete vettore
              exit [ espressione ]
              { 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])  Close an open file, pipe or coprocess.  The optional how should only
                             be  used  when closing one end of a two-way pipe to a coprocess.  It
                             must be a string value, either "to" or "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
                             Format and print.

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

       system(riga-di-comando)
                             Execute the command cmd-line, and return the exit status.  (This may
                             not     be     available     on     non-POSIX     systems.)      See
                             https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions
                             for the full details on the exit status.

       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.

       The AWK versions of the printf statement and sprintf() function are similar to those of C.
       For details, see 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  has  the  following   built-in   string   functions;   details   are   provided   in
       https://www.gnu.org/software/gawk/manual/html_node/String-Functions.

       asort(s [, d [, come] ])
                               Return  the  number  of  elements in the source array s.  Sort the
                               contents of s using gawk's normal rules for comparing values,  and
                               replace  the  indices  of  the  sorted  values  s  with sequential
                               integers starting with 1. If the optional destination array  d  is
                               specified,  first duplicate s into d, and then sort d, leaving the
                               indices of the source array s unchanged. The optional  string  how
                               controls  the direction and the comparison mode.  Valid values for
                               how                are                described                 in
                               https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions.
                               s and d are allowed to be the same array; this  only  makes  sense
                               when supplying the third argument as well.

       asorti(s [, d [, come] ])
                               Return the number of elements in the source array s.  The behavior
                               is the same as that of asort(), except that the array indices  are
                               used  for  sorting, not the array values.  When done, the array is
                               indexed numerically, and the values  are  those  of  the  original
                               indices.   The  original  values  are  lost; thus provide a second
                               array if you wish to preserve the original.  The  purpose  of  the
                               optional string how is the same as for asort().  Here too, s and d
                               are allowed to be the same  array;  this  only  makes  sense  when
                               supplying the third argument as well.

       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])        For each substring matching the regular expression r in the string
                               t,   substitute   the   string   s,   and  return  the  number  of
                               substitutions.  If t is  not  supplied,  use  $0.   An  &  in  the
                               replacement  text  is  replaced  with  the  text that was actually
                               matched.  Use \& to get a literal  &.   (This  must  be  typed  as
                               "\\&";                                                         see
                               https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details
                               for   a   fuller  discussion  of  the  rules  for  ampersands  and
                               backslashes  in  the  replacement  text  of  sub(),  gsub(),   and
                               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])             Return the length of the string s, or the length of $0 if s is not
                               supplied.  With an array argument, length() returns the number  of
                               elements in the array.

       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.   See
                               https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions
                               for a description of how the array a is filled if it is provided.

       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] ])
                               Split  the string s into the array a and the separators array seps
                               on the regular expression r, and return the number of fields.   If
                               r  is  omitted,  FS  is  used  instead.  The arrays a and seps are
                               cleared first.  seps[i]  is  the  field  separator  matched  by  r
                               between  a[i]  and a[i+1].  Splitting behaves identically to field
                               splitting.

       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  provides  the  following  functions  for  obtaining time stamps and formatting them.
       Details are provided in https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.

       mktime(datespec [, utc-flag])
                 Turn datespec into a time stamp of the same form as returned by  systime(),  and
                 return the result.  If utc-flag is present and is non-zero or non-null, the time
                 is assumed to be in the UTC time zone; otherwise, the time is assumed to  be  in
                 the  local  time  zone.   If datespec does not contain enough elements or if the
                 resulting   time   is   out   of    range,    mktime()    returns    -1.     See
                 https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions
                 for the details of 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  supplies  the  following  bit  manipulation  functions.   They  work  by  converting
       double-precision floating point values to uintmax_t integers,  doing  the  operation,  and
       then  converting  the  result back to floating point.  Passing negative operands to any of
       these functions causes a fatal error.

       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) Return true if x is an array, false otherwise.

       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
       The following functions may be used from within your AWK program for  translating  strings
       at            run-time.             For            full            details,            see
       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".

   Boolean Valued Functions
       You can create special Boolean-typed values; see the manual for how they work and why they
       exist.

       mkbool(espressione)
              Based  on  the  boolean  value  of expression return either a true value or a false
              value.  True values have numeric value one.  False values have numeric value 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.

       Local variables are declared as extra parameters in the parameter list.  The convention is
       to separate local variables from real parameters by extra spaces in  the  parameter  list.
       For example:

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

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

       The  left  parenthesis  in  a function call is required to immediately follow the function
       name, without any intervening whitespace.  This restriction does not apply to the built-in
       functions listed above.

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

       Functions may be called indirectly. To do this, assign the name  of  the  function  to  be
       called,  as  a  string,  to a variable.  Then use the variable as if it were the name of a
       function, prefixed with an @ sign, like so:
              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

       You can dynamically add new functions written in C or C++ to the running gawk  interpreter
       with  the @load statement.  The full details are beyond the scope of this manual page; see
       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" }'

       might         print         bonjour,         monde         in         France.          See
       https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization
       for the steps involved in producing and running a localizable AWK program.

ESTENSIONI GNU

       Gawk has  a  too-large  number  of  extensions  to  POSIX  awk.   They  are  described  in
       https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html.  All the extensions
       can be disabled by invoking gawk with the --traditional or --posix options.

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.

       The GAWK_PERSIST_FILE environment variable, if present, specifies a file  to  use  as  the
       backing  store  for  persistent  memory.   This  is  an  experimental  feature.  See GAWK:
       Effective AWK Programming for the details.

       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 UNIX awk è stata progettata e implementata da Alfred Aho, Peter
       Weinberger, e Brian Kernighan dei Bell Laboratories.  Brian Kernighan continua a mantenere
       e migliorare il programma.

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

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

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

NOTIFICA DEI "BUG"

       If you find a bug in gawk, please use the gawkbug(1)  program to report it.

       Full      instructions      for      reporting      a      bug     are     provided     in
       https://www.gnu.org/software/gawk/manual/html_node/Bugs.html.  Please carefully  read  and
       follow  the  instructions  given  there.  This will make bug reporting and resolution much
       easier for everyone involved.  Really.

BUG

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

       This manual page is too long; gawk has too many features.

VEDERE ANCHE

       egrep(1), sed(1), gawkbug(1), printf(3), and 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> e  Marco  Curreli
       <marcocurreli@tiscali.it>

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