Provided by: manpages-it_3.73-2_all 
NOME
gawk - linguaggio per il riconoscimento e il trattamento di espressioni regolari
SINTASSI
gawk [ opzioni in stile POSIX o GNU ] -f file di programma [ -- ] file ...
gawk [ opzioni in stile POSIX o GNU ] [ -- ] testo del programma file ...
DESCRIZIONE
Gawk è l'implementazione nell'ambito del Progetto GNU del linguaggio di programmazione AWK . Si attiene
alla definizione del linguaggio descritta nello Standard POSIX 1003.1. Questa versione è basata a sua
volta sulla descrizione contenuta in The AWK Programming Language, di Aho, Kernighan e Weinberger. Gawk
fornisce le funzionalità aggiuntive presenti nella versione corrente di awk
di Brian Kernighan e diverse estensioni specifiche di GNU.
La riga di comando contiene opzioni per gawk stesso, il testo del programma AWK (se non è stato fornito
con le opzioni -f o --file ), e valori da rendere disponibili nelle variabili AWK predefinite ARGC e ARGV
.
Quando gawk è invocato con l'opzione --profile , inizia a raccogliere statistiche sul comportamento del
programma durante l'esecuzione. Gawk in questa modalità è più lento, e produce automaticamente un
profilo di esecuzione nel file awkprof.out alla fine dell'esecuzione. Si veda l'opzione --profile più
avanti.
Gawk ha anche una capacità integrata di debugging. Una sessione interattiva di analisi degli errori
(debug) può essere iniziata fornendo l'opzione --debug sulla riga di comando. In questa modalità di
esecuzione, gawk carica il codice sorgente di AWK e poi richiede l'inserimento di comandi di debug. Gawk
può analizzare solo il sorgente di un programma AWK fornito tramite l'opzione -f. Il debugger è
documentato in GAWK: Effective AWK Programming.
FORMATO DELLE OPZIONI
Le opzioni di Gawk possono essere sia nella tradizionale forma a una lettera di POSIX, sia nella forma
estesa tipica di GNU. Le opzioni POSIX cominciano con un “-” singolo, quelle in forma lunga cominciano
con “--”. Sono disponibili opzioni in forma lunga sia per le funzionalità specifiche di GNU, sia per
quelle previste da POSIX.
Le opzioni specifiche di Gawk sono usate normalmente nella forma lunga. Gli argomenti delle opzioni in
forma lunga possono essere uniti ad esse da un segno =, senza spazi, oppure sono indicati nel successivo
argomento della riga di comando. Le opzioni lunghe possono essere abbreviate, sempre che l'abbreviazione
rimanga univoca.
In aggiunta, ogni opzione lunga ha una corrispondente opzione corta, in modo che la funzionalità
dell'opzione possa essere usata all'interno di script #! eseguibili.
OPZIONI
Gawk accetta le seguenti opzioni. Le opzioni standard sono elencate per prime, seguite dalle opzioni per
le estensioni gawk, elencate nell'ordine alfabetico delle opzioni corte.
-f file_di_programma
--file file_di_programma
Legge il sorgente del programma AWK dal file file_di_programma, invece che dal primo argomento
della riga di comando. Si possono specificare più opzioni -f (o --file).
-F fs
--separatore_di_campo fs
Usa fs come separatore di campo in input (il valore della variabile incorporata FS ).
-v var=val
--assign var=val
Assegna il valore val alla variabile var, prima che inizi l'esecuzione del programma. Questi
valori delle variabili sono messi a disposizione della regola BEGIN di un programma AWK.
-b
--characters-as-bytes
Tratta tutti i dati in input come caratteri costituiti da un solo byte. In altre parole, non
presta alcuna attenzione alle informazioni sulla localizzazione quando tenta di elaborare stringhe
come caratteri multibyte. L'opzione --posix ignora questo comportamento.
-c
--traditional
Viene eseguito in modalità compatibile. In questa modalità, gawk si comporta esattamente come awk
di Brian Kernighan; non viene riconosciuta nessuna delle estensioni specifiche di GNU. Si veda
ESTENSIONI GNU, più avanti, per maggiori informazioni.
-C
--copyright
Stampa sullo standard output la versione sintetica del messaggio di informazione sul copyright GNU
ed esce senza segnalare errori.
-d[file]
--dump-variables[=file]
Stampa un lista ordinata di variabili globali, specificandone il tipo e il valore finale in file.
Se file non viene specificato, gawk usa un file chiamato awkvars.out nella directory corrente.
Avere una lista di tutte le variabili globali è un buon modo per cercare errori tipografici nei
programmi. Questa opzione potrebbe essere usata anche se si ha un grosso programma con tantissime
funzioni, e ci si vuole assicurare che le funzioni non usino inavvertitamente variabili globali
che sono supposte essere locali (è facile commettere questo errore quando si usano nomi di
variabili semplici come i, j, e così via).
-D[file]
--debug[=file]
Abilita il debugging di programmi AWK. Se non diversamente specificato, l'analizzatore di errori
[debugger] legge i comandi in maniera interattiva dal terminale. L'argomento opzionale file
specifica un file contenente un elenco di comandi per il debugger da eseguire in maniera non
interattiva.
-e testo_del_programma
--source testo_del_programma
Usa testo_del_programma come codice sorgente del programma AWK. Quest'opzione permette di
combinare in modo semplice funzioni di libreria (usate attraverso i file indicati dalle opzioni -f
e --file) con codice sorgente immesso sulla riga di comando. È rivolta principalmente a programmi
AWK di media e grande dimensione usati all'interno di script di shell.
-E file
--exec file
Simile a -f, comunque, quest'opzione è l'ultima ad essere elaborata. Dovrebbe essere usata con
script #!, specialmente per applicazioni CGI [Common Gateway Interface], per evitare di passare
opzioni o codice (!) sulla riga di comando da un URL. Quest'opzione disabilita gli assegnamenti
di variabile da riga di comando.
-g
--gen-pot
Esamina e analizza il programma AWK, e genera un file in formato GNU .pot (Portable Object
Template) sullo standard output con elementi relativi a tutte le stringhe localizzabili nel
programma. Il programma in sé non viene eseguito. Si veda la distribuzione GNU gettext per
maggiori informazioni sui file .pot .
-h
--help Scrive sullo standard output un riassunto abbastanza breve delle opzioni disponibili. (In linea
con le convenzioni di codifica GNU Coding Standards, queste opzioni provocano un'uscita immediata
e senza segnalazione di errore.
-i include-file
--include include-file
Carica una libreria di sorgenti awk. Cerca la libreria usando la variabile d'ambiente AWKPATH.
Se la ricerca iniziale non va a buon fine, viene fatto un altro tentativo dopo aver aggiunto il
suffisso .awk . Il file verrà caricato solo una volta (cioè vengono ignorati i duplicati), e il
codice non costituisce il sorgente del programma principale.
-l lib
--load lib
Carica una libreria condivisa lib. Cerca la libreria usando la variabile d'ambiente AWKLIBPATH .
Se la ricerca iniziale non va a buon fine, viene fatto un altro tentativo dopo aver aggiunto il
suffisso della libreria condivisa predefinita per la piattaforma. La procedura di
inizializzazione della libreria si suppone avere come nome dl_load().
-L [valore]
--lint[=valore]
Emette messaggi d'avvertimento relativi a costrutti dubbi o non portabili su altre implementazioni
di AWK. Con l'argomento opzionale fatal, gli avvertimenti lint sono considerati come errori
fatali. Questo può essere drastico, ma incoraggerà sicuramente lo sviluppo di programmi AWK più
corretti. Con l'argomento opzionale invalid, vengono emessi solo gli avvertimenti relativi a
quello che è effettivamente non valido (funzionalità non ancora completamente implementata).
-M
--bignum
Forza il calcolo con precisione arbitraria sui numeri. Quest'opzione non ha effetto se gawk non è
compilato per l'uso delle librerie GNU MPFR e MP.
-n
--non-decimal-data
Riconosce valori ottali ed esadecimali nei dati in input. Usare quest'opzione con molta cautela!
-N
--use-lc-numeric
Forza gawk a usare il carattere di separazione decimale della localizzazione quando analizza i
dati in input. Sebbene lo standard POSIX richieda questo comportamento, e gawk faccia questo
quando l'opzione --posix è attiva, il comportamento predefinito è quello tradizionale di usare il
punto come separatore decimale, anche per le localizzazioni in cui il carattere di separazione non
è il punto. Quest'opzione ignora il comportamento predefinito, senza il rigore draconiano
dell'opzione --posix .
-o[file]
--pretty-print[=file]
Stampa una versione formattata graziosamente del programma su file. Se non viene indicato un
file, gawk usa un file di nome awkprof.out nella directory corrente.
-O
--optimize
Abilita ottimizzazioni nella rappresentazione interna del programma. Attualmente, questo
comprende il calcolo di costanti, se possibile, al momento della compilazione, e l'eliminazione
della chiamata di coda per funzioni ricorsive. Il manutentore di gawk spera di aggiungere nel
tempo ulteriori ottimizzazioni.
-p[prof-file]
--profile[=prof-file]
Inizia una sessione di "profiling", e invia i dati tracciati al file prof-file. Quello
predefinito è awkprof.out. Il profilo contiene il numero di esecuzioni di ogni istruzione sul
margine sinistro e il conteggio delle chiamate di funzione per ogni funzione definita dall'utente.
-P
--posix
Quest'opzione attiva la modalità di compatibilità , con le seguenti restrizioni aggiuntive:
• Le sequenze di protezione \x non vengono riconosciute.
• Quando a FS è assegnato come valore un singolo spazio, solo spazio e TAB fungono da separatori
di campo, il newline invece no.
• Non è possibile continuare le righe dopo ? e :.
• Non viene riconosciuto il sinonimo func per la parola chiave function .
• Non si possono usare gli operatori ** e **= al posto di ^ e ^=.
-r
--re-interval
Abilita l'uso di espressioni di intervallo nelle espressioni regolari (si veda Espressioni
regolari, più avanti). Nel linguaggio AWK le espressioni di intervallo non sono mai state
disponibili. Lo standard POSIX le ha aggiunte, per rendere awk ed egrep coerenti tra di loro.
Sono abilitate in modalità predefinita, però quest'opzione rimane per essere usata con l'opzione
--traditional.
-S
--sandbox
Esegue gawk in modalità "sandbox", disabilitando la funzione system(), la ridirezione dell'input
con getline, la ridirezione sull'output con print e printf, e il caricamento delle estensioni
dinamiche. L'esecuzione di comandi (tramite pipeline) è anch'essa disabilitata. Questo impedisce
completamente l'accesso di uno script alle risorse locali (tranne che per i file specificati nella
riga di comando).
-t
--lint-old
Emette messaggi d'avvertimento relativi a costrutti non portabili sulla versione originale di awk
per UNIX.
-V
--version
Scrive sullo standard output la versione di questa particolare copia di gawk. È utile
principalmente per sapere se la copia di gawk attualmente installata è aggiornata rispetto a ciò
che Free Software Foundation sta distribuendo. È utile anche quando si devono segnalare degli
errori. (In linea con le convenzioni di codifica GNU Coding Standards, queste opzioni provocano
un'uscita immediata e senza segnalazione di errore.)
-- Segnala la fine delle opzioni. È utile perché permette di passare al programma AWK ulteriori
argomenti [nomi di file] che iniziano con “-”. Questo assicura una coerenza con le convenzioni di
esame degli argomenti usato dalla maggior parte dei programmi POSIX .
In modalità compatibile, qualsiasi altra opzione è contrassegnata come non valida e viene ignorata.
Nell'uso normale, sempre che sia stato fornito il testo del programma, le opzioni sconosciute sono
passate al programma AWK nel vettore ARGV per l'elaborazione. Questo è particolarmente utile per
eseguire i programmi AWK attraverso il meccanismo dell'interprete eseguibile “#!”.
Per compatibilità con POSIX, si può usare l'opzione -W , seguita dal nome di un'opzione lunga.
ESECUZIONE DEL PROGRAMMA AWK
Un programma AWK consiste di una sequenza di istruzioni di tipo criterio-azione e di definizioni di
funzione opzionali.
@include "nome_del_file"
@load "nome_del_file"
criterio di ricerca { istruzioni di azione }
function nome(lista di parametri) { istruzioni }
Gawk prima legge il codice del programma dal/dai file_di_programma se specificato/i, dagli argomenti
passati a --source, o dal primo argomento sulla riga di comando che non sia un'opzione. Le opzioni -f e
--source possono essere usate più volte nella riga di comando. Gawk legge il testo del programma come se
tutti i file_di_programma e i testi sorgenti della riga di comando fossero concatenati. Questo permette
di realizzare librerie di funzioni AWK senza bisogno di includerle in ogni nuovo programma AWK che le
usi; inoltre si possono combinare funzioni di libreria con programmi provenienti dalla riga di comando.
Oltre a ciò, le righe che iniziano con @include possono essere usate per includere altri file sorgenti
nel programma, rendendo l'uso della libreria ancora più facile. Questo è equivalente all'uso
dell'opzione -i.
Le righe che iniziano con @load possono essere usate per caricare librerie condivise nel programma.
Questo è equivalente all'uso dell'opzione -l.
La variabile d'ambiente AWKPATH specifica il percorso lungo il quale cercare i file sorgenti indicati con
le opzioni -f e -i. Se questa variabile non esiste, il percorso predefinito è ".:/usr/local/share/awk"
(la directory in questione può variare a seconda di come gawk è stato compilato e installato). Se un
nome di file dato con l'opzione -f contiene un carattere “/”, non viene eseguita nessuna ricerca sul
percorso.
La variabile d'ambiente AWKLIBPATH specifica il percorso lungo il quale cercare i file sorgenti indicati
con l'opzione -l , Se questa variabile non esiste, il percorso predefinito è ".:/usr/local/lib/gawk" (la
directory in questione può variare a seconda di come gawk è stato compilato e installato).
Gawk esegue i programmi AWK nell'ordine seguente. Per prima cosa, vengono effettuati tutti gli
assegnamenti di variabile indicati dall'opzione -v. Successivamente, gawk compila il programma in un
formato interno. Poi gawk esegue il codice nella regola/e BEGIN (se esistente/i), quindi procede con la
lettura di ciascun file indicato nel vettore ARGV (fino a ARGV[ARGC]). Se non ci sono file indicati
nella riga di comando, gawk legge dallo standard input.
Se un nome di file nella riga di comando ha la forma var=val, è trattato come un assegnamento di
variabile. Alla variabile var sarà assegnato il valore val (questo accade dopo che ogni regola BEGIN è
stata eseguita). L'assegnamento di variabili da riga di comando è utilissima per assegnare dinamicamente
valori alle variabili che AWK usa per controllare come l'input è organizzato in campi e record. È utile
inoltre per controllare variabili di stato quando siano necessari più passi di elaborazione su un singolo
file di dati.
Se il valore di un particolare elemento di ARGV è la stringa vuota (""), gawk lo salta.
Per ogni file in input, se esiste una regola BEGINFILE, gawk esegue il codice associato prima di
elaborare il contenuto del file. Similarmente, gawk esegue il codice associato a ENDFILE dopo
l'elaborazione del file.
Per ogni record in input, gawk controlla se c'è corrispondenza con qualche criterio di ricerca
specificato nel programma AWK. Per ogni criterio di ricerca a cui un record corrisponde, gawk esegue
l'azione associata. I criteri di ricerca sono verificati nell'ordine in cui appaiono nel programma.
Infine, dopo che sono esauriti i dati in input, gawk esegue il codice nelle regola/e END (se
esistente/i),
Directory nella riga di comando
Secondo POSIX, i file indicati sulla riga di comando di awk devono essere file di testo. Se non lo sono
il comportamento è ``indefinito''. La maggior parte delle versioni di awk considerano una directory
sulla riga di comando come un errore fatale.
A partire dalla versione 4.0 di gawk, una directory sulla riga di comando produce solo un messaggio di
avvertimento, senza conseguenze. Se sono date le opzioni --posix o --traditional gawk ritorna a trattare
le directory sulla riga di comando come errore fatale.
VARIABILI, RECORD E CAMPI
Le variabili di AWK sono dinamiche; iniziano a esistere la prima volta che vengono usate. I loro valori
sono numeri in virgola mobile, o stringhe, o entrambe le cose, a seconda di come sono usati la prima
volta. Inoltre AWK dispone di vettori monodimensionali; i vettori multidimensionali possono essere
simulati [da vettori monodimensionali]. Gawk fornisce veri vettori di vettori; si veda Vettori, più
avanti. Al momento dell'esecuzione del programma sono impostate parecchie variabili predefinite; saranno
descritte di volta in volta quando sarà necessario, ed elencate più avanti.
Record
Normalmente i record sono separati dal carattere newline. Si può controllare il modo in cui i record
sono separati assegnando valori alla variabile incorporata RS. Se RS contiene un qualsiasi carattere
singolo, tale carattere separa i record. Altrimenti, se RS è un'espressione regolare, il testo
nell'input che corrisponde a questa espressione regolare sarà il separatore di record. Tuttavia, nella
modalità compatibile è preso in considerazione solo il primo carattere della stringa risultante, come
separatore. Se RS contiene la stringa nulla, i record sono separati da righe vuote. Quando RS contiene
la stringa nulla, il carattere newline ha sempre la funzione di separatore di campo in aggiunta a quello
indicato dalla variabile FS, quale che esso sia.
Campi
Ogni volta che gawk legge un record lo spezza in campi, usando il valore della variabile FS come
separatore di campo. Se FS è un carattere singolo, i campi sono separati da quel carattere. Se FS è la
stringa nulla, ogni singolo carattere diventa un campo a sé. Diversamente, si presume che FS sia
un'espressione regolare completa. Nel caso particolare in cui FS sia un singolo spazio, i campi sono
separati da sequenze di spazi, caratteri di tabulazione o newline (ma si veda la sezione COMPATIBILITÀ
POSIX più avanti). NOTA: Il valore di IGNORECASE (vedi più avanti) influenza anche il modo in cui i
campi sono spezzati quando FS è un'espressione regolare, e come i record vengano separati quando RS è
un'espressione regolare.
Se alla variabile FIELDWIDTHS è assegnata una lista di numeri separati da spazi, ogni campo è considerato
di lunghezza fissa, e gawk spezza il record secondo le ampiezze specificate. Il valore di FS è ignorato.
Assegnando un nuovo valore a FS o a FPAT si annulla l'effetto di FIELDWIDTHS.
Similmente, se alla variabile FPAT è assegnata una stringa che rappresenta un'espressione regolare, ogni
campo è composto di testo che corrisponde a quella espressione regolare. In questo caso, l'espressione
regolare descrive i campi stessi, invece che il testo che separa i campi. Assegnando un nuovo valore a
FS o a FIELDWIDTHS si annulla l'effetto di FPAT.
Ogni campo nel record in input può essere individuato dalla sua posizione: $1, $2, e così via. $0 è
l'intero record. Non è necessario che i campi siano indicati da costanti:
n = 5
print $n
stampa il quinto campo del record in input.
La variabile NF contiene il numero di campi nel record in input.
Riferimenti a campi inesistenti (cioè campi dopo $NF) producono la stringa vuota. Tuttavia,
l'assegnamento ad un campo inesistente (per esempio $(NF+2) = 5) provoca l'incremento del valore di NF,
crea tutti i campi intermedi assegnando loro la stringa nulla, e fa sì che il valore di $0 sia
ricalcolato utilizzando OFS per separare i campi. Riferimenti a campi con indice negativo producono un
errore fatale. Il decremento di NF provoca la perdita dei campi di indice superiore al valore impostato,
ed il ricalcolo di $0, utilizzando OFS per separare i campi.
L'assegnamento di un valore a un campo esistente provoca la ricostruzione dell'intero record quando si
faccia riferimento a $0. Analogamente, assegnare un valore a $0 provoca una nuova divisione del record,
creando nuovi valori per i suoi campi.
Variabili incorporate
Le variabili incorporate di gawk sono:
ARGC Il numero di argomenti da riga di comando (non include le opzioni di gawk o il sorgente del
programma).
ARGIND L'indice in ARGV del file correntemente in elaborazione.
ARGV Vettore degli argomenti della riga di comando. Il vettore è indicizzato da 0 ad ARGC - 1.
La modifica dinamica del contenuto di ARGV può controllare i file usati per i dati.
BINMODE Su sistemi non-POSIX, specifica l'uso della modalità “binaria” per tutti i file I/O. I
valori numerici 1, 2 e 3 specificano che i file di input, i file di output e tutti i file,
rispettivamente, dovrebbero usare I/O binari. I valori di stringa "r" e "w" specificano che
i file di input e i file di output, rispettivamente, dovrebbero usare I/O binari. I valori
di stringa "rw" e "wr" specificano che tutti i file dovrebbero usare I/O binari. Qualsiasi
altro valore di stringa è trattato come "rw", ma genera un messaggio di avvertimento.
CONVFMT Il formato di conversione dei numeri, quello predefinito è "%.6g".
ENVIRON Un vettore contenente i valori dell'ambiente corrente. Il vettore è indicizzato dalle
variabili d'ambiente, e ogni elemento è il valore di quella variabile (per esempio,
ENVIRON["HOME"] potrebbe essere "/home/arnold"). La modifica di questo vettore non ha
effetto sull'ambiente ereditato dai programmi che gawk esegue per ridirezione o tramite la
funzione system().
ERRNO Se ha luogo un errore di sistema durante una ridirezione per una getline, o durante una
lettura fatta con getline, oppure in una close(), ERRNO conterrà una stringa che descrive
l'errore. Il valore è passibile di traduzione nelle localizzazioni diverse dall'inglese.
FIELDWIDTHS Una lista di dimensioni di campo separate da spazi. Se impostato, gawk suddivide l'input
secondo campi di larghezza fissa, anziché usare il valore della variabile FS come separatore
di campo. Si veda Campi, più sopra.
FILENAME Il nome del file di input corrente. Se non sono specificati file nella riga di comando, il
valore di FILENAME è “-”. Tuttavia, FILENAME è indefinito all'interno della regola BEGIN (a
meno che non sia impostato da getline).
FNR Il numero di record corrente del file in input corrente.
FPAT Un'espressione regolare che descrive il contenuto dei campi in un record. Se impostato, gawk
suddivide l'input in campi, dove i campi corrispondono all'espressione regolare, invece di
usare il valore della variabile FS come separatore di campo. Si veda Campi, più sopra.
FS Il separatore di campo, quello predefinito è uno spazio. Si veda Campi, più sopra.
FUNCTAB Un vettore i cui indici e i corrispondenti valori sono i nomi di tutte le funzioni definite
dall'utente o funzioni di estensione presenti nel programma. NOTA: Si può non usare
l'istruzione delete applicandola al vettore FUNCTAB.
IGNORECASE Controlla la sensibilità alla distinzione tra maiuscole e minuscole in tutte le espressioni
regolari e nelle operazioni sulle stringhe. Se IGNORECASE ha un valore diverso da zero, il
confronto di stringhe e la ricerca di corrispondenze nei criteri di ricerca, la separazione
di campi tramite FS e FPAT, la separazione di record tramite RS, la ricerca di corrispondenze
nelle espressioni regolari con ~ e !~, e le funzioni incorporate gensub(), gsub(), index(),
match(), patsplit(), split(), e sub() ignoreranno tutti la differenza tra maiuscole e
minuscole nelle operazioni con le espressioni regolari. NOTA: Non ha effetto sugli indici
dei vettori. Tuttavia, sulle funzioni asort() e asorti() ha effetto.
Così, se IGNORECASE è diverso da zero, /aB/ corrisponde a tutte queste stringhe : "ab", "aB",
"Ab", e "AB". Come per tutte le variabili di AWK, il valore iniziale di IGNORECASE è zero,
cosicché tutte le operazioni sulle espressioni regolari e su stringhe normalmente distinguono
tra maiuscole e minuscole.
LINT Fornisce un controllo dinamico dell'opzione --lint dall'interno di un programma AWK. Quando
il valore è "vero", gawk stampa avvertimenti lint. Quando è "falso", no. Assegnando il
valore di stringa "fatal", gli avvertimenti lint sono considerati errori fatali, esattamente
come --lint=fatal. Qualsiasi altro valore "vero" stampa solo avvertimenti.
NF Il numero di campi nel record corrente.
NR Il numero totale di record incontrati finora.
OFMT Il formato d'uscita per i numeri, quello predefinito è "%.6g".
OFS Il separatore di campi in uscita, normalmente è uno spazio.
ORS Il separatore di record in uscita, normalmente la sequenza di fine linea ("newline").
PREC La precisione di lavoro di numeri a virgola mobile con precisione arbitraria, 53 [bit] è il
valore predefinito.
PROCINFO Gli elementi di questo vettore forniscono accesso alle informazioni sul programma AWK in
esecuzione. Su alcuni sistemi, ci possono essere elementi nel vettore, da "gruppo1" a
"gruppon" per qualsiasi n, che è il numero di gruppi supplementari che ha il processo. Usare
l'operatore in per verificare la presenza di questi elementi. I seguenti elementi sono
sicuramente disponibili:
PROCINFO["egid"] Il valore della chiamata di sistema getegid(2).
PROCINFO["strftime"]
La stringa di formato data/ora predefinita per strftime().
PROCINFO["euid"] Il valore della chiamata di sistema geteuid(2).
PROCINFO["FS"] "FS" se la separazione in campi con FS è attiva, "FPAT" se la separazione
in campi con FPAT è attiva, o "FIELDWIDTHS" se la separazione in campi
con FIELDWIDTHS è attiva.
PROCINFO["identifiers"]
Un sottovettore, avente come indici i nomi di tutti gli identificatori
usati nel testo del programma AWK. I valori indicano quello che gawk
conosce degli identificatori dopo aver finito di analizzare il programma;
essi non sono aggiornati durante l'esecuzione del programma. Per ogni
identificatore, il valore dell'elemento è uno fra questi:
"array"
L'identificatore è un vettore.
"extension"
L'identificatore è una funzione di estensione caricata con @load.
"scalar"
L'identificatore è uno scalare.
"untyped"
L'identificatore non è classificato (potrebbe essere usato come
scalare o come vettore, gawk ancora non lo sa).
"user" L'identificatore è una funzione definita dall'utente.
PROCINFO["gid"] Il valore della chiamata di sistema getgid(2).
PROCINFO["pgrpid"] Il process group ID del processo corrente.
PROCINFO["pid"] L'ID di processo del processo corrente.
PROCINFO["ppid"] Il process ID del "padre" [parent] del processo corrente.
PROCINFO["uid"] Il valore della chiamata di sistema getuid(2).
PROCINFO["sorted_in"]
Se questo elemento esiste in PROCINFO, il suo valore controlla l'ordine
in cui gli elementi del vettore sono attraversati nei cicli for. I
valori supportati sono "@ind_str_asc", "@ind_num_asc", "@val_type_asc",
"@val_str_asc", "@val_num_asc", "@ind_str_desc", "@ind_num_desc",
"@val_type_desc", "@val_str_desc", "@val_num_desc", e "@unsorted". Il
valore può essere anche il nome di una qualsiasi funzione di confronto
definita nel seguente modo:
function cmp_func(i1, v1, i2, v2)
dove i1 e i2 sono gli indici, e v1 e v2 sono i valori corrispondenti dei
due elementi che si stanno confrontando. Dovrebbe restituire un numero
minore, uguale o maggiore di 0, a seconda di come devono essere ordinati
gli elementi del vettore.
PROCINFO["input", "READ_TIMEOUT"]
Il tempo massimo a disposizione in millisecondi per leggere i dati da
input, dove input è una stringa di ridirezione o un nome di file. Un
valore di zero o o minore di zero significa nessun limite di tempo.
PROCINFO["mpfr_version"]
La versione della libreria GNU MPFR usata per il supporto ai numeri con
precisione arbitraria in gawk. Questa voce non è presente se il supporto
MPFR non è stato compilato in gawk.
PROCINFO["gmp_version"]
La versione della libreria GNU MP usata per il supporto ai numeri con
precisione arbitraria in gawk. Questa voce non è presente se il supporto
MPFR non è stato compilato in gawk.
PROCINFO["prec_max"]
La massima precisione supportata dalla libreria GNU MPFR per i numeri a
virgola mobile con precisione arbitraria. Questa voce non è presente se
il supporto MPFR non è stato compilato in gawk.
PROCINFO["prec_min"]
La minima precisione supportata dalla libreria GNU MPFR per i numeri a
virgola mobile con precisione arbitraria. Questa voce non è presente se
il supporto MPFR non è stato compilato in gawk.
PROCINFO["api_major"]
La versione principale dell'estensione API. Questa voce non è presente
se non è disponibile il caricamento delle estensioni dinamiche.
PROCINFO["api_minor"]
La versione secondaria dell'estensione API. Questa voce non è presente
se non è disponibile il caricamento delle estensioni dinamiche.
PROCINFO["version"] la versione di gawk.
ROUNDMODE La modalità di arrotondamento da usare per operazioni sui numeri con precisione arbitraria,
quella predefinita è "N" (IEEE-754 roundTiesToEven mode). Sono accettati i valori "N" o "n"
per roundTiesToEven, "U" o "u" per roundTowardPositive, "D" o "d" per roundTowardNegative,
"Z" o "z" per roundTowardZero e, se la versione della libreria GNU MPFR in uso li supporta,
"A" o "a" per roundTiesToAway.
RS Il separatore di record in input, normalmente "newline".
RT Il terminatore di record. Gawk pone RT uguale al testo in input che corrisponde al carattere
o alla espressione regolare indicati in RS.
RSTART L'indice del primo carattere trovato da match(), oppure 0 se non ci sono corrispondenze
(questo implica che gli indici dei caratteri inizino da uno).
RLENGTH La lunghezza della stringa trovata da match(); oppure -1 se non ci sono corrispondenze.
SUBSEP Il carattere usato per separare indici multipli negli elementi di un vettore, quello
predefinito è "\034".
SYMTAB Un vettore i cui indici sono i nomi di tutti i vettori e le variabili globali attualmente
definite presenti nel programma. Il vettore può essere usato per l'accesso indiretto in
lettura e scrittura del valore di una variabile:
foo = 5
SYMTAB["foo"] = 4
print foo # stampa 4
La funzione isarray() può essere usata per controllare se un elemento in SYMTAB è un vettore.
Non è possibile usare l'istruzione delete per il vettore SYMTAB .
TEXTDOMAIN Il dominio di testo del programma AWK ; usato per trovare le traduzioni localizzate delle
stringhe del programma.
Vettori
I vettori hanno per indice un'espressione tra parentesi quadre ([ e ]). Se l'espressione è formata da
una lista di espressioni (expr, expr ...) l'indice del vettore è una stringa ottenuta concatenando i
valori (stringa) di ogni espressione, separati dal valore della variabile SUBSEP . Questa modalità è
usata per simulare vettori multidimensionali. Per esempio:
i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"
assegna la stringa "hello, world\n" all'elemento del vettore x che è indicizzato dalla stringa
"A\034B\034C". In AWK, tutti i vettori sono associativi, cioè indicizzati da valori di tipo stringa.
L'operatore speciale in può essere usato per controllare se un vettore contiene un certo valore come
indice.
if (val in vettore)
print vettore[val]
Se il vettore ha indici multipli, si usi (i, j) in vettore.
Il costrutto in può anche essere usato in un ciclo for per iterare su tutti gli elementi di un vettore.
Un elemento di un vettore può essere cancellato con l'istruzione delete . delete può anche essere usato
per cancellare l'intero contenuto di un vettore, basta specificare il nome del vettore stesso senza
indici.
gawk supporta veri vettori multidimensionali. Non richiede che tali vettori siano ``rettangolare'' come
in C or C++. Per esempio:
a[1] = 5
a[2][1] = 6
a[2][2] = 7
NOTA: Si potrebbe aver necessità di dire a gawk che un elemento di un vettore è in realtà un sottovettore
per usarlo dove gawk si aspetta di trovare un vettore (come nel secondo argomento di split()). Si può
fare questo creando un elemento nel sottovettore e cancellandolo poi con l'istruzione delete .
Notazione e conversione delle variabili
Le variabili e i campi possono essere numeri (in virgola mobile), stringhe, o entrambe le cose. Come sia
interpretato il valore di una variabile dipende dal contesto. In un'espressione numerica, sarà trattato
come un numero; usato come stringa, sarà trattato come tale.
Per far trattare una variabile come numero, le si sommi 0; per ottenere che venga trattata come come
stringa, le si concateni la stringa nulla.
Le variabili non inizializzate hanno sia il valore numerico 0 che il valore di stringa "" (la stringa
nulla, o vuota).
Quando una stringa deve essere convertita in un numero, la conversione è compiuta con strtod(3). I
numeri sono convertiti a stringhe usando sprintf(3) col valore di CONVFMT come stringa di formato ed il
valore numerico della variabile come argomento. Tuttavia, anche se tutti i numeri in AWK sono in virgola
mobile ("float"), i valori privi di decimali sono sempre convertiti in numeri interi. Così, dati
CONVFMT = "%2.2f"
a = 12
b = a ""
la variabile b ha un valore di tipo stringa di "12" e non "12.00".
NOTA: Quando si opera in modalità POSIX (come con l'opzione --posix), bisogna fare attenzione che le
impostazioni per la localizzazione possono interferire col modo in cui sono trattati i numeri decimali:
il separatore decimale dei numeri che si forniscono a gawk deve essere conforme a quello che si aspetta
la localizzazione in uso, che sia un punto (.) o una virgola (,).
Gawk esegue i confronti nel modo seguente: Se due variabili sono numeriche, sono confrontate
numericamente. Se una è numerica e l'altra è una stringa interpretabile come “stringa numerica,” sono
pure confrontate numericamente. Negli altri casi, gli eventuali valori numerici sono convertiti in
stringhe, ed è eseguito un confronto tra stringhe. Ovviamente, due stringhe sono confrontate come
stringhe.
Si noti che le costanti stringa, come "57", non sono stringhe numeriche, ma solo costanti stringa.
L'idea di “stringa numerica” si applica solo ai campi, all'input di getline, a FILENAME, agli elementi di
ARGV di ENVIRON , ed agli elementi di un vettore creato da split() o da patsplit() che abbiano le
caratteristiche di una stringa numerica. L'idea fondamentale è che i dati immessi dall'utente, e solo
essi, se risultano essere numerici, saranno trattati come numeri.
Costanti ottali ed esadecimali
Nel codice sorgente del programma si possono usare costanti ottali ed esadecimali in stile C. Per
esempio, il valore ottale 011 è uguale al decimale 9, e il valore esadecimale 0x11 è uguale al decimale
17.
Costanti di tipo stringa
Le costanti stringa in AWK sono sequenze di caratteri racchiusi tra doppi apici (come "valore").
All'interno delle stringhe, sono riconosciute alcune sequenze di protezione, come in in C. Queste sono:
\\ Una barra inversa letterale.
\a Il carattere “alert”; in genere il carattere ASCII BEL.
\b Tasto di cancellazione all'indietro (backspace).
\f Salto pagina (form-feed).
\n Nuova riga (newline).
\r Ritorno carrello (CR).
\t Tabulazione orizzontale.
\v Tabulazione verticale.
\xcifre_esa
Il carattere rappresentato dalla stringa di cifre esadecimali dopo la \x. Come in ISO C, tutte le
cifre esadecimali che seguono sono considerate parte della sequenza di protezione. (Questa
"funzionalità" la dice lunga riguardo alla progettazione di un linguaggio da parte di un comitato.)
Per esempio, "\x1B" è il carattere ASCII ESC (escape).
\ddd Il carattere rappresentato da una sequenza di 3 cifre ottali. Per esempio, "\033" è il carattere
ASCII ESC (escape).
\c Il carattere letterale c.
Le sequenze di protezione possono essere usate anche all'interno di espressioni regolari utilizzate come
costanti (per esempio, /[ \t\f\n\r\v]/ corrisponde a spazi vuoti).
In modalità compatibile, i caratteri rappresentati da sequenze di protezione ottali ed esadecimali sono
trattati letteralmente, se usati in costanti costituite da espressioni regolari. Così, /a\52b/ è
equivalente a /a\*b/.
CRITERI DI RICERCA E AZIONI
AWK è un linguaggio che procede per righe. Il criterio va a inizio riga, l'azione lo segue. Le
istruzioni dell'azione sono racchiuse tra { e }. Sia il criterio che l'azione possono mancare ma,
naturalmente, non entrambi. Se manca il criterio, l'azione è eseguita per ogni record in input.
Omettere invece l'azione equivale a specificare
{ print }
ossia stampare l'intero record.
I commenti cominciano col carattere #, e continuano fino a fine riga. Si possono separare le istruzioni
con righe vuote. Un'istruzione finisce normalmente alla fine della riga, a meno che non termini con una
virgola, {, ?, :, &&, o ||. Le istruzioni in righe terminanti con do o else continuano automaticamente
alla riga successiva. Negli altri casi, una riga terminante con un “\” continua alla successiva, e il
"newline" è ignorato.
Si possono scrivere più istruzioni sulla stessa riga separandole con “;”. Questo si applica sia alle
istruzioni all'interno di un'azione (il caso più comune), sia ai gruppi criterio-azione stessi.
Criteri di ricerca
I criteri di ricerca di AWK possono assumere le forme seguenti:
BEGIN
END
BEGINFILE
ENDFILE
/espressione regolare/
espressione di relazione
criterio && criterio
criterio || criterio
criterio ? criterio : criterio
(criterio)
! criterio
criterio1, criterio2
BEGIN e END sono due tipi speciali di criteri di ricerca, che non dipendono dai dati in input. Le azioni
di tutti i criteri di ricerca BEGIN sono unite insieme, come se tutte le istruzioni fossero scritte in
un'unica regola BEGIN , e sono eseguite prima che sia letto qualsiasi input. Allo stesso modo, tutte le
regole END sono fuse insieme, ed eseguite dopo che tutti i dati in input sono terminati o dopo che si è
incontrata l'istruzione exit . BEGIN e END non possono essere combinati con altri criteri in espressioni
di ricerca. I criteri BEGIN e END devono necessariamente essere seguiti dall'indicazione di un'azione
BEGINFILE e ENDFILE sono altri criteri speciali il cui contenuto è eseguito prima della lettura del primo
record di ogni file di input richiamato sulla riga di comando, e dopo la lettura dell'ultimo record di
ognuno di questi file. All'interno della regola BEGINFILE il valore di ERRNO sarà una stringa vuota se
il file è stato aperto con successo. Altrimenti, in caso di problemi col file il codice dovrebbe usare
nextfile per saltarlo. Se non lo fa, gawk emette il solito errore fatale per i file che non possono
essere aperti.
Per i criteri del tipo /espressione regolare/ l'azione associata è eseguita per ogni record in input che
corrisponde all'espressione regolare. Le espressioni regolari hanno la stessa forma di quelle di
egrep(1), e sono descritte più avanti.
In un'espressione relazionale si può usare qualsiasi operatore definito nella sezione sulla azioni, più
avanti. Generalmente l'espressione relazionale è utilizzata per verificare se certi campi siano
individuati da determinate espressioni regolari.
Gli operatori &&, ||, e ! sono rispettivamente l'AND logico, l'OR logico e il NOT logico. Come i loro
equivalenti del linguaggio C, sono valutati solo il numero di operandi strettamente necessario a decidere
il risultato, a partire da quello più a sinistra ("short-circuit evaluation"). Sono usati per combinare
espressioni di ricerca più semplici. Come nella maggior parte dei linguaggi, si possono usare parentesi
per cambiare l'ordine di valutazione.
L'operatore ?: è simile allo stesso operatore in C: se il primo criterio è vero, allora il criterio
utilizzato per il test è il secondo, altrimenti è il terzo. Dei criteri secondo e terzo, ne è valutato
sempre solo uno.
Un'espressione nella forma criterio1, criterio2 è detta criterio intervallo. Essa individua tutti i
record a partire da quello che ha corrispondenza con criterio1, fino a quello che corrisponde a
criterio2, compreso. Non può essere combinata con alcun'altra espressione.
Espressioni regolari
Le espressioni regolari sono del tipo esteso che si trova in egrep. Sono composte da caratteri secondo
le regole seguenti:
c Corrisponde al carattere (non speciale) c.
\c Corrisponde al carattere c considerato letteralmente.
. Corrisponde a qualsiasi carattere, compreso "newline".
^ Corrisponde all'inizio di una stringa.
$ Corrisponde alla fine di una stringa.
[abc...] Una lista di caratteri: corrisponde a uno qualsiasi dei caratteri abc.... Si possono
includere intervalli di caratteri separandoli con un trattino.
[^abc...] Una lista di caratteri negata: corrisponde a qualsiasi carattere eccetto abc....
r1|r2 Alternativa: corrisponde a r1 oppure a r2.
r1r2 Concatenazione: corrisponde a r1, e poi r2.
r+ Corrisponde a una o più r.
r* Corrisponde a zero o più r.
r? Corrisponde a zero o una r.
(r) Raggruppamento: corrisponde a r.
r{n}
r{n,}
r{n,m} Uno o due numeri racchiusi tra parentesi graffe indicano una espressione di intervallo. Se
c'è un numero tra parentesi graffe, l'espressione regolare che precede r è ripetuta n volte.
Se tra parentesi graffe ci sono due numeri separati da virgola, r è ripetuta da n ad m volte.
Se c'è un numero seguito da una virgola, r è ripetuta almeno n volte.
\y Corrisponde alla stringa vuota all'inizio o alla fine di una parola.
\B Corrisponde alla stringa vuota all'interno di una parola.
\< Corrisponde alla stringa vuota all'inizio di una parola.
\> Corrisponde alla stringa vuota alla fine di una parola. \s Corrisponde a qualsiasi spazio
vuoto.
\S Corrisponde a qualsiasi carattere che non sia uno spazio vuoto.
\w Corrisponde a un qualsiasi carattere che possa far parte di una parola, cioè lettere, numeri o
trattino basso).
\W Corrisponde a un qualsiasi carattere che non possa far parte di una parola.
\` Corrisponde alla stringa vuota all'inizio di una stringa.
\' Corrisponde alla stringa vuota alla fine di una stringa.
Le sequenze di protezione valide all'interno delle costanti stringa (si veda Costanti di tipo stringa)
sono ammesse anche nelle espressioni regolari.
Le classi di caratteri sono una nuova funzionalità introdotta nello standard POSIX. Una classe di
caratteri è una speciale notazione per indicare liste di caratteri accomunati da uno specifico attributo,
dove però i caratteri veri e propri possono variare a seconda della nazione e del set di caratteri. Per
esempio, la nozione di "carattere alfabetico" valida negli Stati Uniti è diversa da quella valida in
Francia.
Una classe di caratteri è ammessa solo all'interno delle parentesi quadre di una lista di caratteri di
una espressione regolare. Le classi di caratteri si rappresentano con [:, una parola chiave indicante la
classe, e :]. Queste sono le classi di caratteri definite dallo standard POSIX:
[:alnum:] Caratteri alfanumerici.
[:alpha:] Caratteri alfabetici.
[:blank:] Caratteri "spazio" e "tab".
[:cntrl:] Caratteri di controllo.
[:digit:] Caratteri numerici.
[:graph:] Caratteri che siano sia stampabili che visibili (uno spazio è stampabile ma non visibile,
mentre a è entrambe le cose).
[:lower:] Caratteri alfabetici minuscoli.
[:print:] Caratteri stampabili (cioè caratteri che non siano di controllo).
[:punct:] Caratteri di punteggiatura (cioè caratteri che non siano né lettere, né cifre, né caratteri di
controllo, né caratteri di spaziatura).
[:space:] Caratteri di spaziatura (come lo spazio, "tab", "formfeed", per citarne solo alcuni).
[:upper:] Caratteri alfabetici maiuscoli.
[:xdigit:] Cifre esadecimali.
Per fare un esempio, prima dell'introduzione dello standard POSIX si sarebbe dovuto scrivere
/[A-Za-z0-9]/ per individuare caratteri alfanumerici. Qualora il set di caratteri vigente avesse
compreso altri caratteri alfanumerici, l'espressione non li avrebbe riconosciuti, e se il set di
caratteri fosse rappresentato in modo diverso da ASCII, non sarebbero riconosciuti neanche i caratteri
alfanumerici ASCII. Con le classi di caratteri POSIX, si può scrivere /[[:alnum:]]/, che troverà
corrispondenza con i caratteri alfabetici e numerici previsti dal set di caratteri in uso, qualunque esso
sia.
Nelle liste di caratteri possono comparire due sequenze speciali aggiuntive. Esse si applicano ai set di
caratteri non ASCII, i quali possono comprendere sia simboli singoli (chiamati elementi di collazione)
rappresentati da più di un carattere, sia gruppi di caratteri tra loro equivalenti ai fini della
collazione o dell'ordinamento. Per esempio, in francese una “e” semplice ed una “e`” con l'accento grave
sono equivalenti.
Simboli di collazione
Un simbolo di collazione è un elemento di confronto costituito da più di un carattere racchiuso
tra [. e .]. Per esempio, se ch è un elemento di collazione, allora [[.ch.]] è l'espressione
regolare che lo individua, mentre [ch] è un'espressione regolare che individua o il carattere c o
il carattere h.
Classi di Equivalenza
Una classe di equivalenza è un nome, dipendente dalla localizzazione, associato a una lista di
caratteri tra loro equivalenti. Il nome è racchiuso tra [= e =]. Per esempio, il nome e potrebbe
essere usato per rappresentare globalmente i caratteri “e,” “e´,” ed “e`.” In questo caso, [[=e]]
è un'espressione regolare compatibile con uno qualsiasi dei caratteri e, é, ed è.
Queste funzionalità sono molto apprezzabili quando la lingua corrente non è l'inglese. Le funzioni di
libreria che gawk usa nella valutazione di espressioni regolari riconoscono attualmente solo le classi di
caratteri POSIX, non i simboli di collazione né le classi di equivalenza.
Gli operatori \y, \B, \<, \>, \w, \W, \`, ed \' sono specifici di gawk; queste estensioni sono possibili
grazie alle facilitazioni derivanti dall'uso della libreria "regexp" di GNU.
Quelle che seguono sono le opzioni della riga di comando che controllano come gawk interpreta i caratteri
nelle espressioni regolari.
Nessuna opzione
In assenza di indicazioni, gawk mette a disposizione tutte le facilitazioni caratteristiche delle
espressioni regolari POSIX e degli operatori GNU descritti più sopra.
--posix
Sono riconosciute solo le espressioni regolari POSIX, non gli operatori GNU (per esempio, \w
individua il carattere w).
--traditional
Le espressioni regolari sono valutate secondo le regole del tradizionale awk per . Gli operatori
GNU non hanno un significato speciale, e le espressioni di intervallo non sono disponibili. I
caratteri descritti da sequenze ottali o esadecimali sono trattati letteralmente, anche se
rappresentano metacaratteri di espressioni regolari.
--re-interval
Sono permesse le espressioni di intervallo, anche se è stato specificato --traditional.
Azioni
Le istruzioni di azione sono racchiuse tra parentesi graffe, { e }. L'insieme delle istruzioni di azione
è formato dalle solite istruzioni di assegnamento, condizionali e iterative presenti nella maggior parte
dei linguaggi. Gli operatori, le strutture di controllo e le istruzioni di input/output ricalcano quelli
corrispondenti nel linguaggio C.
Operatori
Gli operatori di AWK, in ordine decrescente di precedenza, sono
(...) Raggruppamento
$ Riferimento a campi.
++ -- Incremento e decremento, sia prefisso che suffisso.
^ Elevamento a potenza (si può anche usare ** al suo posto, e **= nell'assegnamento con
operatore).
+ - ! Più e meno unari, e negazione logica.
* / % Moltiplicazione, divisione e resto della divisione.
+ - Addizione e sottrazione.
spazio Concatenazione di stringhe.
| |& I/O proveniente dall'output di comandi [pipe] per getline, print, e printf.
< > <= >= != ==
I normali operatori di relazione.
~ !~ Corrispondenza tra espressioni regolari, e nessuna corrispondenza. NOTA: Non usare
un'espressione regolare costante (/foo/) come operando di sinistra di ~ o !~. Usare
un'espressione regolare solo come operando di destra. L'espressione /foo/ ~ exp equivale a
richiedere (($0 ~ /foo/) ~ exp). Di solito non è questo, quel che si vorrebbe.
in Controllo di appartenenza a un vettore.
&& AND logico.
|| OR logico.
?: L'espressione condizionale in stile C. Ha la forma espressione1 ? espressione2 :
espressione3. Se espressione1 è vera, il valore dell'espressione è espressione2, altrimenti
è espressione3. Viene calcolata solo una delle due espressioni espressione2 ed espressione3
= += -= *= /= %= ^=
Assegnamento. Sono permessi sia l'assegnamento assoluto (var = valore) che quello con
operatore (le altre forme).
Istruzioni di controllo
Le istruzioni di controllo sono le seguenti:
if (condizione) istruzione [ else istruzione ]
while (condizione) istruzione
do istruzione while (condizione)
for (espressione1; espressione2; espressione3) istruzione
for (var in vettore) istruzione
break
continue
delete vettore[indice]
delete vettore
exit [ espressione ]
{ istruzione }
switch (espressione) {
case valore|espressione_regolare : istruzione
...
[ default: istruzione ]
}
Istruzioni di I/O
Le istruzioni di input/output sono le seguenti:
close(file [, come]) Chiude un file, una pipe o un co-processo. Il parametro facoltativo come
dovrebbe essere usato solo per chiudere un'estremità di una pipe bi-
direzionale aperta con un co-processo. Il valore dev'essere una stringa, o
"to" o "from".
getline Imposta $0 usando la successiva riga di input; imposta NF, NR, FNR, RT.
getline <file Imposta $0 usando la successiva riga di file; imposta NF, RT.
getline variabile Imposta variabile dalla successiva riga di input; imposta NR, FNR, RT.
getline variabile <file Imposta variabile dalla successiva riga di file, RT.
comando | getline [variabile] Esegue comando dirigendo l'output [del comando] o in $0 o in variabile,
come sopra, e RT.
comando |& getline [variabile]
Esegue comando come un co-processo dirigendo l'output [del comando] o in $0
o in variabile, come sopra, e RT. I co-processi sono un'estensione gawk.
(il comando può anche essere un socket. Vedere la sottosezione Nomi di
file speciali, più avanti.)
next Cessa l'elaborazione della riga di input corrente. È letta la successiva,
e l'elaborazione ricomincia dal primo criterio di ricerca del programma
AWK. Se non ci sono più righe in input, gawk esegue i comandi delle regole
END, se presenti.
nextfile Cessa l'elaborazione del file di input corrente. La prossima riga sarà
letta dal file di input successivo. Sono aggiornati FILENAME e ARGIND, FNR
è reimpostato a 1, e l'elaborazione riprende dal primo criterio di ricerca
del programma AWK. Quando non ci sono più righe in input, gawk esegue i
comandi delle regole END, se presenti.
print Stampa il record corrente. Alla fine della riga in output viene aggiunto
il valore della variabile ORS.
print lista-espressioni Stampa le espressioni indicate. Ogni espressione è separata dal valore
della variabile OFS. La riga prodotta termina col valore della variabile
ORS.
print lista-espressioni >file Stampa le espressioni indicate su file. Ogni espressione è separata dal
valore della variabile OFS. La riga prodotta termina col valore della
variabile ORS.
printf fmt, lista-espressioni Stampa secondo formato. Vedere L'istruzione printf , più avanti.
printf fmt, lista-espressioni >file
Stampa secondo formato su file.
system(riga-di-comando) Esegue il comando riga-di-comando, e ne restituisce il valore d'uscita.
(può non essere disponibile sui sistemi non-POSIX).
fflush([file]) Scarica il contenuto di tutti i buffer associati ai file o alle pipe aperti
in scrittura file. Se file non è specificato o ha per valore la stringa
nulla, l'operazione è eseguita su tutti i file e le pipe aperti in
scrittura.
Sono permessi anche altri tipi di ridirezione in scrittura per print e printf.
print ... >> file
Aggiunge righe alla fine di file.
print ... | comando
Scrive su una pipe.
print ... |& comando
Invia dati a un co-processo o a un socket. (Vedere anche la sottosezione Nomi di file speciali,
più avanti).
Il comando getline restituirà 1 se tutto va bene, 0 in caso di fine file, e -1 in caso di errore. ERRNO
è impostato a una stringa che descrive il problema.
NOTA: L'insuccesso nell'apertura di un socket bidirezionale genera un errore non fatale che viene
restituito alla funzione chiamante. Se si sta usando una pipe, un co-processo, o un socket per
alimentare la getline, o da print o printf all'interno di un ciclo, si deve usare close() per creare una
nuova istanza del comando o del socket. AWK non chiude automaticamente pipe, socket, o co-processi
quando questi restituiscono EOF.
L'istruzione printf
Le versioni di AWK dell'istruzione printf e della funzione sprintf() (vedi più avanti) accettano i
seguenti formati di richiesta conversione:
%c Un singolo carattere. Se l'argomento usato per %c è numerico, è considerato come un carattere e
stampato. Altrimenti, si suppone che l'argomento sia una stringa, e ne è stampato solo il primo
carattere.
%d, %i Un numero decimale (solo la sua parte intera).
%e, %E Un numero in virgola mobile nella forma [-]d.dddddde[+-]dd. Il formato %E usa E anziché e.
%f, %F Un numero in virgola mobile nella forma [-]ddd.dddddd. Se la libreria di sistema lo supporta, il
formato %F è pure disponibile. Si comporta come %f, ma usa lettere maiuscole per i valori
speciali “non un numero” e “infinito”. Se %F non è disponibile gawk usa %f.
%g, %G Usa la conversione %e o %f, (la più corta delle due), sopprimendo gli zeri non significativi. Il
formato %G usa %E invece che %e.
%o Un numero ottale senza segno (anche questo intero).
%u Un numero decimale senza segno (pure questo intero).
%s Una stringa di caratteri.
%x, %X Un numero esadecimale senza segno (un intero). Il formato %X usa ABCDEF invece di abcdef.
%% Un singolo carattere % ; non c'è alcuna conversione di argomenti.
Alcuni ulteriori parametri facoltativi possono comparire fra il % e la lettera che indica il tipo di
visualizzazione richiesta:
n$ Usa l'argomento n-esimo a questo punto della formattazione. Questo è detto uno specificatore
posizionale ed è pensato per usato principalmente nelle versioni tradotte delle stringhe di
formattazione, non nel testo originale [normalmente in inglese] di un programma AWK. Si tratta di
un'estensione gawk
- L'espressione va allineata a sinistra all'interno del proprio campo.
spazio Nelle conversioni numeriche, inserire uno spazio prima dei valori positivi, e un segno "meno"
prima di quelli negativi.
+ Il segno "più" usato prima del modificatore di dimensione (vedi più avanti) indica che nelle
conversioni numeriche il segno deve essere sempre presente, anche se il valore da riportare è
positivo. + annulla l'effetto del modificatore "spazio".
# Usa una “forma alternativa” per alcune lettere di controllo. Associato a %o, aggiunge uno zero
iniziale. Con %x, e %X, aggiunge all'inizio rispettivamente 0x o 0X in caso di valore diverso da
zero. Con %e, %E, %f e %F, il risultato conterrà sempre il separatore decimale. Con %g, e %G,
gli zeri in coda non sono rimossi dal risultato.
0 Uno 0 (zero) iniziale indica che la stringa risultante deve essere preceduta da zeri anziché da
spazi. Questo vale solo per i formati numerici. Questo flag ha effetto solo quando la larghezza
del campo è maggiore di quella necessaria a contenere il valore da stampare.
ampiezza
Il numero dovrebbe occupare questo numero di byte. Il numero è normalmente preceduto da spazi.
In presenza del flag 0, è invece preceduto da zeri.
.prec Un numero indicante la precisione da utilizzare nella stampa. Con i formati %e, %E, %f, e %F,
specifica il numero di cifre che dovranno comparire a destra del separatore decimale. Con i
formati %g, e %G, specifica il massimo numero di cifre significative. Con i formati %d, %i, %o,
%u, %x, e %X, specifica il numero minimo di cifre da stampare. Per %s, specifica il massimo
numero di caratteri della stringa che dovrebbero essere stampati.
La definizione dinamica di ampiezza e prec prevista dalle funzioni printf() dell'ISO C sono supportate.
Un * al posto sia di ampiezza che di prec farà sì che i loro valori siano presi dalla lista degli
argomenti di printf o sprintf(). Per usare uno specificatore di posizione con una larghezza o una
precisione dinamica inserire il contatore$ dopo il carattere * nella stringa di formattazione. Per
esempio, "%3$*2$.*1$s".
Nomi di file speciali
effettuando delle ridirezioni di print o printf in un file, o attraverso getline da un file, gawk
riconosce internamente alcuni nomi di file speciali, che permettono di accedere a descrittori di file già
aperti ereditati dal processo genitore di gawk (la shell, solitamente). Questi nomi di file possono
anche essere usati nella riga di comando per designare dei file di dati. I nomi di file sono:
- Lo standard input.
/dev/stdin Lo standard input.
/dev/stdout Lo standard output.
/dev/stderr Lo standard error in output.
/dev/fd/n Il file associato al descrittore di file aperto n.
Questi ultimi sono utili in particolare per i messaggi di errore. Per esempio:
print "Ti è andata male!" > "/dev/stderr"
laddove, per ottenere lo stesso effetto, si sarebbe stati costretti a scrivere
print "Ti è andata male!" | "cat 1>&2"
I seguenti nomi speciali di file si possono usare con l'operatore |& di co-processo per creare
connessioni di rete TCP/IP:
/inet/tcp/lport/rhost/rport
/inet4/tcp/lport/rhost/rport
/inet6/tcp/lport/rhost/rport
File per una connessione TCP/IP su una porta locale lport verso un host remoto rhost sulla porta
remota rport. Si usi la porta numero 0 Per permettere al sistema di scegliere una porta. Si usi
/inet4 per richiedere una connessione IPv4, e /inet6 per richiedere una connessione IPv6.
Specificando semplicemente /inet usa quello predefinito del sistema (molto probabilmente sarà
IPv4).
/inet/udp/lport/rhost/rport
/inet4/udp/lport/rhost/rport
/inet6/udp/lport/rhost/rport
Come sopra, ma usando porte UDP/IP invece che TCP/IP.
Funzioni numeriche
AWK ha le seguenti funzioni aritmetiche incorporate:
atan2(y, x) Restituisce l'arcotangente di y/x in radianti.
cos(espressione) Restituisce il coseno di espressione, in radianti.
exp(espressione) La funzione esponenziale.
int(espressione) Troncamento a numero intero.
log(espressione) Logaritmo a base naturale.
rand() Restituisce un numero casuale N, tra 0 e 1, tale che 0 ≤ N < 1.
sin(espressione) Restituisce il seno di espressione, in radianti.
sqrt(espressione) Restituisce la radice quadrata di espressione.
srand([espressione]) usa espressione come nuovo seme per il generatore di numeri casuali. Se espressione
non è indicata, sarà utilizzata il tempo corrente, misurato in secondi dal 1970. Il
valore restituito è il valore precedente del seme.
Funzioni di stringa
Gawk offre le seguenti funzioni di stringa incorporate:
asort(s [, d [, come] ]) Restituisce il numero di elementi del vettore di partenza s. Ordina i
contenuti del vettore s usando le regole normali di gawk per confrontare
fra loro i valori, e sostituisce gli indici dei valori ordinati di s con
la sequenza dei numeri interi a partire da 1. Se viene specificato il
vettore destinazione (facoltativo) d, dapprima il vettore s viene copiato
in d, e poi viene ordinato d, senza modificare gli indici del vettore di
partenza s. La stringa facoltativa come controlla la direzione e il modo
del confronto. Valori ammissibili per come sono quelli delle stringhe
ammissibili per PROCINFO["sorted_in"]. Si può anche specificare il nome
di una funzione di confronto definita dall'utente, come viene spiegato in
PROCINFO["sorted_in"].
asorti(s [, d [, come] ]) Restituisce il numero di elementi del vettore di partenza s. Il
comportamento è lo stesso di asort(), con la differenza che l'ordinamento
è fatto usando gli indici del vettore, e non i valori. Fatto
l'ordinamento, il vettore è indicizzato numericamente, e i valori sono
quelli degli indici di partenza. I valori originali sono persi; quindi
va utilizzato un secondo vettore se si vuole conservare il vettore di
partenza. Lo scopo della stringa facoltativa come è lo stesso descritto
in asort() più sopra.
gensub(r, s, h [, t]) Cerca nella stringa obiettivo t corrispondenze con l'espressione regolare
r. Se h è una stringa che inizia con g o G, tutte le corrispondenze con
r sono sostituite con s. Altrimenti, h è un numero che indica la
particolare corrispondenza con r che si vuole sostituire. Se t non è
specificata, è usato $0 al suo posto. All'interno del testo di rimpiazzo
s si può utilizzare la sequenza \n, dove n è una cifra tra 1 e 9, per
indicare la parte di testo che corrisponde alla n-esima sottoespressione
tra parentesi. La sequenza \0 rappresenta tutto il testo corrispondente,
e così pure il carattere &. A differenza di sub() e gsub(), la stringa
modificata è restituita come risultato della funzione, e la stringa
obiettivo originale resta inalterata.
gsub(r, s [, t]) Per ogni sottostringa conforme all'espressione regolare r nella stringa
t, sostituisce la stringa s, e restituisce il numero di sostituzioni. Se
t non è specificata, usa $0. Una & nel testo di rimpiazzo è sostituita
dal testo trovato corrispondente alla espressione regolare. Si usi \&
per indicare il carattere & inteso letteralmente (va scritto come "\\&";
vedere GAWK: Effective AWK Programming per una trattazione più completa
delle regole sull'uso delle & e delle barre inverse nel testo di
rimpiazzo di sub(), gsub(), e gensub()).
index(s, t) Restituisce la posizione della stringa t all'interno della stringa s, o 0
se la stringa t non è presente. (Ciò implica che gli indici di una
stringa di caratteri partono da 1.) È un errore fatale usare una
costante generata da un'espressione regolare per t.
length([s]) Restituisce la lunghezza della stringa s, oppure la lunghezza di $0 se s
non è specificata. Come estensione non-standard, se si fornisce come
argomento un vettore, length() restituisce il numero di elementi del
vettore.
match(s, r [, a]) Restituisce la posizione in s in cui ricorre l'espressione regolare r,
oppure 0 se r non è presente, e imposta i valori di RSTART e RLENGTH. Si
noti che l'ordine degli argomenti è lo stesso in uso per l'operatore ~:
stringa ~ espressione-regolare. Se viene specificato il vettore a, a
viene preventivamente svuotato e quindi i suoi elementi da 1 a n sono
riempiti con le parti di s corrispondenti alle sottoespressioni fra
parentesi presenti in r. L'elemento di indice 0 di a contiene la parte
di s corrispondente all'intera espressione regolare r. Gli indici a[n,
"inizio"], e a[n, "lunghezza"] contengono l'indice di inizio all'interno
della stringa e la lunghezza, rispettivamente, di ogni sottostringa
individuata.
patsplit(s, a [, r [, seps] ]) Suddivide la stringa s nel vettore a e il vettore dei separatori seps
nell'espressione regolare r, e restituisce il numero dei campi. I valori
di ogni elemento [del vettore] sono le parti di s che corrispondono a r.
Il valore di seps[i] è il separatore individuato davanti a a[i+1]. Se r
è omesso, FPAT viene usato al suo posto. I vettori a e seps sono
svuotati all'inizio dell'operazione. La suddivisione si comporta come la
suddivisione in campi con FPAT, descritta sopra.
split(s, a [, r [, seps] ]) Suddivide la stringa s nel vettore a e nel vettore di separatori seps
individuati dall'espressione regolare r, e restituisce il numero di
campi. Se r è omessa, il separatore utilizzato è FS. I vettori a e seps
sono svuotati all'inizio dell'operazione. seps[i] è il separatore di
campo individuato da r tra a[i] e a[i+1]. Se r è uno spazio singolo, gli
eventuali spazi bianchi all'inizio di s vengono messi nell'elemento extra
del vettore seps[0] e gli spazi bianchi alla fine vanno nell'elemento
extra del vettore seps[n], dove n è il valore restituito da split(s, a,
r, seps). La suddivisione si comporta come la suddivisione in campi,
descritta sopra.
sprintf(fmt, lista-espressioni) Stampa lista-espressioni secondo quanto specificato dal formato fmt, e
restituisce la stringa risultante.
strtonum(str) Esamina str, e ne restituisce il valore numerico. Se str inizia con uno
0, è considerato un numero ottale. Se str inizia con uno 0x o 0X, è
considerato un numero esadecimale. Altrimenti, viene interpretato come
numero decimale.
sub(r, s [, t]) Si comporta come gsub(), ma è sostituita solo la prima sottostringa
trovata.
substr(s, i [, n]) Restituisce una sottostringa, lunga al massimo n-caratteri, di s a
partire dalla posizione i. Se n è omesso, è usato il resto di s.
tolower(str) Restituisce una copia della stringa str, con tutti i caratteri maiuscoli
in str tradotti nei minuscoli corrispondenti. I caratteri non alfabetici
restano invariati.
toupper(str) Restituisce una copia della stringa str, con tutti i caratteri minuscoli
di str tradotti nei maiuscoli corrispondenti. I caratteri non alfabetici
restano invariati.
Gawk gestisce i caratteri multi-byte. Ciò implica che index(), length(), substr() e match() lavorano in
termini di caratteri, non di byte.
Funzioni di tempo
Poiché uno dei principali campi di applicazione dei programmi AWK è l'elaborazione dei file di log
contenenti informazioni relative alla data e all'ora [di un evento], gawk mette a disposizione le
seguenti funzioni per ottenere data e ora e per formattarle come desiderato.
mktime(datespec)
Traduce datespec In una marcatura temporale nello stesso formato restituito dalla funzione [del
linguaggio C] systime(), e restituisce il risultato. Il parametro datespec è una stringa nella
forma YYYY MM DD HH MM SS[ DST]. Il contenuto della stringa consiste in sei o sette numeri che
rappresentano rispettivamente: l'anno, incluso il secolo, il mese, da 1 a 12, il giorno del
mese da 1 a 31, l'ora del giorno da 0 a 23, il minuto da 0 a 59, il secondo da 0 a 60, e un
flag facoltativo riguardo all'ora legale. I valori di questi numeri non sono limitati agli
intervalli sopra descritti; per esempio, un'ora di -1 significa 1 ora prima di mezzanotte. Si
suppone di lavorare con un calendario gregoriano dotato di anno 0, con l'anno 0 prima dell'anno
1 e l'anno -1 prima dell'anno 0. L'ora del giorno è supposta essere quella locale. Se il flag
dell'ora legale è positivo, si suppone che ci si trovi in un periodo dell'anno in cui vige
l'ora legale; se vale zero, l'ora è ritenuta essere quella standard [ora di Greenwich]; se è
negativa (questo è il comportamento predefinito), mktime() tenta di determinare se è in vigore
l'ora legale nel momento specificato. Se datespec non contiene sufficienti elementi o se il
tempo risultante è fuori intervallo, mktime() restituisce -1.
strftime([format [, timestamp[, utc-flag]]])
Formatta timestamp secondo quanto specificato in format. Se utc-flag è presente e diversa da
zero o dalla stringa nulla, il risultato è in UTC [ora di Greenwich], altrimenti il risultato è
nell'ora locale. Il timestamp dovrebbe essere nella forma utilizzata da systime(). Se
timestamp è omesso, sono utilizzate la data e l'ora correnti. Se format è omesso, è assunto un
formato equivalente a quello dell'output del comando date(1). Il formato predefinito è
disponibile in PROCINFO["strftime"]. Vedere le specifiche per la funzione strftime() in ISO C
per i formati di conversione che sono sicuramente disponibili.
systime() Restituisce l'ora corrente come numero di secondi a partire da: (1970-01-01 00:00:00 UTC sui
sistemi POSIX).
Funzioni di manipolazione dei bit
Gawk prevede le seguenti funzioni di manipolazione dei bit. Sono realizzate dapprima convertendo valori
in virgola mobile con precisione doppia in interi nel formato uintmax_t, eseguendo l'operazione indicata,
e poi convertendo il risultato nuovamente in virgola mobile. Le funzioni sono:
and(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione booleana AND
bit per bit ai valori degli argomenti della lista degli argomenti. Gli argomenti
devono essere almeno due.
compl(val) Restituisce il complemento bit per bit di val.
lshift(val, contatore) Restituisce il valore di val, spostato a sinistra di contatore bit.
or(v1, v2 [, ...]) Restituisce il risultato dell'applicare la funzione booleana OR bit per bit ai
valori degli argomenti della lista degli argomenti. Gli argomenti devono essere
almeno due.
rshift(val, contatore) Restituisce il valore di val, spostato a destra di contatore bit.
xor(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione booleana XOR
bit per bit ai valori degli argomenti della lista degli argomenti. Gli argomenti
devono essere almeno due.
Funzione di tipo
La funzione seguente va usata per vettori multidimensionali.
isarray(x)
Restituisce "Vero" se x è un vettore, altrimenti restituisce "Falso". [0 e la stringa nulla
significano "Falso". Qualsiasi altro valore sta per "Vero".]
Funzioni di internazionalizzazione
Le seguenti funzioni possono essere usate all'interno di un programma AWK per tradurre stringhe in fase
di esecuzione del programma. Per informazioni più complete, vedere GAWK: Effective AWK Programming.
bindtextdomain(directory [, dominio])
Specifica la directory in cui gawk cerca i file .gmo, nel caso non si trovino o non si possano
mettere nelle directory ``standard'' (per esempio, in fase di test). Restituisce la directory a
cui dominio è ``collegato''.
Il valore predefinito per dominio è il valore della variabile TEXTDOMAIN. Se directory è
impostato alla stringa nulla (""), bindtextdomain() restituisce il collegamento corrente per il
dato dominio.
dcgettext(stringa [, dominio [, categoria]])
Restituisce la traduzione della stringa nel dominio di testo dominio per la categoria di
localizzazione categoria. Il valore predefinito per dominio è il valore corrente della variabile
TEXTDOMAIN. Il valore predefinito per categoria è "LC_MESSAGES".
Se si fornisce un valore per categoria, dev'essere una stringa uguale a una delle categorie di
localizzazione note, come descritto in GAWK: Effective AWK Programming. Occorre anche fornire un
dominio di testo. Si usi TEXTDOMAIN se ci si vuole servire del dominio corrente.
dcngettext(stringa1, stringa2, numero [, dominio [, category]])
Restituisce la forma plurale in uso per numero nella traduzione di stringa1 e stringa2 nel dominio
di testo dominio per la categoria di localizzazione categoria. Il valore predefinito per dominio
è il valore corrente della variabile TEXTDOMAIN. Il valore predefinito per categoria è
"LC_MESSAGES".
Se si fornisce un valore per categoria, dev'essere una stringa uguale a una delle categorie di
localizzazione note, come descritto in GAWK: Effective AWK Programming. Occorre anche fornire un
dominio di testo. Si usi TEXTDOMAIN se ci si vuole servire del dominio corrente.
FUNZIONI DEFINITE DALL'UTENTE
Le funzioni in AWK sono definite in questo modo:
function nome(lista-di-parametri) { istruzioni }
Le funzioni sono eseguite tramite chiamata dall'interno di espressioni, presenti sia all'interno di
criteri di ricerca, che all'interno di azioni. I parametri forniti al momento della chiamata sono
sostituiti ai parametri formali dichiarati nella funzione. I vettori sono passati per riferimento, le
altre variabili per valore.
Poiché le funzioni non erano in origine previste nel linguaggio AWK, la gestione delle variabili locali è
piuttosto goffa: sono dichiarate semplicemente come parametri in più nella lista dei parametri formali.
Per convenzione, si usa separare le variabili locali dai veri parametri con qualche spazio in più nella
lista. Per esempio:
function f(p, q, a, b) # a e b sono variabili locali
{
...
}
/abc/ { ... ; f(1, 2) ; ... }
La parentesi di sinistra che indica una chiamata deve seguire immediatamente il nome della funzione
chiamata, senza spazi in mezzo; questo per evitare l'ambiguità sintattica con l'operatore di
concatenazione [di stringhe]. Questa restrizione non si applica alle funzioni incorporate elencate
sopra.
Le funzioni possono chiamare a loro volta altre funzioni, e possono essere ricorsive. I parametri
utilizzati come variabili locali sono inizializzati alla stringa nulla e al numero zero al momento
dell'invocazione.
Si usi return expr per restituire un valore da una funzione. Il valore di ritorno è indefinito se non si
fornisce alcun valore, o se la funzione ritorna automaticamente dopo aver eseguito l'ultima istruzione
della funzione stessa, nella modalità detta “falling off”.
Come estensione gawk le funzioni possono essere chiamate indirettamente. Per far ciò basta assegnare il
nome della funzione da chiamare, in formato stringa, a una variabile. Poi si usi la variabile come se
fosse un nome di funzione, premettendole il segno @ come si può vedere qui sotto:
function mia_funzione()
{
print "mia_funzione è stata chiamata"
...
}
{ ...
nome_funzione = "mia_funzione"
@nome_funzione() # chiamata tramite nome_funzione di mia_funzione
...
}
Se è stata data l'opzione --lint, gawk avvertirà in caso di chiamate a funzioni indefinite al momento
della valutazione sintattica del programma anziché durante l'esecuzione. La chiamata di una funzione
indefinita in fase di esecuzione è un errore fatale.
Si può usare la parola func al posto di function. anche se questo modo di operare è deprecato.
CARICARE DINAMICAMENTE NUOVE FUNZIONI
Si possono aggiungere dinamicamente nuove funzioni incorporate all'interpreter gawk con l'istruzione
@load. Una descrizione dettagliata non è possibile in questa pagina di manuale; vedere GAWK: Effective
AWK Programming.
SEGNALI
Il profilo gawk riconosce due segnali. SIGUSR1 provoca la scrittura di un profilo e dello stack delle
chiamate a funzione nel file di profilazione, che ha per nome awkprof.out, o qualsiasi nome sia stato
fornito specificando l'opzione --profile. Poi l'esecuzione del programma prosegue regolarmente. SIGHUP
chiede a gawk di scrivere il profilo e lo stack delle chiamate a funzione e di terminare l'esecuzione del
programma.
INTERNAZIONALIZZAZIONE
Le costanti di tipo stringa sono sequenze di caratteri racchiuse fra doppi apici. In un ambiente dove
non si parla inglese, è possibile segnare delle stringhe in un programma AWK per richiederne la
traduzione nel linguaggio utilizzato in loco. Tali stringhe sono precedute nel programma AWK da un
carattere di sottolineatura (“_”). Per esempio,,
gawk 'BEGIN { print "hello, world" }'
stampa sempre il messaggio hello, world. Ma,
gawk 'BEGIN { print _"hello, world" }'
potrebbe invece stampare bonjour, monde se eseguito in Francia.
Parecchi passi sono necessari per produrre ed eseguire un programma AWK localizzabile.
1. Aggiungere un'azione BEGIN per assegnare un valore alla variabile TEXTDOMAIN per impostare il dominio
del testo a un nome associato al programma in uso:
BEGIN { TEXTDOMAIN = "mio_programma" }
Ciò consente a gawk di trovare il file .gmo associato al vostro programma. Se non si fa ciò, gawk
usa il dominio di testo associato ai messaggi il quale, molto probabilmente, non contiene le
traduzioni necessarie al programma in uso.
2. Far precedere a tutte le stringhe da tradurre il carattere "_".
3. Se è il caso, usare le funzioni dcgettext() e/o bindtextdomain() nel programma, secondo necessità.
4. Eseguite il comando gawk --gen-pot -f mio_programma.awk > mio_programma.pot per generare un file .pot
per il programma [questo file contiene i messaggi da tradurre e la struttura in cui inserire la
traduzione]
5. Preparare delle traduzioni appropriate dei messaggi, e costruire [con make] il corrispondente file
.gmo [che contiene messaggi e traduzioni in formato accessibile da gawk].
Le procedure da usare per la traduzione sono descritte in dettaglio in GAWK: Effective AWK Programming.
COMPATIBILITÀ POSIX
Un obiettivo fondamentale di gawk è la compatibilità con lo standard POSIX, come pure con l'ultima
versione di awk scritta da Brian Kernighan. Per questa ragione gawk include le seguenti caratteristiche
a disposizione dell'utente che non sono descritte nel libro di AWK, ma che fanno parte della versione di
awk scritta da Brian Kernighan, e che sono incluse nello standard POSIX.
Il libro indica che l'assegnazione delle variabili fornite sulla riga di comando è fatta subito prima che
awk apra il primo file fra gli argomenti, il che avviene dopo che la regola BEGIN è stata eseguita.
Peraltro, in implementazioni precedenti, quando una tale assegnazione compariva prima di un nome di file,
l'assegnazione sarebbe avvenuta prima di eseguire la regola BEGIN . Esistono applicazioni che dipendono
da questa “funzionalità.” Quando awk è stato cambiato per corrispondere alla sua documentazione
l'opzione -v per assegnare valori alle variabili prima dell'inizio dell'esecuzione è stata aggiunta per
tener conto delle applicazioni che dipendevano dal precedente comportamento. (Questa funzionalità ha
ottenuto l'approvazione sia dei Bell Laboratories che degli sviluppatori di GNU .)
Nella scansione degli argomenti, gawk usa l'opzione speciale “--” per segnalare la fine degli argomenti.
In modalità compatibile, emette un messaggio e poi ignora le opzioni non disponibili. Nella modalità
normale di operazione, siffatti argomenti sono passati al programma AWK per essere trattati.
Il libro di AWK non definisce il valore restituito dalla funzione srand(). Lo standard POSIX richiede
che restituisca il "seme" che è stato usato, per consentire di tener traccia delle sequenze di numeri
casuali. Pertanto srand() in gawk restituisce anche il suo "seme" corrente.
Altre nuove funzionalità sono: L'uso di opzioni -f multiple (dalla versione MKS [Mortice Kern Systems] di
awk); il vettore ENVIRON; le sequenze di protezione \a, e \v (provenienti originalmente da gawk e poi
riversate nella versione Bell Laboratories); le funzioni incorporate tolower() e toupper() (dalla
versione Bell Laboratories); e le specifiche di conversione ISO C in printf (presenti per prime nella
versione Bell Laboratories).
FUNZIONALITÀ STORICHE
C'è una caratteristica dell'implementazione storica di AWK che gawk supporta: È possibile chiamare la
funzione incorporata length() non solo senza alcun argomento, ma perfino senza parentesi! Quindi,
a = length # Sant'Algol 60, Batman!
equivale sia a
a = length()
a = length($0)
Usare questa funzionalità è una pratica deprecata, e gawk emette un messaggio di avvertimento se la si
usa, qualora si sia specificato --lint sulla riga di comando.
ESTENSIONI GNU
Gawk ha fin troppe estensioni rispetto alla versione POSIX di awk. Esse sono descritte in questa
sezione. Tutte le estensioni qui descritte possono essere disabilitate invocando gawk con le opzioni
--traditional o --posix.
Le seguenti funzionalità di gawk sono sono disponibili nella versione POSIX di awk.
• Non viene fatta una ricerca nelle librerie per file richiamati tramite l'opzione -f. Quindi la
variabile d'ambiente AWKPATH non è speciale.
• Non c'è modo di includere dei file da programma (il meccanismo gawk di @include).
• Non c'è modo di aggiungere dinamicamente nuove funzioni scritte in C (meccanismo @load di gawk).
• La sequenza di protezione \x. (Disabilitata specificando --posix.)
• La possibilità di continuare delle righe dopo un ? e i :. (Disabilita specificando --posix.)
• Costanti ottali ed esadecimali nei programmi AWK.
• Le variabili ARGIND, BINMODE, ERRNO, LINT, RT e TEXTDOMAIN non sono speciali.
• La variabile IGNORECASE e i suoi effetti collaterali non sono disponibili.
• La variabile FIELDWIDTHS e la suddivisione in campi di larghezza fissa e variabile.
• La variabile FPAT e la suddivisione in campi sulla base dei valori di un campo.
• Il vettore PROCINFO non è disponibile.
• L'uso della variabile RS come espressione regolare.
• I nomi speciali di file disponibili per ridirigere l'I/O non sono riconosciuti.
• L'operatore |& utilizzabile per creare co-processi.
• I criteri di confronto speciali BEGINFILE e ENDFILE non sono disponibili.
• La possibilità di separare fra loro singoli caratteri usando la stringa nulla come valore per la
variabile FS, e come terzo argomento nella funzione split().
• Un quarto argomento opzionale per split() che riceva i testi da usare come separatori.
• Il secondo argomento opzionale della funzione close().
• Il terzo argomento opzionale della funzione match().
• La possibilità di usare specificatori posizionali con printf e sprintf().
• La possibilità di avere un vettore come argomento alla funzione length().
• Le funzioni and(), asort(), asorti(), bindtextdomain(), compl(), dcgettext(), dcngettext(), gensub(),
lshift(), mktime(), or(), patsplit(), rshift(), strftime(), strtonum(), systime() e xor().
• Stringhe traducibili in varie lingue.
Il libro AWK non definisce il valore restituito dalla funzione close(). Invece la funzione close() di
Gawk restituisce il valore ottenuto da fclose(3) o pclose(3) alla chiusura, rispettivamente, di un file
di output o di una pipe. Alla chiusura di una pipe di input viene restituito lo stato di uscita del
processo. Il valore restituito è -1 se il file, la pipe o il co-processo in questione non sono stati
aperti con una ridirezione.
Quando gawk è invocato con l'opzione --traditional, se l'argomento fs all'opzione -F è “t”, FS è
impostato avendo come valore il carattere di tabulazione (<TAB>). Si noti che immettendo gawk -F\t ...
si chiede alla shell di preservare “t,” e non di passare “\t” all'opzione -F. Poiché questo è un caso
speciale piuttosto antipatico, non è il comportamento predefinito. Questo comportamento non viene
seguito neppure quando si specifica --posix. Per ottenere che un carattere <TAB> faccia da delimitatore
di campo, è meglio usare apici singoli: gawk -F'\t' ....
VARIABILI D'AMBIENTE
La variabile d'ambiente AWKPATH può essere usata per fornire una lista di directory che gawk esamina alla
ricerca di file coi nomi indicati tramite le opzioni -f, --file, -i e --include. Se la ricerca iniziale
non ha successo, una seconda ricerca è effettuata accodando .awk al nome del file indicato.
La variabile d'ambiente AWKLIBPATH può essere usata per fornire una lista di directory che gawk esamina
alla ricerca di file coi nomi indicati tramite le opzioni -l e --load
La variabile d'ambiente GAWK_READ_TIMEOUT può essere usata per specificare un tempo massimo in
millisecondi per leggere input da un terminale, da una pipe o da una comunicazione bidirezionale, inclusi
i socket.
Per le connessioni a un host remoto via socket, GAWK_SOCK_RETRIES controlla il numero di tentativi di
lettura, e GAWK_MSEC_SLEEP l'intervallo fra un tentativo di lettura e l'altro. L'intervallo è in
millisecondi. Su sistemi che non supportano usleep(3), il valore è arrotondato a un numero intero di
secondi.
Se la variabile POSIXLY_CORRECT esiste nell'ambiente, gawk si comporta esattamente come se --posix fosse
stato specificato sulla riga di comando. Se --lint è stato specificato, gawk emette un messaggio di
avvertimento riguardo a questo.
STATO DI USCITA
Se l'istruzione exit è usata avendo come parametro un valore, gawk termina restituendo il valore numerico
in questione.
Altrimenti, se non sono stati riscontrati problemi in fase di esecuzione, gawk termina con il valore
della costante C EXIT_SUCCESS. Questo valore è normalmente zero.
In caso di errore, gawk termina con il valore della costante C EXIT_FAILURE. Questo valore è normalmente
uno.
Se gawk termina a causa di un errore fatale, il valore restituito è 2. Su sistemi non-POSIX, questo
valore può essere visualizzato come EXIT_FAILURE.
INFORMAZIONE SULLA VERSIONE
Questa pagina man documenta gawk, versione 4.1.
AUTORI
La versione originale di UNIX awk è stata progettata e implementata da Alfred Aho, Peter Weinberger, e
Brian Kernighan dei Bell Laboratories. Brian Kernighan continua a mantenere e migliorare il programma.
Paul Rubin e Jay Fenlason, della Free Software Foundation, hanno scritto gawk, in modo che fosse
compatibile con la versione originale di awk distribuita con la Settima Edizione di UNIX. John Woods ha
contribuito con numerose correzioni di errori. David Trueman, con contribuzioni da Arnold Robbins, ha
reso gawk compatibile con la nuova versione di UNIX awk. Arnold Robbins è il manutentore corrente.
Vedere GAWK: Effective AWK Programming per una lista completa di contributori a gawk e alla sua
documentazione.
Vedere il file README nella distribuzione gawk per informazioni aggiornate riguardo ai manutentori e per
sapere per quali sistemi operativi gawk è disponibile.
Traduzione in italiano a cura di ILDP - Italian Linux Documentation Project http://www.pluto.it/ildp
SEGNALAZIONE DI ERRORI
Se trovate un bug in gawk, siete pregati di inviare un messaggio di posta elettronica a bug-gawk@gnu.org. Siete pregati di includere il vostro sistema operativo e la versione di gawk (da gawk --version), quale compilatore C avete usato per compilarlo, e un programma di test con anche i dati, ridotti allo stretto necessario, per riprodurre il problema. Prima di spedire un rapporto di errore fate quanto segue. Per prima cosa, verificate che stiate usando l'ultima versione di gawk. Molti bug (normalmente abbastanza difficili da incontrare) sono corretti in ogni nuova versione, e se la vostra versione è molto datata, il problema potrebbe essere già stato risolto. Secondariamente, siete pregati di controllare se impostando la variabile d'ambiente LC_ALL a LC_ALL=C faccia sì che il problema scompaia. Se così è, si tratta di un problema legato alla localizzazione, che può essere o meno un errore. Infine, siete pregati di leggere questa man page e il manuale di riferimento con attenzione, per assicurarvi che quello che voi ritenete essere un errore lo sia veramente, invece di essere solo un comportamento strano del linguaggio. Qualsiasi cosa facciate, NON inviate un messaggio per segnalare l'errore a comp.lang.awk. Anche se gli sviluppatori di gawk di tanto in tanto leggono questo forum, inviare qui messaggi di segnalazione di errore è una maniera poco affidabile per segnalare errori. Siete invece pregati di usare l'indirizzo di posta elettronica scritto più sopra. Veramente! Se state usando un sistema GNU/Linux o basato sulla distribuzione BSD, potreste rivolgervi a chi fornisce la vostra distribuzione software. Questo va bene, ma siete pregati di spedire una copia all'indirizzo email specificato, poiché non esiste alcune certezza che il vostro messaggio sia inoltrato al manutentore di gawk. Segnalare eventuali errori di traduzione a ildp@pluto.it
ERRORI
L'opzione -F non è più necessaria, vista la possibilità di assegnare variabili nella riga di comando;
viene mantenuta solo per compatibilità all'indietro.
Può capitare che dei programmi contenenti singoli caratteri sintatticamente non validi tendano a esaurire
la stack di analisi, generando un messaggio di poca utilità. Tali programmi sono sorprendentemente
difficili da riconoscere nel caso più generale possibile, e lo sforzo richiesto per fare ciò non è
veramente giustificato.
VEDERE ANCHE
egrep(1), sed(1), getpid(2), getppid(2), getpgrp(2), getuid(2), geteuid(2), getgid(2), getegid(2), getgroups(2), usleep(3) The AWK Programming Language, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 1988. ISBN 0-201-07981-X. GAWK: Effective AWK Programming, Edition 4.1, disponibile con il codice sorgente gawk. La versione originale corrente di questo documento è disponibile online a: http://www.gnu.org/software/gawk/manual.
ESEMPI
Stampa ed ordina i nomi di login di tutti gli utenti:
BEGIN { FS = ":" }
{ print $1 | "sort" }
Conta le righe di un file:
{ nlines++ }
END { print nlines }
Aggiunge il numero di riga all'inizio di ogni riga del file:
{ print FNR, $0 }
Concatena e aggiunge numerazione (variazione sul tema):
{ print NR, $0 }
Esegui un comando esterno per alcune linee di dati:
tail -f access_log |
awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'
RICONOSCIMENTI
Brian Kernighan ha fornito valida assistenza durante il test e la correzione degli errori. Lo
ringraziamo.
COPYING PERMISSIONS
Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
2007, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this manual page provided the copyright
notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual page under the conditions
for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual page into another language,
under the above conditions for modified versions, except that this permission notice may be stated in a
translation approved by the Foundation.
PERMESSI DI COPIA
Questa è una traduzione non ufficiale in italiano dei permessi di copia riportati nella precedente
sezione "COPYING PERMISSIONS". Non è una pubblicazione della Free Software Foundation, e non ha validità
legale per i termini di distribuzione della documentazione; solo il testo originale inglese ha tale
validità.
This is an unofficial translation into Italian of the above section "COPYING PERMISSIONS". It was not
published by the Free Software Foundation, and does not legally state the distribution terms for this
documentation; only the original English text does that.
Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
2007, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
È permesso stampare e distribuire copie letterali di questa pagina di manuale, a patto che il copyright e
questa nota di autorizzazione siano conservate e presenti in ogni copia.
È permesso copiare e distribuire versioni modificate di questa pagina del manuale, sotto le condizioni
poste per la copia letterale, a patto che l'intero lavoro derivato sia distribuito secondo permessi di
stampa identici a questi.
È permesso copiare e distribuire traduzioni di questa pagina di manuale in un'altra lingua, sotto le
condizioni poste sopra per le versioni modificate, salvo che quest'informazione sui permessi di copia e
ristampa deve essere espressa in una traduzione approvata dalla Free Software Foundation.