Provided by: manpages-it_4.17.0-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 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.
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 e --include. 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). I file letti come specificato da -f sono trattati come se iniziassero con
la direttiva implicita @namespace "awk".
-F fs
--field-separator fs
Usa fs come separatore di campo in input (il valore della variabile predefinita
FS).
-v var=val
--assign var=val
Assegna il valore val alla variabile var, prima che inizi l'esecuzione del
programma. Questi valori delle variabili sono messi a disposizione della regola
BEGIN di un programma AWK.
-b
--characters-as-bytes
Tratta tutti i dati in 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. Quest'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. 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.
-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 --include) 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. Ogni argomento specificato da -e è trattato
come se iniziasse con la direttiva implicita @namespace "awk".
-E file
--exec file
Simile a -f, comunque, quest'opzione è l'ultima ad essere elaborata. Dovrebbe
essere usata con script #!, specialmente per applicazioni CGI [Common Gateway
Interface], per evitare di passare opzioni o codice (!) sulla riga di comando da un
URL. Quest'opzione disabilita gli assegnamenti di variabile da riga di comando.
-g
--gen-pot
Esamina e analizza il programma AWK, e genera un file in formato GNU .pot (Portable
Object Template) sullo standard output con elementi relativi a tutte le stringhe
localizzabili nel programma. Il programma in sé non viene eseguito. 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. I file letti come specificato da --include sono trattati
come se iniziassero con la direttiva implicita @namespace "awk".
-l lib
--load lib
Carica un'estensione gawk dalla libreria condivisa lib. Cerca la libreria usando la
variabile d'ambiente AWKLIBPATH. Se la ricerca iniziale non va a buon fine, viene
fatto un altro tentativo dopo aver aggiunto il suffisso della libreria condivisa
predefinita per la piattaforma. La procedura di inizializzazione della libreria si
suppone avere come nome dl_load().
-L [valore]
--lint[=valore]
Emette 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).
Specificando l'argomento facoltativo no-ext, gli avvertimenti riguardo alle
estensioni gawk sono disabilitati.
-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.)
-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.
Quest'opzione attiva anche l'opzione --no-optimize.
-O
--optimize
Abilita le ottimizzazioni predefinite di gawk nella rappresentazione interna del
programma. Attualmente, questo comprende il semplice calcolo delle costanti.
Quest'opzione è attiva in modo predefinito.
-p[prof-file]
--profile[=prof-file]
Inizia una sessione di "profiling", e invia i dati tracciati al file prof-file.
Quello predefinito è 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. Quest'opzione attiva anche l'opzione
--no-optimize.
-P
--posix
Quest'opzione attiva la modalità di compatibilità, con le seguenti restrizioni
aggiuntive:
• Le sequenze di protezione \x non vengono riconosciute.
• 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 (vedere
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
e egrep coerenti tra di loro. Sono abilitate in modalità predefinita, però
quest'opzione rimane per essere usata insieme all'opzione --traditional.
-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. 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 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. 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 --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). 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, gawk consente di avere variabili di tipo
"espressione regolare". AWK ha anche vettori monodimensionali; i vettori multidimensionali
possono essere simulati [da vettori monodimensionali]. Gawk fornisce veri vettori di
vettori; vedere 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 predefinita 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. 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 larghezza fissa, e gawk spezza il record secondo le larghezze
specificate. 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. 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, compresi eventuali spazi bianchi iniziali e finali. 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 predefinite
Le variabili predefinite 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").
In modalità POSIX, la modifica di questo vettore non ha effetto sull'ambiente
ereditato dai programmi che gawk esegue per ridirezione o tramite la funzione
system(). Altrimenti, gawk aggiorna il suo ambiente reale in modo che i
programmi che eredita vedano le modifiche.
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. Se la stringa in ERRNO
corrisponde a un errore di sistema descritto nella variabile errno(3), il
corrispondente valore numerico può essere trovato in PROCINFO["errno"]. Per
errori non di sistema, l'elemento PROCINFO["errno"] varrà zero.
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. 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 di 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 predefinite 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. I valori specificabili con l'opzione --lint possono
anche essere assegnati alla variabile d'ambiente LINT, e hanno gli stessi
effetti. 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["argv"] Gli argomenti sulla riga di comando come sono visti da
gawk a livello di linguaggio C. Gli indici partono dallo
zero.
PROCINFO["egid"] Il valore della chiamata di sistema getegid(2).
PROCINFO["errno"] Il valore di errno(3) quando ERRNO è impostato al
messaggio di errore associato.
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,
"FIELDWIDTHS" se la separazione in campi con FIELDWIDTHS
è attiva, o "API" se la separazione in campi con
l'analizzatore di input API è attiva.
PROCINFO["gid"] Il valore della chiamata di sistema getgid(2).
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.
"builtin" L'identificatore è una funzione predefinita.
"extension" L'identificatore è una funzione di estensione
caricata con @load o --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["pgrpid"] Il valore della chiamata di sistema getpgrp(2).
PROCINFO["pid"] Il valore della chiamata di sistema getpid(2).
PROCINFO["platform"] Una stringa che indica la piattaforma sulla quale gawk è
stato compilato. Può essere una delle alternative
seguenti:
"djgpp", "mingw"
Microsoft Windows, compilato tramite DJGPP o
MinGW, rispettivamente.
"os2" OS/2.
"posix"
GNU/Linux, Cygwin, Mac OS X, e i sistemi Unix
precedenti.
"vms" OpenVMS o Vax/VMS.
PROCINFO["ppid"] Il valore della chiamata di sistema getppid(2).
PROCINFO["strftime"] La stringa di formato data/ora predefinita per
strftime(). Cambiandone il valore cambia anche il modo
con cui strftime() visualizza i valori di data e ora se
chiamata senza specificare argomenti.
PROCINFO["uid"] Il valore della chiamata di sistema getuid(2).
PROCINFO["version"] La versione di gawk.
I seguenti elementi sono presenti se è disponibile il caricamento delle
estensioni dinamiche.
PROCINFO["api_major"]
La versione principale dell'estensione API.
PROCINFO["api_minor"]
La versione secondaria dell'estensione API.
I seguenti elementi sono disponibili se il supporto MPFR è statocompilato in
gawk:
PROCINFO["gmp_version"]
La versione della libreria GNU GMP usata per il supporto ai numeri con
precisione arbitraria in gawk.
PROCINFO["mpfr_version"]
La versione della libreria GNU MPFR usata per il supporto ai numeri con
precisione arbitraria in gawk.
PROCINFO["prec_max"]
La massima precisione supportata dalla libreria GNU MPFR per i numeri a
virgola mobile con precisione arbitraria.
PROCINFO["prec_min"]
La minima precisione supportata dalla libreria GNU MPFR per i numeri a
virgola mobile con precisione arbitraria.
I seguenti elementi possono essere impostati da un programma per cambiare il
comportamento di gawk:
PROCINFO["NONFATAL"]
Se presente, gli errori di I/O per tutte le ridirezioni diventano non
fatali.
PROCINFO["nome", "NONFATAL"]
Rende gli errori relativi a nome non fatali.
PROCINFO["comando", "pty"]
Usa una pseudo-tty per una comunicazione bidirezionale con comando
invece di impostare due "pipe" unidirezionali.
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["input", "RETRY"]
Se un errore di I/O non fatale si verifica leggendo dati da un file di
input, e questo elemento di vettore esiste, getline restituisce -2
invece di restituire il valore previsto di -1 e di configurare l'input
in modo da non fornire ulteriori dati. Un errore di I/O non fatale si
verifica quando errno(3) ha il valore EAGAIN, EWOULDBLOCK, EINTR o
ETIMEDOUT. Questo può tornare utile nel caso si utilizzi
PROCINFO["input", "READ_TIMEOUT"] o in situazioni in cui un descrittore
di file è stato configurato in modo da non bloccarsi in caso di errore.
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", and "@unsorted". Il
valore può essere anche il nome (come stringa) 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.
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:
"A" o "a"
per arrotondamento lontano da zero (per eccesso). Questi valori sono
disponibili solo se la versione della libreria GNU MPFR supporta gli
arrotondamenti lontano da zero.
"D" o "d" per roundTowardNegative.
"N" o "n" per roundTiesToEven.
"U" o "u" per roundTowardPositive.
"Z" o "z" per roundTowardZero.
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 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 La stringa usata per separare indici multipli negli elementi di un vettore,
quella predefinita è "\034".
SYMTAB Un vettore i cui indici sono i nomi di 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 typeof() può essere usata per controllare se un elemento in SYMTAB
è un vettore. Non è possibile usare l'istruzione delete per il vettore SYMTAB
e neppure impostare elementi il cui indice non sia un nome di variabile.
TEXTDOMAIN Il dominio di testo del programma AWK ; usato per trovare le traduzioni
localizzate delle stringhe del programma.
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 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
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.
Spazi-dei-nomi
Gawk fornisce una semplice funzionalità, namespace, (spazio-dei-nomi) per ovviare al fatto
che tutte le variabili in AWK sono globali.
Un nome qualificato consiste di due identificativi semplici, congiunti da una coppia di
due punti (::). Il primo dei due identificativi designa lo spazio-dei-nomi (namespace)
mentre il secondo è il nome della variabile al suo interno. Tutti i nomi semplici (non
qualificati) sono considerati come appartenenti allo spazio-dei-nomi “corrente”; lo
spazio-dei-nomi predefinito ha nome awk. Comunque, gli identificativi i cui nomi sono
composti solo da lettere maiuscole, vengono sempre considerati come facenti parte dello
spazio-dei-nomi awk, anche se lo spazio-dei-nomi corrente è diverso da quello predefinito.
Si può cambiare lo spazio-dei-nomi corrente tramite la direttiva @namespace "nome".
I nomi delle funzioni interne predefinite non possono essere usati come nomi di uno
spazio-dei-nomi. I nomi di ulteriori funzioni, fornite da gawk possono essere usati come
nomi di uno spazio-dei-nomi o come semplici identificativi in altri spazi-dei-nomi. Per
ulteriori dettagli, vedere GAWK: Effective AWK Programming.
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. 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. Fino a due
cifre esadecimali che seguono sono considerate parte della sequenza di protezione.
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.
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/.
Costanti di tipo Regexp
Una costante di tipo espressione regolare è una sequenza di caratteri racchiusa tra barre
(come /valore/). Come stabilire una corrispondenza con un'espressione regolare è descritto
in maniera più dettagliata più avanti; vedere Espressioni regolari.
Le sequenze di protezione descritte sopra si possono usare anche all'interno di costanti
che sono espressioni regolari (p.es., /[ \t\f\n\r\v]/ corrisponde a tutti i caratteri non
stampabili [bianchi]).
Gawk consente anche di usare costanti formate da espressioni regolari fortemente
tipizzate. I nome di tali costanti sono preceduti da un simbolo @ (così: @/valore/).
Queste costanti possono essere assegnare a scalari (variabili, elementi di un vettore) e
passate a funzione definite dall'utente. Le variabili il cui valore è stato assegnato in
questo modo hanno come tipo quello di variabili di espressioni regolari.
CRITERI DI RICERCA E AZIONI
AWK è un linguaggio che procede per righe. Il criterio va a inizio riga, l'azione lo
segue. Le istruzioni dell'azione sono racchiuse tra { e }. Sia il criterio che l'azione
possono mancare ma, naturalmente, non entrambi. Se manca il criterio, l'azione è eseguita
per ogni record in input. Omettere invece l'azione equivale a specificare
{ print }
ossia stampare l'intero record.
I commenti cominciano col carattere #, e continuano fino a fine riga. Si possono separare
le istruzioni con righe vuote. Un'istruzione finisce normalmente alla fine della riga, a
meno che non termini con una virgola, {, ?, :, &&, o ||. Anche le istruzioni in righe
terminanti con do o else continuano automaticamente alla riga successiva. Negli altri
casi, un'istruzione può continua sulla riga successiva se termina con “\”, nel qual caso
il "newline" è ignorato. Comunque, un “\” che venga dopo un carattere # non è speciale.
Si possono scrivere più istruzioni sulla stessa riga separandole con “;”. Questo si
applica sia alle istruzioni all'interno di un'azione (il caso più comune), sia ai gruppi
criterio-azione stessi.
Criteri di ricerca
I criteri di ricerca di AWK possono assumere le forme seguenti:
BEGIN
END
BEGINFILE
ENDFILE
/espressione regolare/
espressione di relazione
criterio && criterio
criterio || criterio
criterio ? criterio : criterio
(criterio)
! criterio
criterio1, criterio2
BEGIN e END sono due tipi speciali di criteri di ricerca, che non dipendono dai dati in
input. Le azioni di tutti i criteri di ricerca BEGIN sono unite insieme, come se tutte le
istruzioni fossero scritte in un'unica regola BEGIN, e sono eseguite prima che sia letto
qualsiasi input. Allo stesso modo, tutte le regole END sono fuse insieme, ed eseguite dopo
che tutti i dati in input sono terminati o dopo che si è incontrata l'istruzione exit.
BEGIN e END non possono essere combinati con altri criteri in espressioni di ricerca. I
criteri BEGIN e END devono necessariamente essere seguiti dall'indicazione di un'azione.
BEGINFILE e ENDFILE sono altri criteri speciali le cui azioni sono eseguite prima della
lettura del primo record di ogni file di input richiamato sulla riga di comando, e dopo la
lettura dell'ultimo record di ognuno di questi file. All'interno della regola BEGINFILE,
il valore di ERRNO è una stringa vuota se il file è stato aperto con successo. Altrimenti,
in caso di problemi col file il codice dovrebbe usare nextfile per saltarlo. Se non lo
fa, gawk emette il solito errore fatale per i file che non possono essere aperti.
Per i criteri del tipo /espressione regolare/ l'azione associata è eseguita per ogni
record in input che corrisponde all'espressione regolare. Le espressioni regolari hanno la
stessa forma di quelle di egrep(1), 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
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.
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. Per
aggiungere alla lista il carattere trattino, inserirlo all'inizio o alla fine
della lista stessa.
[^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 (vedere 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 “`” 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”, “\*(rq', ed “`”. In questo caso, [[=e]] è un'espressione regolare compatibile
con uno qualsiasi dei caratteri e, e´, ed e`.
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, \<, \>, \s, \S, \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
UNIX. 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.
space 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 ]
{ istruzioni }
switch (espressione) { case valore|espressione_regolare : istruzione ... [ default: istruzione ]
}
Istruzioni di I/O
Le istruzioni di input/output sono le seguenti:
close(file [, come]) Chiude un file, una pipe o un coprocesso. Il parametro facoltativo
come dovrebbe essere usato solo per chiudere un'estremità di una
pipe bi-direzionale aperta con un coprocesso. Il valore dev'essere
una stringa, o "to" o "from".
getline Imposta $0 usando la successiva riga di input; imposta NF, NR, FNR,
RT.
getline <file Imposta $0 usando la successiva riga di file; imposta NF, RT.
getline variabile Imposta variabile dalla successiva riga di input; imposta NR, FNR,
RT.
getline variabile <file
Imposta variabile dalla successiva riga di file; imposta RT.
comando | getline [variabile]
Esegue comando dirigendo l'output [del comando] o in $0 o in
variabile, come sopra, e RT.
comando |& getline [variabile]
Esegue comando come un coprocesso dirigendo l'output [del comando] o
in $0 o in variabile, come sopra, e RT. I coprocessi 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. 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
Stampa secondo formato. Vedere '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). Si
veda GAWK: Effective AWK Programming per tutti i dettagli sullo
stato d'uscita.
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 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.
L'istruzione printf
Le versioni di AWK dell'istruzione printf e della funzione sprintf() (vedi più avanti)
accettano i seguenti formati di richiesta conversione:
%a, %A Un numero a virgola mobile nel formato [-]0xh.hhhhp+-dd (formato esadecimale a
virgola mobile di C99). Per %A, si usano lettere maiuscole invece che lettere
minuscole.
%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:
count$ 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.
space 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 svolge una funzione di flag, per indicare che l'output deve
essere preceduto da zeri anziché da spazi. Questo vale solo per i formati numerici
in output. Questo flag ha effetto solo quando la larghezza del campo è maggiore di
quella necessaria a contenere il valore da stampare.
' Un apice semplice chiede a gawk di inserire il separatore delle migliaia proprio
della localizzazione, come pure di usare il separatore decimale proprio della
localizzazione per i numeri in virgola mobile. È richiesto che la libreria C
supporti correttamente la localizzazione e che questa sia stata definita
correttamente.
width 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 il formato %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 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 offre le seguenti funzioni di stringa predefinite:
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 precedenza
per asort().
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
della "e commerciale" (ampersand) e delle barre inverse nel testo
di rimpiazzo di sub(), gsub(), e gensub().)
index(s, t) Restituisce la posizione della stringa t all'interno della stringa
s, o zero se la stringa t non è presente. (Ciò implica che gli
indici di una stringa di caratteri partono da 1.) È 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 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. 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 zero 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 (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, 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] and 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. Nel caso particolare in cui r è una stringa composta da un
unico carattere, quella stringa fa da separatore, anche se il
carattere è un metacarattere di un'espressione regolare.
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
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 [, utc-flag])
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. Se il flag utc-flag è presente e diverso da zero e dalla stringa
nulla, il tempo è supposto essere quello del fuso orario UTC [ora di Greenwich];
altrimenti, si suppone che il tempo sia quello del fuso orario locale. Se il
flag DST (daylight saving time - 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.
NOTA: Se a una delle funzioni seguenti si forniscono operandi negativi, il risultato è un
errore fatale.
Le funzioni sono:
and(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione
booleana AND bit per bit ai valori degli argomenti della lista degli
argomenti. Gli argomenti devono essere almeno due.
compl(val) Restituisce il complemento bit per bit di val.
lshift(val, contatore)
Restituisce il valore di val, spostato a sinistra di contatore bit.
or(v1, v2 [, ...]) Restituisce il risultato dell'applicare la funzione booleana OR bit
per bit ai valori degli argomenti della lista degli argomenti. Gli
argomenti devono essere almeno due.
rshift(val, contatore)
Restituisce il valore di val, spostato a destra di contatore bit.
xor(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione
booleana XOR bit per bit ai valori degli argomenti della lista degli
argomenti. Gli argomenti devono essere almeno due.
Funzioni di tipo
Le seguenti funzioni forniscono informazioni relative agli argomenti che vengono loro
passati.
isarray(x) Restituisce "Vero" se x è un vettore, altrimenti restituisce "Falso". [0 e la
stringa nulla significano "Falso". Qualsiasi altro valore sta per "Vero".]
Questa funzione è destinata principalmente a essere usata con elementi di
vettori multidimensionali, e con parametri usati da funzioni.
typeof(x) Restituisce una stringa che indica il tipo di x. La stringa sarà una di queste:
"array", "number", "regexp", "string", "strnum", "unassigned" o "undefined".
Funzioni di internazionalizzazione
Le seguenti funzioni possono essere usate all'interno di un programma AWK per tradurre
stringhe in fase di esecuzione del programma. Per informazioni più complete, vedere 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 [, 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".
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 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.
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 predefinite elencate sopra.
Le funzioni possono chiamare a loro volta altre funzioni, e possono essere ricorsive. I
parametri utilizzati come variabili locali sono inizializzati alla stringa nulla e al
numero zero al momento dell'invocazione.
Si usi return expr per restituire un valore da una funzione. Il valore di ritorno è
indefinito se non si fornisce alcun valore, o se la funzione ritorna automaticamente dopo
aver eseguito l'ultima istruzione della funzione stessa, nella modalità detta “falling
off”.
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" ... }
{ ... the_func = "mia_funzione" @the_func() # chiamata tramite nome_funzione di mia_funzione ... }
A partire dalla versione 4.1.2, questo vale per le funzioni definite dall'utente, per
quelle predefinite e per le funzioni di estensione.
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 scritte in C o C++ all'interpreter gawk
in esecuzione tramite 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 dagli sviluppatori dei Bell Laboratories che
dagli 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 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
predefinite 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 predefinita 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.
• La possibilità di continuare delle righe dopo un ? e i :.
• Costanti ottali ed esadecimali nei programmi AWK.
• Le variabiliARGIND, BINMODE, ERRNO, LINT, PREC, ROUNDMODE, 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.
• I vettori FUNCTAB, SYMTAB, e PROCINFO non sono disponibili.
• L'uso della variabile RS come espressione regolare.
• I nomi di file speciali disponibili per ridirigere l'I/O non sono riconosciuti.
• L'operatore |& utilizzabile per creare coprocessi.
• 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.
• Errore di I/O non-fatale.
• I/O ritentabile.
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 coprocesso 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, e tramite la direttiva @include. Se la ricerca iniziale non ha successo, una
seconda ricerca è effettuata accodando .awk al nome del file indicato.
La variabile d'ambiente AWKLIBPATH può essere usata per fornire una lista di directory che
gawk esamina alla ricerca di file coi nomi indicati tramite le opzioni -l e --load.
La variabile d'ambiente GAWK_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.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.
NOTIFICA DEI "BUG"
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.
Analogamente, NON usare una comunità web (tipo Stack Overflow) per segnalare errori. Siete
invece pregati di usare gli indirizzi di posta elettronica riportati 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.
BUG
L'opzione -F non è più necessaria, vista la possibilità di assegnare variabili nella riga
di comando; viene mantenuta solo per compatibilità all'indietro.
VEDERE ANCHE
egrep(1), sed(1), getpid(2), getppid(2), getpgrp(2), getuid(2), geteuid(2), getgid(2),
getegid(2), getgroups(2), printf(3), strftime(3), 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, Edizione 5.1, 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") }'
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, 2014, 2015, 2016, 2017, 2018, 2019, 2020,
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⟩.