@c
@c WONTFIX: 10/2020
@c This is too much work. FPAT and CSV files are very flakey and
@c fragile. Doing something like this is merely inviting trouble.
Come per @code{FS}, la variabile @code{IGNORECASE}
(@pxref{Variabili modificabili dall'utente}) ha effetto sulla separazione dei
campi con @code{FPAT}.
Se si assegna un valore a @code{FPAT} la divisione in campi non viene
effettuata utilizzando @code{FS} o @code{FIELDWIDTHS}.
Infine, la funzione @code{patsplit()} rende la stessa funzionalit@`a disponibile
per suddividere normali stringhe (@pxref{Funzioni per stringhe}).
@node File CSV
@subsection Ancora sui file CSV
@cindex Collado, Manuel
Manuel Collado fa notare che, oltre alle virgole, un campo CSV pu@`o anche
contenere apici, che devono essere protetti raddoppiandoli.
Le espressione regolari descritte sopra non sono in grado di accettare
campi fra apici che contengano al loro interno sia virgole che apici.
Egli suggerisce che l'espressione pi@`u semplice di @code{FPAT} in grado
di riconoscere tale tipo di campi @`e @code{/([^,]*)|("([^"]|"")+")/}.
Egli ha preparato questo input come test per riconoscere queste varianti:
@example
@c file eg/misc/sample.csv
p,"q,r",s
p,"q""r",s
p,"q,""r",s
p,"",s
p,,s
@c endfile
@end example
@noindent
E questo @`e il suo programma di test:
@example
@c file eg/misc/test-csv.awk
@group
BEGIN @{
fp[0] = "([^,]+)|(\"[^\"]+\")"
fp[1] = "([^,]*)|(\"[^\"]+\")"
fp[2] = "([^,]*)|(\"([^\"]|\"\")+\")"
FPAT = fp[fpat+0]
@}
@end group
@group
@{
print "<" $0 ">"
printf("NF = %s ", NF)
for (i = 1; i <= NF; i++) @{
printf("<%s>", $i)
@}
print ""
@}
@end group
@c endfile
@end example
Se eseguito usando la terza variante di @code{FPAT},
il programma produce in output:
@example
$ @kbd{gawk -v fpat=2 -f test-csv.awk sample.csv}
@print{}
@print{} NF = 3 <"q,r">
@print{}
@print{} NF = 3 <"q""r">
@print{}
@print{} NF = 3 <"q,""r">
@print{}
@print{} NF = 3 <"">
@print{}
@print{} NF = 3 <>
@end example
@node Controllare la creazione di campi
@section Controllare come @command{gawk} sta dividendo i record
@cindex @command{gawk} @subentry separazione in campi e
Come visto sopra, @command{gawk} fornisce tre metodi indipendenti per
dividere i record in input in campi. Il meccanismo utilizzato dipende da
quale delle tre variabili --- @code{FS}, @code{FIELDWIDTHS} o
@code{FPAT} --- @`e stato definito per ultimo.
Inoltre, un analizzatore di input che utilizzi l'API (Application
Programming Interface) pu@`o scegliere di modificare il meccanismo di
analisi dei record; si veda @ref{Analizzatori di input} per ulteriori informazioni
riguardo a questa funzionalit@`a.
Per ripristinare la normale divisione in campi dopo aver fatto uso
di @code{FIELDWIDTHS} e/o @code{FPAT}, @`e sufficiente assegnare un valore
alla variabile @code{FS}.
Si pu@`o usare @samp{FS = FS} per farlo, senza bisogno di conoscere il
valore corrente di @code{FS}.
Per determinare quale sia il tipo di divisione dei campi attiva al momento,
si usi @code{PROCINFO["FS"]} (@pxref{Variabili auto-assegnate}).
Il valore @`e @code{"FS"} se si usa la maniera normale di divisione dei campi,
@code{"FIELDWIDTHS"} se si usa la divisione in campi di lunghezza fissa,
oppure @code{"FPAT"} se si una la divisione in campi in base al contenuto:
@example
if (PROCINFO["FS"] == "FS")
@var{divisione normale in campi} @dots{}
else if (PROCINFO["FS"] == "FIELDWIDTHS")
@var{divisione in campi a lunghezza fissa} @dots{}
else if (PROCINFO["FS"] == "FPAT")
@var{divisione in campi in base al contenuto} @dots{}
else
@var{divisione in campi da analizzatore di input API} @dots{}
@ii{(funzionalit@`a avanzata)}
@end example
Quest'informazione @`e utile se si sta scrivendo una funzione che
deve cambiare provvisoriamente @code{FS} o @code{FIELDWIDTHS}, leggere alcuni
record e poi ripristinare le inpostazioni originali. Si veda
(@pxref{Funzioni Passwd} per un esempio di una funzione di questo tipo.
@node Righe multiple
@section Record su righe multiple
@cindex righe multiple @subentry record su
@cindex record @subentry multiriga
@cindex input @subentry record multiriga
@cindex file @subentry lettura dei record multiriga
@cindex input
In alcune banche-dati, una sola riga non pu@`o contenere in modo adeguato
tutte le informazioni di una voce. In questi casi si possono usare record
multiriga.
Il primo passo @`e quello di scegliere il formato dei dati.
@cindex separatore di record @subentry per record multiriga
Una tecnica @`e quella di usare un carattere o una stringa non usuali per
separare i record. Per esempio, si pu@`o usare il carattere di interruzione di
pagina (scritto @samp{\f} sia in @command{awk} che in C) per separarli,
rendendo ogni record una pagina del file. Per far ci@`o, basta impostare la
variabile @code{RS} a @code{"\f"} (una stringa contenente il carattere di
interruzione di pagina). Si potrebbe ugualmente usare qualsiasi altro
carattere, sempre che non faccia parte dei dati di un record.
@cindex @code{RS} (variabile) @subentry record multiriga e
Un'altra tecnica @`e quella di usare righe vuote per separare i record.
Per una particolare
convenzione, una stringa nulla come valore di @code{RS} indica che i record
sono separati da una o pi@`u righe vuote. Quando @code{RS} @`e impostato alla
stringa nulla, ogni record termina sempre alla prima riga vuota che @`e stata
trovata. Il record successivo non inizia prima della successiva riga non
vuota. Indipendentemente dal numero di righe vuote presenti in successione,
esse costituiscono sempre un unico separatore di record.
(Le righe vuote devono essere completamente vuote; righe che contengono
spazi bianchi @emph{non} sono righe vuote.)
@cindex stringa @subentry pi@`u lunga da sinistra @subentry individuare la
@cindex individuare @subentry la stringa pi@`u lunga da sinistra
Si pu@`o ottenere lo stesso effetto di @samp{RS = ""} assegnando la stringa
@code{"\n\n+"} a @code{RS}. Quest'espressione regolare individua
il ritorno a capo alla fine del record e una o pi@`u righe vuote dopo il
record. In aggiunta, un'espressione regolare individua sempre la sequenza pi@`u
lunga possibile quando una tale stringa sia presente.
(@pxref{Pi@`u lungo da sinistra}).
Quindi, il record successivo non inizia prima della successiva riga non
vuota; indipendentemente dal numero di righe vuote presenti in una voce di
banca-dati, esse sono considerate come un unico separatore di record.
@cindex angolo buio @subentry record multiriga
Comunque, c'@`e una sostanziale differenza tra @samp{RS = ""} e @samp{RS =
"\n\n+"}. Nel primo caso, i ritorni a capo iniziali nel @value{DF} di
input vengono ignorati, e se un file termina senza righe vuote aggiuntive dopo
l'ultimo record, il ritorno a capo viene rimosso dal record. Nel secondo
caso, questa particolare elaborazione non viene fatta.
@value{DARKCORNER}
@cindex separatore di campo @subentry nei record multiriga
@cindex @code{FS} (variabile) @subentry nei record multiriga
Ora che l'input @`e separato in record, il secondo passo @`e quello di separare i
campi all'interno dei record. Un modo per farlo @`e quello di dividere in
campi ognuna delle righe in input
nel modo solito. Questo viene fatto per default tramite una
speciale funzionalit@`a. Quando @code{RS} @`e impostato alla stringa nulla
@emph{e} @code{FS} @`e impostato a un solo carattere, il carattere di
ritorno a capo agisce @emph{sempre} come separatore di campo.
Questo in aggiunta a tutte le separazioni di campo che risultano da
@code{FS}.
@quotation NOTA
Quando @code{FS} @`e la stringa nulla (@code{""}), o
un'espressione regolare, questa particolare funzionalit@`a di @code{RS} non
viene applicata; si applica al separatore di campo di default,
che @`e costituito da un solo spazio:
@samp{FS = @w{" "}}.
Si noti che la formulazione della specifica POSIX implica che
questa particolare funzionalit@`a dovrebbe valere anche quando
@code{FS} sia un'espressione regolare.
Tuttavia, Unix @command{awk} non si @`e mai comportato in questo
modo, e neppure @command{gawk}. Questo @`e fondamentalmente
un errore nella specifica POSIX.
@c Noted as of 4/2019; working to get the standard fixed.
@end quotation
La motivazione originale per questa particolare eccezione probabilmente era
quella di prevedere un comportamento che fosse utile nel caso di default
(cio@`e, @code{FS} uguale a @w{@code{" "}}). Questa funzionalit@`a pu@`o
costituire un problema se non si vuole che il carattere di ritorno a capo
faccia da separatore tra i campi, perch@'e non c'@`e alcun modo per impedirlo.
Tuttavia, si pu@`o aggirare il problema usando la funzione @code{split()}
per spezzare i record manualmente.
(@pxref{Funzioni per stringhe}).
Se si ha un separatore di campo costituito da un solo carattere, si pu@`o
aggirare la funzionalit@`a speciale in modo diverso, trasformando @code{FS}
in un'espressione regolare contenente
quel carattere singolo. Per esempio, se il separatore di campo @`e
un carattere di percentuale, al posto di
@samp{FS = "%"}, si pu@`o usare @samp{FS = "[%]"}.
Un altro modo per separare i campi @`e quello di
mettere ciascun campo su una riga separata: per far questo basta impostare la
variabile @code{FS} alla stringa @code{"\n"}.
(Questo separatore di un solo carattere individua un singolo ritorno a capo.)
Un esempio pratico di un @value{DF} organizzato in questo modo potrebbe essere
un elenco di indirizzi, in cui delle righe vuote fungono da separatore fra
record. Si consideri un elenco di indirizzi in un file chiamato
@file{indirizzi}, simile a questo:
@example
Jane Doe
123 Main Street
Anywhere, SE 12345-6789
John Smith
456 Tree-lined Avenue
Smallville, MW 98765-4321
@dots{}
@end example
@noindent
Un semplice programma per elaborare questo file @`e il seguente:
@example
# addrs.awk --- semplice programma per una lista di indirizzi postali
# I record sono separati da righe bianche
# Ogni riga @`e un campo.
BEGIN @{ RS = "" ; FS = "\n" @}
@{
print "Il nome @`e:", $1
print "L'indirizzo @`e:", $2
print "Citt@`a e Stato sono:", $3
print ""
@}
@end example
L'esecuzione del programma produce questo output:
@example
$ @kbd{awk -f addrs.awk addresses}
@print{} Il nome @`e: Jane Doe
@print{} L'indirizzo @`e: 123 Main Street
@print{} Citt@`a e Stato sono: Anywhere, SE 12345-6789
@print{}
@print{} Il nome @`e: John Smith
@print{} L'indirizzo @`e: 456 Tree-lined Avenue
@print{} Citt@`a e Stato sono: Smallville, MW 98765-4321
@print{}
@dots{}
@end example
@xref{Programma labels}, per un programma pi@`u realistico per gestire
elenchi di indirizzi. Il seguente elenco riassume come sono divisi i record,
a seconda del valore assunto da
@ifinfo
@code{RS}.
(@samp{==} significa ``@`e uguale a.'')
@end ifinfo
@ifnotinfo
@code{RS}:
@end ifnotinfo
@table @code
@item RS == "\n"
I record sono separati dal carattere di ritorno a capo (@samp{\n}). In
effetti, ogni riga nel @value{DF} @`e un record separato, comprese le righe
vuote. Questo @`e il comportamento di default.
@item RS == @var{qualsiasi carattere singolo}
I record sono separati da ogni ricorrenza del carattere specificato. Pi@`u
ricorrenze adiacenti delimitano record vuoti.
@item RS == ""
I record sono separati da una o pi@`u righe vuote.
Quando @code{FS} @`e un carattere singolo,
il carattere di ritorno a capo
serve sempre come separatore di campo, in aggiunta a qualunque valore possa
avere @code{FS}. I ritorni a capo all'inizio e alla fine del file sono
ignorati.
@item RS == @var{regexp}
I record sono separati da ricorrenze di caratteri corrispondenti a
@var{regexp}. Le corrispondenze iniziali e finali di
@var{regexp} designano record vuoti.
(Questa @`e un'estensione di @command{gawk}; non @`e specificata dallo
standard POSIX.)
@end table
@cindex @command{gawk} @subentry variabile @subentry @code{RT} in
@cindex @code{RT} (variabile)
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabili @code{RS}/@code{RT}
Se non @`e eseguito in modalit@`a di compatibilit@`a (@pxref{Opzioni}),
@command{gawk} imposta @code{RT} al testo di input corrispondente
al valore specificato da @code{RS}.
Ma se al termine del file in input non @`e stato trovato un testo che
corrisponde a @code{RS}, @command{gawk} imposta @code{RT} alla stringa nulla.
@node Getline
@section Richiedere input usando @code{getline}
@cindex @code{getline} (comando) @subentry input esplicito con
@cindex input @subentry esplicito
Finora abbiamo ottenuto i dati di input dal flusso di input principale di
@command{awk}: lo standard input (normalmente la tastiera, a volte
l'output di un altro programma) o i
file indicati sulla riga di comando. Il linguaggio @command{awk} ha uno
speciale comando predefinito chiamato @code{getline} che
pu@`o essere usato per leggere l'input sotto il diretto controllo dell'utente.
Il comando @code{getline} @`e usato in molti modi diversi e
@emph{non} dovrebbe essere usato dai principianti.
L'esempio che segue alla spiegazione del comando @code{getline}
comprende del materiale che ancora non @`e stato trattato. Quindi, @`e meglio
tornare indietro e studiare il comando @code{getline} @emph{dopo} aver rivisto
il resto
@ifinfo
di questo @value{DOCUMENT}
@end ifinfo
@ifhtml
di questo @value{DOCUMENT}
@end ifhtml
@ifnotinfo
@ifnothtml
delle Parti I e II
@end ifnothtml
@end ifnotinfo
e avere acquisito una buona conoscenza di come funziona @command{awk}.
@cindex @command{gawk} @subentry variabile @subentry @code{ERRNO} in
@cindex @code{ERRNO} (variabile) @subentry con comando @command{getline}
@cindex differenze tra @command{awk} e @command{gawk} @subentry comando @code{getline}
@cindex @code{getline} (comando) @subentry codice di ritorno
@cindex @option{--sandbox} (opzione) @subentry ridirezione dell'input con @code{getline}
@cindex opzione @subentry @option{--sandbox} @subentry ridirezione dell'input con @code{getline}
Il comando @code{getline} restituisce 1 se trova un record e 0 se
trova la fine del file. Se si verifica qualche errore cercando di leggere
un record, come un file che non pu@`o essere aperto, @code{getline}
restituisce @minus{}1. In questo caso, @command{gawk} imposta la variabile
@code{ERRNO} a una stringa che descrive l'errore in questione.
Se il messaggio di errore @code{ERRNO} indica che l'operazione di I/O pu@`o
essere ritentata e la variabile @code{PROCINFO["@var{input}", "RETRY"]} @`e
impostata a 1, @code{getline} restituisce un codice di ritorno @minus{}2
invece che @minus{}1, e si pu@`o provare a chiamare ulterioriormente
@code{getline}. @xref{Proseguire dopo errore in input} per ulteriori
informazioni riguardo a questa funzionalit@`a.
Negli esempi seguenti, @var{comando} sta per un valore di stringa che
rappresenta un comando della shell.
@quotation NOTA
Quando @`e stata specificata l'opzione @option{--sandbox} (@pxref{Opzioni}),
la lettura di input da file, @dfn{pipe} e coprocessi non @`e possibile.
@end quotation
@menu
* Getline semplice:: Usare @code{getline} senza argomenti.
* Getline variabile:: Usare @code{getline} in una variabile.
* Getline file:: Usare @code{getline} da un file.
* Getline variabile file:: Usare @code{getline} in una variabile da un
file.
* Getline @dfn{pipe}:: Usare @code{getline} da una @dfn{pipe}.
* Getline variabile @dfn{pipe}:: Usare @code{getline} in una variabile da una
@dfn{pipe}.
* Getline coprocesso:: Usare @code{getline} da un coprocesso.
* Getline variabile coprocesso:: Usare @code{getline} in una variabile da un
coprocesso.
* Note su getline:: Cose importanti da sapere su @code{getline}.
* Sommario di getline:: Sommario delle varianti di @code{getline}.
@end menu
@node Getline semplice
@subsection Usare @code{getline} senza argomenti
Il comando @code{getline} pu@`o essere usato senza argomenti per leggere l'input
dal file in input corrente. Tutto quel che fa in questo caso @`e leggere il
record in input successivo e dividerlo in campi. Questo @`e utile se @`e
finita l'elaborarezione del record corrente, e si vogliono fare delle
elaborazioni particolari sul record successivo @emph{proprio adesso}.
Per esempio:
@c 6/2019: Thanks to Mark Krauze for suggested
@c improvements (the inner while loop).
@example
# rimuovere il testo tra /* e */, compresi
@{
while ((inizio = index($0, "/*")) != 0) @{
prima = substr($0, 1, inizio - 1) # parte iniziale della stringa
dopo = substr($0, inizio + 2) # ... */ ...
while ((fine = index(dopo, "*/")) == 0) @{ # */ @`e nella parte finale?
# passa ai record seguenti
if (getline <= 0) @{
print("Fine file inattesa o errore:", ERRNO) > "/dev/stderr"
exit
@}
# costruisce la riga usando la concatenazione di stringhe
dopo = dopo $0
@}
dopo = substr(dopo, fine + 2) # rimuove il commento
# costruisce la riga di output usando la concatenazione
# di stringhe
$0 = prima dopo
@}
print $0
@}
@end example
Questo programma @command{awk} cancella i commenti in stile C
(@samp{/* @dots{} */}) dall'input.
Usa diverse funzionalit@`a che non sono ancora state trattate, incluse la
concatenazione di stringhe
(@pxref{Concatenazione})
e le funzioni predefinite @code{index()} e @code{substr()}
(@pxref{Funzioni per stringhe}).
Sostituendo @samp{print $0} con altre
istruzioni, si possono effettuare elaborazioni pi@`u complesse sull'input
decommentato, come ricercare corrispondenze di un'espressione regolare.
Ecco un esempio di file in input:
@example
mon/*comment*/key
rab/*commen
t*/bit
horse /*comment*/more text
part 1 /*comment*/part 2 /*comment*/part 3
no comment
@end example
Quando lo si esegue, l'output @`e:
@example
$ @kbd{awk -f strip_comments.awk example_text}
@print{} monkey
@print{} rabbit
@print{} horse more text
@print{} part 1 part 2 part 3
@print{} no comment
@end example
Questa forma del comando @code{getline} imposta @code{NF},
@code{NR}, @code{FNR}, @code{RT} e il valore di @code{$0}.
@quotation NOTA
Il nuovo valore di @code{$0} @`e usato per verificare
le espressioni di ricerca di ogni regola successiva. Il valore originale
di @code{$0} che ha attivato la regola che ha eseguito la @code{getline}
viene perso.
A differenza di @code{getline}, l'istruzione @code{next} legge un nuovo record
ma inizia a elaborarlo normalmente, a partire dalla prima
regola presente nel programma. @xref{Istruzione next}.
@end quotation
@node Getline variabile
@subsection Usare @code{getline} in una variabile
@cindex @code{getline} (comando) @subentry in una variabile
@cindex variabili @subentry usare in comando @code{getline}
Si pu@`o usare @samp{getline @var{var}} per leggere il record successivo
in input ad @command{awk} nella variabile @var{var}. Non vien fatta
nessun'altra elaborazione.
Per esempio, supponiamo che la riga successiva sia un commento o una stringa
particolare, e la si voglia leggere senza innescare nessuna regola. Questa
forma di @code{getline} permette di leggere quella riga e memorizzarla in una
variabile in modo che il ciclo principale di @command{awk} che "legge una riga
e controlla ogni regola" non la veda affatto.
L'esempio seguente inverte tra loro a due a due le righe in input:
@example
@group
@{
if ((getline tmp) > 0) @{
print tmp
print $0
@} else
print $0
@}
@end group
@end example
@noindent
Prende la seguente lista:
@example
wan
tew
free
phore
@end example
@noindent
e produce questo risultato:
@example
tew
wan
phore
free
@end example
Il comando @code{getline} usato in questo modo imposta solo le variabili
@code{NR}, @code{FNR} e @code{RT} (e, naturalmente, @var{var}).
Il record non viene
suddiviso in campi, e quindi i valori dei campi (compreso @code{$0}) e
il valore di @code{NF} non cambiano.
@node Getline file
@subsection Usare @code{getline} da un file
@cindex @code{getline} (comando) @subentry da un file
@cindex input @subentry ridirezione dell'
@cindex ridirezione dell'input
@cindex @code{<} (parentesi acuta sinistra) @subentry operatore @code{<} (I/O)
@cindex parentesi @subentry acuta sinistra (@code{<}) @subentry operatore @code{<} (I/O)
@cindex operatori @subentry input/output
Si usa @samp{getline < @var{file}} per leggere il record successivo da
@var{file}. Qui, @var{file} @`e un'espressione di tipo stringa che
specifica il @value{FN}. @samp{< @var{file}} @`e una cosidetta
@dfn{ridirezione} perch@'e richiede che l'input provenga da un posto
differente. Per esempio, il seguente programma
legge il suo record in input dal file @file{secondary.input} quando
trova un primo campo con un valore uguale a 10 nel file in input
corrente:
@example
@{
if ($1 == 10) @{
getline < "secondary.input"
print
@} else
print
@}
@end example
Poich@'e non viene usato il flusso principale di input, i valori di @code{NR} e
@code{FNR} restano immutati. Comunque, il record in input viene diviso in
modo normale, per cui vengono cambiati i valori di @code{$0} e degli altri
campi, producendo un nuovo valore di @code{NF}.
Viene impostato anche @code{RT}.
@cindex POSIX @command{awk} @subentry @code{<} (operatore)
@c Thanks to Paul Eggert for initial wording here
Per lo standard POSIX, @samp{getline < @var{espressione}} @`e ambiguo se
@var{espressione} contiene operatori che non sono all'interno di parentesi,
ad esclusione di @samp{$}; per esempio, @samp{getline < dir "/" file} @`e
ambiguo perch@'e l'operatore di concatenazione (non ancora trattato;
@pxref{Concatenazione}) non @`e posto tra parentesi.
Si dovrebbe scrivere invece @samp{getline < (dir "/" file)}, se il
programma dev'essere portabile su tutte le implementazioni di @command{awk}.
@node Getline variabile file
@subsection Usare @code{getline} in una variabile da un file
@cindex variabili @subentry usare in comando @code{getline}
Si usa @samp{getline @var{var} < @var{file}} per leggere l'input
dal file
@var{file}, e metterlo nella variabile @var{var}. Come prima, @var{file}
@`e un'espressione di tipo stringa che specifica il file dal quale
legggere.
In questa versione di @code{getline}, nessuna delle variabili predefinite @`e
cambiata e il record non @`e diviso in campi. La sola variabile cambiata @`e
@var{var}.@footnote{Questo non @`e completamente vero. @code{RT} pu@`o essere
cambiato se @code{RS} @`e un'espressione regolare.}
Per esempio, il seguente programma copia tutti i file in input nell'output, ad
eccezione dei record che dicono @w{@samp{@@include @var{nomefile}}}.
Tale record @`e sostituito dal contenuto del file
@var{nomefile}:
@example
@{
if (NF == 2 && $1 == "@@include") @{
while ((getline line < $2) > 0)
print line
close($2)
@} else
print
@}
@end example
Si noti come il nome del file in input aggiuntivo non compaia all'interno del
programma; @`e preso direttamente dai dati, e precisamente dal secondo campo
della riga di @code{@@include}.
La funzione @code{close()} viene chiamata per assicurarsi che se nell'input
appaiono due righe @code{@@include} identiche, l'intero file specificato sia
incluso ogni volta.
@xref{Chiusura file e @dfn{pipe}}.
Una carenza di questo programma @`e che non gestisce istruzioni
@code{@@include} nidificate
(cio@`e, istruzioni @code{@@include} contenute nei file inclusi)
nel modo in cui ci si aspetta che funzioni un vero preelaboratore di macro.
@xref{Programma igawk} per un programma
che gestisce le istruzioni @code{@@include} nidificate.
@node Getline @dfn{pipe}
@subsection Usare @code{getline} da una @dfn{pipe}
@c From private email, dated October 2, 1988. Used by permission, March 2013.
@cindex Kernighan, Brian @subentry citazioni di
@quotation
@i{L'onniscienza ha molti aspetti positivi.
Se non si pu@`o ottenerla, l'attenzione ai dettagli pu@`o aiutare.}
@author Brian Kernighan
@end quotation
@cindex @code{|} (barra verticale) @subentry operatore @code{|} (I/O)
@cindex barra verticale (@code{|}) @subentry operatore @code{|} (I/O)
@cindex input @subentry @dfn{pipeline}
@cindex @dfn{pipe} @subentry input
@cindex operatori @subentry input/output
L'output di un comando pu@`o anche essere convogliato in @code{getline}, usando
@samp{@var{comando} | getline}. In
questo caso, la stringa @var{comando} viene eseguita come comando di shell e
il suo output @`e passato ad @command{awk} per essere usato come input.
Questa forma di @code{getline} legge un record alla volta dalla @dfn{pipe}.
Per esempio, il seguente programma copia il suo input nel suo output,
ad eccezione delle righe che iniziano con @samp{@@execute}, che sono
sostituite dall'output prodotto dall'esecuzione del resto della riga
costituito da un comando di shell.
@example
@group
@{
if ($1 == "@@execute") @{
tmp = substr($0, 10) # Rimuove "@@execute"
while ((tmp | getline) > 0)
print
close(tmp)
@} else
print
@}
@end group
@end example
@noindent
La funzione @code{close()} viene chiamata per assicurarsi che, se appaiono
nell'input due righe @samp{@@execute} identiche, il comando sia eseguito per
ciascuna di esse.
@ifnottex
@ifnotdocbook
@xref{Chiusura file e @dfn{pipe}}.
@end ifnotdocbook
@end ifnottex
@c This example is unrealistic, since you could just use system
Dato l'input:
@example
pippo
pluto
paperino
@@execute who
gastone
@end example
@noindent
il programma potrebbe produrre:
@cindex Robbins @subentry Bill
@cindex Robbins @subentry Miriam
@cindex Robbins @subentry Arnold
@example
pippo
pluto
paperino
arnold ttyv0 Jul 13 14:22
miriam ttyp0 Jul 13 14:23 (murphy:0)
bill ttyp1 Jul 13 14:23 (murphy:0)
gastone
@end example
@noindent
Si osservi che questo programma ha eseguito @command{who} e stampato il
risultato. (Eseguendo questo programma, @`e chiaro che ciascun utente otterr@`a
risultati diversi, a seconda di chi @`e collegato al sistema.)
Questa variante di @code{getline} divide il record in campi, imposta il valore
di @code{NF}, e ricalcola il valore di @code{$0}. I valori di
@code{NR} e @code{FNR} non vengono cambiati.
Viene impostato @code{RT}.
@cindex POSIX @command{awk} @subentry @code{|} (operatore I/O)
@c Thanks to Paul Eggert for initial wording here
Per lo standard POSIX, @samp{@var{espressione} | getline} @`e ambiguo se
@var{espressione} contiene operatori che non sono all'interno di parentesi,
ad esclusione di @samp{$}. Per esempio,
@samp{@w{"echo "} "date" | getline} @`e ambiguo perch@'e
l'operatore di concatenazione non @`e tra parentesi. Si dovrebbe scrivere
invece @samp{(@w{"echo "} "date") | getline}, se il programma dev'essere
portabile su tutte le implementazioni di @command{awk}.
@cindex Brian Kernighan @subentry @command{awk} di
@cindex @command{mawk} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{mawk}
@quotation NOTA
Sfortunatamente, @command{gawk} non ha un comportamento uniforme nel
trattare un costrutto come @samp{@w{"echo "} "date" | getline}.
La maggior parte delle versioni, compresa la versione corrente, lo tratta
come @samp{@w{("echo "} "date") | getline}.
(Questo @`e anche il comportamento di BWK @command{awk}.)
Alcune versioni invece lo trattano come
@samp{@w{"echo "} ("date" | getline)}.
(Questo @`e il comportamento di @command{mawk}.)
In breve, per evitare problemi, @`e @emph{sempre} meglio usare parentesi
esplicite.
@end quotation
@node Getline variabile @dfn{pipe}
@subsection Usare @code{getline} in una variabile da una @dfn{pipe}
@cindex variabili @subentry usare in comando @code{getline}
Quando si usa @samp{@var{comando} | getline @var{var}},
l'output di @var{comando} @`e inviato tramite una @dfn{pipe} a
@code{getline} ad una variabile @var{var}. Per esempio, il
seguente programma legge la data e l'ora corrente nella variabile
@code{current_time}, usando il programma di utilit@`a @command{date}, e poi lo
stampa:
@example
BEGIN @{
"date" | getline current_time
close("date")
print "Report printed on " current_time
@}
@end example
In questa versione di @code{getline}, nessuna delle variabili predefinite @`e
cambiata e il record non @`e diviso in campi. In ogni caso, @code{RT} viene
impostato.
@ifinfo
@c Thanks to Paul Eggert for initial wording here
Per lo standard POSIX, @samp{@var{espressione} | getline @var{var}} @`e ambiguo
se @var{espressione} contiene operatori che non sono all'interno di parentesi
ad esclusione di @samp{$}; per esempio,
@samp{@w{"echo "} "date" | getline @var{var}} @`e ambiguo
perch@'e l'operatore di concatenazione non @`e tra parentesi. Si dovrebbe
scrivere invece @samp{(@w{"echo "} "date") | getline @var{var}} se il
programma dev'essere portabile su tutte le implementazioni di @command{awk}.
@end ifinfo
@node Getline coprocesso
@subsection Usare @code{getline} da un coprocesso
@cindex coprocessi @subentry @code{getline} da
@cindex @code{getline} (comando) @subentry coprocessi, usare da
@cindex @code{|} (barra verticale) @subentry operatore @code{|&} (I/O)
@cindex barra verticale (@code{|}) @subentry operatore @code{|&} (I/O)
@cindex operatori @subentry input/output
@cindex differenze tra @command{awk} e @command{gawk} @subentry operatori di input/output
Leggere dell'input in @code{getline} da una @dfn{pipe} @`e un'operazione
unidirezionale.
Il comando avviato con @samp{@var{comando} | getline} invia dati
@emph{al} programma @command{awk}.
Occasionalmente, si potrebbe avere la necessit@`a di inviare dei dati a un altro
programma che li elabori, per poi leggere il risultato che esso genera.
@command{gawk} permette di avviare un @dfn{coprocesso}, col quale sono
possibili comunicazioni bidirezionali. Questo vien fatto con l'operatore
@samp{|&}.
Tipicamente, dapprima si inviano dati al coprocesso e poi si leggono
i risultati da esso prodotto, come mostrato di seguito:
@example
print "@var{some query}" |& "db_server"
"db_server" |& getline
@end example
@noindent
esso invia una richiesta a @command{db_server} e poi legge i risultati.
I valori di @code{NR} e
@code{FNR} non vengono cambiati,
perch@'e non @`e cambiato il flusso principale.
In ogni caso, il record @`e diviso in campi
nel solito modo, cambiando cos@`{@dotless{i}} i valori di @code{$0}, degli altri campi,
e di @code{NF} e @code{RT}.
I coprocessi sono una funzionalit@`a avanzata. Vengono trattati qui solo perch@'e
@ifnotinfo
questa @`e la
@end ifnotinfo
@ifinfo
questo @`e il
@end ifinfo
@value{SECTION} su @code{getline}.
@xref{I/O bidirezionale},
dove i coprocessi vengono trattati pi@`u dettagliatamente.
@node Getline variabile coprocesso
@subsection Usare @code{getline} in una variabile da un coprocesso
@cindex variabili @subentry usare in comando @code{getline}
Quando si usa @samp{@var{comando} |& getline @var{var}}, l'output dal
coprocesso @var{comando} viene inviato tramite una @dfn{pipe} bidirezionale a
@code{getline} e nella variabile @var{var}.
In questa versione di @code{getline}, nessuna delle variabili predefinite
viene cambiata e il record non viene diviso in campi. La sola variabile che
cambia @`e @var{var}.
In ogni caso, @code{RT} viene impostato.
@ifinfo
I coprocessi sono una funzionalit@`a avanzata. Vengono trattati qui solo perch@'e
questo @`e il @value{SECTION} su @code{getline}.
@xref{I/O bidirezionale},
dove i coprocessi vengono trattati pi@`u dettagliatamente.
@end ifinfo
@node Note su getline
@subsection Cose importanti da sapere riguardo a @code{getline}
Qui sono elencate diverse considerazioni su @code{getline}
da tener presenti:
@itemize @value{BULLET}
@item
Quando @code{getline} cambia il valore di @code{$0} e @code{NF},
@command{awk} @emph{non} salta automaticamente all'inizio del
programma per iniziare a provare il nuovo record su ogni criterio di ricerca.
Comunque, il nuovo record viene provato su ogni regola successiva.
@cindex differenze tra @command{awk} e @command{gawk} @subentry limitazioni di implementazione
@cindex implementazione @subentry problemi di @subentry @command{gawk}, limiti
@cindex @command{awk} @subentry implementazioni di @subentry limiti delle
@cindex @command{gawk} @subentry problemi di implementazione @subentry limiti
@item
Alcune tra le prime implementazioni di @command{awk} limitano a una sola il
numero di @dfn{pipeline} che un programma @command{awk} pu@`o tenere aperte.
In @command{gawk}, non c'@`e questo limite.
Si possono aprire tante @dfn{pipeline} (e coprocessi) quante ne permette il
sistema operativo in uso.
@cindex effetti collaterali @subentry variabile @code{FILENAME}
@cindex @code{FILENAME} (variabile) @subentry impostare con @code{getline}
@cindex angolo buio @subentry variabile @subentry @code{FILENAME}
@cindex @code{getline} (comando) @subentry variabile @code{FILENAME} e
@cindex @code{BEGIN} (regola) @subentry @code{getline} e
@item
Un interessante effetto collaterale si ha se si usa @code{getline}, senza
una ridirezione, all'interno di una regola @code{BEGIN}. Poich@'e una
@code{getline} non ridiretta legge dai @value{DF} specificati nella riga di
comando, il primo comando @code{getline} fa s@`{@dotless{i}} che @command{awk} imposti
il valore di @code{FILENAME}. Normalmente, @code{FILENAME} non ha ancora un
valore all'interno delle regole @code{BEGIN}, perch@'e non si @`e ancora
iniziato a elaborare il
@value{DF} della riga di comando.
@value{DARKCORNER}
(Si veda @ref{BEGIN/END};
e @pxref{Variabili auto-assegnate}.)
@item
Usare @code{FILENAME} con @code{getline}
(@samp{getline < FILENAME})
pu@`o essere fonte di
confusione. @command{awk} apre un flusso separato di input, diverso dal
file in input corrente. Comunque, poich@'e non si usa una variabile,
@code{$0} e @code{NF} vengono aggiornati. Se si sta facendo questo, @`e
probabilmente per sbaglio, e si dovrebbe rivedere quello che si sta cercando
di fare.
@item
@ifdocbook
La prossima @value{SECTION}
@end ifdocbook
@ifnotdocbook
@ref{Sommario di getline},
@end ifnotdocbook
contiene una tabella che sintetizza le
varianti di @code{getline} e le variabili da esse modificate.
@`E degno di nota che le varianti che non usano la ridirezione
possono far s@`{@dotless{i}} che @code{FILENAME} venga aggiornato se chiedono ad
@command{awk} di iniziare a leggere un nuovo file in input.
@item
@cindex Moore, Duncan
Se la variabile assegnata @`e un'espressione con effetti collaterali, versioni
differenti di @command{awk} si comportano in modo diverso quando trovano la
fine-del-file [EOF]. Alcune versioni non valutano l'espressione; molte
versioni (compreso @command{gawk}) lo fanno. Si veda un esempio, gentilmente
fornito da Duncan Moore:
@ignore
Date: Sun, 01 Apr 2012 11:49:33 +0100
From: Duncan Moore
@end ignore
@example
BEGIN @{
system("echo 1 > f")
while ((getline a[++c] < "f") > 0) @{ @}
print c
@}
@end example
@noindent
Qui l'effetto secondario @`e @samp{++c}. Se viene trovata la fine del file
@emph{prima} di assegnare l'elemento @code{a}, @code{c} @`e incrementato o no?
@command{gawk} tratta @code{getline} come una chiamata di funzione, e valuta
l'espressione @samp{a[++c]} prima di cercare di leggere da @file{f}.
Comunque, alcune versioni di @command{awk} valutano l'espressione solo
se c'@`e un valore di stringa da assegnare.
@end itemize
@node Sommario di getline
@subsection Sommario delle varianti di @code{getline}
@cindex @code{getline} (comando) @subentry varianti
La @ref{tabella-varianti-getline}
riassume le otto varianti di @code{getline},
elencando le variabili predefinite che sono impostate da ciascuna di esse,
e se la variante @`e standard o @`e un'estensione di @command{gawk}.
Nota: per ogni variante, @command{gawk} imposta la variabile predefinita
@code{RT}.
@float Tabella,tabella-varianti-getline
@caption{Varianti di @code{getline} e variabili impostate da ognuna}
@multitable @columnfractions .33 .38 .27
@headitem Variante @tab Effetto @tab @command{awk} / @command{gawk}
@item @code{getline} @tab Imposta @code{$0}, @code{NF}, @code{FNR}, @code{NR}, e @code{RT} @tab @command{awk}
@item @code{getline} @var{var} @tab Imposta @var{var}, @code{FNR}, @code{NR}, e @code{RT} @tab @command{awk}
@item @code{getline <} @var{file} @tab Imposta @code{$0}, @code{NF}, e @code{RT} @tab @command{awk}
@item @code{getline @var{var} < @var{file}} @tab Imposta @var{var} e @code{RT} @tab @command{awk}
@item @var{comando} @code{| getline} @tab Imposta @code{$0}, @code{NF}, e @code{RT} @tab @command{awk}
@item @var{comando} @code{| getline} @var{var} @tab Imposta @var{var} e @code{RT} @tab @command{awk}
@item @var{comando} @code{|& getline} @tab Imposta @code{$0}, @code{NF}, e @code{RT} @tab @command{gawk}
@item @var{comando} @code{|& getline} @var{var} @tab Imposta @var{var} e @code{RT} @tab @command{gawk}
@end multitable
@end float
@node Timeout in lettura
@section Leggere input entro un tempo limite
@cindex tempo limite @subentry entro il quale leggere input
@cindex @dfn{timeout} @seeentry{tempo limite}
@cindex differenze tra @command{awk} e @command{gawk} @subentry tempo limite per lettura
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Si pu@`o specificare un tempo limite in millisecondi per leggere l'input dalla
tastiera, da una @dfn{pipe} o da una comunicazione bidirezionale, compresi i
@dfn{socket} TCP/IP. Questo pu@`o essere fatto per input, per comando o per
connessione, impostando un elemento speciale nel vettore @code{PROCINFO}
(@pxref{Variabili auto-assegnate}):
@example
PROCINFO["nome_input", "READ_TIMEOUT"] = @var{tempo limite in millisecondi}
@end example
Se @`e impostato, @command{gawk} smette di attendere una risposta e restituisce
insuccesso se non sono disponibili dati da leggere entro il limite di tempo
specificato. Per esempio, un cliente TCP pu@`o decidere di abbandonare se
non riceve alcuna risposta dal server dopo un certo periodo di tempo:
@example
@group
Service = "/inet/tcp/0/localhost/daytime"
PROCINFO[Service, "READ_TIMEOUT"] = 100
if ((Service |& getline) > 0)
print $0
else if (ERRNO != "")
print ERRNO
@end group
@end example
Qui vediamo come ottenere dati interattivamente dall'utente@footnote{Questo
presuppone che lo standard input provenga dalla tastiera.} aspettando per
non pi@`u di cinque secondi:
@example
PROCINFO["/dev/stdin", "READ_TIMEOUT"] = 5000
while ((getline < "/dev/stdin") > 0)
print $0
@end example
@command{gawk} termina l'operazione di lettura se l'input non
arriva entro il periodo di tempo limite, restituisce insuccesso
e imposta @code{ERRNO} a una stringa di valore adeguato.
Un valore del tempo limite negativo o pari a zero equivale a non specificare
affatto un tempo limite.
Si pu@`o impostare un tempo limite anche per leggere dalla tastiera nel ciclo
implicito che legge i record in input e li confronta coi criteri di ricerca,
come:
@example
$ @kbd{gawk 'BEGIN @{ PROCINFO["-", "READ_TIMEOUT"] = 5000 @}}
> @kbd{@{ print "You entered: " $0 @}'}
@kbd{gawk}
@print{} You entered: gawk
@end example
In questo caso, la mancata risposta entro cinque secondi d@`a luogo al seguente
messaggio di errore:
@example
@c questo @`e l'output effettivo - Antonio
@error{} gawk: riga com.:2: (FILENAME=- FNR=1) fatale: errore leggendo
@error{} file in input `-': Connessione scaduta
@end example
Il tempo limite pu@`o essere impostato o cambiato in qualsiasi momento, e avr@`a
effetto al tentativo successivo di leggere dal dispositivo di input. Nel
seguente esempio, partiamo con un valore di tempo limite di un secondo e
lo riduciamo progressivamente di un decimo di secondo finch@'e l'attesa
per l'input diventa illimitata.
@example
PROCINFO[Service, "READ_TIMEOUT"] = 1000
while ((Service |& getline) > 0) @{
print $0
PROCINFO[Service, "READ_TIMEOUT"] -= 100
@}
@end example
@quotation NOTA
Non si deve dare per scontato che l'operazione di lettura si blocchi
esattamente dopo che @`e stato stampato il decimo record. @`E possibile che
@command{gawk} legga e tenga in memoria i dati di pi@`u di un record
la prima volta. Per questo, cambiare il valore del tempo
limite come nell'esempio appena visto non @`e molto utile.
@end quotation
@cindex @env{GAWK_READ_TIMEOUT} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{GAWK_READ_TIMEOUT}
Se l'elemento di @code{PROCINFO} non @`e presente e la variabile d'ambiente
@env{GAWK_READ_TIMEOUT} esiste,
@command{gawk} usa il suo valore per inizializzare il valore di tempo limite.
L'uso esclusivo della variabile d'ambiente per specificare il tempo limite
ha lo svantaggio di non essere
adattabile per ogni comando o per ogni connessione.
@command{gawk} considera errore un superamento di tempo limite anche se
il tentativo di leggere dal dispositivo sottostante potrebbe riuscire
in un tentativo successivo. Questa @`e una limitazione, e inoltre
significa che non @`e possibile usarlo per ottenere input multipli,
provenienti da due o pi@`u sorgenti. @xref{Proseguire dopo errore in input}
per una modalit@`a che consente di tentare ulteriori operazioni di I/O.
Assegnare un valore di tempo limite previene un blocco a tempo indeterminato
legato a operazioni di lettura. Si tenga per@`o presente che ci sono altre
situazioni in cui @command{gawk} pu@`o restare bloccato in attesa che un
dispositivo di input sia pronto. Un cliente di rete a volte pu@`o impiegare
molto tempo per stabilire una
connessione prima di poter iniziare a leggere qualsiasi dato,
oppure il tentativo di aprire un file speciale FIFO in lettura pu@`o bloccarsi
indefinitamente in attesa che qualche altro processo lo apra in scrittura.
@node Proseguire dopo errore in input
@section Elaborare ulteriore input dopo certi errori di I/O
@cindex proseguire dopo errore in input
@cindex errore @subentry in input @subentry possibilit@`a di proseguire
@cindex differenze tra @command{awk} e @command{gawk} @subentry proseguire dopo errore in input
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Qualora @command{gawk} incontri un errore durante la lettura dell'input,
per default @code{getline} ha come codice di ritorno @minus{}1, e i
successivi tentativi di leggere dallo stesso file restituiscono una
indicazione di fine-file. @`E tuttavia possibile chiedere a
@command{gawk} di consentire un ulteriore tentativo di lettura in presenza
di certi errori, impostando uno speciale elemento del vettore
@code{PROCINFO} (@pxref{Variabili auto-assegnate}):
@example
PROCINFO["@var{nome_input_file}", "RETRY"] = 1
@end example
Quando un tale elemento esiste, @command{gawk} controlla il valore della
variabile di sistema
(nel linguaggio C)
@code{errno} quando si verifica un errore di I/O.
Se @code{errno} indica che un ulteriore tentativo di lettura pu@`o
terminare con successo, @code{getline} ha come codice di ritorno @minus{}2
e ulteriori chiamate a @code{getline} possono terminare correttamente.
Questo vale per i seguenti valori di @code{errno}: @code{EAGAIN},
@code{EWOULDBLOCK}, @code{EINTR}, e @code{ETIMEDOUT}.
Questa funzionalit@`a @`e utile quando si assegna un valore all'elemento
@code{PROCINFO["@var{nome_input_file}", "READ_TIMEOUT"]} o in situazioni
in cui un descrittore di file sia stato configurato per comportarsi in
modo non bloccante.
@node Directory su riga di comando
@section Directory sulla riga di comando
@cindex differenze tra @command{awk} e @command{gawk} @subentry directory sulla riga di comando
@cindex directory @subentry riga di comando
@cindex riga di comando @subentry directory su
Per lo standard POSIX, i file che compaiono sulla riga di comando di
@command{awk} devono essere file di testo; @`e un errore fatale se non lo sono.
La maggior parte delle versioni di @command{awk} genera un errore fatale
quando trova una directory sulla riga di comando.
Per default, @command{gawk} emette un avvertimento se c'@`e una directory sulla
riga di comando, e in ogni caso la ignora. Questo rende pi@`u facile usare
metacaratteri di shell col proprio programma @command{awk}:
@example
$ @kbd{gawk -f whizprog.awk *} @ii{Le directory potrebbero far fallire il programma}
@end example
Se viene data una delle opzioni @option{--posix}
o @option{--traditional}, @command{gawk} considera invece
una directory sulla riga di comando come un errore fatale.
@xref{Esempio di estensione Readdir} per un modo di trattare le directory
come dati usabili da un programma @command{awk}.
@sp 2
@node Sommario di Input
@section Sommario di Input
@itemize @value{BULLET}
@item
L'input @`e diviso in record in base al valore di @code{RS}.
Le possibilit@`a sono le seguenti:
@multitable @columnfractions .28 .45 .40
@headitem Valore di @code{RS} @tab Record separati da @dots{} @tab @command{awk} / @command{gawk}
@item Un carattere singolo @tab Quel carattere @tab @command{awk}
@item La stringa nulla (@code{""}) @tab Serie di due o pi@`u ritorni a capo @tab @command{awk}
@item Un'espressione regolare @tab Testo corrispondente alla @dfn{regexp} @tab @command{gawk}
@end multitable
@item
@code{FNR} indica quanti record sono stati letti dal file in input corrente;
@code{NR} indica quanti record sono stati letti in totale.
@item
@command{gawk} imposta @code{RT} al testo individuato da @code{RS}.
@item
Dopo la divisione dell'input in record, @command{awk} divide
i record in singoli campi, chiamati @code{$1}, @code{$2} e cos@`{@dotless{i}}
via. @code{$0} @`e l'intero record, e @code{NF} indica quanti campi
contiene. Il metodo di default per dividere i campi utilizza i
caratteri di spazio vuoto.
@item Si pu@`o far riferimento ai campi usando una variabile, come in @code{$NF}.
Ai campi possono anche essere assegnati dei valori, e questo implica che il
valore di @code{$0} sia ricalcolato se ad esso si fa riferimento in seguito.
Fare un assegnamento a un campo con un numero maggiore di @code{NF} crea il
campo e ricostruisce il record, usando @code{OFS} per separare i campi.
Incrementare @code{NF} fa la stessa cosa. Decrementare @code{NF} scarta dei
campi e ricostruisce il record.
@item
Separare i campi @`e pi@`u complicato che separare i record.
@multitable @columnfractions .40 .40 .20
@headitem Valore del separatore di campo @tab Campi separati @dots{} @tab @command{awk} / @command{gawk}
@item @code{FS == " "} @tab Da serie di spazi vuoti @tab @command{awk}
@item @code{FS == @var{un solo carattere}} @tab Da quel carattere @tab @command{awk}
@item @code{FS == @var{espr. reg.}} @tab Dal testo che corrisponde alla @dfn{regexp} @tab @command{awk}
@item @code{FS == ""} @tab Cos@`{@dotless{i}} ogni singolo carattere @`e un campo separato @tab @command{gawk}
@item @code{FIELDWIDTHS == @var{lista di colonne}} @tab Basata sulla posizione del carattere @tab @command{gawk}
@item @code{FPAT == @var{regexp}} @tab Dal testo attorno al testo corrispondente alla @dfn{regexp} @tab @command{gawk}
@end multitable
@item
Usando @samp{FS = "\n"} l'intero record sar@`a un unico campo
(nell'ipotesi che i record siano separati da caratteri di ritorno a capo).
@item
@code{FS} pu@`o essere impostato dalla riga di comando con l'opzione
@option{-F}.
Si pu@`o fare la stessa cosa usando un assegnamento di variabile da riga di
comando.
@item
@code{PROCINFO["FS"]} permette di sapere come i campi sono separati.
@item
@code{getline} nelle sue diverse forme serve per leggere record aggiuntivi
provenienti dal flusso di input di default, da un file, o da una @dfn{pipe}
o da un coprocesso.
@item
@code{PROCINFO[@var{file}, "READ_TIMEOUT"]} si pu@`o usare per impostare un
tempo limite alle operazioni di lettura da @var{file}.
@cindex POSIX @subentry modalit@`a
@cindex modalit@`a POSIX
@item
Le directory sulla riga di comando generano un errore fatale per
@command{awk} standard;
@command{gawk} le ignora se non @`e in modalit@`a POSIX.
@end itemize
@c EXCLUDE START
@node Esercizi su Input
@section Esercizi
@enumerate
@item
Usando la variabile @code{FIELDWIDTHS} (@pxref{Dimensione costante}),
scrivere un programma per leggere i dati delle elezioni, dove ogni record
rappresenta i voti di un votante. Trovare un modo per definire quali colonne
sono associate a ogni quesito elettorale, e stampare i voti totali,
comprese le astensioni, per ciascun quesito.
@end enumerate
@c EXCLUDE END
@node Stampare
@chapter Stampare in output
@cindex stampare
@cindex output @subentry stampare @seeentry{stampare}
Una delle azioni che un programma fa pi@`u comunemente, @`e quella di produrre
@dfn{stampe}, ossia scrivere in output l'input letto, tutto o in parte.
Si pu@`o usare l'istruzione @code{print} per una stampa semplice, e l'istruzione
@code{printf} per una formattazione dell'output pi@`u sofisticata.
L'istruzione @code{print} non ha un limite al numero di elementi quando
calcola @emph{quali} valori stampare. Peraltro, con due eccezioni,
non @`e possibile specificare @emph{come} stamparli: quante
colonne, se usare una notazione esponenziale o no, etc.
(Per le eccezioni, @pxref{Separatori di output} e
la @ref{OFMT}.)
Per stampare fornendo delle specifiche, @`e necessario usare
l'istruzione @code{printf}
(@pxref{Printf}).
@cindex istruzione @subentry @code{print}
@cindex istruzione @subentry @code{printf}
Oltre alla stampa semplice e formattata, questo @value{CHAPTER}
esamina anche le ridirezioni di I/O verso file e @dfn{pipe}, introduce
i @value{FNS} speciali che @command{gawk} elabora internamente,
e parla della funzione predefinita @code{close()}.
@menu
* Print:: L'istruzione @code{print}.
* Esempi su print:: Semplici esempi di
istruzioni @code{print}.
* Separatori di output:: I separatori di output e come
modificarli.
* OFMT:: Controllare l'output di numeri con
@code{print}.
* Printf:: l'istruzione @code{printf}.
* Ridirezione:: Come ridirigere l'output a diversi
file e @dfn{pipe}.
* FD speciali:: I/O con FD [Descrittori File]
speciali.
* File speciali:: Interpretazione nomi file in
@command{gawk}. @command{gawk}
Permette di accedere a descrittori
file gi@`a aperti a inizio esecuzione
* Chiusura file e @dfn{pipe}:: Chiudere file in input e di output e
@dfn{pipe}.
* Continuazione dopo errori:: Abilitare continuazione dopo errori
in output.
* Sommario di Output:: Sommario di Output.
* Esercizi su Output:: Esercizi.
@end menu
@node Print
@section L'istruzione @code{print}
L'istruzione @code{print} si usa per produrre dell'output formattato in
maniera semplice, standardizzata. Si
specificano solo le stringhe o i numeri
da stampare, in una lista separata da virgole. Questi elementi sono stampati,
separati tra loro da spazi singoli, e alla fine viene stampato un
ritorno a capo. L'istruzione @`e simile a questa:
@example
print @var{elemento1}, @var{elemento2}, @dots{}
@end example
@noindent
L'intera lista di elementi pu@`o opzionalmente essere racchiusa fra
parentesi. Le parentesi sono obbligatorie se qualche espressione presente
in uno degli elementi usa l'operatore relazionale @samp{>}, che potrebbe
essere confuso con una ridirezione dell'output (@pxref{Ridirezione}).
Gli elementi da stampare possono essere stringhe costanti o numeri, campi
del record corrente (come @code{$1}), variabili, o quasiasi espressione
@command{awk}. I valori numerici sono convertiti in stringhe prima di essere
stampati.
@cindex record @subentry stampare
@cindex righe @subentry vuote @subentry stampare
@cindex testo @subentry stampare
Una semplice istruzione @samp{print} senza specificare elementi equivale a
@samp{print $0}: stampa l'intero record corrente. Per stampare una riga
vuota, si usa @samp{print ""}.
Per stampare un testo che non cambia, si usi come elemento una costante
stringa, per esempio @w{@code{"Non v'allarmate"}}. Dimenticandosi di mettere
i doppi apici, il testo @`e preso per un'espressione @command{awk},
e probabilmente verr@`a emesso un messaggio di errore. Occorre tener presente
che tra ogni coppia di elementi viene stampato uno spazio.
Si noti che l'istruzione @code{print} @`e un'istruzione, e non
un'espressione: non @`e possibile usarla nella parte modello [di ricerca] di
un'istruzione @dfn{criterio di ricerca--azione}, per esempio.
@node Esempi su print
@section Esempi di istruzioni @code{print}
Ogni istruzione @code{print} produce almeno una riga in output. Comunque,
non @`e limitata a una sola riga. Se il valore di un elemento @`e una stringa
che contiene un ritorno a capo, il ritorno a capo @`e stampato insieme al
resto della stringa. Una
singola istruzione @code{print} pu@`o in questo modo generare un numero
qualsiasi di righe.
@cindex ritorno a capo @subentry stampare un
Quel che segue @`e un esempio di stampa di una stringa che contiene al suo
interno dei
@ifinfo
ritorni a capo
(la @samp{\n} @`e una sequenza di protezione, che si usa per rappresentare il
carattere di ritorno a capo; @pxref{Sequenze di protezione}):
@end ifinfo
@ifhtml
ritorni a capo
(la @samp{\n} @`e una sequenza di protezione, che si usa per rappresentare il
carattere di ritorno a capo; @pxref{Sequenze di protezione}):
@end ifhtml
@ifnotinfo
@ifnothtml
ritorni a capo:
@end ifnothtml
@end ifnotinfo
@example
@group
$ @kbd{awk 'BEGIN @{ print "riga uno\nriga due\nriga tre" @}'}
@print{} riga uno
@print{} riga due
@print{} riga tre
@end group
@end example
@cindex campi @subentry stampare
Il prossimo esempio, eseguito sul file @file{inventory-shipped},
stampa i primi due campi di ogni record in input, separandoli con uno
spazio:
@example
$ @kbd{awk '@{ print $1, $2 @}' inventory-shipped}
@print{} Jan 13
@print{} Feb 15
@print{} Mar 15
@dots{}
@end example
@cindex istruzione @subentry @code{print} @subentry virgole, omettere
@cindex debug @subentry istruzione @code{print} @subentry omissione virgole
Un errore frequente usando l'istruzione @code{print} @`e quello di tralasciare
la virgola tra due elementi. Questo ha spesso come risultato la stampa di
elementi attaccati tra loro, senza lo spazio di separazione. Il motivo per
cui ci@`o accade @`e che la scrittura di due
espressioni di stringa in @command{awk} ne indica la concatenazione. Qui si
vede l'effetto dello stesso programma,
senza le virgole:
@example
$ @kbd{awk '@{ print $1 $2 @}' inventory-shipped}
@print{} Jan13
@print{} Feb15
@print{} Mar15
@dots{}
@end example
@cindex @code{BEGIN} (regola) @subentry intestazioni, aggiungere
Per chi non conosce il file @file{inventory-shipped} nessuno
dei due output di esempio risulta molto comprensibile. Una riga iniziale di
intestazione li renderebbe pi@`u chiari.
Aggiungiamo qualche intestazione alla nostra tabella dei mesi
(@code{$1}) e dei contenitori verdi spediti (@code{$2}). Lo facciamo usando
una regola @code{BEGIN} (@pxref{BEGIN/END}) in modo che le intestazioni siano
stampate una volta sola:
@example
awk 'BEGIN @{ print "Mese Contenitori"
print "------ ----- --- --" @}
@{ print $1, $2 @}' inventory-shipped
@end example
@noindent
Una volta eseguito, il programma stampa questo:
@example
Mese Contenitori
----- -----------
Jan 13
Feb 15
Mar 15
@dots{}
@end example
@noindent
Il solo problema, in effetti, @`e che le intestazioni e i dati della tabella
non sono allineati! Possiamo provvedere stampando alcuni spazi tra i due
campi:
@example
@group
awk 'BEGIN @{ print "Mese Contenitori"
print "------ ----- --- --" @}
@{ print $1, " ", $2 @}' inventory-shipped
@end group
@end example
@cindex istruzione @subentry @code{printf} @subentry colonne, allineamento
@cindex colonne @subentry allineamento
Allineare le colonne in questo modo pu@`o diventare piuttosto
complicato, quando ci sono parecchie colonne da tenere allineate. Contare gli
spazi per due o tre colonne @`e semplice, ma oltre questo limite comincia a
volerci molto tempo. Ecco perch@'e @`e disponibile l'istruzione @code{printf}
(@pxref{Printf});
una delle possibilit@`a che offre @`e quella di allineare colonne di dati.
@cindex continuazione di riga @subentry in istruzione @code{print}
@cindex istruzione @subentry @code{print} @subentry continuazione di riga e
@cindex @code{print} (istruzione) @subentry continuazione di riga e
@quotation NOTA
Si pu@`o continuare su pi@`u righe sia l'istruzione @code{print} che l'istruzione
@code{printf} semplicemente mettendo un ritorno a capo dopo una virgola
qualsiasi
(@pxref{Istruzioni/Righe}).
@end quotation
@node Separatori di output
@section I separatori di output e come modificarli
@cindex variabile @subentry @code{OFS}
Come detto sopra, un'istruzione @code{print} contiene una lista di elementi
separati da virgole. Nell'output, gli elementi sono solitamente separati
da spazi singoli. Non @`e detto tuttavia che debba sempre essere cos@`{@dotless{i}}; uno
spazio singolo @`e semplicemente il valore di default. Qualsiasi stringa di
caratteri pu@`o essere usata come
@dfn{separatore di campo in output} impostando la variabile
predefinita @code{OFS}. Il valore iniziale di questa variabile @`e
la stringa @w{@code{" "}} (cio@`e, uno spazio singolo).
L'output di un'istruzione @code{print} completa @`e detto un @dfn{record di
output}. Ogni istruzione @code{print} stampa un record di output, e alla fine
ci aggiunge una stringa detta @dfn{separatore record in output} (o
@code{ORS}). Il valore iniziale di @code{ORS} @`e la stringa @code{"\n"}
(cio@`e, un carattere di ritorno a capo). Quindi, ogni istruzione
@code{print} normalmente genera [almeno] una riga a s@'e stante.
@cindex output @subentry record
@cindex separatore di record @subentry in output @seeentry{@code{ORS} (variabile)}
@cindex @code{ORS} (variabile)
@cindex @code{BEGIN} (regola) @subentry variabili @code{OFS}/@code{ORS}, assegnare valori a
Per cambiare il tipo di separazione in output di campi e record, si impostano
valori differenti alle variabili @code{OFS} e @code{ORS}. Il posto pi@`u
indicato per farlo @`e nella regola @code{BEGIN}
(@pxref{BEGIN/END}), in modo che l'assegnazione abbia effetto prima
dell'elaborazione di ogni record in input. Questi valori si possono
anche impostare dalla riga di comando, prima della lista dei file in input,
oppure usando l'opzione della riga di comando @option{-v}
(@pxref{Opzioni}).
L'esempio seguente stampa il primo e il secondo campo di ogni record in input,
separati da un punto e virgola, con una riga vuota aggiunta dopo ogni
ritorno a capo:
@example
$ @kbd{awk 'BEGIN @{ OFS = ";"; ORS = "\n\n" @}}
> @kbd{@{ print $1, $2 @}' mail-list}
@print{} Amelia;555-5553
@print{}
@print{} Anthony;555-3412
@print{}
@print{} Becky;555-7685
@print{}
@print{} Bill;555-1675
@print{}
@print{} Broderick;555-0542
@print{}
@print{} Camilla;555-2912
@print{}
@print{} Fabius;555-1234
@print{}
@print{} Julie;555-6699
@print{}
@print{} Martin;555-6480
@print{}
@print{} Samuel;555-3430
@print{}
@print{} Jean-Paul;555-2127
@print{}
@end example
Se il valore di @code{ORS} non contiene un ritorno a capo, l'output del
programma viene scritto tutto su un'unica riga.
@node OFMT
@section Controllare l'output di numeri con @code{print}
@cindex numerico @subentry formato di output
@cindex formato @subentry numerico di output
Quando si stampano valori numerici con l'istruzione @code{print},
@command{awk} converte internamente ogni numero in una stringa di caratteri
e stampa quella stringa. @command{awk} usa la funzione @code{sprintf()}
per effettuare questa conversione
(@pxref{Funzioni per stringhe}).
Per ora, basta dire che la funzione @code{sprintf()}
accetta una @dfn{specifica di formato} che indica come formattare
i numeri (o le stringhe), e che ci sono svariati modi per formattare i
numeri. Le differenti specifiche di formato sono trattate pi@`u
esaurientemente
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Lettere di controllo}.
@cindexawkfunc{sprintf}
@cindex @code{OFMT} (variabile)
@cindex output @subentry specificatore di formato @subentry @code{OFMT}
La variabile predefinita @code{OFMT} contiene la specifica di formato
che @code{print} usa con @code{sprintf()} per convertire un numero in
una stringa per poterla stampare.
Il valore di default di @code{OFMT} @`e @code{"%.6g"}.
Il modo in cui @code{print} stampa i numeri si pu@`o cambiare
fornendo una specifica di formato differente
per il valore di @code{OFMT}, come mostrato nell'esempio seguente:
@example
$ @kbd{awk 'BEGIN @{}
> @kbd{OFMT = "%.0f" # Stampa numeri come interi (arrotonda)}
> @kbd{print 17.23, 17.54 @}'}
@print{} 17 18
@end example
@noindent
@cindex angolo buio @subentry variabile @subentry @code{OFMT}
@cindex POSIX @command{awk} @subentry @code{OFMT} (variabile)
@cindex variabile @subentry @code{OFMT} @subentry POSIX @command{awk} in
Per lo standard POSIX, il comportamento di @command{awk} @`e indefinito
se @code{OFMT} contiene qualcosa di diverso da una specifica di conversione
di un numero in virgola mobile.
@value{DARKCORNER}
@node Printf
@section Usare l'istruzione @code{printf} per stampe sofisticate
@cindex istruzione @subentry @code{printf}
@cindex @code{printf} (istruzione)
@cindex output @subentry formattare
@cindex formattare @subentry output
Per un controllo pi@`u ampio sul formato di output di quello fornito da
@code{print}, si pu@`o usare @code{printf}.
Con @code{printf} si pu@`o
specificare lo spazio da utilizzare per ogni elemento, e anche le varie
scelte di formattazione disponibile per i numeri (come la base da usare in
output, se stampare con notazione esponenziale, se inserire un segno, e quante
cifre stampare dopo il separatore decimale).
@menu
* Printf Fondamenti:: Sintassi dell'istruzione
@code{printf}.
* Lettere di controllo:: Lettere di controllo del formato.
* Modificatori di formato:: Modificatori specifiche di formato.
* Esempi su printf:: Numerosi esempi.
@end menu
@node Printf Fondamenti
@subsection Sintassi dell'istruzione @code{printf}
@cindex istruzione @subentry @code{printf} @subentry sintassi
@cindex @code{printf} (istruzione) @subentry sintassi
Una semplice istruzione @code{printf} @`e qualcosa di simile a questo:
@example
printf @var{formato}, @var{elemento1}, @var{elemento2}, @dots{}
@end example
@noindent
Come nel caso di @code{print}, l'intera lista degli argomenti pu@`o
opzionalmente essere racchiusa fra
parentesi. Anche qui, le parentesi sono obbligatorie se l'espressione di
qualche elemento usa l'operatore
relazionale @samp{>}, che potrebbe
essere confuso con una ridirezione dell'output (@pxref{Ridirezione}).
@cindex specificatori di formato
La differenza tra @code{printf} e @code{print} @`e l'argomento @var{formato}.
Questo @`e un'espressione il cui valore @`e visto come una stringa;
specifica come scrivere in output ognuno degli altri argomenti. @`E chiamata
@dfn{stringa di formato}.
La stringa di formato @`e molto simile a quella usata dalla funzione di
libreria ISO C @code{printf()}. Buona parte del @var{formato} @`e testo da
stampare cos@`{@dotless{i}} come @`e scritto.
All'interno di questo testo ci sono degli @dfn{specificatori di formato},
uno per ogni elemento da stampare.
Ogni specificatore di formato richiede di stampare l'elemento successivo
nella lista degli argomenti
in quella posizione del formato.
L'istruzione @code{printf} non aggiunge in automatico un ritorno a capo
al suo output. Scrive solo quanto specificato dalla stringa di formato.
Quindi, se serve un ritorno a capo, questo va incluso nella stringa di formato.
Le variabili di separazione dell'output @code{OFS} e @code{ORS} non hanno
effetto sulle istruzioni @code{printf}.
Per esempio:
@example
@group
$ @kbd{awk 'BEGIN @{}
> @kbd{ORS = "\nAHI!\n"; OFS = "+"}
> @kbd{msg = "Non v\47allarmate!"}
> @kbd{printf "%s\n", msg}
> @kbd{@}'}
@print{} Non v'allarmate!
@end group
@end example
@noindent
Qui, n@'e il @samp{+} n@'e l'esclamazione @samp{AHI!} compaiono nel messaggio
in output.
@node Lettere di controllo
@subsection Lettere di controllo del formato
@cindex istruzione @subentry @code{printf} @subentry lettere di controllo del formato
@cindex @code{printf} (istruzione) @subentry lettere di controllo del formato
@cindex specificatori di formato @subentry istruzione @code{printf}
Uno specificatore di formato inizia col carattere @samp{%} e termina con
una @dfn{lettera di controllo del formato}; e dice all'istruzione
@code{printf} come stampare un elemento. La lettera di controllo del
formato specifica che @emph{tipo}
di valore stampare. Il resto dello specificatore di formato @`e costituito da
@dfn{modificatori} opzionali che controllano @emph{come} stampare il valore,
per esempio stabilendo la larghezza del campo. Ecco una lista delle
lettere di controllo del formato:
@c @asis for docbook to come out right
@table @asis
@item @code{%a}, @code{%A}
Un numero in virgola mobile scritto nella forma
[@code{-}]@code{0x@var{h}.@var{hhhh}p+-@var{dd}}
(formato esadecimale virgola mobile nel compilatore C99).
Per @code{%A},
si usano lettere maiuscole invece che lettere minuscole.
@quotation NOTA
Lo standard POSIX in vigore richiede il supporto di @code{%a}
e di @code{%A} in @command{awk}. Per quanto ci consta, oltre a
@command{gawk}, la sola altra versione di @command{awk} che fornisce
questo supporto @`e BWK @command{awk}.
Se si usano questi formati, il programma in questione @`e quindi
estremamente non-portabile!
Inoltre, questi formati non sono disponibili su alcun sistema in cui
la funzione di libreria C @code{printf()} utilizzata da @command{gawk}
non li supporta.
Al momento in cui questo libro @`e stato scritto, fra i sistemi su cui
@`e stato portato @command{gawk}, il solo sistema noto che
non li supporta @`e OpenVMS.
@end quotation
@item @code{%c}
Stampa un numero come un carattere; quindi, @samp{printf "%c",
65} stampa la lettera @samp{A}. L'output per un valore costituito da una
stringa @`e il primo carattere della stringa stessa.
@cindex angolo buio @subentry caratteri di controllo del formato
@cindex @command{gawk} @subentry caratteri di controllo del formato
@quotation NOTA
Lo standard POSIX richiede che il primo carattere di una stringa sia stampato.
In localizzazioni con caratteri multibyte, @command{gawk} tenta di
convertire i primi byte della stringa in un carattere multibyte valido
e poi di stampare la codifica multibyte di quel carattere.
Analogamente, nella stampa di un valore numerico, @command{gawk} ammette che
il valore appartenga all'intervallo numerico di valori che possono essere
contenuti in un carattere multibyte.
Se la conversione alla codifica multibyte non riesce, @command{gawk}
usa gli ultimi otto bit della cifra (quelli meno significativi) come
carattere da stampare.
Altre versioni di @command{awk} generalmente si limitano a stampare
il primo byte di una stringa o i valori numerici che possono essere
rappresentati in un singolo byte (0--255).
@value{DARKCORNER}
@end quotation
@item @code{%d}, @code{%i}
Stampa un numero intero in base decimale.
Le due lettere di controllo sono equivalenti.
(La specificazione @samp{%i} @`e ammessa per compatibilit@`a con ISO C.)
@item @code{%e}, @code{%E}
Stampa un numero nella notazione scientifica (con uso di esponente).
Per esempio:
@example
printf "%4.3e\n", 1950
@end example
@noindent
stampa @samp{1.950e+03}, con un totale di quattro cifre significative, tre
delle quali
seguono il punto che separa la parte intera da quella decimale
[in Italia si usa la virgola al posto del punto]
(L'espressione @samp{4.3} rappresenta due modificatori,
introdotti nella prossima @value{SUBSECTION}).
@samp{%E} usa @samp{E} invece di @samp{e} nell'output.
@item @code{%f}
Stampa un numero in notazione in virgola mobile.
Per esempio:
@example
printf "%4.3f", 1950
@end example
@noindent
stampa @samp{1950.000}, con un minimo di quattro cifre significative, tre
delle quali vengono dopo il punto decimale.
(L'espressione @samp{4.3} rappresenta due modificatori,
introdotti nella prossima @value{SUBSECTION}).
In sistemi che implementano il formato in virgola mobile, come specificato
dallo standard IEEE 754, il valore infinito negativo @`e rappresentato come
@samp{-inf} o @samp{-infinity},
e l'infinito positivo come
@samp{inf} o @samp{infinity}.
Il valore speciale ``not a number'' [non @`e un numero] viene scritto come
@samp{-nan} o @samp{nan}
(@pxref{Definizioni matematiche}).
@item @code{%F}
Come @samp{%f}, ma i valori di infinito e di ``not a number'' sono scritti
in lettere maiuscole.
Il formato @samp{%F} @`e un'estensione POSIX allo standard ISO C; non tutti
i sistemi lo prevedono. In tali casi,
@command{gawk} usa il formato @samp{%f}.
@item @code{%g}, @code{%G}
Stampa un numero usando o la notazione scientifica o quella in virgola
mobile, scegliendo la forma pi@`u concisa; se il risultato @`e stampato usando la
notazione scientifica, @samp{%G} usa @samp{E} invece di @samp{e}.
@item @code{%o}
Stampa un numero intero in ottale, senza segno
(@pxref{Numeri non-decimali}).
@item @code{%s}
Stampa una stringa.
@item @code{%u}
Stampa un numero intero decimale, senza segno.
(Questo formato @`e poco usato, perch@'e tutti i numeri in @command{awk}
sono in virgola mobile; @`e disponibile principalmente per compatibilit@`a col
linguaggio C.)
@item @code{%x}, @code{%X}
Stampa un intero esadecimale senza segno;
@samp{%X} usa le lettere da @samp{A} a @samp{F}
invece che da @samp{a} a @samp{f}
(@pxref{Numeri non-decimali}).
@item @code{%%}
Stampa un solo carattere @samp{%}.
Questa notazione non serve per stampare alcun
argomento e ignora eventuali modificatori.
@end table
@cindex angolo buio @subentry caratteri di controllo del formato
@cindex @command{gawk} @subentry caratteri di controllo del formato
@quotation NOTA
Quando si usano lettere di controllo del formato per numeri interi
per stampare valori esterni all'intervallo massimo disponibile nel
linguaggio C per i numeri interi,
@command{gawk} usa lo
specificatore di formato @samp{%g}. Se si specifica l'opzione @option{--lint}
sulla riga di comando (@pxref{Opzioni}), @command{gawk}
emette un messaggio di avvertimento. Altre versioni di @command{awk} possono
stampare valori non validi, o comportarsi in modo completamente differente.
@value{DARKCORNER}
@end quotation
@quotation NOTA
Lo standard IEEE 754 per l'aritmetica in virgola mobile consente di
avere valori speciali per rappresentare ``infinito'' (sia positivo che
negativo) e valori che sono ``non numerici'' (NaN - [Not a Number]).
L'input e l'output di tali valori avviene sotto forma di stringhe di
testo. Ci@`o pone dei problemi nel linguaggio @command{awk}, che
esisteva gi@`a prima della definizione dello standard IEEE. Dettagli
ulteriori si possono trovare in @ref{Problemi virgola mobile POSIX};
si prega di fare riferimento a quel testo.
@end quotation
@node Modificatori di formato
@subsection Modificatori per specifiche di formato @code{printf}
@cindex istruzione @subentry @code{printf} @subentry modificatori
@cindex @code{printf} (istruzione) @subentry modificatori
@cindex modificatori @subentry in specificatori di formato
Una specifica di formato pu@`o anche includere dei @dfn{modificatori} che
possono controllare che parte stampare del valore dell'elemento, e anche
quanto spazio utilizzare per stamparlo.
I modificatori sono posizionati tra il @samp{%} e la lettera che controlla
il formato.
Negli esempi seguenti verr@`a usato il simbolo del punto elenco ``@bullet{}'' per
rappresentare
spazi nell'output. Questi sono i modificatori previsti, nell'ordine in
cui possono apparire:
@table @asis
@cindex differenze tra @command{awk} e @command{gawk} @subentry tra istruzioni @code{print} e @code{printf}
@cindex istruzione @subentry @code{printf} @subentry specificatori di posizione
@cindex @code{printf} (istruzione) @subentry specificatori di posizione
@c the code{} does NOT start a secondary
@cindex specificatori di posizione @subentry istruzione @code{printf}
@item @code{@var{N}$}
Una costante intera seguita da un @samp{$} @`e uno @dfn{specificatore di posizione}.
Normalmente, le specifiche di formato sono applicate agli argomenti
nell'ordine in cui appaiono nella stringa di formato. Con uno specificatore
di posizione, la specifica di formato @`e applicata a un argomento
indicato per numero, invece che a quello che
sarebbe il prossimo argomento nella lista. Gli specificatori di posizione
iniziano a contare partendo da uno. Quindi:
@example
printf "%s %s\n", "Non", "v'allarmate"
printf "%2$s %1$s\n", "v'allarmate", "Non"
@end example
@noindent
stampa per due volte il famoso consiglio amichevole.
A prima vista, questa funzionalit@`a non sembra di grande utilit@`a.
Si tratta in effetti di un'estensione @command{gawk}, pensata per essere
usata nella traduzione di messaggi emessi in fase di esecuzione.
@xref{Ordinamento di printf},
che descrive come e perch@'e usare specificatori di posizione.
Per ora li possiamo ignorare.
@item - @code{-} (Segno meno)
Il segno meno, usato prima del modificatore di larghezza (si veda pi@`u avanti
in questa lista),
richiede di allineare a sinistra
l'argomento mantenendo la larghezza specificata. Normalmente, l'argomento
@`e stampato allineato a destra, con la larghezza specificata. Quindi:
@example
printf "%-6s", "pippo"
@end example
@noindent
stampa @samp{pippo@bullet{}}.
@item @var{spazio}
Applicabile a conversioni numeriche, richiede di inserire uno spazio prima
dei valori positivi e un segno meno prima di quelli negativi.
@item @code{+}
Il segno pi@`u, usato prima del modificatore di larghezza (si veda pi@`u avanti
in questa lista),
richiede di mettere sempre un segno nelle conversioni numeriche, anche se
il dato da formattare ha valore positivo. Il @samp{+} prevale sul
modificatore @dfn{spazio}.
@item @code{#}
Richiede di usare una ``forma alternativa'' per alcune lettere di controllo.
Per @samp{%o}, preporre uno zero.
Per @samp{%x} e @samp{%X}, preporre @samp{0x} o @samp{0X} se il
numero @`e diverso da zero.
Per @samp{%e}, @samp{%E}, @samp{%f}, e @samp{%F}, il risultato deve contenere
sempre un separatore decimale.
Per @code{%g} e @code{%G}, gli zeri finali non significativi non sono
tolti dal numero stampato.
@item @code{0}
Uno @samp{0} (zero) iniziale serve a richiedere che l'output sia
riempito con zeri (invece che con spazi), prima delle cifre significative.
Questo si applica solo ai formati di output di tipo numerico.
Questo @dfn{flag} ha un effetto solo se la larghezza del campo @`e maggiore
di quella del valore da stampare.
@item @code{'}
Un carattere di apice singolo o un apostrofo @`e un'estensione POSIX allo
standard ISO C.
Indica che la parte intera di un valore in virgola mobile, o la parte intera
di un valore decimale intero, ha un carattere di separazione delle migliaia.
Ci@`o @`e applicabile solo alle localizzazioni che prevedono un tale carattere.
Per esempio:
@example
$ @kbd{cat migliaia.awk} @ii{Visualizza il programma sorgente}
@print{} BEGIN @{ printf "%'d\n", 1234567 @}
$ @kbd{LC_ALL=C gawk -f migliaia.awk}
@print{} 1234567 @ii{Risultato nella localizzazione} "C"
$ @kbd{LC_ALL=en_US.UTF-8 gawk -f migliaia.awk}
@print{} 1,234,567 @ii{Risultato nella localizzazione UTF inglese americana}
@end example
@noindent
Per maggiori informazioni relative a localizzazioni e internazionalizzazioni,
si veda @ref{Localizzazioni}.
@quotation NOTA
Il @dfn{flag} @samp{'} @`e una funzionalit@`a interessante, ma utilizza un
carattere che @`e fonte di complicazioni, perch@'e risulta difficila da usare nei
programmi scritti direttamente sulla riga di comando. Per informazioni sui
metodi appropriati per gestire la cosa, si veda @ref{Protezione}.
@end quotation
@item @var{larghezza}
Questo @`e un numero che specifica la larghezza minima che deve occupare un
campo. L'inserimento di un numero tra il segno @samp{%} e il carattere
di controllo del formato fa s@`{@dotless{i}} che il campo si espanda a quella larghezza.
Il modo di default per fare questo @`e di aggiungere degli spazi a
sinistra. Per esempio:
@example
printf "%6s", "pippo"
@end example
@noindent
stampa @samp{@bullet{}pippo}.
il valore di @var{larghezza} indica la larghezza minima, non la massima. Se
il valore dell'elemento richiede pi@`u caratteri della @var{larghezza}
specificata, questa pu@`o essere aumentata secondo necessit@`a.
Quindi, per esempio:
@example
printf "%6s", "pippo-pluto"
@end example
@noindent
stampa @samp{pippo-pluto}.
Anteponendo un segno meno alla @var{larghezza} si richiede che l'output sia
esteso con spazi a destra, invece che a sinistra.
@item @code{.@var{precisione}}
Un punto, seguito da una costante intera
specifica la precisione da usare nella stampa.
Il tipo di precisione varia a seconda della lettera di controllo:
@table @asis
@item @code{%d}, @code{%i}, @code{%o}, @code{%u}, @code{%x}, @code{%X}
Minimo numero di cifre da stampare.
@item @code{%e}, @code{%E}, @code{%f}, @code{%F}
Numero di cifre alla destra del separatore decimale.
@item @code{%g}, @code{%G}
Massimo numero di cifre significative.
@item @code{%s}
Massimo numero di caratteri della stringa che possono essere stampati.
@end table
Quindi, l'istruzione:
@example
printf "%.4s", "foobar"
@end example
@noindent
stampa @samp{foob}.
@end table
Le funzionalit@`a di @var{larghezza} e @var{precisione} dinamiche (cio@`e,
@code{"%*.*s"}) disponibili nell'istruzione @code{printf} della libreria C sono
utilizzabili.
Invece che fornire esplicitamente una @var{larghezza} e/o una @var{precisione}
nella stringa di formato, queste sono fornite come parte della lista degli
argomenti. Per esempio:
@example
w = 5
p = 3
s = "abcdefg"
printf "%*.*s\n", w, p, s
@end example
@noindent
equivale esattamente a:
@example
s = "abcdefg"
printf "%5.3s\n", s
@end example
@noindent
Entrambi i programmi stampano @samp{@w{@bullet{}@bullet{}abc}}.
Versioni pi@`u datate di @command{awk} non consentivano questa possibilit@`a.
Dovendo usare una di queste versioni, @`e possibile simulare questa
funzionalit@`a usando la concatenazione per costruire una stringa di formato,
come per esempio:
@example
w = 5
p = 3
s = "abcdefg"
printf "%" w "." p "s\n", s
@end example
@noindent
Questo codice non @`e di facile lettura, ma funziona.
@c @cindex lint checks
@cindex debug @subentry errori fatali @subentry @code{printf}, stringhe di formato
@cindex POSIX @command{awk} @subentry stringhe di formato @code{printf}
Chi programma in C probabilmente @`e abituato a specificare modificatori
addizionali (@samp{h}, @samp{j}, @samp{l}, @samp{L}, @samp{t} e @samp{z}) nelle
stringhe di formato di @code{printf}. Questi modificatori non sono validi
in @command{awk}. La maggior parte della implementazioni di @command{awk} li
ignora senza emettere messaggi. Se si specifica l'opzione @option{--lint}
sulla riga di comando (@pxref{Opzioni}), @command{gawk} emette un messaggio
di avvertimento quando li si usa. Se si specifica l'opzione @option{--posix},
il loro uso genera un errore fatale.
@node Esempi su printf
@subsection Esempi d'uso di @code{printf}
Il seguente semplice esempio mostra
come usare @code{printf} per preparare una tabella allineata:
@example
awk '@{ printf "%-10s %s\n", $1, $2 @}' mail-list
@end example
@noindent
Questo comando
stampa i nomi delle persone (@code{$1}) nel file
@file{mail-list} come una stringa di 10 caratteri allineati a sinistra.
Stampa anche i numeri telefonici (@code{$2}) a fianco, sulla stessa riga.
Il risultato @`e una tabella allineata, contenente due colonne, di nomi e numeri
telefonici, come si pu@`o vedere qui:
@example
$ @kbd{awk '@{ printf "%-10s %s\n", $1, $2 @}' mail-list}
@print{} Amelia 555-5553
@print{} Anthony 555-3412
@print{} Becky 555-7685
@print{} Bill 555-1675
@print{} Broderick 555-0542
@print{} Camilla 555-2912
@print{} Fabius 555-1234
@print{} Julie 555-6699
@print{} Martin 555-6480
@print{} Samuel 555-3430
@print{} Jean-Paul 555-2127
@end example
In questo caso, i numeri telefonici debbono essere stampati come stringhe,
poich@'e includono un trattino. Una stampa dei numeri telefonici come numeri
semplici avrebbe visualizzato solo le prime tre cifre: @samp{555},
e questo non sarebbe stato di grande utilit@`a.
Non era necessario specificare una larghezza per i numeri telefonici poich@'e
sono nell'ultima colonnna di ogni riga. Non c'@`e bisogno di avere un
allineamento di spazi dopo di loro.
La tabella avrebbe potuto essere resa pi@`u leggibile aggiungendo
intestazioni in cima
alle colonne. Questo si pu@`o fare usando una regola @code{BEGIN}
(@pxref{BEGIN/END})
in modo che le intestazioni siano stampate una sola volta, all'inizio del
programma @command{awk}:
@example
awk 'BEGIN @{ print "Nome Numero"
print "---- ------" @}
@{ printf "%-10s %s\n", $1, $2 @}' mail-list
@end example
L'esempio precedente usa sia l'istruzione @code{print} che l'istruzione
@code{printf} nello stesso programma. Si possono ottenere gli stessi
risultati usando solo istruzioni @code{printf}:
@example
awk 'BEGIN @{ printf "%-10s %s\n", "Nome", "Numero"
printf "%-10s %s\n", "----", "------" @}
@{ printf "%-10s %s\n", $1, $2 @}' mail-list
@end example
@noindent
Stampare ogni intestazione di colonna con la stessa specifica di formato
usata per gli elementi delle colonne ci d@`a la certezza che le intestazioni
sono allineate esattamente come le colonne.
Il fatto che usiamo per tre volte la stessa specifica di formato si pu@`o
evidenziare memorizzandola in una variabile, cos@`{@dotless{i}}:
@example
awk 'BEGIN @{ format = "%-10s %s\n"
printf format, "Nome", "Numero"
printf format, "----", "------" @}
@{ printf format, $1, $2 @}' mail-list
@end example
@node Ridirezione
@section Ridirigere l'output di @code{print} e @code{printf}
@cindex output @subentry ridirezione
@cindex ridirezione dell'output
@cindex @option{--sandbox} (opzione) @subentry ridirezione dell'output con @code{print}, @code{printf}
@cindex opzione @subentry @option{--sandbox} @subentry ridirezione dell'output con @code{print}, @code{printf}
Finora, l'output di @code{print} e @code{printf} @`e stato diretto
verso lo standard output,
che di solito @`e lo schermo. Sia @code{print} che @code{printf} possono
anche inviare il loro output in altre direzioni.
@`E quel che si chiama @dfn{ridirezione}.
@quotation NOTA
Quando si specifica @option{--sandbox} (@pxref{Opzioni}),
la ridirezione dell'output verso file, @dfn{pipe} e coprocessi non @`e
consentita.
@end quotation
Una ridirezione @`e posta dopo l'istruzione @code{print} o @code{printf}.
Le ridirezioni in @command{awk} sono scritte come le ridirezioni nei
comandi della shell, l'unica differenza @`e che si trovano all'interno di
un programma @command{awk}.
@c the commas here are part of the see also
@cindex istruzione @subentry @code{print} @seealso{ridirezione dell'output}
@cindex istruzione @subentry @code{printf} @seealso{ridirezione dell'output}
Ci sono quattro forme di ridirezione dell'output:
output scritto su un file,
output aggiunto in fondo a un file,
output che fa da input a un altro comando (usando una @dfn{pipe}) e
output diretto a un coprocesso.
Vengono descritti per l'istruzione @code{print},
ma funzionano allo stesso modo per @code{printf}:
@table @code
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>} (I/O)
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>} (I/O)
@cindex operatori @subentry input/output
@item print @var{elementi} > @var{output-file}
Questa ridirezione stampa gli elementi nel file di output chiamato
@var{output-file}. Il @value{FN} @var{output-file} pu@`o essere
una qualsiasi espressione. Il suo valore @`e trasformato in una stringa e
quindi usato come
@iftex
@value{FN} (@pxrefil{Espressioni}).
@end iftex
@ifnottex
@value{FN} (@pxref{Espressioni}).
@end ifnottex
Quando si usa questo tipo di ridirezione, il file @var{output-file} viene
cancellato prima che su di esso sia stato scritto il primo record in uscita.
Le successive scritture verso lo stesso file @var{output-file} non cancellano
@var{output-file}, ma continuano ad aggiungervi record.
(Questo comportamento @`e differente da quello delle ridirezioni usate negli
script della shell.)
Se @var{output-file} non esiste, viene creato. Per esempio, ecco
come un programma @command{awk} pu@`o scrivere una lista di nomi di persone
su un file di nome @file{lista-nomi}, e una lista di numeri telefonici
su un altro file di nome @file{lista-telefoni}:
@example
$ @kbd{awk '@{ print $2 > "lista-telefoni"}
> @kbd{print $1 > "lista-nomi" @}' mail-list}
$ @kbd{cat lista-telefoni}
@print{} 555-5553
@print{} 555-3412
@dots{}
$ @kbd{cat lista-nomi}
@print{} Amelia
@print{} Anthony
@dots{}
@end example
@noindent
Ogni file in output contiene un nome o un numero su ogni riga.
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>>} (I/O)
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>>} (I/O)
@item print @var{elementi} >> @var{output-file}
Questa ridirezione stampa gli elementi in un file di output preesistente,
di nome @var{output-file}. La differenza tra questa ridirezione e quella
con un solo @samp{>} @`e che il precedente contenuto (se esiste) di
@var{output-file} non viene cancellato. Invece, l'output di @command{awk} @`e
aggiunto in fondo al file.
Se @var{output-file} non esiste, viene creato.
@cindex @code{|} (barra verticale) @subentry operatore @code{|} (I/O)
@cindex @dfn{pipe} @subentry output
@cindex output @subentry a @dfn{pipe}
@item print @var{elementi} | @var{comando}
@`E possibile inviare output a un altro programma usando una @dfn{pipe}
invece di inviarlo a un file. Questa ridirezione apre una @dfn{pipe} verso
@var{comando}, e invia i valori di @var{elementi}, tramite questa
@dfn{pipe}, a un altro processo creato per eseguire @var{comando}.
L'argomento @var{comando}, verso cui @`e rivolta la ridirezione, @`e in realt@`a
un'espressione
@command{awk}. Il suo valore @`e convertito in una stringa il cui contenuto
costituisce un comando della shell che deve essere eseguito. Per esempio,
il seguente programma produce due file, una lista non ordinata di nomi di
persone e una lista ordinata in ordine alfabetico inverso:
@ignore
10/2000:
This isn't the best style, since COMMAND is assigned for each
record. It's done to avoid overfull hboxes in TeX. Leave it
alone for now and let's hope no-one notices.
@end ignore
@example
@group
awk '@{ print $1 > "nomi.non.ordinati"
comando = "sort -r > nomi.ordinati"
print $1 | comando @}' mail-list
@end group
@end example
La lista non ordinata @`e scritta usando una ridirezione normale, mentre
la lista ordinata @`e scritta inviando una @dfn{pipe} in input al programma
di utilit@`a @command{sort}.
Il prossimo esempio usa la ridirezione per inviare un messaggio alla
mailing list @code{bug-sistema}. Questo pu@`o tornare utile se si hanno
problemi con uno @dfn{script} @command{awk} eseguito periodicamente per la
manutenzione del sistema:
@example
report = "mail bug-sistema"
print("Script awk in errore:", $0) | report
print("al record numero", FNR, "di", NOME_FILE) | report
close(report)
@end example
La funzione @code{close()} @`e stata chiamata perch@'e @`e una buona idea chiudere
la @dfn{pipe} non appena tutto l'output da inviare alla @dfn{pipe} @`e stato
inviato. @xref{Chiusura file e @dfn{pipe}}
per maggiori informazioni.
Questo esempio illustra anche l'uso di una variabile per rappresentare
un @var{file} o un @var{comando}; non @`e necessario usare sempre
una costante stringa. Usare una variabile @`e di solito una buona idea,
perch@'e (se si vuole riusare lo stesso file o comando)
@command{awk} richiede che il valore della stringa sia sempre scritto
esattamente nello stesso modo.
@cindex coprocessi
@cindex @code{|} (barra verticale) @subentry operatore @code{|&} (I/O)
@cindex operatori @subentry input/output
@cindex differenze tra @command{awk} e @command{gawk} @subentry operatori di input/output
@item print @var{elementi} |& @var{comando}
Questa ridirezione stampa gli elementi nell'input di @var{comando}.
La differenza tra questa ridirezione e quella
con la sola @samp{|} @`e che l'output da @var{comando}
pu@`o essere letto tramite @code{getline}.
Quindi, @var{comando} @`e un @dfn{coprocesso}, che lavora in parallelo al
programma @command{awk}, ma @`e al suo servizio.
Questa funzionalit@`a @`e un'estensione @command{gawk}, e non @`e disponibile in
POSIX @command{awk}.
@ifnotdocbook
@xref{Getline coprocesso},
per una breve spiegazione.
@ref{I/O bidirezionale}
per un'esposizione pi@`u esauriente.
@end ifnotdocbook
@ifdocbook
@xref{Getline coprocesso}
per una breve spiegazione.
@xref{I/O bidirezionale}
per un'esposizione pi@`u esauriente.
@end ifdocbook
@end table
Ridirigere l'output usando @samp{>}, @samp{>>}, @samp{|} o @samp{|&}
richiede al sistema di aprire un file, una @dfn{pipe} o un coprocesso solo se
il particolare @var{file} o @var{comando} che si @`e specificato non @`e gi@`a
stato utilizzato in scrittura dal programma o se @`e stato chiuso
dopo l'ultima scrittura.
@cindex debug @subentry stampare
@`E un errore comune usare la ridirezione @samp{>} per la prima istruzione
@code{print} verso un file, e in seguito usare @samp{>>} per le successive
scritture in output:
@example
# inizializza il file
print "Non v'allarmate" > "guida.txt"
@dots{}
# aggiungi in fondo al file
print "Evitate generatori di improbabilit@`a" >> "guide.txt"
@end example
@noindent
Questo @`e il modo in cui le ridirezioni devono essere usate lavorando
con la shell. Ma in @command{awk} ci@`o non @`e necessario. In casi di questo
genere, un programma dovrebbe
usare @samp{>} per tutte le istruzioni @code{print}, perch@'e il file di
output @`e aperto una sola volta.
(Usando sia @samp{>} che @samp{>>} nello stesso programma, l'output @`e prodotto
nell'ordine atteso.
Tuttavia il mischiare gli operatori per lo stesso file @`e sintomo di uno
stile di programmazione inelegante, e pu@`o causare confusione in chi legge
il programma.)
@cindex differenze tra @command{awk} e @command{gawk} @subentry limitazioni di implementazione
@cindex problemi di implementazione @subentry @command{gawk} @subentry limitazioni
@cindex @command{awk} @subentry problemi di implementazione @subentry @dfn{pipe}
@cindex @command{gawk} @subentry problemi di implementazione @subentry @dfn{pipe}
@ifnotinfo
Come visto in precedenza
(@pxref{Note su getline}),
molte
@end ifnotinfo
@ifnottex
@ifnotdocbook
@ifnothtml
Molte
@end ifnothtml
@end ifnotdocbook
@end ifnottex
tra le pi@`u vecchie implementazioni di
@command{awk} limitano il numero di @dfn{pipeline} che un programma
@command{awk} pu@`o mantenere aperte a una soltanto! In @command{gawk}, non c'@`e
un tale limite. @command{gawk} consente a un programma di
aprire tante @dfn{pipeline} quante ne consente il sistema operativo su cui
viene eseguito.
@sidebar Inviare @dfn{pipe} alla @command{sh}
@cindex shell @subentry inviare comandi tramite @dfn{pipe} alla
Una maniera particolarmente efficace di usare la ridirezione @`e quella di
preparare righe di comando da passare
come @dfn{pipe} alla shell,
@command{sh}. Per esempio, si supponga di avere una lista di file provenienti
da un sistema in cui tutti i
@value{FNS} sono memorizzari in maiuscolo, e di volerli rinominare
in modo da avere nomi tutti in
minuscolo. Il seguente programma @`e
sia semplice che efficiente:
@c @cindex @command{mv} utility
@example
@{ printf("mv %s %s\n", $0, tolower($0)) | "sh" @}
END @{ close("sh") @}
@end example
La funzione @code{tolower()} restituisce la stringa che gli viene passata
come argomento con tutti i caratteri maiuscoli convertiti in minuscolo
(@pxref{Funzioni per stringhe}).
Il programma costruisce una lista di righe di comando,
usando il programma di utilit@`a @command{mv} per rinominare i file.
Poi invia la lista alla shell per l'elaborazione.
@xref{Apici alla shell} per una funzione che pu@`o essere utile nel generare
righe di comando da passare alla shell.
@end sidebar
@node FD speciali
@section File speciali per flussi standard di dati pre-aperti
@cindex standard input
@cindex input @subentry standard
@cindex standard output
@cindex output @subentry standard
@cindex errore @subentry in output
@cindex standard error
@cindex descrittori di file
@cindex file @subentry descrittori @seeentry{descrittori di file}
I programmi in esecuzione hanno convenzionalmente tre flussi di input e
output a disposizione, gi@`a aperti per la lettura e la scrittura.
Questi sono noti come
lo @dfn{standard input}, lo @dfn{standard output} e lo @dfn{standard
error output}. A questi flussi aperti (e a tutti gli altri file aperti o
@dfn{pipe}) si fa spesso riferimento usando il termine tecnico
@dfn{descrittori di file} [FD].
Questi flussi sono, per default, associati alla tastiera e allo schermo,
ma spesso sono ridiretti, nella shell, utilizzando gli operatori
@samp{<}, @samp{<<}, @samp{>}, @samp{>>}, @samp{>&} e @samp{|}.
Lo standard error @`e tipicamente usato per scrivere messaggi di errore;
la ragione per cui ci sono due flussi distinti,
standard output e standard error, @`e per poterli ridirigere indipendentemente
l'uno dall'altro.
@cindex differenze tra @command{awk} e @command{gawk} @subentry messaggi di errore
@cindex gestione errori
@cindex errori @subentry gestione degli
Nelle tradizionali implementazioni di @command{awk}, il solo modo per
scrivere un messaggio di errore allo
standard error in un programma @command{awk} @`e il seguente:
@example
print "Ho trovato un errore grave!" | "cat 1>&2"
@end example
@noindent
Con quest'istruzione si apre una @dfn{pipeline} verso un comando della shell
che @`e in grado di accedere al flusso di standard error che eredita dal
processo @command{awk}.
@c 8/2014: Mike Brennan says not to cite this as inefficient. So, fixed.
Questo @`e molto poco elegante, e richiede anche di innescare un processo
separato. Per questo chi scrive programmi @command{awk} spesso
non usa questo metodo. Invece, invia i messaggi di errore allo
schermo, in questo modo:
@example
print "Ho trovato un errore grave!" > "/dev/tty"
@end example
@noindent
(@file{/dev/tty} @`e un file speciale fornito dal sistema operativo
ed @`e connesso alla tastiera e allo schermo. Rappresenta il
``terminale'',@footnote{``tty'' in @file{/dev/tty} @`e un'abbreviazione di
``TeleTYpe'' [telescrivente], un terminale seriale.} che nei sistemi odierni
@`e una tastiera e uno schermo, e non una @dfn{console} seriale).
Questo ha generalmente lo stesso effetto, ma non @`e sempre detto: sebbene il
flusso di standard error sia solitamente diretto allo schermo, potrebbe
essere stato
ridiretto; se questo @`e il caso, scrivere verso lo schermo non serve. In
effetti, se @command{awk} @`e chiamato da un lavoro che non @`e eseguito
interattivamente,
pu@`o non avere a disposizione alcun terminale su cui scrivere.
In quel caso, l'apertura di @file{/dev/tty} genera un errore.
@command{gawk}, BWK @command{awk}, e @command{mawk} mettono a disposizione
speciali @value{FNS} per accedere ai tre flussi standard.
Se il @value{FN} coincide con uno di questi nomi speciali, quando
@command{gawk} (o uno degli altri) ridirige l'input o l'output, usa
direttamente il descrittore di file identificato dal @value{FN}. Questi
@value{FNS} sono gestiti cos@`{@dotless{i}} in tutti i sistemi operativi nei quali
@command{gawk} @`e disponibile, e non solo in quelli che aderiscono allo
standard POSIX:
@cindex estensioni comuni @subentry file speciale @code{/dev/stdin}
@cindex estensioni comuni @subentry file speciale @code{/dev/stdout}
@cindex estensioni comuni @subentry file speciale @code{/dev/stderr}
@cindex nomi @subentry di file @subentry flussi standard in @command{gawk}
@cindex @code{/dev/@dots{}}, file speciali
@cindex file @subentry speciali @subentry @code{/dev/@dots{}}
@cindex @code{/dev/fd/@var{N}}, file speciali (in @command{gawk})
@table @file
@item /dev/stdin
Lo standard input (descrittore di file 0).
@item /dev/stdout
Lo standard output (descrittore di file 1).
@item /dev/stderr
Lo standard error output (descrittore di file 2).
@end table
Usando questa funzionalit@`a
la maniera corretta di scrivere un messaggio di errore diviene quindi:
@example
print "Ho trovato un errore grave!" > "/dev/stderr"
@end example
@cindex debug @subentry doppio apice con nomi di file
Si noti l'uso di doppi apici per racchiudere il @value{FN}.
Come per ogni altra ridirezione, il valore dev'essere una stringa.
@`E un errore comune omettere i doppi apici, il che conduce a
risultati inattesi.
@command{gawk} non tratta questi @value{FNS} come speciali quando opera
in modalit@`a di compatibilit@`a POSIX. Comunque, poich@'e BWK @command{awk}
li prevede, @command{gawk} li ammette anche quando viene
invocato con l'opzione @option{--traditional} (@pxref{Opzioni}).
@node File speciali
@section @value{FFNS} speciali in @command{gawk}
@cindex @command{gawk} @subentry nomi di file in
Oltre all'accesso a standard input, standard output e standard error,
@command{gawk} consente di accedere a ogni descrittore di file aperto.
In pi@`u, ci sono dei @value{FNS} speciali riservati per accedere a
reti TCP/IP.
@menu
* Altri file ereditati:: Accedere ad altri file aperti con
@command{gawk}.
* Reti speciali:: File speciali per comunicazioni con la rete.
* Avvertimenti speciali:: Cose a cui prestare attenzione.
@end menu
@node Altri file ereditati
@subsection Accedere ad altri file aperti con @command{gawk}
Oltre ai valori speciali di @value{FNS}
@code{/dev/stdin}, @code{/dev/stdout} e @code{/dev/stderr}
gi@`a menzionati, @command{gawk} prevede una sintassi
per accedere a ogni altro file aperto ereditato:
@table @file
@item /dev/fd/@var{N}
Il file associato al descrittore di file @var{N}. Il file indicato deve
essere aperto dal programma che inizia l'esecuzione di @command{awk}
(tipicamente la shell). Se non sono state poste in essere iniziative
speciali nella shell da cui @command{gawk} @`e stato invocato, solo i
descrittori 0, 1, e 2 sono disponibili.
@end table
I @value{FNS} @file{/dev/stdin}, @file{/dev/stdout} e @file{/dev/stderr}
sono essenzialmente alias per @file{/dev/fd/0}, @file{/dev/fd/1} e
@file{/dev/fd/2}, rispettivamente. Comunque, i primi nomi sono pi@`u
autoesplicativi.
Si noti che l'uso di @code{close()} su un @value{FN} della forma
@code{"/dev/fd/@var{N}"}, per numeri di descrittore di file
oltre il due, effettivamente chiude il descrittore di file specificato.
@node Reti speciali
@subsection File speciali per comunicazioni con la rete
@cindex reti @subentry funzionalit@`a per
@cindex TCP/IP @subentry funzionalit@`a per
I programmi @command{gawk}
possono aprire una connessione bidirezionale
TCP/IP, fungendo o da @dfn{client} o da @dfn{server}.
Questo avviene usando uno speciale @value{FN} della forma:
@example
@file{/@var{tipo-rete}/@var{protocollo}/@var{porta-locale}/@var{host-remoto}/@var{porta-remota}}
@end example
Il @var{tipo-rete} pu@`o essere @samp{inet}, @samp{inet4} o @samp{inet6}.
Il @var{protocollo} pu@`o essere @samp{tcp} o @samp{udp},
e gli altri campi rappresentano gli altri dati essenziali
necessari per realizzare una connessione di rete.
Questi @value{FNS} sono usati con l'operatore @samp{|&} per comunicare
con @w{un coprocesso}
(@pxref{I/O bidirezionale}).
Questa @`e una funzionalit@`a avanzata, qui riferita solo per completezza.
Una spiegazione esauriente sar@`a fornita nella
@ref{Reti TCP/IP}.
@node Avvertimenti speciali
@subsection Avvertimenti speciali sui @value{FNS}
Sono qui elencate alcune cose da tener presente usando i
@value{FNS} speciali forniti da @command{gawk}:
@itemize @value{BULLET}
@cindex modalit@`a compatibile di (@command{gawk}) @subentry nomi di file
@cindex nomi @subentry di file @subentry nella modalit@`a compatibile di @command{gawk}
@cindex modalit@`a POSIX
@item
Il riconoscimento dei @value{FNS} per i tre file standard pre-aperti
@`e disabilitato solo in modalit@`a POSIX.
@item
Il riconoscimento degli altri @value{FNS} speciali @`e disabilitato se
@command{gawk} @`e in modalit@`a compatibile
(o @option{--traditional} o @option{--posix};
@pxref{Opzioni}).
@item
@command{gawk} interpreta @emph{sempre}
questi @value{FNS} speciali.
Per esempio, se si usa @samp{/dev/fd/4}
per l'output, si scrive realmente sul descrittore di file 4, e non su un nuovo
descrittore di file generato duplicando (con @code{dup()}) il descrittore
file 4. Solitamente questo non ha importanza; comunque, @`e importante
@emph{non} chiudere alcun file correlato ai descrittori di file 0, 1 e 2.
Se lo si fa, il comportamente risultante @`e imprevedibile.
@end itemize
@node Chiusura file e @dfn{pipe}
@section Chiudere ridirezioni in input e in output
@cindex output @subentry file in
@cindex input @subentry chiusura
@cindex file @subentry in output @subentry chiusura di
@cindex @dfn{pipe} @subentry chiusura
@cindex coprocessi @subentry chiusura
@cindex @code{getline} (comando) @subentry coprocessi, usare da
Se lo stesso @value{FN} o lo stesso comando di shell @`e usato con @code{getline}
pi@`u di una volta durante l'esecuzione di un programma @command{awk}
(@pxref{Getline}),
il file viene aperto (o il comando viene eseguito) solo la prima volta.
A quel punto, il primo record in input @`e letto da quel file o comando.
La prossima volta che lo stesso file o comando @`e usato con @code{getline},
un altro record @`e letto da esso, e cos@`{@dotless{i}} via.
Analogamente, quando un file o una @dfn{pipe} sono aperti in output,
@command{awk} ricorda
il @value{FN} o comando a essi associato, e le successive
scritture verso lo stesso file o comando sono accodate alle precedenti
scritture.
Il file o la @dfn{pipe} rimangono aperti fino al termine dell'esecuzione
di @command{awk}.
@cindexawkfunc{close}
Questo implica che sono necessari dei passi speciali per rileggere nuovamente
lo stesso file dall'inizio, o per eseguire di nuovo un comando di shell
(invece che leggere ulteriore output dal precedente comando). La funzione
@code{close()} rende possibile fare queste cose:
@example
close(@var{NOME_FILE})
@end example
@noindent
o:
@example
close(@var{comando})
@end example
l'argomento @var{NOME_FILE} o @var{comando} pu@`o essere qualsiasi espressione,
il cui valore dev'essere @emph{esattamente} uguale alla stringa
usata per aprire il file o eseguire il comando (spazi e altri caratteri
``irrilevanti'' inclusi). Per esempio, se si apre una @dfn{pipe} cos@`{@dotless{i}}:
@example
"sort -r nomi" | getline pippo
@end example
@noindent
essa va chiusa in questo modo:
@example
close("sort -r nomi")
@end example
Una volta eseguita questa chiamata di funzione, la successiva @code{getline}
da quel file o comando, o la successiva @code{print} o @code{printf} verso quel
file o comando, riaprono il file o eseguono nuovamente il comando.
Poich@'e l'espressione da usare per chiudere un file o una @dfn{pipeline} deve
essere uguale all'espressione usata per aprire il file o eseguire il comando,
@`e buona norma usare una variabile che contenga il @value{FN} o il comando.
Il precedente esempio cambia come segue:
@example
@group
sortcom = "sort -r nomi"
sortcom | getline pippo
@end group
@group
@dots{}
close(sortcom)
@end group
@end example
@noindent
Questo aiuta a evitare nei programmi @command{awk} errori di battitura
difficili da scoprire. Queste sono alcune delle ragioni per cui @`e bene
chiudere un file di output:
@itemize @value{BULLET}
@item
Scrivere un file e rileggerlo in seguito all'interno dello stesso programma
@command{awk}. Occorre chiudere il file dopo aver finito di scriverlo, e poi
iniziare a rileggerlo con @code{getline}.
@item
Per scrivere numerosi file, uno dopo l'altro, nello stesso programma
@command{awk}. Se i file non vengono chiusi, prima o poi @command{awk} pu@`o
superare il limite di sistema per il numero di file aperti in un processo.
@`E meglio chiudere ogni file quando il programma ha finito di scriverlo.
@item
Per terminare un comando. Quando l'output @`e ridiretto usando una @dfn{pipe},
il comando che legge la @dfn{pipe} normalmente continua a tentare di leggere
input finch@'e la @dfn{pipe} rimane aperta. Spesso questo vuol dire che
il comando non pu@`o eseguire il compito a lui assegnato finch@'e la @dfn{pipe}
non viene chiusa. Per esempio, se l'output @`e ridiretto al programma
@command{mail}, il messaggio non @`e effettivamente inviato finch@'e la @dfn{pipe}
non viene chiusa.
@item
Eseguire lo stesso programma una seconda volta, con gli stessi argomenti.
Questo non equivale a fornire ulteriore input alla prima esecuzione!
Per esempio, si supponga che una programma invii tramite una @dfn{pipe}
dell'output al programma @command{mail}.
Se invia parecchie linee ridirigendole a questa @dfn{pipe} senza chiuderla,
queste costituiscono un solo messaggio di parecchie righe. Invece, se il
programma chiude la @dfn{pipe} dopo ogni riga dell'output, allora ogni riga
costituisce un messaggio separato.
@end itemize
@cindex differenze tra @command{awk} e @command{gawk} @subentry funzione @code{close()}
@cindex portabilit@`a @subentry funzione @code{close()}
@cindex funzione @subentry @code{close()} @subentry portabilit@`a
@cindex @code{close()} (funzione) @subentry portabilit@`a
Se si usano file in numero superiore a quelli che il sistema permette
di mantenere aperti,
@command{gawk} tenta di riutilizzare i file aperti disponibili fra
i @value{DF}. La possibilit@`a che @command{gawk} lo faccia dipende dalle
funzionalit@`a del sistema operativo, e quindi non @`e detto che questo riesca
sempre. @`E quindi sia una buona pratica
che un buon suggerimento per la portabilit@`a quello di usare sempre
@code{close()} sui file, una volta che si @`e finito di operare su di essi.
In effetti, se si usano molte @dfn{pipe}, @`e fondamentale che i comandi
vengano chiusi, una volta finita la loro elaborazione. Per esempio, si
consideri qualcosa del tipo:
@example
@{
@dots{}
comando = ("grep " $1 " /qualche/file | un_mio_programma -q " $3)
while ((comando | getline) > 0) @{
@var{elabora output di} comando
@}
# qui serve close(comando)
@}
@end example
Questo esempio crea una nuova @dfn{pipeline} a seconda dei dati contenuti in
@emph{ogni} record.
Senza la chiamata a @code{close()} indicata come commento, @command{awk}
genera processi-figlio per eseguire i comandi, fino a che non finisce per
esaurire i descrittori di file
necessari per creare ulteriori @dfn{pipeline}.
Sebbene ogni comando sia stato completato (come si deduce dal codice di
fine-file restituito dalla @code{getline}), il processo-figlio non @`e
terminato;@footnote{La terminologia tecnica @`e piuttosto macabra.
Il processo-figlio terminato @`e chiamato ``zombie,'' e la pulizia alla fine
dello stesso @`e chiamata ``reaping'' [mietitura].}
@c Good old UNIX: give the marketing guys fits, that's the ticket
inoltre, e questo @`e ci@`o che pi@`u ci interessa, il descrittore di file
per la @dfn{pipe} non @`e chiuso e liberato finch@'e non si chiama
@code{close()} o finch@'e il programma @command{awk} non termina.
@code{close()} non fa nulla (e non emette messaggi) se le viene fornito come
argomento una stringa che non rappresenta un file, una @dfn{pipe} o un
coprocesso che sia stato aperto mediante una ridirezione. In quel caso,
@code{close()} restituisce un codice di ritorno negativo, che indica un
errore. Inoltre, @command{gawk} imposta @code{ERRNO}
a una stringa che indica il tipo di errore.
Si noti anche che @samp{close(NOME_FILE)} non ha effetti ``magici'' sul ciclo
implicito che legge ogni record dei file indicati nella riga di comando.
Si tratta, con ogni probabilit@`a, della chiusura di un file che non era mai
stato aperto con una ridirezione,
e per questo @command{awk} silenziosamente non fa nulla, tranne impostare un
codice di ritorno negativo.
@cindex @code{|} (barra verticale) @subentry operatore @code{|&} (I/O) @subentry @dfn{pipe}, chiusura
Quando si usa l'operatore @samp{|&} per comunicare con un coprocesso,
@`e talora utile essere in grado di chiudere un lato della @dfn{pipe}
bidirezionale, senza chiudere l'altro lato.
Questo @`e possibile fornendo un secondo argomento a @code{close()}.
Come in ogni altra invocazione di @code{close()},
il primo argomento @`e il nome del comando o file speciale usato
per iniziare il coprocesso.
Il secondo argomento dovrebbe essere una stringa, con uno dei due valori
@code{"to"} [a] oppure @code{"from"} [da]. Maiuscolo/minuscolo non fa
differenza. Poich@'e questa @`e una funzionalit@`a avanzata, la trattazione @`e
rinviata alla
@ref{I/O bidirezionale},
che ne parla pi@`u dettagliatamente e fornisce un esempio.
@sidebar Usare il codice di ritorno di @code{close()}
@cindex angolo buio @subentry funzione @subentry @code{close()}
@cindex funzione @subentry @code{close()} @subentry codice di ritorno
@cindex @code{close()} (funzione) @subentry codice di ritorno
@cindex codice di ritorno @subentry funzione @code{close()}
@cindex differenze tra @command{awk} e @command{gawk} @subentry funzione @code{close()}
@cindex Unix @command{awk} @subentry funzione @code{close()} e
In molte versioni di Unix @command{awk}, la funzione @code{close()}
@`e in realt@`a un'istruzione.
@value{DARKCORNER}
@`E un errore di sintassi tentare di usare il
codice di ritorno da @code{close()}:
@example
comando = "@dots{}"
comando | getline info
retval = close(comando) # errore di sintassi in parecchi Unix awk
@end example
@cindex @command{gawk} @subentry variabile @subentry @code{ERRNO} in
@cindex variabile @subentry @code{ERRNO} @subentry con funzione @command{close()}
@cindex @code{ERRNO} (variabile) @subentry con funzione @command{close()}
@command{gawk} gestisce @code{close()} come una funzione.
Il codice di ritorno @`e @minus{}1 se l'argomento designa un file
che non era mai stato aperto con una ridirezione, o se c'@`e un problema di
sistema nella chiusura del file o del processo.
In tal caso, @command{gawk} imposta la variabile predefinita
@code{ERRNO} a una stringa che descrive il problema.
In @command{gawk}, a partire dalla @value{PVERSION} 4.2,
quando si chiude una @dfn{pipe} o un coprocesso (in input o in output),
il codice di ritorno @`e quello restituito dal comando,
come descritto in @ref{table-close-pipe-return-values}.@footnote{Prima
della @value{PVERSION} 4.2, il codice di ritorno dopo la chiusura di
una @dfn{pipe} o di un coprocesso era una cifra di due byte (16-bit),
contenente il valore restituito dalla chiamata di sistema @code{wait()}}.
Altrimenti, @`e il codice di ritorno dalla chiamata alle funzione
di sistema @code{close()} o alla funzione C @code{fclose()}
se si sta chiudendo un file in input o in output, rispettivamente.
Questo valore @`e zero se la chiusura riesce, o @minus{}1 se non riesce.
@float Tabella,table-close-pipe-return-values
@caption{Codici di ritorno dalla @code{close()} di una @dfn{pipe}}
@multitable @columnfractions .50 .50
@headitem Situazione @tab Valore restituito da @code{close()}
@item Uscita normale dal comando @tab Il codice di ritorno del comando
@item Uscita dal comando per @dfn{signal} @tab 256 + numero del segnale assassino
@item Uscita dal comando per @dfn{signal} con @dfn{dump} @tab 512 + numero del segnale assassino
@item Errore di qualsiasi tipo @tab @minus{}1
@end multitable
@end float
@cindex POSIX @subentry modalit@`a
@cindex modalit@`a POSIX
Lo standard POSIX @`e molto generico; dice che @code{close()}
restituisce zero se @`e terminata correttamente, e un valore diverso da zero
nell'altro caso. In generale,
implementazioni differenti variano in quel che restituiscono chiudendo una
@dfn{pipe}; quindi, il codice di ritorno non pu@`o essere usato in modo
portabile.
@value{DARKCORNER}
In modalit@`a POSIX (@pxref{Opzioni}), @command{gawk} restituisce solo zero
quando chiude una @dfn{pipe}.
@end sidebar
@node Continuazione dopo errori
@section Abilitare continuazione dopo errori in output
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
In @command{awk} standard, l'output con @code{print} o @code{printf}
a un file che non esiste, o qualche altro errore di I/O (come p.es.
esaurire lo spazio disponibile su disco) @`e un errore fatale (termina
l'esecuzione del programma).
@example
$ @kbd{gawk 'BEGIN @{ print "ciao" > "/file/non/esistente" @}'}
@error{} gawk: riga com.:1: fatale: non riesco a ri-dirigere a
@error{} `/file/non/esistente' (/file o directory non esistente)
@end example
@command{gawk} rende possibile accorgersi che c'@`e stato un errore,
permettendo di tentare di rimediare, o almeno di stampare un messaggio
di errore prima di terminare il programma.
@`E possibile fare questo in due modi differenti:
@itemize @bullet
@item
Per tutti i file in output, assegnando un valore qualsiasi a
@code{PROCINFO["NONFATAL"]}.
@item
Specificamente per un solo file, assegnando un valore qualsiasi a
@code{PROCINFO[@var{nome_file}, "NONFATAL"]}.
@var{nome_file} @`e il nome del file per il quale
si desidera che l'errore di output non faccia terminare il programma.
@end itemize
Una volta abilitata la continuazione dopo un errore di output, si dovr@`a
controllare la variabile @code{ERRNO} dopo ogni istruzione
@code{print} o @code{printf} diretta a quel file, per controllare che
tutto sia andato a buon fine. @`E anche una buona idea inizializzare
@code{ERRNO} a zero prima di tentare l'operazione di scrittura.
Per esempio:
@example
$ @kbd{gawk '}
> @kbd{BEGIN @{}
> @kbd{ PROCINFO["NONFATAL"] = 1}
> @kbd{ ERRNO = 0}
> @kbd{ print "ciao" > "/file/non/esistente"}
> @kbd{ if (ERRNO) @{}
> @kbd{ print("Output non riuscito:", ERRNO) > "/dev/stderr"}
> @kbd{ exit 1}
> @kbd{ @}}
> @kbd{@}'}
@error{} Output non riuscito: No such file or directory
@end example
@command{gawk} non genera un errore fatale; permette invece
al programma @command{awk} di rendersi conto del problema e di gestirlo.
Questo meccanismo si applica anche allo standard output e allo standard error.
Per lo standard output, si pu@`o usare @code{PROCINFO["-", "NONFATAL"]}
o @code{PROCINFO["/dev/stdout", "NONFATAL"]}.
Per lo standard error, occorre
usare @code{PROCINFO["/dev/stderr", "NONFATAL"]}.
@cindex @env{GAWK_SOCK_RETRIES} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{GAWK_SOCK_RETRIES}
Se si tenta di aprire un @dfn{socket} TCP/IP (@pxref{Reti TCP/IP}),
@command{gawk} tenta di farlo per un certo numero di volte.
La variabile d'ambiente @env{GAWK_SOCK_RETRIES}
(@pxref{Altre variabili d'ambiente}) consente di alterare il numero di
tentativi che @command{gawk} farebbe per default. Tuttavia,
una volta abilitata la continuazione dopo un errore di I/O per un certo
@dfn{socket}, @command{gawk} si limita a un solo tentativo,
lasciando al codice del programma @command{awk} il compito di gestire
l'eventuale problema.
@node Sommario di Output
@section Sommario.
@itemize @value{BULLET}
@item
L'istruzione @code{print} stampa una lista di espressioni separate da virgole.
Le espressioni sono separate tra loro dal valore di @code{OFS} e completate
dal valore di @code{ORS}. @code{OFMT} fornisce il formato di conversione
dei valori numerici per l'istruzione @code{print}.
@item
L'istruzione @code{printf} fornisce un controllo pi@`u preciso sull'output,
con lettere di controllo del formato per diversi tipi di dati e vari
modificatori
che cambiano il comportamento delle lettere di controllo del formato.
@item
L'output sia di @code{print} che di @code{printf} pu@`o essere ridiretto a
file, @dfn{pipe}, e coprocessi.
@item
@command{gawk} fornisce @value{FNS} speciali per accedere allo
standard input, standard output e standard error, e per comunicazioni di rete.
@item
Usare @code{close()} per chiudere file aperti, @dfn{pipe} e ridirezioni a
coprocessi.
Per i coprocessi, @`e possibile chiudere anche soltanto una delle due
direzioni di comunicazione.
@item
Normalmente se si verificano errori eseguendo istruzioni @code{print} o
@code{printf}, questi causano la fine del programma.
@command{gawk} consente di proseguire l'elaborazione anche in questo
caso, o per un errore su qualsiasi file in output, o per un errore
relativo a qualche file in particolare.
Resta a carico del programma controllare se si sono verificati errori
dopo l'esecuzione di ogni istruzione di output interessata.
@end itemize
@c EXCLUDE START
@node Esercizi su Output
@section Esercizi
@enumerate
@item
Riscrivere il programma:
@example
awk 'BEGIN @{ print "Mese Contenitori"
print "----- -----------" @}
@{ print $1, $2 @}' inventory-shipped
@end example
@noindent
come
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Separatori di output}, usando un nuovo valore per @code{OFS}.
@item
Usare l'istruzione @code{printf} per allineare le intestazioni e i dati
della tabella
per il file di esempio @file{inventory-shipped} utilizzato nella @ref{Print}.
@item
Spiegare cosa succede se si dimenticano i doppi apici ridirigendo l'output,
come nel caso che segue:
@example
BEGIN @{ print "Ho trovato un errore grave!" > /dev/stderr @}
@end example
@end enumerate
@c EXCLUDE END
@node Espressioni
@chapter Espressioni
@cindex espressioni
Le espressioni sono i mattoni fondamentali dei modelli di ricerca e delle
azioni di @command{awk}. Un'espressione genera un valore che si
pu@`o stampare, verificare o passare a una funzione. Oltre a ci@`o, un'espressione
pu@`o assegnare un nuovo valore a una variabile o a un campo usando un operatore
di assegnamento.
Un'espressione pu@`o servire come modello di ricerca o istruzione di azione a
s@'e stante. La maggior parte degli altri tipi di istruzione contengono una o
pi@`u espressioni che specificano i dati sui quali operare. Come in altri
linguaggi, le espressioni in @command{awk} possono includere variabili,
riferimenti a vettori e a costanti, e chiamate di funzione, come pure
combinazioni tra questi usando diversi operatori.
@menu
* Valori:: Costanti, variabili ed espressioni regolari.
* Tutti gli operatori:: Gli operatori di @command{gawk}.
* Valori e condizioni di verit@`a:: Determinare Vero/Falso.
* Chiamate di funzione:: Una chiamata di funzione pu@`o essere
un'espressione.
* Precedenza:: Come si nidificano i vari operatori.
* Localizzazioni:: Come la localizzazione influenza la
gestione dati.
* Sommario delle espressioni:: Sommario delle espressioni.
@end menu
@node Valori
@section Costanti, variabili e conversioni
Le espressioni sono costruite a partire da valori e dalle operazioni eseguite
su di essi. Questa @value{SECTION} descrive gli oggetti elementari
che forniscono i valori usati nelle espressioni.
@menu
* Costanti:: Costanti di tipo stringa, numeriche ed
espressioni regolari
* Usare le costanti @dfn{regexp}:: Quando e come usare una costante
specificata tramite espressioni regolari
* Variabili:: Le variabili permettono di
definire valori da usare in seguito.
* Conversione:: La conversione di stringhe in numeri
e viceversa.
@end menu
@node Costanti
@subsection Espressioni costanti
@cindex costanti @subentry tipi di
Il tipo di espressione pi@`u semplice @`e una @dfn{costante}, che ha sempre lo
stesso valore. Ci sono tre tipi di costanti: numeriche, di stringa e di
espressione regolare.
Ognuna di esse si usa nel contesto appropriato quando occorre assegnare ai
dati un valore che non dovr@`a essere cambiato. Le costanti numeriche possono
avere forme diverse, ma sono memorizzate internamente sempre allo stesso modo.
@menu
* Costanti scalari:: Costanti numeriche e stringhe.
* Numeri non-decimali:: Cosa sono i numeri ottali ed esadecimali.
* Costanti come espressioni regolari:: Costanti fornite tramite espressioni
regolari.
@end menu
@node Costanti scalari
@subsubsection Costanti numeriche e stringhe
@cindex costanti @subentry numeriche
@cindex numeriche @subentry costanti
Una @dfn{costante numerica} @`e un numero. Questo numero pu@`o essere un
numero intero, una frazione decimale o un numero in notazione scientifica
(esponenziale).@footnote{La rappresentazione interna di tutti i numeri,
compresi gli interi, usa numeri in virgola mobile a doppia precisione.
Sui sistemi pi@`u moderni, questi sono nel formato standard IEEE 754.
@xref{Calcolo con precisione arbitraria}, per maggiori informazioni.}
Ecco alcuni esempi di costanti numeriche che hanno tutte lo stesso
valore:
@example
105
1.05e+2
1050e-1
@end example
@cindex costanti @subentry stringa
@cindex stringa @subentry costante
Una @dfn{costante stringa} @`e formata da una sequenza di caratteri racchiusi tra
doppi apici. Per esempio:
@example
"pappagallo"
@end example
@noindent
@cindex differenze tra @command{awk} e @command{gawk} @subentry stringhe
@cindex stringa @subentry limitazioni della lunghezza
@cindex ASCII
rappresenta la stringa il cui contenuto @`e la parola @samp{pappagallo}.
Le stringhe in
@command{gawk} possono essere di qualsiasi lunghezza, e possono contenere
tutti i possibili caratteri ASCII a otto bit, compreso il carattere ASCII
@sc{nul} (carattere con codice zero).
Altre implementazioni di @command{awk} possono avere difficolt@`a con alcuni
particolari codici di carattere.
Alcuni linguaggi di programmazione consentono la continuazione di stringhe
lunghe su pi@`u righe, qualora una riga termini con una barra inversa.
Per esempio in C:
@example
#include
int main()
@{
printf("ciao, \
mondo\n");
return 0;
@}
@end example
@noindent
In questo caso, il compilatore C rimuove sia la barra inversa che il
carattere di avanzamento riga (@dfn{newline}),
producendo una stringa che equivale ad aver immesso
@samp{"ciao, mondo\n"}. Ci@`o torna utile quando una stringa deve contenere
una grande quantit@`a di testo.
Lo standard POSIX afferma esplicitamente che
il carattere di avanzamento riga
non @`e consentito all'interno di costanti di tipo stringa.
E in effetti, tutte le implementazioni di @command{awk} emettono un
messaggio di errore se si tenta di utilizzarlo. Per esempio:
@example
$ @kbd{gawk 'BEGIN @{ print "ciao, }
> @kbd{mondo" @}'}
@print{} gawk: riga com.:1: BEGIN @{ print "ciao,
@print{} gawk: riga com.:1: ^ stringa non terminata
@print{} gawk: riga com.:1: BEGIN @{ print "ciao,
@print{} gawk: riga com.:1: ^ syntax error
@end example
@cindex angolo buio @subentry stringhe @subentry continuazione su pi@`u righe
@cindex stringa @subentry continuazione su pi@`u righe
@cindex differenze tra @command{awk} e @command{gawk} @subentry stringhe
Sebbene POSIX non definisca cosa succede usando un carattere
protetto di avanzamento riga, come nell'esempio in linguaggio C
visto sopra, tutte le versioni di @command{awk} consentono di
farlo. Sfortunatamente, quello che una particolare versione di
@command{awk} fa con una tale stringa non @`e uniforme.
@value{DARKCORNER} @command{gawk}, @command{mawk}, e
OpenSolaris POSIX @command{awk} (@pxref{Altre versioni})
tolgono sia la barra inversa che il carattere di
avanzamento riga, come avviene nel linguaggio C:
@example
$ @kbd{gawk 'BEGIN @{ print "ciao, \}
> @kbd{mondo" @}'}
@print{} ciao, mondo
@end example
@cindex modalit@`a POSIX
In modalit@`a POSIX (@pxref{Opzioni}), @command{gawk} non consente
caratteri protetti di avanzamento riga. Altrimenti, il
comportamento @`e quello descritto sopra.
BKW @command{awk} e BusyBox @command{awk}
tolgono la barra inversa, ma lasciano indisturbato il carattere
di avanzamento riga, che fa quindi parte della stringa:
@example
$ @kbd{nawk 'BEGIN @{ print "ciao, \}
> @kbd{mondo" @}'}
@print{} ciao,
@print{} mondo
@end example
@node Numeri non-decimali
@subsubsection Numeri ottali ed esadecimali
@cindex ottali @subentry numeri
@cindex esadecimali @subentry numeri
@cindex numeri @subentry ottali
@cindex numeri @subentry esadecimali
In @command{awk}, tutti i numeri sono espressi nel sistema decimale (cio@`e a
base 10).
Molti altri linguaggi di programmazione consentono di specificare i numeri in
altre basi, spesso in ottale (base 8) e in esadecimale (base 16).
Nel sistema ottale i numeri hanno la sequenza 0, 1, 2, 3, 4, 5, 6, 7, 10, 11,
12, e cos@`{@dotless{i}} via. Come @samp{11} decimale @`e una volta 10 pi@`u 1, cos@`{@dotless{i}}
@samp{11} ottale @`e una volta 8 pi@`u 1. Questo equivale a 9 nel sistema decimale.
Nell'esadecimale ci sono 16 cifre. Poich@'e l'usuale sistema numerico decimale
ha solo dieci cifre (@samp{0}--@samp{9}), le lettere da
@samp{a} a @samp{f} rappresentano le cifre ulteriori.
(normalmente @`e irrilevante se le lettere sono maiuscole o minuscole; gli
esadecimali @samp{a} e @samp{A} hanno lo stesso valore).
Cos@`{@dotless{i}}, @samp{11} esadecimale @`e 1 volta 16 pi@`u 1,
il che equivale a 17 decimale.
Guardando solamente un @samp{11} puro e semplice, non si capisce in quale base
sia. Cos@`{@dotless{i}}, in C, C++, e in altri linguaggi derivati da C,
@c such as PERL, but we won't mention that....
c'@`e una speciale notazione per esprimere la base.
I numeri ottali iniziano con uno @samp{0},
e i numeri esadecimali iniziano con uno @samp{0x} o @samp{0X}:
@table @code
@item 11
Valore decimale 11
@item 011
11 ottale, valore decimale 9
@item 0x11
11 esadecimale, valore decimale 17
@end table
Quest'esempio mostra le differenze:
@example
$ @kbd{gawk 'BEGIN @{ printf "%d, %d, %d\n", 011, 11, 0x11 @}'}
@print{} 9, 11, 17
@end example
Poter usare costanti ottali ed esadecimali nei propri programmi @`e molto utile
quando si lavora con dati che non possono essere rappresentati
convenientemente come caratteri o come numeri regolari, come i dati binari di
vario tipo.
@cindex @command{gawk} @subentry numeri ottali e
@cindex @command{gawk} @subentry numeri esadecimali e
@command{gawk} permette l'uso di costanti ottali ed esadecimali nel testo di
un programma. Comunque, se numeri non-decimali sono presenti tra i dati in
input, essi non sono trattati in maniera speciale; trattarli in modo speciale
per default significherebbe che vecchi programmi @command{awk} produrrebbero
risultati errati.
(Se si vuole che i numeri siano trattati in maniera speciale, si deve
specificare l'opzione da riga di comando
@option{--non-decimal-data};
@pxref{Dati non decimali}.)
Se si devono gestire dati ottali o esadecimali,
si pu@`o usare la funzione @code{strtonum()}
(@pxref{Funzioni per stringhe})
per convertire i dati in numeri.
La maggior parte delle volte, le costanti ottali o esadecimali si usano quando
si lavora con le funzioni predefinite di manipolazione di bit;
si veda @ref{Funzioni a livello di bit}
per maggiori informazioni.
Diversamente da alcune tra le prime implementazioni di C, @samp{8} e @samp{9}
non sono cifre valide nelle costanti ottali. Per esempio, @command{gawk}
tratta @samp{018} come un 18 decimale:
@example
$ @kbd{gawk 'BEGIN @{ print "021 @`e", 021 ; print 018 @}'}
@print{} 021 @`e 17
@print{} 18
@end example
@cindex modalit@`a compatibile di (@command{gawk}) @subentry numeri ottali
@cindex numeri @subentry ottali @subentry nella modalit@`a compatibile di (@command{gawk})
@cindex modalit@`a compatibile di (@command{gawk}) @subentry numeri esadecimali
@cindex numeri @subentry esadecimali @subentry nella modalit@`a compatibile di (@command{gawk})
@cindex compatibile @subentry modalit@`a (@command{gawk}) @subentry numeri ottali
@cindex compatibile @subentry modalit@`a (@command{gawk}) @subentry numeri esadecimali
Le costanti ottali ed esadecimali nel codice sorgente sono un'estensione di
@command{gawk}. Se @command{gawk} @`e in modalit@`a compatibile
(@pxref{Opzioni}),
non sono disponibili.
@sidebar La base di una costante non influisce sul suo valore
Una volta che una costante numerica @`e stata
convertita internamente in un numero [decimale],
@command{gawk} non considera pi@`u
la forma originale della costante; viene sempre usato il valore
interno. Questo ha delle precise conseguenze per la conversione dei
numeri in stringhe:
@example
$ @kbd{gawk 'BEGIN @{ printf "0x11 vale <%s>\n", 0x11 @}'}
@print{} 0x11 vale <17>
@end example
@end sidebar
@node Costanti come espressioni regolari
@subsubsection Costanti fornite tramite espressioni regolari
@cindex @dfn{regexp} @subentry costanti
@cindex costanti @subentry @dfn{regexp}
@cindex @code{~} (tilde) @subentry operatore @code{~}
@cindex tilde (@code{~}) @subentry operatore @code{~}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!~}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!~}
Una @dfn{costante regexp} @`e la descrizione di un'espressione regolare
delimitata
da barre, come @code{@w{/^inizio e fine$/}}. La maggior parte delle
@dfn{regexp} usate nei programmi @command{awk} sono costanti, ma gli operatori
di confronto @samp{~} e @samp{!~} possono confrontare anche @dfn{regexp}
calcolate o dinamiche (che tipicamente sono solo stringhe ordinarie o
variabili che contengono un'espressione regolare, ma potrebbero anche essere
espressioni pi@`u complesse).
@node Usare le costanti @dfn{regexp}
@subsection Usare espressioni regolari come costanti
Le costanti @dfn{regexp} sono costituite da testo che descrive un'espressione
regolare, racchiusa fra barre (come p.e. @code{/la +risposta/}).
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} tratta del comportamento di tali costanti in
POSIX @command{awk} e in @command{gawk}, e prosegue descrivendo le
@dfn{costanti @dfn{regexp} fortemente tipizzate}, che sono
un'estensione @command{gawk}.
@menu
* Costanti @dfn{regexp} normali:: Costanti @dfn{regexp} normali in
@command{awk}.
* Costanti @dfn{regexp} forti:: Costanti @dfn{regexp} fortemente tipizzate.
@end menu
@node Costanti @dfn{regexp} normali
@subsubsection Costanti @dfn{regexp} normali in @command{awk}.
@cindex angolo buio @subentry costanti @dfn{regexp}
Quand'@`e usata a destra degli operatori @samp{~} o @samp{!~},
una costante @dfn{regexp} rappresenta semplicemente l'espressione regolare che
dev'essere confrontata. Comunque, le costanti @dfn{regexp} (come @code{/pippo/})
possono essere usate come semplici espressioni.
Quando una
costante @dfn{regexp} compare da sola, ha lo stesso significato di quando
compare in un criterio di ricerca (cio@`e @samp{($0 ~ /pippo/)}).
@value{DARKCORNER}
@xref{Espressioni come criteri di ricerca}.
Ci@`o vuol dire che i due frammenti di codice seguenti:
@example
if ($0 ~ /barfly/ || $0 ~ /camelot/)
print "trovato"
@end example
@noindent
e:
@example
if (/barfly/ || /camelot/)
print "trovato"
@end example
@noindent
sono esattamente equivalenti.
Una conseguenza piuttosto bizzarra di questa regola @`e che la seguente
espressione booleana @`e valida, ma non fa quel che probabilmente l'autore
si aspettava:
@example
# Notare che /pippo/ @`e alla @emph{sinistra} della ~
if (/pippo/ ~ $1) print "trovato pippo"
@end example
@c @cindex automatic warnings
@c @cindex warnings, automatic
@cindex @command{gawk} @subentry costanti @dfn{regexp} e
@cindex costanti @subentry @dfn{regexp} @subentry in @command{gawk}
@noindent
Questo codice ``ovviamente'' intende verificare se @code{$1} contiene
l'espressione regolare @code{/pippo/}. Ma in effetti l'espressione
@samp{/pippo/ ~ $1} significa realmente @samp{($0 ~ /pippo/) ~ $1}. In altre
parole, prima confronta il record in input con l'espressione regolare
@code{/pippo/}. Il risultato @`e zero o uno, a seconda che il confronto dia esito
positivo o negativo. Questo risultato
@`e poi confrontato col primo campo nel record.
Siccome @`e improbabile che qualcuno voglia mai fare realmente questo genere di
test, @command{gawk} emette un avvertimento quando vede questo costrutto in
un programma.
Un'altra conseguenza di questa regola @`e che l'istruzione di assegnamento:
@example
confronta = /pippo/
@end example
@noindent
assegna zero o uno alla variabile @code{confronta}, a seconda
del contenuto del record in input corrente.
@cindex differenze tra @command{awk} e @command{gawk} @subentry costanti @dfn{regexp}
@cindex angolo buio @subentry costanti @dfn{regexp} @subentry come argomenti a funzioni definite dall'utente
@cindexgawkfunc{gensub}
@cindexawkfunc{sub}
@cindexawkfunc{gsub}
Le espressioni regolari costanti possono essere usate anche come primo
argomento delle
funzioni @code{gensub()}, @code{sub()}, e @code{gsub()}, come secondo argomento
della funzione @code{match()},
e come terzo argomento delle funzioni @code{split()} e @code{patsplit()}
(@pxref{Funzioni per stringhe}).
Le moderne implementazioni di @command{awk}, incluso @command{gawk}, permettono
di usare come terzo argomento di @code{split()} una costante @dfn{regexp}, ma
alcune implementazioni pi@`u vecchie non lo consentono.
@value{DARKCORNER}
Poich@'e alcune funzioni predefinite accettano costanti @dfn{regexp} come
argomenti, pu@`o generare confusione l'uso di costanti @dfn{regexp} come
argomenti di funzioni definite dall'utente
(@pxref{Funzioni definite dall'utente}). Per esempio:
@example
@group
function mysub(modello, sostituzione, stringa, globale)
@{
if (globale)
gsub(modello, sostituzione, stringa)
else
sub(modello, sostituzione, stringa)
return stringa
@}
@end group
@group
@{
@dots{}
text = "salve! salve a te!"
mysub(/salve/, "ciao", text, 1)
@dots{}
@}
@end group
@end example
@c @cindex automatic warnings
@c @cindex warnings, automatic
In quest'esempio, il programmatore vuol passare una costante @dfn{regexp} alla
funzione definita dall'utente @code{mysub()}, che a sua volta la passa o a
@code{sub()} o a @code{gsub()}. Comunque, quel che realmente succede @`e che
al parametro @code{modello} @`e assegnato un valore di uno o zero, a seconda
che @code{$0} corrisponda a @code{/salve/} o no.
@command{gawk} emette un avvertimento quando vede una costante @dfn{regexp}
usata come parametro di una funzione definita dall'utente, poich@'e
passare un valore vero/falso in questo modo probabilmente non @`e quello che
si intendeva fare.
@node Costanti @dfn{regexp} forti
@subsubsection Costanti @dfn{regexp} fortemente tipizzate
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Come visto
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ifdocbook
@value{SECTION}
@end ifdocbook
precedente,
le costanti @dfn{regexp} (@code{/@dots{}/}) hanno uno strano posto nel
linguaggio @command{awk}. In molti contesti, si comportano come
un'espressione:
@samp{$0 ~ /@dots{}/}. In altri contesti, denotano solo una @dfn{regexp} da
individuare. In nessun caso esse sono davvero ``cittadine di serie A'' del
linguaggio. Ovvero, non @`e possibile definire una variabile scalare il cui
tipo sia ``@dfn{regexp}'' nello stesso senso in cui si pu@`o definire una
variabile che sia un numero o una stringa:
@example
num = 42 @ii{Variabile numerica}
str = "hi" @ii{Variabile di tipo stringa}
re = /pippo/ @ii{Errore!} re @ii{@`e il risultato di} $0 ~ /pippo/
@end example
Per alcuni casi di uso pi@`u avanzati,
sarebbe bello poter avere costanti @dfn{regexp} che sono
@dfn{fortemente tipizzate}; in altre parole, che sostituiscono
una @dfn{regexp} utile per effettuare dei confronti,
e non una semplice espressione regolare.
@cindex valori @subentry @dfn{regexp}
@command{gawk} prevede questa funzionalit@`a. Un'espressione regolare
fortemente tipizzata @`e molto simile a un'espressione regolare normale,
tranne per il fatto di essere preceduta dal simbolo @samp{@@}:
@example
re = @@/foo/ @ii{variabile @dfn{regexp} fortemente tipizzata}
@end example
Le variabili @dfn{regexp} fortemente tipizzate @emph{non possono} essere
usate in ogni istruzione in cui compare un'espressione regolare normale.
perch@'e ci@`o renderebbe il linguaggio ancora pi@`u fuorviante.
Queste espressioni possono essere usate solo in alcuni contesti:
@itemize @bullet
@item
Sul lato destro degli operatori @samp{~} e @samp{!~}:
@samp{qualche_variabile ~ @@/foo/}
(@pxref{Uso di @dfn{regexp}}).
@item
Nella parte @code{case} di un'istruzione @code{switch}
(@pxref{Istruzione switch}).
@item
Come argomento in una delle funzioni predefinite che possono utilizzare
costanti @dfn{regexp}:
@code{gensub()},
@code{gsub()},
@code{match()},
@code{patsplit()},
@code{split()}
e
@code{sub()}
(@pxref{Funzioni per stringhe}).
@item
Come parametro in una chiamata a una funzione definita dall'utente
(@pxref{Funzioni definite dall'utente}).
@item
Come valore restituito da una funzione definita dall'utente.
@item
Sul lato destro di un assegnamento di variabile:
@samp{qualche_variabile = @@/foo/}.
In tal caso, @code{qualche_variabile} @`e di tipo @dfn{regexp}.
Inoltre, @code{qualche_variabile}
pu@`o essere usata con gli operatori @samp{~} e @samp{!~}, passata a una
delle funzioni predefinite sopra elencate o passata come parametro
a una funzione definita dall'utente.
@end itemize
Si pu@`o usare la funzione predefinita @code{typeof()}
(@pxref{Funzioni per i tipi})
per determinare se un parametro passato a una funzione
@`e una variabile di tipo @dfn{regexp}.
La vera efficacia di questa funzionalit@`a consiste nella capacit@`a di creare
variabili il cui tipo @`e @dfn{regexp}. Tali variabili possono essere passate
a funzioni definite dall'utente, senza gli inconvenenti che si hanno usando
espressioni regolari calcolate, a partire da stringhe o da costanti di tipo
stringa. Queste variabili possono anche essere passate utilizzando chiamate
indirette a funzioni (@pxref{Chiamate indirette}) e alle funzioni predefinite
che accettano costanti di tipo @dfn{regesp}.
Quando sono usate per effettuare conversioni numeriche, le variabili
@dfn{regexp} fortemente tipizzate vengono convertite alla cifra zero.
Quando sono usate per effettuare conversioni a stringhe, vengono convertite
al valore di stringa del testo della @dfn{regexp} originale.
@node Variabili
@subsection Variabili
@cindex variabili @subentry definite dall'utente
@cindex definite dall'utente @subentry @dfn{Si veda} variabili definite dall'utente
Le @dfn{variabili} consentono di memorizzare valori in un certo punto di un
programma, per usarli pi@`u tardi in un'altra parte del programma. Le variabili
possono essere gestite interamente all'interno del testo del programma, ma
ad esse possono essere assegnati valori sulla riga di comando, in fase di
invocazione di @command{awk}.
@menu
* Usare variabili:: Usare variabili nei propri programmi.
* Opzioni di assegnamento:: Impostare variabili dalla riga di
comando, e un sommario della sintassi
della riga di comando.
Questo @`e un metodo di input avanzato.
@end menu
@node Usare variabili
@subsubsection Usare variabili in un programma
Le variabili permettono di dare nomi ai valori e di far riferimento ad essi in
un secondo momento. Alcune variabili sono gi@`a state usate in molti degli
esempi.
Il nome di una variabile dev'essere una sequenza di lettere, cifre o trattini
bassi, e non deve iniziare con una cifra.
Qui, una @dfn{lettera} @`e una qualsiasi delle 52 lettere maiuscole e minuscole
dell'alfabeto inglese. Altri caratteri che possono essere definiti come
lettere in localizzazioni non inglesi non sono validi nei nomi di variabile.
Il maiuscolo o minuscolo sono significativi nei nomi di variabile;
@code{a} e @code{A} sono variabili diverse.
Un nome di variabile @`e un'espressione valida in se stessa; rappresenta il
valore corrente della variabile. I valori delle variabili possono essere
modificati tramite @dfn{operatori di assegnamento}, @dfn{operatori di
incremento} e @dfn{operatori di decremento}
(@xref{Operatori di assegnamento}).
Inoltre, le funzioni @code{sub()} e @code{gsub()} possono cambiare il valore
di una variabile e le funzioni
@code{match()}, @code{split()}, e @code{patsplit()} possono cambiare il
contenuto dei loro parametri che sono
costituiti da vettori
(@pxref{Funzioni per stringhe}).
@cindex variabili @subentry predefinite
@cindex variabili @subentry inizializzazione
Alcune variabili hanno un significato speciale predefinito, come @code{FS}
(il separatore di campo) e @code{NF} (il numero di campi nel record di input
corrente). @xref{Variabili predefinite} per un elenco delle variabili
predefinite. Queste variabili predefinite possono essere usate e possono
ricevere assegnamenti come tutte le altre variabili, ma i loro valori sono
anche usati o cambiati automaticamente da @command{awk}. Tutti i nomi delle
variabili predefinite sono in caratteri maiuscoli.
Alle variabili in @command{awk} possono essere assegnati valori numerici o
valori di stringa. Il tipo di valore che una variabile contiene pu@`o cambiare
durante la vita di un programma. Per default, le variabili sono inizializzate
alla stringa nulla, che vale zero se viene convertita in un numero. Non c'@`e
alcuna
necessit@`a di inizializzare esplicitamente una variabile in @command{awk},
come invece occorre fare in C e nella maggior parte dei linguaggi
tradizionali.
@node Opzioni di assegnamento
@subsubsection Assegnare una variabile dalla riga di comando
@cindex variabili @subentry assegnare da riga di comando
@cindex riga di comando @subentry variabili @subentry assegnare da
Si pu@`o impostare qualsiasi variabile @command{awk} includendo un
@dfn{assegnamento di variabile} tra gli argomenti sulla riga di comando quando
viene invocato @command{awk} (@pxref{Altri argomenti}).
Tale assegnamento ha la seguente forma:
@example
@var{variabile}=@var{testo}
@end example
@cindex @option{-v} (opzione)
@cindex opzione @subentry @option{-v}
@noindent
Con questo assegnamento, una variabile viene impostata o all'inizio
dell'esecuzione di @command{awk} o tra la lettura di un file in input e il
successivo file in input.
Quando l'assegnamento @`e preceduto dall'opzione @option{-v},
come nel seguente esempio:
@example
-v @var{variabile}=@var{testo}
@end example
@noindent
la variabile @`e impostata proprio all'inizio, ancor prima che sia eseguita la
regola @code{BEGIN}. L'opzione @option{-v} e il suo assegnamento
deve precedere tutti gli argomenti @value{FN}, e anche il testo del programma.
(@xref{Opzioni} per maggiori informazioni sull'opzione
@option{-v}.)
In alternativa, l'assegnamento di variabile @`e effettuata in un momento
determinato
dalla posizione dell'opzione tra gli argomenti "file in input", cio@`e dopo
l'elaborazione del precedente argomento "file in input". Per esempio:
@example
awk '@{ print $n @}' n=4 inventory-shipped n=2 mail-list
@end example
@noindent
stampa il valore del campo numero @code{n} per tutti i record in input. Prima
che venga letto il primo file, la riga di comando imposta la variabile @code{n}
al valore quattro. Questo fa s@`{@dotless{i}} che venga stampato il quarto campo delle righe
del file @file{inventory-shipped}. Dopo la fine del primo file, ma prima
che inizi il secondo file, @code{n} viene impostato a due, e quindi poi
viene stampato il secondo campo delle righe di @file{mail-list}:
@example
$ @kbd{awk '@{ print $n @}' n=4 inventory-shipped n=2 mail-list}
@print{} 15
@print{} 24
@dots{}
@print{} 555-5553
@print{} 555-3412
@dots{}
@end example
@cindex angolo buio @subentry argomenti da riga di comando
Gli argomenti da riga di comando sono resi disponibili dal programma
@command{awk} nel vettore @code{ARGV} per poter essere esaminati esplicitamente
(@pxref{ARGC e ARGV}).
@command{awk} elabora i valori degli assegnamenti da riga di comando per
sequenze di protezione
(@pxref{Sequenze di protezione}).
@value{DARKCORNER}
Le variabili assegnate sulla riga di comando (sia tramite l'opzione
@option{-v} che senza) sono trattate come stringhe. Quando tali variabili
sono usate come numeri, viene effettuata la normale conversione automatica
da stringhe a numeri, e ogni cosa ``funziona come deve''.
Peraltro, @command{gawk} supporta variabili di tipo ``regexp''.
Si possono assegnare valori a variabili di questo tipo usando la
sintassi seguente:
@example
gawk -v 're1=@@/pippo|pluto/' '@dots{}' /percorso/al/file1 're2=@@/ciao|salve/' /percorso/al/file2
@end example
@noindent
Le costanti @dfn{regexp} fortemente tipizzate sono un'altra
funzionalit@`a avanzata disponibile
(@pxref{Costanti @dfn{regexp} forti}).
Sono ricordate qui solo per completezza.
@node Conversione
@subsection Conversione di stringhe e numeri
Le conversioni di numeri in stringhe e di stringhe in numeri sono generalmente
semplici. Ci possono essere delle sottigliezze che bisogna tenere presenti;
questa @value{SECTION} tratta di quest'importante sfaccettatura di @command{awk}.
@menu
* Stringhe e numeri:: Come @command{awk} converte tra
stringhe e numeri.
* Localizzazione e conversioni:: Come la localizzazione pu@`o influire
sulle conversioni.
@end menu
@node Stringhe e numeri
@subsubsection Come @command{awk} converte tra stringhe e numeri
@cindex conversione @subentry da stringa a numero
@cindex stringa @subentry conversione
@cindex numeri @subentry conversione in stringhe
@cindex conversione @subentry da numero a stringa
Le stringhe sono convertite in numeri e i numeri sono convertiti in stringhe,
se il contesto del programma @command{awk} lo richiede. Per esempio, se il
valore di @code{pippo} o @code{pluto} nell'espressione @samp{pippo + pluto}
@`e una stringa, viene convertita in un numero prima di eseguire l'addizione.
Se in una concatenazione di stringhe ci sono valori numerici, questi sono
convertiti in stringhe. Si consideri il seguente esempio:
@example
@group
due = 2; tre = 3
print (due tre) + 4
@end group
@end example
@noindent
Stampa il valore (numerico) di 27. I valori numerici delle
variabili @code{due} e @code{tre} sono convertiti in stringhe e
concatenati insieme. La stringa risultante @`e riconvertita nel
numero 23, al quale poi viene aggiunto 4.
@cindex stringa nulla @subentry conversione da tipo numerico a tipo stringa
@cindex conversione @subentry di tipo di variabile
@cindex variabili @subentry conversione di tipo
Se, per qualche ragione, si vuole forzare la conversione di un numero in
una stringa, basta concatenare a quel numero la stringa nulla, @code{""}.
Per forzare la conversione di una stringa in un numero, basta aggiungere zero
a quella stringa. Una stringa viene convertita in un numero interpretando
qualsiasi prefisso numerico della stringa come numero:
@code{"2.5"} si converte in 2.5, @code{"1e3"} si converte in 1000, e
@code{"25fix"} ha un valore numerico di 25.
Le stringhe che non possono essere interpretate come numeri validi vengono
convertite al valore zero.
@cindex @code{CONVFMT} (variabile)
Il modo esatto in cui i numeri sono convertiti in stringhe @`e controllato dalla
variabile predefinita di @command{awk} @code{CONVFMT}
(@pxref{Variabili predefinite}). I numeri vengono convertiti usando la
funzione @code{sprintf()}
con @code{CONVFMT} come specificatore di formato
(@pxref{Funzioni per stringhe}).
Il valore di default di @code{CONVFMT} @`e @code{"%.6g"}, che crea un valore con
un massimo di sei cifre significative. Per alcune applicazioni potrebbe essere
opportuno cambiare questo valore per ottenere una maggiore precisione.
Sulla maggior parte delle macchine moderne
normalmente bastano 17 cifre per esprimere esattamente il valore di un numero
in virgola mobile.@footnote{Per casi eccezionali possono essere richieste fino
a 752 cifre (!), non sembra che sia il caso di preoccuparsene qui.}
@cindex angolo buio @subentry variabile @subentry @code{CONVFMT}
Si possono avere strani risultati se si imposta @code{CONVFMT} a una stringa
che non indica a @code{sprintf()} come formattare i numeri in virgola mobile
in un modo utile. Per esempio, se ci si dimentica la @samp{%} nel formato,
@command{awk} converte tutti i numeri alla stessa stringa costante.
Come caso particolare, per un numero intero, il risultato della conversione
a una stringa @`e @emph{sempre} un numero intero, indipendentemente da quale
sia il valore di @code{CONVFMT}. Dato il seguente fammento di codice:
@example
CONVFMT = "%2.2f"
a = 12
b = a ""
@end example
@noindent
@code{b} ha valore @code{"12"}, non @code{"12.00"}.
@value{DARKCORNER}
@sidebar @command{awk} prima di POSIX usava @code{OFMT} per la conversione di stringhe
@cindex POSIX @command{awk} @subentry @code{OFMT} (variabile)
@cindex @code{OFMT} (variabile)
@cindex portabilit@`a @subentry nuovo @command{awk} vs.@: vecchio @command{awk}
@cindex @command{awk} @subentry nuovo vs.@: vecchio @subentry variabile @code{OFMT}
Prima dello standard POSIX, @command{awk} usava il valore di @code{OFMT} per
convertire i numeri in stringhe. @code{OFMT} specifica il formato di output da
usare per la stampa dei numeri con @code{print}. @code{CONVFMT} fu introdotto
per separare la semantica della conversione dalla semantica della stampa. Sia
@code{CONVFMT} che @code{OFMT} hanno lo stesso valore di dafault:
@code{"%.6g"}. Nella stragrande maggioranza dei casi, i vecchi programmi di
@command{awk} non cambiano questo comportamento.
@xref{Print} per maggiori informazioni sull'istruzione @code{print}.
@end sidebar
@node Localizzazione e conversioni
@subsubsection Le localizzazioni possono influire sulle conversioni
Il luogo dove si @`e pu@`o avere importanza quando si tratta di convertire numeri e
stringhe. La lingua e i caratteri --- la @dfn{localizzazione} --- possono
influire sui formati numerici. In particolare, per i programmi @command{awk},
influiscono sui caratteri separatore decimale e separatore delle migliaia.
La localizzazione @code{"C"}, e la maggior parte delle localizzazioni inglesi,
usano il punto (@samp{.}) come separatore decimale e non prevedono un
separatore delle
migliaia. Tuttavia, molte (se non la maggior parte) delle localizzazioni
europee e non inglesi usano la virgola (@samp{,}) come separatore dei decimali.
Le localizzazioni europee spesso usano o lo spazio o il punto come separatore
delle migliaia, all'occorrenza.
@cindex angolo buio @subentry carattere di separazione dei decimali nelle localizzazioni
Lo standard POSIX prevede che @command{awk} usi sempre il punto come separatore
dei decimali nel codice sorgente del programma @command{awk}, e per
gli assegnamenti di variabile da riga di comando (@pxref{Altri argomenti}).
Tuttavia, nell'interpretazione dei dati in input, per l'output di
@code{print} e @code{printf}, e per la conversione da numeri a stringhe,
viene usato il
separatore decimale locale. @value{DARKCORNER} In ogni caso, i numeri nel
codice sorgente e nei dati di input non possono avere un separatore delle
migliaia. Di seguito sono riportati alcuni esempi che illustrano la differenza
di comportamento, su un sistema GNU/Linux:
@example
$ @kbd{export POSIXLY_CORRECT=1} @ii{Forzare aderenza a standard POSIX}
$ @kbd{gawk 'BEGIN @{ printf "%g\n", 3.1415927 @}'}
@print{} 3.14159
$ @kbd{LC_ALL=en_DK.utf-8 gawk 'BEGIN @{ printf "%g\n", 3.1415927 @}'}
@print{} 3,14159
$ @kbd{echo 4,321 | gawk '@{ print $1 + 1 @}'}
@print{} 5
$ @kbd{echo 4,321 | LC_ALL=en_DK.utf-8 gawk '@{ print $1 + 1 @}'}
@print{} 5,321
@end example
@noindent
La localizzazione @code{en_DK.utf-8} @`e per l'inglese in Danimarca, dove
le virgole fungono da separatore decimale. Nella localizzazione @code{"C"}
normale, @command{gawk} tratta @samp{4,321} come 4, mentre nella localizzazione
danese @`e trattato come numero completo comprendente la parte frazionaria,
4.321.
@cindex modalit@`a POSIX
Alcune delle prime versioni di @command{gawk} si conformavano completamente con
quest'aspetto dello standard. Tuttavia, molti utenti di localizzazioni non
inglesi si lamentavano di questo comportamento, perch@'e i loro dati usavano il
punto come separatore decimale, per cui fu ripristinato il comportamento di
default che usava il punto come carattere di separazione decimale. Si pu@`o
usare l'opzione @option{--use-lc-numeric} (@pxref{Opzioni}) per forzare
@command{gawk} a usare il carattere separatore decimale della localizzazione.
(@command{gawk} usa il separatore decimale della localizzazione anche quando
@`e in modalit@`a POSIX, o con l'opzione @option{--posix} o con la variabile
d'ambiente @env{POSIXLY_CORRECT}, come appena visto.)
@ref{table-locale-affects} descrive i casi in cui si usa il separatore decimale
locale e quando si usa il punto. Alcune di queste funzionalit@`a non sono state
ancora descritte.
@float Tabella,table-locale-affects
@caption{Separatore decimale locale o punto}
@multitable @columnfractions .15 .25 .45
@headitem Funzione @tab Default @tab @option{--posix} o @option{--use-lc-numeric}
@item @code{%'g} @tab Usa la localizzazione @tab Usa la localizzazione
@item @code{%g} @tab Usa il punto @tab Usa la localizzazione
@item Input @tab Usa il punto @tab Usa la localizzazione
@item @code{strtonum()} @tab Usa il punto @tab Usa la localizzazione
@end multitable
@end float
Infine, gli standard ufficiali correnti e la rappresentazione dei numeri
in virgola mobile dello standard IEEE possono avere un effetto insolito ma
importante sul modo in cui @command{gawk} converte alcuni valori di stringa
speciali in numeri. I dettagli sono illustrati in
@ref{Problemi virgola mobile POSIX}.
@node Tutti gli operatori
@section Operatori: fare qualcosa coi valori
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} introduce gli @dfn{operatori} che fanno uso
dei valori forniti da costanti e variabili.
@menu
* Operatori aritmetici:: Operazioni aritmetiche (@samp{+}, @samp{-},
etc.)
* Concatenazione:: Concatenazione di stringhe.
* Operatori di assegnamento:: Cambiare il valore di una variabile o di un
campo.
* Operatori di incremento:: Incrementare il valore numerico di una
variabile.
@end menu
@node Operatori aritmetici
@subsection Operatori aritmetici
@cindex aritmetici @subentry operatori
@cindex operatori @subentry aritmetici
@c @cindex addition
@c @cindex subtraction
@c @cindex multiplication
@c @cindex division
@c @cindex remainder
@c @cindex quotient
@c @cindex exponentiation
Il linguaggio @command{awk} usa i comuni operatori aritmetici nella valutazione
delle espressioni. Tutti questi operatori aritmetici seguono le normali regole
di precedenza e funzionano come ci si aspetta.
Il seguente esempio usa un file chiamato @file{grades}, che contiene
una lista di nomi di studenti e anche i voti di tre verifiche per ogni studente
(@`e una piccola classe):
@example
Pat 100 97 58
Sandy 84 72 93
Chris 72 92 89
@end example
@noindent
Questo programma prende il file @file{grades} e stampa la media
dei voti:
@example
$ @kbd{awk '@{ sum = $2 + $3 + $4 ; avg = sum / 3}
> @kbd{print $1, avg @}' grades}
@print{} Pat 85
@print{} Sandy 83
@print{} Chris 84.3333
@end example
La lista seguente elenca gli operatori aritmetici in @command{awk},
in ordine di precedenza, da quella pi@`u alta a quella pi@`u bassa:
@table @code
@cindex estensioni comuni @subentry operatore @code{**}
@cindex POSIX @command{awk} @subentry operatori aritmetici
@item @var{x} ^ @var{y}
@itemx @var{x} ** @var{y}
Elevamento a potenza; @var{x} elevato alla potenza @var{y}. @samp{2 ^ 3}
ha il valore otto; la sequenza di caratteri @samp{**} equivale a
@samp{^}. @value{COMMONEXT}
@item - @var{x}
Negazione.
@item + @var{x}
Pi@`u unario; l'espressione @`e convertita in un numero.
@item @var{x} * @var{y}
Moltiplicazione.
@cindex risoluzione di problemi @subentry divisione
@cindex problemi @subentry risoluzione di @subentry divisione
@cindex divisione
@item @var{x} / @var{y}
Divisione; poich@'e tutti i numeri in @command{awk} sono numeri in virgola
mobile, il risultato @emph{non} @`e arrotondato all'intero --- @samp{3 / 4} ha il
valore di 0.75. (Un errore comune, specialmente tra i programmatori in C, @`e
quello di dimenticare che @emph{tutti} i numeri in @command{awk} sono in virgola mobile,
e che la divisione di costanti rappresentate da numeri interi produce un
numero reale, non un numero intero.)
@item @var{x} % @var{y}
Resto della divisione; subito dopo questa lista, l'argomento viene
ulteriormente dettagliato.
@item @var{x} + @var{y}
Addizione.
@item @var{x} - @var{y}
Sottrazione.
@end table
Il pi@`u e il meno unari hanno la stessa precedenza,
gli operatori di moltiplicazione hanno tutti la stessa precedenza, e
l'addizione e la sottrazione hanno la stessa precedenza.
@cindex differenze tra @command{awk} e @command{gawk} @subentry operazione di modulo-troncamento
@cindex modulo-troncamento @subentry operazione di
Quando si calcola il resto di @samp{@var{x} % @var{y}},
il quoziente @`e troncato all'intero e
moltiplicato per @var{y}. Questo risultato @`e sottratto da @var{x};
quest'operazione @`e nota anche come ``modulo''. La seguente
relazione @`e sempre verificata:
@example
b * int(a / b) + (a % b) == a
@end example
Un possibile effetto indesiderato di questa definizione di resto @`e che
@samp{@var{x} % @var{y}} sia negativo se @var{x} @`e negativo. Cos@`{@dotless{i}}:
@example
-17 % 8 = -1
@end example
@noindent
Questa definizione @`e in accordo con lo standard POSIX, il quale prescrive
che l'operatore @code{%} produca risultati equivalenti a quelli che si
otterrebbero usando la funzione standard del linguaggio C @code{fmod()},
la quale funzione, a sua volta, si comporta come appena descritto.
In altre implementazioni di @command{awk} il segno del resto
pu@`o essere dipendente dalla macchina.
@cindex portabilit@`a @subentry operatore @code{**}
@cindex @code{*} (asterisco) @subentry operatore @code{**}
@cindex asterisco (@code{*}) @subentry operatore @code{**}
@quotation NOTA
Lo standard POSIX specifica solo l'uso di @samp{^}
per l'elevamento a potenza.
Per garantire la massima portabilit@`a @`e meglio non usare l'operatore @samp{**}.
@end quotation
@node Concatenazione
@subsection Concatenazione di stringhe
@cindex Kernighan, Brian @subentry citazioni di
@quotation
@i{Allora ci era sembrata una buona idea.}
@author Brian Kernighan
@end quotation
@cindex operatori @subentry di stringa
@cindex stringa @subentry operatori di
@cindex concatenare
C'@`e una sola operazione di stringa: la concatenazione. Non ha un operatore
specifico per rappresentarla. Piuttosto, la concatenazione @`e effettuata
scrivendo le espressioni l'una vicino all'altra, senza alcun operatore.
Per esempio:
@example
$ @kbd{awk '@{ print "Campo numero uno: " $1 @}' mail-list}
@print{} Campo numero uno: Amelia
@print{} Campo numero uno: Anthony
@dots{}
@end example
Senza lo spazio nella costante stringa dopo @samp{:}, la riga
rimane unita. Per esempio:
@example
$ @kbd{awk '@{ print "Campo numero uno:" $1 @}' mail-list}
@print{} Campo numero uno:Amelia
@print{} Campo numero uno:Anthony
@dots{}
@end example
@cindex risoluzione di problemi @subentry concatenazione di stringhe
@cindex problemi @subentry risoluzione di @subentry concatenazione di stringhe
Poich@'e la concatenazione di stringhe non ha un operatore esplicito, @`e spesso
necessario assicurarsi che venga effettuata al momento giusto usando le
parentesi per racchiudere gli elementi da concatenare. Per esempio, ci si
potrebbe aspettare che il
seguente fammento di codice concateni @code{nome} e @code{file}:
@example
nome = "nome"
file = "file"
print "qualcosa di significativo" > nome file
@end example
@cindex Brian Kernighan @subentry @command{awk} di
@cindex @command{mawk} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{mawk}
@noindent
Questo produce un errore di sintassi in alcune versioni di
@command{awk} per Unix.@footnote{Pu@`o capitare che BWK @command{awk},
@command{gawk} e @command{mawk} lo interpretino nel modo giusto,
ma non ci si dovrebbe fare affidamento.}
@`E necessario usare la seguente sintassi:
@example
print "qualcosa di significativo" > (nome file)
@end example
@cindex ordine di valutazione @subentry concatenazione
@cindex valutazione @subentry ordine di @subentry concatenazione
@cindex effetti collaterali
Si dovrebbero usare le parentesi attorno alle concatenazioni in tutti i
contesti non comuni, come, per esempio, sul lato destro di @samp{=}.
Bisogna stare attenti
al tipo di espressioni usate nella concatenazione di stringhe. In particolare,
l'ordine di valutazione di espressioni usate per la concatenazione non @`e
definita nel linguaggio @command{awk}. Si consideri quest'esempio:
@example
BEGIN @{
a = "Non"
print (a " " (a = "v'allarmate"))
@}
@end example
@noindent
Non @`e definito se il secondo assegnamento ad @code{a} debba avvenire
prima o dopo il recupero del valore di @code{a} per produrre il
valore concatenato. Il risultato potrebbe essere sia @samp{Non v'allarmate},
sia @samp{v'allarmate v'allarmate}.
@c see test/nasty.awk for a worse example
La precedenza della concatenazione, quando @`e in combinazione con altri
operatori, @`e spesso controintuitiva. Si consideri questo esempio:
@ignore
> To: bug-gnu-utils@@gnu.org
> CC: arnold@@gnu.org
> Subject: gawk 3.0.4 bug with {print -12 " " -24}
> From: Russell Schulz
> Date: Tue, 8 Feb 2000 19:56:08 -0700
>
> gawk 3.0.4 on NT gives me:
>
> prompt> cat bad.awk
> BEGIN { print -12 " " -24; }
>
> prompt> gawk -f bad.awk
> -12-24
>
> when I would expect
>
> -12 -24
>
> I have not investigated the source, or other implementations. The
> bug is there on my NT and DOS versions 2.15.6 .
@end ignore
@example
$ @kbd{awk 'BEGIN @{ print -12 " " -24 @}'}
@print{} -12-24
@end example
Quest'esempio, ``ovviamente'' concatena @minus{}12, uno spazio, e @minus{}24.
Ma dov'@`e finito lo spazio?
La risposta sta nella combinazione di precedenze di operatori e nelle regole di
conversione automatica di @command{awk}. Per ottenere il risultato desiderato,
si deve scrivere il programma in questo modo:
@example
$ @kbd{awk 'BEGIN @{ print -12 " " (-24) @}'}
@print{} -12 -24
@end example
Questo forza il trattamento, da parte di @command{awk}, del @samp{-} del
@samp{-24} come operatore unario. Altrimenti @`e analizzato in questo modo:
@display
@minus{}12 (@code{"@ "} @minus{} 24)
@result{} @minus{}12 (0 @minus{} 24)
@result{} @minus{}12 (@minus{}24)
@result{} @minus{}12@minus{}24
@end display
Come si @`e detto precedentemente,
quando si usa la concatenazione insieme ad altri operatori, @`e necessario
@emph{usare le parentesi}. Altrimenti, non si pu@`o essere mai completamente
certi di quel che si ottiene.
@node Operatori di assegnamento
@subsection Espressioni di assegnamento
@cindex operatori @subentry di assegnamento
@cindex assegnamento @subentry operatori di
@cindex espressioni @subentry di assegnamento
@cindex @code{=} (uguale) @subentry operatore @code{=}
@cindex uguale (@code{=}) @subentry operatore @code{=}
Un @dfn{assegnamento} @`e un'espressione che memorizza un valore (generalmente
diverso da quello che la variabile aveva in precedenza) in una variabile.
Per esempio, si assegni il valore uno alla variabile @code{z}:
@example
z = 1
@end example
Dopo l'esecuzione di quest'espressione, la variabile @code{z} ha il valore
uno. Qualsiasi precedente valore di @code{z} prima dell'assegnamento
viene dimenticato.
Gli assegnamenti possono anche memorizzare valori di stringa. Il seguente
esempio memorizza
il valore @code{"questo cibo @`e buono"} nella variabile @code{messaggio}:
@example
cosa = "cibo"
predicato = "buono"
messaggio = "questo " cosa " @`e " predicato
@end example
@noindent
@cindex effetti collaterali @subentry espressioni di assegnamento
Quest'esempio illustra anche la concatenazione di stringhe.
Il segno @samp{=} @`e un @dfn{operatore di assegnamento}. @`E il pi@`u semplice
fra gli operatori di assegnamento perch@'e il valore dell'operando di destra
@`e memorizzato invariato.
La maggior parte degli operatori (addizione, concatenazione e cos@`{@dotless{i}} via) non
fanno altro che calcolare un valore. Se il valore non viene poi utilizzato non c'@`e alcun
motivo per usare l'operatore. Un operatore di assegnamento @`e differente;
produce un valore; anche se poi non lo si usa, l'assegnamento svolge ancora
una funzione alterando la variabile. Chiamiamo questo
un @dfn{effetto collaterale}.
@cindex @dfn{lvalue/rvalue}
@cindex @dfn{rvalue/lvalue}
@cindex assegnamento @subentry operatori di @subentry @dfn{lvalue/rvalue}
@cindex operatori @subentry di assegnamento
L'operando di sinistra non dev'essere necessariamente una variabile
(@pxref{Variabili}); pu@`o essere anche un campo
(@pxref{Cambiare i campi}) o
@iftex
un elemento di un vettore (@pxrefil{Vettori}).
@end iftex
@ifnottex
un elemento di un vettore (@pxref{Vettori}).
@end ifnottex
Questi operandi sono chiamati @dfn{lvalue}, il
che significa che possono apparire sul lato sinistro di un operatore di
assegnamento. L'operando sul lato destro pu@`o essere qualsiasi espressione;
produce un nuovo valore che l'assegnamento memorizza nella variabile, nel campo
o nell'elemento di vettore specificati. Tali valori sono chiamati
@dfn{rvalue}.
@cindex variabili @subentry tipi di
@`E importante notare che le variabili @emph{non} hanno dei tipi permanenti.
Il tipo di una variabile @`e semplicemente quello di qualsiasi valore le sia stato
assegnato per ultimo. Nel seguente frammento di programma, la variabile
@code{pippo} ha dapprima un valore numerico, e in seguito un valore di stringa:
@example
@group
pippo = 1
print pippo
@end group
@group
pippo = "pluto"
print pippo
@end group
@end example
@noindent
Quando il secondo assegnamento d@`a a @code{pippo} un valore di stringa, il fatto
che avesse precedentemente un valore numerico viene dimenticato.
Ai valori di stringa che non iniziano con una cifra viene assegnato il valore
numerico zero. Dopo l'esecuzione del seguente codice, il valore di @code{pippo} @`e
cinque:
@example
pippo = "una stringa"
pippo = pippo + 5
@end example
@quotation NOTA
Usare una variabile sia come numero che come stringa pu@`o originare confusione
e denota uno stile di programmazione scadente. I due esempi precedenti
illustrano come funziona @command{awk}, @emph{non} come si dovrebbero scrivere
i programmi!
@end quotation
Un assegnamento @`e un'espressione, per cui ha un valore: lo stesso valore che
le @`e stato assegnato. Cos@`{@dotless{i}}, @samp{z = 1} @`e un'espressione col valore uno.
Una conseguenza di ci@`o @`e che si possono scrivere pi@`u assegnamenti insieme,
come:
@example
x = y = z = 5
@end example
@noindent
Quest'esempio memorizza il valore cinque in tutte e tre le variabili,
(@code{x}, @code{y} e @code{z}).
Questo perch@'e il
valore di @samp{z = 5}, che @`e cinque, @`e memorizzato in @code{y} e poi
il valore di @samp{y = z = 5}, che @`e cinque, @`e memorizzato in @code{x}.
Gli assegnamenti possono essere usati ovunque sia prevista un'espressione. Per
esempio, @`e valido scrivere @samp{x != (y = 1)} per impostare @code{y} a
uno, e poi verificare se @code{x} @`e uguale a uno. Per@`o questo stile rende i
programmi difficili da leggere; una tale nidificazione di assegnamenti dovrebbe
essere evitata, eccetto forse in un programma usa-e-getta.
@cindex @code{+} (pi@`u) @subentry operatore @code{+=}
@cindex pi@`u (@code{+}) @subentry operatore @code{+=}
Accanto a @samp{=}, ci sono diversi altri operatori di assegnamento che
eseguono calcoli col vecchio valore di una variabile. Per esempio,
l'operatore @samp{+=} calcola un nuovo valore aggiungendo il valore sul lato
destro al vecchio valore di una variabile. Cos@`{@dotless{i}}, il seguente assegnamento
aggiunge cinque al valore di @code{pippo}:
@example
pippo += 5
@end example
@noindent
Questo equivale a:
@example
pippo = pippo + 5
@end example
@noindent
Si usi la notazione che rende pi@`u chiaro il significato del programma.
Ci sono situazioni in cui usare @samp{+=} (o qualunque operatore di
assegnamento) @emph{non} @`e la stessa cosa che ripetere semplicemente l'operando
di sinistra nell'espressione di destra. Per esempio:
@cindex Rankin, Pat
@example
@group
# Grazie a Pat Rankin per quest'esempio
BEGIN @{
pippo[rand()] += 5
for (x in pippo)
print x, pippo[x]
@end group
@group
pluto[rand()] = pluto[rand()] + 5
for (x in pluto)
print x, pluto[x]
@}
@end group
@end example
@cindex operatori @subentry di assegnamento @subentry ordine di valutazione
@cindex assegnamento @subentry operatori di @subentry ordine di valutazione
@noindent
@`E praticamente certo che gli indici di @code{pluto} siano differenti, perch@'e
@code{rand()} restituisce valori differenti ogni volta che viene chiamata.
(I vettori e la funzione @code{rand()} non sono ancora stati trattati.
@iftex
@xrefil{Vettori},
@end iftex
@ifnottex
@xref{Vettori},
@end ifnottex
e
@ifnotdocbook
@pxref{Funzioni numeriche}
@end ifnotdocbook
@ifdocbook
@ref{Funzioni numeriche}
@end ifdocbook
per maggiori informazioni.)
Quest'esempio illustra un fatto importante riguardo agli operatori di
assegnamento: l'espressione di sinistra viene valutata @emph{una volta sola}.
Dipende dall'implementazione stabilire quale espressione valutare per
prima, se quella di sinistra o quella di destra.
Si consideri quest'esempio:
@example
i = 1
a[i += 2] = i + 1
@end example
@noindent
Il valore di @code{a[3]} potrebbe essere sia due sia quattro.
La @ref{table-assign-ops} elenca gli operatori di assegnamento aritmetici. In
ogni caso, l'operando di destra @`e un'espressione il cui valore @`e convertito in
un numero.
@cindex @code{-} (meno) @subentry operatore @code{-=}
@cindex meno (@code{-}) @subentry operatore @code{-=}
@cindex @code{*} (asterisco) @subentry operatore @code{*=}
@cindex asterisco (@code{*}) @subentry operatore @code{*=}
@cindex @code{/} (barra) @subentry operatore @code{/=}
@cindex barra (@code{/}) @subentry operatore @code{/=}
@cindex @code{%} (percento) @subentry operatore @code{%=}
@cindex percento (@code{%}) @subentry operatore @code{%=}
@cindex @code{^} (circonflesso) @subentry operatore @code{^=}
@cindex circonflesso (@code{^}) @subentry operatore @code{^=}
@cindex @code{*} (asterisco) @subentry operatore @code{**=}
@cindex asterisco (@code{*}) @subentry operatore @code{**=}
@float Tabella,table-assign-ops
@caption{Operatori di assegnamento aritmetici}
@multitable @columnfractions .30 .70
@headitem Operatore @tab Effetto
@item @var{lvalue} @code{+=} @var{incremento} @tab Aggiunge @var{incremento} al valore di @var{lvalue}.
@item @var{lvalue} @code{-=} @var{decremento} @tab Sottrae @var{decremento} dal valore di @var{lvalue}.
@item @var{lvalue} @code{*=} @var{coefficiente} @tab Moltiplica il valore di @var{lvalue} per @var{coefficiente}.
@item @var{lvalue} @code{/=} @var{divisore} @tab Divide il valore di @var{lvalue} per @var{divisore}.
@item @var{lvalue} @code{%=} @var{modulo} @tab Imposta @var{lvalue} al resto della sua divisione per @var{modulo}.
@cindex estensioni comuni @subentry operatore @code{**=}
@cindex estensioni comuni @subentry operatore @code{**=}
@cindex @command{awk} @subentry linguaggio @subentry versione POSIX
@cindex POSIX @command{awk}
@item @var{lvalue} @code{^=} @var{esponente} @tab Eleva @var{lvalue} alla potenza @var{esponente}.
@item @var{lvalue} @code{**=} @var{esponente} @tab Eleva @var{lvalue} alla potenza @var{esponente}. @value{COMMONEXT}
@end multitable
@end float
@cindex POSIX @command{awk} @subentry @code{**=} (operatore)
@cindex portabilit@`a @subentry operatore @code{**=}
@quotation NOTA
Soltanto l'operatore @samp{^=} @`e definito da POSIX.
Per avere la massima portabilit@`a, non usare l'operatore @samp{**=}.
@end quotation
@sidebar Ambiguit@`a sintattiche tra @samp{/=} e le espressioni regolari
@cindex angolo buio @subentry costanti @dfn{regexp} @subentry operatore @code{/=} e
@cindex @code{/} (barra) @subentry operatore @code{/=} @subentry vs. costante @dfn{regexp} @code{/=@dots{}/}
@cindex barra (@code{/}) @subentry operatore @code{/=} @subentry vs. costante @dfn{regexp} @code{/=@dots{}/}
@cindex @dfn{regexp} @subentry costanti @subentry @code{/=@dots{}/}, operatore @code{/=} e
@c derived from email from "Nelson H. F. Beebe"
@c Date: Mon, 1 Sep 1997 13:38:35 -0600 (MDT)
@cindex angolo buio @subentry operatore @code{/=} vs. costante @dfn{regexp} @code{/=@dots{}/}
@cindex ambiguit@`a sintattica: operatore @code{/=} vs. costante @dfn{regexp} @code{/=@dots{}/}
@cindex sintattica @subentry ambiguit@`a: operatore @code{/=} vs. costante @dfn{regexp} @code{/=@dots{}/}
C'@`e un'ambiguit@`a sintattica tra l'operatore di assegnamento @code{/=}
e le costanti @dfn{regexp} il cui primo carattere sia @samp{=}.
@value{DARKCORNER}
Questo @`e pi@`u evidente in alcune versioni commerciali di @command{awk}.
Per esempio:
@example
$ @kbd{awk /==/ /dev/null}
@error{} awk: syntax error at source line 1
@error{} context is
@error{} >>> /= <<<
@error{} awk: bailing out at source line 1
@end example
@noindent
Un espediente @`e:
@example
awk '/[=]=/' /dev/null
@end example
@command{gawk} non ha questo problema, e neppure lo hanno BWK @command{awk}
e @command{mawk}.
@end sidebar
@node Operatori di incremento
@subsection Operatori di incremento e di decremento
@cindex incremento @subentry operatori di
@cindex operatori @subentry di decremento/incremento
Gli @dfn{operatori di incremento} e @dfn{decremento} incrementano o riducono il
valore di una variabile di uno. Un operatore di assegnamento pu@`o fare la
stessa cosa, per cui gli operatori di incremento non aggiungono funzionalit@`a
al inguaggio @command{awk}; in ogni caso, sono delle convenienti abbreviazioni
per operazioni molto comuni.
@cindex effetti collaterali
@cindex @code{+} (pi@`u) @subentry operatore @code{++}
@cindex pi@`u (@code{+}) @subentry operatore @code{++}
@cindex effetti collaterali @subentry operatori di decremento/incremento
L'operatore per aggiungere uno @`e @samp{++}. Pu@`o essere usato per incrementare
una variabile prima o dopo aver stabilito il suo valore. Per @dfn{preincrementare}
una variabile @code{v}, si scrive @samp{++v}. Questo aggiunge uno al valore di
@code{v}; questo nuovo valore @`e anche il valore dell'espressione.
(L'espressione di assegnamento @samp{v += 1} @`e totalmente equivalente.)
Scrivendo @samp{++} dopo la variabile si specifica un @dfn{postincremento}.
Questo incrementa il valore della variabile nello stesso modo; la differenza @`e
che il valore dell'espressione d'incremento @`e il @emph{vecchio} valore della
variabile. Cos@`{@dotless{i}}, se @code{pippo} ha il valore quattro, l'espressione
@samp{pippo++} ha il valore quattro, ma cambia il valore di @code{pippo} in cinque.
In altre parole, l'operatore restituisce il vecchio valore della variabile, ma
con l'effetto collaterale di incrementarlo.
Il postincremento @samp{pippo++} @`e quasi come scrivere @samp{(pippo += 1) - 1}.
Non @`e perfettamente equivalente perch@'e tutti i numeri in @command{awk} sono in
virgola mobile. In virgola mobile, @samp{pippo + 1 - 1} non @`e necessariamente
uguale a @code{pippo}, ma la differenza @`e molto piccola finch@'e si ha a che
fare con numeri relativamente piccoli (inferiori a
@iftex
@math{10^{12}}).
@end iftex
@ifinfo
10e12).
@end ifinfo
@ifnottex
@ifnotinfo
10@sup{12}).
@end ifnotinfo
@end ifnottex
@cindex @code{$} (dollaro) @subentry incrementare campi e vettori
@cindex dollaro (@code{$}) @subentry incrementare campi e vettori
I campi di un record e gli elementi di un vettore vengono incrementati
proprio come le
variabili. (Si deve usare @samp{$(i++)} quando si deve fare un riferimento a
un campo e incrementare una variabile allo stesso tempo. Le parentesi sono
necessarie a causa della precedenza dell'operatore di riferimento @samp{$}.)
@cindex decremento @subentry operatori di
L'operatore di decremento @samp{--} funziona proprio come @samp{++}, solo che
sottrae uno anzich@'e aggiungerlo. Come @samp{++}, si pu@`o usare prima di
@dfn{lvalue}
per predecrementare o dopo per postdecrementare.
Quel che segue @`e un sommario delle espressioni di incremento e di
decremento:
@table @code
@cindex @code{+} (pi@`u) @subentry operatore @code{++}
@cindex pi@`u (@code{+}) @subentry operatore @code{++}
@item ++@var{lvalue}
Incrementa @var{lvalue}, restituendo il nuovo valore come
valore dell'espressione.
@item @var{lvalue}++
Incrementa @var{lvalue}, restituendo il @emph{vecchio} valore di @var{lvalue}
come valore dell'espressione.
@cindex @code{-} (meno) @subentry operatore @code{--}
@cindex meno (@code{-}) @subentry operatore @code{--}
@item --@var{lvalue}
Decrementa @var{lvalue}, restituendo il nuovo valore come
valore dell'espressione.
(Quest'espressione @`e come
@samp{++@var{lvalue}}, ma invece di aggiungere, sottrae.)
@item @var{lvalue}--
Decrementa @var{lvalue}, restituendo il @emph{vecchio} valore di @var{lvalue}
come valore dell'espressione.
(Quest'espressione @`e come
@samp{@var{lvalue}++}, ma invece di aggiungere, sottrae.)
@end table
@sidebar Ordine di valutazione degli operatori
@cindex precedenza
@cindex operatori @subentry precedenza degli
@cindex portabilit@`a @subentry operatori
@cindex valutazione @subentry ordine di
@cindex Marx, Groucho
@quotation
@i{Dottore, quando faccio cos@`{@dotless{i}} mi fa male!@*
E allora non farlo!}
@author Groucho Marx
@end quotation
@noindent
Che cosa succede con qualcosa come questo?
@example
b = 6
print b += b++
@end example
@noindent
O con qualcosa di pi@`u strano ancora?
@example
b = 6
b += ++b + b++
print b
@end example
@cindex effetti collaterali
In altre parole, quando hanno effetto i vari effetti collaterali previsti
dagli operatori col suffisso (@samp{b++})? Quando gli effetti collaterali
si verificano @`e @dfn{definito dall'implementazione}.
Per dirla diversamente, questo @`e compito di ogni specifica versione di
@command{awk}. Il risultato del primo esempio pu@`o essere 12 o 13, e del
secondo pu@`o essere 22 o 23.
In breve, @`e sconsigliato fare cose come questa e, in ogni caso,
ogni cosa che possa incidere sulla portabilit@`a.
Si dovrebbero evitare cose come queste nei programmi.
@c You'll sleep better at night and be able to look at yourself
@c in the mirror in the morning.
@end sidebar
@node Valori e condizioni di verit@`a
@section Valori e condizioni di verit@`a
In certi contesti, i valori delle espressioni servono anche come
``valori di verit@`a''; cio@`e, determinano quale sar@`a la direzione che il
programma prender@`a durante la sua esecuzione. Questa
@value{SECTION} descrive come @command{awk} definisce ``vero'' e ``falso''
e come questi valori sono confrontati.
@menu
* Valori di verit@`a:: Cos'@`e ``vero'' e cos'@`e ``falso''.
* Tipi di variabile e confronti:: Come alle variabili si assegna il tipo e
l'effetto che questo ha sul confronto di
numeri e stringhe con @samp{<}, etc.
* Operatori booleani:: Combinare espressioni di confronto usando
operatori booleani @samp{||} (``or''),
@samp{&&} (``and'') e @samp{!} (``not'').
* Espressioni condizionali:: Le espressioni condizionali scelgono una fra
due sottoespressioni, a seconda del valore di
una terza sottoespressione.
@end menu
@node Valori di verit@`a
@subsection Vero e falso in @command{awk}
@cindex valori @subentry di verit@`a
@cindex logico @subentry valore @subentry vero/falso
@cindex falso @subentry valore logico (zero o stringa nulla)
@cindex vero @subentry valore logico (diverso da zero e da stringa nulla)
@cindex nulle @subentry stringhe
Molti linguaggi di programmazione hanno una particolare rappresentazione per i
concetti di ``vero'' e ``falso.'' Questi linguaggi usano normalmente le
costanti speciali @code{true} e @code{false}, o forse i loro equivalenti
maiuscoli.
Per@`o @command{awk} @`e differente.
Prende in prestito un concetto molto semplice di vero e falso dal linguaggio
C. In @command{awk}, ogni valore numerico diverso da zero @emph{oppure}
ogni valore di stringa non vuota @`e vero. Ogni altro valore (zero o la stringa
nulla, @code{""}) @`e falso. Il seguente programma stampa @samp{Uno strano
valore di verit@`a} tre volte:
@example
BEGIN @{
if (3.1415927)
print "Uno strano valore di verit@`a"
if ("Ottanta e sette anni or sono")
print "Uno strano valore di verit@`a"
if (j = 57)
print "Uno strano valore di verit@`a"
@}
@end example
@cindex angolo buio @subentry @code{"0"} @`e effettivamente vero
C'@`e una conseguenza sorprendente della regola ``non zero o non nullo'':
la costante di stringa @code{"0"} sta effettivamente per vero, perch@'e
@`e non nulla.
@value{DARKCORNER}
@node Tipi di variabile e confronti
@subsection Tipi di variabile ed espressioni di confronto
@quotation
@i{La Guida galattica @`e infallibile. @`E la realt@`a, spesso, a essere inesatta.}
@author Douglas Adams, @cite{Guida galattica per autostoppisti}
@end quotation
@c 2/2015: Antonio Colombo points out that this is really from
@c The Restaurant at the End of the Universe. But I'm going to
@c leave it alone.
@cindex confronto @subentry espressioni di
@cindex espressioni @subentry di confronto
@cindex espressioni @subentry ricerca di corrispondenze @seeentry{espressioni di confronto}
@cindex individuare @subentry tramite espressioni @seeentry{espressioni di confronto}
@cindex relazionali @subentry operatori @seeentry{espressioni di confronto}
@cindex operatori @subentry relazionali @seeentry{espressioni di confronto}
@cindex variabili @subentry tipi di
@cindex variabili @subentry tipi di @subentry espressioni di confronto e
Diversamente che in altri linguaggi di programmazione, le variabili di
@command{awk} non hanno un tipo fisso. Possono essere sia un numero che una
stringa, a seconda del valore loro assegnato.
Vediamo ora come viene assegnato il tipo a una variabile, e come @command{awk}
le confronta.
@menu
* Tipi di variabile:: Tipo stringa rispetto a tipo numero.
* Operatori di confronto:: Gli operatori di confronto.
* Confronto POSIX di stringhe:: Confronto tra stringhe usando le
regole POSIX.
@end menu
@node Tipi di variabile
@subsubsection Tipo stringa rispetto a tipo numero
Per gli elementi scalari in @command{awk} (variabili, elementi di
vettore e campi), il tipo degli stessi viene attribuito @emph{dinamicamente}.
Ci@`o significa che il tipo di un elemento pu@`o cambiare nel corso
dell'esecuzione di un programma, da @dfn{untyped} (non ancora tipizzata),
valore assunto prima che la variabile sia utilizzata,@footnote{@command{gawk}
chiama queste variabili @dfn{unassigned} (non ancora assegnate), come si
vede dall'esempio che segue.} a stringa oppure a numero, e in seguito
da stringa a numero o da numero a stringa, nel prosieguo del programma.
(@command{gawk} prevede anche degli scalari di tipo @dfn{regexp}, ma
per ora possiamo ignorarli;
@pxref{Costanti @dfn{regexp} forti}.)
Non si pu@`o fare molto riguardo alle variabili di tipo @dfn{untyped},
oltre a constatare che ancora non @`e stato loro attribuito un tipo.
Il seguente programma confronta la variabile @code{a} con i valori
@code{""} e @code{0}; il confronto d@`a esito positivo se alla
variabile @code{a} non @`e mai stato assegnato un valore.
L'esempio usa la funzione predefinita @code{typeof()}
(non ancora trattata; @pxref{Funzioni per i tipi}) per
visualizzare il tipo della variabile @code{a}:
@example
$ @kbd{gawk 'BEGIN @{ print (a == "" && a == 0 ?}
> @kbd{"a non ha un tipo" : "a ha un tipo!") ; print typeof(a) @}'}
@print{} a non ha un tipo
@print{} unassigned
@end example
Una variabile scalare diviene di tipo numerico quando le viene assegnato un
valore numerico, per mezzo di una costante numerica, o tramite un'altra
variabile scalare di tipo numerico:
@example
$ @kbd{gawk 'BEGIN @{ a = 42 ; print typeof(a)}
> @kbd{b = a ; print typeof(b) @}'}
number
number
@end example
Analogamente, una variabile scalare diviene di tipo stringa quando le
viene assegnato come valore una stringa, per mezzo di una costante stringa,
o tramite un'altra variabile scalare di tipo stringa:
@example
$ @kbd{gawk 'BEGIN @{ a = "quarantadue" ; print typeof(a)}
> @kbd{b = a ; print typeof(b) @}'}
string
string
@end example
Fin qui, tutto semplice e chiaro. Cosa succede, per@`o, quando
@command{awk} deve trattare dati forniti dall'utente?
Il primo caso da considerare @`e quello dei campi di dati in input.
Quale dovrebbe essere l'output del seguente programma?
@example
echo ciao | awk '@{ printf("%s %s < 42\n", $1,
($1 < 42 ? "@`e" : "non @`e")) @}'
@end example
@noindent
Poich@'e @samp{ciao} @`e un dato di tipo alfabetico, @command{awk} pu@`o solo
effettuare un confronto di tipo stringa. Internamente, il numero @code{42}
viene convertito in @code{"42"} e vengono confrontate le due stringhe di
valore @code{"ciao"} e @code{"42"}. Questo @`e il risultato:
@example
$ @kbd{echo ciao | awk '@{ printf("%s %s < 42\n", $1,}
> @kbd{ ($1 < 42 ? "@`e" : "non @`e")) @}'}
@print{} ciao non @`e < 42
@end example
Tuttavia, cosa succede quando un dato utente @emph{assomiglia} a un
numero?
Da un lato, in realt@`a, il dato in input @`e formato da alcuni caratteri, non da
valori numerici in formato binario. Ma, d'altro lato, il dato sembra
numerico, e @command{awk} dovrebbe davvero trattarlo come tale. E in effetti
questo @`e ci@`o che avviene:
@example
$ @kbd{echo 37 | awk '@{ printf("%s %s < 42\n", $1,}
> @kbd{ ($1 < 42 ? "@`e" : "non @`e")) @}'}
@print{} 37 is < 42
@end example
Queste sono le regole seguite per determinare quando @command{awk}
tratta dei dati in input come numeri, e quando li considera stringhe.
@cindex numeriche @subentry stringhe
@cindex stringa @subentry numerica
@cindex POSIX @command{awk} @subentry stringhe numeriche
Lo standard POSIX usa il concetto di @dfn{stringa numerica}, per dei dati
in input che appaiono essere numerici. Il @samp{37} nell'esempio precedente
@`e una stringa numerica. Quindi, qual @`e il tipo di una stringa numerica?
Risposta: numerico.
Il tipo di una variabile @`e importante perch@'e il tipo di due variabili
determina il modo con cui le stesse vengono confrontate.
La determinazione del tipo di variabile segue queste regole:
@itemize @value{BULLET}
@item
Una costante numerica o il risultato di un'operazione numerica ha l'attributo
@dfn{numeric}.
@item
Una costante di stringa o il risultato di un'operazione di stringa ha
l'attributo @dfn{string}.
@item
Campi, input tramite @code{getline}, @code{FILENAME}, elementi di
@code{ARGV}, elementi di @code{ENVIRON}, e gli elementi di un vettore
creato da @code{match()}, @code{split()} e @code{patsplit()} che sono
stringhe numeriche hanno l'attributo @dfn{strnum}.@footnote{Quindi, una
stringa numerica POSIX e una variabile tipo @dfn{strnum} di @command{gawk}
sono equivalenti.}
Altrimenti, hanno l'attributo @dfn{string}.
Anche le variabili non inizializzate hanno l'attributo @var{strnum}.
@item
Gli attributi si trasmettono attraverso gli assegnamenti ma non vengono
cambiati da nessun uso.
@c (Although a use may cause the entity to acquire an additional
@c value such that it has both a numeric and string value, this leaves the
@c attribute unchanged.)
@c This is important but not relevant
@end itemize
L'ultima regola @`e particolarmente importante. Nel seguente programma,
@code{a} @`e di tipo numerico, anche se viene usata in un secondo momento in
un'operazione di stringa:
@example
BEGIN @{
a = 12.345
b = a " @`e un numero carino"
print b
@}
@end example
Quando si confrontano due operandi, pu@`o essere usata sia il confronto come
stringa che il confronto numerico, a seconda degli attributi degli operandi,
secondo questa matrice simmetrica:
@c thanks to Karl Berry, kb@cs.umb.edu, for major help with TeX tables
@tex
\centerline{
\vbox{\bigskip % space above the table (about 1 linespace)
% Because we have vertical rules, we can't let TeX insert interline space
% in its usual way.
\offinterlineskip
%
% Define the table template. & separates columns, and \cr ends the
% template (and each row). # is replaced by the text of that entry on
% each row. The template for the first column breaks down like this:
% \strut -- a way to make each line have the height and depth
% of a normal line of type, since we turned off interline spacing.
% \hfil -- infinite glue; has the effect of right-justifying in this case.
% # -- replaced by the text (for instance, `STRNUM', in the last row).
% \quad -- about the width of an `M'. Just separates the columns.
%
% The second column (\vrule#) is what generates the vertical rule that
% spans table rows.
%
% The doubled && before the next entry means `repeat the following
% template as many times as necessary on each line' -- in our case, twice.
%
% The template itself, \quad#\hfil, left-justifies with a little space before.
%
\halign{\strut\hfil#\quad&\vrule#&&\quad#\hfil\cr
&&STRING &NUMERIC &STRNUM\cr
% The \omit tells TeX to skip inserting the template for this column on
% this particular row. In this case, we only want a little extra space
% to separate the heading row from the rule below it. the depth 2pt --
% `\vrule depth 2pt' is that little space.
\omit &depth 2pt\cr
% This is the horizontal rule below the heading. Since it has nothing to
% do with the columns of the table, we use \noalign to get it in there.
\noalign{\hrule}
% Like above, this time a little more space.
\omit &depth 4pt\cr
% The remaining rows have nothing special about them.
STRING &&string &string &string\cr
NUMERIC &&string &numeric &numeric\cr
STRNUM &&string &numeric &numeric\cr
}}}
@end tex
@ifnottex
@ifnotdocbook
@verbatim
+----------------------------------------------
| STRING NUMERIC STRNUM
--------+----------------------------------------------
|
STRING | string string string
|
NUMERIC | string numeric numeric
|
STRNUM | string numeric numeric
--------+----------------------------------------------
@end verbatim
@end ifnotdocbook
@end ifnottex
@docbook
STRING
NUMERIC
STRNUM
STRING
string
string
string
NUMERIC
string
numeric
numeric
STRNUM
string
numeric
numeric
@end docbook
L'idea di base @`e che l'input dell'utente che appare come numerico --- e
@emph{solo} l'input dell'utente --- dovrebbe essere trattato come numerico, anche
se in realt@`a @`e un insieme di caratteri e quindi anche una stringa.
Cos@`{@dotless{i}}, ad esempio, la costante di stringa @w{@code{" +3.14"}},
quando appare nel codice sorgente di un programma,
@`e una stringa --- anche se sembra numerica --- e non
viene @emph{mai} trattato come numero
ai fini di un confronto.
In breve, quando un operando @`e una stringa ``pura'', come una costante di
stringa, viene effettuato un confronto di stringa. In caso contrario viene
effettuato un confronto numerico.
(La differenza principale tra un numero e uno @dfn{strnum} @`e che per gli
@dfn{strnum} @command{gawk} conserva anche il valore originale della stringa
che la variabile scalare aveva al momento in cui @`e stata letta.
Questo punto merita di essere ulteriormente ribadito:
l'input che appare essere un numero @emph{@`e} numerico.
Tutto il resto dell'input @`e considerato essere una stringa.
Cos@`{@dotless{i}}, la stringa in input di sei caratteri @w{@samp{ +3.14}}
riceve l'attributo @dfn{strnum}. Al contrario, la stringa di sei caratteri
@w{@code{" +3.14"}} che compaia nel testo di un programma rimane una
costante di stringa. I seguenti esempi stampano @samp{1} quando il confronto
fra due diverse costanti @`e vero, altrimenti stampano @samp{0}:
@c 22.9.2014: Tested with mawk and BWK awk, got same results.
@example
$ @kbd{echo ' +3.14' | awk '@{ print($0 == " +3.14") @}'} @ii{Vero}
@print{} 1
$ @kbd{echo ' +3.14' | awk '@{ print($0 == "+3.14") @}'} @ii{Falso}
@print{} 0
$ @kbd{echo ' +3.14' | awk '@{ print($0 == "3.14") @}'} @ii{Falso}
@print{} 0
$ @kbd{echo ' +3.14' | awk '@{ print($0 == 3.14) @}'} @ii{Vero}
@print{} 1
$ @kbd{echo ' +3.14' | awk '@{ print($1 == " +3.14") @}'} @ii{Falso}
@print{} 0
$ @kbd{echo ' +3.14' | awk '@{ print($1 == "+3.14") @}'} @ii{Vero}
@print{} 1
$ @kbd{echo ' +3.14' | awk '@{ print($1 == "3.14") @}'} @ii{Falso}
@print{} 0
$ @kbd{echo ' +3.14' | awk '@{ print($1 == 3.14) @}'} @ii{Vero}
@print{} 1
@end example
Per controllare il tipo di un campo in input (o di altro input immesso
dall'utente, si pu@`o usare @code{typeof()}:
@example
$ @kbd{echo salve 37 | gawk '@{ print typeof($1), typeof($2) @}'}
@print{} string strnum
@end example
@node Operatori di confronto
@subsubsection Operatori di confronto
@cindex operatori @subentry di confronto
Le @dfn{espressioni di confronto} confrontano stringhe o numeri per metterli in
relazione tra di loro, come ad esempio nella relazione di uguaglianza. Sono
scritte usando @dfn{operatori di relazione}, che sono un superinsieme di quelli
in C. Sono descritti nella @ref{table-relational-ops}.
@cindex @code{<} (parentesi acuta sinistra) @subentry operatore @code{<}
@cindex parentesi @subentry acuta sinistra (@code{<}) @subentry operatore @code{<}
@cindex @code{<} (parentesi acuta sinistra) @subentry operatore @code{<=}
@cindex parentesi @subentry acuta sinistra (@code{<}) @subentry operatore @code{<=}
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>=}
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>=}
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>}
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>}
@cindex @code{=} (uguale) @subentry operatore @code{==}
@cindex uguale (@code{=}) @subentry operatore @code{==}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!=}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!=}
@cindex @code{~} (tilde) @subentry operatore @code{~}
@cindex tilde (@code{~}) @subentry operatore @code{~}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!~}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!~}
@cindex @code{in} (operatore)
@float Tabella,table-relational-ops
@caption{Operatori di relazione}
@multitable @columnfractions .23 .77
@headitem Espressione @tab Risultato
@item @var{x} @code{<} @var{y} @tab Vero se @var{x} @`e minore di @var{y}
@item @var{x} @code{<=} @var{y} @tab Vero se @var{x} @`e minore o uguale a @var{y}
@item @var{x} @code{>} @var{y} @tab Vero se @var{x} @`e maggiore di @var{y}
@item @var{x} @code{>=} @var{y} @tab Vero se @var{x} @`e maggiore o uguale a @var{y}
@item @var{x} @code{==} @var{y} @tab Vero se @var{x} @`e uguale a @var{y}
@item @var{x} @code{!=} @var{y} @tab Vero se @var{x} @`e diverso da @var{y}
@item @var{x} @code{~} @var{y} @tab Vero se la stringa @var{x} corrisponde alla @dfn{regexp} rappresentata da @var{y}
@item @var{x} @code{!~} @var{y} @tab Vero se la stringa @var{x} non corrisponde alla @dfn{regexp} rappresentata da @var{y}
@item @var{indice} @code{in} @var{vettore} @tab Vero se il vettore @var{vettore} ha un elemento con indice @var{indice}
@end multitable
@end float
Le espressioni di confronto valgono uno se sono vere e zero se false.
Quando si confrontano operandi di tipi diversi, gli operandi numerici sono
convertiti in stringhe usando il valore di @code{CONVFMT}
(@pxref{Conversione}).
Il confronto tra stringhe avviene
confrontando il primo carattere di ciascuna stringa, poi il secondo carattere,
e cos@`{@dotless{i}} via. Quindi, @code{"10"} @`e minore di @code{"9"}. Se vi sono due
stringhe di cui una @`e il prefisso dell'altra, la stringa pi@`u corta @`e minore di
quella pi@`u lunga. Cos@`{@dotless{i}}, @code{"abc"} @`e minore di @code{"abcd"}.
@cindex risoluzione di problemi @subentry operatore @code{==}
@cindex problemi @subentry risoluzione di @subentry operatore @code{==}
@`E molto facile sbagliarsi scrivendo l'operatore @samp{==} e
omettendo uno dei due caratteri @samp{=}. Il risultato @`e sempre un codice
@command{awk} valido, ma il programma non fa quel che si voleva:
@example
@group
if (a = b) # oops! dovrebbe essere == b
@dots{}
else
@dots{}
@end group
@end example
@noindent
A meno che @code{b} non sia zero o la stringa nulla, la parte @code{if}
del test ha sempre successo. Poich@'e gli operatori sono molto simili,
questo tipo di errore @`e molto difficile da individuare
rileggendo il codice sorgente.
Il seguente elenco di espressioni illustra il tipo di confronti
che @command{awk} effettua e il risultato di ciascun confronto:
@table @code
@item 1.5 <= 2.0
Confronto numerico (vero)
@item "abc" >= "xyz"
Confronto tra stringhe (falso)
@item 1.5 != " +2"
Confronto tra stringhe (vero)
@item "1e2" < "3"
Confronto tra stringhe (vero)
@item a = 2; b = "2"
@itemx a == b
Confronto tra stringhe (vero)
@item a = 2; b = " +2"
@itemx a == b
Confronto tra stringhe (falso)
@end table
In quest'esempio:
@example
$ @kbd{echo 1e2 3 | awk '@{ print ($1 < $2) ? "vero" : "falso" @}'}
@print{} falso
@end example
@cindex espressioni @subentry di confronto @subentry stringa vs.@: @dfn{regexp}
@c @cindex string comparison vs.@: regexp comparison
@c @cindex regexp comparison vs.@: string comparison
@noindent
il risultato @`e @samp{falso} perch@'e sia @code{$1} che @code{$2}
sono immessi dall'utente. Sono stringhe numeriche --- quindi hanno entrambe
l'attributo @dfn{strnum}, che richiede un confronto di tipo numerico.
Lo scopo delle regole di confronto e dell'uso di stringhe numeriche @`e quello
di cercare di produrre il comportamento "meno inaspettato possibile",
pur "facendo la cosa giusta".
I confronti di stringhe e i confronti di espressioni regolari sono molto
diversi. Per esempio:
@example
x == "att"
@end example
@noindent
ha il valore uno, ossia @`e vero, se la variabile @code{x}
@`e precisamente @samp{att}. Al contrario:
@example
x ~ /att/
@end example
@noindent
ha il valore uno se @code{x} contiene @samp{att}, come
@code{"Oh, che matto che sono!"}.
@cindex @code{~} (tilde) @subentry operatore @code{~}
@cindex tilde (@code{~}) @subentry operatore @code{~}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!~}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!~}
L'operando di destra degli operatori @samp{~} e @samp{!~} pu@`o essere sia una
costante @dfn{regexp} (@code{/}@dots{}@code{/}) che un'espressione ordinaria.
In quest'ultimo caso, il valore dell'espressione come stringa @`e usato come una
@dfn{regexp} dinamica (@pxref{Uso di @dfn{regexp}}; e
@pxref{Espressioni regolari calcolate}).
@cindex @command{awk} @subentry costanti @dfn{regexp} e
@cindex costanti @subentry @dfn{regexp}
@cindex @dfn{regexp} @subentry costanti
Un'espressione regolare costante tra due barre @`e di per s@'e anche
un'espressione. @code{/@var{regexp}/} @`e un'abbreviazione per la seguente
espressione di confronto:
@example
$0 ~ /@var{regexp}/
@end example
Una particolare posizione dove @code{/pippo/} @emph{non} @`e un'abbreviazione di
@samp{$0 ~ /pippo/} @`e quella in cui @`e l'operando di destra di @samp{~} o
@samp{!~}.
@xref{Usare le costanti @dfn{regexp}},
dove questo punto @`e trattato in maggiore dettaglio.
@node Confronto POSIX di stringhe
@subsubsection Confronto tra stringhe usando l'ordine di collazione locale
Lo standard POSIX diceva che il confronto di stringhe viene effettuato secondo
l'@dfn{ordine di collazione} locale. Questo @`e l'ordine secondo il quale sono
disposti i caratteri, come definito dalla localizzazione (per una trattazione
pi@`u dettagliata, @pxref{Localizzazioni}). Quest'ordine normalmente @`e molto
diverso dal risultato ottenuto quando si esegue un confronto rigorosamente
"carattere per carattere".@footnote{Tecnicamente, il confronto di stringhe
dovrebbe funzionare come se le stringhe fossero confrontate usando la
funzione @code{strcoll()} di C.}
@cindex modalit@`a POSIX
Poich@'e questo comportamento differisce sensibilmente dalla pratica corrente,
@command{gawk} lo implementava solo quando eseguito in modalit@`a POSIX
(@pxref{Opzioni}).
Quest'esempio ilustra la differenza, in una localizzazione
@code{en_US.UTF-8}:
@example
$ @kbd{gawk 'BEGIN @{ printf("ABC < abc = %s\n",}
> @kbd{("ABC" < "abc" ? "TRUE" : "FALSE")) @}'}
@print{} ABC < abc = TRUE
$ @kbd{gawk --posix 'BEGIN @{ printf("ABC < abc = %s\n",}
> @kbd{("ABC" < "abc" ? "TRUE" : "FALSE")) @}'}
@print{} ABC < abc = FALSE
@end example
Fortunatamente, dal mese di agosto 2016, un confronto basato sull'ordine
di collazione locale non @`e pi@`u richiesto per gli operatori @code{==} e
@code{!=}.@footnote{Si consulti il sito web
@uref{http://austingroupbugs.net/view.php?id=1070,
dell'Austin Group}.} Tuttavia, un confronto basato sull'ordine di
collazione locale @`e ancora richiesto per gli operatori @code{<},
@code{<=}, @code{>} e @code{>=}. POSIX, quindi, raccomanda quanto
segue:
@quotation
Poich@'e l'operatore @code{==} controlla che se le stringhe sono identiche,
e non se sono nell'ordine di collazione locale, le applicazioni che
devono controllare se le stringhe sono nell'ordine di collazione locale
possono usare:
@example
a <= b && a >= b
@end example
@end quotation
@cindex modalit@`a POSIX
A partire dalla @value{PVERSION} 4.2, @command{gawk} continua a usare
l'ordine di collazione locale per @code{<}, @code{<=}, @code{>}
e @code{>=} solo se eseguito nella modalit@`a POSIX.
@ignore
References: http://austingroupbugs.net/view.php?id=963
and http://austingroupbugs.net/view.php?id=1070.
@end ignore
@node Operatori booleani
@subsection Espressioni booleane
@cindex @dfn{and} (operatore logico-booleano)
@cindex @dfn{or} (operatore logico-booleano)
@cindex @dfn{not} (operatore logico-booleano)
@cindex espressioni @subentry booleane
@cindex booleane @subentry espressioni
@cindex operatori @subentry booleani @seeentry{espressioni booleane}
@cindex booleani @subentry operatori @seeentry{espressioni booleane}
@cindex logico @subentry operatore @seeentry{ espressioni booleane}
@cindex operatori @subentry logici @seeentry{espressioni booleane}
Un'@dfn{espressione booleana} @`e una combinazione di espressioni di confronto o
espressioni di ricerca, che usa gli operatori booleani "or"
(@samp{||}), "and" (@samp{&&}), e "not" (@samp{!}), facendo uso di
parentesi per controllare le nidificazioni. Il valore di verit@`a
dell'espressione booleana @`e calcolato calcolando i valori di verit@`a delle
espressioni componenti. Le espressioni booleane sono conosciute anche come
@dfn{espressioni logiche}. I due termini sono equivalenti.
Le espressioni booleane possono essere usate in tutti i casi in cui @`e possibile
usare espressioni di confronto e di ricerca di corrispondenze. Si possono
usare nelle istruzioni @code{if}, @code{while}, @code{do} e @code{for}
(@pxref{Istruzioni}).
Hanno valori numerici (uno se vero, zero se falso) che entrano in gioco
se il risultato di un'espressione booleana @`e memorizzato in una variabile o
se @`e usato nei calcoli.
Inoltre, ogni espressione booleana @`e anche un modello di ricerca valido, cos@`{@dotless{i}}
se ne pu@`o usare uno come modello di ricerca per controllare l'esecuzione di
regole. Gli operatori booleani sono:
@table @code
@item @var{booleano1} && @var{booleano2}
Vero se @var{booleano1} e @var{booleano2} sono entrambi veri. Per esempio,
la seguente istruzione stampa il record in input corrente se contiene
sia @samp{edu} che @samp{li}:
@example
if ($0 ~ /edu/ && $0 ~ /li/) print
@end example
@cindex effetti collaterali @subentry operatori booleani
La sottoespressione @var{booleano2} viene valutata solo se @var{booleano1}
@`e vero. Questo pu@`o comportare una differenza laddove @var{booleano2} contenga
espressioni che hanno effetti collaterali. Nel caso di @samp{$0 ~ /pippo/ &&
($2 == pluto++)}, la variabile @code{pluto} non viene incrementata se non c'@`e
nessuna sottostringa @samp{pippo} nel record.
@item @var{booleano1} || @var{booleano2}
Vero se almeno uno tra @var{booleano1} e @var{booleano2} @`e vero.
Per esempio, la seguente istruzione stampa tutti i record dell'input che
contengono @samp{edu} @emph{oppure}
@samp{li}:
@example
if ($0 ~ /edu/ || $0 ~ /li/) print
@end example
La sottoespressione @var{booleano2} viene valutata solo se @var{booleano1}
@`e falso. Questo pu@`o comportare una differenza quando @var{booleano2} contiene
espressioni che hanno effetti collaterali.
(Perci@`o, questo confronto non individua mai i record che contengono sia
@samp{edu} che @samp{li}: non appena @samp{edu} viene trovato,
l'intero confronto @`e concluso positivamente.)
@item ! @var{booleano}
Vero se @var{booleano} @`e falso. Per esempio,
il seguente programma stampa @samp{nessuna home!} nel
caso insolito che la variabile d'ambiente @env{HOME}
non sia stata definita:
@example
BEGIN @{ if (! ("HOME" in ENVIRON))
print "nessuna home!" @}
@end example
(L'operatore @code{in} @`e descritto in
@ref{Visitare elementi}.)
@end table
@cindex cortocircuito @subentry operatori
@cindex operatori @subentry di cortocircuito
@cindex @code{&} (e commerciale) @subentry operatore @code{&&}
@cindex e commerciale (@code{&}) @subentry operatore @code{&&}
@cindex @code{|} (barra verticale) @subentry operatore @code{||}
@cindex barra verticale (@code{|}) @subentry operatore @code{||}
Gli operatori @samp{&&} e @samp{||} sono chiamati operatori di
@dfn{cortocircuito} per il modo in cui funzionano. La valutazione dell'intera
espressione @`e "cortocircuitata" se il risultato pu@`o gi@`a essere determinato
prima di aver completato interamente la valutazione.
@cindex continuazione di riga
Le istruzioni che finiscono con @samp{&&} o @samp{||} si possono continuare
semplicemente mettendo un ritorno a capo dopo di esse. Per@`o non si pu@`o mettere
un ritorno a capo @emph{prima} di questi operatori senza usare la
continuazione tramite la barra inversa (@pxref{Istruzioni/Righe}).
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!}
@cindex ritorno a capo
@cindex variabili @subentry di tipo indicatore (@dfn{flag})
@cindex @dfn{flag} (indicatore), variabili di tipo
Il valore reale di un'espressione che usa l'operatore @samp{!} @`e uno
o zero, a seconda del valore di verit@`a dell'espressione a cui
@`e applicato.
L'operatore @samp{!} spesso @`e utile per cambiare il senso di una variabile
indicatore [@dfn{flag}] da falso a vero e viceversa. Per esempio, il seguente
programma @`e un modo per stampare righe poste tra due speciali righe
delimitatrici:
@example
$1 == "START" @{ pertinente = ! pertinente; next @}
pertinente @{ print @}
$1 == "END" @{ pertinente = ! pertinente; next @}
@end example
@noindent
La variabile @code{pertinente}, cos@`{@dotless{i}} come tutte le variabili di @command{awk},
@`e inizializzata a zero, che vale anche "falso". Quando viene trovata
una riga il cui primo campo @`e @samp{START}, il valore di @code{pertinente}
viene commutato a vero, usando @samp{!}. La regola nella riga seguente stampa righe finch@'e
@code{pertinente} resta vero. Quando viene trovata una riga il cui primo
campo @`e @samp{END}, @code{pertinente} viene nuovamente commutata a
falso.@footnote{Questo programma ha un bug; stampa righe che iniziano con
@samp{END}. Come si pu@`o risolvere?}
@ignore
Scott Deifik points out that this program isn't robust against
bogus input data, but the point is to illustrate the use of `!',
so we'll leave well enough alone.
@end ignore
Pi@`u comunemente, l'operatore @samp{!} viene usato nelle condizioni delle
istruzioni @code{if} e @code{while}, dove ha pi@`u senso formulare espressioni
logiche in negativo:
@example
if (! @var{qualche condizione} || @var{qualche altra condizione}) @{
@var{@dots{} fai un'operazione a piacere @dots{}}
@}
@end example
@cindex @code{next} (istruzione)
@quotation NOTA
L'istruzione @code{next} viene trattata in
@ref{Istruzione next}.
@code{next} dice ad @command{awk} di tralasciare il resto delle regole,
leggere il record successivo, e iniziare a elaborare le regole partendo
nuovamente dalla prima.
Il motivo @`e quello di evitare di stampare le righe delimitatrici
@samp{START} e @samp{END}.
@end quotation
@node Espressioni condizionali
@subsection Espressioni condizionali
@cindex condizionali @subentry espressioni
@cindex espressioni @subentry condizionali
@cindex espressioni @subentry selezionare
Un'@dfn{espressione condizionale} @`e un tipo particolare di espressione che ha
tre operandi. Consente di usare il primo valore dell'espressione per
scegliere una o l'altra delle due ulteriori espressioni.
L'espressione condizionale in @command{awk} @`e la stessa di quella del
linguaggio C, ovvero:
@example
@var{selettore} ? @var{espr-se-vero} : @var{espr-se-falso}
@end example
@noindent
Ci sono tre sottoespressioni. La prima, @var{selettore}, viene sempre
calcolata per prima. Se @`e "vera" (non zero o non nulla), viene poi calcolata
@var{espr-se-vero} e il suo valore diventa il valore dell'intera espressione.
Altrimenti, la seconda espressione che viene calcolata @`e @var{espr-se-falso}
e il suo valore diventa il valore dell'intera espressione.
Per esempio, la seguente espressione produce il valore assoluto di @code{x}:
@example
x >= 0 ? x : -x
@end example
@cindex effetti collaterali @subentry espressioni condizionali
Ogni volta che viene calcolata un'espressione condizionale, solo una delle
espressioni @var{espr-se-vero} e @var{espr-se-falso} viene usata; l'altra
@`e ignorata. Questo @`e importante quando le espressioni hanno effetti
collaterali. Per esempio, quest'espressione condizionale esamina l'elemento
@code{i} del vettore @code{a} o del vettore @code{b}, e incrementa @code{i}:
@example
x == y ? a[i++] : b[i++]
@end example
@noindent
Questa istruzione garantisce che @code{i} sia incrementato una volta sola
per ogni esecuzione dell'istruzione stessa, perch@'e ogni volta viene eseguita
solo una delle due espressioni di incremento, mentre l'altra viene
ignorata.
@iftex
@xrefil{Vettori},
@end iftex
@ifnottex
@xref{Vettori},
@end ifnottex
per maggiori informazioni sui vettori.
@cindex differenze tra @command{awk} e @command{gawk} @subentry continuazione di riga
@cindex continuazione di riga @subentry @command{gawk}
@cindex @command{gawk} @subentry continuazione di riga in
Come estensione minore di @command{gawk},
un'istruzione che usa @samp{?:} si pu@`o continuare mettendo
semplicemente un ritorno a capo dopo i due caratteri.
Tuttavia, se si mette un ritorno a capo @emph{prima} dei due
caratteri, la continuazione non funziona, se non si aggiunge anche la barra inversa
(@pxref{Istruzioni/Righe}).
Se viene specificata l'opzione @option{--posix}
(@pxref{Opzioni}), quest'estensione @`e disabilitata.
@node Chiamate di funzione
@section Chiamate di funzione
@cindex chiamare @subentry funzione
Una @dfn{funzione} @`e un nome per richiedere un particolare calcolo.
Il nome permette di richiamare
la funzione da qualsiasi punto del programma.
Per esempio, la funzione @code{sqrt()} calcola la radice quadrata di un numero.
@cindex funzioni @subentry predefinite
Un certo numero di funzioni sono @dfn{predefinite}, ossia sono
disponibili in ogni programma @command{awk}. La funzione @code{sqrt()} @`e una
di queste. @xref{Funzioni predefinite} per un elenco di funzioni
predefinite e per le loro rispettive descrizioni. In aggiunta, l'utente pu@`o
definire delle funzioni da usare nel proprio programma.
@xref{Funzioni definite dall'utente}
per istruzioni su come farlo.
Infine, @command{gawk} permette di scrivere funzioni in C o in C++ che possono
essere chiamate dal proprio programma (@pxref{Estensioni dinamiche}).
@cindex argomenti @subentry nelle chiamate di funzione
Una funzione viene utilizzata invocandola tramite un'espressione di
@dfn{chiamata di funzione}, che consiste nel nome della funzione seguito
immediatamente da una lista di @dfn{argomenti} tra parentesi. Gli argomenti
sono espressioni che forniscono i materiali grezzi su cui opera la funzione.
Quando ci sono pi@`u argomenti, questi sono separati da virgole. Se
non ci sono argomenti, basta scrivere @samp{()} dopo il nome della funzione.
Gli esempi che seguono mostrano chiamate di funzione con e senza argomenti:
@example
sqrt(x^2 + y^2) @ii{un argomento}
atan2(y, x) @ii{due argomenti}
rand() @ii{nessun argomento}
@end example
@cindex risoluzione di problemi @subentry sintassi della chiamata di funzione
@cindex problemi @subentry risoluzione di @subentry sintassi della chiamata di funzione
@quotation ATTENZIONE
Non ci dev'essere nessuno spazio tra il nome della funzione e la parentesi
aperta! Un nome di funzione definita dall'utente pu@`o essere scambiata per
il nome di una
variabile: uno spazio renderebbe l'espressione simile alla concatenazione di
una variabile con un'espressione racchiusa tra parentesi.
Per le funzioni predefinite, lo spazio prima delle parentesi non crea problemi,
ma @`e meglio non prendere l'abitudine di usare spazi per evitare errori con le
funzioni definite dall'utente.
@end quotation
Ogni funzione richiede uno specifico numero di argomenti.
Per esempio, la funzione @code{sqrt()} dev'essere chiamata con
un solo argomento, il numero del quale si vuole estrarre la radice quadrata:
@example
sqrt(@var{argomento})
@end example
Alcune delle funzioni predefinite hanno uno o pi@`u argomenti opzionali.
Se questi argomenti non vengono forniti, le funzioni
usano un valore di default appropriato.
@xref{Funzioni predefinite} per tutti i dettagli. Se sono omessi argomenti
in chiamate a funzioni definite dall'utente, tali argomenti sono considerati
essere variabili locali. Il valore di tali variabili locali
@`e la stringa nulla se usate in un contesto che richiede una stringa
di caratteri, e lo zero se @`e richiesto
un valore numerico
(@pxref{Funzioni definite dall'utente}).
Come funzionalit@`a avanzata, @command{gawk} prevede la possibilit@`a di
effettuare chiamate di funzione
indirette, il che permette di scegliere la funzione da chiamare al momento
dell'esecuzione, invece che nel momento in cui si scrive il codice sorgente
del programma.
Si rimanda la trattazione di questa funzionalit@`a
a un secondo momento; si veda @ref{Chiamate indirette}.
@cindex effetti collaterali @subentry chiamate di funzione
Come ogni altra espressione, la chiamata di funzione ha un valore, chiamato
spesso @dfn{valore di ritorno}, che @`e calcolato dalla funzione
in base agli argomenti dati. In quest'esempio, il codice di ritorno
di @samp{sqrt(@var{argomento})} @`e la radice quadrata di @var{argomento}.
Il seguente programma legge numeri, un numero per riga, e stampa
la radice quadrata di ciascuno:
@example
$ @kbd{awk '@{ print "La radice quadrata di", $1, "@`e", sqrt($1) @}'}
@kbd{1}
@print{} La radice quadrata di 1 @`e 1
@kbd{3}
@print{} La radice quadrata di 3 @`e 1.73205
@kbd{5}
@print{} La radice quadrata di 5 @`e 2.23607
@kbd{Ctrl-d}
@end example
Una funzione pu@`o avere anche effetti collaterali, come assegnare
valori a certe variabili o effettuare operazioni di I/O.
Questo programma mostra come la funzione @code{match()}
(@pxref{Funzioni per stringhe})
cambia le variabili @code{RSTART} e @code{RLENGTH}:
@example
@{
if (match($1, $2))
print RSTART, RLENGTH
else
print "non uguali"
@}
@end example
@noindent
Qui vediamo un'esecuzione di esempio:
@example
$ @kbd{awk -f matchit.awk}
@kbd{aaccdd c+}
@print{} 3 2
@kbd{pippo pluto}
@print{} non uguali
@kbd{abcdefg e}
@print{} 5 1
@end example
@node Precedenza
@section Precedenza degli operatori (Come si nidificano gli operatori)
@cindex precedenza
@cindex operatori @subentry precedenza
La @dfn{precedenza degli operatori} determina come gli operatori vengono
raggruppati quando diversi operatori appaiono uno vicino all'altro in
un'espressione.
Per esempio, @samp{*} ha una precedenza pi@`u alta di @samp{+}; cos@`{@dotless{i}},
@samp{a + b * c} moltiplica @code{b} e @code{c}, e poi aggiunge @code{a} al
prodotto (ovvero esegue @samp{a + (b * c)}).
La normale precedenza degli operatori pu@`o essere cambiata usando delle
parentesi. Si possono vedere le regole di precedenza come un modo per
indicare dove si sarebbero dovute mettere delle parentesi. Di fatto,
@`e cosa saggia usare sempre le parentesi
in presenza di una combinazione di operatori insolita, perch@'e altre persone
che leggono il programma potrebbero non ricordare quale sia la precedenza
in quel particolare caso.
Anche dei programmatori esperti a volte dimenticano le regole esatte,
il che porta a commettere errori.
Usare esplicitamente le parentesi previene qualunque errore
di questo tipo.
Quando vengono usati insieme operatori con uguale precedenza, quello pi@`u a
sinistra viene raggruppato per primo, ad eccezione degli operatori di
assegnamento, condizionali e di elevamento a potenza, che vengono raggruppati
nell'ordine opposto.
Quindi, @samp{a - b + c} raggruppa come @samp{(a - b) + c} e
@samp{a = b = c} raggruppa come @samp{a = (b = c)}.
Normalmente la precedenza degli operatori unari di prefisso non ha importanza,
perch@'e c'@`e un solo modo di interpretarli: prima il pi@`u interno. Quindi,
@samp{$++i} significa @samp{$(++i)} e
@samp{++$x} significa @samp{++($x)}. Tuttavia, quando un altro operatore segue
l'operando, la precedenza degli operatori unari pu@`o avere importanza.
@samp{$x^2} significa @samp{($x)^2}, ma @samp{-x^2} significa
@samp{-(x^2)}, perch@'e @samp{-} ha precedenza pi@`u bassa rispetto a @samp{^},
mentre @samp{$} ha precedenza pi@`u alta.
Inoltre, gli operatori non possono essere combinati in modo tale da violare le
regole di precedenza; per esempio, @samp{$$0++--} non @`e un'espressione valida
perch@'e il primo @samp{$} ha precedenza pi@`u alta di
@samp{++}; per evitare il problema l'espressione pu@`o essere scritta come
@samp{$($0++)--}.
Questa lista illustra gli operatori di @command{awk}, in ordine di precedenza
dalla pi@`u alta alla pi@`u bassa:
@c @asis for docbook to come out right
@table @asis
@item @code{(}@dots{}@code{)}
Raggruppamento.
@cindex @code{$} (dollaro) @subentry operatore di campo @code{$}
@cindex dollaro (@code{$}) @subentry operatore di campo @code{$}
@item @code{$}
Riferimento a un campo.
@cindex @code{+} (pi@`u) @subentry operatore @code{++}
@cindex pi@`u (@code{+}) @subentry operatore @code{++}
@cindex @code{-} (meno) @subentry operatore @code{--}
@cindex meno (@code{-}) @subentry operatore @code{--}
@item @code{++ --}
Incremento, decremento.
@cindex @code{^} (circonflesso) @subentry operatore @code{^}
@cindex circonflesso (@code{^}) @subentry operatore @code{^}
@cindex @code{*} (asterisco) @subentry operatore @code{**}
@cindex asterisco (@code{*}) @subentry operatore @code{**}
@item @code{^ **}
Elevamento a potenza. Questi operatori sono raggruppati da destra verso
sinistra.
@cindex @code{+} (pi@`u) @subentry operatore @code{+}
@cindex pi@`u (@code{+}) @subentry operatore @code{+}
@cindex @code{-} (meno) @subentry operatore @code{-}
@cindex meno (@code{-}) @subentry operatore @code{-}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!}
@item @code{+ - !}
Pi@`u, meno, ``not'' logico, unari.
@cindex @code{*} (asterisco) @subentry operatore @code{*} @subentry come operatore di moltiplicazione
@cindex asterisco (@code{*}) @subentry operatore @code{*} @subentry come operatore di moltiplicazione
@cindex @code{/} (barra) @subentry operatore @code{/}
@cindex barra (@code{/}) @subentry operatore @code{/}
@cindex @code{%} (percento) @subentry operatore @code{%}
@cindex percento (@code{%}) @subentry operatore @code{%}
@item @code{* / %}
Moltiplicazione, divisione, resto di una divisione.
@cindex @code{+} (pi@`u) @subentry operatore @code{+}
@cindex pi@`u (@code{+}) @subentry operatore @code{+}
@cindex @code{-} (meno) @subentry operatore @code{-}
@cindex meno (@code{-}) @subentry operatore @code{-}
@item @code{+ -}
Addizione, sottrazione.
@item Concatenazione di stringhe
Non c'@`e un simbolo speciale per la concatenazione.
Gli operandi sono semplicemente scritti uno accanto all'altro.
(@pxref{Concatenazione}).
@cindex @code{<} (parentesi acuta sinistra) @subentry operatore @code{<}
@cindex parentesi @subentry acuta sinistra (@code{<}) @subentry operatore @code{<}
@cindex @code{<} (parentesi acuta sinistra) @subentry operatore @code{<=}
@cindex parentesi @subentry acuta sinistra (@code{<}) @subentry operatore @code{<=}
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>=}
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>=}
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>}
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>}
@cindex @code{=} (uguale) @subentry operatore @code{==}
@cindex uguale (@code{=}) @subentry operatore @code{==}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!=}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!=}
@cindex @code{>} (parentesi acuta destra) @subentry operatore @code{>>} (I/O)
@cindex parentesi @subentry acuta destra (@code{>}) @subentry operatore @code{>>} (I/O)
@cindex operatori @subentry input/output
@cindex @code{|} (barra verticale) @subentry operatore @code{|} (I/O)
@cindex barra verticale (@code{|}) @subentry operatore @code{|} (I/O)
@cindex operatori @subentry input/output
@cindex @code{|} (barra verticale) @subentry operatore @code{|&} (I/O)
@cindex barra verticale (@code{|}) @subentry operatore @code{|&} (I/O)
@cindex operatori @subentry input/output
@item @code{< <= == != > >= >> | |&}
Operatori relazionali e ridirezione.
Gli operatori relazionali e le ridirezioni hanno lo stesso livello di
precedenza. I caratteri come @samp{>} servono sia come operatori relazionali
che come ridirezioni; la distinzione tra i due significati dipende dal
contesto.
@cindex istruzione @subentry @code{print} @subentry operatori I/O in
@cindex istruzione @subentry @code{printf} @subentry operatori I/O in
Si noti che gli operatori di ridirezione I/O nelle istruzioni @code{print} e
@code{printf} appartengono al livello dell'istruzione, non alle espressioni.
La ridirezione non produce un'espressione che potrebbe essere l'operando di un
altro operatore. Di conseguenza, non ha senso usare un operatore di
ridirezione vicino a un altro operatore con precedenza pi@`u bassa senza
parentesi. Tali combinazioni generano errori di sintassi
(p.es., @samp{print pippo > a ? b : c}).
Il modo corretto di scrivere quest'istruzione @`e @samp{print pippo > (a ? b : c)}.
@cindex @code{~} (tilde) @subentry operatore @code{~}
@cindex tilde (@code{~}) @subentry operatore @code{~}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!~}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!~}
@item @code{~ !~}
Corrispondenza, non corrispondenza.
@cindex @code{in} (operatore)
@item @code{in}
Appartenenza a un vettore.
@cindex @code{&} (e commerciale) @subentry operatore @code{&&}
@cindex e commerciale (@code{&}) @subentry operatore @code{&&}
@item @code{&&}
``and'' logico.
@cindex @code{|} (barra verticale) @subentry operatore @code{||}
@cindex barra verticale (@code{|}) @subentry operatore @code{||}
@item @code{||}
``or'' logico.
@cindex @code{?} (punto interrogativo) @subentry operatore @code{?:}
@cindex punto interrogativo (@code{?}) @subentry operatore @code{?:}
@cindex @code{:} (due punti) @subentry operatore @code{?:}
@cindex due punti (@code{:}) @subentry operatore @code{?:}
@item @code{?:}
Operatore condizionale. Questo operatore raggruppa da destra verso sinistra.
@cindex @code{+} (pi@`u) @subentry operatore @code{+=}
@cindex pi@`u (@code{+}) @subentry operatore @code{+=}
@cindex @code{-} (meno) @subentry operatore @code{-=}
@cindex meno (@code{-}) @subentry operatore @code{-=}
@cindex @code{*} (asterisco) @subentry operatore @code{*=}
@cindex asterisco (@code{*}) @subentry operatore @code{*=}
@cindex @code{*} (asterisco) @subentry operatore @code{**=}
@cindex asterisco (@code{*}) @subentry operatore @code{**=}
@cindex @code{/} (barra) @subentry operatore @code{/=}
@cindex barra (@code{/}) @subentry operatore @code{/=}
@cindex @code{%} (percento) @subentry operatore @code{%=}
@cindex percento (@code{%}) @subentry operatore @code{%=}
@cindex @code{^} (circonflesso) @subentry operatore @code{^=}
@cindex circonflesso (@code{^}) @subentry operatore @code{^=}
@item @code{= += -= *= /= %= ^= **=}
Assegnamento. Questi operatori raggruppano da destra verso sinistra.
@end table
@cindex POSIX @command{awk} @subentry @code{**} (operatore)
@cindex portabilit@`a @subentry operatori @subentry non in POSIX @command{awk}
@quotation NOTA
Gli operatori @samp{|&}, @samp{**} e @samp{**=} non sono definiti da POSIX.
Per la massima portabilit@`a, @`e meglio non usarli.
@end quotation
@node Localizzazioni
@section Il luogo fa la differenza
@cindex localizzazione @subentry definizione di
I moderni sistemi prevedono la nozione di @dfn{localizzazione}: un modo per
informare il sistema sulla serie di caratteri e sulla lingua locali.
Lo standard ISO C definisce una localizzazione di default @code{"C"}, che @`e
l'ambiente tipico a cui molti programmatori in C sono abituati.
Un tempo, le impostazioni della localizzazione avevano influenza sulla
ricerca di corrispondenze tramite @dfn{regexp}, ma ora non @`e pi@`u cos@`{@dotless{i}}
(@pxref{Intervalli e localizzazione}).
La localizzazione pu@`o influire sulla separazione dei record. Per il caso
normale di @samp{RS = "\n"}, la localizzazione @`e generalmente irrilevante.
Per altri separatori di record di un solo carattere, impostare
la variabile d'ambiente @samp{LC_ALL=C}
garantisce una migliore efficienza nella lettura dei record. Altrimenti,
@command{gawk} dovrebbe fare diverse chiamate di funzione, @emph{per ogni
carattere in input}, per determinare la fine del record.
La localizzazione pu@`o influire sulla formattazione delle date e delle ore
(@pxref{Funzioni di tempo}). Per esempio, un modo comune per abbreviare la
data 4 settembre 2015, negli Stati Uniti @`e ``9/4/15.'' In molti paesi
dell'Europa, invece, l'abbreviazione @`e "4.9.15". Quindi, la specifica di
formato
@code{%x} in una localizzazione @code{"US"} potrebbe produrre @samp{9/4/15},
mentre in una localizzazione @code{"EUROPA"}, potrebbe produrre @samp{4.9.15}.
Secondo POSIX, anche il confronto tra stringhe @`e influenzato dalla
localizzazione (come nelle espressioni regolari). I dettagli sono descritti in
@ref{Confronto POSIX di stringhe}.
Infine, la localizzazione influenza il valore del separatore decimale
usato quando @command{gawk} analizza i dati in input. Questo @`e stato
trattato nel dettaglio in @ref{Conversione}.
@node Sommario delle espressioni
@section Sommario
@itemize @value{BULLET}
@item
Le espressioni sono gli elementi base dei calcoli eseguiti nei programmi.
Sono costruite a partire da costanti, variabili, chiamate di funzione e dalla
combinazione di vari tipi di valori tramite operatori.
@item
@command{awk} fornisce tre tipi di costanti: numerica, di stringa e
di @dfn{regexp}. Le costanti numeriche in @command{gawk} si possono
specificare nei sistemi ottale ed esadecimale (con base 8 e 16), e anche nel
sistema decimale (base 10). In alcuni contesti, una costante @dfn{regexp}
isolata come @code{/pippo/} ha lo stesso significato di @samp{$0 ~ /pippo/}.
@item
Le variabili contengono valori che possono essere usati diverse volte nei
calcoli. Un certo numero di variabili predefinite forniscono informazioni al
programma @command{awk}, mentre altre permettono il controllo del comportamento
di @command{awk}.
@item
I numeri sono automaticamente convertiti in stringhe, e le stringhe in numeri,
a seconda delle necessit@`a di @command{awk}. I valori numerici sono convertiti
come se fossero formattati con @code{sprintf()} usando il formato contenuto in
@code{CONVFMT}. La localizzazione pu@`o influire sulle conversioni.
@item
In @command{awk} ci sono gli operatori aritmetici di uso comune (addizione,
sottrazione, moltiplicazione, divisione, modulo), e il pi@`u e il meno unari.
Ci sono anche operatori di confronto, operatori booleani, una verifica
dell'esistenza di una chiave in
un vettore, e operatori per la ricerca di corrispondenze con espressioni
regolari. La concatenazione di stringhe @`e effettuata mettendo due espressioni
una vicino all'altra; non c'@`e nessun operatore esplicito.
L'operatore con tre operandi @samp{?:} fornisce una verifica ``if-else''
all'interno delle espressioni.
@item
Gli operatori di assegnamento forniscono delle comode forme brevi per le comuni
operazioni aritmetiche.
@item
In @command{awk}, un valore @`e considerato vero se @`e diverso da zero
@emph{oppure} non nullo. Altrimenti, il valore @`e falso.
@item
Il tipo di una variabile viene impostata a ogni assegnamento e pu@`o cambiare
durante il suo ciclo di vita. Il tipo determina il comportamento della
variabile nei confronti (di tipo stringa o numerici).
@item
Le chiamate di funzione restituiscono un valore che pu@`o essere usato come parte
di un'espressione pi@`u lunga. Le espressioni usate per passare valori di
parametro vengono valutate completamente prima di chiamare la funzione.
@command{awk} fornisce funzioni predefinite e prevede quelle definite
dall'utente; questo @`e descritto in
@ref{Funzioni}.
@item
La precedenza degli operatori specifica l'ordine secondo il quale vengono
effettuate le operazioni, a meno che quest'ordine non sia esplicitamente
alterato
tramite parentesi. Le regole di precedenza degli operatori di @command{awk}
sono compatibili con quelle del linguaggio C.
@item
La localizzazione pu@`o influire sul formato dei dati in uscita da un programma
@command{awk}, e occasionalmente sul formato dei dati letti in input.
@end itemize
@node Criteri di ricerca e azioni
@chapter Criteri di ricerca, azioni e variabili
@cindex criteri di ricerca
@cindex @dfn{pattern} @seeentry{criteri di ricerca}
@cindex espressioni @subentry di ricerca
Come gi@`a visto, ogni istruzione @command{awk} consiste di un criterio di
ricerca [@dfn{pattern}] a cui @`e associata un'azione. Questo @value{CHAPTER}
descrive come specificare criteri e azioni, cosa @`e possibile
fare tramite le azioni e quali sono le variabili predefinite in
@command{awk}.
Le regole @dfn{criterio di ricerca--azione} e le istruzioni che si possono
dare all'interno delle azioni formano il nucleo centrale dei programmi
scritti in @command{awk}.
In un certo senso, tutto quanto si @`e visto finora costituisce le fondamenta
sulle quali sono costruiti i programmi. @`E giunto il momento di iniziare a
costruire qualcosa di utile.
@menu
* Panoramica sui criteri di ricerca:: Come scrivere un criterio di ricerca.
* Usare variabili di shell:: come usare variabili della shell in
@command{awk}.
* Panoramica sulle azioni:: Come scrivere un'azione.
* Istruzioni:: Descrizione dettagliata delle varie
istruzioni di controllo.
* Variabili predefinite:: Sommario delle variabili predefinite.
* Sommario criteri e azioni:: Sommario di criteri di ricerca e azioni.
@end menu
@node Panoramica sui criteri di ricerca
@section Elementi di un criterio di ricerca
@menu
* @dfn{regexp} come criteri di ricerca:: Usare espressioni regolari come
criteri di ricerca.
* Espressioni come criteri di ricerca:: Qualsiasi espressione pu@`o servire da
criterio di ricerca.
* Intervalli:: Coppie di espressioni regolari per
delimitare una ricerca.
* BEGIN/END:: Specificare regole di inizio e fine programma.
* BEGINFILE/ENDFILE:: Due condizioni speciali per controlli avanzati.
* Vuoto:: Il criterio di ricerca vuoto, che
corrisponde a ogni record.
@end menu
@cindex criteri di ricerca @subentry tipi di
I criteri di ricerca in @command{awk} controllano l'esecuzione di
azioni: un'azione viene eseguita
quando il criterio di ricerca associato ad essa @`e soddisfatto dal
record in input corrente.
La tabella seguente @`e un sommario dei tipi di criteri di ricerca in
@command{awk}:
@table @code
@item /@var{espressione regolare}/
Un'espressione regolare. @`E verificata quando il testo di un
record in input corrisponde all'espressione regolare.
@iftex
(@xrefIl{Espressioni regolari}.)
@end iftex
@ifnottex
(@xref{Espressioni regolari}.)
@end ifnottex
@item @var{espressione}
Una singola espressione. @`E verificata quando il suo valore @`e
diverso da zero (se di tipo numerico) o non nullo (se @`e una stringa).
(@xref{Espressioni come criteri di ricerca}.)
@item @var{inizio_interv}, @var{fine_interv}
Una coppia di criteri di ricerca separati da una virgola, che specificano un
@dfn{intervallo} di record.
L'intervallo comprende sia il record iniziale che corrisponde a @var{inizio_interv}
sia il record finale che corrisponde a @var{fine_interv}.
(@xref{Intervalli}.)
@item BEGIN
@itemx END
Criteri di ricerca speciali che consentono azioni di inizializzazione o
di pulizia in un programma @command{awk}.
(@xref{BEGIN/END}.)
@item BEGINFILE
@itemx ENDFILE
Criteri di ricerca speciali che consentono azioni di inizializzazione o di
pulizia da eseguire all'inizio o alla fine di ogni file in input.
(@xref{BEGINFILE/ENDFILE}.)
@item @var{vuoto}
Il criterio di ricerca vuoto corrisponde a ciascun record in input.
(@xref{Vuoto}.)
@end table
@node @dfn{regexp} come criteri di ricerca
@subsection Espressioni regolari come criteri di ricerca
@cindex criteri di ricerca @subentry espressioni regolari come
@cindex espressioni regolari @subentry come criteri di ricerca
Le espressioni regolari sono uno dei primi tipi di criteri di ricerca
presentati in questo @value{DOCUMENT}.
Questo tipo di criterio di ricerca @`e semplicemente una costante @dfn{regexp}
posta nella parte @dfn{criterio di ricerca} di una regola. Equivale a
scrivere @samp{$0 ~ /@var{criterio di ricerca}/}.
Il criterio di ricerca @`e verificato quando il record in input corrisponde
alla @dfn{regexp}.
Per esempio:
@example
/pippo|pluto|paperino/ @{ personaggi_Disney++ @}
END @{ print personaggi_Disney, "Personaggi Disney visti" @}
@end example
@node Espressioni come criteri di ricerca
@subsection Espressioni come criteri di ricerca
@cindex espressioni regolari @subentry come criteri di ricerca
@cindex criteri di ricerca @subentry espressioni regolari come
Qualsiasi espressione @command{awk} pu@`o essere usata come un criterio di
ricerca @command{awk}.
Il criterio di ricerca @`e verificato se il valore dell'espressione @`e diverso
da zero (se @`e un numero), o non nullo (se @`e una stringa).
L'espressione @`e ricalcolata ogni volta che la regola viene applicata a un
nuovo record in input. Se l'espressione usa campi come @code{$1}, il suo
valore dipende direttamente dal contenuto del record in input appena letto;
altrimenti, dipende solo da quel che @`e accaduto fino a quel momento durante
l'esecuzione del programma @command{awk}.
@cindex espressioni @subentry di confronto @subentry come criteri di ricerca
@cindex criteri di ricerca @subentry espressioni di confronto come
Le espressioni di confronto, che usano gli operatori di confronto descritti in
@ref{Tipi di variabile e confronti},
sono un tipo di criterio di ricerca usato frequentemente.
Anche le @dfn{regexp}, verificate o non verificate, sono tipi di espressioni molto frequenti.
L'operando a sinistra degli operatori @samp{~} e @samp{!~} @`e una stringa.
L'operando di destra @`e un'espressione regolare costante delimitata da
barre (@code{/@var{@dfn{regexp}}/}) o qualsiasi espressione il cui valore come
stringa @`e usato come un'espressione regolare dinamica
(@pxref{Espressioni regolari calcolate}).
L'esempio seguente stampa il secondo campo di ogni record in input
il cui primo campo sia esattamente @samp{li}:
@cindex @code{/} (barra) @subentry criteri di ricerca e
@cindex barra (@code{/}) @subentry criteri di ricerca e
@cindex @code{~} (tilde) @subentry operatore @code{~}
@cindex tilde (@code{~}) @subentry operatore @code{~}
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!~}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!~}
@example
$ @kbd{awk '$1 == "li" @{ print $2 @}' mail-list}
@end example
@noindent
(Il programma non stampa alcun output, perch@'e nessuna persona ha come nome esattamente @samp{li}.)
Si veda la differenza con il seguente confronto di espressione regolare, che
individua invece qualsiasi record il cui primo campo @emph{contenga} @samp{li}:
@example
$ @kbd{awk '$1 ~ /li/ @{ print $2 @}' mail-list}
@print{} 555-5553
@print{} 555-6699
@end example
@cindex @dfn{regexp} @subentry costanti @subentry come criteri di ricerca
@cindex criteri di ricerca @subentry costanti @dfn{regexp} come
Una costante @dfn{regexp} usata come criterio di ricerca @`e anche un
caso speciale di criterio di ricerca costituito da un'espressione.
All'espressione @code{/li/} viene assegnato il valore uno se @samp{li}
viene trovato nel record in input corrente. Quindi, come criterio di ricerca,
@code{/li/} individua tutti i record che contengono la stringa @samp{li}.
@cindex espressioni @subentry booleane @subentry come criteri di ricerca
@cindex criteri di ricerca @subentry espressioni booleane come
Anche le espressioni booleane sono frequentemente usate come criteri di
ricerca. Se un criterio di ricerca
individua o no un record in input dipende dalla verifica delle
sottoespressioni da cui @`e composto.
Per esempio, il seguente comando stampa tutti i record in
@file{mail-list} che contengono sia @samp{edu} che @samp{li}:
@example
$ @kbd{awk '/edu/ && /li/' mail-list}
@print{} Samuel 555-3430 samuel.lanceolis@@shu.edu A
@end example
Il seguente comando stampa tutti i record in
@file{mail-list} che contengono @samp{edu} @emph{oppure} @samp{li}
(o entrambi, naturalmente):
@example
$ @kbd{awk '/edu/ || /li/' mail-list}
@print{} Amelia 555-5553 amelia.zodiacusque@@gmail.com F
@print{} Broderick 555-0542 broderick.aliquotiens@@yahoo.com R
@print{} Fabius 555-1234 fabius.undevicesimus@@ucb.edu F
@print{} Julie 555-6699 julie.perscrutabor@@skeeve.com F
@print{} Samuel 555-3430 samuel.lanceolis@@shu.edu A
@print{} Jean-Paul 555-2127 jeanpaul.campanorum@@nyu.edu R
@end example
Il seguente comando stampa tutti i record in
@file{mail-list} che @emph{non} contengono la stringa @samp{li}:
@example
$ @kbd{awk '! /li/' mail-list}
@print{} Anthony 555-3412 anthony.asserturo@@hotmail.com A
@print{} Becky 555-7685 becky.algebrarum@@gmail.com A
@print{} Bill 555-1675 bill.drowning@@hotmail.com A
@print{} Camilla 555-2912 camilla.infusarum@@skynet.be R
@print{} Fabius 555-1234 fabius.undevicesimus@@ucb.edu F
@group
@print{} Martin 555-6480 martin.codicibus@@hotmail.com A
@print{} Jean-Paul 555-2127 jeanpaul.campanorum@@nyu.edu R
@end group
@end example
@cindex @code{BEGIN} (regola) @subentry criteri di ricerca booleani e
@cindex @code{END} (regola) @subentry criteri di ricerca booleani e
@cindex @code{BEGINFILE} (regola) @subentry criteri di ricerca booleani e
@cindex @code{ENDFILE} (regola) @subentry criteri di ricerca booleani e
Le sottoespressioni di un'operatore booleano in un criterio di ricerca possono
essere espressioni regolari costanti, confronti, o qualsiasi altra espressione
di @command{awk}. Gli intervalli di ricerca
non sono espressioni, e quindi non possono apparire all'interno di
criteri di ricerca booleani. Analogamente, i criteri di ricerca speciali
@code{BEGIN}, @code{END}, @code{BEGINFILE} ed @code{ENDFILE},
che non corrispondono ad alcun record in input, non sono espressioni e non
possono essere usati all'interno di criteri di ricerca booleani.
L'ordine di precedenza dei differenti operatori che possono essere usati nei
criteri di ricerca @`e descritto in @ref{Precedenza}.
@node Intervalli
@subsection Specificare intervalli di record con i criteri di ricerca
@cindex intervalli di ricerca
@cindex criteri di ricerca @subentry intervalli nei
@cindex righe @subentry individuare intervalli di
@cindex @code{,} (virgola), negli intervalli di ricerca
@cindex virgola (@code{,}), negli intervalli di ricerca
Un @dfn{intervallo di ricerca} @`e composto da due criteri di ricerca
separati da una virgola, nella forma
@samp{@var{inizio_intervallo}, @var{fine_intervallo}}. @`E usato per
individuare
una serie di record consecutivi nei file in input. Il primo criterio di
ricerca, @var{inizio_intervallo}, controlla dove inizia la serie di record,
mentre @var{fine_intervallo} controlla dove finisce la serie stessa.
L'esempio seguente:
@example
awk '$1 == "on", $1 == "off"' miofile
@end example
@noindent
stampa ogni record in @file{miofile} incluso tra i due record che iniziano con
@samp{on}/@samp{off}, estremi compresi.
Un intervallo di ricerca inizia con la valutazione di
@var{inizio_intervallo} per ogni record in input. Quando un record soddisfa
la condizione @var{inizio_intervallo}, l'intervallo di ricerca @`e
@dfn{attivato} e l'intervallo di ricerca include anche quel
record. Finch@'e l'intervallo di ricerca rimane attivo,
automaticamente vengono trovate corrispondenze in ogni record in input letto.
L'intervallo di ricerca verifica anche @var{fine_intervallo} per ogni
record in input; quando la verifica ha successo, il
criterio di ricerca viene @dfn{disattivato} a partire dal record seguente.
Quindi il criterio di ricerca torna a controllare
@var{inizio_intervallo} per ogni nuovo record.
@cindex @code{if} (istruzione) @subentry azioni, modificabili
Il record che segnala l'inizio dell'intervallo
di ricerca e quello che segnala la fine di quell'intervallo soddisfano
@emph{entrambi} il criterio di ricerca. Se non si vuole agire su tali record
si possono scrivere istruzioni @code{if} nella parte @dfn{azione} della regola
per distinguerli dai record che il programma @`e interessato a trattare.
@`E possibile che un criterio di ricerca sia attivato e disattivato dallo
stesso record. Se il record soddisfa entrambe le condizioni, l'azione @`e
eseguita solo su quel record.
Per esempio, si supponga che ci sia un testo tra due separatori identici
(p.es., il simbolo @samp{%}), ognuno dei quali sia su una riga a parte, che
dovrebbero essere ignorati. Un primo tentativo potrebbe essere quello di
combinare un intervallo di ricerca che descrive il
testo delimitato con l'istruzione
@code{next}
(non ancora introdotta, @pxref{Istruzione next}).
Con quest'istruzione @command{awk} non effettua alcuna azione sul record
corrente e inizia di nuovo a elaborare il successivo record in input.
Un tale programma @`e simile a questo:
@example
/^%$/,/^%$/ @{ next @}
@{ print @}
@end example
@noindent
@cindex righe @subentry saltare tra delimitatori
@c @cindex @dfn{flag} variables
Questo programma non funziona, perch@'e l'intervallo di ricerca @`e sia attivato
che disattivato dalla prima riga incontrata, quella costituita da un @samp{%}.
Per ottenere l'effetto desiderato, si scriva il programma nella maniera che
segue, utilizzando un @dfn{flag}:
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!}
@example
/^%$/ @{ ignora = ! ignora; next @}
ignora == 1 @{ next @} # ignora righe quando `ignora' @`e impostato a 1
@end example
In un intervallo di ricerca, la virgola (@samp{,}) ha la
precedenza pi@`u bassa tra tutti gli operatori (cio@`e, @`e l'ultima a essere
valutata). Il programma seguente tenta di combinare un intervallo di
ricerca con un altro controllo, pi@`u semplice:
@example
echo Yes | awk '/1/,/2/ || /Yes/'
@end example
L'intenzione in questo programma @`e quello di esprimere le condizioni
@samp{(/1/,/2/) || /Yes/}.
Tuttavia, @command{awk} lo interpreta come se fosse
@samp{/1/, (/2/ || /Yes/)}.
Questo comportamento non pu@`o essere cambiato o evitato; gli intervalli di
ricerca non si possono combinare con altri criteri di ricerca:
@example
$ @kbd{echo Yes | gawk '(/1/,/2/) || /Yes/'}
@error{} gawk: riga com.:1: (/1/,/2/) || /Yes/
@error{} gawk: riga com.:1: ^ syntax error
@end example
@cindex intervalli di ricerca @subentry continuazione di riga e
@cindex angolo buio @subentry intervalli di ricerca @subentry continuazione di riga e
Come punto di secondaria importanza, nonostante sia stilisticamente poco elegante,
lo standard POSIX consente di andare a capo dopo la virgola
in un intervallo di ricerca. @value{DARKCORNER}
@node BEGIN/END
@subsection I criteri di ricerca speciali @code{BEGIN} ed @code{END}
@cindex @code{BEGIN} (regola)
@cindex @code{END} (regola)
@cindex regola @subentry @code{END}
Tutti i criteri di ricerca fin qui descritti servono a individuare dei record
in input.
I criteri di ricerca speciali @code{BEGIN} ed @code{END} non hanno questo scopo.
Servono invece per effettuare azioni di inizializzazione o di pulizia nei
programmi @command{awk}.
Le regole @code{BEGIN} ed @code{END} devono prevedere azioni; non c'@`e
un'azione di default per queste regole, perch@'e non c'@`e un record corrente
quando sono invocate.
Le regole @code{BEGIN} ed @code{END} sono spesso chiamate
``blocchi @code{BEGIN} ed @code{END}'' da programmatori che usano @command{awk}
da molto tempo.
@menu
* Usare BEGIN/END:: Come e perch@'e usare regole BEGIN/END.
* I/O e BEGIN/END:: Problemi di I/O nelle regole BEGIN/END.
@end menu
@node Usare BEGIN/END
@subsubsection Azioni di inizializzazione e pulizia
@cindex @code{BEGIN} (regola)
@cindex regola @subentry @code{BEGIN}
@cindex @code{END} (regola)
@cindex regola @subentry @code{END}
Una regola @code{BEGIN} @`e eseguita solo una volta, prima che sia letto il
primo record in input. Analogamente, una regola @code{END} @`e eseguita
solo una volta, dopo che tutto l'input @`e gi@`a stato letto. Per esempio:
@example
$ @kbd{awk '}
> @kbd{BEGIN @{ print "Analisi di \"li\"" @}}
> @kbd{/li/ @{ ++n @}}
> @kbd{END @{ print "\"li\" @`e presente in", n, "record." @}' mail-list}
@print{} Analisi di "li"
@print{} "li" @`e presente in 4 record.
@end example
@cindex @code{BEGIN} (regola) @subentry operatori e
@cindex @code{END} (regola) @subentry operatori e
@cindex regola @subentry @code{END} @subentry operatori e
Questo programma trova il numero di record nel file in input
@file{mail-list} che contengono la stringa @samp{li}. La regola @code{BEGIN}
stampa un titolo per il rapporto. Non c'@`e bisogno di usare la regola
@code{BEGIN} per inizializzare il contatore @code{n} a zero, poich@'e
@command{awk} lo fa
automaticamente (@pxref{Variabili}).
La seconda regola incrementa la variabile @code{n} ogni volta che si legge
un record che soddisfa il criterio di ricerca @samp{li}. La regola @code{END}
stampa il valore di @code{n} alla fine del programma.
I criteri di ricerca speciali @code{BEGIN} ed @code{END} non possono essere
usati negli intervalli,
o con operatori booleani (in effetti, non possono essere combinati con nessun
altro operatore).
Un programma @command{awk} pu@`o avere molte regole @code{BEGIN} e/o @code{END}.
Queste sono eseguite nell'ordine in cui compaiono nel programma: tutte le
regole @code{BEGIN} a inizio programma e tutte le regole @code{END}
a fine programma.
Le regole @code{BEGIN} ed @code{END} possono apparire in qualsiasi
posizione all'interno del programma.
Questa funzionalit@`a @`e stata aggiunta nella versione 1987 di @command{awk} ed
@`e inclusa nello standard POSIX.
La versione originale (1978) di @command{awk} richiedeva che la regola
@code{BEGIN} fosse posta all'inizio del programma, e la regola
@code{END} alla fine del programma, e solo una regola per tipo era ammessa.
Ci@`o non @`e pi@`u obbligatorio, ma @`e una buona idea continuare a seguire questo
modello per migliorare l'organizzazione e la leggibilit@`a del programma.
Regole multiple @code{BEGIN} ed @code{END} sono utili per scrivere funzioni
di libreria, poich@'e ogni file di libreria pu@`o avere la sua propria regola
@code{BEGIN} e/o @code{END} per fare la propria inizializzazione e/o pulizia.
L'ordine in cui le funzioni di libreria sono menzionate nella riga dei comandi
determina l'ordine in cui le rispettive regole @code{BEGIN} ed @code{END} sono
eseguite. Per questo motivi, occorre prestare attenzione nello scrivere tali
regole nei file di libreria, in modo che non sia importante
l'ordine in cui tali regole vengono eseguite.
@xref{Opzioni} per maggiori informazioni sull'uso di funzioni di libreria.
@iftex
@xrefil{Funzioni di libreria},
@end iftex
@ifnottex
@xref{Funzioni di libreria},
@end ifnottex
per parecchie utili funzioni di libreria.
Se un programma @command{awk} ha solo regole @code{BEGIN} e nessun'altra
regola, il programma esce dopo aver eseguito le regole
@code{BEGIN}.@footnote{La versione originale di @command{awk} continuava a
leggere e ignorare i record in input fino alla fine del file.} Tuttavia, se
una regola @code{END} esiste, l'intero input @`e letto, anche se non sono
presenti altre regole nel programma. Ci@`o viene fatto necessariamente
per permettere che
la regola @code{END} faccia uso delle variabili @code{FNR} e @code{NR},
o i campi [dell'ultimo record in input].
@node I/O e BEGIN/END
@subsubsection Input/Output dalle regole @code{BEGIN} ed @code{END}
@cindex input/output @subentry dalle regole @code{BEGIN} ed @code{END}
Ci sono parecchi punti (talora insidiosi) da tener presente se si fa dell'I/O
all'interno di una regola @code{BEGIN} o @code{END}.
Il primo ha a che fare con il valore di @code{$0} in una regola @code{BEGIN}.
Poich@'e le regole @code{BEGIN} sono eseguite prima delle lettura di qualsiasi
input, non c'@`e assolutamente alcun record in input, e quindi nessun campo,
quando si eseguono delle regole @code{BEGIN}. I riferimento a @code{$0} e ai
campi restituiscono una stringa nulla o zero, a seconda del contesto.
Un modo per assegnare un valore effettivo a @code{$0} @`e di eseguire un
comando @code{getline} senza indicare una variabile (@pxref{Getline}).
Un altro modo @`e semplicemente quello di assegnare un valore a @code{$0}.
@cindex Brian Kernighan @subentry @command{awk} di
@cindex differenze tra @command{awk} e @command{gawk} @subentry criteri di ricerca @code{BEGIN}/@code{END}
@cindex POSIX @command{awk} @subentry criteri di ricerca @code{BEGIN}/@code{END}
@cindex @code{print} (istruzione) @subentry criteri di ricerca @code{BEGIN}/@code{END} e
@cindex @code{BEGIN} (regola) @subentry istruzione @code{print} e
@cindex @code{END} (regola) @subentry istruzione @code{print} e
Il secondo punto @`e simile al primo, ma in direzione opposta.
Tradizionalmente, pi@`u che altro per problemi di implementazione, @code{$0}
e @code{NF} erano @emph{indefiniti} all'interno di una regola @code{END}.
Lo standard POSIX prescrive che @code{NF} sia disponibile all'interno di una
regola @code{END}. Contiene il numero di campi dell'ultimo record in input.
@c FIXME: Update this if POSIX is ever fixed.
Probabilmente per una svista, lo standard non specifica che @`e reso
disponibile anche @code{$0}, sebbene possa apparire logico che sia cos@`{@dotless{i}}.
In effetti, BWK @command{awk}, @command{mawk} e @command{gawk} mantengono il
valore di @code{$0} in modo che sia possibile usarlo all'interno delle regole
@code{END}. Occorre peraltro tener presente che alcune altre implementazioni
e parecchie tra le versioni pi@`u vecchie di Unix @command{awk} non si
comportano cos@`{@dotless{i}}.
Il terzo punto @`e una conseguenza dei primi due. Il significato di
@samp{print}
all'interno di una regola @code{BEGIN} o @code{END} @`e quello di sempre:
@samp{print $0}. Se @code{$0} @`e la stringa nulla, stampa una riga vuota.
Molti programmatori di lungo corso di @command{awk} usano un semplice
@samp{print} all'interno delle regole @code{BEGIN} ed @code{END},
intendendo @samp{@w{print ""}}, contando sul fatto che @code{$0} sia una
stringa nulla. Sebbene questo funzioni solitamente per le regole
@code{BEGIN}, @`e una pessima idea nelle regole @code{END},
almeno in @command{gawk}. @`E anche stilisticamente inelegante, perch@'e se
serve una riga vuota in output, il programma dovrebbe stamparne
una esplicitamente.
@cindex @code{next} (istruzione) @subentry criteri di ricerca @code{BEGIN}/@code{END} e
@cindex @code{nextfile} (istruzione) @subentry criteri di ricerca @code{BEGIN}/@code{END} e
@cindex @code{BEGIN} (regola) @subentry istruzioni @code{next}/@code{nextfile} e
@cindex @code{END} (regola) @subentry istruzioni @code{next}/@code{nextfile} e
Per finire, le istruzioni @code{next} e @code{nextfile} non sono consentite
all'interno di una regola @code{BEGIN}, perch@'e il ciclo implicito
leggi-un-record-e-confrontalo-con-le-regole non @`e ancora iniziato.
Analogamente, tali istruzioni non sono valide all'interno di una regola
@code{END}, perch@'e tutto l'input @`e gi@`a stato letto.
(@xref{Istruzione next} e
@ifnotdocbook
@pxref{Istruzione nextfile}.)
@end ifnotdocbook
@ifdocbook
@ref{Istruzione nextfile}.)
@end ifdocbook
@node BEGINFILE/ENDFILE
@subsection I criteri di ricerca speciali @code{BEGINFILE} ed @code{ENDFILE}
@cindex @code{BEGINFILE} (regola)
@cindex @code{ENDFILE} (regola)
@cindex differenze tra @command{awk} e @command{gawk} @subentry criteri di ricerca @code{BEGINFILE}/@code{ENDFILE}
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Due tipi speciali di criterio di ricerca, @code{BEGINFILE} ed @code{ENDFILE},
forniscono
degli ``agganci'' per intervenire durante il ciclo di elaborazione dei file
specificati sulla riga di comando di @command{gawk}.
Come con le regole @code{BEGIN} ed @code{END}
@ifnottex
@ifnotdocbook
(@pxref{BEGIN/END}),
@end ifnotdocbook
@end ifnottex
@iftex
(si veda la @value{SECTION} precedente),
@end iftex
@ifdocbook
(si veda la @value{SECTION} precedente),
@end ifdocbook
le regole @code{BEGINFILE} in un programma sono eseguite
nell'ordine in cui sono lette da @command{gawk} e lo stesso viene fatto
per tutte le regole @code{ENDFILE}.
I codici delle regole @code{BEGINFILE} sono eseguiti subito prima che
@command{gawk} legga il primo record da un file. La variabile @code{FILENAME}
@`e impostata al nome del file corrente e @code{FNR} @`e impostata a zero.
Prima della @value{PVERSION} 5.1.1 di @command{gawk}, per un difetto di
implementazione, @code{$0} e i campi del record mantenevano, nelle regole
@code{BEGINFILE} il valore che avevano in precedenza.
A partire dalla @value{PVERSION} 5.1.1, sia @code{$0} che i campi del
record sono impostati alla stringa nulla, poich@'e nessun record @`e
ancora stato letto dal file in procinto di essere elaborato.
La regola @code{BEGINFILE} d@`a la possibilit@`a di eseguire due compiti
che sarebbe difficile o impossibile effettuare altrimenti:
@itemize @value{BULLET}
@item
Si pu@`o verificare che il file sia leggibile. Di solito, se un file presente
nella riga dei comandi non pu@`o essere aperto in lettura, il programma
@command{gawk} viene terminato. Comunque, questo si pu@`o evitare, per poi
passare a elaborare il file successivo specificato sulla riga dei comandi.
@cindex @command{gawk} @subentry variabile @subentry @code{ERRNO} in
@cindex @code{ERRNO} (variabile) @subentry con criterio di ricerca @code{BEGINFILE}
@cindex @code{nextfile} (istruzione) @subentry criteri di ricerca @code{BEGINFILE}/@code{ENDFILE} e
Questo controllo @`e fattibile controllando se la variabile @code{ERRNO} @`e
diversa dalla stringa nulla; se @`e questo il caso, @command{gawk} non @`e
riuscito ad aprire il file. In questo caso il programma pu@`o eseguire
un'istruzione @code{nextfile}
(@pxref{Istruzione nextfile}). In questo modo @command{gawk} salta
completamente l'elaborazione di quel file.
In caso contrario, @command{gawk} termina come al solito con un
errore fatale.
@item
Se sono state scritte estensioni che modificano la gestione del record
(tramite l'inserzione di un ``analizzatore di input'';
@pxref{Analizzatori di input}), @`e possibile richiamarle
a questo punto, prima che @command{gawk} inizi a elaborare il file.
(Questa @`e una funzionalit@`a @emph{molto} avanzata, usata al momento solo dal
@uref{https://sourceforge.net/projects/gawkextlib, progetto @code{gawkextlib}}.)
@end itemize
La regola @code{ENDFILE} @`e chiamata quando @command{gawk} ha finito di
elaborare l'ultimo record di un file in input. Per l'ultimo file in input,
@`e chiamata prima di ogni regola @code{END}.
La regola @code{ENDFILE} @`e eseguita anche per file in input vuoti.
Normalmente, se si verifica un errore di lettura durante il normale
ciclo di elaborazione dell'input,
questo @`e considerato fatale (il programma termina). Tuttavia, se @`e presente
una regola @code{BEGINFILE}, l'errore non @`e considerato fatale, ma viene
impostato @code{ERRNO}. Ci@`o permette di intercettare ed elaborare errori
di I/O a livello di programma @command{awk}.
@cindex @code{next} (istruzione) @subentry criteri di ricerca @code{BEGINFILE}/@code{ENDFILE} e
L'istruzione @code{next} (@pxref{Istruzione next}) non @`e permessa all'interno
di una regola @code{BEGINFILE} o @code{ENDFILE}. L'istruzione @code{nextfile}
@`e consentita solo all'interno di una regola @code{BEGINFILE}, non all'interno
di una regola @code{ENDFILE}.
@cindex @code{getline} (comando) @subentry criteri di ricerca @code{BEGINFILE}/@code{ENDFILE} e
L'istruzione @code{getline} (@pxref{Getline}) @`e limitata all'interno sia di
@code{BEGINFILE} che di @code{ENDFILE}: solo le forme ridirette di
di @code{getline} sono permesse.
@code{BEGINFILE} ed @code{ENDFILE} sono estensioni @command{gawk}.
In molte altre implementazioni di @command{awk} o se @command{gawk} @`e in
modalit@`a compatibile (@pxref{Opzioni}), non sono regole speciali.
@node Vuoto
@subsection Il criterio di ricerca vuoto
@cindex vuoto @subentry criterio di ricerca
@cindex criteri di ricerca @subentry vuoti
Un criterio di ricerca vuoto (cio@`e omesso) corrisponde a
@emph{ogni} record in input. Per esempio, il programma:
@example
awk '@{ print $1 @}' mail-list
@end example
@noindent
stampa il primo campo di ogni record.
@node Usare variabili di shell
@section Usare variabili di shell in programmi
@cindex shell @subentry variabili della
@cindex programmi @command{awk} @subentry variabili di shell nei
@c @cindex shell and @command{awk} interaction
I programmi @command{awk} sono spesso usati come componenti di programmi pi@`u
ampi, scritti in un linguaggio di shell.
Per esempio, @`e molto comune usare una variabile di shell per
specificare un criterio di ricerca che il programma @command{awk} deve poi
individuare.
Ci sono due modi per rendere disponibile il valore di una variabile di shell
all'interno di un programma @command{awk}.
@cindex shell @subentry uso di doppio apice nella
Un modo comune @`e quello di usare i doppi apici per sostituire il valore della
variabile nel progamma @command{awk} contenuto nello @dfn{script}:
Per esempio, si consideri il programma seguente:
@example
@group
printf "Immettere il criterio di ricerca: "
read criterio_di_ricerca
awk "/$criterio_di_ricerca/ "'@{ num_trov++ @}
END @{ print num_trov, "occorrenze trovate" @}' /nome/file/dati
@end group
@end example
@noindent
Il programma @command{awk} consiste di due pezzi di testo tra apici
che, concatenati insieme, formano il programma.
La prima parte @`e tra doppi apici, per consentire la sostituzione della
variabile di shell @code{criterio_di_ricerca} contenuta al loro interno.
La seconda parte @`e racchiusa tra apici singoli.
La sostituzione di variabile attraverso gli apici funziona, ma pu@`o
facilmente generare difficolt@`a. Richiede una buona comprensione delle
regole per l'uso degli apici nella shell
(@pxref{Protezione}),
e spesso @`e difficile accoppiare i vari apici quando si legge il programma.
Un metodo migliore @`e quello di usare la funzionalit@`a di assegnamento delle
variabili di @command{awk}
(@pxref{Opzioni di assegnamento})
per assegnare il valore di una variabile di shell a una variabile
di @command{awk}.
Poi si possono usare @dfn{regexp} dinamiche come criterio di ricerca
(@pxref{Espressioni regolari calcolate}).
Quanto segue mostra come sarebbe l'esempio precedente usando questa tecnica:
@example
printf "Immettere il criterio di ricerca: "
read criterio_di_ricerca
awk -v crit="$criterio_di_ricerca" '$0 ~ crit @{ num_trov++ @}
END @{ print num_trov, "occorrenze trovate" @}' /nome/file/dati
@end example
@noindent
Adesso il programma @command{awk} @`e solo una stringa tra apici semplici.
L'assegnamento @samp{-v crit="$criterio_di_ricerca"} richiede ancora doppi
apici, per il caso in cui uno spazio vuoto sia presente nel valore di
@code{$criterio_di_ricerca}.
La variabile @command{awk} @code{crit} potrebbe avere come nome anche
@code{criterio_di_ricerca}, ma ci@`o potrebbe essere causa di confusione.
Usare una variabile permette una maggiore flessibilit@`a, poich@'e la variabile
pu@`o essere usata in ogni parte del
programma --- per stamparla, per indicizzare un vettore, o per qualsiasi altro
scopo --- senza che sia necessario l'artificio di doverla inserire usando gli
apici.
@node Panoramica sulle azioni
@section Azioni
@c @cindex action, definizione di
@c @cindex curly braces
@c @cindex action, curly braces
@c @cindex action, separating statements
@cindex azioni
Un programma o @dfn{script} @command{awk} consiste in una serie di
regole e definizioni di funzione frammiste tra loro. (Le funzioni sono
descritte pi@`u avanti. @xref{Funzioni definite dall'utente}.)
Una regola contiene un criterio di ricerca e un'azione; l'uno o l'altra
(ma non tutt'e due) possono essere omessi. Lo scopo di una @dfn{azione} @`e
di specificare cosa deve fare @command{awk} quando si trova una corrispondenza
con il criterio di ricerca. Quindi, schematicamente, un programma
@command{awk} @`e normalmente simile a questo:
@display
[@var{criterio di ricerca}] @code{@{ @var{azione} @}}
@var{criterio di ricerca} [@code{@{ @var{azione} @}}]
@dots{}
@code{function @var{nome}(@var{argomenti}) @{ @dots{} @}}
@dots{}
@end display
@cindex @code{@{@}} (parentesi graffe) @subentry azioni e
@cindex parentesi @subentry graffe (@code{@{@}}) @subentry azioni e
@cindex separatore di istruzioni @subentry nelle azioni
@cindex ritorno a capo @subentry separatore di istruzioni nelle azioni
@cindex @code{;} (punto e virgola) @subentry separare istruzioni nelle azioni
@cindex punto e virgola (@code{;}) @subentry separare istruzioni nelle azioni
Un'azione consiste di una o pi@`u @dfn{istruzioni} @command{awk}, racchiuse
fra parentesi graffe (@samp{@{@r{@dots{}}@}}). Ogni istruzione specifica
una cosa da fare. Le istruzioni sono separate tra loro da dei ritorni a capo o
da dei punti e virgola.
Le parentesi graffe attorno a un'azione vanno usate anche se l'azione
contiene una sola istruzione o se non contiene alcuna istruzione.
Comunque, se si omette completamente l'azione, si possono omettere anche le
parentesi graffe. Un'azione omessa equivale a specificare
@samp{@{ print $0 @}}:
@example
/pippo/ @{ @} @ii{se si trova @code{pippo}, non fare nulla --- azione vuota}
/pippo/ @ii{se si trova @code{pippo}, stampa il record --- azione omessa}
@end example
I seguenti tipi di istruzione sono disponibili in @command{awk}:
@table @asis
@cindex effetti collaterali @subentry delle istruzioni
@cindex istruzioni @subentry effetti collaterali delle
@item Espressioni
Servono per chiamare funzioni o assegnare valori a variabili
@iftex
(@pxrefil{Espressioni}). L'esecuzione
@end iftex
@ifnottex
(@pxref{Espressioni}). L'esecuzione
@end ifnottex
di questo tipo di istruzione calcola semplicemente il valore dell'espressione.
Ci@`o @`e utile quando l'espressione ha effetti collaterali
(@pxref{Operatori di assegnamento}).
@item Istruzioni di controllo
Specificano il flusso di controllo dei programmi @command{awk}.
Il linguaggio @command{awk} utilizza dei costrutti simili a quelli del C,
(@code{if}, @code{for}, @code{while} e @code{do}), e anche alcune altre
di tipo speciale (@pxref{Istruzioni}).
@item Istruzioni composte
Sono una o pi@`u istruzioni racchiuse tra parentesi graffe. Un'istruzione
composta
@`e usata per riunire un gruppo di istruzioni all'interno di
un'istruzione @code{if}, @code{while}, @code{do} o @code{for}.
@item Istruzioni di input
Usano il comando @code{getline}
(@pxref{Getline}).
In @command{awk} sono anche disponibili le istruzioni @code{next}
(@pxref{Istruzione next})
e @code{nextfile}
(@pxref{Istruzione nextfile}).
@item Istruzioni di output
Come @code{print} e @code{printf}.
@iftex
@xrefIl{Stampare}.
@end iftex
@ifnottex
@xref{Stampare}.
@end ifnottex
@item Istruzioni di cancellazione
Per eliminare elementi di vettori.
@xref{Cancellazione}.
@end table
@node Istruzioni
@section Istruzioni di controllo nelle azioni
@cindex istruzioni di controllo
@cindex controllo @subentry tramite istruzioni @subentry in azioni
@cindex azioni @subentry istruzioni di controllo in
Le @dfn{istruzioni di controllo}, come @code{if}, @code{while} e cos@`{@dotless{i}} via,
regolano il flusso di esecuzione nei programmi @command{awk}. Molte tra
le istruzioni di controllo di @command{awk} sono modellate sulle
corrispondenti istruzioni in C.
@cindex istruzioni composte @subentry istruzioni di controllo e
@cindex composte @subentry istruzioni @subentry istruzioni di controllo e
@cindex corpo @subentry nelle azioni
@cindex @code{@{@}} (parentesi graffe) @subentry istruzioni, raggruppare
@cindex parentesi @subentry graffe (@code{@{@}}) @subentry istruzioni, raggruppare
@cindex ritorno a capo @subentry separatore di istruzioni nelle azioni
@cindex @code{;} (punto e virgola) @subentry separare istruzioni nelle azioni
@cindex punto e virgola (@code{;}) @subentry separare istruzioni nelle azioni
Tutte le istruzioni di controllo iniziano con parole chiave speciali, come
@code{if} e @code{while}, per distinguerle dalle semplici espressioni.
Molte istruzioni di controllo contengono altre istruzioni. Per esempio,
l'istruzione @code{if} contiene un'altra istruzione che pu@`o essere eseguita
oppure no. Le istruzioni contenute sono chiamate @dfn{corpo}.
Per includere pi@`u di un'istruzione nel corpo, queste vanno raggruppate
in una sola @dfn{istruzione composta} tra parentesi graffe, e separate tra
loro con dei ritorni a capo o dei punti e virgola.
@menu
* Istruzione if:: Eseguire in maniera condizionale
istruzioni @command{awk}.
* Istruzione while:: Eseguire il ciclo finch@'e @`e
verificata una condizione.
* Istruzione do:: Eseguire l'azione specificata, continuare
a eseguire il ciclo
finch@'e @`e verificata una condizione.
* Istruzione for:: Un'altra istruzione iterativa, che
permette di specificare clausole
iniziali e di incremento.
* Istruzione switch :: Valutazione di quale insieme di
istruzioni eseguire, a seconda del
valore assunto da una variabile.
* Istruzione break:: Uscire subito dal ciclo pi@`u interno
in cui ci si trova.
* Istruzione continue:: Andare alla fine del ciclo pi@`u interno
in cui ci si trova.
* Istruzione next:: Smettere di elaborare il record corrente.
* Istruzione nextfile:: Smettere di elaborare il file corrente.
* Istruzione exit:: Interrompere l'esecuzione di @command{awk}.
@end menu
@node Istruzione if
@subsection L'istruzione @code{if}-@code{else}
@cindex istruzione @subentry @code{if}
@cindex @code{if} (istruzione)
L'istruzione @code{if}-@code{else} @`e quella che serve in @command{awk}
per prendere decisioni. @`E simile
a questa:
@display
@code{if (@var{condizione}) @var{se-vera-fai}} [@code{else @var{se-falsa-fai}}]
@end display
@noindent
La @var{condizione} @`e un'espressione che controlla quel che fa il resto
dell'istruzione. Se la @var{condizione} @`e vera, viene eseguita la
parte @var{se-vera-fai}; altrimenti viene
eseguita la parte @var{se-falsa-fai}.
La parte @code{else} dell'istruzione @`e
opzionale. La condizione @`e considerata falsa se il suo valore @`e zero o
la stringa nulla; altrimenti, la condizione @`e vera.
Si consideri quanto segue:
@example
@group
if (x % 2 == 0)
print "x @`e pari"
else
print "x @`e dispari"
@end group
@end example
In questo esempio, se l'espressione @samp{x % 2 == 0} @`e vera (cio@`e,
se il valore di @code{x} @`e esattamente divisibile per due), allora viene
eseguita la prima istruzione
@code{print}; altrimenti, viene eseguita la seconda istruzione @code{print}.
Se la parola chiave @code{else} sta sulla stessa riga di @var{se-vera-fai}
e se @var{se-vera-fai} non @`e un'istruzione composta (cio@`e, non @`e racchiusa
tra parentesi graffe), allora un punto e virgola deve separare
@var{se-vera-fai} dalla parola chiave @code{else}.
Per chiarire questo, l'esempio precedente si pu@`o riscrivere come:
@example
if (x % 2 == 0) print "x @`e pari"; else
print "x @`e dispari"
@end example
@noindent
Se il @samp{;} @`e omesso, @command{awk} non pu@`o interpretare l'istruzione e
segnala un errore di sintassi. Non si dovrebbero scrivere programmi in
questo modo, perch@'e a chi li legge potrebbe sfuggire la parola chiave
@code{else} se non @`e la prima parola della riga.
@node Istruzione while
@subsection L'istruzione @code{while}
@cindex @code{while} (istruzione)
@cindex istruzione @subentry @code{while}
@cindex cicli
@cindex cicli @subentry @code{while}
@cindex cicli @seealso{@code{while} (istruzione)}
Nella programmazione, un @dfn{ciclo} @`e una parte di un programma che pu@`o
essere eseguita due o pi@`u volte consecutivamente.
L'istruzione @code{while} @`e la pi@`u semplice istruzione iterativa in
@command{awk}. Esegue ripetutamente un'istruzione finch@'e una data
condizione @`e vera. Per esempio:
@example
while (@var{condizione})
@var{corpo-del-ciclo}
@end example
@cindex corpo @subentry nei cicli
@noindent
@var{corpo-del-ciclo} @`e un'istruzione detta @dfn{corpo} del ciclo,
e @var{condizione} @`e un'espressione che controlla per quante volte il ciclo
deve continuare a essere ripetuto.
La prima cosa che l'istruzione @code{while} fa @`e un controllo della
@var{condizione}.
Se la @var{condizione} @`e vera, viene eseguita l'istruzione
@var{corpo-del-ciclo}.
@ifinfo
(La @var{condizione} @`e vera quando il suo valore
@`e diverso da zero e non @`e la stringa nulla.)
@end ifinfo
Dopo che le istruzioni in @var{corpo-del-ciclo} sono state eseguite,
@var{condizione} @`e controllata nuovamente, e se @`e ancora vera,
@var{corpo-del-ciclo} viene eseguito ancora. Questo processo @`e ripetuto
finch@'e @var{condizione} rimane vera. Se la @var{condizione} @`e falsa fin
dall'inizio, il corpo del ciclo
non viene eseguito per nulla, e @command{awk} continua con l'istruzione
che viene dopo il ciclo.
Questo esempio stampa i primi tre campi di ogni record in input, uno per
riga:
@example
awk '
@{
i = 1
while (i <= 3) @{
print $i
i++
@}
@}' inventory-shipped
@end example
@noindent
Il corpo di questo ciclo @`e un'istruzione composta racchiusa tra parentesi graffe,
che contiene due istruzioni.
Il ciclo funziona in questo modo: all'inizio, il valore di @code{i} @`e
impostato a 1.
Poi, l'istruzione @code{while} controlla se @code{i} @`e minore o uguale a
tre. Ci@`o @`e vero quando @code{i} @`e uguale a 1, quindi il campo
@code{i}-esimo viene stampato. Quindi l'istruzione @samp{i++} incrementa il
valore di @code{i}
e il ciclo viene ripetuto. Il ciclo termina quando @code{i} assume il
valore quattro.
Un ritorno a capo non @`e richiesto tra la condizione e il corpo del ciclo;
tuttavia, se lo si mette, il programma @`e di pi@`u facile comprensione,
a meno che il corpo del ciclo non sia un'istruzione composta, oppure se @`e
qualcosa di molto semplice. Neppure il ritorno a capo dopo la parentesi graffa
aperta che inizia l'istruzione composta @`e necessario, ma il
programma @`e di lettura pi@`u difficile se lo si omette.
@node Istruzione do
@subsection L'istruzione @code{do}-@code{while}
@cindex @code{do}-@code{while} (istruzione)
@cindex cicli @subentry @code{do}-@code{while}
Il ciclo @code{do} @`e una variazione dell'istruzione di ciclo @code{while}.
Il ciclo @code{do} esegue il @var{corpo-del-ciclo} una volta e poi ripete il
@var{corpo-del-ciclo} finch@'e la @var{condizione} rimane vera. @`E simile a questo:
@example
do
@var{corpo-del-ciclo}
while (@var{condizione})
@end example
Anche se la @var{condizione} @`e falsa fin dall'inizio, il @var{corpo-del-ciclo}
viene eseguito almeno una volta (e solo una volta, a meno che
l'esecuzione di @var{corpo-del-ciclo}
non renda vera la @var{condizione}). Si confronti con il corrispondente
@code{while}:
@example
while (@var{condizione})
@var{corpo-del-ciclo}
@end example
@noindent
Quest'istruzione non esegue il @var{corpo-del-ciclo} neppure una volta, se
la @var{condizione} @`e falsa fin dall'inizio. Il seguente @`e un esempio di
@code{do}:
@example
@{
i = 1
do @{
print $0
i++
@} while (i <= 10)
@}
@end example
@noindent
Questo programma stampa ogni record in input per 10 volte. Non si tratta,
peraltro, di un esempio molto realistico, perch@'e in questo caso un semplice
@code{while} sarebbe sufficiente. Questa osservazione riflette un'esperienza
reale; solo occasionalmente @`e davvero necessario usare un @code{do}.
@node Istruzione for
@subsection L'istruzione @code{for}
@cindex istruzione @subentry @code{for}
@cindex @code{for} (istruzione)
@cindex cicli @subentry @code{for} @subentry iterativi
L'istruzione @code{for} rende pi@`u agevole contare le iterazioni di un ciclo.
La forma generale dell'istruzione @code{for} @`e simile a questa:
@example
for (@var{inizializzazione}; @var{condizione}; @var{incremento})
@var{corpo-del-ciclo}
@end example
@noindent
La parti @var{inizializzazione}, @var{condizione} e @var{incremento} sono
espressioni @command{awk} a piacere, e @var{corpo-del-ciclo} indica qualsiasi
istruzione @command{awk}.
L'istruzione @code{for} comincia con l'esecuzione di @var{inizializzazione}.
Poi, finch@'e
la @var{condizione} @`e vera, esegue ripetutamente @var{corpo-del-ciclo},
e quindi @var{incremento}. Tipicamente, @var{inizializzazione} imposta una
variabile a zero o a uno, @var{incremento} aggiunge uno alla stessa e
@var{condizione} ne confronta il valore rispetto al numero desiderato di
iterazioni.
Per esempio:
@example
awk '
@{
for (i = 1; i <= 3; i++)
print $i
@}' inventory-shipped
@end example
@noindent
Questo programma stampa i primi tre campi di ogni record in input,
mettendo un unico campo in una riga in output.
Non @`e possibile impostare
pi@`u di una variabile nella parte di
@var{inizializzazione} senza usare un'istruzione di assegnamento multiplo,
come @samp{x = y = 0}. Ci@`o ha senso solo se tutti i valori iniziali
sono uguali. (Ma @`e possibile inizializzare ulteriori variabili scrivendo
i relativi assegnamenti come istruzioni separate @emph{prima} del ciclo
@code{for}.)
@c @cindex comma operator, not supported
Lo stesso vale per la parte @var{incremento}. Se serve incrementare ulteriori
variabili, questo va fatto con istruzioni separate alla fine del ciclo.
L'espressione composta del linguaggio C, che usa l'operatore virgola [,]
del C, sarebbe
utile in questo contesto, ma non @`e
prevista in @command{awk}.
Molto spesso, @var{incremento} @`e un'espressione di incremento, come
nell'esempio precedente. Ma questo non @`e obbligatorio; pu@`o trattarsi di
un'espressione qualsiasi. Per esempio,
la seguente istruzione stampa tutte le potenze di due comprese
tra 1 e 100:
@example
for (i = 1; i <= 100; i *= 2)
print i
@end example
Se non @`e necessaria, ognuna delle tre espressioni fra
parentesi che segue la parola chiave @code{for} pu@`o essere omessa. Quindi,
@w{@samp{for (; x > 0;)}} equivale a @w{@samp{while (x > 0)}}. Se la
@var{condizione} @`e omessa del tutto, @`e ritenuta sempre vera, producendo
un @dfn{ciclo infinito} (cio@`e, un ciclo che non finisce mai).
Molto spesso, un ciclo @code{for} @`e un'abbreviazione per un ciclo @code{while},
come si pu@`o vedere qui:
@example
@var{inizializzazione}
while (@var{condizione}) @{
@var{corpo-del-ciclo}
@var{incremento}
@}
@end example
@cindex cicli @subentry istruzione @code{continue} e
@noindent
La sola eccezione @`e quando l'istruzione @code{continue}
(@pxref{Istruzione continue}) @`e usata
all'interno del ciclo. Se si modifica un'istruzione @code{for}
sostituendola con un'istruzione @code{while}
ci@`o pu@`o cambiare l'effetto dell'istruzione @code{continue} posta all'interno
del ciclo.
Il linguaggio @command{awk} ha un'istruzione @code{for} oltre all'istruzione
@code{while} perch@'e un ciclo @code{for} @`e spesso pi@`u semplice da scrivere,
e viene in mente pi@`u naturalmente.
Contare il numero di iterazioni @`e
molto frequente nei cicli. Pu@`o essere pi@`u facile pensare a questo conto come
parte del ciclo, piuttosto che come qualcosa da fare all'interno del ciclo.
@cindex @code{in} (operatore)
@cindex operatore @subentry @code{in}
Esiste una versione alternativa al ciclo @code{for}, per esaminare tutti
gli indici di un vettore:
@example
for (i in vettore)
@var{fai qualcosa con} vettore[i]
@end example
@noindent
@xref{Visitare un intero vettore}
per maggiori informazioni su questa versione del ciclo @code{for}.
@node Istruzione switch
@subsection L'istruzione @code{switch}
@cindex @code{switch} (istruzione)
@cindex @code{case} @subentry parola chiave
@cindex @code{case} @subentry @seealso{@code{switch} (istruzione)}
@cindex parola @subentry chiave @code{case}
@cindex @code{default} @subentry parola chiave
@cindex @code{default} @subentry @seealso{@code{switch} (istruzione)}
@cindex parola @subentry chiave @code{default}
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Se @command{gawk} @`e in modalit@`a compatibile (@pxref{Opzioni}),
la funzionalit@`a non @`e disponibile.
L'istruzione @code{switch} consente di valutare un'espressione e di
eseguire istruzioni se il valore trovato corrisponde a uno dei @code{case} [casi] previsti.
Le istruzioni @code{case} sono esaminate per cercare una corrispondenza
nell'ordine in cui i casi sono definiti nel programma. Se nessuno dei @code{case}
corrisponde al valore dell'espressione, viene eseguita la sezione
@code{default}, se @`e stata specificata.
Ogni @code{case} contiene una singola costante, che pu@`o essere un numero,
una stringa, o una @dfn{regexp}. Viene valutata l'espressione @code{switch},
e poi la costante di ogni @code{case} viene confrontata di volta in volta
con il valore risultante.
Il tipo di costante determina come sar@`a eseguito il confronto: per i tipi
numerici o stringa si seguono le regole abituali. Per una costante
@dfn{regexp} (sia regolare, @code{/pippo/}, che fortemente tipizzata,
@code{@@/pippo/}) viene effettuato un confronto tra l'espressione e il
valore di tipo stringa dell'espressione originale.
Il formato generale dell'istruzione @code{switch} @`e simile a questo:
@example
switch (@var{espressione}) @{
case @var{valore o espressione regolare}:
@var{corpo-del-caso}
default:
@var{corpo-del-default}
@}
@end example
Il flusso di controllo
dell'istruzione @code{switch} funziona come per il linguaggio C. Una volta
stabilita una corrispondenza con un dato caso, le istruzione che formano il
corpo del caso sono eseguite, fino a che non venga trovata un'istruzione
@code{break},
@code{continue}, @code{next}, @code{nextfile} o @code{exit},
o fino alla fine dell'istruzione @code{switch} medesima. Per esempio:
@example
while ((c = getopt(ARGC, ARGV, "aksx")) != -1) @{
switch (c) @{
case "a":
# stampa la dimensione di tutti i file
all_files = TRUE;
break
case "k":
BLOCK_SIZE = 1024 # in blocchi da 1 Kbyte
break
case "s":
# fa solo le somme
sum_only = TRUE
break
case "x":
# non esce dal filesystem
fts_flags = or(fts_flags, FTS_XDEV)
break
case "?":
default:
uso()
break
@}
@}
@end example
Si noti che se nessuna delle istruzioni specificate qui arresta l'esecuzione
di un'istruzione @code{case} per la quale @`e stata trovata una corrispondenza;
l'esecuzione continua fino al successivo @code{case} finch@'e
non viene interrotta. In questo esempio, il
@code{case} per @code{"?"} esegue quello di @code{default}, che consiste nel
chiamare una funzione di nome @code{uso()}.
(La funzione @code{getopt()} qui chiamata @`e descritta in
@ref{Funzione getopt}.)
@node Istruzione break
@subsection L'istruzione @code{break}
@cindex @code{break} (istruzione)
@cindex istruzione @subentry @code{break}
@cindex cicli @subentry uscita
@cindex cicli @subentry istruzione @code{break} e
L'istruzione @code{break} esce dal ciclo pi@`u interno @code{for},
@code{while} o @code{do} dentro al quale si trova. L'esempio seguente
trova, se esiste, il divisore pi@`u piccolo di un dato numero intero, oppure
dichiara che si tratta di un numero primo:
@example
@group
# trova il divisore pi@`u piccolo di num
@{
num = $1
for (divisore = 2; divisore * divisore <= num; divisore++) @{
if (num % divisore == 0)
break
@}
@end group
@group
if (num % divisore == 0)
printf "Il pi@`u piccolo divisore di %d @`e %d\n", num, divisore
else
printf "%d @`e un numero primo\n", num
@}
@end group
@end example
Quando il resto della divisione @`e zero nella prima istruzione @code{if},
@command{awk} immediatamente esce, a causa del @dfn{break}, dal ciclo
@code{for} in cui @`e contenuto. Ci@`o vuol dire
che @command{awk} prosegue immediatamente fino all'istruzione che viene dopo
il ciclo, e continua l'elaborazione. (L'istruzione @code{break} @`e molto
differente dall'istruzione @code{exit},
la quale termina l'intero programma @command{awk}.
@xref{Istruzione exit}.)
Il seguente programma mostra come la @var{condizione} di un'istruzione
@code{for} o @code{while} potrebbe essere sostituita da un'istruzione
@code{break} all'interno di un @code{if}:
@example
# trova il divisore pi@`u piccolo di num
@{
num = $1
for (divisore = 2; ; divisore++) @{
if (num % divisore == 0) @{
printf "Il pi@`u piccolo divisore di %d @`e %d\n", num, divisore
break
@}
if (divisore * divisore > num) @{
printf "%d @`e un numero primo\n", num
break
@}
@}
@}
@end example
L'istruzione @code{break} @`e usata anche per terminare l'esecuzione di
un'istruzione @code{switch}.
Questo argomento @`e trattato in @ref{Istruzione switch}.
@c @cindex @code{break}, outside of loops
@c @cindex historical features
@c @cindex @command{awk} language, POSIX version
@cindex POSIX @command{awk} @subentry @code{break} (istruzione)
@cindex angolo buio @subentry istruzione @subentry @code{break}
@cindex @command{gawk} @subentry @code{break} (istruzione) in
@cindex Brian Kernighan @subentry @command{awk} di
L'istruzione @code{break} non ha significato se
usata fuori dal corpo di un ciclo o di un'istruzione @code{switch}.
Tuttavia, anche se la cosa non @`e mai stata documentata,
le prime implementazioni di @command{awk} consideravano l'istruzione @code{break}
esterna a un ciclo come un'istruzione @code{next}
(@pxref{Istruzione next}).
@value{DARKCORNER}
Versioni recenti di BWK @command{awk} non consentono pi@`u un tale uso,
e lo stesso fa @command{gawk}.
@node Istruzione continue
@subsection L'istruzione @code{continue}
@cindex @code{continue} (istruzione)
@cindex istruzione @subentry @code{continue}
Analogamente a @code{break}, l'istruzione @code{continue} @`e usata solo
all'interno di cicli @code{for}, @code{while} e @code{do}. L'istruzione
ignora il resto del corpo del ciclo, facendo s@`{@dotless{i}} che la successiva iterazione
del ciclo inizi immediatamente. Questo comportamento @`e differente da quello
di @code{break}, che esce completamente dal ciclo.
L'istruzione @code{continue} in un ciclo @code{for} fa s@`{@dotless{i}} che @command{awk}
ignori il resto del corpo del ciclo e prosegua l'esecuzione con l'espressione
@var{incremento} dell'istruzione @code{for}. Il seguente programma
@`e un esempio di ci@`o:
@example
BEGIN @{
for (x = 0; x <= 20; x++) @{
if (x == 5)
continue
printf "%d ", x
@}
print ""
@}
@end example
@noindent
Questo programma stampa tutti i numeri da 0 a 20 --- tranne il 5, in cui
l'istruzione @code{printf} @`e saltata. Siccome l'incremento @samp{x++}
non viene saltato, @code{x} non rimane fermo al valore 5. Si confronti il ciclo
@code{for} dell'esempio precedente con il seguente ciclo @code{while}:
@example
BEGIN @{
x = 0
while (x <= 20) @{
if (x == 5)
continue
printf "%d ", x
x++
@}
print ""
@}
@end example
@noindent
Questo programma inizia un ciclo infinito dopo che @code{x} ha assunto il
valore 5, poich@'e l'istruzione di incremento (@samp{x++}) non @`e mai raggiunta.
@c @cindex @code{continue}, outside of loops
@c @cindex historical features
@c @cindex @command{awk} language, POSIX version
@cindex POSIX @command{awk} @subentry @code{continue} (istruzione)
@cindex angolo buio @subentry istruzione @subentry @code{continue}
@cindex @command{gawk} @subentry @code{continue} (istruzione) in
@cindex Brian Kernighan @subentry @command{awk} di
L'istruzione @code{continue} non ha un significato speciale se appare in
un'istruzione @code{switch}, e non ha alcun significato se usata fuori dal
corpo di un ciclo. Le prime versioni di @command{awk} trattavano le
istruzioni @code{continue} che erano fuori da un ciclo allo stesso modo con
cui trattavano l'istruzione @code{break}
fuori da un ciclo: come se fosse un'istruzione @code{next}
@ifset FOR_PRINT
(trattata nella @value{SECTION} seguente).
@end ifset
@ifclear FOR_PRINT
(@pxref{Istruzione next}).
@end ifclear
@value{DARKCORNER}
Versioni recenti di BWK @command{awk} non consentono pi@`u un tale uso,
e lo stesso vale per @command{gawk}.
@node Istruzione next
@subsection L'istruzione @code{next}
@cindex @code{next} (istruzione)
@cindex istruzione @subentry @code{next}
L'istruzione @code{next} fa s@`{@dotless{i}} che @command{awk} termini immediatamente
l'elaborazione del record corrente e proceda a elaborare il record successivo.
Ci@`o vuol dire che nessuna delle eventuali regole successive viene eseguita
per il record corrente e che il resto delle azioni presenti nella
regola correntemente in esecuzione non viene eseguito.
Si confronti quanto sopra con quel che fa la funzione @code{getline}
(@pxref{Getline}). Anch'essa fa s@`{@dotless{i}} che @command{awk} legga il record
successivo immediatamente, ma non altera il flusso del controllo in alcun
modo (cio@`e, il resto dell'azione in esecuzione prosegue con il nuovo record
in input).
@cindex programmi @command{awk} @subentry eseguire
Al livello pi@`u alto, l'esecuzione di un programma @command{awk} @`e un ciclo
che legge un record in input e quindi confronta il criterio di ricerca di
ciascuna regola con il record stesso. Se si vede questo ciclo come un
@code{for} il cui corpo contiene le regole, l'istruzione @code{next} @`e analoga
a un'istruzione @code{continue}. Salta, cio@`e, alla fine del corpo di questo
ciclo implicito
ed esegue l'incremento (ovvero legge un altro record).
Per esempio, si supponga che un programma @command{awk} agisca solo su record
che hanno quattro campi, e che non dovrebbe terminare con un errore se trova
dei record in input non validi. Per evitare di complicare il resto del
programma, si pu@`o scrivere una regola ``filtro'' a inizio programma, come
mostrato in questo esempio:
@example
NF != 4 @{
printf("%s:%d: salto: NF != 4\n", FILENAME, FNR) > "/dev/stderr"
next
@}
@end example
@noindent
Siccome @`e presente un @code{next},
le regole successive del programma non elaboreranno i record non validi.
Il messaggio @`e ridiretto al flusso in output
@dfn{standard error}, sul quale vanno scritti i messaggi di errore.
Per maggiori dettagli, si veda
@ref{File speciali}.
Se l'istruzione @code{next} provoca il raggiungimento della fine del file
in input, vengono eseguite le eventuali regole @code{END} presenti.
@xref{BEGIN/END}.
L'istruzione @code{next} non @`e consentita all'interno delle regole
@code{BEGINFILE} ed @code{ENDFILE}. @xref{BEGINFILE/ENDFILE}.
@c @cindex @code{next}, inside a user-defined function
@cindex @code{BEGIN} (regola) @subentry istruzioni @code{next}/@code{nextfile} e
@cindex @code{END} (regola) @subentry istruzioni @code{next}/@code{nextfile} e
@cindex POSIX @command{awk} @subentry @code{next}/@code{nextfile} (istruzioni)
@cindex @code{next} (istruzione) @subentry in funzione definita dall'utente
@cindex funzione definita dall'utente @subentry istruzioni @code{next}/@code{nextfile} e
Secondo lo standard POSIX, il comportamento di @command{awk} @`e indefinito
se @code{next} @`e usato in una regola @code{BEGIN} o @code{END}.
@command{gawk} considera questo come un errore di sintassi. Sebbene POSIX
non proibisca di usarlo,
molte altre implementazioni di @command{awk} non consentono che l'istruzione
@code{next} sia usata all'interno del corpo di funzioni.
(@pxref{Funzioni definite dall'utente}).
Come tutte le altre istruzioni @code{next}, un'istruzione @code{next} all'interno del
corpo di una funzione legge il record successivo e inizia a elaborarlo
a partire dalla prima regola del programma.
@node Istruzione nextfile
@subsection L'istruzione @code{nextfile}
@cindex @code{nextfile} (istruzione)
@cindex istruzione @subentry @code{nextfile}
L'istruzione @code{nextfile}
@`e simile all'istruzione @code{next}.
Tuttavia, invece di terminare l'elaborazione del record corrente, l'istruzione
@code{nextfile} richiede ad @command{awk} di terminare di elaborare il
@value{DF} corrente.
Alla fine dell'esecuzione dell'istruzione @code{nextfile},
@code{FILENAME} @`e
aggiornato per contenere il nome del successivo @value{DF} elencato sulla riga
di comando, @code{FNR} @`e reimpostato a uno, e l'elaborazione riparte con
la prima regola del programma.
Se l'istruzione @code{nextfile} raggiunge la fine dei file in input,
vengono eseguite le eventuali regole @code{END} presenti.
Un'eccezione a questo si ha se @code{nextfile} @`e invocata durante
l'esecuzione di qualche istruzione all'interno di una regola @code{END};
in questo caso, il programma viene terminato immediatamente.
@xref{BEGIN/END}.
L'istruzione @code{nextfile} @`e utile quando ci sono parecchi @value{DF} da
elaborare, ma non @`e necessario elaborare ogni record in ogni file.
Senza @code{nextfile},
per passare al successivo @value{DF}, un programma
dovrebbe continuare a leggere i record che non gli servono. L'istruzione
@code{nextfile} @`e una maniera molto pi@`u efficiente per ottenere lo stesso
risultato.
In @command{gawk}, l'esecuzione di @code{nextfile} produce ulteriori effetti:
le eventuali regole @code{ENDFILE}
sono eseguite se @command{gawk} non
si trova correntemente all'interno di una regola @code{END} o
@code{BEGINFILE}; @code{ARGIND} @`e
incrementato e le eventuali regole @code{BEGINFILE} sono eseguite.
(@code{ARGIND} non @`e stato ancora trattato.
@xref{Variabili predefinite}.)
In @command{gawk}, @code{nextfile} @`e utile all'interno di una regola
@code{BEGINFILE} per evitare di elaborare un file che altrimenti causerebbe
un errore fatale in @command{gawk}.
In questo caso, le regole @code{ENDFILE} non vengono eseguite.
@xref{BEGINFILE/ENDFILE}.
Sebbene possa sembrare che @samp{close(FILENAME)} ottenga lo stesso
risultato di @code{nextfile}, non @`e cos@`{@dotless{i}}. @code{close()}
pu@`o essere usato solo per chiudere file, @dfn{pipe} e coprocessi che siano
stati aperti tramite ridirezioni. Non ha niente a che vedere con
l'elaborazione principale che
@command{awk} fa dei file elencati in @code{ARGV}.
@quotation NOTA
Per molti anni, @code{nextfile} @`e stata
un'estensione comune. A settembre 2012 si @`e deciso di
includerla nello standard POSIX.
Si veda @uref{http://austingroupbugs.net/view.php?id=607, il sito web dell'Austin Group}.
@end quotation
@cindex funzione definita dall'utente @subentry istruzioni @code{next}/@code{nextfile} e
@cindex @code{nextfile} (istruzione) @subentry in funzioni definite dall'utente
@cindex Brian Kernighan @subentry @command{awk} di
@cindex @command{mawk} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{mawk}
Le versioni correnti di BWK @command{awk} e @command{mawk}
entrambe prevedono @code{nextfile}. Tuttavia, non sono consentite istruzioni
@code{nextfile} all'interno del corpo delle funzioni
(@pxref{Funzioni definite dall'utente}).
@command{gawk} lo permette; una @code{nextfile} all'interno del corpo di una
funzione legge il primo record del file
successivo e inizia l'elaborazione dello stesso
a partire dalla prima regola del programma, esattamente come farebbe
qualsiasi altra istruzione @code{nextfile}.
@node Istruzione exit
@subsection L'istruzione @code{exit}
@cindex @code{exit} (istruzione)
@cindex istruzione @subentry @code{exit}
L'istruzione @code{exit} fa s@`{@dotless{i}} che @command{awk} termini immediatamente
l'esecuzione della regola corrente e che termini di elaborare l'input;
qualsiasi input ancora da elaborare @`e ignorato. L'istruzione @code{exit} @`e
scritta come segue:
@display
@code{exit} [@var{codice di ritorno}]
@end display
@cindex @code{BEGIN} (regola) @subentry istruzione @code{exit} e
@cindex regola @subentry @code{BEGIN} @subentry @code{exit} (istruzione) e
@cindex @code{END} (regola) @subentry istruzione @code{exit} e
@cindex regola @subentry @code{END} @subentry @code{exit} (istruzione) e
Quando un'istruzione @code{exit} @`e eseguita all'interno di una regola @code{BEGIN},
il programma termina completamente l'elaborazione. Nessun record in input
viene letto. Tuttavia, se una regola @code{END} @`e presente, come parte
dell'esecuzione dell'istruzione @code{exit},
la regola @code{END} viene eseguita
(@pxref{BEGIN/END}).
Se @code{exit} @`e usata nel corpo di una regola @code{END},
il programma termina immediatamente.
Un'istruzione @code{exit} che non fa parte di una regola @code{BEGIN} o @code{END}
termina l'esecuzione di qualsiasi ulteriore regola applicabile al record
corrente, salta la lettura di qualsiasi record in input, ed esegue
le eventuali regole @code{END}. @command{gawk} salta anche le eventuali regole
@code{ENDFILE}, che non vengono eseguite.
In questo caso,
se non si desidera che la regola @code{END} venga eseguita, si deve impostare
una variabile a un valore diverso da zero, prima di invocare l'istruzione
@code{exit} e controllarne il valore nella regola @code{END}.
@xref{Funzione assert}
per un esempio di questo tipo.
@cindex angolo buio @subentry istruzione @subentry @code{exit}
Se si specifica un argomento all'istruzione @code{exit}, il suo valore @`e
usato come codice di ritorno finale dell'elaborazione @command{awk}. Se non
viene specificato alcun argomento,
@code{exit} fa terminare @command{awk} con un codice di ritorno di
``successo''.
Nel caso in cui un argomento
sia specificato in una prima istruzione @code{exit} e poi @code{exit} sia
chiamato una seconda volta all'interno di una regola @code{END} senza alcun
argomento, @command{awk} usa il codice di ritorno specificato in precedenza.
@value{DARKCORNER}
@xref{Codice di ritorno} per maggiori informazioni.
@cindex convenzioni di programmazione @subentry istruzione @code{exit}
Per esempio, si supponga che si sia verificata una condizione di errore
difficile o impossibile da gestire. Convenzionalmente, i programmi la
segnalano terminando con un codice di ritorno diverso da zero. Un programma
@command{awk} pu@`o farlo usando un'istruzione @code{exit} con un argomento
diverso da zero, come mostrato nell'esempio seguente:
@example
@group
BEGIN @{
if (("date" | getline data_corrente) <= 0) @{
print "Non riesco a ottenere la data dal sistema" > "/dev/stderr"
exit 1
@}
@end group
@group
print "la data corrente @`e", data_corrente
close("date")
@}
@end group
@end example
@quotation NOTA
Per una completa portabilit@`a, i codici di ritorno dovrebbero essere compresi
tra zero e 126, estremi compresi.
Valori negativi e valori maggiori o uguali a 127, possono non generare
risultati coerenti tra loro in sistemi operativi diversi.
@end quotation
@node Variabili predefinite
@section Variabili predefinite
@cindex predefinita @subentry variabile
@cindex variabili @subentry predefinite
La maggior parte delle variabili @command{awk} sono disponibili per essere
usate dall'utente secondo le proprie esigenze;
queste variabili non cambiano mai di valore a meno che il
programma non assegni loro dei valori, e non hanno alcuna influenza sul
programma a meno che non si decida di utilizzarle nel programma.
Tuttavia, alcune variabili in @command{awk} hanno dei significati speciali
predefiniti.
@command{awk} tiene conto di alcune di queste automaticamente, in modo da
rendere possibile la richiesta ad @command{awk} di fare certe cose nella
maniera desiderata. Altre variabili sono impostate automaticamente da
@command{awk}, in modo da poter comunicare al programma in esecuzione
informazioni sul modo di procedere interno di @command{awk}.
@cindex @command{gawk} @subentry variabili predefinite e
Questa @value{SECTION} documenta tutte le variabili predefinite di
@command{gawk}; molte di queste variabili sono anche documentate nei
@value{CHAPTER} che descrivono le loro aree di influenza.
@menu
* Variabili modificabili dall'utente:: Variabili predefinite modificabili per
controllare @command{awk}.
* Variabili auto-assegnate:: Variabili predefinite con cui
@command{awk} fornisce informazioni.
* ARGC e ARGV:: Modi di usare @code{ARGC} e @code{ARGV}.
@end menu
@node Variabili modificabili dall'utente
@subsection Variabili predefinite modificabili per controllare @command{awk}
@cindex variabili @subentry predefinite @subentry modificabili dall'utente
@cindex modificabili dall'utente @subentry variabili
La seguente @`e una lista alfabetica di variabili che @`e possibile modificare per
controllare come @command{awk} gestisce alcuni compiti.
Le variabili che sono specifiche di @command{gawk} sono contrassegnate da un
cancelletto (@samp{#}). Queste variabili sono estensioni @command{gawk}.
In altre implementazioni di @command{awk}, o se @command{gawk} @`e eseguito in
modalit@`a compatibile
(@pxref{Opzioni}), non hanno un significato speciale. (Eventuali eccezioni
sono menzionate nella descrizione di ogni variabile.)
@table @code
@cindex @code{BINMODE} (variabile)
@cindex variabile @subentry @code{BINMODE}
@cindex binario @subentry input/output
@cindex input/output @subentry binario
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{BINMODE}
@item BINMODE #
Su sistemi non-POSIX, questa variabile specifica l'uso della modalit@`a binaria
per tutto l'I/O. I valori numerici di uno, due o tre specificano che i file
in input, i file di output o tutti i file, rispettivamente, devono usare I/O
binario.
Un valore numerico inferiore a zero @`e trattato come zero e un valore
numerico maggiore di tre @`e trattato
come tre. Alternativamente, le stringhe @code{"r"} o @code{"w"} specificano
che i file in input e i file in output,
rispettivamente, devono usare
I/O binario. Una stringa @code{"rw"} o @code{"wr"} indica che tutti i file
devono usare I/O binario. Ogni altro valore di stringa @`e trattato come
@code{"rw"}, ma @command{gawk} genera un messaggio di avvertimento.
@code{BINMODE} @`e descritto in maggior
dettaglio in @ref{Uso su PC}. @command{mawk} (@pxref{Altre versioni})
prevede questa variabile, ma consente solo valori numerici.
@cindex @code{CONVFMT} (variabile)
@cindex variabile @subentry @code{CONVFMT}
@cindex POSIX @command{awk} @subentry @code{CONVFMT} (variabile)
@cindex numeri @subentry conversione in stringhe
@cindex stringa @subentry conversione in numero
@item @code{CONVFMT}
Una stringa che controlla la conversione di numeri in
stringhe (@pxref{Conversione}).
In effetti @`e la stringa passata come primo argomento alla funzione
@code{sprintf()}
(@pxref{Funzioni per stringhe}).
Il suo valore di default @`e @code{"%.6g"}.
@code{CONVFMT} @`e stata introdotta dallo standard POSIX.
@cindex @command{gawk} @subentry variabile @subentry @code{FIELDWIDTHS} in
@cindex @code{FIELDWIDTHS} (variabile)
@cindex variabile @subentry @code{FIELDWIDTHS}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{FIELDWIDTHS}
@cindex separatore di campo @subentry variabile @code{FIELDWIDTHS} e
@cindex campi @subentry separatore di @subentry variabile @code{FIELDWIDTHS} e
@item FIELDWIDTHS #
Una lista di posizioni di colonna, separate da spazi, per dire a
@command{gawk}
come dividere campi in input posti su colonne fisse.
A partire dalla @value{PVERSION} 4.2, ogni lunghezza di campo pu@`o essere
opzionalmente preceduta da un valore, separato da due punti (@code{:})
che specifica il numero di caratteri da ignorare prima dell'inizio del campo.
Assegnando un valore a @code{FIELDWIDTHS}, le variabili @code{FS} e
@code{FPAT}
@emph{non} vengono usate per effettuare la divisione in campi.
@xref{Dimensione costante} per maggiori informazioni.
@cindex @command{gawk} @subentry variabile @subentry @code{FPAT} in
@cindex @code{FPAT} (variabile)
@cindex variabile @subentry @code{FPAT}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{FPAT}
@cindex separatore di campo @subentry variabile @code{FPAT} e
@cindex campi @subentry separatore di @subentry variabile @code{FPAT} e
@item FPAT #
Un'espressione regolare (di tipo stringa) per dire a @command{gawk}
di creare i campi utilizzando come delimitatore il testo che corrisponde
all'espressione regolare.
Assegnando un valore a @code{FPAT}
le variabili @code{FS} e @code{FIELDWIDTHS}
@emph{non} vengono usate per effettuare la divisione in campi.
@xref{Separazione in base al contenuto} per maggiori informazioni.
@cindex @code{FS} (variabile)
@cindex variabile @subentry @code{FS}
@cindex campi @subentry separatore di
@cindex separatore di campo
@item FS
Il separatore dei campi in input (@pxref{Separatori di campo}).
Il valore pu@`o essere una stringa di un solo carattere o un'espressione
regolare composta da pi@`u caratteri che individua il separatore tra i campi
dei record in input. Se il suo valore
@`e la stringa nulla (@code{""}),
ogni singolo carattere del record costituisce un campo.
(Questo comportamente @`e un'estensione @command{gawk}. POSIX @command{awk} non
specifica il comportamento quando @code{FS} @`e la stringa nulla.
Nonostante questo, alcune altre versioni di @command{awk} trattano @code{""}
in modo speciale.)
@cindex POSIX @command{awk} @subentry @code{FS} (variabile)
Il valore di default @`e @w{@code{" "}}, una stringa consistente in un singolo
spazio. In via eccezionale, questo valore significa che qualsiasi sequenza
di spazi, TAB, e/o ritorni a capo costituisce
un solo separatore.
Inoltre eventuali spazi, TAB e ritorni a capo all'inizio e alla fine
del record in input vengono ignorati.
Si pu@`o impostare il valore di @code{FS} sulla riga dei comandi usando
l'opzione @option{-F}:
@example
awk -F, '@var{programma}' @var{file-in-input}
@end example
@cindex @command{gawk} @subentry separatore di campo e
Se @command{gawk} sta usando @code{FIELDWIDTHS} o @code{FPAT}
per separare i campi,
assegnare un valore a @code{FS} fa s@`{@dotless{i}} che @command{gawk} torni alla
separazione dei campi normale, fatta utilizzando la variabile @code{FS}.
Un modo semplice per fare questo
@`e semplicemente quello di scrivere l'istruzione
@samp{FS = FS}, aggiungendo magari un commento esplicativo.
@cindex @command{gawk} @subentry variabile @subentry @code{IGNORECASE} in
@cindex @code{IGNORECASE} (variabile)
@cindex variabile @subentry @code{IGNORECASE}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{IGNORECASE}
@cindex maiuscolo/minuscolo @subentry confronti tra stringhe e
@cindex maiuscolo/minuscolo @subentry @dfn{regexp} e
@cindex espressioni regolari @subentry maiuscolo/minuscolo
@item IGNORECASE #
Se la variabile @code{IGNORECASE} @`e diversa da zero o dalla stringa nulla,
tutti i confronti tra stringhe
e tutti i confronti tra espressioni regolari sono insensibili
alle differenze maiuscolo/minuscolo.
Questo vale per il confronto tra @dfn{regexp}
usando @samp{~} e @samp{!~}, per le funzioni @code{gensub()},
@code{gsub()}, @code{index()}, @code{match()}, @code{patsplit()},
@code{split()} e @code{sub()},
per la determinazione della fine record con @code{RS} e per la divisione
in campi con @code{FS} e @code{FPAT}.
Tuttavia, il valore di @code{IGNORECASE} @emph{non} influenza gli indici
dei vettori
e non influenza la separazione dei campi qualora si usi un separatore di campo
costituito da un unico carattere.
@xref{Maiuscolo-Minuscolo}.
@cindex @command{gawk} @subentry variabile @subentry @code{LINT} in
@cindex @code{LINT} (variabile)
@cindex variabile @subentry @code{LINT}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{LINT}
@cindex @dfn{lint} @subentry controlli
@cindex controllo @subentry @dfn{lint}
@item LINT o
Quando questa variabile @`e vera (non uguale a zero e non uguale alla stringa
nulla), @command{gawk} si comporta come se fosse stata specificata sulla
riga di comando l'opzione @option{--lint}
(@pxref{Opzioni}).
Con un valore di @code{"fatal"}, gli avvertimenti di @dfn{lint} generano un errore
fatale.
Con un valore di @code{"invalid"}, sono inviati solo gli avvertimenti
per cose che sono effettivamente non valide. (Questa parte non funziona
ancora perfettamente.)
Ogni altro valore @dfn{vero} stampa avvertimenti non fatali.
Se @code{LINT} ha per valore @dfn{falso} nessun avvertimento @dfn{lint} viene
stampato.
Questa variabile @`e un'estensione @command{gawk}. Non ha un valore speciale
per altre implementazioni di @command{awk}. A differenza di altre variabili
speciali, modificare il valore di @code{LINT} altera la produzione di
avvertimenti @dfn{lint} anche se @command{gawk} @`e in modalit@`a compatibile.
Analogamente a come le opzioni
@option{--lint} e @option{--traditional} controllano in maniera indipendente
diversi aspetti del comportamente di @command{gawk}, il controllo
degli avvertimenti di @dfn{lint} durante l'esecuzione del programma @`e indipendente
dall'implementazione @command{awk} in esecuzione.
@cindex @code{OFMT} (variabile)
@cindex variabile @subentry @code{OFMT}
@cindex numeri @subentry conversione in stringhe
@cindex stringa @subentry conversione in numero
@item OFMT
@`E questa la stringa che controlla la conversione di numeri in
stringhe (@pxref{Conversione}) quando li
si stampa con l'istruzione
@code{print}. Funziona passandola
come primo argomento alla funzione @code{sprintf()}
(@pxref{Funzioni per stringhe}).
Il suo valore di default @`e @code{"%.6g"}. Le prime versioni di @command{awk}
usavano @code{OFMT} per specificare il formato da usare per convertire
numeri in stringhe in espressioni generali; questo compito @`e ora svolto
da @code{CONVFMT}.
@cindex funzione @subentry @code{sprintf()} (variabile) @code{OFMT} e
@cindex @code{print} (istruzione) @subentry variabile @code{OFMT} e
@cindex istruzione @subentry @code{print} @subentry @code{OFMT} (variabile) e
@cindex variabile @subentry @code{OFS}
@cindex @code{OFS} (variabile)
@cindex campi @subentry separatore di
@cindex separatore di campo
@item OFS
@`E il separatore dei campi in output (@pxref{Separatori di output}). @`E ci@`o
che viene stampato in output per separare i campi stampati da un'istruzione @code{print}.
Il suo valore di default @`e @w{@code{" "}}, una stringa costituita da un solo
spazio.
@cindex @code{ORS} (variabile)
@cindex variabile @subentry @code{ORS}
@item ORS
Il separatore dei record in output. Viene stampato alla fine di ogni
istruzione @code{print}. Il suo valore di default @`e @code{"\n"},
il carattere di ritorno a capo.
(@xref{Separatori di output}.)
@cindex @code{PREC} (variabile)
@cindex variabile @subentry @code{PREC}
@item PREC #
La precisione disponibile nei numeri in virgola mobile a precisione arbitraria,
per default 53 bit (@pxref{Impostare la precisione}).
@cindex @code{ROUNDMODE} (variabile)
@cindex variabile @subentry @code{ROUNDMODE}
@item ROUNDMODE #
La modalit@`a di arrotondamento da usare per operazioni aritmetiche a precisione
arbitraria svolte sui numeri, per default @code{"N"}
(@code{roundTiesToEven} nello standard
IEEE 754; @pxref{Impostare modo di arrotondare}).
@cindex @code{RS} (variabile)
@cindex variabile @subentry @code{RS}
@cindex separatore di record
@cindex record @subentry separatore di
@item @code{RS}
Il separatore tra record in input. Il suo valore di default @`e una stringa
contenente il solo carattere di ritorno a capo, il che significa che un record in input
consiste di una sola riga di testo.
Il suo valore pu@`o essere anche la stringa nulla, nel qual caso i record sono
separati da una o pi@`u righe vuote.
Se invece @`e una @dfn{regexp}, i record sono separati da
corrispondenze alla @dfn{regexp} nel testo in input.
(@xref{Record}.)
La possibilit@`a che @code{RS} sia un'espressione regolare
@`e un'estensione @command{gawk}.
In molte altre implementazioni @command{awk}, oppure
se @command{gawk} @`e in modalit@`a compatibile
(@pxref{Opzioni}),
@`e usato solo il primo carattere del valore di @code{RS}.
@cindex @code{SUBSEP} (variabile)
@cindex variabile @subentry @code{SUBSEP}
@cindex separatore di indici
@cindex indici di vettore @subentry separatore di
@item @code{SUBSEP}
Il separatore di indici. Ha il valore di default di
@code{"\034"} ed @`e usato per separare le parti di cui sono composti gli indici
di un vettore multidimensionale. Quindi, l'espressione
@samp{@w{pippo["A", "B"]}}
in realt@`a accede a @code{pippo["A\034B"]}
(@pxref{Vettori multidimensionali}).
@cindex @command{gawk} @subentry variabile @subentry @code{TEXTDOMAIN} in
@cindex @code{TEXTDOMAIN} (variabile)
@cindex variabile @subentry @code{TEXTDOMAIN}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{TEXTDOMAIN}
@cindex internazionalizzazione @subentry localizzazione
@item TEXTDOMAIN #
Usata per l'internazionalizzazione di programmi a livello di
@command{awk}. Imposta il dominio di testo (@dfn{text domain}) di default per costanti stringa
marcate in maniera speciale nel codice sorgente, e anche per le funzioni
@code{dcgettext()}, @code{dcngettext()} e @code{bindtextdomain()}
@iftex
(@pxrefil{Internazionalizzazione}).
@end iftex
@ifnottex
(@pxref{Internazionalizzazione}).
@end ifnottex
Il valore di default di @code{TEXTDOMAIN} @`e @code{"messages"}.
@end table
@node Variabili auto-assegnate
@subsection Variabili predefinite con cui @command{awk} fornisce informazioni
@cindex predefinita @subentry variabile @subentry che fornisce informazioni
@cindex variabili @subentry predefinite @subentry che forniscono informazioni
Quella che segue @`e una lista in ordine alfabetico di variabili che
@command{awk} imposta automaticamente in determinate situazioni per
fornire informazioni a un programma.
Le variabili specifiche di @command{gawk} sono contrassegnate da un
cancelletto (@samp{#}). Queste variabili sono estensioni @command{gawk}.
In altre implementazioni di @command{awk} o se @command{gawk} @`e in
modalit@`a compatibile (@pxref{Opzioni}), non hanno un significato speciale:
@c @asis for docbook
@table @asis
@cindex @code{ARGC}/@code{ARGV} (variabili)
@cindex argomenti @subentry riga di comando
@cindex riga di comando @subentry argomenti
@item @code{ARGC}, @code{ARGV}
Gli argomenti della riga di comando disponibili ai programmi @command{awk}
sono memorizzati in un vettore di nome
@code{ARGV}. @code{ARGC} @`e il numero di argomenti presenti sulla
riga di comando.
@xref{Altri argomenti}.
A differenza di quasi tutti i vettori di @command{awk},
@code{ARGV} @`e indicizzato da 0 a @code{ARGC} @minus{} 1.
Lo si pu@`o vedere nell'esempio seguente:
@example
@group
$ @kbd{awk 'BEGIN @{}
> @kbd{for (i = 0; i < ARGC; i++)}
> @kbd{print ARGV[i]}
> @kbd{@}' inventory-shipped mail-list}
@print{} awk
@print{} inventory-shipped
@print{} mail-list
@end group
@end example
@noindent
@code{ARGV[0]} contiene @samp{awk}, @code{ARGV[1]}
contiene @samp{inventory-shipped} e @code{ARGV[2]} contiene
@samp{mail-list}. Il valore di @code{ARGC} @`e tre, ossia uno in pi@`u
dell'indice dell'ultimo elemento di @code{ARGV}, perch@'e gli elementi sono
numerati a partire da zero.
@cindex convenzioni di programmazione @subentry @code{ARGC}/@code{ARGV} (variabili)
I nomi @code{ARGC} e @code{ARGV}, come pure la convenzione di indicizzare
il vettore da 0 a @code{ARGC} @minus{} 1, derivano dal modo in cui il
linguaggio C accede agli argomenti presenti sulla riga di comando.
@cindex angolo buio @subentry valore di @code{ARGV[0]}
Il valore di @code{ARGV[0]} pu@`o variare da sistema a sistema.
Va anche notato che il programma @emph{non}
@`e incluso in @code{ARGV}, e non sono incluse neppure le eventuali opzioni di
@command{awk} specificate sulla riga di comando.
@xref{ARGC e ARGV} per informazioni
su come @command{awk} usa queste variabili.
@value{DARKCORNER}
@cindex @code{ARGIND} (variabile)
@cindex variabile @subentry @code{ARGIND}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{ARGIND}
@item @code{ARGIND #}
L'indice in @code{ARGV} del file correntemente in elaborazione.
Ogni volta che @command{gawk} apre un nuovo @value{DF} per elaborarlo, imposta
@code{ARGIND} all'indice in @code{ARGV} del @value{FN}.
Quando @command{gawk} sta elaborando i file in input, il confronto
@samp{FILENAME == ARGV[ARGIND]} @`e sempre verificato.
@cindex file @subentry elaborazione di @subentry variabile @code{ARGIND} e
Questa variabile @`e utile nell'elaborazione dei file; consente di stabilire
a che punto ci si trova nella lista
di @value{DF}, e anche di distinguere tra successive occorrenze dello stesso
@value{FN} sulla riga dei comandi.
@cindex nomi @subentry di file @subentry distinguere
Anche se @`e possibile modificare il valore di @code{ARGIND} all'interno del
programma @command{awk}, @command{gawk} automaticamente lo imposta a un nuovo
valore quando viene aperto il file successivo.
@cindex @code{ENVIRON} (vettore)
@cindex vettore @subentry @code{ENVIRON}
@cindex variabili d'ambiente @subentry nel vettore @code{ENVIRON}
@item @code{ENVIRON}
Un vettore associativo contenente i valori delle variabili d'ambiente.
Gli indici del vettore sono i nomi delle variabili d'ambiente; gli elementi
sono i valori della specifica variabile d'ambiente. Per esempio,
@code{ENVIRON["HOME"]} potrebbe valere @code{/home/arnold}.
Per POSIX @command{awk}, le modifiche a questo vettore non cambiano
le variabili d'ambiente passate a qualsivoglia programma che @command{awk}
pu@`o richiamare tramite una ridirezione
o usando la funzione @code{system()}.
Tuttavia, a partire dalla @value{PVERSION} 4.2, se non si @`e in
modalit@`a compatibile POSIX, @command{gawk} aggiorna le proprie variabili
d'ambiente, quando si modifica @code{ENVIRON}, e in questo modo sono
modificate anche le variabili d'ambiente disponibili ai programmi richiamati.
Un'attenzione speciale dovrebbe essere prestata alla modifica di
@code{ENVIRON["PATH"]}, che @`e il percorso di ricerca usato per trovare
i programmi eseguibili.
Queste modifiche possono anche influire sul programma @command{gawk}, poich@'e
alcune funzioni predefinite possono tener conto di certe
variabili d'ambiente.
L'esempio pi@`u notevole di una tale situazione @`e @code{mktime()}
(@pxref{Funzioni di tempo})
che, in molti sistemi, tiene conto del valore della
variabile d'ambiente @env{TZ}.
Alcuni sistemi operativi possono non avere variabili d'ambiente.
In tali sistemi, il vettore @code{ENVIRON} @`e vuoto (tranne che per
le variabili
@w{@code{ENVIRON["AWKPATH"]}} e
@w{@code{ENVIRON["AWKLIBPATH"]}} eventualmente presenti;
@pxref{AWKPATH (Variabile)} e
@ifdocbook
@ref{AWKLIBPATH (Variabile)}).
@end ifdocbook
@ifnotdocbook
@pxref{AWKLIBPATH (Variabile)}).
@end ifnotdocbook
@cindex @command{gawk} @subentry variabile @subentry @code{ERRNO} in
@cindex @code{ERRNO} (variabile)
@cindex variabile @subentry @code{ERRNO}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{ERRNO}
@cindex gestione errori @subentry variabile @code{ERRNO} e
@item @code{ERRNO #}
Se si verifica un errore di sistema durante una ridirezione per @code{getline},
durante una lettura per @code{getline} o durante un'operazione di
@code{close()}, la variabile
@code{ERRNO} contiene una stringa che descrive l'errore.
Inoltre, @command{gawk} annulla @code{ERRNO} prima di aprire ogni
file in input presente sulla riga di comando. Questo consente di controllare
se il file @`e accessibile
all'interno di un criterio di ricerca @code{BEGINFILE}
(@pxref{BEGINFILE/ENDFILE}).
Per il resto, @code{ERRNO} si comporta analogamente alla variabile C
@code{errno}.
Tranne nel caso sopra accennato, @command{gawk} non annulla @emph{mai}
@code{ERRNO} (lo imposta a zero o a @code{""}). Quindi, ci si deve
aspettare che il suo valore sia significativo solo quando un'operazione
di I/O restituisce un valore che indica il fallimento dell'operazione, come
per esempio quando @code{getline} restituisce @minus{}1. Si @`e, naturalmente,
liberi di annullarla prima di effettuare un'operazione di I/O.
Se il valore di @code{ERRNO} corrisponde a un errore di sistema della
variabile C @code{errno}, @code{PROCINFO["errno"]} sar@`a impostato al valore
di @code{errno}. Per errori non di sistema, @code{PROCINFO["errno"]} sar@`a
impostata al valore zero.
@cindex @code{FILENAME} (variabile)
@cindex variabile @subentry @code{FILENAME}
@cindex angolo buio @subentry variabile @subentry @code{FILENAME}
@item @code{FILENAME}
Il nome del file in input corrente. Quando non ci sono @value{DF}
sulla riga dei comandi, @command{awk} legge dallo standard input e
@code{FILENAME} @`e impostato a @code{"-"}. @code{FILENAME} cambia ogni
volta che si legge un nuovo file
@iftex
(@pxrefil{Leggere file}).
@end iftex
@ifnottex
(@pxref{Leggere file}).
@end ifnottex
All'interno di una
regola @code{BEGIN}, il valore di @code{FILENAME} @`e @code{""}, perch@'e non si
sta elaborando alcun file in input.@footnote{Alcune tra le prime implementazioni di Unix
@command{awk} inizializzavano @code{FILENAME} a @code{"-"}, anche se
vi erano @value{DF} da elaborare. Un tale comportamento era incorretto e
non ci si dovrebbe poter contare nei programmi.}
@value{DARKCORNER} Si noti, tuttavia,
che l'uso di @code{getline} (@pxref{Getline}) all'interno di una regola
@code{BEGIN} pu@`o implicare l'assegnamento di un valore a @code{FILENAME}.
@cindex @code{FNR} (variabile)
@cindex variabile @subentry @code{FNR}
@item @code{FNR}
Il numero del record corrente nel file corrente. @command{awk} incrementa
@code{FNR} ogni volta che legge un nuovo record (@pxref{Record}).
@command{awk} imposta nuovamente a zero @code{FNR} ogni volta che inizia a
leggere un nuovo file in input.
@cindex @code{NF} (variabile)
@cindex variabile @subentry @code{NF}
@item @code{NF}
Il numero di campi nel corrente record in input.
@code{NF} @`e impostato ogni volta che si legge un nuovo record,
quando un nuovo campo viene creato,
o quando si modifica @code{$0} (@pxref{Campi}).
A differenza di molte altre variabili descritte in questa @value{SUBSECTION},
l'assegnamento di un valore a @code{NF} pu@`o potenzialmente influenzare
il funzionamento interno di @command{awk}. In particolare, assegnamenti
a @code{NF} si possono usare per aggiungere o togliere campi dal
record corrente. @xref{Cambiare i campi}.
@cindex @code{FUNCTAB} (vettore)
@cindex vettore @subentry @code{FUNCTAB}
@cindex @command{gawk} @subentry vettore @subentry @code{FUNCTAB} in
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{FUNCTAB}
@item @code{FUNCTAB #}
Un vettore i cui indici e i corrispondenti valori sono i nomi di tutte le
funzioni predefinite, definite dall'utente ed estese, presenti nel programma.
@quotation NOTA
Il tentativo di usare l'istruzione @code{delete} per eliminare il vettore
@code{FUNCTAB} genera un errore fatale. Genera un errore fatale anche
ogni tentativo di impostare un elemento di @code{FUNCTAB}.
@end quotation
@cindex @code{NR} (variabile)
@cindex variabile @subentry @code{NR}
@item @code{NR}
Il numero di record in input che @command{awk} ha elaborato dall'inizio
dell'esecuzione del programma
(@pxref{Record}).
@command{awk} incrementa @code{NR} ogni volta che legge un nuovo record.
@cindex @command{gawk} @subentry vettore @subentry @code{PROCINFO} in
@cindex @code{PROCINFO} (vettore)
@cindex vettore @subentry @code{PROCINFO}
@cindex differenze tra @command{awk} e @command{gawk} @subentry vettore @code{PROCINFO}
@item @code{PROCINFO #}
Gli elementi di questo vettore danno accesso a informazioni sul
programma @command{awk} in esecuzione.
I seguenti elementi (elencati in ordine alfabetico)
sono sicuramente sempre disponibili:
@table @code
@item PROCINFO["argv"]
@cindex argomenti @subentry riga di comando
@cindex riga di comando @subentry argomenti
Il vettore @code{PROCINFO["argv"]} contiene tutti gli argomenti della riga di
comando (dopo che l'eventuale elaborazione di valutazione e ridirezione,
nelle piattaforme in cui ci@`o debba essere fatto a cura del programma), con
indici che vanno da 0 a @code{argc} @minus{} 1. Per esempio,
@code{PROCINFO["argv"][0]} conterr@`a il nome con cui @command{gawk} @`e stato
richiamato. Ecco un esempio di come si pu@`o usare questa funzionalit@`a:
@example
gawk '
BEGIN @{
for (i = 0; i < length(PROCINFO["argv"]); i++)
print i, PROCINFO["argv"][i]
@}'
@end example
Si tenga presente che questo vettore @`e diverso dal vettore standard
@code{ARGV} il quale non include quegli argomenti della riga di comando
che sono gi@`a stati elaborati da @command{gawk} (@pxref{ARGC e ARGV}).
@cindex effettivo @subentry @dfn{ID di gruppo} dell'utente di @command{gawk}
@item PROCINFO["egid"]
Il valore restituito dalla chiamata di sistema @code{getegid()}.
@item PROCINFO["errno"]
Il valore della variabile C @code{ERRNO} quando @code{ERRNO} @`e impostato
al messaggio di errore a essa associato.
@item PROCINFO["euid"]
@cindex @dfn{ID effettivo} dell'utente di @command{gawk}
Il valore restituito dalla chiamata di sistema @code{geteuid()}.
@item PROCINFO["FS"]
Questo elemento vale
@code{"FS"} se @`e in uso la separazione in campi con @code{FS},
@code{"FIELDWIDTHS"} se @`e in uso quella con @code{FIELDWIDTHS},
@code{"FPAT"} se @`e in uso l'individuazione di campo con @code{FPAT}, o
@code{"API"} se la divisione in campi @`e controllata da un analizzatore
di input tramite API.
@item PROCINFO["gid"]
@cindex @dfn{ID di gruppo} dell'utente @command{gawk}
Il valore restituito dalla chiamata di sistema @code{getgid()} .
@item PROCINFO["identifiers"]
@cindex programma @subentry identificativi in un
@cindex identificativi in un programma
Un sottovettore, indicizzato dai nomi di tutti gli identificativi usati
all'interno del programma @command{awk}. Un @dfn{identificativo} @`e
semplicemente il nome di una variabile
(scalare o vettoriale), una funzione predefinita, una funzione definita
dall'utente, o una funzione contenuta in un'estensione.
Per ogni identificativo, il valore dell'elemento @`e uno dei seguenti:
@table @code
@item "array"
L'identificativo @`e un vettore.
@item "builtin"
L'identificativo @`e una funzione predefinita.
@item "extension"
L'identificativo @`e una funzione in un'estensione caricata tramite
@code{@@load} o con l'opzione @option{-l}.
@item "scalar"
L'identificativo @`e uno scalare.
@item "untyped"
L'identificativo non ha ancora un tipo (potrebbe essere usato come scalare o
come vettore; @command{gawk} non @`e ancora in grado di dirlo).
@item "user"
L'identificativo @`e una funzione definita dall'utente.
@end table
@noindent
I valori riportano ci@`o che @command{gawk} sa sugli identificativi
dopo aver finito l'analisi iniziale del programma; questi valori @emph{non}
vengono pi@`u aggiornati durante l'esecuzione del programma.
@item PROCINFO["platform"]
@cindex piattaforma di esecuzione
@cindex @code{PROCINFO} (vettore) @subentry ambiente di compilazione
Quest'elemento restituisce una stringa che indica la piattaforma
per la quale @command{gawk} @`e stato compilato. Il valore sar@`a
uno dei seguenti:
@c nested table
@table @code
@item "djgpp"
@itemx "mingw"
Microsoft Windows, utilizzando DJGPP o MinGW, rispettivamente.
@item "os2"
OS/2.
@item "os390"
OS/390.
@item "posix"
GNU/Linux, Cygwin, Mac OS X, e sistemi Unix tradizionali.
@item "vms"
OpenVMS o Vax/VMS.
@end table
@item PROCINFO["pgrpid"]
@cindex @dfn{process group ID} del programma @command{gawk}
Il @dfn{ID di gruppo del processo} del programma corrente.
@item PROCINFO["pid"]
@cindex @dfn{process ID} del programma @command{gawk}
Il @dfn{process ID} del programma corrente.
@item PROCINFO["ppid"]
@cindex @dfn{parent process ID} del programma @command{gawk}
Il @dfn{ID di processo del padre} del programma corrente.
@item PROCINFO["strftime"]
La stringa col formato di default usato per la funzione @code{strftime()}.
Assegnando un nuovo valore a questo elemento si cambia quello di default.
@xref{Funzioni di tempo}.
@item PROCINFO["uid"]
Il valore restituito dalla chiamata di sistema @code{getuid()}.
@item PROCINFO["version"]
@cindex versione @subentry di @command{gawk}
@cindex @command{gawk} @subentry versione di
La versione di @command{gawk}.
@end table
I seguenti elementi addizionali del vettore
sono disponibili per fornire informazioni sulle librerie MPFR e GMP,
se la versione in uso di @command{gawk} consente il calcolo con precisione
arbitraria
(@pxref{Calcolo con precisione arbitraria}):
@table @code
@item PROCINFO["gmp_version"]
@cindex versione @subentry della libreria GNU MP
La versione della libreria GNU MP.
@cindex versione @subentry della libreria GNU MPFR
@item PROCINFO["mpfr_version"]
La versione della libreria GNU MPFR.
@item PROCINFO["prec_max"]
@cindex precisione @subentry massima consentita dalla libreria MPFR
La massima precisione consentita da MPFR.
@item PROCINFO["prec_min"]
@cindex precisione @subentry minima richiesta dalla libreria MPFR
La precisione minima richiesta da MPFR.
@end table
I seguenti elementi addizionali del vettore
sono disponibili per fornire
informazioni sulla versione dell'estensione API, se la versione
di @command{gawk} prevede il caricamento dinamico di funzioni di estensione
@iftex
(@pxrefil{Estensioni dinamiche}):
@end iftex
@ifnottex
(@pxref{Estensioni dinamiche}):
@end ifnottex
@table @code
@item PROCINFO["api_major"]
@cindex versione @subentry dell'estensione API @command{gawk}
@cindex estensione API @subentry numero di versione
La versione principale dell'estensione API.
@item PROCINFO["api_minor"]
La versione secondaria dell'estensione API.
@end table
@cindex gruppi @subentry Unix supplementari visualizzati in @command{gawk}
Su alcuni sistemi, ci possono essere elementi nel vettore, da @code{"group1"}
fino a @code{"group@var{N}"}. @var{N} @`e il numero di
gruppi supplementari che il processo [Unix] possiede. Si usi l'operatore
@code{in} per verificare la presenza di questi elementi
(@pxref{Visitare elementi}).
I seguenti elementi consentono di modificare il comportamento di
@command{gawk}:
@table @code
@item PROCINFO["NONFATAL"]
Se questo elemento esiste, gli errori di I/O per tutte le ridirezioni
consentono la prosecuzione del programma.
@xref{Continuazione dopo errori}.
@item PROCINFO["@var{nome}", "NONFATAL"]
Gli errori di I/O per il file @var{nome}
consentono la prosecuzione del programma.
@xref{Continuazione dopo errori}.
@item PROCINFO["@var{comando}", "pty"]
Per una comunicazione bidirezionale con @var{comando}, si usi una pseudo-tty
invece di impostare una @dfn{pipe} bidirezionale.
@xref{I/O bidirezionale} per ulteriori informazioni.
@item PROCINFO["@var{input_name}", "READ_TIMEOUT"]
Imposta un tempo limite per leggere dalla ridirezione di input @var{input_name}.
@xref{Timeout in lettura} per ulteriori informazioni.
@item PROCINFO["@var{input_name}", "RETRY"]
Se durante la lettura del file @var{input_name} si verifica un errore di I/O
per il quale si pu@`o ritentare una lettura, e questo elemento di vettore
esiste, @code{getline} d@`a come codice di ritorno @minus{}2 invece di
seguire il comportamento di default, che consiste nel restituire @minus{}1
e configurare @var{input_name} in modo che non fornisca pi@`u alcun dato.
Un errore di I/O per cui si pu@`o ritentare una lettura in cui @code{errno}
ha il valore @code{EAGAIN}, @code{EWOULDBLOCK}, @code{EINTR},
o @code{ETIMEDOUT}. Ci@`o pu@`o essere utile in associazione con l'elemento
di vettore @code{PROCINFO["@var{input_name}", "READ_TIMEOUT"]}
o in situazioni in cui un descrittore di file @`e stato configurato
per comportarsi in modo da non bloccare l'elaborazione.
@xref{Proseguire dopo errore in input} per ulteriori informazioni.
@item PROCINFO["sorted_in"]
Se questo elemento esiste in @code{PROCINFO}, il suo valore controlla
l'ordine in cui gli indici dei vettori saranno elaborati nei cicli
@samp{for (@var{indice} in @var{vettore})}.
Questa @`e una funzionalit@`a avanzata, la cui descrizione completa sar@`a vista
pi@`u avanti; si veda
@ref{Controllare visita}.
@end table
@cindex @code{RLENGTH} (variabile)
@cindex variabile @subentry @code{RLENGTH}
@item @code{RLENGTH}
La lunghezza della sottostringa individuata dalla funzione
@code{match()}
(@pxref{Funzioni per stringhe}).
@code{RLENGTH} viene impostata quando si richiama la funzione @code{match()}.
Il suo
valore @`e la lunghezza della stringa individuata, oppure @minus{}1 se non @`e
stata trovata alcuna corrispondenza.
@cindex @code{RSTART} (variabile)
@cindex variabile @subentry @code{RSTART}
@item @code{RSTART}
L'indice, in caratteri, da cui parte la sottostringa che @`e individuata dalla
funzione @code{match()}
(@pxref{Funzioni per stringhe}).
@code{RSTART} viene impostata quando si richiama la funzione @code{match()}.
Il suo
valore @`e la posizione nella stringa da cui inizia la sottostringa
individuata, oppure zero, se non @`e stata trovata alcuna corrispondenza.
@cindex @command{gawk} @subentry variabile @subentry @code{RT} in
@cindex @code{RT} (variabile)
@cindex variabile @subentry @code{RT}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabili @code{RS}/@code{RT}
@item @code{RT #}
Il testo in input che corrisponde al testo individuato da @code{RS},
il separatore di record. Questa variabile viene impostata dopo aver letto
ciascun record.
@cindex @command{gawk} @subentry vettore @subentry @code{SYMTAB} in
@cindex @code{SYMTAB} (vettore)
@cindex vettore @subentry @code{SYMTAB}
@cindex differenze tra @command{awk} e @command{gawk} @subentry vettore @code{SYMTAB}
@item @code{SYMTAB #}
Un vettore i cui indici sono i nomi di tutte le variabili globali e i vettori
definiti nel programma. @code{SYMTAB} rende visibile al
programmatore @command{awk} la tabella dei simboli di @command{gawk}.
Viene preparata nella fase di analisi iniziale del programma @command{gawk}
ed @`e completata prima di cominciare a eseguire il programma.
Il vettore pu@`o essere usato per accedere indirettamente, in lettura o in
scrittura, al valore di una variabile:
@example
pippo = 5
SYMTAB["pippo"] = 4
print pippo # stampa 4
@end example
@noindent
La funzione @code{isarray()} (@pxref{Funzioni per i tipi}) si pu@`o usare per
controllare se un elemento in @code{SYMTAB} @`e un vettore.
Inoltre, non @`e possibile usare l'istruzione @code{delete} con il vettore
@code{SYMTAB}.
Prima della @value{PVERSION} 5.0 di @command{gawk}, era possibile
usare come indice per @code{SYMTAB} una stringa che non era un
identificativo gi@`a esistente:
@example
SYMTAB["xxx"] = 5
print SYMTAB["xxx"]
@end example
@noindent
Ci@`o non @`e pi@`u possibile, e il farlo determina un errore
fatale, perch@'e il poterlo fare era solo fonte di confusione.
@cindex Schorr, Andrew
Il vettore @code{SYMTAB} @`e pi@`u interessante di quel che sembra. Andrew
Schorr fa notare che effettivamente consente di ottenere dei puntatori ai dati
in @command{awk}. Si consideri quest'esempio:
@example
@group
# Moltiplicazione indiretta di una qualsiasi variabile per un
# numero a piacere e restituzione del risultato
function multiply(variabile, numero)
@{
return SYMTAB[variabile] *= numero
@}
@end group
@end example
@noindent
Si potrebbe usare in questo modo:
@example
BEGIN @{
risposta = 10.5
multiply("risposta", 4)
print "La risposta @`e", risposta
@}
@end example
@noindent
Eseguendo, il risultato @`e:
@example
$ @kbd{gawk -f risposta.awk}
@print{} La risposta @`e 42
@end example
@quotation NOTA
Per evitare seri paradossi temporali,
@footnote{Per non parlare dei grossi problemi di implementazione.}
n@'e @code{FUNCTAB} n@'e @code{SYMTAB} sono disponibili come
elemento all'interno del vettore @code{SYMTAB}.
@end quotation
@end table
@sidebar Modificare @code{NR} e @code{FNR}
@cindex @code{NR} (variabile) @subentry modifica di
@cindex variabile @subentry @code{NR} @subentry modifica di
@cindex @code{FNR} (variabile) @subentry modifica di
@cindex variabile @subentry @code{FNR} @subentry modifica di
@cindex angolo buio @subentry variabile @subentry @code{FNR}/@code{NR}
@command{awk} incrementa le variabili @code{NR} e @code{FNR}
ogni volta che legge un record, invece che impostarle al valore assoluto del
numero di record letti. Ci@`o significa che un programma pu@`o
modificare queste variabili e i valori cos@`{@dotless{i}} assegnati sono incrementati per
ogni record.
@value{DARKCORNER}
Si consideri l'esempio seguente:
@example
$ @kbd{echo '1}
> @kbd{2}
> @kbd{3}
> @kbd{4' | awk 'NR == 2 @{ NR = 17 @}}
> @kbd{@{ print NR @}'}
@print{} 1
@print{} 17
@print{} 18
@print{} 19
@end example
@noindent
Prima che @code{FNR} venisse aggiunto al linguaggio @command{awk}
(@pxref{V7/SVR3.1}),
molti programmi @command{awk} usavano questa modalit@`a per
contare il numero di record in un file impostando a zero @code{NR} al cambiare
di @code{FILENAME}.
@end sidebar
@node ARGC e ARGV
@subsection Usare @code{ARGC} e @code{ARGV}
@cindex @code{ARGC}/@code{ARGV} (variabili) @subentry come usarle
@cindex variabile @subentry @code{ARGC}/@code{ARGV} @subentry utilizzo
@cindex argomenti @subentry riga di comando
@cindex riga di comando @subentry argomenti
@iftex
La
@end iftex
@ref{Variabili auto-assegnate}
conteneva il programma seguente che visualizzava le informazioni contenute
in @code{ARGC} e @code{ARGV}:
@example
@group
$ @kbd{awk 'BEGIN @{}
> @kbd{for (i = 0; i < ARGC; i++)}
> @kbd{print ARGV[i]}
> @kbd{@}' inventory-shipped mail-list}
@print{} awk
@print{} inventory-shipped
@print{} mail-list
@end group
@end example
@noindent
In questo esempio, @code{ARGV[0]} contiene @samp{awk}, @code{ARGV[1]}
contiene @samp{inventory-shipped} e @code{ARGV[2]} contiene
@samp{mail-list}.
Si tenga presente che il nome del programma @command{awk}
non @`e incluso in @code{ARGV}.
Le altre opzioni della riga di comando, con i relativi argomenti,
sono parimenti non presenti, compresi anche gli assegnamenti di
variabile fatti tramite l'opzione @option{-v}
(@pxref{Opzioni}).
I normali assegnamenti di variabile sulla riga dei comandi @emph{sono}
trattati come argomenti e quindi inseriti nel vettore @code{ARGV}.
Dato il seguente programma in un file di nome @file{vediargomenti.awk}:
@example
BEGIN @{
printf "A=%d, B=%d\n", A, B
for (i = 0; i < ARGC; i++)
printf "\tARGV[%d] = %s\n", i, ARGV[i]
@}
END @{ printf "A=%d, B=%d\n", A, B @}
@end example
@noindent
la sua esecuzione produce il seguente risultato:
@example
$ @kbd{awk -v A=1 -f vediargomenti.awk B=2 /dev/null}
@print{} A=1, B=0
@print{} ARGV[0] = awk
@print{} ARGV[1] = B=2
@print{} ARGV[2] = /dev/null
@print{} A=1, B=2
@end example
Un programma pu@`o modificare @code{ARGC} e gli elementi di @code{ARGV}.
Ogni volta che @command{awk} arriva alla fine di un file in input, usa
il successivo elemento nel vettore @code{ARGV} come nome del successivo file
in input. Cambiando il contenuto di quella stringa, un programma
pu@`o
modificare la lista dei file che sono letti.
Si usi @code{"-"} per rappresentare lo standard input. Assegnando ulteriori
elementi e incrementando @code{ARGC}
verranno letti ulteriori file.
Se il valore di @code{ARGC} viene diminuto, vengono ignorati i file in input
posti alla fine della lista. Memorizzando il valore originale di @code{ARGC}
da qualche altra parte, un programma pu@`o gestire gli argomenti
ignorati come se fossero qualcosa di diverso dai @value{FN}.
Per eliminare un file che sia in mezzo alla lista, si imposti in @code{ARGV}
la stringa nulla
(@code{""}) al posto del nome del file in questione. Come funzionalit@`a
speciale, @command{awk} ignora valori di @value{FN} che siano stati
rimpiazzati con la stringa nulla.
Un'altra possibilit@`a @`e quella
di usare l'istruzione @code{delete} per
togliere elementi da @code{ARGV} (@pxref{Cancellazione}).
Tutte queste azioni sono tipicamente eseguite nella regola @code{BEGIN},
prima di iniziare l'elaborazione vera e propria dell'input.
@xref{Programma split} e
@ifnotdocbook
@pxref{Programma tee}
@end ifnotdocbook
@ifdocbook
@ref{Programma tee}
@end ifdocbook
per esempi
su ognuno dei modi per togliere elementi dal vettore @code{ARGV}.
Per passare direttamente delle opzioni a un programma scritto in
@command{awk}, si devono terminare le opzioni di @command{awk} con
@option{--} e poi inserire le opzioni destinate al programma @command{awk},
come mostrato di seguito:
@example
awk -f mio_programma.awk -- -v -q file1 file2 @dots{}
@end example
Il seguente frammento di programma ispeziona @code{ARGV} per esaminare, e
poi rimuovere, le opzioni sulla riga di comando viste sopra:
@example
BEGIN @{
for (i = 1; i < ARGC; i++) @{
if (ARGV[i] == "-v")
verbose = 1
else if (ARGV[i] == "-q")
debug = 1
else if (ARGV[i] ~ /^-./) @{
e = sprintf("%s: opzione non riconosciuta -- %c",
ARGV[0], substr(ARGV[i], 2, 1))
print e > "/dev/stderr"
@} else
break
delete ARGV[i]
@}
@}
@end example
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabili @code{ARGC}/@code{ARGV}
Terminare le opzioni di @command{awk} con @option{--} non @`e
necessario in @command{gawk}. A meno che non si specifichi @option{--posix},
@command{gawk} inserisce, senza emettere messaggi, ogni opzione non
riconosciuta
nel vettore @code{ARGV} perch@'e sia trattata dal programma @command{awk}.
Dopo aver trovato un'opzione non riconosciuta, @command{gawk} non cerca
ulteriori opzioni, anche se ce ne fossero di riconoscibili.
La riga dei comandi precedente sarebbe
con @command{gawk}:
@example
gawk -f mio_programma.awk -q -v file1 file2 @dots{}
@end example
@noindent
Poich@'e @option{-q} non @`e un'opzione valida per @command{gawk}, quest'opzione
e l'opzione @option{-v} che segue sono passate al programma @command{awk}.
(@xref{Funzione getopt} per una funzione di libreria @command{awk}
che analizza le opzioni della riga di comando.)
Nel progettare un programma, si dovrebbero scegliere opzioni che non
siano in conflitto con quelle di @command{gawk}, perch@'e ogni opzioni
accettata da @command{gawk} verr@`a elaborata prima di passare il resto
della riga dei comandi al programma @command{awk}.
Usare @samp{#!} con l'opzione @option{-E} pu@`o essere utile in questo caso
(@pxref{@dfn{Script} eseguibili}
e
@ifnotdocbook
@pxref{Opzioni}).
@end ifnotdocbook
@ifdocbook
@ref{Opzioni}).
@end ifdocbook
@node Sommario criteri e azioni
@section Sommario
@itemize @value{BULLET}
@item
Coppie @dfn{criterio di ricerca--azione} sono gli elementi base di un
programma @command{awk}. I criteri di ricerca possono essere espressioni
normali, espressioni di intervallo, o costanti @dfn{regexp}; possono anche
essere i criteri speciali @code{BEGIN}, @code{END},
@code{BEGINFILE} o @code{ENDFILE}; o essere omessi. L'azione viene eseguita
se il record corrente soddisfa il criterio di ricerca. Criteri di ricerca
vuoti (omessi) corrispondono a
tutti i record in input.
@item
L'I/O effettuato nelle azioni delle regole @code{BEGIN} ed @code{END}
ha alcuni vincoli.
Questo vale a maggior ragione per le regole @code{BEGINFILE} ed
@code{ENDFILE}. Queste ultime due forniscono degli ``agganci'' per interagire
con l'elaborazione dei file fatta da @command{gawk},
consentendo di risolvere situazioni che altrimenti genererebbero degli
errori fatali (ad esempio per un file che non si @`e autorizzati
a leggere).
@item
Le variabili di shell possono essere usate nei programmi @command{awk}
prestando la dovuta attenzione all'uso degli apici.
@`E pi@`u facile passare una variabile di shell ad
@command{awk} usando l'opzione @option{-v} e una variabile @command{awk}.
@item
Le azioni sono formate da istruzioni racchiuse tra parentesi graffe.
Le istruzioni sono composte da
espressioni, istruzioni di controllo,
istruzioni composte,
istruzioni di input/output e istruzioni di cancellazione.
@item
Le istruzioni di controllo in @command{awk} sono @code{if}-@code{else},
@code{while}, @code{for} e @code{do}-@code{while}. @command{gawk}
aggiunge l'istruzione @code{switch}. Ci sono due tipi di istruzione
@code{for}: uno per eseguire dei cicli, e l'altro per esaminare un vettore.
@item
Le istruzioni @code{break} e @code{continue} permettono di uscire
velocemente da un ciclo, o di passare alla successiva iterazione dello
stesso (o di uscire da un'istruzione @code{switch}).
@item
Le istruzioni @code{next} e @code{nextfile} permettono, rispettivamente,
di passare al record successivo, ricominciando l'elaborazione dalla prima
regola del programma, o di passare al successivo file in input, sempre
ripartendo dalla prima regola del programma.
@item
L'istruzione @code{exit} termina il programma. Quando @`e eseguita
dall'interno di un'azione (o nel corpo di una funzione), trasferisce
il controlla alle eventuali istruzioni @code{END}. Se @`e eseguita nel corpo
di un'istruzione @code{END}, il programma @`e terminato
immediatamente. @`E possibile specificare un valore numerico da usare come
codice di ritorno di @command{awk}.
@item
Alcune variabili predefinite permettono di controllare @command{awk},
principalmente per l'I/O. Altre variabili trasmettono informazioni
da @command{awk} al programma.
@item
I vettori @code{ARGC} e @code{ARGV} rendono disponibili al programma gli
argomenti della riga di comando. Una loro modifica all'interno di una regola
@code{BEGIN} permette di controllare come @command{awk} elaborer@`a i @value{DF}
in input.
@end itemize
@node Vettori
@chapter Vettori in @command{awk}
@cindex vettori
Un @dfn{vettore} @`e una tabella di valori chiamati @dfn{elementi}. Gli
elementi di un vettore sono individuati dai loro @dfn{indici}. Gli indici
possono essere numeri o stringhe.
Questo @value{CHAPTER} descrive come funzionano i vettori in @command{awk},
come usare gli elementi di un vettore, come visitare tutti gli elementi
di un vettore, e come rimuovere elementi da un vettore.
Descrive anche come @command{awk} simula vettori multidimensionali,
oltre ad alcuni aspetti meno ovvii sull'uso dei vettori.
Il @value{CHAPTER} prosegue illustrando la funzionalit@`a di ordinamento dei
vettori di @command{gawk}, e termina con una breve descrizione della capacit@`a
di @command{gawk} di consentire veri vettori di vettori.
@menu
* Fondamenti sui vettori:: Informazioni di base sui vettori.
* Indici numerici di vettore:: Come usare numeri come indici in
@command{awk}.
* Indici non inizializzati:: Usare variabili non inizializzate come indici.
* Cancellazione:: L'istruzione @code{delete} toglie un elemento
da un vettore.
* Vettori multidimensionali:: Emulare vettori multidimensionali in
@command{awk}.
* Vettori di vettori:: Vettori multidimensionali veri.
* Sommario dei vettori:: Sommario dei vettori.
@end menu
@node Fondamenti sui vettori
@section Informazioni di base sui vettori
Questa @value{SECTION} espone le nozioni fondamentali: elaborare gli elementi
di un vettore uno alla volta, e visitare sequenzialmente tutti gli elementi
di un vettore.
@menu
* Introduzione ai vettori:: Introduzione ai vettori
* Visitare elementi:: Come esaminare un elemento di un vettore.
* Impostare elementi:: Come cambiare un elemento di un vettore.
* Esempio di vettore:: Esempio semplice di vettore
* Visitare un intero vettore:: Variazione dell'istruzione @code{for}. Esegue
un ciclo attraverso gli indici degli elementi
contenuti in un vettore.
* Controllare visita:: Controllare l'ordine in cui i vettori sono
visitati.
@end menu
@node Introduzione ai vettori
@subsection Introduzione ai vettori
@cindex Wall, Larry
@quotation
@i{Visitare sequenzialmente un vettore associativo @`e come tentare di
lapidare qualcuno usando una mitragliatrice Uzi carica.}
@author Larry Wall
@end quotation
Il linguaggio @command{awk} mette a disposizione vettori monodimensionali per
memorizzare gruppi di stringhe o di numeri correlati fra loro. Ogni vettore di
@command{awk} deve avere un nome. I nomi dei vettori hanno la stessa sintassi
dei nomi di variabile; qualsiasi nome valido di variabile potrebbe essere anche
un valido nome di vettore. Un nome per@`o non pu@`o essere usato in entrambi i
modi (come vettore e come variabile) nello stesso programma @command{awk}.
I vettori in @command{awk} assomigliano superficialmente ai vettori in altri
linguaggi di programmazione, ma ci sono differenze fondamentali. In
@command{awk}, non @`e necessario specificare la dimensione di un vettore prima
di iniziare a usarlo. In pi@`u, qualsiasi numero o stringa pu@`o essere usato
come indice di un vettore, non solo numeri interi consecutivi.
Nella maggior parte degli altri linguaggi, i vettori devono essere
@dfn{dichiarati} prima dell'uso, specificando quanti elementi o componenti
contengono. In questi linguaggi, la dichiarazione causa l'allocazione, per
questi elementi, di un blocco di memoria contiguo.
Normalmente, un indice di un vettore dev'essere un intero non negativo.
Per esempio, l'indice zero specifica il primo elemento nel vettore, che @`e
effettivamente memorizzato all'inizio di un blocco di memoria. L'indice uno
specifica il secondo elemento, che @`e memorizzato subito dopo il primo elemento,
e cos@`{@dotless{i}} via. @`E impossibile aggiungere ulteriori elementi al vettore, perch@'e
esso pu@`o contenere solo il numero di elementi dichiarato.
(Alcuni linguaggi consentono indici iniziali e finali arbitrari --- p.es.,
@samp{15 .. 27} --- per@`o la dimensione del vettore rimane fissa una volta che
il vettore sia stato dichiarato.)
@c 1/2015: Do not put the numeric values into @code. Array element
@c values are no different than scalar variable values.
Un vettore contiguo di quattro elementi potrebbe essere come quello in
@ifnotdocbook
@ref{vettore-elementi},
@end ifnotdocbook
@ifdocbook
come mostrato in @inlineraw{docbook, }:
@end ifdocbook
concettualmente, se i valori degli elementi sono 8, @code{"pippo"},
@code{""} e 30.
@ifnotdocbook
@float Figura,vettore-elementi
@caption{Un vettore contiguo}
@ifset SMALLPRINT
@center @image{vettore-elementi, 11cm, , Un vettore contiguo}
@end ifset
@ifclear SMALLPRINT
@center @image{vettore-elementi, , , Un vettore contiguo}
@end ifclear
@end float
@end ifnotdocbook
@docbook
Un vettore contiguo
@end docbook
@noindent
Vengono memorizzati solo i valori; gli indici sono definiti implicitamente
dall'ordine dei valori. Qui, 8 @`e il valore il cui indice @`e zero, perch@'e 8
appare nella posizione con zero elementi prima di essa.
@cindex vettori @subentry indicizzazione di
@cindex indici di vettore
@cindex associativi @subentry vettori
@cindex vettori @subentry associativi
I vettori in @command{awk} non sono di questo tipo: sono invece
@dfn{associativi}.
Ci@`o significa che ogni vettore @`e un insieme di coppie, ognuna costituita
da un indice e dal corrispondente valore dell'elemento del vettore:
@ifnotdocbook
@c extra empty column to indent it right
@multitable @columnfractions .1 .1 .1
@headitem @tab Indice @tab Valore
@item @tab @code{3} @tab @code{30}
@item @tab @code{1} @tab @code{"pippo"}
@item @tab @code{0} @tab @code{8}
@item @tab @code{2} @tab @code{""}
@end multitable
@end ifnotdocbook
@docbook
Indice
Valore
3
30
1
"pippo"
0
8
2
""
@end docbook
@noindent
Le coppie sono elencate in ordine casuale perch@'e il loro ordinamento @`e
irrilevante.@footnote{L'ordine potr@`a variare nelle diverse implementazioni
di @command{awk}, che tipicamente usa tabelle @dfn{hash} per memorizzare
elementi e valori del vettore.}
Un vantaggio dei vettori associativi @`e che si possono aggiungere nuove coppie
in qualsiasi momento. Per esempio, supponiamo di aggiungere al vettore un
decimo elemento il cui valore sia @w{@code{"numero dieci"}}. Il risultato sar@`a:
@ifnotdocbook
@c extra empty column to indent it right
@multitable @columnfractions .1 .1 .3
@headitem @tab Indice @tab Valore
@item @tab @code{10} @tab @code{"numero dieci"}
@item @tab @code{3} @tab @code{30}
@item @tab @code{1} @tab @code{"pippo"}
@item @tab @code{0} @tab @code{8}
@item @tab @code{2} @tab @code{""}
@end multitable
@end ifnotdocbook
@docbook
Indice
Valore
10
"numero dieci"
3
30
1
"pippo"
0
8
2
""
@end docbook
@noindent
@cindex sparsi @subentry vettori
@cindex vettori @subentry sparsi
Ora il vettore @`e @dfn{sparso}, il che significa semplicemente che non sono
usati alcuni indici. Ha gli elementi 0, 1, 2, 3 e 10, ma mancano gli
elementi 4, 5, 6, 7, 8 e 9.
Un'altra caratteristica dei vettori associativi @`e che gli indici non devono
essere necessariamente interi non negativi. Qualsiasi numero, o anche una
stringa, pu@`o essere un indice. Per esempio, il seguente @`e un vettore che
traduce delle parole dall'inglese all'italiano:
@ifnotdocbook
@multitable @columnfractions .1 .1 .1
@headitem @tab Indice @tab Valore
@item @tab @code{"dog"} @tab @code{"cane"}
@item @tab @code{"cat"} @tab @code{"gatto"}
@item @tab @code{"one"} @tab @code{"uno"}
@item @tab @code{1} @tab @code{"uno"}
@end multitable
@end ifnotdocbook
@docbook
Indice
Valore
"dog"
"cane"
"cat"
"gatto"
"one"
"uno"
1
"uno"
@end docbook
@noindent
Qui abbiamo deciso di tradurre il numero uno sia nella forma letterale che in
quella numerica, per illustrare che un singolo vettore pu@`o avere come indici
sia numeri che stringhe.
(In effetti, gli indici dei vettori sono sempre stringhe.
Ci sono alcune sottigliezze su come funzionano i numeri quando sono usati come
indici dei vettori; questo verr@`a trattato in maggior dettaglio nella
@ref{Indici numerici di vettore}.)
Qui sopra, il numero @code{1} non @`e tra doppi apici, perch@'e @command{awk}
lo converte automaticamente in una stringa.
@cindex @command{gawk} @subentry variabile @subentry @code{IGNORECASE} in
@cindex maiuscolo/minuscolo @subentry distinzione @subentry negli indici dei vettori
@cindex vettori @subentry ordinamento @subentry variabile @code{IGNORECASE} e
@cindex @code{IGNORECASE} (variabile) @subentry indici dei vettori e
@cindex variabile @subentry @code{IGNORECASE} @subentry indici di vettore e
Il valore di @code{IGNORECASE} non ha alcun effetto sull'indicizzazione dei
vettori. Lo stesso valore di stringa usato per memorizzare un elemento di un
vettore pu@`o essere usato per richiamarlo.
Quando @command{awk} crea un vettore (p.es., con la funzione predefinita
@code{split()}), gli indici di quel vettore sono numeri interi consecutivi
a partire da uno.
(@xref{Funzioni per stringhe}.)
I vettori di @command{awk} sono efficienti: il tempo necessario per accedere a
un elemento @`e indipendente dal numero di elementi nel vettore.
@node Visitare elementi
@subsection Come esaminare un elemento di un vettore
@cindex vettori @subentry elementi @subentry esaminare gli
@cindex vettori @subentry elementi
@cindex elementi @subentry di vettore
Il modo principale di usare un vettore @`e quello di esaminare uno dei suoi
elementi. Un @dfn{riferimento al vettore} @`e un'espressione come questa:
@example
@var{vettore}[@var{espressione-indice}]
@end example
@noindent
Qui, @var{vettore} @`e il nome di un vettore. L'espressione
@var{espressione-indice} @`e l'indice dell'elemento del vettore che si vuol
esaminare.
@c 1/2015: Having the 4.3 in @samp is a little iffy. It's essentially
@c an expression though, so leave be. It's to early in the discussion
@c to mention that it's really a string.
Il valore del riferimento al vettore @`e il valore corrente di quell'elemento
del vettore. Per esempio, @code{pippo[4.3]} @`e un'espressione che richiama
l'elemento del vettore @code{pippo} il cui indice @`e @samp{4.3}.
@cindex vettori @subentry elementi @subentry non assegnati
@cindex elementi @subentry di vettore @subentry non assegnati
@cindex elementi @subentry di vettore @subentry vuoti
Un riferimento a un elemento di un vettore il cui indice non esiste ancora
restituisce un valore uguale a @code{""}, la stringa nulla. Questo comprende
elementi a cui non @`e stato assegnato un valore ed elementi che sono stati
eliminati (@pxref{Cancellazione}).
@cindex elementi @subentry di vettore @subentry inesistenti
@cindex vettori @subentry elementi @subentry inesistenti
@quotation NOTA
Un riferimento a un elemento inesistente crea @emph{automaticamente}
quell'elemento di vettore, con la stringa nulla come valore. (In certi casi,
ci@`o @`e indesiderabile, perch@'e potrebbe sprecare memoria all'interno di
@command{awk}.)
I programmatori principianti di @command{awk} fanno spesso l'errore di
verificare se un elemento esiste controllando se il valore @`e vuoto:
@example
# Verifica se "pippo" esiste in a: @ii{Non corretto!}
if (a["pippo"] != "") @dots{}
@end example
@noindent
Questo @`e sbagliato per due motivi. Primo, @emph{crea} @code{a["pippo"]}
se ancora non esisteva! Secondo, assegnare a un elemento di un vettore la
stringa vuota come valore @`e un'operazione valida (anche se un po' insolita).
@end quotation
@c @cindex arrays, @code{in} operator and
@cindex @code{in} (operatore) @subentry verificare se un elemento esiste in un vettore
Per determinare se un elemento con un dato indice esiste in un vettore,
si usi la seguente espressione:
@example
@var{indice} in @var{vettore}
@end example
@cindex effetti collaterali @subentry indicizzazione di vettori
@noindent
Quest'espressione verifica se lo specifico indice @var{indice} esiste, senza
l'effetto collaterale di creare quell'elemento nel caso che esso non sia
presente. L'espressione ha il valore uno (vero) se
@code{@var{vettore}[@var{indice}]}
esiste e zero (falso) se non esiste.
@c (Qui usiamo @var{indx}, perch@'e @samp{index} @`e il nome di una funzione
@c predefinita.)
Per esempio, quest'istruzione verifica se il vettore @code{frequenze}
contiene l'indice @samp{2}:
@example
@group
if (2 in frequenze)
print "L'indice 2 @`e presente."
@end group
@end example
Si noti che questo @emph{non} verifica se il vettore
@code{frequenze} contiene un elemento il cui @emph{valore} @`e 2.
Il solo modo far questo @`e quello di passare in rassegna tutti gli
elementi. Inoltre, questo @emph{non} crea @code{frequenze[2]}, mentre la
seguente alternativa (non corretta) lo fa:
@example
@group
if (frequenze[2] != "")
print "L'indice 2 @`e presente."
@end group
@end example
@node Impostare elementi
@subsection Assegnare un valore a elementi di un vettore
@cindex vettori @subentry elementi @subentry assegnare valori
@cindex elementi @subentry di vettore @subentry assegnare valori a
Agli elementi di un vettore possono essere assegnati valori proprio come
alle variabili di @command{awk}:
@example
@var{vettore}[@var{espressione-indice}] = @var{valore}
@end example
@noindent
@var{vettore} @`e il nome di un vettore. L'espressione
@var{espressione-indice} @`e l'indice dell'elemento del vettore a cui @`e
assegnato il valore. L'espressione @var{valore} @`e il valore da assegnare
a quell'elemento del vettore.
@node Esempio di vettore
@subsection Esempio semplice di vettore
@cindex vettori @subentry esempio sull'uso
Il seguente programma prende una lista di righe, ognuna delle quali inizia con
un numero di riga, e le stampa in ordine di numero di riga. I numeri di riga
non sono ordinati al momento della lettura, ma sono invece in ordine sparso.
Questo programma ordina le righe mediante la creazione di un vettore che usa
i numeri di riga come indici. Il programma stampa poi le righe
ordinate secondo il loro numero. @`E un programma molto semplice e non @`e in
grado di gestire numeri ripetuti, salti di riga o righe che non
iniziano con un numero:
@example
@c file eg/misc/arraymax.awk
@{
if ($1 > massimo)
massimo = $1
vett[$1] = $0
@}
END @{
for (x = 1; x <= massimo; x++)
print vett[x]
@}
@c endfile
@end example
La prima regola tiene traccia del numero di riga pi@`u grande visto
durante la lettura;
memorizza anche ogni riga nel vettore @code{vett}, usando come indice
il numero di riga.
La seconda regola viene eseguita dopo che @`e stato letto tutto l'input, per
stampare tutte le righe.
Quando questo programma viene eseguito col seguente input:
@example
@group
@c file eg/misc/arraymax.data
5 Io sono l'uomo Cinque
2 Chi sei? Il nuovo numero due!
4 . . . E quattro a terra
1 Chi @`e il numero uno?
3 Sei il tre.
@c endfile
@end group
@end example
@noindent
Il suo output @`e:
@example
@group
1 Chi @`e il numero uno?
2 Chi sei? Il nuovo numero due!
3 Sei il tre.
4 . . . E quattro a terra
5 Io sono l'uomo Cinque
@end group
@end example
Se un numero di riga appare pi@`u di una volta, l'ultima riga con quel dato
numero prevale sulle altre.
Le righe non presenti nel vettore
si possono saltare con un semplice perfezionamento della
regola @code{END} del programma, in questo modo:
@example
@group
END @{
for (x = 1; x <= massimo; x++)
if (x in vett)
print vett[x]
@}
@end group
@end example
@node Visitare un intero vettore
@subsection Visitare tutti gli elementi di un vettore
@cindex elementi @subentry di vettore @subentry visitare
@cindex visitare @subentry vettori
@cindex vettori @subentry visitare
@cindex cicli @subentry @code{for} @subentry visita di un vettore
Nei programmi che usano vettori, @`e spesso necessario usare un ciclo che
esegue un'azione su ciascun elemento di un vettore. In altri linguaggi, dove
i vettori sono contigui e gli indici sono limitati ai numeri interi
non negativi,
questo @`e facile: tutti gli indici validi possono essere visitati partendo
dall'indice pi@`u basso e arrivando a quello pi@`u alto. Questa tecnica non
@`e applicabile in @command{awk}, perch@'e qualsiasi numero o stringa pu@`o
fare da indice in un vettore. Perci@`o @command{awk} ha un tipo speciale di
istruzione @code{for} per visitare un vettore:
@example
@group
for (@var{variabile} in @var{vettore})
@var{corpo}
@end group
@end example
@noindent
@cindex @code{in} (operatore) @subentry uso in cicli
@cindex operatore @subentry @code{in} @subentry uso in cicli
Questo ciclo esegue @var{corpo} una volta per ogni indice in @var{vettore} che
il programma ha usato precedentemente, con la variabile @var{variabile}
impostata a quell'indice.
@cindex vettori @subentry istruzione @code{for} e
@cindex @code{for} (istruzione) @subentry esecuzione di cicli su un vettore
Il seguente programma usa questa forma dell'istruzione @code{for}. La
prima regola visita i record in input e tiene nota di quali parole appaiono
(almeno una volta) nell'input, memorizzando un 1 nel vettore @code{usate} con
la parola come indice. La seconda regola visita gli elementi di
@code{usate} per trovare tutte le parole distinte che appaiono nell'input.
Il programma stampa poi ogni parola che @`e pi@`u lunga di 10 caratteri e
anche il numero di tali parole.
@xref{Funzioni per stringhe}
per maggiori informazioni sulla funzione predefinita @code{length()}.
@example
@group
# Registra un 1 per ogni parola usata almeno una volta
@{
for (i = 1; i <= NF; i++)
usate[$i] = 1
@}
@end group
@group
# Trova il numero di parole distinte lunghe pi@`u di 10 caratteri
END @{
for (x in usate) @{
if (length(x) > 10) @{
++numero_parole_lunghe
print x
@}
@}
print numero_parole_lunghe, "parole pi@`u lunghe di 10 caratteri"
@}
@end group
@end example
@noindent
@xref{Programma utilizzo parole}
per un esempio di questo tipo pi@`u dettagliato.
@cindex vettori @subentry elementi @subentry ordine di accesso da parte dell'operatore @code{in}
@cindex elementi @subentry di vettore @subentry ordine di accesso da parte dell'operatore @code{in}
@cindex @code{in} (operatore) @subentry ordine di accesso dei vettori
@cindex operatore @subentry @code{in} @subentry ordine di accesso dei vettori
L'ordine nel quale gli elementi del vettore sono esaminati da quest'istruzione
@`e determinato dalla disposizione interna degli elementi del vettore all'interno
di @command{awk} e nell'@command{awk} standard non pu@`o essere controllato
o cambiato. Questo pu@`o portare a dei problemi se vengono aggiunti nuovi
elementi al @var{vettore} dall'istruzione eseguendo il corpo del ciclo;
non @`e prevedibile se il ciclo @code{for} li potr@`a raggiungere. Similmente,
modificare @var{variabile} all'interno del ciclo potrebbe produrre strani
risultati. @`E meglio evitare di farlo.
Di sicuro, @command{gawk} imposta la lista di elementi su cui eseguire
l'iterazione prima che inizi il ciclo, e non la cambia in corso d'opera.
Ma non tutte le versioni di @command{awk} fanno cos@`{@dotless{i}}. Si consideri questo
programma, chiamato @file{vediciclo.awk}:
@example
BEGIN @{
a["questo"] = "questo"
a["@`e"] = "@`e"
a["un"] = "un"
a["ciclo"] = "ciclo"
for (i in a) @{
j++
a[j] = j
print i
@}
@}
@end example
Ecco quel che accade quando viene eseguito con @command{gawk} (e @command{mawk}):
@example
$ @kbd{gawk -f vediciclo.awk}
@print{} questo
@print{} ciclo
@print{} un
@print{} @`e
@end example
Se si usa invece BWK @command{awk}:
@example
$ @kbd{nawk -f vediciclo.awk}
@print{} ciclo
@print{} questo
@print{} @`e
@print{} un
@print{} 1
@end example
@node Controllare visita
@subsection Visita di vettori in ordine predefinito con @command{gawk}
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SUBSECTION} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
Per default, quando un ciclo @code{for} visita un vettore, l'ordine
@`e indeterminato, il che vuol dire che l'implementazione di @command{awk}
determina l'ordine in cui il vettore viene attraversato.
Quest'ordine normalmente @`e basato sull'implementazione interna dei vettori
e varia da una versione di @command{awk} alla successiva.
@cindex vettori @subentry ordine di visita @subentry controllo dell'
@cindex controllo @subentry ordine di visita dei vettori
Spesso, tuttavia, servirebbe fare qualcosa di semplice, come
``visitare il vettore confrontando gli indici in ordine crescente,''
o ``visitare il vettore confrontando i valori in ordine decrescente.''
@command{gawk} fornisce due meccanismi che permettono di farlo.
@itemize @value{BULLET}
@item
Assegnare a @code{PROCINFO["sorted_in"]} un valore a scelta fra
alcuni valori predefiniti.
Si vedano pi@`u sotto i valori ammessi.
@item
Impostare @code{PROCINFO["sorted_in"]} al nome di una funzione definita
dall'utente, da usare per il confronto tra gli elementi di un vettore. Questa
funzionalit@`a avanzata verr@`a descritta in seguito in @ref{Ordinamento di vettori}.
@end itemize
@cindex @code{PROCINFO} (vettore) @subentry valori di @code{sorted_in}
Sono disponibili i seguenti valori speciali per @code{PROCINFO["sorted_in"]}:
@table @code
@item "@@unsorted"
Lasciare gli elementi del vettore in ordine arbitrario
(questo @`e il comportamento di default di @command{awk}).
@item "@@ind_str_asc"
Ordinare in ordine crescente di indice, confrontando tra loro gli indici
come stringhe; questo @`e l'ordinamento pi@`u normale.
(Internamente, gli indici dei vettori sono sempre stringhe, per cui con
@samp{a[2*5] = 1} l'indice @`e la stringa @code{"10"} e non il numero 10.)
@item "@@ind_num_asc"
Ordinare in ordine crescente di indice, ma nell'elaborazione gli indici vengono
trattati come numeri. Gli indici con valore non numerico verranno posizionati
come se fossero uguali a zero.
@item "@@val_type_asc"
Ordinare secondo il valore degli elementi in ordine crescente (invece che in
base agli indici). L'ordinamento @`e in base al tipo assegnato all'elemento
(@pxref{Tipi di variabile e confronti}).
Tutti i valori numerici precedono tutti i valori di tipo stringa,
che a loro volta vengono prima dei sottovettori.
(I sottovettori non sono ancora stati descritti;
@pxref{Vettori di vettori}.)
Se si sceglie di utilizzare questa funzionalit@`a per esaminare
tutti gli elementi di @code{FUNCTAB} (@pxref{Variabili auto-assegnate}),
l'ordine in cui sono presentati gli elementi @`e: dapprima le
funzioni predefinite (@pxref{Funzioni predefinite}), poi
le funzioni definite dall'utente (@pxref{Funzioni definite dall'utente})
e infine le funzioni caricate da un'estensione
(@pxref{Estensioni dinamiche}).
@item "@@val_str_asc"
Ordinare secondo il valore degli elementi in ordine crescente (invece che in
base agli indici). I valori scalari sono confrontati come stringhe.
Quando i valori delle stringhe coincidono, vengono confrontati i valori
degli indici delle stringhe.
Quando si confrontano valori di tipo non-scalare si usa il criterio di
ordinamento @code{"@@val_type_asc"} e per questo i sottovettori, se
presenti, vengono per ultimi.
@item "@@val_num_asc"
Ordinare secondo il valore degli elementi in ordine crescente (invece che in
base agli indici). I valori scalari sono confrontati come numeri.
I valori non-scalari sono confrontati usando il criterio di ordinamento
@code{"@@val_type_asc"} e per questo i sottovettori, se presenti,
vengono per ultimi.
Quando i valori numerici coincidono, vengono confrontati i valori di
tipo stringa per stabilire un ordinamento: ci@`o garantisce risultati
coerenti tra differenti versioni della funzione C
@code{qsort()},@footnote{Quando due elementi
risultano uguali, la funzione C @code{qsort()} non garantisce
che dopo l'ordinamento venga rispettato il loro ordine relativo originale.
Usando il valore di stringa per stabilire un ordinamento univoco quando i
valori numerici sono uguali assicura che il comportamento di @command{gawk}
sia coerente in differenti ambienti.} che @command{gawk} usa internamente
per effettuare l'ordinamento.
Quando i valori delle stringhe coincidono, vengono confrontati i valori
degli indici delle stringhe.
@item "@@ind_str_desc"
Ordinare come fa @code{"@@ind_str_asc"}, ma gli
indici di tipo stringa sono ordinati dal pi@`u alto al pi@`u basso.
@item "@@ind_num_desc"
Ordinare come fa @code{"@@ind_num_asc"}, ma gli
indici numerici sono ordinati dal pi@`u alto al pi@`u basso.
@item "@@val_type_desc"
Ordinare come fa @code{"@@val_type_asc"}, ma i valori
degli elementi, a seconda del tipo, sono ordinati dal pi@`u alto al pi@`u basso.
I sottovettori, se presenti, vengono per primi.
@item "@@val_str_desc"
Ordinare come fa @code{"@@val_str_asc"}, ma i valori degli
elementi, trattati come stringhe, sono ordinati dal pi@`u alto al pi@`u basso.
Quando i valori delle stringhe coincidono, vengono confrontati i valori
degli indici delle stringhe.
Quando si confrontano valori di tipo non-scalare si usa il criterio di
ordinamento @code{"@@val_type_desc"} e per questo i sottovettori, se
presenti, vengono per primi.
@item "@@val_num_desc"
Ordinare come fa @code{"@@val_num_asc"}, ma i valori degli
elementi, trattati come numeri, sono ordinati dal pi@`u alto al pi@`u basso.
Quando i valori numerici coincidono, vengono confrontati i valori di
tipo stringa. Se anche questi sono identici, veogno confrontati i valori
della stringa di indice.
I valori non-scalari sono confrontati usando il criterio di ordinamento
@code{"@@val_type_desc"} e per questo i sottovettori, se presenti,
vengono per primi.
@end table
L'ordine in cui il vettore @`e visitato viene determinato prima di iniziare
l'esecuzione del ciclo @code{for}. Cambiare @code{PROCINFO["sorted_in"]}
all'interno del corpo del ciclo non influisce sul ciclo stesso.
Per esempio:
@example
$ @kbd{gawk '}
> @kbd{BEGIN @{}
> @kbd{ a[4] = 4}
> @kbd{ a[3] = 3}
> @kbd{ for (i in a)}
> @kbd{ print i, a[i]}
> @kbd{@}'}
@print{} 4 4
@print{} 3 3
$ @kbd{gawk '}
> @kbd{BEGIN @{}
> @kbd{ PROCINFO["sorted_in"] = "@@ind_str_asc"}
> @kbd{ a[4] = 4}
> @kbd{ a[3] = 3}
> @kbd{ for (i in a)}
> @kbd{ print i, a[i]}
> @kbd{@}'}
@print{} 3 3
@print{} 4 4
@end example
Quando si ordina un vettore in base al valore dei suoi elementi, se viene
trovato un valore che @`e un sottovettore, questo @`e considerato pi@`u grande di
qualsiasi stringa o valore numerico, indipendentemente da quel che contiene
lo stesso sottovettore, e tutti i sottovettori sono trattati come se fossero
l'uno uguale all'altro. Il loro ordine reciproco @`e determinato dai loro
indici, visti come stringhe.
Di seguito sono elencati alcuni punti da tener presenti sulla visita
ordinata dei vettori:
@itemize @value{BULLET}
@item
Il valore di @code{PROCINFO["sorted_in"]} @`e globale. Cio@`e, ha effetto su tutti
i cicli @code{for} relativi a qualsiasi vettore. Se si deve cambiarlo
all'interno del proprio codice, si dovrebbe vedere se era gi@`a stato
definito in precedenza, e salvare il valore relativo, per ripristinarlo
successivamente:
@example
@dots{}
if ("sorted_in" in PROCINFO) @{
ordine_salvato = PROCINFO["sorted_in"]
PROCINFO["sorted_in"] = "@@val_str_desc" # o qualcos'altro
@}
@dots{}
if (ordine_salvato)
PROCINFO["sorted_in"] = ordine_salvato
@end example
@item
Come gi@`a accennato, l'ordine di visita di default del vettore
@`e rappresentato da @code{"@@unsorted"}. Si pu@`o ottenere il comportamento di
default anche assegnando la stringa nulla a @code{PROCINFO["sorted_in"]} o
semplicemente eliminando l'elemento @code{"sorted_in"} dal vettore
@code{PROCINFO} con l'istruzione @code{delete}.
(L'istruzione @code{delete} non @`e stata ancora descritta; @pxref{Cancellazione}.)
@end itemize
Inoltre, @command{gawk} fornisce funzioni predefinite per l'ordinamento
dei vettori; si veda @ref{Funzioni di ordinamento di vettori}.
@node Indici numerici di vettore
@section Usare numeri per indicizzare i vettori
@cindex numeri @subentry come indici di vettore
@cindex indici di vettore @subentry numeri come
@cindex vettori @subentry indici @subentry numerici
@cindex variabile @subentry @code{CONVFMT} @subentry indici di vettore e
@cindex @code{CONVFMT} (variabile) @subentry indici di vettore e
Un aspetto importante da ricordare riguardo ai vettori @`e che
@emph{gli indici dei vettori sono sempre stringhe}.
Quando un valore numerico @`e usato come indice,
viene convertito in un valore di tipo stringa prima di essere usato per
l'indicizzazione (@pxref{Conversione}).
Ci@`o vuol dire che il valore della variabile predefinita @code{CONVFMT} pu@`o
influire su come un programma ha accesso agli elementi di un vettore.
Per esempio:
@example
xyz = 12.153
dati[xyz] = 1
CONVFMT = "%2.2f"
if (xyz in dati)
printf "%s @`e in dati\n", xyz
else
printf "%s non @`e in dati\n", xyz
@end example
@noindent
Il risultato @`e @samp{12.15 non @`e in dati}. La prima istruzione d@`a a
@code{xyz} un valore numerico. L'assegnamento a @code{dati[xyz]}
indicizza @code{dati} col valore di tipo stringa @code{"12.153"}
(usando il valore di conversione di default @code{CONVFMT}, @code{"%.6g"}).
Quindi, all'elemento del vettore @code{dati["12.153"]} @`e assegnato il valore
uno. Il programma cambia poi
il valore di @code{CONVFMT}. La verifica @samp{(xyz in dati)} genera un nuovo
valore di stringa da @code{xyz} --- questa volta @code{"12.15"} --- perch@'e il
valore di @code{CONVFMT} consente solo due cifre decimali. Questa
verifica d@`a esito negativo, perch@'e @code{"12.15"} @`e diverso da @code{"12.153"}.
@cindex conversione @subentry di numeri interi che sono indici di vettore
@cindex numeri @subentry interi @subentry come indici di vettore
@cindex interi @subentry indici di vettore
Secondo le regole di conversione
(@pxref{Conversione}), i valori numerici interi
vengono convertiti in stringhe sempre come interi, indipendentemente dal
valore che potrebbe avere @code{CONVFMT}. E infatti il caso
seguente produce il risultato atteso:
@example
for (i = 1; i <= maxsub; i++)
@ii{fa qualcosa con} vettore[i]
@end example
La regola ``i valori numerici interi si convertono sempre in stringhe intere''
ha un'altra conseguenza per l'indicizzazione dei vettori.
Le costanti ottali ed esadecimali
@ifnotdocbook
(@pxref{Numeri non-decimali})
@end ifnotdocbook
@ifdocbook
(trattate in @ref{Numeri non-decimali})
@end ifdocbook
vengono convertite internamente in numeri, e la loro forma originale
non viene pi@`u ricordata. Ci@`o significa, per esempio, che
@code{vettore[17]},
@code{vettore[021]} e
@code{vettore[0x11]} fanno riferimento tutti allo stesso
elemento!
Come molte cose in @command{awk}, molto spesso le cose
funzionano come ci si aspetta. @`E utile comunque avere una
conoscenza precisa delle regole applicate, poich@'e a volte possono avere
effetti difficili da individuare sui programmi.
@node Indici non inizializzati
@section Usare variabili non inizializzate come indici
@cindex variabili @subentry non inizializzate @subentry come indici di vettore
@cindex non inizializzate @subentry variabili @subentry come indici di vettore
@cindex indici di vettore @subentry variabili non inizializzate come
@cindex vettori @subentry indici @subentry variabili non inizializzate come
Supponiamo che sia necessario scrivere un programma
per stampare i dati di input in ordine inverso.
Un tentativo ragionevole per far ci@`o (con qualche dato di
prova) potrebbe essere qualcosa di questo tipo:
@example
$ @kbd{echo 'riga 1}
> @kbd{riga 2}
> @kbd{riga 3' | awk '@{ l[righe] = $0; ++righe @}}
> @kbd{END @{}
> @kbd{for (i = righe - 1; i >= 0; i--)}
> @kbd{print l[i]}
> @kbd{@}'}
@print{} riga 3
@print{} riga 2
@end example
Sfortunatamente, la prima riga di dati in input non appare
nell'output!
A prima vista, verrebbe da dire che questo programma avrebbe dovuto
funzionare. La variabile @code{righe}
non @`e inizializzata, e le variabili non inizializzate hanno il valore numerico
zero. Cos@`{@dotless{i}}, @command{awk} dovrebbe aver stampato il valore @code{l[0]}.
Qui il problema @`e che gli indici per i vettori di @command{awk} sono
@emph{sempre} stringhe. Le variabili non inizializzate, quando sono usate come
stringhe, hanno il valore @code{""}, e non zero. Quindi, @samp{riga 1}
finisce per essere memorizzata in @code{l[""]}.
La seguente variante del programma funziona correttamente:
@example
@{ l[righe++] = $0 @}
END @{
for (i = righe - 1; i >= 0; i--)
print l[i]
@}
@end example
Qui, @samp{++} forza @code{righe} a essere di tipo numerico, rendendo
quindi il ``vecchio valore'' uno zero numerico. Questo viene poi convertito
in @code{"0"} come l'indice del vettore.
@cindex indici di vettore @subentry stringhe nulle come
@cindex nulle @subentry stringhe @subentry come indici di vettore
@cindex stringa nulla @subentry come indice di vettore
@cindex angolo buio @subentry indici di vettori
@cindex @dfn{lint} @subentry controlli @subentry indici di vettori
@cindex controllo @subentry @dfn{lint} @subentry indici di vettori
Anche se la cosa pu@`o sembrare strana, la stringa nulla
(@code{""}) @`e un indice di vettore valido.
@value{DARKCORNER}
Se viene fornita l'opzione @option{--lint} sulla riga di comando
@pxref{Opzioni}), @command{gawk} avvisa quando la stringa nulla viene usata
come indice.
@node Cancellazione
@section L'istruzione @code{delete}
@cindex @code{delete} (istruzione)
@cindex istruzione @subentry @code{delete}
@cindex eliminare @subentry elementi di vettori
@cindex vettori @subentry elementi @subentry eliminazione di
@cindex elementi @subentry di vettore @subentry eliminazione di
Per rimuovere un singolo elemento da un vettore si usa l'istruzione
@code{delete}:
@example
delete @var{vettore}[@var{espressione-indice}]
@end example
Una volta che un elemento di un vettore @`e stato eliminato, il valore che aveva
quell'elemento non @`e pi@`u disponibile. @`E come se quell'elemento non sia
mai stato referenziato oppure come se non gli sia mai stato assegnato un
valore. Il seguente @`e un esempio di eliminazione di elementi da un vettore:
@example
for (i in frequenze)
delete frequenze[i]
@end example
@noindent
Quest'esempio rimuove tutti gli elementi dal vettore @code{frequenze}. Una
volta che un elemento @`e stato eliminato, una successiva istruzione @code{for}
che visiti il vettore non trover@`a quell'elemento, e l'uso dell'operatore
@code{in} per controllare la presenza di quell'elemento restituisce zero (cio@`e
falso):
@example
delete pippo[4]
if (4 in pippo)
print "Questo non verr@`a mai stampato"
@end example
@cindex nulle @subentry stringhe @subentry eliminazione di elementi di un vettore e
@cindex stringa nulla @subentry eliminazione di elementi di un vettore e
@`E importante notare che eliminare un elemento @emph{non} @`e la stessa cosa
che assegnargli un valore nullo (la stringa vuota, @code{""}).
Per esempio:
@example
@group
pippo[4] = ""
if (4 in pippo)
print "Questa riga viene stampata, anche se pippo[4] @`e vuoto"
@end group
@end example
@cindex @dfn{lint} @subentry controlli @subentry elementi di vettori
@cindex controllo @subentry @dfn{lint} @subentry elementi di vettori
@cindex elementi @subentry di vettore @subentry controlli @dfn{lint} per
Non @`e un errore eliminare un elemento che non esiste.
Tuttavia, se viene data l'opzione @option{--lint} sulla riga di comando
(@pxref{Opzioni}),
@command{gawk} emette un messaggio di avvertimento quando viene eliminato un
elemento che non @`e presente in un vettore.
@cindex comuni @subentry estensioni @subentry @code{delete} per eliminare interi vettori
@cindex estensioni comuni @subentry @code{delete} per eliminare interi vettori
@cindex vettori @subentry eliminare l'intero contenuto
@cindex eliminare @subentry interi vettori
@cindex @code{delete} (istruzione) @subentry eliminare un elemento di un vettore
@cindex differenze tra @command{awk} e @command{gawk} @subentry elementi dei vettori @subentry eliminazione
Tutti gli elementi di un vettore possono essere eliminati con una singola
istruzione omettendo l'indice nell'istruzione @code{delete},
in questo modo:
@example
delete @var{vettore}
@end example
L'uso di questa versione dell'istruzione @code{delete} @`e circa tre volte pi@`u
efficiente dell'equivalente ciclo che elimina gli elementi uno
alla volta.
Questa forma dell'istruzione @code{delete} @`e ammessa anche
da BWK @command{awk} e da @command{mawk}, e anche da
diverse altre implementazioni.
@cindex Brian Kernighan @subentry @command{awk} di
@quotation NOTA
Per molti anni, l'uso di @code{delete} senza un indice era un'estensione
comune. A settembre 2012 si @`e deciso di includerla nello
standard POSIX. Si veda @uref{http://austingroupbugs.net/view.php?id=544,
il sito dell'Austin Group}.
@end quotation
@cindex portabilit@`a @subentry eliminazione di elementi di un vettore
@cindex Brennan, Michael
La seguente istruzione fornisce un modo portabile, anche se non evidente,
per svuotare un vettore:@footnote{Un ringraziamento a Michael
Brennan per la segnalazione.}
@example
split("", vettore)
@end example
@cindex @code{split()} (funzione) @subentry eliminazione di elementi di vettori
@cindex funzione @subentry @code{split()} @subentry eliminazione di elementi di vettori
La funzione @code{split()}
(@pxref{Funzioni per stringhe})
dapprima svuota il vettore indicato. La chiamata chiede di dividere
la stringa nulla. Poich@'e non c'@`e nulla da dividere, la
funzione si limita a svuotare il vettore e poi termina.
@quotation ATTENZIONE
L'eliminazione di tutti gli elementi di un vettore non cambia il suo tipo; non
si pu@`o svuotare un vettore e poi usare il nome del vettore come scalare
(cio@`e, come una variabile semplice). Per esempio, questo non @`e consentito:
@example
a[1] = 3
delete a
a = 3
@end example
@end quotation
@node Vettori multidimensionali
@section Vettori multidimensionali
@menu
* Visitare vettori multidimensionali:: Visitare vettori multidimensionali.
@end menu
@cindex indici di vettore @subentry multidimensionale
@cindex vettori @subentry multidimensionali
@cindex multidimensionali @subentry vettori
Un @dfn{vettore multidimensionale} @`e un vettore in cui un elemento @`e
identificato da un insieme di indici invece che da un indice singolo. Per
esempio, un vettore bidimenisonale richiede due indici. Il modo consueto (in
molti linguaggi, compreso @command{awk}) per far riferimento a un elemento di
un vettore multidimensionale chiamato @code{griglia} @`e con
@code{griglia[@var{x},@var{y}]}.
@cindex @code{SUBSEP} (variabile) @subentry vettori multidimensionali e
@cindex variabile @subentry @code{SUBSEP} @subentry vettori multidimensionali e
I vettori multidimensionali sono resi disponibili in @command{awk} attraverso
la concatenazione di pi@`u indici in una stringa;
@command{awk} converte gli indici in stringhe
(@pxref{Conversione}) e
le concatena assieme, inserendo un separatore tra ognuna di loro. Ne
risulta una sola stringa che include i valori di ogni indice. La
stringa cos@`{@dotless{i}} composta viene usata come un singolo indice in un vettore
ordinario monodimensionale. Il separatore usato @`e il valore della variabile
predefinita @code{SUBSEP}.
Per esempio, supponiamo di valutare l'espressione @samp{pippo[5,12] = "valore"}
quando il valore di @code{SUBSEP} @`e @code{"@@"}. I numeri 5 e 12 vengono
convertiti in stringhe che sono poi
concatenate con un @samp{@@} tra di essi, dando @code{"5@@12"}; di conseguenza,
l'elemento del vettore @code{pippo["5@@12"]} @`e impostato a @code{"valore"}.
Una volta che il valore dell'elemento @`e memorizzato, @command{awk}
ignora se sia stato memorizzato con un solo indice o con una
serie di indici. Le due espressioni @samp{pippo[5,12]} e
@w{@samp{pippo[5 SUBSEP 12]}} sono sempre equivalenti.
Il valore di default di @code{SUBSEP} @`e la stringa @code{"\034"},
che contiene un carattere non stampabile che difficilmente appare in
un programma di @command{awk} e nella maggior parte dei dati di input.
Il vantaggio di scegliere un carattere improbabile discende dal fatto che i
valori degli indici che contengono una stringa corrispondente a @code{SUBSEP}
possono portare a stringhe risultanti ambigue. Supponendo che
@code{SUBSEP} valga @code{"@@"}, @w{@samp{pippo["a@@b", "c"]}} e
@w{@samp{pippo["a", "b@@c"]}} risultano indistinguibili perch@'e entrambi
sarebbero in realt@`a memorizzati come @samp{pippo["a@@b@@c"]}.
@cindex @code{in} (operatore) @subentry verificare se un elemento esiste in un vettore multidimensionale
Per verificare se una determinata sequenza di indici esiste in un vettore
multidimensionale, si usa lo stesso operatore (@code{in}) che viene usato
per i vettori monodimensionali. Si scrive l'intera sequenza di indici tra
parentesi, separati da virgole, come operando di sinistra:
@example
if ((@var{indice1}, @var{indice2}, @dots{}) in @var{vettore})
@dots{}
@end example
Qui vediamo un esempio, avendo in input un vettore bidimensionale
di campi, ruota questo vettore di 90 gradi in senso orario e stampa il
risultato. Si suppone che tutte le righe in input contengano lo stesso
numero di elementi:
@example
@{
if (max_nf < NF)
max_nf = NF
max_nr = NR
for (x = 1; x <= NF; x++)
vettore[x, NR] = $x
@}
END @{
for (x = 1; x <= max_nf; x++) @{
for (y = max_nr; y >= 1; --y)
printf("%s ", vettore[x, y])
printf("\n")
@}
@}
@end example
@noindent
Dato l'input:
@example
@group
1 2 3 4 5 6
2 3 4 5 6 1
3 4 5 6 1 2
4 5 6 1 2 3
@end group
@end example
@noindent
il programma produce il seguente output:
@example
@group
4 3 2 1
5 4 3 2
6 5 4 3
1 6 5 4
2 1 6 5
3 2 1 6
@end group
@end example
@node Visitare vettori multidimensionali
@subsection Visitare vettori multidimensionali
Non c'@`e un'istruzione @code{for} particolare per visitare un
vettore ``multidimensionale''. Non ce ne pu@`o essere una, perch@'e
@command{awk} in realt@`a non ha
vettori o elementi multidimensionali: c'@`e solo una modalit@`a
multidimensionale per @emph{accedere} a un vettore.
@cindex indici di vettore @subentry multidimensionale @subentry visitare gli
@cindex vettori @subentry multidimensionali @subentry visitare
@cindex visitare @subentry vettori multidimensionali
Comunque, se un programma ha un vettore al quale si accede sempre in
modalit@`a multidimensionale, si pu@`o ottenere il risultato di visitarlo
combinando l'istruzione di visita @code{for}
(@pxref{Visitare un intero vettore}) con la funzione
interna @code{split()}
(@pxref{Funzioni per stringhe}).
Si procede nel seguente modo:
@example
for (indice_combinato in vettore) @{
split(indice_combinato, indici_separati, SUBSEP)
@dots{}
@}
@end example
@noindent
Questo imposta la variabile @code{indice_combinato} a ogni
concatenazione di indici contenuta nel vettore, e la suddivide
nei singoli indici separandoli
in corrispondenza del valore di
@code{SUBSEP}. I singoli indici diventano poi gli elementi
del vettore @code{indici_separati}.
Perci@`o, se un valore @`e stato precedentemente memorizzato in
@code{vettore[1, "pippo"]}, esiste in @code{vettore} un elemento con indice
@code{"1\034pippo"} (ricordare che il valore di default di @code{SUBSEP}
@`e il carattere con codice ottale 034).
Prima o poi, l'istruzione @code{for} trova quell'indice e fa un'iterazione
con la variabile @code{indice_combinato} impostata a @code{"1\034pippo"}.
Poi viene chiamata la funzione @code{split()} in questo modo:
@example
split("1\034pippo", indici_separati, "\034")
@end example
@noindent
Il risultato @`e quello di impostare @code{indici_separati[1]} a @code{"1"} e
@code{indici_separati[2]} a @code{"pippo"}. Ecco fatto!
La sequenza originale degli indici separati @`e ripristinata.
@node Vettori di vettori
@section Vettori di vettori
@cindex vettori @subentry di vettori
@command{gawk} migliora l'accesso ai vettori multidimensionali di
@command{awk} standard e mette a disposizione dei veri vettori di vettori.
Agli elementi di un sottovettore si fa riferimento tramite il loro indice
racchiuso tra parentesi quadre, proprio come gli elementi del vettore
principale. Per esempio, quel che segue crea un sottovettore con due elementi
all'indice @code{1} del vettore principale @code{a}:
@example
a[1][1] = 1
a[1][2] = 2
@end example
Questo simula un vero vettore bidimensionale. Ogni elemento di un sottovettore
pu@`o contenere un altro sottovettore come valore, che a sua volta pu@`o
contenere anche ulteriori vettori. In questo modo, si possono creare vettori
di tre o pi@`u dimensioni.
Gli indici possono essere costituiti da qualunque espressione di
@command{awk}, compresi dei
valori scalari separati da virgole (cio@`e, un indice multidimensionale simulato
di @command{awk}). Quindi, la seguente espressione @`e valida in
@command{gawk}:
@example
a[1][3][1, "nome"] = "barney"
@end example
Ogni sottovettore e il vettore principale possono essere di diversa lunghezza.
Di fatto, gli elementi di un vettore o un suo sottovettore non devono essere
necessariamente tutti dello stesso tipo. Ci@`o significa che il vettore
principale come anche uno qualsiasi dei suoi sottovettori pu@`o essere
non rettangolare,
o avere una struttura frastagliata. Si pu@`o assegnare un valore scalare
all'indice @code{4} del vettore principale @code{a}, anche se @code{a[1]}
@`e esso stesso un vettore e non uno scalare:
@example
a[4] = "Un elemento in un vettore frastagliato"
@end example
I termini @dfn{dimensione}, @dfn{riga} e @dfn{colonna} sono privi di
significato quando sono applicati
a questo tipo di vettore, ma d'ora in poi useremo ``dimensione'' per indicare
il numero massimo di indici necessario per far riferimento a un elemento
esistente. Il tipo di ogni elemento che @`e gi@`a stato assegnato non pu@`o essere
cambiato assegnando un valore di tipo diverso. Prima si deve eliminare
l'elemento corrente, per togliere completamente dalla memoria di
@command{gawk} ogni riferimento a quell'indice:
@example
delete a[4]
a[4][5][6][7] = "Un elemento in un vettore quadridimensionale"
@end example
@noindent
Le due istruzioni rimuovono il valore scalare dall'indice @code{4} e
inseriscono poi un
sottovettore interno a tre indici contenente uno scalare. Si pu@`o anche
eliminare un intero sottovettore o un sottovettore di sottovettori:
@example
delete a[4][5]
a[4][5] = "Un elemento nel sottovettore a[4]"
@end example
Si deve per@`o ricordare che non @`e consentito eliminare il vettore principale
@code{a} e poi usarlo come scalare.
Le funzioni predefinite che accettano come argomenti dei vettori possono
essere usate
anche con i sottovettori. Per esempio, il seguente frammento di codice usa
@code{length()} (@pxref{Funzioni per stringhe})
per determinare il numero di elementi nel vettore principale @code{a}
e nei suoi sottovettori:
@example
print length(a), length(a[1]), length(a[1][3])
@end example
@noindent
Il risultato per il nostro vettore principale @code{a} @`e il seguente:
@example
2, 3, 1
@end example
@noindent
L'espressione @samp{@var{indice} in @var{vettore}}
(@pxref{Visitare elementi}) funziona allo stesso modo sia per
i vettori regolari in stile @command{awk}
che per i vettori di vettori. Per esempio, le espressioni @samp{1 in a},
@samp{3 in a[1]} e @samp{(1, "nome") in a[1][3]} risultano tutte di valore
uno (vero) per il nostro vettore @code{a}.
L'istruzione @samp{for (elemento in vettore)} (@pxref{Visitare un intero vettore})
pu@`o essere nidificata per visitare tutti gli
elementi di un vettore di vettori che abbia una struttura rettangolare. Per
stampare il contenuto (valori scalari) di un vettore di vettori bidimensionale
(cio@`e nel quale ogni elemento di primo livello @`e esso stesso un
vettore, non necessariamente di lunghezza uguale agli altri)
si pu@`o usare il seguente codice:
@example
for (i in vettore)
for (j in vettore[i])
print vettore[i][j]
@end example
La funzione @code{isarray()} (@pxref{Funzioni per i tipi})
permette di verificare se un elemento di un vettore @`e esso stesso un vettore:
@example
for (i in vettore) @{
if (isarray(vettore[i])) @{
for (j in vettore[i]) @{
print vettore[i][j]
@}
@}
else
print vettore[i]
@}
@end example
Se la struttura di un vettore di vettori frastagliato @`e nota in anticipo,
si pu@`o spesso trovare il modo per visitarlo usando istruzioni di controllo.
Per esempio,
il seguente codice stampa gli elementi del nostro vettore principale @code{a}:
@example
@group
for (i in a) @{
for (j in a[i]) @{
if (j == 3) @{
for (k in a[i][j])
print a[i][j][k]
@end group
@group
@} else
print a[i][j]
@}
@}
@end group
@end example
@noindent
@xref{Visitare vettori} per una funzione definita dall'utente che
``visita'' un vettore di vettori di dimensioni arbitrarie.
Si ricordi che un riferimento a un elemento di un vettore non
inizializzato genera un elemento con valore uguale a @code{""}, la stringa
nulla. Questo ha
un'importante implicazione quando s'intende usare un sottovettore come
argomento di una funzione, come illustrato nel seguente esempio:
@example
$ @kbd{gawk 'BEGIN @{ split("a b c d", b[1]); print b[1][1] @}'}
@error{} gawk: riga com.:1: fatale: split: secondo argomento
@error{} non-vettoriale
@end example
Il modo per aggirare quest'ostacolo @`e quello di definire prima @code{b[1]}
come vettore creando un indice arbitrario:
@example
$ @kbd{gawk 'BEGIN @{ b[1][1] = ""; split("a b c d", b[1]); print b[1][1] @}'}
@print{} a
@end example
@node Sommario dei vettori
@section Sommario
@itemize @value{BULLET}
@item
@command{awk} standard dispone di vettori associativi monodimensionali
(vettori indicizzati da valori di tipo stringa). Tutti i vettori sono
associativi; gli indici numerici vengono convertiti automaticamente in
stringhe.
@item
Agli elementi dei vettori si fa riferimento come
@code{@var{vettore}[@var{indice}]}. Fare riferimento a un elemento lo
crea se questo non esiste ancora.
@item
Il modo corretto per vedere se un vettore ha un elemento con un dato indice
@`e quello di usare l'operatore @code{in}: @samp{@var{indice} in @var{vettore}}.
@item
Si usa @samp{for (@var{indice} in @var{vettore}) @dots{}} per visitare
ogni singolo elemento di un vettore. Nel corpo del ciclo,
@var{indice} assume via via il valore dell'indice di ogni elemento del vettore.
@item
L'ordine in cui il ciclo @samp{for (@var{indice} in @var{vettore})}
attraversa un vettore non @`e definito in POSIX @command{awk} e varia a seconda
dell'implementazione. @command{gawk} consente di controllare l'ordinamento
di visita
assegnando speciali valori predefiniti a @code{PROCINFO["sorted_in"]}.
@item
Si usa @samp{delete @var{vettore}[@var{indice}]} per eliminare un singolo
elemento di un vettore.
Per eliminare tutti gli elementi di un vettore,
si usa @samp{delete @var{vettore}}.
Quest'ultima funzionalit@`a @`e stata per molti anni un'estensione comune
e ora @`e standard, ma potrebbe non essere disponibile in tutte le
versioni commerciali di @command{awk}.
@item
@command{awk} standard simula vettori multidimensionali ammettendo pi@`u indici
separati da virgole. I loro valori sono concatenati in un'unica
stringa, separati dal valore di @code{SUBSEP}. Il modo di creazione
dell'indice non viene immagazzinato; cos@`{@dotless{i}},
cambiare @code{SUBSEP} potrebbe avere conseguenze inaspettate. Si pu@`o usare
@samp{(@var{sub1}, @var{sub2}, @dots{}) in @var{vettore}} per vedere se
un certo indice multidimensionale esiste in @var{vettore}.
@item
@command{gawk} consente di avere a disposizione veri vettori di vettori.
Si usa una coppia
di parentesi quadre per ogni dimensione in tali vettori:
@code{dati[riga][colonna]}, per esempio. Gli elementi del vettore possono
poi essere valori scalari (numeri o stringhe) o altri vettori.
@item
Si usa la funzione predefinita @code{isarray()} per determinare se un elemento
di un vettore @`e esso stesso un sottovettore.
@end itemize
@node Funzioni
@chapter Funzioni
@cindex funzione @subentry predefinita
@cindex predefinita @subentry funzione
Questo @value{CHAPTER} descrive le funzioni predefinite di @command{awk},
che sono di tre tipi: numeriche, di stringa, e di I/O.
@command{gawk} mette a disposizione ulteriori tipi di funzioni
per gestire valori che rappresentano marcature temporali, per manipolare bit, per
ordinare vettori, per fornire informazioni sui tipi di variabile,
per internazionalizzare e localizzare i programmi.@footnote{Per
un'introduzione alle tematiche suddette, si pu@`o consultare l'articolo
"Localizzazione dei programmi" nel
@uref{http://www.pluto.it/files/journal/pj0404/l10n.html, sito pluto.it.}}
Oltre alle funzioni predefinite, @command{awk} consente di
scrivere nuove funzioni utilizzabili all'interno di un programma.
La seconda met@`a di questo @value{CHAPTER} descrive le funzioni
@dfn{definite dall'utente}.
Vengono infine descritte le chiamate indirette a una funzione, un'estensione
specifica di @command{gawk} che consente di stabilire durante l'esecuzione del
programma quale funzione chiamare.
@menu
* Funzioni predefinite:: Riepilogo delle funzioni predefinite.
* Funzioni definite dall'utente:: Descrizione dettagliata delle funzioni
definite dall'utente.
* Chiamate indirette:: Scegliere la funzione da chiamare in
fase di esecuzione del programma.
* Sommario delle funzioni:: Sommario delle funzioni.
@end menu
@node Funzioni predefinite
@section Funzioni predefinite
Le funzioni @dfn{predefinite} sono sempre disponibili per essere chiamate
da un programma @command{awk}. Questa @value{SECTION} definisce tutte le
funzioni predefinite di @command{awk}; di alcune di queste si fa menzione
in altre @value{SECTIONS},
ma sono comunque riassunte anche qui per comodit@`a.
@menu
* Chiamare funzioni predefinite:: Come chiamare funzioni predefinite.
* Funzioni numeriche:: Funzioni che trattano numeri, comprese
@code{int()}, @code{sin()} e @code{rand()}.
* Funzioni per stringhe:: Funzioni di manipolazione di stringhe,
come @code{split()}, @code{match()}
e @code{sprintf()}.
* Funzioni di I/O:: Funzioni per i file e per i comandi
della shell.
* Funzioni di tempo:: Funzione per gestire marcature temporali.
* Funzioni a livello di bit:: Funzioni per operazioni di
manipolazione bit.
* Funzioni per i tipi:: Funzioni per informazioni sul tipo
di una variabile.
* Funzioni di internazionalizzazione:: Funzioni per tradurre stringhe.
@end menu
@node Chiamare funzioni predefinite
@subsection Chiamare funzioni predefinite
Per chiamare una delle funzioni predefinite di @command{awk},
si scrive il nome della funzione seguito dai suoi argomenti racchiusi
tra parentesi. Per esempio, @samp{atan2(y + z, 1)}
@`e una chiamata alla funzione @code{atan2()} e ha due argomenti.
@cindex convenzioni di programmazione @subentry nelle chiamate di funzione
@cindex spazio bianco @subentry nelle chiamate di funzione
La presenza di spazi bianchi tra il nome della funzione predefinita
e la parentesi aperta @`e consentita, ma @`e buona norma quella di evitare
di inserire spazi bianchi in quella posizione.
Le funzioni definite dall'utente non consentono che vi siano spazi bianchi
fra nome funzione e aperta parentesi,
ed @`e pi@`u semplice evitare errori seguendo una semplice convenzione che
resta sempre valida: non inserire spazi dopo il nome di una funzione.
@cindex risoluzione di problemi @subentry @command{gawk} @subentry errori fatali, argomenti di funzione e
@cindex problemi @subentry risoluzione di @subentry @command{gawk}, errori fatali, argomenti di funzione e
@cindex @command{gawk} @subentry argomenti di funzione e
@cindex differenze tra @command{awk} e @command{gawk} @subentry argomenti di funzione (@command{gawk})
Ogni funzione predefinita accetta un certo numero di argomenti.
In alcuni casi, gli argomenti possono essere omessi. I valori di default per
gli argomenti omessi variano
da funzione a funzione e sono descritti insieme a
ciascuna funzione. In alcune implementazioni di @command{awk}, gli
eventuali argomenti in pi@`u specificati per le funzioni predefinite sono
ignorati. Tuttavia, in @command{gawk},
@`e un errore fatale fornire argomenti in pi@`u a una funzione predefinita.
Quando si richiama una funzione viene calcolato, prima di effettuare la
chiamata, il valore assunto dalle espressioni che descrivono i parametri
da passare alla funzione.
Per esempio, nel seguente frammento di codice:
@example
i = 4
j = sqrt(i++)
@end example
@cindex ordine di valutazione @subentry funzioni
@cindex funzioni @subentry predefinite @subentry ordine di valutazione
@cindex predefinita @subentry funzione @subentry ordine di valutazione
@noindent
la variabile @code{i} @`e incrementata al valore cinque prima di chiamare
la funzione @code{sqrt()} alla quale viene fornito come parametro il valore
quattro.
L'ordine di valutazione delle espressioni usate come parametri per la
funzione @`e indefinito. Per questo motivo, si deve evitare di scrivere
programmi che presuppongono che i parametri siano valutati da sinistra a
destra o da destra a sinistra. Per esempio:
@example
i = 5
j = atan2(++i, i *= 2)
@end example
Se l'ordine di valutazione @`e da sinistra a destra, @code{i} assume dapprima
il valore 6, e quindi il valore 12, e la funzione @code{atan2()} @`e chiamata
con i due argomenti 6 e 12. Ma se l'ordine di valutazione @`e da destra a
sinistra, @code{i} assume dapprima il valore 10, e poi il valore 11, e la
funzione @code{atan2()} @`e chiamata con i due argomenti 11 e 10.
@node Funzioni numeriche
@subsection Funzioni numeriche
@cindex funzioni @subentry numeriche
@cindex numeriche @subentry funzioni
La seguente lista descrive tutte le
funzioni predefinite che hanno a che fare con i numeri.
I parametri opzionali sono racchiusi tra parentesi quadre@w{ ([ ]):}
@c @asis for docbook
@table @asis
@item @code{atan2(@var{y}, @var{x})}
@cindexawkfunc{atan2}
@cindex arcotangente
Restituisce l'arcotangente di @code{@var{y} / @var{x}} in radianti.
Si pu@`o usare @samp{pi = atan2(0, -1)} per ottenere il valore di
@value{PI} greco.
@item @code{cos(@var{x})}
@cindexawkfunc{cos}
@cindex coseno
Restituisce il coseno di @var{x}, con @var{x} in radianti.
@item @code{exp(@var{x})}
@cindexawkfunc{exp}
@cindex esponenziale
Restituisce l'esponenziale di @var{x} (@code{e ^ @var{x}}) o un messaggio
di errore se @var{x} @`e fuori dall'intervallo consentito.
L'intervallo entro il quale pu@`o variare @var{x}
dipende dalla rappresentazione dei numeri in virgola mobile nella macchina in
uso.
@item @code{int(@var{x})}
@cindexawkfunc{int}
@cindex arrotondare @subentry all'intero pi@`u vicino
Restituisce l'intero pi@`u vicino a @var{x}, situato tra @var{x} e zero,
troncato togliendo i decimali.
Per esempio, @code{int(3)} @`e 3, @code{int(3.9)} @`e 3, @code{int(-3.9)}
@`e @minus{}3, e @code{int(-3)} @`e ancora @minus{}3.
@ifset INTDIV
@item @code{intdiv0(@var{numeratore}, @var{denominatore}, @var{risultato})}
@cindexawkfunc{intdiv0}
@cindex funzione @subentry @code{intdiv0}
Esegue una divisione tra numeri interi, simile alla funzione standard C
@code{div}. Dapprima, il @code{numeratore} e il
@code{denominatore} vengono troncati, eliminando la parte decimale,
per trasformarli in numeri interi.
Il vettore @code{risultato} viene dapprima svuotato, e poi viene impostato
l'elemento @code{risultato["quotient"]} al risultato della divisione
@samp{numeratore / denominatore}, troncato a numero intero
mediante l'eliminazione dei decimali,
e viene impostato l'elemento @code{risultato["remainder"]} al
risultato dell'operazione @samp{numeratore % denominatore}, troncato a
numero intero allo stesso modo del risultato.
Il tentativo di effettuare una divisione per zero provoca la fine del
programma. Questa funzione @`e
rivolta principalmente a chi usa numeri interi di lunghezza arbitraria;
consente di evitare la creazione di numeri in virgola mobile
di precisione arbitaria usando la funzionalit@`a MPFR
(@pxref{Interi a precisione arbitraria}).
Questa funzione @`e un'estensione @code{gawk}. Non @`e disponibile in
modalit@`a compatibile (@pxref{Opzioni}).
@end ifset
@item @code{log(@var{x})}
@cindexawkfunc{log}
@cindex logaritmo
Restituisce il logaritmo naturale di @var{x}, se @var{x} @`e positivo;
altrimenti, restituisce @code{NaN} (``not a number'') sui sistemi che
implementano lo standard IEEE 754.
Inoltre, @command{gawk} stampa un messaggio di avvertimento qualora @code{x}
sia negativo.
@cindex Beebe, Nelson H.F.@:
@item @code{rand()}
@cindexawkfunc{rand}
@cindex numeri @subentry casuali @subentry funzioni @code{rand()}/@code{srand()}
Restituisce un numero casuale. I valori di @code{rand()} sono
uniformemente distribuiti tra zero e uno.
Il valore potrebbe essere zero ma non @`e mai uno.@footnote{La versione C di
@code{rand()} in molti sistemi Unix genera notoriamente delle sequenze
piuttosto mediocri di numeri casuali. Tuttavia, non @`e scritto da nessuna
parte che un'implementazione di @command{awk} debba necessariamente
usare la funzione @code{rand()} del linguaggio C per implementare
la versione @command{awk} di @code{rand()}. In effetti, @command{gawk}
ha usato per parecchi anni la funzione @code{random()} di BSD, che @`e
notevolmente migliore di @code{rand()}, per generare dei numeri casuali.
Dalla @value{PVERSION} 4.1.4, grazie al contributo di Nelson H.F.@:
Beebe, @command{gawk} usa l'algoritmo di rimescolamento nella scatola
di Bayes-Durham, che estende in maniera notevole il periodo dopo il
quale i numeri si ripetono ed elimina le correlazioni a breve distanza
e a lunga distanza che potrebbero esistere nel generatore originale
di numeri casuali.}
Spesso servono dei numeri casuali interi invece che frazionari.
La seguente funzione definita dall'utente pu@`o essere usata per ottenere
un numero casuale non negativo inferiore a @var{n}:
@example
function randint(n)
@{
return int(n * rand())
@}
@end example
@noindent
La moltiplicazione produce un numero casuale maggiore o uguale a zero e
minore di @code{n}. Tramite @code{int()}, questo risultato diventa
un intero tra zero e @code{n} @minus{} 1, estremi inclusi.
Il seguente esempio usa una funzione simile per generate interi casuali
fra uno e @var{n}. Il programma stampa un numero casuale per
ogni record in input:
@example
# funzione per simulare un tiro di dado.
function roll(n) @{ return 1 + int(rand() * n) @}
# Tira 3 dadi a sei facce e
# stampa il numero di punti.
@{
printf("%d punteggio\n", roll(6) + roll(6) + roll(6))
@}
@end example
@cindex inizializzazione @subentry della generazione di numeri casuali
@cindex numeri @subentry casuali @subentry inizializzazione della generazione di
@cindex numeri @subentry casuali @subentry seme di
@quotation ATTENZIONE
Nella maggior parte delle implementazioni di @command{awk}, compreso
@command{gawk},
@code{rand()} inizia a generare numeri casuali partendo sempre
dallo stesso numero, o @dfn{seme}, per ogni invocazione di
@command{awk}.@footnote{@command{mawk}
usa un seme differente ogni volta.} @`E per questo motivo che
un programma genera sempre gli stessi risultati ogni volta che lo si esegue.
I numeri sono casuali all'interno di una singola esecuzione di @command{awk}
ma "prevedibili" in ogni successiva esecuzione.
Ci@`o torna utile in fase di test, ma se si desidera che
un programma generi sequenze differenti di numeri casuali ogni volta
che @`e chiamato, occorre impostare il seme a un valore che cambi
per ogni esecuzione. Per fare questo, @`e prevista la funzione @code{srand()}.
@end quotation
@item @code{sin(@var{x})}
@cindexawkfunc{sin}
@cindex seno
Restituisce il seno di @var{x}, con @var{x} espresso in radianti.
@item @code{sqrt(@var{x})}
@cindexawkfunc{sqrt}
@cindex radice quadrata
Restituisce la radice quadrata positiva di @var{x}.
@command{gawk} stampa un messaggio di avvertimento
se @var{x} @`e un numero negativo. Quindi, @code{sqrt(4)} vale 2.
@item @code{srand(}[@var{x}]@code{)}
@cindexawkfunc{srand}
Imposta al valore @var{x} il numero di partenza, o seme,
utilizzato per generare numeri casuali.
Ogni seme genera una sequenza particolare di numeri casuali.@footnote{I
numeri casuali generati da un computer non sono veramente casuali.
Tecnicamente sono conosciuti come numeri @dfn{pseudo-casuali}. Ci@`o vuol dire
che, anche se i numeri in una sequenza sembrano casuali, @`e possibile
in realt@`a generare la stessa sequenza di numeri casuali pi@`u e pi@`u volte.}
Quindi, impostando il seme allo stesso valore una seconda volta,
viene prodotta ancora la stessa sequenza di numeri casuali.
@quotation ATTENZIONE
Differenti implementazioni di @command{awk} usano internamente differenti
generatori di numeri casuali. Non si deve dare per scontato che lo stesso
programma @command{awk}
generi la stessa serie di numeri casuali se viene eseguito da differenti
versioni di @command{awk}.
@end quotation
Se si omette l'argomento @var{x}, scrivendo @samp{srand()}, viene usato
come seme la data e ora corrente. @`E questo il modo per ottenere numeri
casuali che sono veramente imprevedibili.
Il valore restituito da @code{srand()} @`e quello del seme precedente.
Questo per facilitare il monitoraggio dei semi, nel caso occorra riprodurre
in maniera coerente delle sequenze di numeri casuali.
POSIX non specifica quale debba essere il seme iniziale, che quindi varia
a seconda delle implementazioni @command{awk}.
@end table
@node Funzioni per stringhe
@subsection Funzioni di manipolazione di stringhe
@cindex funzioni @subentry di manipolazione di stringhe
Le funzioni in questa @value{SECTION} leggono o modificano il testo di
una o pi@`u stringhe.
@command{gawk} implementa la localizzazione
(@pxref{Localizzazioni}) ed effettua
ogni manipolazione di stringhe trattando ogni singolo @emph{carattere}, non
ogni singolo @emph{byte}.
Questa distinzione @`e particolarmente importante da comprendere per
quelle localizzazioni in cui un singolo carattere pu@`o essere rappresentato
da pi@`u di un byte.
Quindi, per esempio, la funzione @code{length()} restituisce il numero di
caratteri in una stringa, e non il numero di byte usato per rappresentare quei
caratteri. Allo stesso modo, @code{index()} restituisce indici di caratteri, e
non indici di byte.
@quotation ATTENZIONE
Un certo numero di funzioni riguarda indici all'interno di stringhe. Per
queste funzioni, il primo carattere di una stringa @`e alla posizione
(all'indice) uno. Questo comportamento @`e differente da quello del C e dei
linguaggi che da esso discendono, nei quali il primo carattere @`e alla posizione
zero. @`E importante ricordarlo quando si fanno calcoli sugli indici, in
particolare se si ha familiarit@`a con il linguaggio C.
@end quotation
Nella lista seguente, i parametri opzionali sono racchiusi tra parentesi
quadre@w{ ([ ]).}
Parecchie funzioni operano sostituzioni in una stringa; la spiegazione
completa di ci@`o @`e contenuta nella descrizione della funzione @code{sub()},
che si trova quasi alla fine di questa lista, ordinata alfabeticamente.
Le funzioni specifiche di @command{gawk} sono contrassegnate col simbolo
del cancelletto (@samp{#}). Tali funzioni non sono disponibili in modalit@`a
compatibile (@pxref{Opzioni}):
@menu
* Dettagli ostici:: Pi@`u di quel che si vorrebbe sapere su @samp{\}
e @samp{&} con @code{sub()}, @code{gsub()}, e
@code{gensub()}.
@end menu
@c @asis for docbook
@table @asis
@item @code{asort(}@var{sorgente} [@code{,} @var{destinazione} [@code{,} @var{come} ] ]@code{) #}
@itemx @code{asorti(}@var{sorgente} [@code{,} @var{destinazione} [@code{,} @var{come} ] ]@code{) #}
@cindexgawkfunc{asorti}
@cindex vettori @subentry ordinamento
@cindex ordinamento @subentry di vettori
@cindex vettori @subentry determinare il numero degli elementi
@cindexgawkfunc{asort}
@cindex ordinamento @subentry di vettori @subentry in base agli indici
@cindex vettori @subentry ordinamento @subentry in base agli indici
@cindex indici di vettore @subentry ordinamento in base agli
Queste due funzioni sono abbastanza simili, e quindi sono descritte
insieme.
@quotation NOTA
La seguente descrizione ignora il terzo argomento, @var{come}, perch@'e
richiede la conoscenza di funzionalit@`a di cui non si @`e ancora parlato. Per
questo motivo la seguente trattazione @`e volutamente semplificata. (In seguito
l'argomento verr@`a trattato in maniera pi@`u esauriente; si veda @ref{Funzioni di
ordinamento di vettori} per la descrizione completa.)
@end quotation
Entrambe le funzioni restituiscono il numero di elementi nel vettore @var{sorgente}.
Con @command{asort()}, @command{gawk} ordina i valori di @var{sorgente}
e rimpiazza gli indici dei valori ordinati di @var{sorgente} con
numeri interi sequenziali, a partire da uno. Se si specifica il vettore
opzionale @var{destinazione},
@var{sorgente} @`e copiato in @var{destinazione}. @var{destinazione}
viene quindi ordinato, lasciando immodificati gli indici di @var{sorgente}.
@cindex @command{gawk} @subentry variabile @subentry @code{IGNORECASE} in
Nel confronto tra stringhe, la variabile @code{IGNORECASE} influenza
l'ordinamento
(@pxref{Funzioni di ordinamento di vettori}). Se il vettore
@var{sorgente} contiene sottovettori come valori
(@pxref{Vettori di vettori}), questi saranno alla fine, dopo tutti i valori
scalari.
I sottovettori @emph{non} vengono ordinati ricorsivamente.
Per esempio, se i contenuti del vettore @code{a} sono i seguenti:
@example
a["ultimo"] = "de"
a["primo"] = "sac"
a["mediano"] = "cul"
@end example
@noindent
Una chiamata a @code{asort()}:
@example
asort(a)
@end example
@noindent
genera i seguenti contenuti di @code{a}:
@example
@group
a[1] = "cul"
a[2] = "de"
a[3] = "sac"
@end group
@end example
La funzione @code{asorti()} si comporta in maniera simile ad @code{asort()};
tuttavia l'ordinamento avviene in base agli @emph{indici}, e non in base ai
valori. Quindi, nell'esempio seguente, a partire dallo stesso insieme iniziale
di indici e valori nel vettore @code{a}, la chiamata di @samp{asorti(a)}
produrrebbe:
@example
a[1] = "mediano"
a[2] = "primo"
a[3] = "ultimo"
@end example
@quotation NOTA
Non si pu@`o usare n@'e @code{SYMTAB} n@'e @code{FUNCTAB} come secondo
argomento di queste funzioni. Se si tenta di farlo, viene generato un
errore fatale.
Questi vettori possono essere usati come primo argomento, ma soltanto
se si specifica un secondo vettore da usare per contenere il risultato
dell'ordinamento.
@end quotation
@item @code{gensub(@var{regexp}, @var{rimpiazzo}, @var{come}} [@code{, @var{obiettivo}}]@code{) #}
@cindexgawkfunc{gensub}
@cindex cercare e rimpiazzare in stringhe
@cindex sostituzione in stringa
Ricerca nella stringa @var{obiettivo} delle corrispondenze
all'espressione regolare @var{regexp}.
Se @var{come} @`e una stringa che inizia
con @samp{g} o @samp{G} (abbreviazione di ``global''), sostituisce
ogni occorrenza di @var{regexp} con la stringa
@var{rimpiazzo}. Altrimenti, @var{come} @`e visto come un numero che indica
quale corrispondenza di @var{regexp} va rimpiazzata. Valori numerici
inferiori a uno vengono gestiti come se avessero il valore uno.
Se non si specifica il nome dell'@var{obiettivo}, si
opera su @code{$0}. La funzione restituisce come risultato la stringa
modificata, e la stringa originale di partenza @emph{non} viene modificata.
@code{gensub()} @`e una funzione generale di sostituzione. Mira a fornire
pi@`u funzionalit@`a rispetto alle funzioni standard @code{sub()} e
@code{gsub()}.
@code{gensub()} prevede una funzionalit@`a ulteriore, non disponibile in
@code{sub()} o @code{gsub()}: la possibilit@`a di specificare componenti di
una @dfn{regexp} nel testo da sostituire. Questo @`e fatto utilizzando delle
parentesi nella @dfn{regexp} per designare i componenti, e quindi inserendo
@samp{\@var{N}} nel testo di rimpiazzo, dove @var{N} @`e una cifra da 1 a 9.
Per esempio:
@example
$ @kbd{gawk '}
> @kbd{BEGIN @{}
> @kbd{a = "abc def"}
> @kbd{b = gensub(/(.+) (.+)/, "\\2 \\1", "g", a)}
> @kbd{print b}
> @kbd{@}'}
@print{} def abc
@end example
@noindent
Come con @code{sub()}, occorre battere due barre inverse, per ottenerne
una come componente della stringa.
Nel testo di rimpiazzo, la sequenza @samp{\0} rappresenta l'intero testo
corrispondente, e lo stesso vale per
il carattere @samp{&}.
Il seguente esempio mostra come @`e possibile usare il terzo argomento
per controllare quale corrispondenza
della @dfn{regexp} sia da modificare:
@example
$ @kbd{echo a b c a b c |}
> @kbd{gawk '@{ print gensub(/a/, "AA", 2) @}'}
@print{} a b c AA b c
@end example
In questo caso, @code{$0} @`e la stringa obiettivo di default.
@code{gensub()} restituisce la nuova stringa come risultato, e questa
@`e passata direttamente a @code{print} per essere stampata.
@c @cindex automatic warnings
@c @cindex warnings, automatic
Se l'argomento @var{come} @`e una stringa che non inizia con @samp{g} o
@samp{G}, o se @`e un numero minore o uguale a zero, si effettua solo una
sostituzione. Se @var{come} @`e zero, @command{gawk} emette
un messaggio di avvertimento.
Se @var{regexp} non viene trovata in @var{obiettivo}, il valore
restituito da @code{gensub()}
@`e il valore originale e non modificato di @var{obiettivo}.
@item @code{gsub(@var{regexp}, @var{rimpiazzo}} [@code{, @var{obiettivo}}]@code{)}
@cindexawkfunc{gsub}
Ricerca in @var{obiettivo}
@emph{tutte} le sottostringhe corrispondenti al criterio di ricerca, le
pi@`u lunghe possibili partendo da sinistra, @emph{non sovrapposte tra loro},
e le sostituisce con @var{rimpiazzo}.
La lettera @samp{g} in @code{gsub()} significa
``global'', e richiede di sostituire dappertutto. Per esempio:
@example
@{ gsub(/Inghilterra/, "Regno Unito"); print @}
@end example
@noindent
sostituisce tutte le occorrenze della stringa @samp{Inghilterra} con
@samp{Regno Unito} in tutti i record in input.
La funzione @code{gsub()} restituisce il numero di sostituzioni effettuate.
Se la variabile da cercare e modificare (@var{obiettivo}) @`e omessa,
viene usato l'intero record in input.
Come in @code{sub()}, i caratteri @samp{&} e @samp{\} sono speciali,
e il terzo argomento dev'essere modificabile.
@item @code{index(@var{dove}, @var{cosa})}
@cindexawkfunc{index}
@cindex ricerca @subentry in stringhe
@cindex trovare @subentry sottostringhe in una stringa
Ricerca nella stringa @var{dove} la prima occorrenza della stringa @var{cosa},
e restituisce la posizione in caratteri dell'inizio di quest'occorrenza nella
stringa @var{dove}. Si consideri il seguente esempio:
@example
$ @kbd{awk 'BEGIN @{ print index("noccioline", "oli") @}'}
@print{} 6
@end example
@noindent
Se @var{cosa} non viene trovato, @code{index()} restituisce zero.
@cindex angolo buio @subentry @dfn{regexp} come secondo argomento di @code{index()}
In BWK @command{awk} e @command{gawk},
@`e un errore fatale usare una costante @dfn{regexp} per @var{cosa}.
Altre implementazioni lo consentono, considerando semplicemente
la costante @dfn{regexp} come un'espressione che significa
@samp{$0 ~ /@dfn{regexp}/}. @value{DARKCORNER}
@item @code{length(}[@var{stringa}]@code{)}
@cindexawkfunc{length}
@cindex stringa @subentry lunghezza di una
@cindex lunghezza @subentry di una stringa
Restituisce il numero di caratteri in @var{stringa}. Se
@var{stringa} @`e un numero, viene restituita la lunghezza della stringa
di cifre che rappresenta quel numero. Per esempio, @code{length("abcde")} @`e
cinque.
Invece, @code{length(15 * 35)} restituisce tre. In questo esempio,
@iftex
@math{15 @cdot 35 = 525},
@end iftex
@ifnottex
@ifnotdocbook
15 * 35 = 525,
@end ifnotdocbook
@end ifnottex
@docbook
15 ⋅ 35 = 525,
@end docbook
e 525 @`e quindi convertito alla stringa @code{"525"}, che @`e composta da
tre caratteri.
@cindex lunghezza @subentry di un record in input
@cindex record @subentry in input, lunghezza di un
Se non si specifica alcun argomento, @code{length()} restituisce la
lunghezza di @code{$0}.
@c @cindex historical features
@cindex portabilit@`a @subentry funzione @code{length()}
@cindex POSIX @command{awk} @subentry @code{length()} (funzione)
@quotation NOTA
In alcune delle prime versioni di @command{awk}, la funzione @code{length()}
poteva essere richiamata senza alcuna parentesi. Farlo @`e considerata
una cattiva abitudine, sebbene il POSIX standard 2008 lo consenta esplicitamente,
per compatibilit@`a con la vecchia prassi. Per garantire la massima
portabilit@`a ai programmi, @`e meglio mettere sempre le parentesi.
@end quotation
@cindex angolo buio @subentry funzione @subentry @code{length()}
Se @code{length()} @`e chiamata con una variabile che non @`e stata usata,
@command{gawk} considera la variabile come uno scalare. Altre
implementazioni di @command{awk} non assegnano nessun tipo alla variabile.
@value{DARKCORNER}
Si consideri:
@example
$ @kbd{gawk 'BEGIN @{ print length(x) ; x[1] = 1 @}'}
@print{} 0
@error{} gawk: riga com.:1: fatale: tentativo di usare
@error{} scalare 'x' come vettore
$ @kbd{nawk 'BEGIN @{ print length(x) ; x[1] = 1 @}'}
@print{} 0
@end example
@noindent
Se @option{--lint} @`e
stato specificato sulla riga di comando, @command{gawk} emette un
avvertimento a questo riguardo.
@cindex estensioni comuni @subentry @code{length()} applicato a un vettore
@cindex comuni @subentry estensioni @subentry @code{length()} applicato a un vettore
@cindex differenze tra @command{awk} e @command{gawk} @subentry funzione @code{length()}
@cindex numero @subentry di elementi in un vettore
@cindex vettori @subentry determinare il numero degli elementi
In @command{gawk} e in parecchie altre implementazioni @command{awk},
se l'argomento @`e un vettore, la funzione @code{length()} restituisce il numero
di elementi nel vettore. @value{COMMONEXT}
Ci@`o @`e meno utile di quel che sembra a prima vista, in quanto
non @`e affatto detto che il vettore abbia come indici i numeri da 1 al
numero di elementi che contiene.
Se @option{--lint} @`e
stato specificato sulla riga di comando,
(@pxref{Opzioni}),
@command{gawk} avvisa che l'uso di un vettore come argomento non
@`e portabile.
Se si specifica l'opzione @option{--posix}, l'uso di un vettore come
argomento genera un errore fatale
@iftex
(@pxrefil{Vettori}).
@end iftex
@ifnottex
(@pxref{Vettori}).
@end ifnottex
@item @code{match(@var{stringa}, @var{regexp}} [@code{, @var{vettore}}]@code{)}
@cindexawkfunc{match}
@cindex stringa @subentry ricercare espressioni regolari in una
@cindex ricerca @subentry @dfn{regexp} in stringhe
Ricerca in @var{stringa} la
sottostringa pi@`u lunga, a partire da sinistra, che corrisponde
all'espressione regolare @var{regexp} e restituisce la posizione
del carattere (indice) con cui inizia la sottostringa (uno, se
la corrispondenza parte dall'inizio di @var{stringa}). Se non viene
trovata alcuna corrispondenza, restituisce zero.
L'argomento @var{regexp} pu@`o essere sia una costante @dfn{regexp}
(@code{/}@dots{}@code{/}) che una costante stringa (@code{"}@dots{}@code{"}).
In quest'ultimo caso, la stringa @`e trattata come una @dfn{regexp}
per la quale cercare una corrispondenza.
@xref{Espressioni regolari calcolate} per una
spiegazione sulla differenza tra le due forme e sulle loro
implicazioni riguardo al modo per scrivere correttamente un programma.
L'ordine dei primi due argomenti @`e l'opposto di molte altre funzioni che
trattano stringhe e che hanno a che fare con espressioni regolari, come
@code{sub()} e @code{gsub()}. Potrebbe essere di aiuto ricordare che
per @code{match()}, l'ordine @`e lo stesso che per l'operatore @samp{~} :
@samp{@var{stringa} ~ @var{regexp}}.
@cindex @code{RSTART} (variabile) @subentry funzione @code{match()} e
@cindex variabile @subentry @code{RSTART} @subentry funzione @code{match()} e
@cindex @code{RLENGTH} (variabile) @subentry funzione @code{match()} e
@cindex variabile @subentry @code{RLENGTH} @subentry funzione @code{match()} e
@cindex funzione @subentry @code{match()} @subentry variabili @code{RSTART}/@code{RLENGTH}
@cindex funzione @subentry @code{match()} @subentry effetti collaterali
@cindex @code{match()} (funzione) @subentry variabili @code{RSTART}/@code{RLENGTH}
@cindex @code{match()} (funzione) @subentry effetti collaterali
@cindex effetti collaterali @subentry funzione @subentry @code{match()}
La funzione @code{match()} imposta la variabile predefinita @code{RSTART}
all'indice.
Imposta anche la variabile predefinita @code{RLENGTH} alla
lunghezza in caratteri della sottostringa individuata. Se non viene
trovata alcuna corrispondenza, @code{RSTART} @`e impostata a zero, e
@code{RLENGTH} a @minus{}1.
Per esempio:
@example
@c file eg/misc/findpat.awk
@{
if ($1 == "TROVA")
regexp = $2
else @{
dove = match($0, regexp)
if (dove != 0)
print "Corrispondenza di", regexp, "alla posiz.", \
dove, "in", $0
@}
@}
@c endfile
@end example
@noindent
Questo programma ricerca delle righe che corrispondono all'espressione
regolare contenuta nella variabile
@code{regexp}. Quest'espressione regolare pu@`o essere modificata. Se la
prima parola in una riga @`e @samp{TROVA}, @code{regexp} diventa la
seconda parola su quella riga. Quindi, dato:
@example
@c file eg/misc/findpat.data
TROVA or+e
Il mio programma corre
ma non troppo velocemente
TROVA Melvin
JF+KM
Questa riga appartiene a Reality Engineering Co.
Melvin @`e passato da qui.
@c endfile
@end example
@noindent
@command{awk} stampa:
@example
Corrispondenza di or+e alla posiz. 19 in Il mio programma corre
Corrispondenza di Melvin alla posiz. 1 in Melvin @`e passato da qui.
@end example
@cindex differenze tra @command{awk} e @command{gawk} @subentry funzione @code{match()}
Se @var{vettore} esiste gi@`a, viene cancellato, e quindi l'elemento numero
zero di @var{vettore} @`e impostato all'intera parte di @var{stringa}
individuata da @var{regexp}. Se @var{regexp} contiene parentesi,
gli elementi aventi per indici numeri interi in @var{vettore} sono
impostati per contenere ognuno la parte di @var{stringa} individuata dalla
corrispondente sottoespressione delimitata da parentesi.
Per esempio:
@example
$ @kbd{echo pippoooopaperpluttttttt |}
> @kbd{gawk '@{ match($0, /(pippo+).+(plut*)/, vett)}
> @kbd{print vett[1], vett[2] @}'}
@print{} pippoooo pluttttttt
@end example
Inoltre,
sono disponibili indici multidimensionali che contengono
la posizione di partenza e la lunghezza di ogni sottoespressione
individuata:
@example
$ @kbd{echo pippoooopaperpluttttttt |}
> @kbd{gawk '@{ match($0, /(pippo+).+(plut*)/, vett)}
> @kbd{print vett[1], vett[2]}
> @kbd{print vett[1, "start"], vett[1, "length"]}
> @kbd{print vett[2, "start"], vett[2, "length"]}
> @kbd{@}'}
@print{} pippoooo pluttttttt
@print{} 1 8
@print{} 14 10
@end example
Possono non esserci indici che individuino inizio e posizione
per ogni sottoespressione
fra parentesi, perch@'e non tutte potrebbero aver individuato del testo;
quindi, andrebbero esaminati usando l'operatore @code{in}
(@pxref{Visitare elementi}).
@cindex risoluzione di problemi @subentry funzione @code{match()}
@cindex problemi @subentry risoluzione di @subentry funzione @code{match()}
L'argomento @var{vettore} di @code{match()} @`e un'estensione
@command{gawk}. In modalit@`a compatibile
(@pxref{Opzioni}),
l'impiego di un terzo argomento causa un errore fatale.
@item @code{patsplit(@var{stringa}, @var{vettore}} [@code{, @var{regexpdelim}} [@code{, @var{separatori}} ] ]@code{) #}
@cindexgawkfunc{patsplit}
@cindex dividere in un vettore una stringa
@cindex creare un vettore da una stringa
Divide
@var{stringa} in pezzi (o ``campi'') definiti da @var{fieldpat}
e memorizza i pezzi in @var{vettore} e le stringhe di separazione nel
vettore @var{separatori}. Il primo pezzo @`e memorizzato in
@code{@var{vettore}[1]}, il secondo pezzo in @code{@var{vettore}[2]}, e
cos@`{@dotless{i}} via. Il terzo argomento, @var{regexpdelim}, @`e
una @dfn{regexp} che descrive i campi in @var{stringa} (allo stesso modo in
cui @code{FPAT} @`e una @dfn{regexp} che descrive i campi nei record
in input).
Pu@`o essere una costante @dfn{regexp} o una stringa.
Se @var{regexpdelim} @`e omesso, viene usato il valore di @code{FPAT}.
@code{patsplit()} restituisce il numero di elementi creati.
@code{@var{separatori}[@var{i}]} @`e
la stringa (che potrebbe anche essere la stringa nulla) dopo
l'elemento @code{@var{vettore}[@var{i}]}.
Il separatore iniziale (che potrebbe anche essere la stringa nulla)
sar@`a in @code{@var{separatori}[0]}.
Quindi, una @var{stringa} non nulla, con @var{n} campi avr@`a @var{n+1}
separatori.
Una stringa nulla non avr@`a nessun campo e nessun separatore.
La funzione @code{patsplit()} divide delle stringhe in pezzi in modo
simile a quello con cui le righe in input vengono divise in campi
usando @code{FPAT}
(@pxref{Separazione in base al contenuto}).
Prima di dividere la stringa, @code{patsplit()} cancella ogni elemento che
fosse eventualmente presente
nei vettori @var{vettore} e @var{separatori}.
@item @code{split(@var{stringa}, @var{vettore}} [@code{, @var{separacampo}} [@code{, @var{separatori}} ] ]@code{)}
@cindexawkfunc{split}
Divide @var{stringa} in pezzi separati da @var{separacampo}
e memorizza i pezzi in @var{vettore} e le stringhe di separazione nel
vettore @var{separatori}. Il primo pezzo @`e memorizzato in
@code{@var{vettore}[1]}, il secondo pezzo in @code{@var{vettore}[2]}, e
cos@`{@dotless{i}} via. Il valore della stringa specificata nel terzo argomento,
@var{separacampo}, @`e una @dfn{regexp} che indica come dividere @var{stringa}
(analogamente a come @code{FS} pu@`o essere un @dfn{regexp} che indica dove
dividere i record in input).
Se @var{separacampo} @`e omesso, si usa il valore di @code{FS}.
@code{split()} restituisce il numero di elementi creati.
@var{separatori} @`e un'estensione @command{gawk}, in cui
@code{@var{separatori}[@var{i}]}
@`e la stringa che separa @code{@var{vettore}[@var{i}]} e
@code{@var{vettore}[@var{i}+1]}.
Se @var{separacampo} @`e uno spazio bianco, ogni eventuale spazio bianco
a inizio stringa viene messo in @code{@var{separatori}[0]} e ogni
eventuale spazio bianco a fine stringa viene messo in
@code{@var{separatori}[@var{n}]}, dove @var{n} @`e il valore restituito da
@code{split()} (cio@`e il numero di elementi in @var{vettore}).
La funzione @code{split()} divide le stringhe in pezzi nello stesso
modo in cui le righe in input sono divise in campi. Per esempio:
@example
split("cul-de-sac", a, "-", separatori)
@end example
@noindent
@cindex stringa @subentry divisione @subentry esempio
divide la stringa @code{"cul-de-sac"} in tre campi usando @samp{-} come
separatore. Il vettore @code{a} ha i seguenti contenuti:
@example
a[1] = "cul"
a[2] = "de"
a[3] = "sac"
@end example
e imposta il contenuto del vettore @code{separatori} come segue:
@example
seps[1] = "-"
seps[2] = "-"
@end example
@noindent
Il valore restituito da questa chiamata a @code{split()} @`e tre.
@cindex differenze tra @command{awk} e @command{gawk} @subentry funzione @code{split()}
Come nella divisione in campi dei record in input, quando il valore di
@var{separacampo} @`e @w{@code{" "}}, gli spazi bianchi a inizio e fine stringa
vengono ignorati nell'assegnare valori agli elementi di @var{vettore} ma non nel
vettore @var{separatori}, e gli elementi sono separati da uno o pi@`u spazi
bianchi. Inoltre, come nel caso della divisione dei record in input, se
@var{separacampo} @`e la stringa nulla, ogni singolo carattere nella stringa
costituisce un elemento del vettore.
@value{COMMONEXT}
Inoltre, se @var{separacampo} @`e una stringa costituita da un unico
carattere, quella stringa fa da separatore, anche se il carattere
in questione @`e un metacarattere usato nella espressioni regolari.
Si noti, tuttavia, che @code{RS} non influisce sul comportamento di
@code{split()}.
Anche se @samp{RS = ""} fa s@`{@dotless{i}} che il carattere di ritorno a capo sia un
separatore di campo,
questo non influenza il modo in cui @code{split()} divide le stringhe.
@cindex angolo buio @subentry funzione @subentry @code{split()}
Recenti implementazioni di @command{awk}, incluso @command{gawk},
consentono che il terzo argomento sia una costante @dfn{regexp}
(@w{@code{/}@dots{}@code{/}})
o anche una stringa. @value{DARKCORNER}
Anche lo standard POSIX permette questo.
@xref{Espressioni regolari calcolate} per la spiegazione della differenza
tra l'uso di una costante stringa e l'uso di una costante @dfn{regexp},
sulle loro implicazioni riguardo a come scrivere correttamente un programma.
Prima di dividere la stringa, @code{split()} cancella ogni elemento
eventualmente gi@`a presente
nei vettori @var{vettore} e @var{separatori}.
Se @var{stringa} @`e la stringa nulla, il vettore non ha elementi.
(Quindi, in questo modo si pu@`o cancellare un intero vettore con una sola
istruzione).
@xref{Cancellazione}.)
Se in @var{stringa} non viene trovato @var{separacampo} (ma la stringa
non @`e la stringa nulla),
@var{vettore} ha solo un elemento. Il valore di quell'elemento @`e la
@var{stringa} originale.
@cindex modalit@`a POSIX
In modalit@`a POSIX (@pxref{Opzioni}), il quarto argomento non @`e consentito.
@item @code{sprintf(@var{formato}, @var{espressione1}, @dots{})}
@cindexawkfunc{sprintf}
@cindex formattare @subentry stringhe
@cindex stringa @subentry formattazione
Restituisce (senza stamparla) la stringa che @code{printf} avrebbe
stampato con gli stessi argomenti
(@pxref{Printf}).
Per esempio:
@example
pival = sprintf("pi = %.2f (approx.)", 22/7)
@end example
@noindent
assegna la stringa @w{@samp{pi = 3.14 (approx.)}} alla variabile @code{pival}.
@cindexgawkfunc{strtonum}
@cindex conversione @subentry da stringa a numero
@cindex stringa @subentry conversione in numero
@item @code{strtonum(@var{stringa}) #}
Esamina @var{stringa} e restituisce il suo valore numerico. Se
@var{stringa} inizia con la cifra @samp{0}, @code{strtonum()} presuppone
che @var{stringa} sia un numero ottale. Se @var{stringa} inizia con
@samp{0x} o @samp{0X}, @code{strtonum()} presuppone che @var{stringa} sia un
numero esadecimale.
Per esempio:
@example
$ @kbd{echo 0x11 |}
> @kbd{gawk '@{ printf "%d\n", strtonum($1) @}'}
@print{} 17
@end example
Usare la funzione @code{strtonum()} @emph{non} @`e lo stesso che aggiungere
zero al valore di una stringa;
la conversione automatica di stringhe in numeri
si applica solo a dati decimali, non a quelli ottali o
esadecimali.@footnote{Tranne nel caso si usi l'opzione
@option{--non-decimal-data}, il che non @`e consigliato.
@xref{Dati non decimali} per ulteriori informazioni.}
Si noti anche che @code{strtonum()} usa il separatore decimale della
localizzazione corrente per riconoscere i numeri
(@pxref{Localizzazioni}).
@item @code{sub(@var{regexp}, @var{rimpiazzo}} [@code{, @var{obiettivo}}]@code{)}
@cindexawkfunc{sub}
@cindex rimpiazzare @subentry caratteri in una stringa
@cindex stringa @subentry rimpiazzare in una
Ricerca in @var{obiettivo}, che @`e visto come una stringa,
la prima sottostringa pi@`u lunga possibile,
a partire da sinistra, che corrisponde all'espressione regolare @var{regexp}.
Modifica l'intera stringa sostituendo il testo individuato con
@var{rimpiazzo}.
La stringa cos@`{@dotless{i}} modificata diventa il nuovo valore di @var{obiettivo}.
Restituisce il numero di sostituzioni fatte (zero o uno).
L'argomento @var{regexp} pu@`o essere o una costante @dfn{regexp}
(@code{/}@dots{}@code{/}) o una constante stringa (@code{"}@dots{}@code{"}).
In quest'ultimo caso, la stringa @`e trattata come una @dfn{regexp}
da individuare.
@xref{Espressioni regolari calcolate} per la spiegazione della differenza tra
le due forme, delle loro implicazioni riguardo al modo di scrivere
correttamente un programma.
Questa funzione @`e particolare perch@'e @var{obiettivo} non @`e semplicemente usato
per calcolare un valore, e non basta che sia un'espressione qualsiasi:
dev'essere una variabile, un campo, o un elemento di vettore in cui
@code{sub()} possa memorizzare un valore modificato. Se questo argomento @`e
omesso, il comportamento di default @`e
quello di usare e modificare
@code{$0}.@footnote{Si noti che questo significa che il record sar@`a dapprima
ricostruito, usando il valore di @code{OFS} se qualche campo @`e stato cambiato,
e che i campi saranno aggiornati dopo la sostituzione, anche se l'operazione in
s@'e non cambia il record (@`e una ``no-op'') come @samp{sub(/^/, "")}.} Per
esempio:
@example
str = "acqua, acqua dappertutto"
sub(/cqu/, "vari", str)
@end example
@noindent
modifica @code{stringa} facendola divenire
@w{@samp{avaria, acqua dappertutto}},
rimpiazzando l'occorrenza pi@`u lunga,
a partire da sinistra, di @samp{cqu} con @samp{vari}.
Se il carattere speciale @samp{&} compare in @var{rimpiazzo}, designa
l'esatta sottostringa individuata da @var{regexp}. (Se
@dfn{regexp} pu@`o individuare pi@`u di una stringa, questa sottostringa
pu@`o assumere valori diversi.) Per esempio:
@example
@{ sub(/candidato/, "& e sua moglie"); print @}
@end example
@noindent
cambia la prima occorrenza di @samp{candidato} a @samp{candidato
e sua moglie} in ogni riga in input.
Ecco un altro esempio:
@example
$ @kbd{awk 'BEGIN @{}
> @kbd{str = "daabaaa"}
> @kbd{sub(/a+/, "C&C", str)}
> @kbd{print str}
> @kbd{@}'}
@print{} dCaaCbaaa
@end example
@noindent
questo mostra come @samp{&} possa rappresentare una stringa variabile
e illustra anche la regola
``a partire da sinistra, la pi@`u lunga'' nell'individuazione di @dfn{regexp}
(@pxref{Pi@`u lungo da sinistra}).
L'effetto di questo carattere speciale (@samp{&}) pu@`o essere neutralizzato
anteponendogli una barra inversa nella stringa. Come al solito, per
inserire una barra inversa nella
stringa, occorre scrivere due barre inverse. Quindi, occorre scrivere
@samp{\\&} in una costante stringa per includere un carattere @samp{&}
nel rimpiazzo.
Per esempio, quanto segue mostra come rimpiazzare il primo @samp{|} su
ogni riga con un @samp{&}:
@example
@{ sub(/\|/, "\\&"); print @}
@end example
@cindex @code{sub()} (funzione) @subentry argomenti di
@cindex funzione @subentry @code{sub()} @subentry argomenti di
@cindex @code{gsub()} (funzione) @subentry argomenti di
@cindex funzione @subentry @code{gsub()} @subentry argomenti di
Come gi@`a accennato, il terzo argomento di @code{sub()} dev'essere
una variabile, un campo, o un elemento di vettore.
Alcune versioni di @command{awk} accettano come terzo argomento
un'espressione che non @`e un @dfn{lvalue}. In tal caso, @code{sub()}
cerca ugualmente l'espressione e restituisce zero o uno, ma il risultato
della sostituzione (se ce n'@`e uno) viene scartato perch@'e non c'@`e un posto
dove memorizzarlo. Tali versioni di @command{awk} accettano espressioni
come le seguente:
@example
sub(/USA/, "Stati Uniti", "gli USA e il Canada")
@end example
@noindent
@cindex risoluzione di problemi @subentry funzioni @code{gsub()}/@code{sub()}
@cindex problemi @subentry risoluzione di @subentry funzioni @code{gsub()}/@code{sub()}
Per compatibilit@`a storica, @command{gawk} accetta un tale codice erroneo.
Tuttavia, l'uso di qualsiasi altra espressione non modificabile
come terzo parametro causa un errore fatale, e il programma
non viene portato a termine.
Infine, se la @var{regexp} non @`e una costante @dfn{regexp}, @`e convertita
in una stringa, e quindi il valore di quella stringa @`e trattato come
la @dfn{regexp} da individuare.
@item @code{substr(@var{stringa}, @var{inizio}} [@code{, @var{lunghezza}} ]@code{)}
@cindexawkfunc{substr}
@cindex sottostringa
Restituisce una sottostringa di @var{stringa} lunga @var{lunghezza} caratteri,
iniziando dal carattere numero @var{inizio}. Il primo carattere di una
stringa @`e il carattere numero uno.@footnote{Questo @`e differente da
C e C++, in cui il primo carattere ha il numero zero.}
Per esempio, @code{substr("Washington", 5, 3)} restituisce @code{"ing"}.
Se @var{lunghezza} non @`e presente, @code{substr()} restituisce l'intero
suffisso di
@var{stringa} a partire dal carattere numero @var{inizio}. Per esempio,
@code{substr("Washington", 5)} restituisce @code{"ington"}. L'intero
suffisso @`e restituito anche
se @var{lunghezza} @`e maggiore del numero di caratteri disponibili
nella stringa, a partire dal carattere @var{inizio}.
@cindex Brian Kernighan @subentry @command{awk} di
Se @var{inizio} @`e minore di uno, @code{substr()} lo tratta come se
fosse uno. (POSIX non specifica cosa fare in questo caso:
BWK @command{awk} si comporta cos@`{@dotless{i}}, e quindi @command{gawk} fa lo stesso.)
Se @var{inizio} @`e maggiore del numero di caratteri
nella stringa, @code{substr()} restituisce la stringa nulla.
Analogamente, se @var{lunghezza} @`e presente ma minore o uguale a zero,
viene restituita la stringa nulla.
@cindex risoluzione di problemi @subentry funzione @code{substr()}
@cindex problemi @subentry risoluzione di @subentry funzione @code{substr()}
La stringa restituita da @code{substr()} @emph{non pu@`o} essere
assegnata. Quindi, @`e un errore tentare di modificare una porzione di
una stringa, come si vede nel seguente esempio:
@example
stringa = "abcdef"
# tentare di ottenere "abCDEf", non @`e possibile
substr(stringa, 3, 3) = "CDE"
@end example
@noindent
@`E anche un errore usare @code{substr()} come terzo argomento
di @code{sub()} o @code{gsub()}:
@example
gsub(/xyz/, "pdq", substr($0, 5, 20)) # SBAGLIATO
@end example
@cindex portabilit@`a @subentry funzione @code{substr()}
(Alcune versioni commerciali di @command{awk} consentono un tale uso di
@code{substr()}, ma un tale codice non @`e portabile.)
Se si devono sostituire pezzi di una stringa,
si combini @code{substr()}
con una concatenazione di stringa, nel modo seguente:
@example
stringa = "abcdef"
@dots{}
stringa = substr(stringa, 1, 2) "CDE" substr(stringa, 6)
@end example
@cindex maiuscolo/minuscolo @subentry conversione da/a
@cindex stringa @subentry conversione maiuscolo/minuscolo
@item @code{tolower(@var{stringa})}
@cindexawkfunc{tolower}
@cindex conversione @subentry di stringa in minuscolo
Restituisce una copia di @var{stringa}, con ogni carattere maiuscolo
nella stringa rimpiazzato dal suo corrispondente carattere minuscolo.
I caratteri non alfabetici non vengono modificati. Per esempio,
@code{tolower("MaIuScOlO MiNuScOlO 123")} restituisce
@code{"maiuscolo minuscolo 123"}.
@item @code{toupper(@var{stringa})}
@cindexawkfunc{toupper}
@cindex conversione @subentry di stringa in maiuscolo
Restituisce una copia di @var{stringa}, con ogni carattere minuscolo
nella stringa rimpiazzato dal suo corrispondente carattere maiuscolo.
I caratteri non alfabetici non vengono modificati. Per esempio,
@code{tolower("MaIuScOlO MiNuScOlO 123")} restituisce
@code{"MAIUSCOLO MINUSCOLO 123"}.
@end table
@sidebar Individuare la stringa nulla
@cindex individuare @subentry la stringa nulla
@cindex stringa nulla @subentry individuare la
@cindex @code{*} (asterisco) @subentry operatore @code{*} @subentry individuare la stringa nulla
@cindex asterisco (@code{*}) @subentry operatore @code{*} @subentry individuare la stringa nulla
In @command{awk}, l'operatore @samp{*} pu@`o individuare la stringa nulla.
Questo @`e particolarmente importante per le funzioni @code{sub()},
@code{gsub()} e @code{gensub()}. Per esempio:
@example
$ @kbd{echo abc | awk '@{ gsub(/m*/, "X"); print @}'}
@print{} XaXbXcX
@end example
@noindent
Sebbene questo sia abbastanza sensato, pu@`o suscitare una certa sorpresa.
@end sidebar
@node Dettagli ostici
@subsubsection Ulteriori dettagli su @samp{\} e @samp{&} con @code{sub()}, @code{gsub()} e @code{gensub()}
@cindex protezione @subentry nelle funzioni @code{gsub()}/@code{gensub()}/@code{sub()}
@cindex funzione @subentry @code{sub()} @subentry protezione caratteri
@cindex @code{sub()} (funzione) @subentry protezione caratteri
@cindex funzione @subentry @code{gsub()} @subentry protezione caratteri
@cindex @code{gsub()} (funzione) @subentry protezione caratteri
@cindex funzione @subentry @code{gensub()} (@command{gawk}) @subentry protezione caratteri
@cindex @code{gensub()} (funzione @command{gawk}) @subentry protezione caratteri
@cindex @code{\} (barra inversa) @subentry @code{gsub()}/@code{gensub()}/@code{sub()} funzioni e
@cindex barra inversa (@code{\}) @subentry @code{gsub()}/@code{gensub()}/@code{sub()} funzioni e
@cindex @code{&} (e commerciale) @subentry funzioni @code{gsub()}/@code{gensub()}/@code{sub()} e
@cindex e commerciale (@code{&}) @subentry funzioni @code{gsub()}/@code{gensub()}/@code{sub()} e
@quotation ATTENZIONE
Si dice che questa sottosezione possa causare dei mal di testa.
In prima lettura pu@`o essere benissimo saltata.
@end quotation
Quando si usa @code{sub()}, @code{gsub()} o @code{gensub()}, e si
desidera includere delle
barre inverse e delle "e commerciali" (@code{&}) nel testo da sostituire
@`e necessario ricordare che ci sono parecchi livelli di
@dfn{protezione caratteri} in gioco.
Anzitutto, vi @`e il livello @dfn{lessicale}, quello in cui @command{awk}
legge un programma e ne costruisce una copia interna da eseguire.
Poi c'@`e il momento dell'esecuzione, quello in cui @command{awk}
esamina effettivamente la stringa da sostituire, per determinare cosa
fare.
@cindex Brian Kernighan @subentry @command{awk} di
In entrambi i livelli, @command{awk} ricerca un dato insieme di caratteri
che possono venire dopo una
barra inversa. A livello lessicale, cerca le sequenze di protezione
elencate in @ref{Sequenze di protezione}.
Quindi, per ogni @samp{\} che @command{awk} elabora al momento
dell'esecuzione, occorre immetterne due a livello lessicale.
Quando un carattere che non ha necessit@`a di una sequenza di protezione
segue una @samp{\}, sia BWK @command{awk} che @command{gawk} semplicemente
rimuovono la @samp{\} stessa e
mettono il carattere seguente nella stringa. Quindi, per esempio,
@code{"a\qb"} @`e trattato come se si fosse scritto @code{"aqb"}.
Al momento dell'esecuzione, le varie funzioni gestiscono sequenze di
@samp{\} e @samp{&} in maniera differente. La situazione @`e (purtroppo)
piuttosto complessa.
Storicamente, le funzioni @code{sub()} e @code{gsub()} trattavano la
sequenza di due caratteri @samp{\&} in maniera speciale; questa sequenza
era rimpiazzata nel testo
generato da un singolo carattere @samp{&}. Ogni altra @samp{\} contenuta
nella stringa @var{rimpiazzo} che non era posta prima di una @samp{&} era
lasciata passare senza modifiche.
Questo @`e illustrato nella @ref{table-sub-escapes}.
@c Thank to Karl Berry for help with the TeX stuff.
@float Tabella,table-sub-escapes
@caption{Elaborazione storica delle sequenze di protezione per @code{sub()} e @code{gsub()}}
@tex
\vbox{\bigskip
% We need more characters for escape and tab ...
\catcode`_ = 0
\catcode`! = 4
% ... since this table has lots of &'s and \'s, so we unspecialize them.
\catcode`\& = \other \catcode`\\ = \other
_halign{_hfil#!_qquad_hfil#!_qquad#_hfil_cr
Immissione!@code{sub()} vede!@code{sub()} genera_cr
_hrulefill!_hrulefill!_hrulefill_cr
@code{\&}! @code{&}!Il testo individuato_cr
@code{\\&}! @code{\&}!Il carattere @samp{&}_cr
@code{\\\&}! @code{\&}!Il carattere @samp{&}_cr
@code{\\\\&}! @code{\\&}!I caratteri @samp{\&}_cr
@code{\\\\\&}! @code{\\&}!I caratteri @samp{\&}_cr
@code{\\\\\\&}! @code{\\\&}!I caratteri @samp{\\&}_cr
@code{\\q}! @code{\q}!I caratteri @samp{\q}_cr
}
_bigskip}
@end tex
@ifdocbook
@multitable @columnfractions .20 .20 .60
@headitem Immissione @tab @code{sub()} vede @tab @code{sub()} genera
@item @code{\&} @tab @code{&} @tab Il testo individuato
@item @code{\\&} @tab @code{\&} @tab Il carattere @samp{&}
@item @code{\\\&} @tab @code{\&} @tab Il carattere @samp{&}
@item @code{\\\\&} @tab @code{\\&} @tab I caratteri @samp{\&}
@item @code{\\\\\&} @tab @code{\\&} @tab I caratteri @samp{\&}
@item @code{\\\\\\&} @tab @code{\\\&} @tab I caratteri @samp{\\&}
@item @code{\\q} @tab @code{\q} @tab I caratteri @samp{\q}
@end multitable
@end ifdocbook
@ifnottex
@ifnotdocbook
@display
Immissione @code{sub()} vede @code{sub()} genera
--------------- ------------- ---------------
@code{\&} @code{&} Il testo individuato
@code{\\&} @code{\&} La lettera @samp{&}
@code{\\\&} @code{\&} La lettera @samp{&}
@code{\\\\&} @code{\\&} Le lettere @samp{\&}
@code{\\\\\&} @code{\\&} Le lettere @samp{\&}
@code{\\\\\\&} @code{\\\&} Le lettere @samp{\\&}
@code{\\q} @code{\q} Le lettere @samp{\q}
@end display
@end ifnotdocbook
@end ifnottex
@end float
@noindent
Questa tabella mostra l'elaborazione a livello lessicale, in cui
un numero dispari di barre inverse diventa un numero pari al momento
dell'esecuzione,
e mostra anche l'elaborazione in fase di esecuzione fatta da @code{sub()}.
(Per amor di semplicit@`a le tavole che ancora seguono mostrano solo il caso
di un numero pari di barre inverse immesso a livello lessicale.)
Il problema con l'approccio storico @`e che non c'@`e modo di ottenere
un carattere @samp{\} seguito dal testo individuato.
Parecchie edizioni dello standard POSIX hanno provato a risolvere questo
problema, senza riuscirci. I dettagli sono irrilevanti in questo contesto.
A un certo punto, il manutentore di @command{gawk} ha presentato una
proposta per una revisione dello standard per tornare
a regole che corrispondano pi@`u da vicino alla prassi originalmente seguita.
Le regole proposte hanno dei casi speciali che rendono possibile
produrre una @samp{\} prima del
testo individuato. Questo si pu@`o vedere nella
@ref{table-sub-proposed}.
@float Tabella,table-sub-proposed
@caption{Regole @command{gawk} per @code{sub()} e barra inversa}
@tex
\vbox{\bigskip
% We need more characters for escape and tab ...
\catcode`_ = 0
\catcode`! = 4
% ... since this table has lots of &'s and \'s, so we unspecialize them.
\catcode`\& = \other \catcode`\\ = \other
_halign{_hfil#!_qquad_hfil#!_qquad#_hfil_cr
Immissione!@code{sub()} vede!@code{sub()} genera_cr
_hrulefill!_hrulefill!_hrulefill_cr
@code{\\\\\\&}! @code{\\\&}!I caratteri @samp{\&}_cr
@code{\\\\&}! @code{\\&}!Il carattere @samp{\}, seguito dal testo individuato_cr
@code{\\&}! @code{\&}!Il carattere @samp{&}_cr
@code{\\q}! @code{\q}!I caratteri @samp{\q}_cr
@code{\\\\}! @code{\\}!@code{\\}_cr
}
_bigskip}
@end tex
@ifdocbook
@multitable @columnfractions .20 .20 .60
@headitem Immissione @tab @code{sub()} vede @tab @code{sub()} genera
@item @code{\\\\\\&} @tab @code{\\\&} @tab I caratteri @samp{\&}
@item @code{\\\\&} @tab @code{\\&} @tab Il carattere @samp{\}, seguito dal testo individuato
@item @code{\\&} @tab @code{\&} @tab Il carattere @samp{&}
@item @code{\\q} @tab @code{\q} @tab I caratteri @samp{\q}
@item @code{\\\\} @tab @code{\\} @tab @code{\\}
@end multitable
@end ifdocbook
@ifnottex
@ifnotdocbook
@display
Immissione @code{sub()} vede @code{sub()} genera
--------- ---------- ---------------
@code{\\\\\\&} @code{\\\&} Il carattere @samp{\&}
@code{\\\\&} @code{\\&} Il carattere @samp{\}, seguito dal testo individuato
@code{\\&} @code{\&} Il carattere @samp{&}
@code{\\q} @code{\q} I caratteri @samp{\q}
@code{\\\\} @code{\\} @code{\\}
@end display
@end ifnotdocbook
@end ifnottex
@end float
In breve, al momento dell'esecuzione, ci sono ora tre sequenze speciali
di caratteri (@samp{\\\&}, @samp{\\&}, e @samp{\&}) mentre tradizionalmente
ce n'era una sola. Tuttavia, come nel caso storico, ogni @samp{\} che
non fa parte di una di queste tre sequenze non @`e speciale e appare
nell'output cos@`{@dotless{i}} come @`e scritto.
@command{gawk} 3.0 e 3.1 seguono queste regole per @code{sub()} e
@code{gsub()}. La revisione dello standard POSIX ha richiesto molto pi@`u tempo
di quel che ci si attendeva. Inoltre, la proposta del manutentore di
@command{gawk} @`e andata persa durante il processo di standardizzazione. Le
regole finali risultanti sono un po' pi@`u semplici. I risultati sono simili,
tranne che in un caso.
@cindex POSIX @command{awk} @subentry @code{gsub()}/@code{sub()} (funzioni)
Le regole POSIX stabiliscono che @samp{\&} nella stringa di rimpiazzo
produca il carattere @samp{&}, @samp{\\} produce il carattere @samp{\},
e che @samp{\} seguito da qualsiasi carattere non @`e speciale; la @samp{\}
@`e messa direttamente nell'output.
Queste regole sono presentate nella @ref{table-posix-sub}.
@float Tabella,table-posix-sub
@caption{Regole POSIX per @code{sub()} e @code{gsub()}}
@tex
\vbox{\bigskip
% We need more characters for escape and tab ...
\catcode`_ = 0
\catcode`! = 4
% ... since this table has lots of &'s and \'s, so we unspecialize them.
\catcode`\& = \other \catcode`\\ = \other
_halign{_hfil#!_qquad_hfil#!_qquad#_hfil_cr
Immissione!@code{sub()} vede!@code{sub()} genera_cr
_hrulefill!_hrulefill!_hrulefill_cr
@code{\\\\\\&}! @code{\\\&}!I caratteri @samp{\&}_cr
@code{\\\\&}! @code{\\&}!Il carattere @samp{\}, seguito dal testo individuato_cr
@code{\\&}! @code{\&}!Il carattere @samp{&}_cr
@code{\\q}! @code{\q}!I caratteri @samp{\q}_cr
@code{\\\\}! @code{\\}!@code{\}_cr
}
_bigskip}
@end tex
@ifdocbook
@multitable @columnfractions .20 .20 .60
@headitemImmissione @tab @code{sub()} vede @tab @code{sub()} genera
@item @code{\\\\\\&} @tab @code{\\\&} @tab I caratteri @samp{\&}
@item @code{\\\\&} @tab @code{\\&} @tab Il carattere @samp{\}, seguito dal testo individuato
@item @code{\\&} @tab @code{\&} @tab I caratteri @samp{&}
@item @code{\\q} @tab @code{\q} @tab I caratteri @samp{\q}
@item @code{\\\\} @tab @code{\\} @tab @code{\}
@end multitable
@end ifdocbook
@ifnottex
@ifnotdocbook
@display
Immissione @code{sub()} vede @code{sub()} genera
--------- ---------- ---------------
@code{\\\\\\&} @code{\\\&} I caratteri @samp{\&}
@code{\\\\&} @code{\\&} Il carattere @samp{\}, seguito dal testo individuato
@code{\\&} @code{\&} Il carattere @samp{&}
@code{\\q} @code{\q} I caratteri @samp{\q}
@code{\\\\} @code{\\} @code{\}
@end display
@end ifnotdocbook
@end ifnottex
@end float
Il solo caso in cui la differenza @`e rilevante @`e l'ultimo: @samp{\\\\}
@`e visto come @samp{\\} e produce @samp{\} invece che @samp{\\}.
A partire dalla @value{PVERSION} 3.1.4, @command{gawk} ha seguito le regole
POSIX quando si specifica @option{--posix} (@pxref{Opzioni}). Altrimenti, ha
continuato a seguire le regole proposte [a POSIX], poich@'e questa @`e stato il
comportamento seguito per parecchi anni.
Quando la @value{PVERSION} 4.0.0 @`e stata rilasciata, il manutentore di
@command{gawk}
ha stabilito come default le regole POSIX, interrompendo cos@`{@dotless{i}} oltre
un decennio di compatibilit@`a
all'indietro.@footnote{Questa decisione si @`e dimostrata piuttosto avventata,
anche se una nota in questa sezione avvertiva che la successiva versione
principale di @command{gawk} avrebbe adottato le regole POSIX.}
Inutile dire che questa non @`e stata una buona idea, e quindi dalla
@value{PVERSION} 4.0.1, @command{gawk} ha ripreso il suo comportamento
tradizionale, seguendo le regole POSIX solo quando si specifica l'opzione
@option{--posix}.
Le regole per @code{gensub()} sono molto pi@`u semplici. Al momento
dell'esecuzione, quando @command{gawk} vede una @samp{\}, se il carattere
seguente @`e una cifra,
il testo individuato dalla corrispondente sottoespressione tra parentesi
@`e inserito nell'output generato. Altrimenti, qualsiasi carattere segua la
@samp{\} viene inserito nel testo generato, mentre la @samp{\} va persa,
come si vede nella @ref{table-gensub-escapes}.
@float Tabella,table-gensub-escapes
@caption{Elaborazione sequenze di protezione in @code{gensub()}}
@tex
\vbox{\bigskip
% We need more characters for escape and tab ...
\catcode`_ = 0
\catcode`! = 4
% ... since this table has lots of &'s and \'s, so we unspecialize them.
\catcode`\& = \other \catcode`\\ = \other
_halign{_hfil#!_qquad_hfil#!_qquad#_hfil_cr
Immissione!@code{gensub()} vede!@code{gensub()} genera_cr
_hrulefill!_hrulefill!_hrulefill_cr
@code{&}! @code{&}!Il testo individuato_cr
@code{\\&}! @code{\&}!Il carattere @samp{&}_cr
@code{\\\\}! @code{\\}!Il carattere @samp{\}_cr
@code{\\\\&}! @code{\\&}!Il carattere @samp{\}, seguito dal testo individuato_cr
@code{\\\\\\&}! @code{\\\&}!I caratteri @samp{\&}_cr
@code{\\q}! @code{\q}!Il carattere @samp{q}_cr
}
_bigskip}
@end tex
@ifdocbook
@multitable @columnfractions .20 .20 .60
@headitem Immissione @tab @code{gensub()} vede @tab @code{gensub()} genera
@item @code{&} @tab @code{&} @tab Il testo individuato
@item @code{\\&} @tab @code{\&} @tab Il carattere @samp{&}
@item @code{\\\\} @tab @code{\\} @tab Il carattere @samp{\}
@item @code{\\\\&} @tab @code{\\&} @tab Il carattere @samp{\}, seguito dal testo individuato
@item @code{\\\\\\&} @tab @code{\\\&} @tab I caratteri @samp{\&}
@item @code{\\q} @tab @code{\q} @tab Il carattere @samp{q}
@end multitable
@end ifdocbook
@ifnottex
@ifnotdocbook
@display
Immissione @code{gensub()} vede @code{gensub()} genera
--------- ------------- ------------------
@code{&} @code{&} Il testo individuato
@code{\\&} @code{\&} Il carattere @samp{&}
@code{\\\\} @code{\\} Il carattere @samp{\}
@code{\\\\&} @code{\\&} Il carattere @samp{\}, seguito dal testo individuato
@code{\\\\\\&} @code{\\\&} I caratteri @samp{\&}
@code{\\q} @code{\q} Il carattere @samp{q}
@end display
@end ifnotdocbook
@end ifnottex
@end float
A causa della complessit@`a dell'elaborazione a livello lessicale e in fase
di esecuzione, e dei casi speciali di @code{sub()} e @code{gsub()},
si raccomanda l'uso di @command{gawk} e di @code{gensub()} quando ci siano
da fare delle sostituzioni.
@node Funzioni di I/O
@subsection Funzioni di Input/Output
@cindex input/output @subentry funzioni di
@cindex funzioni @subentry di input/output
Le seguenti funzioni riguardano l'input/output (I/O).
I parametri opzionali sono racchiusi tra parentesi quadre ([ ]):
@table @asis
@item @code{close(}@var{nome_file} [@code{,} @var{come}]@code{)}
@cindexawkfunc{close}
@cindex file @subentry chiusura di
@cindex chiudere un file o un coprocesso
Chiude il file @var{nome_file} in input o in output. Alternativamente,
l'argomento pu@`o essere un comando della shell usato per creare un
coprocesso, o per ridirigere
verso o da una @dfn{pipe}; questo coprocesso o @dfn{pipe} viene chiuso.
@xref{Chiusura file e @dfn{pipe}}
per ulteriori informazioni.
Quando si chiude un coprocesso, pu@`o talora essere utile chiudere dapprima
un lato della @dfn{pipe} bidirezionale e quindi chiudere l'altro.
Questo si pu@`o fare fornendo un secondo argomento a @code{close()}.
Questo secondo argomento (@var{come})
dovrebbe essere una delle due stringhe @code{"to"} o @code{"from"},
che indicano quale lato della @dfn{pipe} chiudere. La stringa pu@`o essere
scritta indifferentemente in maiuscolo o in minuscolo.
@xref{I/O bidirezionale},
che tratta questa funzionalit@`a con maggior dettaglio e mostra un esempio.
Si noti che il secondo argomento di @code{close()} @`e
un'estensione @command{gawk}; non @`e disponibile in modalit@`a compatibile
(@pxref{Opzioni}).
@item @code{fflush(}[@var{nome_file}]@code{)}
@cindexawkfunc{fflush}
@cindex scrivere su disco i buffer di output contenuti in memoria
Scrive su disco ogni output contenuto in memoria, associato con
@var{nome_file}, che @`e o un
file aperto in scrittura o un comando della shell che ridirige output a
una @dfn{pipe} o a un coprocesso.
@cindex buffer @subentry scrivere su disco un
@cindex memoria tampone @subentry scrivere su disco
@cindex output @subentry bufferizzazione
@cindex output @subentry nella memoria tampone (buffer)
Molti programmi di utilit@`a @dfn{bufferizzano} il loro output (cio@`e,
accumulano in memoria record da scrivere in un file su disco o sullo
schermo, fin quando non arriva il momento giusto per inviare i
dati al dispositivo di output).
Questo @`e spesso pi@`u efficiente che scrivere
ogni particella di informazione non appena diventa disponibile. Tuttavia,
qualche volta @`e necessario forzare un programma a @dfn{svuotare}
i suoi buffer (cio@`e, inviare l'informazione alla sua destinazione,
anche se un buffer non @`e pieno).
Questo @`e lo scopo della funzione @code{fflush()}; anche
@command{gawk} scrive il suo output in un buffer, e la funzione @code{fflush()}
forza @command{gawk} a svuotare i suoi buffer.
@cindex estensioni comuni @subentry funzione @code{fflush()}
@cindex Brian Kernighan @subentry @command{awk} di
Brian Kernighan ha aggiunto @code{fflush()} al suo @command{awk} nell'aprile
1992. Per due decenni @`e rimasta un'estensione comune. A Dicembre
2012 @`e stata accettata e inclusa nello standard POSIX.
Si veda @uref{http://austingroupbugs.net/view.php?id=634, il sito Web dell'Austin Group}.
POSIX standardizza @code{fflush()} come segue: se non c'@`e alcun
argomento, o se l'argomento @`e la stringa nulla (@w{@code{""}}),
@command{awk} svuota i buffer di @emph{tutti} i file in output e di
@emph{tutte} le @dfn{pipe}.
@quotation NOTA
Prima della @value{PVERSION} 4.0.2, @command{gawk}
avrebbe svuotato solo i buffer dello standard output se non era
specificato alcun argomento,
e svuotato tutti i buffer dei file in output e delle @dfn{pipe} se
l'argomento era la stringa nulla.
Questo @`e stato modificato per essere compatibile con BWK @command{awk},
nella speranza che standardizzare questa
funzionalit@`a in POSIX sarebbe stato pi@`u agevole (come poi @`e effettivamente
successo).
Con @command{gawk},
si pu@`o usare @samp{fflush("/dev/stdout")} se si desidera solo svuotare i
buffer dello standard output.
@end quotation
@c @cindex automatic warnings
@c @cindex warnings, automatic
@cindex risoluzione di problemi @subentry funzione @code{fflush()}
@cindex problemi @subentry risoluzione di @subentry funzione @code{fflush()}
@code{fflush()} restituisce zero se il buffer @`e svuotato con successo;
altrimenti, restituisce un valore diverso da zero. (@command{gawk}
restituisce @minus{}1.)
Nel caso in cui tutti i buffer vadano svuotati, il valore restituito @`e zero
solo se tutti i buffer sono stati svuotati con successo. Altrimenti,
@`e @minus{}1, e @command{gawk} avvisa riguardo al @var{nome_file}
che ha problemi.
@command{gawk} invia anche un messaggio di avvertimento se si tenta di svuotare i
buffer di un file o @dfn{pipe} che era stato aperto in lettura
(p.es. con @code{getline}),
o se @var{nome_file} non @`e un file, una @dfn{pipe}, o un coprocesso aperto.
in tal caso, @code{fflush()} restituisce ancora @minus{}1.
@c end the table to let the sidebar take up the full width of the page.
@end table
@sidebar Bufferizzazione interattiva e non interattiva
@cindex bufferizzazione @subentry interattiva vs.@: non interattiva
A complicare ulteriormente le cose, i problemi di bufferizzazione possono
peggiorare se il programma eseguito
@`e @dfn{interattivo} (cio@`e, se
comunica con un utente seduto davanti a una tastiera).@footnote{Un programma
@`e interattivo se il suo standard output @`e connesso a un dispositivo
terminale. Ai giorni nostri, questo vuol dire davanti a uno
schermo e a una tastiera.}
@c Thanks to Walter.Mecky@dresdnerbank.de for this example, and for
@c motivating me to write this section.
I programmi interattivi normalmente @dfn{bufferizzano per riga} il loro
output (cio@`e, scrivono in output una riga alla volta). I programmi
non-interattivi attendono di aver riempito un buffer, il che pu@`o voler dire
anche parecchie righe di output.
Ecco un esempio della differenza:
@example
$ @kbd{awk '@{ print $1 + $2 @}'}
@kbd{1 1}
@print{} 2
@kbd{2 3}
@print{} 5
@kbd{Ctrl-d}
@end example
@noindent
Ogni riga di output @`e stampata immediatamente. Si confronti questo
comportamente con quello di questo esempio:
@example
$ @kbd{awk '@{ print $1 + $2 @}' | cat}
@kbd{1 1}
@kbd{2 3}
@kbd{Ctrl-d}
@print{} 2
@print{} 5
@end example
@noindent
In questo caso, nessun output viene stampato finch@'e non @`e stato battuto il
@kbd{Ctrl-d}, perch@'e l'output @`e bufferizzato e inviato tramite
@dfn{pipe} al comando @command{cat} in un colpo solo.
@end sidebar
@table @asis
@item @code{system(@var{comando})}
@cindexawkfunc{system}
@cindex chiamare @subentry comando di shell
@cindex interagire con altri programmi
Esegue il comando del sistema operativo @var{comando} e quindi
ritorna al programma @command{awk}.
Restituisce il codice di ritorno di @var{comando}.
Per esempio, inserendo il seguente frammento di codice in un programma
@command{awk}:
@example
END @{
system("date | mail -s 'awk completato' root")
@}
@end example
@noindent
all'amministratore di sistema viene inviato un messaggio di posta quando
il programma @command{awk} termina di elaborare l'input e inizia
l'elaborazione da eseguire alla fine dell'input.
Si noti che la ridirezione di @code{print} o @code{printf} in una
@dfn{pipe} @`e spesso sufficiente per ottenere lo stesso risultato.
Se @`e necessario eseguire parecchi comandi, @`e pi@`u efficiente
stamparli verso una @dfn{pipe} diretta alla shell:
@example
while (@var{ancora lavoro da fare})
print @var{comando} | "/bin/sh"
close("/bin/sh")
@end example
@noindent
@cindex risoluzione di problemi @subentry funzione @code{system()}
@cindex problemi @subentry risoluzione di @subentry funzione @code{system()}
@cindex @option{--sandbox} (opzione) @subentry disabilitare la funzione @code{system()}
@cindex opzione @subentry @option{--sandbox} @subentry disabilitare la funzione @code{system()}
Tuttavia, nel caso che il programma @command{awk} sia interattivo,
@code{system()} @`e utile per eseguire grossi programmi autonomi,
come ad esempio la shell o un programma di modifica testi.
Alcuni sistemi operativi non consentono di implementare la funzione
@code{system()}.
Richiamare @code{system()} in sistemi in cui non @`e disponibile provoca
un errore fatale.
@quotation NOTA
Quando si specifica l'opzione @option{--sandbox}, la funzione @code{system()} @`e
disabilitata (@pxref{Opzioni}).
@end quotation
Nei sistemi aderenti allo standard POSIX, il codice di ritorno di un
comando @`e un numero contenuto in 16 bit. Il valore del codice di ritorno
passato alla funzione C @code{exit()} alla fine del programma @`e contenuto
negli 8 bit di valore pi@`u alto dei 16 bit (la met@`a sinistra) che compongono
il numero. I bit di valore pi@`u basso (la met@`a destra) indicano se il
processo @`e stato terminato da un segnale (bit 7), e, se questo @`e il caso,
il numero del segnale che ha provocato la terminazione (bit 0--6).
Tradizionalmente, la funzione @code{system()} di @command{awk} si @`e
semplicemente limitata a restituire il valore del codice di ritorno
diviso per 256 (ossia la met@`a sinistra del numero di 16 bit, spostata
a destra). In una situazione normale questo equivale a utilizzare il
codice di ritornodi @code{system()}, ma nel caso in cui il programma sia
stato terminato da un segnale, il valore diventa un numero frazionale in
virgola mobile.@footnote{In uno scambio di messaggi privato il Dr.@:
Kernighan mi ha comunicato che questo modo di procedere @`e probabilmente
errato.} POSIX stabilisce che la chiamata a @code{system()} dall'interno
di @command{awk} dovrebbe restituire l'intero valore a 16 bit.
@command{gawk} si trova in qualche modo a met@`a strada.
I valori del codice di ritorno sono descritti nella
@ref{table-system-return-values}.
@float Tabella,table-system-return-values
@caption{Valori codici di ritorno da chiamata a @code{system()}}
@multitable @columnfractions .40 .60
@headitem Situazione @tab Valore codice di ritorno da @code{system()}
@item @option{--traditional} @tab Valore dalla funzione C @code{system()}/256
@item @option{--posix} @tab Valore dalla funzione C @code{system()}
@item Uscita normale dal comando @tab Codice di ritorno del comando
@item Terminazione da un segnale @tab 256 + numero segnale "assassino"
@item Terminazione da un segnale con dump memoria @tab 512 + numero segnale "assassino"
@item Qualsiasi tipo di errore @tab @minus{}1
@end multitable
@end float
@end table
A partire dalla versione di agosto 2018, BWK @command{awk} si comporta
come @command{gawk} per il codice di ritorno della chiamata @code{system()}.
@sidebar Controllare la bufferizzazione dell'output con @code{system()}
@cindex buffer @subentry scrivere su disco un
@cindex bufferizzazione @subentry dell'input/output
@cindex output @subentry bufferizzazione
@cindex bufferizzazione @subentry dell'output
La funzione @code{fflush()} consente un controllo esplicito sulla
bufferizzazione dell'output per singoli file e @dfn{pipe}.
Tuttavia, il suo utilizzo non @`e portabile su molte delle meno recenti
implementazioni di @command{awk}. Un metodo alternativo per forzare la
scrittura dell'output @`e una chiamata a
@code{system()} che abbia come argomento la stringa nulla:
@example
system("") # scrive l'output su disco
@end example
@noindent
@command{gawk} tratta questo uso della funzione @code{system()} come un
caso speciale, e si guarda bene dall'invocare la shell (o un altro
interprete di comandi) con un comando nullo.
Quindi, con @command{gawk}, questa maniera di procedere non @`e solo utile,
ma @`e anche efficiente.
Questo metodo dovrebbe funzionare anche con
altre implementazioni di @command{awk}, ma non @`e detto che eviti una
invocazione non necessaria della shell. (Altre implementazioni potrebbero
limitarsi a forzare la scrittura del buffer associato con lo
standard output, e non necessariamente di tutto l'output bufferizzato.)
Avendo in mente le attese di un programmatore, sarebbe sensato che
@code{system()} forzi la scrittura su disco di tutto l'output disponibile.
Il programma seguente:
@example
BEGIN @{
print "prima riga stampata"
system("echo system echo")
print "seconda riga stampata"
@}
@end example
@noindent
deve stampare:
@example
prima riga stampata
system echo
seconda riga stampata
@end example
@noindent
e non:
@example
system echo
prima riga stampata
seconda riga stampata
@end example
Se @command{awk} non forzasse la scrittura dei suoi buffer prima di
invocare @code{system()}, l'output sarebbe quest'ultimo (quello non voluto).
@end sidebar
@node Funzioni di tempo
@subsection Funzioni per gestire marcature temporali
@cindex funzioni @subentry di tempo
@cindex marcature temporali
@cindex data e ora @subentry @seealso{marcature temporali}
@cindex @dfn{log} (registro) @subentry file di @subentry marcature temporali nei
@cindex registro (@dfn{log}) @subentry file di @subentry marcature temporali nel
@cindex file @subentry di registro (@dfn{log}) @subentry marcature temporali nei
@cindex @command{gawk} @subentry data e ora (marcature temporali)
@cindex POSIX @command{awk} @subentry marcature temporali
I programmi @command{awk} sono frequentemente usati per elaborare file di
registro [file con estensione .log], che contengono l'informazione sulla data e
l'ora (marcatura temporale) in cui un particolare record @`e stato registrato sul log.
Molti programmi registrano questa informazione nel formato restituito
dalla chiamata di sistema @code{time()}, la quale misura il numero di secondi
trascorsi a partire da una certa data iniziale (Epoca). Nei sistemi aderenti
allo standard POSIX, questo @`e il numero di secondi a partire dal primo gennaio
1970, ora di Greenwich (1970-01-01 00:00:00 UTC), senza includere i secondi
@ifclear FOR_PRINT
@iftex
intercalari.@footnote{@xrefIl{Glossario},
@end iftex
@ifnottex
intercalari.@footnote{@xref{Glossario},
@end ifnottex
in particolare le voci ``Epoca'' e ``UTC.''}
@end ifclear
@ifset FOR_PRINT
intercalari.
@end ifset
Tutti i sistemi noti aderenti allo standard POSIX gestiscono le marcature
temporali da 0 fino a
@iftex
@math{2^{31} - 1},
@end iftex
@ifinfo
2^31 - 1,
@end ifinfo
@ifnottex
@ifnotinfo
2@sup{31} @minus{} 1,
@end ifnotinfo
@end ifnottex
il che @`e sufficiente per rappresentare date e ore fino a inizio 2038
(2038-01-19 03:14:07 UTC). Molti sistemi supportano una maggiore estensione
di date, compresi dei valori negativi per rappresentare delle date
anteriori all'Epoca.
@cindex @command{date} (programma di utilit@`a GNU)
@cindex programma di utilit@`a GNU @subentry @command{date}
@cindex tempo @subentry ottenerlo
Per facilitare l'elaborazione di tali file di registro, e per produrre
dei rapporti utili, @command{gawk} prevede le seguenti funzioni per
lavorare con le marcature temporali. Si tratta di estensioni @command{gawk};
non sono previste nello standard POSIX.@footnote{Il comando di utilit@`a GNU
@command{date} pu@`o fare anche molte delle cose qui descritte. Pu@`o essere
preferibile usarlo per semplici operazioni relative a data e ora in semplici
script della shell.} Tuttavia, anche versioni recenti di @command{mawk}
(@pxref{Altre versioni}) prevedono queste funzioni. I parametri opzionali
sono racchiusi tra parentesi quadre ([ ]):
@c @asis for docbook
@table @asis
@item @code{mktime(@var{specifiche_data}} [@code{, @var{utc-flag}} ]@code{)}
@cindexgawkfunc{mktime}
@cindex generare data e ora
Trasforma @var{specifiche_data} in una marcatura temporale nello stesso formato
restituito da @code{systime()}. @`E simile alla funzione omonima
in ISO C. L'argomento, @var{specifiche_data}, @`e una stringa della forma
@w{@code{"@var{AAAA} @var{MM} @var{GG} @var{HH} @var{MM} @var{SS} [@var{DST}]"}}.
La stringa consiste di sei o sette numeri che rappresentano,
rispettivamente,
l'anno in quattro cifre, 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,@footnote{Occasionalmente ci sono dei
minuti in un anno con un secondo intercalare, il che spiega perch@'e i
secondi possono arrivare fino a 60.}
e un'indicazione opzionale relativa all'ora legale.
I valori di questi numeri possono non essere negli intervalli specificati; per
esempio, un'ora di @minus{}1 sta a indicare 1 ora prima di mezzanotte.
Viene adottato il calendario gregoriano con l'origine posta all'anno zero,
con l'anno 0 che viene prima dell'anno 1 e l'anno @minus{}1 che viene prima
dell'anno 0. Se il flag @var{utc-flag} @`e specificato ed @`e diverso da zero
e dalla stringa nulla, si suppone che l'ora sia quella del fuso orario UTC;
altrimenti l'ora @`e considerata essere quella del fuso orario locale. Se
l'indicatore @var{DST}
dell'ora legale @`e positivo, si presuppone che l'ora sia quella
legale; se @`e 0, l'ora considerata @`e quella di Greenwich (standard time); se
invece @`e negativo (questo @`e il default), @code{mktime()} tenta di
determinare se @`e in vigore l'ora legale o no, nel momento specificato.
Se @var{specifiche_data} non contiene elementi in numero sufficiente, o se
la data e ora risultante sono fuori dall'intervallo previsto,
@code{mktime()} restituisce @minus{}1.
@cindex @command{gawk} @subentry vettore @subentry @code{PROCINFO} in
@cindex @code{PROCINFO} (vettore)
@cindex vettore @subentry @code{PROCINFO}
@item @code{strftime(}[@var{formato} [@code{,} @var{data_e_ora} [@code{,} @var{utc}] ] ]@code{)}
@cindexgawkfunc{strftime}
@cindex formato @subentry stringa @subentry marcature temporali
@cindex formato @subentry stringa @subentry data e ora
@cindex data e ora @subentry formato stringa
@cindex marcature temporali @subentry formato stringa
Formatta la data e ora specificata da @var{data_e_ora} in base alle indicazioni
contenute nella stringa @var{formato} e restituisce il risultato.
@`E simile alla funzione omonima in ISO C.
Se @var{utc} @`e presente ed @`e diverso da zero o dalla stringa nulla,
il valore @`e formattato come UTC (Tempo Coordinato Universale,
gi@`a noto come GMT o Tempo Medio di Greenwich).
Altrimenti, il valore @`e formattato per il fuso orario locale.
La stringa @var{data_e_ora} @`e nello stesso formato del valore restituito
dalla funzione @code{systime()}. Se non si specifica l'argomento
@var{data_e_ora}, @command{gawk} usa l'ora del giorno corrente per la
formattazione.
Omettendo l'argomento @var{formato}, @code{strftime()} usa
il valore di @code{PROCINFO["strftime"]} come stringa di formattazione
(@pxref{Variabili predefinite}).
Il valore di default della stringa @`e
@code{@w{"%a %b %e %H:%M:%S %Z %Y"}}. Questa stringa di formattazione
produce lo stesso output del programma di utilit@`a equivalente
@command{date}.
Si pu@`o assegnare un nuovo valore a @code{PROCINFO["strftime"]} per
modificare la formattazione di default; si veda
la lista che segue per le varie direttive di formattazione.
@item @code{systime()}
@cindexgawkfunc{systime}
@cindex marcature temporali
@cindex data e ora @subentry @seealso{marcature temporali}
@cindex data e ora @subentry corrente del sistema
Restituisce l'ora corrente come numero di secondi a partire dall'Epoca
del sistema. Sui sistemi aderenti allo standard POSIX, questo @`e il numero
di secondi trascorsi a partire dal primo gennaio 1970, ora di Greenwich
(1970-01-01 00:00:00 UTC), senza includere i secondi intercalari.
@end table
La funzione @code{systime()} consente di confrontare una marcatura temporale
in un file di registro con la data e ora correnti. In particolare, @`e facile
determinare quanto tempo prima un particolare record @`e stato registrato.
@`E anche possibile produrre record di registro usando il formato
``secondi a partire dall'Epoca''.
@cindex conversione @subentry di date in marcature temporali
@cindex date @subentry conversione in marcature temporali
@cindex marcature temporali @subentry conversione date nelle
La funzione @code{mktime()} consente di convertire una rappresentazione in
forma testuale di una data e ora in una marcatura temporale.
Questo semplifica i confronti prima/dopo tra differenti date e ore, in
particolare quando si abbia a che fare con date e ore provenienti da una
fonte esterna, come un file di registro.
La funzione @code{strftime()} permette di trasformare facilmente una marcatura
temporale in un'informazione intelligibile. @`E analoga come tipo alla funzione
@code{sprintf()} (@pxref{Funzioni per stringhe}), nel senso che copia
letteralmente ci@`o che non @`e una specifica di formato nella stringa che viene
restituita, mentre sostituisce i valori di data e ora a seconda delle
specifiche di formato contenute nella stringa @var{formato}.
@cindex specificatori di formato @subentry funzione @code{strftime()} di @command{gawk}
@cindex formato @subentry specificatori di @subentry funzione @code{strftime()} di @command{gawk}
Per @code{strftime()} lo standard
1999 ISO C@footnote{Sfortunatamente,
non tutte le funzioni @code{strftime()} dei vari sistemi operativi
ammettono tutte le conversioni qui elencate.}
consente le seguenti specifiche di formattazione delle date:
@table @code
@item %a
Il nome abbreviato del giorno della settimana nella lingua locale.
@item %A
Il nome completo del giorno della settimana nella lingua locale.
@item %b
Il nome abbreviato del mese dell'anno nella lingua locale.
@item %B
Il nome completo del mese dell'anno nella lingua locale.
@item %c
Il formato ``appropriato'' della rappresentazione della data e ora
nella lingua locale.
(Questo @`e @samp{%A %B %d %T %Y} per la localizzazione @code{"C"}.)
@item %C
La parte che designa il secolo nell'anno corrente.
Si ottiene dividendo per 100 l'anno, e
troncando verso il basso
all'intero pi@`u vicino.
@item %d
Il giorno del mese come numero decimale (01--31).
@item %D
Equivale a specificare @samp{%m/%d/%y}.
@item %e
Il giorno del mese, preceduto da uno spazio se di tratta di una cifra sola.
@item %F
Equivale a specificare @samp{%Y-%m-%d}.
Questo @`e il formato ISO 8601 della data.
@item %g
L'anno (ultime due cifre) ricavato prendendo il resto della divisione per 100
dell'anno a cui appartiene la settimana, secondo ISO 8601, come numero decimale
(00--99). Per esempio, il primo gennaio 2012, fa parte della settimana 53 del
2011. Quindi, l'anno relativo al numero di settimana ISO di quella data @`e 2011
(ossia 11), anche se la data in s@'e @`e nel 2012. Analogamente, il 31 dicembre
2012, @`e nella prima settimana del 2013. Quindi, l'anno relativo al numero di
settimana ISO di quella data @`e 2013 (ossia 13), anche se la data in s@'e @`e nel
2012.
@item %G
L'anno intero relativo al numero di settimana ISO, come numero decimale.
@item %h
Equivalente a @samp{%b}.
@item %H
L'ora (in un orologio a 24 ore) come numero decimale (00--23).
@item %I
L'ora (in un orologio a 12 ore) come numero decimale (01--12).
@item %j
Il giorno dell'anno come numero decimale (001--366).
@item %m
Il mese come numero decimale (01--12).
@item %M
Il minuto come numero decimale (00--59).
@item %n
Un carattere di ritorno a capo (ASCII LF).
@item %p
L'equivalente nella lingua locale delle designazioni AM/PM
(mattino/pomerigggio) associate a un orologio a 12 ore.
@item %r
L'ora locale nel formato a 12 ore.
(Questo @`e @samp{%I:%M:%S %p} nella localizzazione @code{"C"}.)
@item %R
Equivalente a specificare @samp{%H:%M}.
@item %S
Il secondo come numero decimale (00--60).
@item %t
Un carattere di tabulazione [TAB].
@item %T
Equivalente a specificare @samp{%H:%M:%S}.
@item %u
Il numero del giorno della settimana come numero decimale (1--7).
Luned@`{@dotless{i}} @`e il giorno numero 1.
@item %U
Il numero di settimana dell'anno (con la prima domenica dell'anno presa
come primo giorno della prima settimana) come numero decimale (00--53).
@cindex ISO @subentry 8601 (standard per marcature temporali)
@item %V
Il numero di settimana dell'anno (con il primo luned@`{@dotless{i}} dell'anno preso
come primo giorno della prima settimana) come numero decimale (01--53).
Il metodo per determinare il numero di settimana @`e quello specificato
dallo standard ISO 8601.
(In pratica: se la settimana che contiene il primo gennaio ha quattro o
pi@`u giorni nel nuovo anno, allora
@`e la settimana numero uno; altrimenti @`e l'ultima settimana
[52 o 53] dell'anno
precedente, e la settimana successiva @`e la settimana numero uno.)
@item %w
Il giorno della settimana come numero decimale (0--6).
Domenica @`e il giorno zero.
@item %W
Il numero di settimana dell'anno (con il primo luned@`{@dotless{i}} come primo giorno
della settimana numero uno)
come numero decimale (00--53).
@item %x
Il formato ``appropriato'' della rappresentazione della data
nella lingua locale.
(Questo @`e @samp{%A %B %d %Y} nella localizzazione @code{"C"}.)
@item %X
Il formato ``appropriato'' della rappresentazione della data.
(Questo @`e @samp{%T} nella localizzazione @code{"C"}.)
@item %y
L'anno modulo 100 (le ultime due cifre) come numero decimale (00--99).
@item %Y
L'anno come numero decimale (p.es., 2015).
@c @cindex RFC 822
@c @cindex RFC 1036
@item %z
La differenza di fuso orario [rispetto all'ora di Greenwich] in formato
@samp{+@var{OOMM}} (p.es., il
formato necessario per produrre intestazioni di data conformi agli standard
RFC 822/RFC 1036).
@item %Z
Il nome o l'abbreviazione della zona di fuso orario (@dfn{time zone}); se il fuso
orario non @`e determinabile, @`e impostata alla stringa nulla.
@item %Ec %EC %Ex %EX %Ey %EY %Od %Oe %OH
@itemx %OI %Om %OM %OS %Ou %OU %OV %Ow %OW %Oy
``notazioni alternative'' di specifica
in cui solo la seconda lettera (@samp{%c}, @samp{%C} e cos@`{@dotless{i}} via) @`e
significativa.@footnote{Se questo risulta incomprensibile, non @`e il
caso di preoccuparsi; queste notazioni hanno lo scopo di facilitare
la ``internazionalizzazione'' dei programmi.
Altre funzionalit@`a di internazionalizzazione sono descritte in
@ref{Internazionalizzazione}.}
(Queste facilitano la compatibilit@`a con il programma di utilit@`a
POSIX @command{date}.)
@item %%
Un singolo carattere @samp{%}.
@end table
Se uno specificatore di conversione non @`e tra quelli elencati sopra, il
comportamento @`e indefinito.@footnote{Questo @`e perch@'e ISO C lascia
indefinito il comportamento della versione C di @code{strftime()} e
@command{gawk} usa la versione di sistema di @code{strftime()},
se disponibile.
Tipicamente, lo specificatore di conversione "non previsto" non appare
nella stringa risultante, o appare cos@`{@dotless{i}} come @`e scritto.}
Per sistemi che non aderiscono completamente agli standard
@command{gawk} utilizza una copia di
@code{strftime()} dalla libreria C di GNU.
Sono disponibili tutte le specifiche di formato sopra elencate.
Se la detta versione @`e
usata per compilare @command{gawk} (@pxref{Installazione}),
sono disponibili anche le seguenti ulteriori specifiche di formato:
@table @code
@item %k
L'ora (in un orologio a 24 ore) come numero decimale (0--23).
I numeri di una sola cifra sono preceduti da uno spazio bianco.
@item %l
L'ora (in un orologio a 12 ore) come numero decimale (1--12).
I numeri di una sola cifra sono preceduti da uno spazio bianco.
@ignore
@item %N
Il nome dell'``Imperatore/Era''.
Equivalente a @samp{%C}.
@item %o
L'anno dell'``Imperatore/Era''.
Equivalente a @samp{%y}.
@end ignore
@item %s
L'ora espressa in numero di secondi a partire dall'Epoca.
@ignore
@item %v
La data in formato VMS (p.es., @samp{20-JUN-1991}).
@end ignore
@end table
In aggiunta a ci@`o, le notazioni alternative sono riconosciute, ma al
loro posto sono usate quelle normali.
@cindex @code{date} (programma di utilit@`a POSIX)
@cindex programma di utilit@`a POSIX @subentry @code{date}
@cindex POSIX @command{awk} @subentry @code{date} (programma di utilit@`a)
Il seguente esempio @`e un'implementazione @command{awk} del
programma di utilit@`a POSIX @command{date}.
Normalmente, il programma di utilit@`a @command{date} stampa la
data e l'ora corrente nel formato ben noto. Tuttavia, se si
specifica al comando un argomento che inizia con un @samp{+}, @command{date}
copia i caratteri che non sono specifiche di formato nello standard output
e interpreta l'ora corrente secondo gli specificatori di formato
contenuti nella stringa. Per esempio:
@example
$ @kbd{date '+Oggi @`e %A, %d %B %Y.'}
@print{} Oggi @`e luned@`{@dotless{i}}, 22 settembre 2014.
@end example
Ecco la versione @command{gawk} del programma di utilit@`a @command{date}.
@`E all'interno di uno @dfn{script} di shell
per gestire l'opzione @option{-u},
che richiede che @command{date} sia eseguito come se il fuso orario
fosse impostato a UTC:
@example
#! /bin/sh
#
# date --- simula il comando POSIX 'date'
case $1 in
-u) TZ=UTC0 # usare UTC
export TZ
shift ;;
esac
gawk 'BEGIN @{
formato = PROCINFO["strftime"]
codice_di_ritorno = 0
if (ARGC > 2)
codice_di_ritorno = 1
else if (ARGC == 2) @{
formato = ARGV[1]
if (formato ~ /^\+/)
formato = substr(formato, 2) # togli il + iniziale
@}
print strftime(formato)
exit codice_di_ritorno
@}' "$@@"
@end example
@node Funzioni a livello di bit
@subsection Funzioni per operazioni di manipolazione bit
@cindex bit @subentry funzioni per la manipolazione di
@cindex manipolazione di bit @subentry funzioni per la
@cindex funzioni @subentry per la manipolazione di bit
@cindex bit @subentry operazioni sui
@cindex AND (operazione sui bit)
@cindex operazione sui bit @subentry AND
@cindex OR (operazione sui bit)
@cindex operazione sui bit @subentry OR
@cindex XOR (operazione sui bit)
@cindex operazione sui bit @subentry XOR
@cindex operazione sui bit
@quotation
@i{Io posso spiegarlo per te, ma non posso capirlo per te.}
@author Anonimo
@end quotation
Molti linguaggi consentono di eseguire operazioni @dfn{bit a bit}
su due numeri interi. In altre parole, l'operazione @`e eseguita
su ogni successiva coppia di bit presi da ognuno dei due operandi.
Tre operazioni comuni sono AND, OR e XOR bit a bit.
Queste operazioni sono descritte nella @ref{table-bitwise-ops}.
@c 11/2014: Postprocessing turns the docbook informaltable
@c into a table. Hurray for scripting!
@float Tabella,table-bitwise-ops
@caption{Operazioni a livello di bit}
@ifnottex
@ifnotdocbook
@display
@verbatim
Operatore booleano
| AND | OR | XOR
|---+---+---+---+---+---
Operandi | 0 | 1 | 0 | 1 | 0 | 1
----------+---+---+---+---+---+---
0 | 0 0 | 0 1 | 0 1
1 | 0 1 | 1 1 | 1 0
@end verbatim
@end display
@end ifnotdocbook
@end ifnottex
@tex
\centerline{
\vbox{\bigskip % space above the table (about 1 linespace)
% Because we have vertical rules, we can't let TeX insert interline space
% in its usual way.
\offinterlineskip
\halign{\strut\hfil#\quad\hfil % operands
&\vrule#&\quad#\quad % rule, 0 (of and)
&\vrule#&\quad#\quad % rule, 1 (of and)
&\vrule# % rule between and and or
&\quad#\quad % 0 (of or)
&\vrule#&\quad#\quad % rule, 1 (of of)
&\vrule# % rule between or and xor
&\quad#\quad % 0 of xor
&\vrule#&\quad#\quad % rule, 1 of xor
\cr
&\omit&\multispan{11}\hfil\bf Operatore booleano\hfil\cr
\noalign{\smallskip}
& &\multispan3\hfil AND\hfil&&\multispan3\hfil OR\hfil
&&\multispan3\hfil XOR\hfil\cr
\bf Operandi&&0&&1&&0&&1&&0&&1\cr
\noalign{\hrule}
\omit&height 2pt&&\omit&&&&\omit&&&&\omit\cr
\noalign{\hrule height0pt}% without this the rule does not extend; why?
0&&0&\omit&0&&0&\omit&1&&0&\omit&1\cr
1&&0&\omit&1&&1&\omit&1&&1&\omit&0\cr
}}}
@end tex
@docbook
Operatore booleano
AND
OR
XOR
Operandi
0
1
0
1
0
1
0
0
0
0
1
0
1
1
0
1
1
1
1
0
@end docbook
@end float
@cindex bit @subentry complemento a livello di
@cindex complemento sui bit
Come si vede, il risultato di un'operazione di AND @`e 1 solo quando
@emph{entrambi} i bit sono 1.
Il risultato di un'operazione di OR @`e 1 se @emph{almeno un} bit @`e 1.
Il risultato di un'operazione di XOR @`e 1 se l'uno o l'altro
bit @`e 1, ma non tutti e due.
La successiva operazione @`e il @dfn{complemento}; il complemento di 1 @`e 0 e
il complemento di 0 @`e 1. Quindi, quest'operazione ``inverte'' tutti i bit
di un dato valore.
@cindex bit @subentry spostamento di
@cindex spostamento a sinistra @subentry bit a bit
@cindex spostamento a destra @subentry bit a bit
@cindex spostamento @subentry bit a bit
Infine, due altre operazioni comuni consistono nello spostare i bit
a sinistra o a destra.
Per esempio, se si ha una stringa di bit @samp{10111001} e la si sposta
a destra di tre bit, si ottiene @samp{00010111}.@footnote{Questo esempio
presuppone che degli zeri riempiano le posizioni a sinistra.
Per @command{gawk}, @`e sempre
cos@`{@dotless{i}}, ma in alcuni linguaggi @`e possibile che le posizioni a sinistra
siano riempite con degli uno.}
Partendo nuovamente da @samp{10111001} e spostandolo a sinistra di tre
bit, si ottiene @samp{11001000}. La lista seguente descrive
le funzioni predefinite di @command{gawk} che rendono disponibili
le operazioni a livello di bit.
I parametri opzionali sono racchiusi tra parentesi quadre ([ ]):
@cindex @command{gawk} @subentry operazioni sui bit in
@table @asis
@cindexgawkfunc{and}
@cindex AND (operazione sui bit)
@cindex operazione sui bit @subentry AND
@item @code{and(}@var{v1}@code{,} @var{v2} [@code{,} @dots{}]@code{)}
Restituisce l'AND bit a bit degli argomenti.
Gli argomenti devono essere almeno due.
@cindexgawkfunc{compl}
@cindex complemento sui bit
@cindex operazione sui bit @subentry complemento
@item @code{compl(@var{val})}
Restituisce il complemento bit a bit di @var{val}.
@cindexgawkfunc{lshift}
@item @code{lshift(@var{val}, @var{contatore})}
Restituisce il valore di @var{val}, spostato a sinistra di
@var{contatore} bit.
@cindexgawkfunc{or}
@cindex OR (operazione sui bit)
@cindex operazione sui bit @subentry OR
@item @code{or(}@var{v1}@code{,} @var{v2} [@code{,} @dots{}]@code{)}
Restituisce l'OR bit a bit degli argomenti.
Gli argomenti devono essere almeno due.
@cindexgawkfunc{rshift}
@item @code{rshift(@var{val}, @var{contatore})}
Restituisce il valore di @var{val}, spostato a destra
di @var{contatore} bit.
@cindexgawkfunc{xor}
@cindex XOR (operazione sui bit)
@cindex operazione sui bit @subentry XOR
@item @code{xor(}@var{v1}@code{,} @var{v2} [@code{,} @dots{}]@code{)}
Restituisce il XOR bit a bit degli argomenti.
Gli argomenti devono essere almeno due.
@end table
@quotation ATTENZIONE
A partire dalla versione di @command{gawk} @value{PVERSION} 4.2, gli operandi
negativi non sono consentiti per nessuna di queste funzioni. Un operando
negativo produce un errore fatale. Si veda la nota a lato
``Attenzione. Non @`e tutto oro quel che luccica!'' per maggiori informazioni sul perch@'e.
@end quotation
Ecco una funzione definita dall'utente (@pxref{Funzioni definite dall'utente})
che illustra l'uso di queste funzioni:
@cindex @code{bits2str()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{bits2str()}
@cindex @code{testbits.awk} (programma)
@cindex programma @subentry @code{testbits.awk}
@example
@group
@c file eg/lib/bits2str.awk
# bits2str --- decodifica un numero intero in una serie di 0/1 leggibili
function bits2str(byte, dati, maschera)
@{
if (byte == 0)
return "0"
maschera = 1
for (; byte != 0; stringa = rshift(stringa, 1))
dati = (and(byte, maschera) ? "1" : "0") dati
while ((length(dati) % 8) != 0)
dati = "0" dati
return dati
@}
@c endfile
@end group
@c this is a hack to make testbits.awk self-contained
@ignore
@c file eg/prog/testbits.awk
# bits2str --- turn an integer into readable ones and zeros
function bits2str(bits, data, mask)
@{
if (bits == 0)
return "0"
mask = 1
for (; bits != 0; bits = rshift(bits, 1))
data = (and(bits, mask) ? "1" : "0") data
while ((length(data) % 8) != 0)
data = "0" data
return data
@}
@c endfile
@end ignore
@c file eg/prog/testbits.awk
BEGIN @{
printf "123 = %s\n", bits2str(123)
printf "0123 = %s\n", bits2str(0123)
printf "0x99 = %s\n", bits2str(0x99)
comp = compl(0x99)
printf "compl(0x99) = %#x = %s\n", comp, bits2str(comp)
shift = lshift(0x99, 2)
printf "lshift(0x99, 2) = %#x = %s\n", shift, bits2str(shift)
shift = rshift(0x99, 2)
printf "rshift(0x99, 2) = %#x = %s\n", shift, bits2str(shift)
@}
@c endfile
@end example
@noindent
Questo programma produce il seguente output quando viene eseguito:
@example
$ @kbd{gawk -f testbits.awk}
@print{} 123 = 01111011
@print{} 0123 = 01010011
@print{} 0x99 = 10011001
@print{} compl(0x99) = 0x3fffffffffff66 =
@print{} 00111111111111111111111111111111111111111111111101100110
@print{} lshift(0x99, 2) = 0x264 = 0000001001100100
@print{} rshift(0x99, 2) = 0x26 = 00100110
@end example
@cindex conversione @subentry da stringa a numero
@cindex stringa @subentry conversione
@cindex numeri @subentry conversione in stringhe
@cindex conversione @subentry da numero a stringa
@cindex numeri @subentry visti come stringhe di bit
La funzione @code{bits2str()} trasforma un numero binario in una stringa.
Inizializzando @code{maschera} a uno otteniamo
un valore binario in cui il bit pi@`u a destra @`e impostato a
uno. Usando questa maschera,
la funzione continua a controllare il bit pi@`u a destra.
l'operazione di AND tra la maschera e il valore indica se il
bit pi@`u a destra @`e uno oppure no. Se questo @`e il caso, un @code{"1"}
@`e concatenato all'inizio della stringa.
Altrimenti, @`e concatenato uno @code{"0"}.
Il valore @`e quindi spostato a destra di un bit e il ciclo continua
finch@'e non ci sono pi@`u bit.
Se il valore iniziale @`e zero, viene restituito semplicemente uno @code{"0"}.
Altrimenti, alla fine, al valore ottenuto vengono aggiunti degli zeri a
sinistra, per arrivare a stringhe
di lunghezza multipla di 8, ossia contenenti un numero intero di byte.
Questo @`e tipico dei computer moderni.
Il codice principale nella regola @code{BEGIN} mostra la differenza tra
i valori decimale e ottale dello stesso numero.
(@pxref{Numeri non-decimali}),
e poi mostra i risultati delle funzioni
@code{compl()}, @code{lshift()} e @code{rshift()}.
@sidebar Attenzione. Non @`e tutto oro quel che luccica!
In altri linguaggi, le operazioni "bit a bit" sono eseguite su valori interi,
non su valori in virgola mobile. Come regola generale, tali operazioni
funzionano meglio se eseguite su interi senza segno.
@command{gawk} tenta di trattare gli argomenti delle funzioni
"bit a bit" come interi senza segno. Per questo motivo, gli argomenti negativi
provocano un errore fatale.
In una normale operazione, per tutte queste funzioni, prima il valore in virgola
mobile a doppia precisione viene convertito nel tipo intero senza segno di C
pi@`u ampio, poi viene eseguita l'operazione "bit a bit". Se il risultato non
pu@`o essere rappresentato esattamente come un tipo @code{double} di C,
vengono rimossi i bit iniziali diversi da zero uno alla volta finch@'e
non sono rappresentati esattamente. Il risultato @`e poi nuovamente convertito
in un tipo @code{double} di C.@footnote{Per essere pi@`u chiari,
la conseguenza @`e che @command{gawk} pu@`o memorizzare solo un determinato
intervallo di valori interi; i numeri al di fuori di questo intervallo vengono
ridotti per rientrare all'interno dell'intervallo.}
Comunque, quando si usa il calcolo con precisione arbitraria con l'opzione
@option{-M} (@pxref{Calcolo con precisione arbitraria}), il risultato pu@`o
essere diverso. Questo @`e particolarmente evidente con la funzione @code{compl()}:
@example
$ @kbd{gawk 'BEGIN @{ print compl(42) @}'}
@print{} 9007199254740949
$ @kbd{gawk -M 'BEGIN @{ print compl(42) @}'}
@print{} -43
@end example
Quel che avviene diventa chiaro quando si stampano i risultati
in notazione esadecimale:
@example
$ @kbd{gawk 'BEGIN @{ printf "%#x\n", compl(42) @}'}
@print{} 0x1fffffffffffd5
$ @kbd{gawk -M 'BEGIN @{ printf "%#x\n", compl(42) @}'}
@print{} 0xffffffffffffffd5
@end example
Quando si usa l'opzione @option{-M}, nel dettaglio, @command{gawk} usa
gli interi a precisione arbitraria di GNU MP che hanno almeno 64 bit di precisione.
Quando non si usa l'opzione @option{-M}, @command{gawk} memorizza i valori
interi come regolari valori in virgola mobile con doppia precisione, che
mantengono solo 53 bit di precisione. Inoltre, la libreria GNU MP tratta
(o almeno sembra che tratti) il bit iniziale come un bit con segno;
cos@`{@dotless{i}} il
risultato con @option{-M} in questo caso @`e un numero negativo.
In breve, usare @command{gawk} per qualsiasi tipo di operazione "bit a bit",
tranne le pi@`u semplici, probabilmente @`e una cattiva idea; @dfn{caveat emptor}!
@end sidebar
@node Funzioni per i tipi
@subsection Funzioni per conoscere il tipo di una variabile
@command{gawk} prevede due funzioni che permettono di conoscere
il tipo di una variabile.
Questo @`e necessario per scrivere del codice che visiti ogni elemento di un
vettore di vettori
(@pxref{Vettori di vettori}) e in altri contesti.
@table @code
@cindexgawkfunc{isarray}
@cindex scalare o vettore
@item isarray(@var{x})
Restituisce il valore 'vero' se @var{x} @`e un vettore. Altrimenti, restituisce
'falso'.
@cindexgawkfunc{typeof}
@cindex variabili @subentry tipi di
@cindex tipo di una variabile
@item typeof(@var{x})
Restituisce una delle stringhe seguenti, a seconda del tipo di @var{x}:
@c nested table
@table @code
@item "array"
@var{x} @`e un vettore.
@item "regexp"
@var{x} @`e una @dfn{regexp} fortemente tipizzata
(@pxref{Costanti @dfn{regexp} forti}).
@item "number"
@var{x} @`e un numero.
@item "string"
@var{x} @`e una stringa.
@item "strnum"
@var{x} @`e un numero che ha avuto origine da un input dell'utente,
come un campo o il risultato di una chiamata a @code{split()}.
(Cio@`e, @var{x} ha l'attributo @dfn{strnum};
@pxref{Tipi di variabile}.)
@item "unassigned"
@var{x} @`e una variabile scalare a cui non @`e ancora stato assegnato un valore.
Per esempio:
@example
BEGIN @{
# crea a[1] ma non gli attribuisce alcun valore
a[1]
print typeof(a[1]) # non assegnato
@}
@end example
@item "untyped"
@var{x} non @`e stata usata per nulla; pu@`o diventare uno scalare o un
vettore. @`E anche possibile che il tipo sia differente, in differenti
esecuzioni del medesimo programma!
Per esempio:
@example
BEGIN @{
print "all'inizio, typeof(v) = ", typeof(v)
if ("FOO" in ENVIRON)
make_scalar(v)
else
make_array(v)
print "typeof(v) =", typeof(v)
@}
function make_scalar(p, l) @{ l = p @}
function make_array(p) @{ p[1] = 1 @}
@end example
@end table
@end table
@code{isarray()} torna utile in due occasioni. La prima @`e quando
si visita un vettore multidimensionale: si pu@`o stabilire se un elemento @`e
un vettore oppure no. La seconda @`e all'interno del corpo di una funzione
definita dall'utente (argomento non ancora trattato;
@pxref{Funzioni definite dall'utente}), per determinare se un parametro
@`e un vettore oppure no.
@quotation NOTA
Anche se si pu@`o usare @code{isarray()} a livello globale per controllare le
variabili il farlo non ha alcun senso. Si suppone infatti che chi scrive il
programma sappia se una variabile @`e un vettore oppure no.
@end quotation
La funzione @code{typeof()} @`e generale; consente di determinare
se una variabile o un parametro di funzione @`e uno scalare, (numero,
stringa o @dfn{regexp} fortemente tipizzata), oppure un vettore.
Normalmente, se si passa una variabile che non @`e stata mai usata
a una funzione predefinita, la variabile stessa viene creata come
variabile scalare di tipo non ancora assegnato (unassigned).
Tuttavia, se si chiama @code{isarray()} e @code{typeof()} queste
funzioni non cambiano gli argomenti che vengono passati loro da
non ancora tipizzati (untyped) a non ancora assegnati (unassigned).
@node Funzioni di internazionalizzazione
@subsection Funzioni per tradurre stringhe
@cindex @command{gawk} @subentry funzioni di traduzione di stringhe
@cindex funzioni @subentry di traduzione di stringhe
@cindex traduzione di stringhe @subentry funzioni di
@cindex internazionalizzazione
@cindex programmi @command{awk} @subentry internazionalizzare
@command{gawk} prevede strumenti per internazionalizzare i programmi
@command{awk}.
Questi sono costituiti dalle funzioni descritte nella lista seguente.
Le descrizioni sono volutamente concise.
@xref{Internazionalizzazione},
per un'esposizione completa.
I parametri opzionali sono racchiusi tra parentesi quadre ([ ]):
@table @asis
@cindexgawkfunc{bindtextdomain}
@cindex impostare @subentry directory con catalogo messaggi tradotti
@cindex messaggi tradotti @subentry impostare directory con catalogo
@item @code{bindtextdomain(@var{directory}} [@code{,} @var{dominio}]@code{)}
Imposta la directory in cui
@command{gawk} trova i file di traduzione dei messaggi, nel caso in cui
non siano o non possano essere messi nelle directory ``standard''
(p.es., durante la fase di test di un programma).
Restituisce la directory alla quale @var{dominio} @`e ``connesso.''
Il default per @var{dominio} @`e il valore di @code{TEXTDOMAIN}.
Se @var{directory} @`e la stringa nulla (@code{""}),
@code{bindtextdomain()} restituisce la connessione corrente per il
@var{dominio} dato.
@cindexgawkfunc{dcgettext}
@cindex traduzione di stringhe
@item @code{dcgettext(@var{stringa}} [@code{,} @var{dominio} [@code{,} @var{categoria}] ]@code{)}
Restituisce la traduzione di @var{stringa} nel
dominio linguistico @var{dominio} per la categoria di localizzazione
@var{categoria}.
Il valore di default per @var{dominio} @`e il valore corrente di @code{TEXTDOMAIN}.
Il valore di default per @var{categoria} @`e @code{"LC_MESSAGES"}.
@cindexgawkfunc{dcngettext}
@item @code{dcngettext(@var{stringa1}, @var{stringa2}, @var{numero}} [@code{,} @var{dominio} [@code{,} @var{categoria}] ]@code{)}
Restituisce la forma plurale usata per @var{numero} nella
traduzione di @var{stringa1} e @var{stringa2} nel dominio di testo
@var{dominio} per la categoria di localizzazione @var{categoria}.
@var{stringa1} @`e la variante al singolare in inglese di un messaggio e
@var{stringa2} @`e la variante al plurare in inglese dello stesso messaggio.
Il valore di default per @var{dominio} @`e il valore corrente di @code{TEXTDOMAIN}.
Il valore di default per @var{categoria} @`e @code{"LC_MESSAGES"}.
@end table
@node Funzioni definite dall'utente
@section Funzioni definite dall'utente
@cindex funzione definita dall'utente
@cindex definite dall'utente @subentry @dfn{Si veda} funzioni definite dall'utente
@cindex utente @subentry funzioni definite dall'
Programmi @command{awk} complessi spesso possono essere semplificati
definendo delle apposite funzioni personali.
Le funzioni definite dall'utente sono richiamate allo stesso modo di quelle
predefinite
(@pxref{Chiamate di funzione}),
ma dipende dall'utente la loro definizione
(cio@`e, dire ad @command{awk} cosa dovrebbero fare queste funzioni).
@menu
* Sintassi delle definizioni:: Come scrivere definizioni e cosa
significano.
* Esempio di funzione:: Un esempio di definizione di
funzione e spiegazione della stessa.
* Chiamata di una funzione:: Chiamare funzioni definite dall'utente.
* Istruzione return:: Specificare il valore che una
funzione restituisce.
* Variabili di tipo dinamico:: Come cambiare tipo a una variabile in
fase di esecuzione del programma.
@end menu
@node Sintassi delle definizioni
@subsection Come scrivere definizioni e cosa significano
@quotation
@i{Risponde al vero affermare che la sintassi di awk per la definizione
di variabili locali @`e semplicemente atroce.}
@author Brian Kernighan
@end quotation
@cindex funzioni @subentry definizione di
@cindex definizione di funzioni
Definizioni di funzioni possono stare in una posizione qualsiasi tra le regole
di un programma @command{awk}. Quindi, la forma generale di un
programma @command{awk} @`e estesa per
permettere l'inclusione di regole @emph{e} la definizione di funzioni
create dall'utente.
Non @`e necessario che la definizione di una funzione sia posta prima
del richiamo della stessa. Questo dipende dal fatto che @command{awk}
legge l'intero programma, prima di iniziare ad eseguirlo.
La definizione di una funzione chiamata @var{nome} @`e simile a questa:
@display
@group
@code{function} @var{nome}@code{(}[@var{lista-parametri}]@code{)}
@code{@{}
@var{corpo-della-funzione}
@code{@}}
@end group
@end display
@cindex nomi @subentry di funzione
@cindex funzioni @subentry nomi di
@cindex limitazioni @subentry nei nomi di funzione
@cindex nomi @subentry di funzione @subentry limitazioni nei
@noindent
Qui, @var{nome} @`e il nome della funzione da definire. Un nome di funzione
valido @`e come un nome di variabile valido: una sequenza di
lettere, cifre e trattini bassi che non inizia con una cifra.
Anche qui, solo le 52 lettere inglesi maiuscole e minuscole possono
essere usate in un nome di funzione.
All'interno di un singolo programma @command{awk}, un dato nome pu@`o essere
usato una sola volta: per una variabile, o per un vettore,
o per una funzione.
@var{lista-parametri} @`e una lista opzionale degli argomenti della funzione
e dei nomi delle variabili locali,
separati da virgole. Quando la funzione viene chiamata,
i nomi degli argomenti sono usati per contenere il valore degli argomenti
passati con la chiamata.
Una funzione non pu@`o avere due parametri con lo stesso nome, e neanche un
parametro con lo stesso nome della funzione stessa.
@quotation ATTENZIONE
Secondo lo standard POSIX, i parametri di funzione
non possono avere lo stesso nome di una delle speciali variabili predefinite
(@pxref{Variabili predefinite}), e un parametro di funzione non pu@`o avere
lo stesso nome di un'altra funzione.
@cindex angolo buio @subentry limitazioni nel nome dei parametri
Non tutte le versioni di @command{awk} applicano
queste limitazioni. @value{DARKCORNER}
@command{gawk} applica solo la prima di queste restrizioni.
Se viene specificata l'opzione @option{--posix} (@pxref{Opzioni}),
anche la seconda restrizione viene applicata.
@end quotation
Le variabili locali si comportano come la stringa vuota
se vengono utilizzate dove @`e richiesto il valore di una stringa,
e valgono zero se utilizzate dove @`e richiesto un valore numerico.
Questo @`e lo stesso comportamento delle variabili regolari a cui non sia
stato ancora assegnato un valore. (Ci sono ulteriori informazioni riguardo
alle variabili locali;
@pxref{Variabili di tipo dinamico}.)
Il @var{corpo-della-funzione} @`e composto da istruzioni @command{awk}.
Questa @`e la parte pi@`u importante della definizione, perch@'e dice quello che
la funzione dovrebbe realmente
@emph{fare}. I nomi di argomento esistono per consentire al corpo della
funzione di gestire gli argomenti;
le variabili locali esistono per consentire al corpo della funzione di
memorizzare dei valori temporanei.
I nomi di argomento non sono sintatticamente distinti da quelli delle
variabili locali. Invece, il numero di argomenti forniti quando la
funzione viene chiamata determina quanti degli argomenti passati sono delle
variabili. Quindi, se tre valori di argomento sono specificati, i primi
tre nomi in @var{lista-parametri}
sono degli argomenti e i rimanenti sono delle variabili locali.
Ne consegue che se il numero di argomenti richiesto non @`e lo stesso in
tutte le chiamate alla funzione, alcuni dei nomi in @var{lista-parametri}
possono essere in alcuni casi degli argomenti e in altri casi
delle variabili locali. Un'altra angolatura da cui guardare questo fatto
@`e che gli argomenti omessi assumono come valore di default la stringa nulla.
@cindex convenzioni di programmazione @subentry nella scrittura di funzioni
@cindex funzioni @subentry convenzioni di programmazione @subentry nella scrittura di
Solitamente, quando si scrive una funzione, si sa quanti nomi si intendono
usare per gli argomenti e quanti si vogliono usare come variabili locali.
@`E una convenzione in uso quella di aggiungere alcuni spazi extra tra gli
argomenti e le variabili locali, per documentare come va utilizzata quella
funzione.
@cindex variabili @subentry nascoste
@cindex nascondere valori di variabile
Durante l'esecuzione del corpo della funzione, gli argomenti e i valori
delle variabili locali
nascondono, o @dfn{oscurano}, qualsiasi variabile dello stesso nome usata
nel resto del programma. Le variabili oscurate non sono accessibili
nel corpo della funzione, perch@'e non c'@`e modo di accedere a esse
mentre i loro nomi sono stati "occupati" dagli argomenti e dalla variabili
locali. Tutte le altre variabili usate nel programma @command{awk}
possono essere accedute o impostate normalmente nel corpo della funzione.
Gli argomenti e le variabili locali esistono solo finch@'e il corpo della
funzione @`e in esecuzione. Una volta che l'esecuzione @`e terminata,
ritornano accessibili le variabili che erano oscurate
durante l'esecuzione della funzione.
@cindex ricorsive @subentry funzioni
@cindex funzioni @subentry ricorsive
Il corpo della funzione pu@`o contenere espressioni che chiamano altre
funzioni. Tali espressioni possono perfino chiamare direttamente, o
indirettamente tramite un'altra funzione, la funzione stessa.
Quando questo succede, la funzione @`e detta @dfn{ricorsiva}.
Il fatto che una funzione richiami se stessa @`e detto @dfn{ricorsione}.
Tutte le funzioni predefinite restituiscono un valore al loro chiamante.
Anche le funzioni definite dall'utente possono farlo, usando
l'istruzione @code{return},
che @`e descritta in dettaglio nella @ref{Istruzione return}.
Molti dei successivi esempi in questa @value{SECTION} usano
l'istruzione @code{return}.
@cindex estensioni comuni @subentry parola chiave @code{func}
@c @cindex @command{awk} language, POSIX version
@c @cindex POSIX @command{awk}
@cindex POSIX @command{awk} @subentry @code{function} (parola chiave)
In molte implementazioni di @command{awk}, compreso @command{gawk},
la parola chiave @code{function} pu@`o essere
abbreviata come @code{func}. @value{COMMONEXT}
Tuttavia, POSIX specifica solo l'uso della parola chiave
@code{function}. Questo ha alcune implicazioni di carattere pratico.
Se @command{gawk} @`e in modalit@`a POSIX-compatibile
(@pxref{Opzioni}), la seguente
istruzione @emph{non} definisce una funzione:
@example
func foo() @{ a = sqrt($1) ; print a @}
@end example
@noindent
Invece, definisce una regola che, per ogni record, concatena il valore
della variabile @samp{func} con il valore restituito dalla funzione @samp{foo}.
Se la stringa risultante @`e diversa dalla stringa nulla, l'azione viene eseguita.
Questo non @`e con ogni probabilit@`a quello che si desidera.
(@command{awk} accetta questo input come
sintatticamente valido, perch@'e le funzioni, nei programmi @command{awk}
possono essere usate prima che siano state definite.@footnote{Questo
programma in realt@`a non verr@`a eseguito, perch@'e @code{foo()} risulter@`a
essere una funzione non definita.})
@cindex portabilit@`a @subentry nella definizione di funzioni
Per essere certi che un programma @command{awk} sia portabile,
va sempre usata la parola chiave
@code{function} per definire una funzione.
@node Esempio di funzione
@subsection Un esempio di definizione di funzione
@cindex esempio @subentry di definizione di funzione
@cindex funzione @subentry esempio di definizione di
Ecco un esempio di funzione definita dall'utente, di nome
@code{stampa_num()}, che
ha come input un numero e lo stampa in un formato specifico:
@example
function stampa_num(numero)
@{
printf "%6.3g\n", numero
@}
@end example
@noindent
Per comprenderne il funzionamento, ecco una regola @command{awk} che usa
la funzione @code{stampa_num()}:
@example
$3 > 0 @{ stampa_num($3) @}
@end example
@noindent
Questo programma stampa, nel nostro formato speciale, tutti i terzi campi
nei record in input che
contengono un numero positivo. Quindi, dato il seguente input:
@example
1.2 3.4 5.6 7.8
9.10 11.12 -13.14 15.16
17.18 19.20 21.22 23.24
@end example
@noindent
questo programma, usando la nostra funzione per formattare i risultati, stampa:
@example
5.6
21.2
@end example
La funzione seguente cancella tutti gli elementi in un vettore
(si ricordi che gli spazi bianchi in soprannumero stanno a indicare
l'inizio della lista delle variabili locali):
@example
@group
function cancella_vettore(a, i)
@{
for (i in a)
delete a[i]
@}
@end group
@end example
Quando si lavora con vettori, @`e spesso necessario cancellare
tutti gli elementi in un vettore e ripartire con una nuova lista di elementi
(@pxref{Cancellazione}).
Invece di dover ripetere
questo ciclo ogni volta che si deve cancellare
un vettore, un programma pu@`o limitarsi a effettuare una chiamata
a @code{cancella_vettore()}.
(Questo garantisce la portabilit@`a. L'uso di @samp{delete @var{vettore}}
per cancellare
il contenuto di un intero vettore @`e un'aggiunta relativamente
recente@footnote{Verso la fine del 2012.}
allo standard POSIX.)
Quello che segue @`e un esempio di una funzione ricorsiva. Prende come
parametro di input una stringa e restituisce la stringa in ordine inverso.
Le funzioni ricorsive devono sempre avere un test che interrompa la
ricorsione.
In questo caso, la ricorsione termina quando la stringa in input @`e
gi@`a vuota:
@c 8/2014: Thanks to Mike Brennan for the improved formulation
@cindex @code{rev()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{rev()}
@example
function rev(stringa)
@{
if (stringa == "")
return ""
return (rev(substr(stringa, 2)) substr(stringa, 1, 1))
@}
@end example
Se questa funzione @`e in un file di nome @file{rev.awk}, si pu@`o provare
cos@`{@dotless{i}}:
@example
$ @kbd{echo "Non v'allarmate!" |}
> @kbd{gawk -e '@{ print rev($0) @}' -f rev.awk}
@print{} !etamralla'v noN
@end example
La funzione C @code{ctime()} prende una marcatura temporale e la restituisce
come una stringa,
formattata come gi@`a sappiamo.
Il seguente esempio usa la funzione predefinita @code{strftime()}
(@pxref{Funzioni di tempo})
per creare una versione @command{awk} di @code{ctime()}:
@cindex @code{ctime()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{ctime()}
@example
@c file eg/lib/ctime.awk
# ctime.awk
#
# versione awk della funzione C ctime(3)
function ctime(ts, format)
@{
format = "%a %e %b %Y, %H.%M.%S, %Z"
if (ts == 0)
ts = systime() # usare data e ora correnti per default
return strftime(format, ts)
@}
@c endfile
@end example
Si potrebbe pensare che la funzione @code{ctime()} possa usare
@code{PROCINFO["strftime"]}
come stringa di formato. Sarebbe un errore, perch@'e si suppone che
@code{ctime()} restituisca data e ora formattati in maniera standard,
e qualche codice a livello utente potrebbe aver modificato in precedenza
@code{PROCINFO["strftime"]}.
@node Chiamata di una funzione
@subsection Chiamare funzioni definite dall'utente
@cindex funzione definita dall'utente @subentry chiamare
@cindex chiamare @subentry funzione definita dall'utente
@dfn{Chiamare una funzione} significa richiedere l'esecuzione di una
funzione, la quale svolge il compito per cui @`e stata scritta.
La chiamata di una funzione @`e un'espressione e il suo valore @`e quello
restituito dalla funzione.
@menu
* Chiamare una funzione:: Non usare spazi.
* Campo di validit@`a variabili:: Variabili locali e globali.
* Parametri per valore/riferimento:: Passaggio parametri.
* Precisazioni sulle funzioni:: Cose a cui prestare attenzione.
@end menu
@node Chiamare una funzione
@subsubsection Scrivere una chiamata di funzione
Una chiamata di funzione consiste nel nome della funzione seguito dagli
argomenti racchiusi tra parentesi. Gli argomenti specificati nella chiamata
sono costituiti da espressioni @command{awk}. Ogni volta che si esegue una
chiamata queste espressioni vengono ricalcolate, e i loro valori diventano gli
argomenti passati alla funzione. Per esempio, ecco una chiamata a
@code{pippo()} con tre argomenti (il primo dei quali @`e una concatenazione di
stringhe):
@example
pippo(x y, "perdere", 4 * z)
@end example
@quotation ATTENZIONE
Caratteri bianchi (spazi e TAB) non sono permessi tra il nome della funzione e
la parentesi aperta che apre la lista degli argomenti. Se per errore si
lasciano dei caratteri bianchi, @command{awk} li interpreterebbe come se
s'intendesse concatenare una variabile con un'espressione tra parentesi.
Tuttavia, poich@'e si @`e usato un nome di funzione e non un nome di variabile,
verrebbe emesso un messaggio di errore.
@end quotation
@node Campo di validit@`a variabili
@subsubsection Variabili locali e globali.
@cindex variabili @subentry locali @subentry in una funzione
@cindex locali @subentry variabili, in una funzione
Diversamente da molti altri linguaggi, non c'@`e modo di
rendere locale una variabile in un blocco @code{@{} @dots{} @code{@}} di
@command{awk}, ma si pu@`o rendere locale una variabile di una funzione. @`E
buona norma farlo quando una variabile serve solo all'interno di quella
particolare funzione.
Per rendere locale una variabile per una funzione, basta dichiarare la
variabile come argomento della funzione dopo gli argomenti richiesti dalla
funzione (@pxref{Sintassi delle definizioni}). Si consideri il seguente
esempio, dove la variabile @code{i} @`e una variabile globale usata sia dalla
funzione @code{pippo()} che dalla funzione @code{pluto()}:
@example
function pluto()
@{
for (i = 0; i < 3; i++)
print "in pluto i=" i
@}
function pippo(j)
@{
i = j + 1
print "in pippo i=" i
pluto()
print "in pippo i=" i
@}
BEGIN @{
i = 10
print "in BEGIN i=" i
pippo(0)
print "in BEGIN i=" i
@}
@end example
L'esecuzione di questo @dfn{script} produce quanto segue, perch@'e la stessa
variabile @code{i} @`e usata sia nelle
funzioni @code{pippo()} e @code{pluto()} sia a livello della
regola @code{BEGIN}:
@example
in BEGIN i=10
in pippo i=1
in pluto i=0
in pluto i=1
in pluto i=2
in pippo i=3
in BEGIN i=3
@end example
Se si vuole che @code{i} sia una variabile locale sia per
@code{pippo()} che per @code{pluto()}, occorre procedere in questo modo
(gli spazi extra prima della @code{i} sono una convenzione di codifica
che serve a ricordare che @code{i} @`e una variabile locale, non
un argomento):
@example
function pluto( i)
@{
for (i = 0; i < 3; i++)
print "in pluto i=" i
@}
function pippo(j, i)
@{
i = j + 1
print "in pippo i=" i
pluto()
print "in pippo i=" i
@}
BEGIN @{
i = 10
print "in BEGIN i=" i
pippo(0)
print "in BEGIN i=" i
@}
@end example
L'esecuzione della versione corretta dello @dfn{script} produce il seguente
output:
@example
in BEGIN i=10
in pippo i=1
in pluto i=0
in pluto i=1
in pluto i=2
in pippo i=1
in BEGIN i=10
@end example
Oltre a valori scalari (stringhe e numeri), si possono usare anche
vettori locali. Usando come parametro il nome di un vettore, @command{awk}
lo considera come tale, e lo tratta come locale alla funzione.
Inoltre, chiamate ricorsive creano nuovi vettori.
Si consideri questo esempio:
@example
@group
function qualche_funz(p1, a)
@{
if (p1++ > 3)
return
@end group
a[p1] = p1
qualche_funz(p1)
printf("Al livello %d, indice %d %s trova in a\n",
p1, (p1 - 1), (p1 - 1) in a ? "si" : "non si")
printf("Al livello %d, indice %d %s trova in a\n",
p1, p1, p1 in a ? "si" : "non si")
print ""
@}
BEGIN @{
qualche_funz(1)
@}
@end example
Quando viene eseguito, questo programma produce il seguente output:
@example
Al livello 4, indice 3 non si trova in a
Al livello 4, indice 4 si trova in a
Al livello 3, indice 2 non si trova in a
Al livello 3, indice 3 si trova in a
Al livello 2, indice 1 non si trova in a
Al livello 2, indice 2 si trova in a
@end example
@node Parametri per valore/riferimento
@subsubsection Passare parametri di funzione per valore o per riferimento
In @command{awk}, quando si definisce una funzione, non c'@`e modo di
dichiarare esplicitamente se gli argomenti sono passati @dfn{per valore}
o @dfn{per riferimento}.
Invece, il modo con cui i parametri sono passati @`e determinato
durante l'esecuzione del programma,
quando la funzione @`e chiamata, nel rispetto della regola seguente:
se l'argomento @`e una variabile di tipo vettoriale, questa @`e passata
per riferimento. Altrimenti, l'argomento @`e passato per valore.
@cindex chiamare @subentry funzione @subentry per valore
Passare un argomento per valore significa che quando una funzione @`e chiamata,
le viene fornita una @emph{copia} del valore di quell'argomento. Il chiamante
pu@`o usare una variabile il cui valore calcolato viene passato come argomento, ma la
funzione chiamata non la riconosce come variabile; riconosce solo il valore
assunto dall'argomento. Per esempio, scrivendo il seguente codice:
@example
pippo = "pluto"
z = mia_funzione(pippo)
@end example
@noindent
non si deve pensare che l'argomento passato a @code{mia_funzione()} sia ``la
variabile @code{pippo}.'' Invece, @`e corretto considerare l'argomento come la
stringa il cui valore @`e @code{"pluto"}.
Se la funzione @code{mia_funzione()} altera i valori delle sue variabili
locali, ci@`o non influisce su nessun'altra variabile. Quindi, se
@code{mia_funzione()} fa questo:
@example
@group
function mia_funzione(stringa)
@{
print stringa
stringa = "zzz"
print stringa
@}
@end group
@end example
@noindent
cambiando cos@`{@dotless{i}} il valore della variabile che @`e il suo primo argomento, ossia
@code{stringa}, il valore di @code{pippo} per il chiamante @emph{non} viene
modificato. Il ruolo svolto da @code{pippo} nella chiamata di
@code{mia_funzione()} termina quando il suo valore (@code{"pluto"}) viene
calcolato. Se la variabile @code{stringa} esiste anche al di fuori di
@code{mia_funzione()}, il corpo della funzione non pu@`o modificare questo valore
esterno, perch@'e esso rimane oscurato durante l'esecuzione di
@code{mia_funzione()} e non pu@`o quindi essere visto o modificato.
@cindex chiamare @subentry funzione @subentry per riferimento
@cindex vettori @subentry come parametri di funzione
@cindex funzioni @subentry vettori come parametri di
Tuttavia, quando sono dei vettori a fungere da parametri alle funzioni, questi
@emph{non} vengono copiati. Invece, il vettore stesso @`e reso disponibile per
essere manipolato direttamente dalla funzione. Questo @`e quel che si dice
solitamente una @dfn{chiamata per riferimento}. Le modifiche effettuate su un
vettore passato come parametro all'interno del corpo di una funzione
@emph{sono} visibili all'esterno della funzione.
@quotation NOTA
Modificare un vettore passato come parametro all'interno di una funzione
pu@`o essere molto pericoloso se non si sta attenti a quel che si sta facendo.
Per esempio:
@example
function cambialo(vettore, ind, nvalore)
@{
vettore[ind] = nvalore
@}
BEGIN @{
a[1] = 1; a[2] = 2; a[3] = 3
cambialo(a, 2, "due")
printf "a[1] = %s, a[2] = %s, a[3] = %s\n",
a[1], a[2], a[3]
@}
@end example
@noindent
stampa @samp{a[1] = 1, a[2] = due, a[3] = 3}, perch@'e
@code{cambialo()} memorizza @code{"due"} nel secondo elemento di @code{a}.
@end quotation
@node Precisazioni sulle funzioni
@subsubsection Cose a cui prestare attenzione
@cindex indefinite @subentry funzioni
@cindex funzioni @subentry indefinite
Alcune implementazioni di @command{awk} consentono di chiamare una
funzione che non @`e stata definita.
Viene solo emesso un messaggio che descrive il problema al momento
dell'esecuzione, se il programma tenta di chiamare quella funzione.
Per esempio:
@example
BEGIN @{
if (0)
pippo()
else
pluto()
@}
function pluto() @{ @dots{} @}
# si noti che `pippo' non @`e definito
@end example
@noindent
Poich@'e la condizione dell'istruzione @samp{if} non risulter@`a mai verificata
in questo caso,
non @`e un problema reale il fatto che
che @code{pippo()} non sia stato definito. Solitamente, tuttavia,
@`e un problema se un programma chiama una funzione indefinita.
@cindex @dfn{lint} @subentry controlli @subentry funzione indefinita
@cindex controllo @subentry @dfn{lint} @subentry per funzione indefinita
@cindex funzione @subentry indefinita @subentry controlli @dfn{lint} per
Se si specifica l'opzione @option{--lint}
(@pxref{Opzioni}),
@command{gawk} elenca le chiamate a funzioni indefinite.
@cindex portabilit@`a @subentry istruzione @code{next} in funzioni definite dall'utente
@cindex @code{next} (istruzione) @subentry in funzioni definite dall'utente
Alcune implementazione di @command{awk} emettono un messaggio di errore
se si usa l'istruzione @code{next}
o @code{nextfile}
(@pxref{Istruzione next}, e
@ifdocbook
@ref{Istruzione nextfile})
@end ifdocbook
@ifnotdocbook
@pxref{Istruzione nextfile})
@end ifnotdocbook
all'interno di una funzione definita dall'utente.
@command{gawk} non ha questa limitazione.
@`E possibile chiamare una funzione specificando parametri in pi@`u rispetto
a quelli che la funzione si aspetta, come p.es.:
@example
function pippo(p1, p2)
@{
@dots{}
@}
BEGIN @{
pippo(1, 2, 3, 4)
@}
@end example
Fare questo, tuttavia, @`e una pratica sconsigliata. La funzione chiamata
potrebbe fare qualsiasi cosa con i valori ulteriori che le vengono passati,
quindi @command{awk} calcola le espressioni richieste, per poi non
utilizzarle affatto.
@`E inoltre ancora pi@`u importante notare che una simile chiamata di funzione
pu@`o essere causa di confusione per la persona che potrebbe leggere in
seguito il programma in questione.@footnote{Questa persona potresti
anche essere tu, dopo qualche tempo, e a quel punto ti domanderesti
``cosa stavo pensando?!?''}
I parametri di una funzione sono generalmente elementi dell'input che
influenzano l'elaborazione eseguita dalla funzione. Chiamare una funzione
con pi@`u parametri del necessario potrebbe comunicare la falsa impressione
che quei valori siano importanti per la funzione, mentre in realt@`a non
lo sono affatto.
Poich@'e questa pratica non @`e affatto raccomandabile, @command{gawk}
manda @emph{sempre} un messaggio di avvertimento quando si trova a
eseguire una tale chiamata di funzione. (Se non si vuole ricevere
il messaggio, occorre modificare il codice! In fondo, non @`e
corretto).
@node Istruzione return
@subsection L'istruzione @code{return}
@cindex @code{return} (istruzione) @subentry in funzioni definite dall'utente
@cindex istruzione @subentry @code{return} @subentry in funzioni definite dall'utente
Come visto in parecchi esempi precedenti,
il corpo di una funzione definita dall'utente pu@`o contenere un'istruzione
@code{return}.
Quest'istruzione restituisce il controllo a quella parte del
del programma @command{awk} che ha effettuato la chiamata.
Pu@`o anche essere usata per restituire un valore da usare nel resto del
programma @command{awk}.
Questo @`e un esempio:
@display
@code{return} [@var{espressione}]
@end display
La parte @var{espressione} @`e opzionale.
Probabilmente per una svista, POSIX non definisce qual @`e il valore
restituito, se si omette @var{espressione}. Tecnicamente parlando, questo
rende il valore restituito indefinito, e quindi, indeterminato.
In pratica, tuttavia, tutte le versioni di @command{awk} restituiscono
semplicemente la stringa nulla, che vale zero se usata
in un contesto che richiede un numero.
Un'istruzione @code{return} senza una @var{espressione} @`e considerata presente
alla fine di ogni definizione di funzione.
Quindi, se il flusso di esecuzione raggiunge la fine del corpo della
funzione, tecnicamente la funzione
restituisce un valore indeterminato.
In pratica, restituisce la stringa nulla. @command{awk}
@emph{non} emette alcun messaggio di avvertimento se si usa
il valore restituito di una tale funzione.
Talvolta pu@`o capitare di scrivere una funzione per quello che fa, non per
quello che restituisce. Una tale funzione corrisponde a una funzione
@code{void} in C, C++, o Java, o a una @code{procedure} in Ada.
Quindi, pu@`o essere corretto non
restituire alcun valore; basta fare attenzione a non usare poi il
valore restituito da una tale funzione.
Quello che segue @`e un esempio di una funzione definita dall'utente
che restituisce un valore che @`e
il numero pi@`u alto presente tra gli elementi di un vettore:
@example
function massimo(vettore, i, max)
@{
for (i in vettore) @{
if (max == "" || vettore[i] > max)
max = vettore[i]
@}
return max
@}
@end example
@cindex programmazione @subentry convenzioni di @subentry parametri di funzione
@cindex convenzioni di programmazione @subentry parametri di funzione
@noindent
La chiamata a @code{massimo()} ha un solo argomento, che @`e il nome di
un vettore. Le variabili locali @code{i} e @code{max} non vanno intese
come argomenti; nulla vieta di passare pi@`u di un argomento
a @code{massimo()} ma i risultati sarebbero strani. Gli spazi extra prima
di @code{i} nella lista dei parametri della funzione indicano che @code{i} e
@code{max} sono variabili locali.
@`E consigliabile seguire questa convenzione quando si definiscono delle funzioni.
Il programma seguente usa la funzione @code{massimo()}. Carica un vettore,
richiama @code{massimo()}, e quindi elenca il numero massimo contenuto in
quel vettore:
@example
function massimo(vettore, i, max)
@{
for (i in vettore) @{
if (max == "" || vettore[i] > max)
max = vettore[i]
@}
return max
@}
@group
# Carica tutti i campi di ogni record in numeri.
@{
for (i = 1; i <= NF; i++)
numeri[NR, i] = $i
@}
@end group
END @{
print massimo(numeri)
@}
@end example
Dato il seguente input:
@example
1 5 23 8 16
44 3 5 2 8 26
256 291 1396 2962 100
-6 467 998 1101
99385 11 0 225
@end example
@noindent
il programma trova (come si pu@`o immaginare) che 99.385 @`e il
valore pi@`u alto contenuto nel vettore.
@node Variabili di tipo dinamico
@subsection Funzioni e loro effetti sul tipo di una variabile
@command{awk} @`e un linguaggio molto fluido.
@`E possible che @command{awk} non sia in grado di stabilire se un
identificativo rappresenta una variabile scalare o un vettore,
prima dell'effettiva esecuzione di un programma.
Ecco un esempio di programma commentato:
@example
function pippo(a)
@{
a[1] = 1 # il parametro @`e un vettore
@}
BEGIN @{
b = 1
pippo(b) # non valido: errore fatale, tipi variabile in conflitto
pippo(x) # x non inizializzato, diventa un vettore dinamicamente
x = 1 # a questo punto, non permesso: errore in esecuzione
@}
@end example
In questo esempio, la prima chiamata a @code{pippo()} genera
un errore fatale, quindi @command{awk} non arriver@`a a segnalare il secondo
errore. Se si commenta la prima chiamata e si riesegue il
programma, a quel punto @command{awk} terminer@`a con un messaggio
relativo al secondo errore.
Solitamente queste cose non causano grossi problemi, ma @`e bene
esserne a conoscenza.
@node Chiamate indirette
@section Chiamate indirette di funzione
@cindex indiretta @subentry chiamata di funzione
@cindex chiamare @subentry funzione @subentry indirettamente
@cindex funzione @subentry puntatori a
@cindex puntatori a funzioni
@cindex differenze tra @command{awk} e @command{gawk} @subentry chiamata indiretta di funzione
Questa sezione descrive un'estensione avanzata, specifica di @command{gawk}.
Spesso pu@`o essere utile ritardare la scelta della funzione da chiamare
fino al momento in cui il programma viene eseguito.
Per esempio, potrebbero esserci diversi tipi di record in input, ciascuno
dei quali dovrebbe essere elaborato in maniera differente.
Solitamente, si userebbe una serie di istruzioni @code{if}-@code{else}
per decidere quale funzione chiamare. Usando la chiamata @dfn{indiretta}
a una funzione, si pu@`o assegnare il nome della funzione da chiamare a
una variabile di tipo stringa, e usarla per chiamare la funzione.
Vediamo un esempio.
Si supponga di avere un file con i punteggi ottenuti negli esami per i
corsi che si stanno seguendo, e che si desideri ottenere la somma e la
media dei punteggi ottenuti.
Il primo campo @`e il nome del corso. I campi seguenti sono i nomi delle
funzioni da chiamare per elaborare i dati, fino a un campo ``separatore''
@samp{dati:}. Dopo il separatore, fino alla fine del record,
ci sono i vari risultati numerici di ogni test.
Ecco il file iniziale:
@example
@c file eg/data/class_data1
Biologia_101 somma media dati: 87.0 92.4 78.5 94.9
Chimica_305 somma media dati: 75.2 98.3 94.7 88.2
Inglese_401 somma media dati: 100.0 95.6 87.1 93.4
@c endfile
@end example
Per elaborare i dati, si potrebbe iniziare a scrivere:
@example
@{
corso = $1
for (i = 2; $i != "dati:"; i++) @{
if ($i == "somma")
somma() # elabora l'intero record
else if ($i == "media")
media()
@dots{} # e cos@`{@dotless{i}} via
@}
@}
@end example
@noindent
Questo stile di programmazione funziona, ma pu@`o essere scomodo.
Con la chiamata @dfn{indiretta} di funzione, si pu@`o richiedere a @command{gawk}
di usare il @emph{valore} di una variabile come @emph{nome} della funzione da
chiamare.
@cindex @code{@@} (chiocciola) @subentry @code{@@}-notazione per la chiamata indiretta di funzioni
@cindex chiocciola (@code{@@}) @subentry @code{@@}-notazione per la chiamata indiretta di funzioni
@cindex chiamare @subentry funzione @subentry indirettamente, notazione @code{@@}
@cindex indiretta @subentry chiamata di funzione @subentry @code{@@}-notazione
La sintassi @`e simile a quella di una normale chiamata di funzione:
un identificativo, seguito immediatamente da una parentesi aperta,
qualche argomento, e una parentesi chiusa, con l'aggiunta di un carattere
@samp{@@} all'inizio:
@example
quale_funzione = "somma"
risultato = @@quale_funzione() # chiamata della funzione somma()
@end example
Ecco un intero programma che elabora i dati mostrati sopra,
usando la chiamata indiretta di funzioni:
@example
@c file eg/prog/indirectcall.awk
# chiamataindiretta.awk --- esempio di chiamata indiretta di funzioni
@c endfile
@ignore
@c file eg/prog/indirectcall.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# January 2009
@c endfile
@end ignore
@c file eg/prog/indirectcall.awk
# media --- calcola la media dei valori dei campi $primo - $ultimo
function media(primo, ultimo, somma, i)
@{
somma = 0;
for (i = primo; i <= ultimo; i++)
somma += $i
return somma / (ultimo - primo + 1)
@}
# somma --- restituisce la somma dei valori dei campi $primo - $ultimo
function somma(primo, ultimo, totale, i)
@{
max = 0;
for (i = primo; i <= ultimo; i++)
totale += $i
return totale
@}
@c endfile
@end example
Queste due funzioni presuppongono che si lavori con dei campi; quindi,
i parametri @code{primo} e @code{ultimo} indicano da quale campo iniziare
e fino a quale arrivare.
Per il resto, eseguono i calcoli richiesti, che sono i soliti:
@example
@c file eg/prog/indirectcall.awk
# Per ogni record,
# stampa il nome del corso e le statistiche richieste
@{
nome_corso = $1
gsub(/_/, " ", nome_corso) # Rimpiazza _ con spazi
# trova campo da cui iniziare
for (i = 1; i <= NF; i++) @{
if ($i == "dati:") @{
inizio = i + 1
break
@}
@}
printf("%s:\n", nome_corso)
for (i = 2; $i != "dati:"; i++) @{
quale_funzione = $i
printf("\t%s: <%s>\n", $i, @@quale_funzione(inizio, NF) "")
@}
print ""
@}
@c endfile
@end example
Questo @`e il ciclo principale eseguito per ogni record.
Stampa il nome del corso (con le
lineette basse sostituite da spazi). Trova poi l'inizio dei dati veri
e propri, salvandolo in @code{inizio}.
L'ultima parte del codice esegue un ciclo per ogni nome di funzione
(da @code{$2} fino al separatore, @samp{dati:}), chiamando la funzione
il cui nome @`e specificato nel campo. La chiamata di funzione indiretta
compare come parametro nella chiamata a @code{printf}.
(La stringa di formattazione di @code{printf} usa @samp{%s} come
specificatore di formato, affinch@'e sia possibile usare funzioni
che restituiscano sia stringhe che numeri. Si noti che il risultato
della chiamata indiretta @`e concatenato con la stringa nulla, in modo da
farlo considerare un valore di tipo stringa).
Ecco il risultato dell'esecuzione del programma:
@example
$ @kbd{gawk -f chiamataindiretta.awk dati_dei_corsi}
@print{} Biologia 101:
@print{} somma: <352.8>
@print{} media: <88.2>
@print{}
@print{} Chimica 305:
@print{} somma: <356.4>
@print{} media: <89.1>
@print{}
@print{} Inglese 401:
@print{} somma: <376.1>
@print{} media: <94.025>
@end example
La possibilit@`a di usare la chiamata indiretta di funzioni @`e pi@`u potente
di quel che si possa pensare inizialmente.
I linguaggi C e C++ forniscono ``puntatori di funzione'' che
sono un metodo per chiamare una funzione scelta al momento dell'esecuzione.
Uno dei pi@`u noti usi di questa funzionalit@`a @`e
la funzione C @code{qsort()}, che ordina un vettore usando il famoso
algoritmo noto come ``quicksort''
(si veda @uref{https://en.wikipedia.org/wiki/Quicksort, l'articolo di Wikipedia}
per ulteriori informazioni). Per usare questa funzione, si specifica un
puntatore a una funzione di confronto. Questo meccanismo consente
di ordinare dei dati arbitrari in una maniera arbitraria.
Si pu@`o fare qualcosa di simile usando @command{gawk}, cos@`{@dotless{i}}:
@example
@c file eg/lib/quicksort.awk
# quicksort.awk --- Algoritmo di quicksort, con funzione di confronto
# fornita dall'utente
@c endfile
@ignore
@c file eg/lib/quicksort.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# January 2009
@c endfile
@end ignore
@c file eg/lib/quicksort.awk
# quicksort --- Algoritmo di quicksort di C.A.R. Hoare.
# Si veda Wikipedia o quasi ogni libro
# che tratta di algoritmi o di informatica.
@c endfile
@ignore
@c file eg/lib/quicksort.awk
#
# Adattato da B.W. Kernighan & D.M. Ritchie
# The C Programming Language
# (Englewood Cliffs, NJ: Prentice Hall, 1988)
# Seconda Edizione, pagina 110
@c endfile
@end ignore
@c file eg/lib/quicksort.awk
function quicksort(dati, sinistra, destra, minore_di, i, ultimo)
@{
if (sinistra >= destra) # non fa nulla se il vettore contiene
return # meno di due elementi
quicksort_scambia(dati, sinistra, int((sinistra + destra) / 2))
ultimo = sinistra
for (i = sinistra + 1; i <= destra; i++)
if (@@minore_di(dati[i], dati[sinistra]))
quicksort_scambia(dati, ++ultimo, i)
quicksort_scambia(dati, sinistra, ultimo)
quicksort(dati, sinistra, ultimo - 1, minore_di)
quicksort(dati, ultimo + 1, destra, minore_di)
@}
# quicksort_scambia --- funzione ausiliaria per quicksort,
# sarebbe meglio fosse nel programma principale
function quicksort_scambia(dati, i, j, salva)
@{
salva = dati[i]
dati[i] = dati[j]
dati[j] = salva
@}
@c endfile
@end example
La funzione @code{quicksort()} riceve il vettore @code{dati}, gli
indici iniziali e finali da ordinare
(@code{sinistra} e @code{destra}), e il nome di una funzione che
esegue un confronto ``minore di''. Viene quindi eseguito
l'algoritmo di quicksort.
Per fare uso della funzione di ordinamento, torniamo all'esempio
precedente. La prima cosa da fare @`e di scrivere qualche funzione
di confronto:
@example
@c file eg/prog/indirectcall.awk
@group
# num_min --- confronto numerico per minore di
function num_min(sinistra, destra)
@{
return ((sinistra + 0) < (destra + 0))
@}
@end group
# num_magg_o_ug --- confronto numerico per maggiore o uguale
function num_magg_o_ug(sinistra, destra)
@{
return ((sinistra + 0) >= (destra + 0))
@}
@c endfile
@end example
La funzione @code{num_magg_o_ug()} serve per ottenere un ordinamento
decrescente (dal numero pi@`u alto al pi@`u basso); quando @`e usato
per eseguire un test per ``minore di'', in realt@`a fa l'opposto
(maggiore o uguale a), il che conduce a ottenere dati ordinati
in ordine decrescente.
Poi serve una funzione di ordinamento.
Come parametri ha i numeri del campo iniziale e di quello finale,
e il nome della funzione di confronto.
Costruisce un vettore con
i dati e richiama appropriatamente @code{quicksort()}; quindi formatta i
risultati mettendoli in un'unica stringa:
@example
@c file eg/prog/indirectcall.awk
# ordina --- ordina i dati a seconda di `confronta'
# e li restituisce come un'unica stringa
function ordina(primo, ultimo, confronta, dati, i, risultato)
@{
delete dati
for (i = 1; primo <= ultimo; primo++) @{
dati[i] = $primo
i++
@}
quicksort(dati, 1, i-1, confronta)
risultato = dati[1]
for (i = 2; i in dati; i++)
risultato = risultato " " dati[i]
return risultato
@}
@c endfile
@end example
Per finire, le due funzioni di ordinamento chiamano la funzione
@code{ordina()}, passandole i nomi delle due funzioni di confronto:
@example
@c file eg/prog/indirectcall.awk
@group
# ascendente --- ordina i dati in ordine crescente
# e li restituisce sotto forma di stringa
function ascendente(primo, ultimo)
@{
return ordina(primo, ultimo, "num_min")
@}
@end group
@group
# discendente --- ordina i dati in ordine decrescente
# e li restituisce sotto forma di stringa
function discendente(primo, ultimo)
@{
return ordina(primo, ultimo, "num_magg_o_ug")
@}
@end group
@c endfile
@end example
Ecco una versione estesa del @value{DF}:
@example
@c file eg/data/class_data2
Biologia_101 somma media ascendente discendente dati: 87.0 92.4 78.5 94.9
Chimica_305 somma media ascendente discendente dati: 75.2 98.3 94.7 88.2
Inglese_401 somma media ascendente discendente dati: 100.0 95.6 87.1 93.4
@c endfile
@end example
Per finire, questi sono i risultati quando si esegue il programma
in questa versione migliorata:
@example
$ @kbd{gawk -f quicksort.awk -f indirettacall.awk class_data2}
@print{} Biologia 101:
@print{} somma: <352.8>
@print{} media: <88.2>
@print{} ascendente: <78.5 87.0 92.4 94.9>
@print{} discendente: <94.9 92.4 87.0 78.5>
@print{}
@print{} Chimica 305:
@print{} somma: <356.4>
@print{} media: <89.1>
@print{} ascendente: <75.2 88.2 94.7 98.3>
@print{} discendente: <98.3 94.7 88.2 75.2>
@print{}
@print{} Inglese 401:
@print{} somma: <376.1>
@print{} media: <94.025>
@print{} ascendente: <87.1 93.4 95.6 100.0>
@print{} discendente: <100.0 95.6 93.4 87.1>
@end example
Un altro esempio in cui le chiamate indirette di funzione sono utili
@`e costituito dall'elaborazione di vettori. La descrizione si pu@`o trovare
@ref{Visitare vettori}.
Occorre ricordarsi di anteporre il carattere @samp{@@} prima di una
chiamata indiretta di funzione.
A partire dalla @value{PVERSION} 4.1.2 di @command{gawk}, le chiamate
indirette di funzione
possono anche essere usate per chiamare funzioni predefinite e con
funzioni di estensione
(@pxref{Estensioni dinamiche}). Ci sono alcune limitazioni nel richiamare
in maniera indiretta delle funzioni predefinite, come qui dettagliato:
@itemize @value{BULLET}
@item
Non si pu@`o passare una costante @dfn{regexp} a una funzione predefinita
effettuando una chiamata di funzione indiretta.@footnote{Questa
limitazione potrebbe cambiare in una futura versione;
per appurarlo, si controlli la documentazione che accompagna
la versione in uso di @command{gawk}.}
Quanto sopra vale per le funzioni
@code{sub()}, @code{gsub()}, @code{gensub()}, @code{match()},
@code{split()} e @code{patsplit()}.
@item
Nel chiamare @code{sub()} o @code{gsub()}, sono accettati solo due argomenti,
poich@'e queste funzioni sono atipiche, in quanto aggiornano il loro terzo
argomento. Questo significa che verr@`a sempre aggiornato l'argomento di
default, @code{$0}.
@end itemize
@command{gawk} fa del suo meglio per rendere efficiente la chiamata indiretta
di funzioni. Per esempio, nel ciclo seguente:
@example
for (i = 1; i <= n; i++)
@@quale_funzione()
@end example
@noindent
@command{gawk} ricerca solo una volta quale funzione chiamare.
@node Sommario delle funzioni
@section Sommario
@itemize @value{BULLET}
@item
@command{awk} include delle funzioni predefinite e consente all'utente
di definire le sue proprie funzioni.
@item
POSIX @command{awk} include tre tipi di funzioni predefinite: numeriche, di
stringa, e di I/O. @command{gawk} prevede funzioni per ordinare vettori, per
lavorare con valori che rappresentano marcature temporali,
per la manipolazione di bit,
per determinare il tipo di una variabile (vettoriale piuttosto che scalare), e
programmi per l'internazionalizzazione e la localizzazione. @command{gawk}
prevede anche parecchie estensioni ad alcune funzioni standard, tipicamente
nella forma di ulteriori argomenti.
@item
Le funzioni accettano zero o pi@`u argomenti e restituiscono un valore. Le
espressioni che specificano il valore di ogni argomento sono valutate
completamente prima della chiamata
a una funzione. L'ordine di valutazione di questi argomenti non @`e definito.
Il valore restituito dalla funzione pu@`o essere ignorato.
@item
La gestione delle barre inverse in @code{sub()} e @code{gsub()} non @`e
semplice.
@`E pi@`u semplice nella funzione di @command{gawk} @code{gensub()},
ma anche questa funzione richiede attenzione quando la si usa.
@item
Le funzioni definite dall'utente consentono importanti funzionalit@`a ma hanno
anche alcune ineleganze sintattiche. In una chiamata di funzione non si pu@`o
inserire alcuno spazio tra il nome della funzione e la parentesi sinistra
aperta che inizia la lista degli argomenti. Inoltre, non c'@`e nessuna
prescrizione per le variabili locali, e per questo la
convenzione in uso @`e di aggiungere parametri extra, e di separarli visivamente
dai parametri veri e propri inserendo degli spazi bianchi prima di essi.
@item
Le funzioni definite dall'utente possono chiamare altre
funzioni definite dall'utente (oltre a quelle predefinite)
e possono chiamare se stesse ricorsivamente. I parametri di funzione
``nascondono'' qualsiasi variabile globale che abbia lo stesso nome.
Non si pu@`o usare il nome di una variabile riservata (p.es. @code{ARGC})
come nome di un parametro in funzioni definite dall'utente.
@item
I valori scalari sono passati alle funzioni definite dall'utente
per valore. I parametri che sono dei vettori sono passati alle funzioni
per riferimento; ogni modifica fatta dalla funzione a un parametro che
sia un vettore @`e quindi visibile dopo aver eseguito quella funzione.
@item
L'istruzione @code{return} serve per tornare indietro da una funzione definita
dall'utente. Un'espressione opzionale diviene il valore restituito dalla
funzione. Una funzione pu@`o solo restituire valori di tipo scalare.
@item
Se una variabile che non @`e stata mai usata @`e passata a una funzione
definita dall'utente, il modo con cui quella funzione elabora la variabile
ne pu@`o determinare il tipo: o scalare o vettoriale.
@item
@command{gawk} consente la chiamata indiretta di funzioni usando una sintassi
speciale. Impostando una variabile al nome di una funzione, si pu@`o
determinare al momento dell'esecuzione che funzione sar@`a chiamata in un certo
punto del programma. Questo equivale a usare un puntatore a una funzione nei
linguaggi C e C++.
@end itemize
@ifnotinfo
@part @value{PART2}Risoluzione di problemi con @command{awk}
@end ifnotinfo
@ifdocbook
La Parte II mostra come usare @command{awk} e @command{gawk} per risolvere
problemi. Qui c'@`e il codice di molti programmi, da leggere e da cui si pu@`o
imparare. @`E composta dai seguenti capitoli:
@itemize @value{BULLET}
@item
@ref{Funzioni di libreria}
@item
@ref{Programmi di esempio}
@end itemize
@end ifdocbook
@node Funzioni di libreria
@chapter Una libreria di funzioni @command{awk}
@cindex libreria di funzioni @command{awk}
@cindex funzioni @subentry di libreria
@cindex funzione definita dall'utente @subentry libreria di
@iftex
La
@end iftex
@ref{Funzioni definite dall'utente} descrive come scrivere le proprie
funzioni @command{awk} personali. Scrivere funzioni @`e importante, perch@'e
consente di incapsulare in un unico contenitore algoritmi e azioni di
programma. Semplifica la programmazione, rendendo lo sviluppo di un programma
pi@`u gestibile, e rendendo i programmi pi@`u leggibili.
@cindex Kernighan, Brian @subentry citazioni di
@cindex Plauger, P.J.@:
Nel loro autorevole libro del 1976,
@cite{Software Tools},@footnote{Purtroppo, a distanza di oltre 35 anni,
molte delle
lezioni impartite da questo libro devono ancora essere apprese da un gran
numero di programmatori professionisti.}
Brian Kernighan e P.J.@: Plauger hanno scritto:
@quotation
A programmare bene non s'impara dai concetti generali, ma vedendo come
programmi complessi possono essere resi puliti, facili da leggere,
facili da manutenere e modificare,
strutturati in modo comprensibile, efficienti e affidabili,
applicando il buon senso e delle buone pratiche di programmazione.
Lo studio attento e l'imitazione di buoni programmi conduce a una migliore
scrittura.
@end quotation
In effetti, loro reputavano quest'idea tanto importante da mettere questa
frase sulla copertina del libro. Poich@'e credo fermamente che la loro
affermazione sia corretta, questo @value{CHAPTER} e
@iftex
il
@end iftex
@ref{Programmi di esempio}
forniscono una corposa raccolta di codice da leggere e, si spera, da cui
imparare.
Questo @value{CHAPTER} illustra una libreria di utili funzioni @command{awk}.
Molti dei programmi descritti nel seguito di questo @value{DOCUMENT}
usano queste funzioni.
Le funzioni sono illustrate progressivamente, dalla pi@`u semplice alla pi@`u
complessa.
@cindex Texinfo
@iftex
La
@end iftex
@ref{Programma extract}
illustra un programma che si pu@`o usare per estrarre il codice sorgente
degli esempi di funzioni di libreria e di programmi dal sorgente Texinfo
di questo @value{DOCUMENT}.
(Questo @`e gi@`a stato fatto durante la preparazione della distribuzione
di @command{gawk}.)
@ifclear FOR_PRINT
Chi avesse scritto una o pi@`u funzioni @command{awk} utili e di uso
generale, e volesse metterle a disposizione della comunit@`a degli utenti di
@command{awk}, pu@`o leggere le informazioni contenute in
@ref{Come contribuire}.
@end ifclear
@cindex portabilit@`a @subentry programmi di esempio
I programmi contenuti in questo @value{CHAPTER} e in
@ref{Programmi di esempio},
utilizzano anche le funzionalit@`a specifiche di @command{gawk}.
Riscrivere questi programmi per implementazioni di @command{awk} diverse
@`e piuttosto semplice:
@itemize @value{BULLET}
@item
I messaggi di errore diagnostici sono inviati a @file{/dev/stderr}.
Usare @samp{| "cat 1>&2"} al posto di @samp{> "/dev/stderr"} se il sistema
in uso non ha un @file{/dev/stderr}, o se non @`e possibile usare
@command{gawk}.
@item
Alcuni programmi usano @code{nextfile}
(@pxref{Istruzione nextfile})
per evitare di leggere gli input ancora non letti dal file in input corrente.
@item
@c 12/2000: Thanks to Nelson Beebe for pointing out the output issue.
@cindex distinzione maiuscolo/minuscolo @subentry programmi di esempio
@cindex @code{IGNORECASE} (variabile) @subentry programmi di esempio
@cindex variabile @subentry @code{IGNORECASE} @subentry programmi di esempio
Infine, alcuni dei programmi scelgono di ignorare la distinzione tra maiuscolo e
minuscolo nei loro input, assegnando il valore uno a @code{IGNORECASE}.
Si pu@`o ottenere quasi lo stesso effetto@footnote{I risultati non sono identici.
L'output del record trasformato sar@`a tutto in minuscolo, mentre
@code{IGNORECASE} preserva il contenuto originale del record in input.}
aggiungendo la seguente regola
all'inizio del programma:
@example
# ignora maiuscolo/minuscolo
@{ $0 = tolower($0) @}
@end example
@noindent
Inoltre, si verifichi che tutte le @dfn{regexp} e le costanti
di tipo stringa usate nei confronti utilizzano solo lettere minuscole.
@end itemize
@menu
* Nomi di variabili di libreria:: Che nomi @`e meglio dare alle variabili
private globali nelle funzioni di libreria.
* Funzioni di tipo generale:: Funzioni di uso generale.
* Gestione File Dati:: Funzioni per gestire file-dati specificati
sulla riga di comando.
* Funzione getopt:: Una funzione per trattare argomenti presenti
sulla riga di comando.
* Funzioni Passwd:: Funzioni per ottenete informazioni
sull'utente [da /etc/passwd].
* Funzioni Group:: Funzioni per ottenete informazioni
sul gruppo [da /etc/group].
* Visitare vettori:: Una funzione per visitare vettori di vettori.
* Sommario funzioni di libreria:: Sommario funzioni di libreria
* Esercizi con le librerie:: Esercizi.
@end menu
@node Nomi di variabili di libreria
@section Dare un nome a variabili globali in funzioni di libreria
@cindex nomi @subentry di vettore/variabile
@cindex nomi @subentry di funzione
@cindex questioni sui nomi permessi
@cindex nomi @subentry permessi @subentry questioni sui
@cindex programmi @command{awk} @subentry documentazione dei
@cindex programmi @command{awk} @subentry documentazione dei
Per come si @`e sviluppato il linguaggio @command{awk}, le variabili sono
o @dfn{globali} (usabili dall'intero programma) o @dfn{locali} (usabili solo
in una specifica funzione). Non c'@`e uno stato intermedio analogo alle
variabili @code{statiche} in C.
@cindex variabili @subentry globali @subentry per funzioni di libreria
@cindex globali @subentry variabili @subentry per funzioni di libreria
@cindex private @subentry variabili
@cindex variabili @subentry private
Le funzioni di libreria hanno spesso necessit@`a di avere variabili globali da
usare per conservare informazioni di stato tra successive chiamate alla
funzione; per esempio, la variabile di @code{getopt()} @code{_opti}
(@pxref{Funzione getopt}).
Tali variabili vengono dette @dfn{private}, poich@'e le sole funzioni che
devono usarle sono quelle della libreria.
Quando si scrive una funzione di libreria, si dovrebbe cercare di scegliere per
le variabili private dei nomi che non entrano in conflitto con nessuna delle
variabili usate da un'altra funzione di libreria o dal programma principale di
un utente. Per esempio, un nome come @code{i} o @code{j} non @`e una buona
scelta, perch@'e i programmi a livello utente usano spesso nomi di variabile come
questi per le proprie elaborazioni.
@cindex convenzioni di programmazione @subentry nomi di variabili private
@cindex programmazione @subentry convenzioni di @subentry nomi di variabili private
I programmi di esempio mostrati in questo @value{CHAPTER} usano per le
loro variabili private nomi che iniziano con un trattino basso(@samp{_}).
Generalmente gli utenti
non usano trattini bassi iniziali nei nomi di variabile, cos@`{@dotless{i}} questa convenzione
riduce le possibilit@`a che il nome di variabile coincida con un nome usato
nel programma dell'utente.
@cindex @code{_} (trattino basso) @subentry nei nomi di variabili private
@cindex trattino basso (@code{_}) @subentry nei nomi di variabili private
Inoltre, parecchie funzioni di libreria usano un prefisso che suggerisce
quale funzione o gruppo di funzioni usa quelle variabili; per esempio,
@code{_pw_byname()} nelle routine che consultano la lista degli utenti
(@pxref{Funzioni Passwd}).
L'uso di questa convenzione viene raccomandata, poich@'e riduce ulteriormente la
possibilit@`a di conflitti accidentali tra nomi di variabile. Si noti che questa
convenzione pu@`o anche essere usata per i nomi di variabile e per i nomi delle
funzioni private.@footnote{Sebbene tutte le routine di libreria si sarebbero
potute riscrivere usando questa convenzione, ci@`o non @`e stato fatto, per far
vedere come lo stile di programmazione in @command{awk} si @`e evoluto e
per fornire alcuni spunti per questa spiegazione.}
Come nota finale sui nomi delle variabili, se una funzione rende
disponibile una variabile globale per essere usata da un programma principale,
@`e una buona convenzione quella di far iniziare i nomi di queste variabili con
una lettera maiuscola; per esempio, @code{Opterr} e @code{Optind} di
@code{getopt()}
(@pxref{Funzione getopt}).
La lettera maiuscola iniziale indica che la variabile @`e globale,
mentre il fatto che
il nome della variabile non @`e tutto in lettere maiuscole indica che la variabile
non @`e una delle variabili predefinite di @command{awk}, come @code{FS}.
@cindex @option{--dump-variables} (opzione) @subentry uso per funzioni di libreria
@cindex opzione @subentry @option{--dump-variables} @subentry uso per funzioni di libreria
@`E importante anche che @emph{tutte} le variabili nelle funzioni di libreria
che non abbiano la necessit@`a di essere
conservate per tutta la durata del
programma siano, di fatto, dichiarate
come locali.@footnote{L'opzione da riga di comando di @command{gawk}
@option{--dump-variables} @`e utile per verificare questo.} Se ci@`o non viene
fatto, la variabile potrebbe essere usata accidentalmente nel programma
dell'utente, conducendo a errori che sono molto difficili da scoprire:
@example
function lib_func(x, y, l1, l2)
@{
@dots{}
# qualche_var dovrebbe essere locale ma per una svista non lo @`e
@var{uso della variabile} qualche_var
@dots{}
@}
@end example
@cindex vettori @subentry associativi @subentry funzioni di libreria e
@cindex libreria di funzioni @command{awk} @subentry vettori associativi e
@cindex funzioni @subentry libreria di @subentry vettori associativi e
@cindex Tcl
Una differente convenzione, comune nella comunit@`a Tcl, @`e quella di usare un
solo vettore associativo che contiene i valori necessari alle funzioni di
libreria, o ``package.'' Questo riduce significativamente il numero degli
effettivi nomi globali in uso. Per esempio, le funzioni descritte in
@ref{Funzioni Passwd}
potrebbero aver usato gli elementi di vettore
@code{@w{PW_data["inizializzato"]}},
@code{@w{PW_data["totale"]}}, @code{@w{PW_data["contatore"]}}, e
@code{@w{PW_data["awklib"]}}, al posto di @code{@w{_pw_inizializzato}},
@code{@w{_pw_totale}},
@code{@w{_pw_awklib}} e
@code{@w{_pw_contatore}}.
Le convenzioni illustrate in questa @value{SECTION} sono esattamente
quello che indica il termine: convenzioni. Non si @`e obbligati a scrivere
i propri programmi in questo modo: @`e solo auspicabile che lo si faccia.
A partire dalla @value{PVERSION} 5.0, @command{gawk} fornisce
un meccanismo efficiente per risolvere i problemi descritti in
questa sezione: gli spazi-dei-nomi (@dfn{spazi-dei-nomi}).
Gli spazi-dei-nomi e il loro utilizzo sono descritti in dettaglio
in @ref{Spazi-dei-nomi}.
@node Funzioni di tipo generale
@section Programmazione di tipo generale
Questa @value{SECTION} illustra diverse funzioni che sono di uso generale nella
programmazione.
@menu
* Funzione strtonum:: Da usare se non @`e disponibile la funzione
predefinita @code{strtonum()}.
* Funzione assert:: Una funzione per controllare affermazioni
in programmi @command{awk}.
* Funzione round:: Una funzione per eseguire arrotondamenti
se @code{sprintf()} non lo fa correttamente.
* Funzione random Cliff:: Il generatore Cliff di numeri casuali.
* Funzioni ordinali:: Funzioni per usare caratteri come numeri
e viceversa.
* Funzione join:: Una funzione per fondere un vettore
in una stringa.
* Funzione getlocaltime:: Una funzione per ottenere data e ora nel
formato desiderato.
* Funzione readfile:: Una funzione per leggere un file intero in
un colpo solo.
* Apici alla shell:: Una funzione per passare stringhe
con apici alla shell.
@end menu
@node Funzione strtonum
@subsection Conversione di stringhe in numeri
La funzione @code{strtonum()} (@pxref{Funzioni per stringhe})
@`e un'estensione @command{gawk}. La seguente funzione
fornisce un'implementazione per altre versioni di @command{awk}:
@example
@c file eg/lib/strtonum.awk
# mystrtonum --- converte stringhe in numeri
@c endfile
@ignore
@c file eg/lib/strtonum.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# February, 2004
# Revised June, 2014
@c endfile
@end ignore
@c file eg/lib/strtonum.awk
function mystrtonum(str, ret, n, i, k, c)
@{
if (str ~ /^0[0-7]*$/) @{
# ottale
n = length(str)
ret = 0
for (i = 1; i <= n; i++) @{
c = substr(str, i, 1)
# index() restituisce 0 se c non @`e nella stringa,
# e anche se c == "0"
k = index("1234567", c)
ret = ret * 8 + k
@}
@} else if (str ~ /^0[xX][[:xdigit:]]+$/) @{
# esadecimale
str = substr(str, 3) # via 0x iniziale
n = length(str)
ret = 0
for (i = 1; i <= n; i++) @{
c = substr(str, i, 1)
c = tolower(c)
# index() restituisce 0 se c non @`e nella stringa,
# e anche se c == "0"
k = index("123456789abcdef", c)
ret = ret * 16 + k
@}
@} else if (str ~ \
/^[-+]?([0-9]+([.][0-9]*([Ee][0-9]+)?)?|([.][0-9]+([Ee][-+]?[0-9]+)?))$/) @{
# numero decimale, eventualmente in virgola mobile
ret = str + 0
@} else
ret = "NON-UN-NUMERO"
return ret
@}
# BEGIN @{ # dati per un test
# a[1] = "25"
# a[2] = ".31"
# a[3] = "0123"
# a[4] = "0xdeadBEEF"
# a[5] = "123.45"
# a[6] = "1.e3"
# a[7] = "1.32"
# a[8] = "1.32E2"
#
# for (i = 1; i in a; i++)
# print a[i], strtonum(a[i]), mystrtonum(a[i])
# @}
@c endfile
@end example
La funzione cerca dapprima numeri ottali in stile C (base 8).
Se la stringa in input corrisponde all'espressione regolare che descrive i
numeri ottali, @code{mystrtonum()} esegue il ciclo per ogni carattere presente
nella stringa. Imposta @code{k} all'indice in @code{"1234567"} della cifra
ottale corrente.
Il codice di ritorno sar@`a lo stesso numero della cifra, o zero
se il carattere non c'@`e, il che succeder@`a per ogni cifra @samp{0}.
Questo si pu@`o fare, perch@'e il test di @dfn{regexp} nell'istruzione @code{if}
assicura che vengano scelti per
essere convertiti solo dei numeri ottali.
Una logica simile si applica al codice che ricerca e converte un
valore esadecimale, che inizia con @samp{0x} o @samp{0X}.
L'uso di @code{tolower()} semplifica il calcolo per trovare
il valore numerico corretto per ogni cifra esadecimale.
Infine, se la stringa corrisponde alla (piuttosto complicata) @dfn{regexp} per
un intero decimale regolare o per un numero in virgola mobile, il calcolo
@samp{ret = str + 0} fa s@`{@dotless{i}} che @command{awk} converta il valore in un
numero.
@`E incluso un programma di verifica commentato, in modo che la funzione possa
essere verificata con @command{gawk} e il risultato confrontato con la funzione
predefinita @code{strtonum()}.
@node Funzione assert
@subsection Asserzioni
@cindex asserzioni
@cindex @code{assert()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{assert()}
@cindex libreria di funzioni @command{awk} @subentry asserzioni
@cindex funzioni @subentry libreria di @subentry asserzioni
@cindex programmi @command{awk} @subentry asserzioni in programmi lunghi
Quando si scrivono grossi programmi, spesso @`e utile sapere se
una condizione o una serie di condizioni @`e verificata oppure no.
Prima di procedere
con un determinato calcolo, si fa un'affermazione su cosa si crede sia
vero. Tale affermazione @`e nota come
@dfn{asserzione}. Il linguaggio C fornisce un file di intestazione
@code{} e una corrispondente macro @code{assert()} che un
programmatore pu@`o utilizzare per fare asserzioni.
Se l'asserzione risulta falsa, la macro @code{assert()} predispone la
stampa di un messaggio diagnostico che descrive la condizione che
sarebbe dovuta essere vera ma che non lo era, e poi fa terminare
il programma.
In C, l'uso di @code{assert()} @`e simile a questo:
@example
@group
#include
int myfunc(int a, double b)
@{
assert(a <= 5 && b >= 17.1);
@dots{}
@}
@end group
@end example
Se l'asserzione @`e falsa, il programma stampa un messaggio simile a questo:
@example
prog.c:5: asserzione falsa: `a <= 5 && b >= 17.1'
@end example
@cindex @code{assert()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{assert()}
Il linguaggio C rende possibile trasformare questa condizione in una stringa
da
usare per stampare il messaggio di diagnosi. Ci@`o in @command{awk} non @`e
possibile, per cui la funzione @code{assert()} scritta in @command{awk}
richiede anche una descrizione
della condizione da verificare, in formato stringa.
La funzione @`e la seguente:
@example
@c file eg/lib/assert.awk
# assert --- Verifica una condizione. Se questa @`e falsa esce.
@c endfile
@ignore
@c file eg/lib/assert.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May, 1993
@c endfile
@end ignore
@c file eg/lib/assert.awk
function assert(condizione, stringa)
@{
if (! condizione) @{
printf("%s:%d: asserzione falsa: %s\n",
FILENAME, FNR, stringa) > "/dev/stderr"
_assert_exit = 1
exit 1
@}
@}
@group
END @{
if (_assert_exit)
exit 1
@}
@end group
@c endfile
@end example
La funzione @code{assert()} verifica il parametro @code{condizione}. Se
@`e falso, stampa un messaggio sullo standard error, usando il parametro
@code{stringa} per descrivere la condizione non verificata. Poi imposta la
variabile @code{_assert_exit} a uno ed esegue l'istruzione @code{exit}.
L'istruzione @code{exit} salta alla regola @code{END}. Se la regola @code{END}
trova vera la variabile @code{_assert_exit}, esce immediatamente.
Lo scopo della verifica nella regola @code{END} @`e quello di evitare che venga
eseguita qualsiasi altra eventuale regola @code{END}.
Quando un'asserzione non @`e
verificata, il programma dovrebbe uscire immediatamente.
Se nessuna asserzione
fallisce, @code{_assert_exit} @`e ancora falso quando la regola @code{END} @`e
eseguita normalmente, e le eventuali altre regole @code{END} del programma
vengono eseguite.
Affinch@'e tutto questo funzioni correttamente, @file{assert.awk} dev'essere il
primo file sorgente che viene letto da @command{awk}.
La funzione pu@`o essere usata in un programma nel seguente modo:
@example
function miafunz(a, b)
@{
assert(a <= 5 && b >= 17.1, "a <= 5 && b >= 17.1")
@dots{}
@}
@end example
@noindent
Se l'asserzione non @`e verificata, si vedr@`a un messaggio simile a questo:
@example
mydata:1357: asserzione falsa: a <= 5 && b >= 17.1
@end example
@cindex @code{END} (regola) @subentry funzione definita dall'utente @code{assert()} e
@cindex regola @subentry @code{END} @subentry funzione definita dall'utente @code{assert()} e
C'@`e un piccolo problema con questa versione di @code{assert()}.
Come visto, una regola @code{END} viene automaticamente aggiunta al programma
che chiama @code{assert()}. Normalmente, se un programma consiste
solo di una regola @code{BEGIN}, i file in input e/o lo standard input non
vengono letti. Tuttavia, ora che il programma ha una regola @code{END},
@command{awk} tenta di leggere i @value{DF} in input o lo standard input
(@pxref{Usare BEGIN/END}), provocando molto probabilmente la sospensione del
programma come se rimanesse in attesa di input.
@cindex @code{BEGIN} (regola) @subentry funzione definita dall'utente @code{assert()} e
@cindex regola @subentry @code{BEGIN} @subentry funzione definita dall'utente @code{assert()} e
C'@`e un modo per aggirare questo problema:
assicurarsi che la regola @code{BEGIN} termini sempre
con un'istruzione @code{exit}.
@node Funzione round
@subsection Arrotondamento di numeri
@cindex arrotondare @subentry numeri
@cindex numeri @subentry arrotondamento
@cindex libreria di funzioni @command{awk} @subentry arrotondamento di numeri
@cindex funzioni @subentry libreria di @subentry arrotondamento di numeri
@cindex @code{print} (istruzione) @subentry funzione @code{sprintf()} e
@cindex istruzione @subentry @code{print} @subentry funzione @code{sprintf()} e
@cindex @code{printf} (istruzione) @subentry funzione @code{sprintf()} e
@cindex istruzione @subentry @code{printf} @subentry funzione @code{sprintf()} e
@cindex @code{sprintf()} (funzione) @subentry istruzioni @code{print}/@code{printf} e
@cindex funzione @subentry @code{sprintf()} @subentry istruzioni @code{print}/@code{printf} e
Il modo in cui @code{printf} e @code{sprintf()}
(@pxref{Printf})
effettuano l'arrotondamento spesso dipende dalla subroutine C @code{sprintf()}
del sistema. Su molte macchine, l'arrotondamento di @code{sprintf()} @`e
@dfn{statistico}, il che significa che non sempre arrotonda un .5 finale per
eccesso, contrariamente alle normali aspettative. Nell'arrotondamento
statistico, .5 arrotonda alla cifra pari, anzich@'e sempre per eccesso, cos@`{@dotless{i}}
1.5 arrotonda a 2 e 4.5 arrotonda a 4. Ci@`o significa che se si sta usando un
formato che fa arrotondamenti (p.es. @code{"%.0f"}), si dovrebbe controllare
quello che fa il sistema che si sta usando. La seguente funzione esegue un
arrotondamento tradizionale; potrebbe essere utile nel caso in cui
l'istruzione @code{printf}
di @command{awk} che si sta usando faccia degli arrotondamenti statistici:
@cindex @code{round()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{round()}
@example
@c file eg/lib/round.awk
# round.awk --- effettua arrotondamento tradizionale
@c endfile
@ignore
@c file eg/lib/round.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# August, 1996
@c endfile
@end ignore
@c file eg/lib/round.awk
function round(x, ival, aval, frazione)
@{
ival = int(x) # parte intera, int() fa un troncamento
# vedere se c'@`e la parte frazionale
if (ival == x) # nessuna parte frazionale
return ival # nessun decimale
if (x < 0) @{
aval = -x # valore assoluto
ival = int(aval)
frazione = aval - ival
if (frazione >= .5)
return int(x) - 1 # -2.5 --> -3
else
return int(x) # -2.3 --> -2
@} else @{
frazione = x - ival
if (frazione >= .5)
return ival + 1
else
return ival
@}
@}
@c endfile
@c don't include test harness in the file that gets installed
@group
# codice per testare, commentato
# @{ print $0, round($0) @}
@end group
@end example
@node Funzione random Cliff
@subsection Il generatore di numeri casuali Cliff
@cindex numeri @subentry casuali @subentry generatore Cliff
@cindex Cliff @subentry generatore di numeri casuali
@cindex casuali @subentry numeri @subentry generatore Cliff di
@cindex funzioni @subentry libreria di @subentry numeri casuali Cliff
Il
@uref{http://mathworld.wolfram.com/CliffRandomNumberGenerator.html, generatore di numeri casuali Cliff}
@`e un generatore di numeri casuali molto semplice che ``passa il test della sfera
del rumore per la casualit@`a non mostrando di avere alcuna struttura.''
@`E programmato in modo molto semplice, in meno di 10 righe di codice
@command{awk}:
@cindex @code{cliff_rand()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{cliff_rand()}
@example
@c file eg/lib/cliff_rand.awk
# cliff_rand.awk --- generare numeri casuali con algoritmo di Cliff
@c endfile
@ignore
@c file eg/lib/cliff_rand.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# December 2000
@c endfile
@end ignore
@c file eg/lib/cliff_rand.awk
BEGIN @{ _cliff_seme = 0.1 @}
function cliff_rand()
@{
_cliff_seme = (100 * log(_cliff_seme)) % 1
if (_cliff_seme < 0)
_cliff_seme = - _cliff_seme
return _cliff_seme
@}
@c endfile
@end example
Questo algoritmo richiede un ``seme'' iniziale di 0,1. Ogni nuovo valore
usa il seme corrente come input per il calcolo.
Se la funzione predefinita @code{rand()}
(@pxref{Funzioni numeriche})
non @`e abbastanza casuale, si pu@`o tentare di usare al suo posto questa funzione.
@node Funzioni ordinali
@subsection Tradurre tra caratteri e numeri
@cindex libreria di funzioni @command{awk} @subentry valori di carattere come numeri
@cindex funzioni @subentry libreria di @subentry valori di carattere come numeri
@cindex caratteri @subentry valore come numero
@cindex numeri @subentry come valori di carattere
Un'implementazione commerciale di @command{awk} fornisce una funzione
predefinita @code{ord()}, che prende un carattere e restituisce il valore
numerico per quel carattere nella rappresentazione dei caratteri
di quella particolare macchina. Se la
stringa passata a @code{ord()} ha pi@`u di un carattere, viene usato solo il
primo.
L'inverso di questa funzione @`e @code{chr()} (dalla funzione con lo stesso nome
in Pascal), che, dato un numero, restituisce il corrispondente carattere.
Entrambe le funzioni si possono scrivere molto bene usando @command{awk};
non vi @`e nessun reale motivo per inglobarle come funzioni predefinite
@command{awk}:
@cindex @code{ord()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{ord()}
@cindex @code{chr()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{chr()}
@cindex @code{_ord_init()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{_ord_init()}
@example
@c file eg/lib/ord.awk
# ord.awk --- implementa ord e chr
# Identificativi globali:
# _ord_: valori numerici indicizzati da caratteri
# _ord_init: funzione per inizializzare _ord_
@c endfile
@ignore
@c file eg/lib/ord.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# 16 January, 1992
# 20 July, 1992, revised
@c endfile
@end ignore
@c file eg/lib/ord.awk
BEGIN @{ _ord_init() @}
function _ord_init( basso, alto, i, t)
@{
basso = sprintf("%c", 7) # BEL @`e ascii 7
if (basso == "\a") @{ # ascii regolare
basso = 0
alto = 127
@} else if (sprintf("%c", 128 + 7) == "\a") @{
# ascii, con il primo bit a 1 (mark)
basso = 128
alto = 255
@} else @{ # ebcdic(!)
basso = 0
alto = 255
@}
for (i = basso; i <= alto; i++) @{
t = sprintf("%c", i)
_ord_[t] = i
@}
@}
@c endfile
@end example
@cindex serie di caratteri (codifiche dei caratteri da parte della macchina)
@cindex ASCII
@cindex EBCDIC
@cindex Unicode
@cindex bit @subentry di parit@`a (in ASCII)
@cindex @dfn{mark} (bit di parit@`a in ASCII)
Alcune spiegazioni riguardo ai numeri usati da @code{_ord_init()}
non guastano.
La serie di caratteri pi@`u importante oggi in uso @`e nota come
ASCII.@footnote{La situazione sta per@`o
cambiando: molti sistemi usano Unicode, una serie di caratteri molto ampia
che comprende ASCII al suo interno.
Nei sistemi che supportano interamente Unicode,
un carattere pu@`o occupare fino a 32 bit, facendo diventare
i semplici test usati qui eccessivamente complessi.}
Sebbene un byte a
8 bit possa contenere 256 valori distinti (da 0 a 255), ASCII definisce solo i
caratteri che usano i valori da 0 a 127.@footnote{ASCII
@`e stato esteso in molti paesi per usare i valori da 128 a 255 includendo
i caratteri specifici del paese. Se il sistema in uso si avvale di queste
estensioni, si pu@`o semplificare @code{_ord_init()} per eseguire un ciclo da
0 a 255.} Nel lontano passato,
almeno un produttore di microcomputer
@c Pr1me, blech
ha usato ASCII, ma con una parit@`a di tipo @dfn{mark}, cio@`e con il bit pi@`u a
sinistra sempre a 1. Questo significa che su questi sistemi i caratteri
ASCII hanno valori numerici da 128 a 255.
Infine, i grandi elaboratori centrali usano la serie di caratteri EBCDIC, che
prevede tutti i 256 valori.
Ci sono altre serie di caratteri in uso su alcuni sistemi pi@`u vecchi, ma non
vale la pena di considerarli:
@example
@c file eg/lib/ord.awk
function ord(str, c)
@{
# solo il primo carattere @`e d'interesse
c = substr(str, 1, 1)
return _ord_[c]
@}
function chr(c)
@{
# trasforma c in un numero aggiungendo uno 0
return sprintf("%c", c + 0)
@}
@c endfile
#### programma di verifica ####
# BEGIN @{
# for (;;) @{
# printf("immetti un carattere: ")
# if (getline var <= 0)
# break
# printf("ord(%s) = %d\n", var, ord(var))
# @}
# @}
@c endfile
@end example
Un ovvio miglioramento a queste funzioni @`e quello di spostare il codice per la
funzione @code{@w{_ord_init}} nel corpo della regola @code{BEGIN}.
Il programma @`e
stato scritto inizialmente in questo modo per comodit@`a di sviluppo.
C'@`e un ``programma di verifica'' in una regola @code{BEGIN}, per verificare
la funzione. @`E commentato, per poter essere eventualmente usato in produzione.
@node Funzione join
@subsection Trasformare un vettore in una sola stringa
@cindex libreria di funzioni @command{awk} @subentry trasformare vettori in stringhe
@cindex funzioni @subentry libreria di @subentry trasformare vettori in stringhe
@cindex stringa @subentry trasformare vettore in
@cindex vettori @subentry trasformare in stringhe
Quando si fanno elaborazioni su stringhe, spesso @`e utile poter unire
tutte le stringhe di un vettore in una lunga stringa. La funzione seguente,
@code{join()}, svolge questo compito. Verr@`a utilizzata nel seguito in diversi
programmi applicativi
@iftex
(@pxrefil{Programmi di esempio}).
@end iftex
@ifnottex
(@pxref{Programmi di esempio}).
@end ifnottex
La buona progettazione di una funzione @`e importante; la funzione dev'essere
generale, ma potrebbe anche avere un ragionevole comportamento di default.
Viene chiamata con un vettore e anche con gli indici iniziale e finale degli
elementi del vettore da riunire.
Questo presuppone che gli indici del vettore
siano numerici---una supposizione logica, dato che il vettore probabilmente @`e
stato creato con @code{split()}
(@pxref{Funzioni per stringhe}):
@cindex @code{join()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{join()}
@example
@c file eg/lib/join.awk
# join.awk --- trasforma un vettore in una stringa
@c endfile
@ignore
@c file eg/lib/join.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
@c endfile
@end ignore
@c file eg/lib/join.awk
function join(vettore, iniz, fine, separ, risultato, i)
@{
if (separ == "")
separ = " "
else if (separ == SUBSEP) # valore magico
separ = ""
risultato = vettore[iniz]
for (i = iniz + 1; i <= fine; i++)
risultato = risultato separ vettore[i]
return risultato
@}
@c endfile
@end example
Un ulteriore argomento opzionale @`e il separatore da usare quando si uniscono
nuovamente le stringhe. Se il chiamante fornisce un valore non nullo,
@code{join()} usa quello; se non viene fornito,
per default ha un valore nullo.
In questo caso, @code{join()} usa uno spazio singolo come separatore
di default
per le stringhe. Se il valore @`e uguale a @code{SUBSEP},
@code{join()} unisce le stringhe senza un separatore tra di esse.
@code{SUBSEP} serve come valore ``magico'' per indicare che potrebbe non esserci
un separatore tra le stringhe componenti.@footnote{Sarebbe bello
se @command{awk} avesse un operatore di assegnamento per la concatenazione.
La mancanza di un esplicito operatore per la concatenazione rende le operazioni
sulle stringhe pi@`u difficili di quanto potrebbero essere.}
@node Funzione getlocaltime
@subsection Gestione dell'ora del giorno
@cindex libreria di funzioni @command{awk} @subentry gestire ora del giorno (marcature temporali)
@cindex funzioni @subentry libreria di @subentry gestione delle ore del giorno
@cindex data e ora @subentry formattazione
@cindex marcature temporali @subentry formattate
@cindex ora del giorno @subentry gestire
Le funzioni @code{systime()} e @code{strftime()} descritte nella
@ref{Funzioni di tempo}
forniscono la funzionalit@`a minima necessaria per visualizzare l'ora del giorno
in una forma intelligibile. Sebbene @code{strftime()} offra un'ampia gamma di
formattazioni, i formati di controllo non sono facili da ricordare o
intuitivamente ovvii quando si legge un programma.
La seguente funzione, @code{getlocaltime()}, riempie un vettore fornito
dall'utente con informazioni sul tempo preformattate. Restituisce una stringa
con data e ora corrente formattata come nel programma di utilit@`a @command{date}:
@cindex @code{getlocaltime()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getlocaltime()}
@example
@c file eg/lib/gettime.awk
# getlocaltime.awk --- ottiene l'ora del giorno in un formato usabile
@c endfile
@ignore
@c file eg/lib/gettime.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain, May 1993
#
@c endfile
@end ignore
@c file eg/lib/gettime.awk
# Restituisce una stringa nel formato dell'output di date(1)
# Riempie l'argomento del vettore ora con valori individuali:
# ora["second"] -- secondi (0 - 59)
# ora["minute"] -- minuti (0 - 59)
# ora["hour"] -- ore (0 - 23)
# ora["althour"] -- ore (0 - 12)
# ora["monthday"] -- giorno del mese (1 - 31)
# ora["month"] -- mese dell'anno (1 - 12)
# ora["monthname"] -- nome del mese
# ora["shortmonth"] -- nome breve del mese
# ora["year"] -- anno modulo 100 (0 - 99)
# ora["fullyear"] -- anno completo
# ora["weekday"] -- giorno della settimana (domenica = 0)
# ora["altweekday"] -- giorno della settimana (luned@`{@dotless{i}} = 0)
# ora["dayname"] -- nome del giorno della settimana
# ora["shortdayname"] -- nome breve del giorno della settimana
# ora["yearday"] -- giorno dell'anno (0 - 365)
# ora["timezone"] -- abbreviazione del nome della zona di fuso orario
# ora["ampm"] -- designazione di AM o PM
# ora["weeknum"] -- numero della settimana, domenica primo giorno
# ora["altweeknum"] -- numero della settimana, luned@`{@dotless{i}} primmo giorno
function getlocaltime(ora, ret, adesso, i)
@{
# ottiene data e ora una volta sola,
# evitando chiamate di sistema non necessarie
adesso = systime()
# restituisce l'output in stile date(1)
@c lun 8 giu 2015, 20.39.38, CEST
@c "%a %e %b %Y , %H.%M.%S, %Z"
ret = strftime("%a %e %b %Y, %H.%M.%S, %Z", adesso)
# clear out target array
delete time
# immette i valori, forzando i valori numerici
# a essere numerici aggiungendo uno 0
ora["second"] = strftime("%S", adesso) + 0
ora["minute"] = strftime("%M", adesso) + 0
ora["hour"] = strftime("%H", adesso) + 0
ora["althour"] = strftime("%I", adesso) + 0
ora["monthday"] = strftime("%d", adesso) + 0
ora["month"] = strftime("%m", adesso) + 0
ora["monthname"] = strftime("%B", adesso)
ora["shortmonth"] = strftime("%b", adesso)
ora["year"] = strftime("%y", adesso) + 0
ora["fullyear"] = strftime("%Y", adesso) + 0
ora["weekday"] = strftime("%w", adesso) + 0
ora["altweekday"] = strftime("%u", adesso) + 0
ora["dayname"] = strftime("%A", adesso)
ora["shortdayname"] = strftime("%a", adesso)
ora["yearday"] = strftime("%j", adesso) + 0
ora["timezone"] = strftime("%Z", adesso)
ora["ampm"] = strftime("%p", adesso)
ora["weeknum"] = strftime("%U", adesso) + 0
ora["altweeknum"] = strftime("%W", adesso) + 0
return ret
@}
@c endfile
@end example
Gli indici di stringa sono pi@`u facili da usare e leggere rispetto ai
vari formati
richiesti da @code{strftime()}. Il programma @code{alarm} illustrato in
@ref{Programma alarm}
usa questa funzione.
Una progettazione pi@`u generica della funzione @code{getlocaltime()}
avrebbe permesso all'utente di fornire un valore di data e ora
opzionale da usare al posto della data/ora corrente.
@node Funzione readfile
@subsection Leggere un intero file in una sola volta
Spesso @`e conveniente avere il contenuto di un intero file disponibile
in memoria, visto
come un'unica stringa. Un modo chiaro e semplice per far ci@`o potrebbe essere
questo:
@example
function readfile1(file, temp, contenuto)
@{
if ((getline temp < file) < 0)
return
contenuto = temp RT
while ((getline temp < file) > 0)
contenuto = contenuto temp RT
close(file)
return contenuto
@}
@end example
Questa funzione legge da @code{file} un record alla volta, ricostruendo
l'intero contenuto del file nella variabile locale @code{contenuto}.
Funziona, ma non @`e detto che sia efficiente.
La funzione seguente, basata su un suggerimento di Denis Shirokov,
legge l'intero contenuto del file in un colpo solo:
@cindex @code{readfile()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{readfile()}
@example
@c file eg/lib/readfile.awk
# readfile.awk --- legge un intero file in un colpo solo
@c endfile
@ignore
@c file eg/lib/readfile.awk
#
# Idea originale di Denis Shirokov, cosmogen@@gmail.com, aprile 2013
#
@c endfile
@end ignore
@c file eg/lib/readfile.awk
function readfile(file, temp, salva_rs)
@{
salva_rs = RS
RS = "^$"
getline temp < file
close(file)
RS = salva_rs
return temp
@}
@c endfile
@end example
Funziona impostando @code{RS} a @samp{^$}, un'espressione regolare che
non trova nessuna corrispondenza se il file ha un contenuto.
@command{gawk}
legge i dati dal file contenuto in @code{temp}, tentando di trovare una
corrispondenza con @code{RS}.
La ricerca dopo ogni lettura non ha mai successo, ma termina
rapidamente, e quindi @command{gawk} inserisce in
@code{temp} l'intero contenuto del file.
(@xref{Record} per informazioni su @code{RT} e @code{RS}.)
Se @code{file} @`e vuoto, il codice di ritorno @`e la stringa vuota.
Quindi, il codice chiamante pu@`o usare qualcosa simile a questo:
@example
contenuto = readfile("/qualche/percorso")
if (length(contenuto) == 0)
# file vuoto @dots{}
@end example
La verifica serve a determinare se il file @`e vuoto o no. Una verifica
equivalente potrebbe essere @samp{@w{contenuto == ""}}.
@xref{Esempio di estensione Readfile} per una funzione di estensione
anch'essa finalizzata a leggere un intero file in memoria.
@node Apici alla shell
@subsection Stringhe con apici da passare alla shell
@c included by permission
@ignore
Date: Sun, 27 Jul 2014 17:16:16 -0700
Message-ID:
Subject: Useful awk function
From: Mike Brennan
To: Arnold Robbins
@end ignore
Michael Brennan propone il seguente modello di programma,
da lui usato spesso:
@example
#! /bin/sh
awkp='
@dots{}
'
@var{specifica_programma_da_eseguire} | awk "$awkp" | /bin/sh
@end example
Per esempio, un suo programma chiamato @command{flac-edit}@footnote{I
file con suffisso @dfn{flac} contengono normalmente dei brani musicali.
@command{metaflac} @`e un programma che permette di modificare
le informazioni [@dfn{metadati}] contenute all'inizio di un file di tipo
@dfn{flac}.} ha questa forma:
@example
$ @kbd{flac-edit -song="Whoope! That's Great" file.flac}
@end example
@command{flac-edit} genera in output il seguente @dfn{script}, da passare alla
shell (@file{/bin/sh}) per essere eseguito:
@example
chmod +w file.flac
metaflac --remove-tag=TITLE file.flac
LANG=en_US.88591 metaflac --set-tag=TITLE='Whoope! That'"'"'s Great' file.flac
chmod -w file.flac
@end example
Si noti la necessit@`a di gestire gli apici nello @dfn{script} da passare alla shell.
La funzione
@code{shell_quote()} li prepara nel formato richiesto.
@code{SINGLE} @`e la stringa di un solo
carattere @code{"'"} e @code{QSINGLE} @`e la stringa di tre caratteri
@code{"\"'\""}:
@example
@c file eg/lib/shellquote.awk
# shell_quote --- pone tra apici un argomento da passare alla shell
@c endfile
@ignore
@c file eg/lib/shellquote.awk
#
# Michael Brennan
# brennan@@madronabluff.com
# September 2014
@c endfile
@end ignore
@c file eg/lib/shellquote.awk
function shell_quote(s, # parametro
SINGLE, QSINGLE, i, X, n, ret) # variabili locali
@{
if (s == "")
return "\"\""
SINGLE = "\x27" # apice singolo
QSINGLE = "\"\x27\"" # apice singolo incapsulato
n = split(s, X, SINGLE)
ret = SINGLE X[1] SINGLE
for (i = 2; i <= n; i++)
ret = ret QSINGLE SINGLE X[i] SINGLE
return ret
@}
@c endfile
@end example
@node Gestione File Dati
@section Gestione di @value{DF}
@cindex file @subentry gestione di
@cindex gestione di file
@cindex libreria di funzioni @command{awk} @subentry gestire file di dati
@cindex funzioni @subentry libreria di @subentry gestire file di dati
Questa @value{SECTION} presenta funzioni utili per gestire
@value{DF} da riga di comando.
@menu
* Funzione filetrans:: Una funzione per gestire il passaggio da un
file in input al successivo.
* Funzione rewind:: Una funzione per rileggere il file in input.
* Controllo di file:: Controllare che i file in input siano
accessibili.
* File vuoti:: Controllare se i file in input sono vuoti.
* Ignorare assegnamenti di variabili:: Trattare assegnamenti di variabili.
come nomi di file.
@end menu
@node Funzione filetrans
@subsection Trovare i limiti dei @value{DF}
@cindex file @subentry gestione di @subentry limiti dei file-dati
@cindex file @subentry inizializzazione e pulizia
Ognuna delle regole @code{BEGIN} ed @code{END} viene eseguita esattamente
solo una volta, rispettivamente all'inizio e alla fine del programma
@command{awk} (@pxref{BEGIN/END}).
Una volta noi (gli autori di @command{gawk}) siamo venuti in contatto
con un utente che
erroneamemnte pensava che le regole @code{BEGIN} venissero eseguite all'inizio
di ogni @value{DF} e le regole @code{END} alla fine di ogni @value{DF}.
Quando lo abbiamo informato che
non era cos@`{@dotless{i}}, ci ha chiesto di aggiungere un nuovo criterio di ricerca speciale
a @command{gawk}, chiamato @code{BEGIN_FILE} e @code{END_FILE}, che avesse il
comportamento desiderato. Ci ha fornito anche il codice per far questo.
Non @`e stato necessario aggiungere a @command{gawk} questi criteri di ricerca
speciali; il lavoro si pu@`o fare tranquillamente usando @command{awk}, come
illustrato nel seguente programma di libreria. @`E strutturato in modo da
chiamare due funzioni fornite dall'utente, @code{beginfile()} e
@code{endfile()}, all'inizio e alla fine di ogni @value{DF}. Oltre a risolvere
il problema in sole nove(!) righe di codice,
questa soluzione @`e @emph{portabile}; il
programma funziona con qualsiasi implementazione di @command{awk}:
@example
# transfile.awk
#
# Dare all'utente un aggancio per il passaggio
# da un file in input a quello successivo
#
# L'utente deve fornire le funzioni beginfile() ed endfile()
# ciascuna delle quali @`e invocata
# quando il file, rispettivamente,
# inizia e finisce.
@c #
@c # Arnold Robbins, arnold@@skeeve.com, Public Domain
@c # January 1992
FILENAME != _oldfilename_ && _filename_ != FILENAME @{
if (_oldfilename_ != "")
endfile(_oldfilename_)
_oldfilename_ = FILENAME
beginfile(FILENAME)
@}
END @{ endfile(FILENAME) @}
@end example
Questo file [transfile.awk] dev'essere caricato prima del programma
``principale'' dell'utente,
in modo che la regola ivi contenuta venga eseguita per prima.
Questa regola dipende dalla variabile di @command{awk} @code{FILENAME}, che
cambia automaticamente per ogni nuovo @value{DF}. Il @value{FN} corrente viene
salvato in una variabile privata, @code{_oldfilename_}. Se @code{FILENAME} non @`e
uguale a @code{_oldfilename_}, inizia l'elaborazioone di un nuovo @value{DF} ed
@`e necessario chiamare @code{endfile()} per il vecchio file. Poich@'e
@code{endfile()} dovrebbe essere chiamato solo se un file @`e stato elaborato, il
programma esegue prima un controllo per assicurarsi che @code{_oldfilename_} non
sia la stringa nulla. Il programma assegna poi il valore corrente di
@value{FN} a @code{_oldfilename_} e chiama @code{beginfile()} per il file.
Poich@'e, come tutte le variabili di @command{awk}, @code{_oldfilename_} @`e
inizializzato alla stringa nulla, questa regola viene eseguita correttamente
anche per il primo @value{DF}.
Il programma contiene anche una regola @code{END} per completare l'elaborazione
per l'ultimo file. Poich@'e questa regola @code{END} viene prima di qualsiasi
regola @code{END} contenuta nel programma ``principale'',
@code{endfile()} viene
chiamata per prima. Ancora una volta, l'utilit@`a di poter avere pi@`u regole
@code{BEGIN} ed @code{END} dovrebbe risultare chiara.
@cindex @code{beginfile()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{beginfile()}
@cindex @code{endfile()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{endfile()}
Se lo stesso @value{DF} compare due volte di fila sulla riga di comando,
@code{endfile()} e @code{beginfile()} non vengono eseguite alla fine del primo
passaggio e all'inizio del secondo passaggio.
La versione seguente risolve il problema:
@example
@c file eg/lib/ftrans.awk
# ftrans.awk --- gestisce il passaggio da un file dati al successivo
#
# L'utente deve fornire le funzioni beginfile() ed endfile()
@c endfile
@ignore
@c file eg/lib/ftrans.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# November 1992
@c endfile
@end ignore
@c file eg/lib/ftrans.awk
FNR == 1 @{
if (_filename_ != "")
endfile(_filename_)
_filename_ = FILENAME
beginfile(FILENAME)
@}
END @{ endfile(_filename_) @}
@c endfile
@end example
@iftex
La
@end iftex
@ref{Programma wc}
mostra come utilizzare questa funzione di libreria e come ci@`o
semplifichi la scrittura del programma principale.
@sidebar Allora perch@'e @command{gawk} ha @code{BEGINFILE} e @code{ENDFILE}?
Ci si chieder@`a, probabilmente: perch@'e, se le funzioni @code{beginfile()} e
@code{endfile()} possono eseguire il compito, @command{gawk} prevede i
criteri di
ricerca @code{BEGINFILE} e @code{ENDFILE}?
Buona domanda. Normalmente, se @command{awk} non riesce ad aprire un file,
questo fatto
provoca un errore fatale immediato. In tal caso, per una funzione definita
dall'utente non vi @`e alcun modo di affrontare il problema, giacch@'e la
chiamata verrebbe effettuata
solo dopo aver aperto il file e letto il primo record.
Quindi, la ragione principale di @code{BEGINFILE} @`e quella di dare un
``aggancio'' per gestire i file che non posso essere elaborati.
@code{ENDFILE} esiste per simmetria, e perch@'e consente facilmente
una pulizia "file per file". Per maggiori informazioni si faccia
riferimento alla @ref{BEGINFILE/ENDFILE}.
@end sidebar
@node Funzione rewind
@subsection Rileggere il file corrente
@cindex file @subentry rileggere
Un'altra richiesta per una nuova funzione predefinita @`e stata per
una funzione per rileggere il file corrente.
L'utente che l'ha richiesta non voleva dover usare @code{getline}
(@pxref{Getline})
all'interno di un ciclo.
Comunque, se non si @`e nella regola @code{END}, @`e piuttosto facile
fare in modo di chiudere il corrente file in input immediatamente
e ricominciare a leggerlo dall'inizio.
In mancanza di un nome migliore, chiameremo la funzione @code{rewind()}:
@cindex @code{rewind()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{rewind()}
@example
@c file eg/lib/rewind.awk
# rewind.awk --- ricarica il file corrente e ricomincia a leggerlo
@c endfile
@ignore
@c file eg/lib/rewind.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# September 2000
@c endfile
@end ignore
@c file eg/lib/rewind.awk
function rewind( i)
@{
# sposta in alto i rimanenti argomenti
for (i = ARGC; i > ARGIND; i--)
ARGV[i] = ARGV[i-1]
# assicurarsi che gawk sappia raggiungerli
ARGC++
# fa s@`{@dotless{i}} che il file corrente sia il prossimo a essere letto
ARGV[ARGIND+1] = FILENAME
# do it
nextfile
@}
@c endfile
@end example
La funzione @code{rewind()} dipende dalla variabile @code{ARGIND}
(@pxref{Variabili auto-assegnate}), che @`e specifica di @command{gawk}. Dipende anche
dalla parola chiave @code{nextfile} (@pxref{Istruzione nextfile}).
Perci@`o, non si dovrebbe chiamarla da una regola @code{ENDFILE}.
(Non sarebbe peraltro necessario, perch@'e @command{gawk} legge il file
successivo non appena la regola @code{ENDFILE} finisce!)
Occorre prestare attenzione quando si chiama @code{rewind()}. Si pu@`o
provocare una ricorsione infinita se non si sta attenti. Ecco un
esempio di uso:
@example
$ @kbd{cat dati}
@print{} a
@print{} b
@print{} c
@print{} d
@print{} e
$ cat @kbd{test.awk}
@print{} FNR == 3 && ! riavvolto @{
@print{} riavvolto = 1
@print{} rewind()
@print{} @}
@print{}
@print{} @{ print FILENAME, FNR, $0 @}
$ @kbd{gawk -f rewind.awk -f test.awk dati }
@print{} data 1 a
@print{} data 2 b
@print{} data 1 a
@print{} data 2 b
@print{} data 3 c
@group
@print{} data 4 d
@print{} data 5 e
@end group
@end example
@node Controllo di file
@subsection Controllare che i @value{DF} siano leggibili
@cindex risoluzione di problemi @subentry leggibilit@`a file-dati
@cindex leggibilit@`a @subentry di un file-dati @subentry controllare la
@cindex file @subentry non elaborare
Normalmente, se si fornisce ad @command{awk} un @value{DF} che non @`e leggibile,
il programma
si arresta con un errore fatale. Ci sono casi in cui sarebbe preferibile
ignorare semplicemente questi file e proseguire.@footnote{Il criterio di
ricerca speciale @code{BEGINFILE} (@pxref{BEGINFILE/ENDFILE}) fornisce un
meccanismo alternativo per trattare i file che non sono leggibili.
Tuttavia, il codice qui proposto fornisce una soluzione portabile.}
Si pu@`o far questo facendo precedere il proprio programma @command{awk} dal
seguente programma:
@cindex @code{readable.awk} (programma)
@example
@c file eg/lib/readable.awk
# readable.awk --- file di libreria per saltare file non leggibili
@c endfile
@ignore
@c file eg/lib/readable.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# October 2000
# December 2010
@c endfile
@end ignore
@c file eg/lib/readable.awk
BEGIN @{
for (i = 1; i < ARGC; i++) @{
if (ARGV[i] ~ /^[a-zA-Z_][a-zA-Z0-9_]*=.*/ \
|| ARGV[i] == "-" || ARGV[i] == "/dev/stdin")
continue # assegnamento di variabile o standard input
else if ((getline aperdere < ARGV[i]) < 0) # file non leggibile
delete ARGV[i]
else
close(ARGV[i])
@}
@}
@c endfile
@end example
@cindex risoluzione di problemi @subentry funzione @code{getline}
@cindex comando @subentry @code{getline} @subentry risoluzione di problemi
@cindex @code{getline} (comando) @subentry risoluzione di problemi
Questo codice funziona, perch@'e l'errore di @code{getline} non @`e fatale.
Rimuovendo l'elemento da @code{ARGV} con @code{delete}
si tralascia il file (perch@'e non @`e pi@`u nella lista).
Si veda anche @ref{ARGC e ARGV}.
Poich@'e per i nomi delle variabili @command{awk} si possono usare solo lettere
dell'alfabeto inglese, di proposito il controllo con espressioni regolari
non usa classi di
carattere come @samp{[:alpha:]} e @samp{[:alnum:]}
(@pxref{Espressioni tra parentesi quadre}).
@node File vuoti
@subsection Ricerca di file di lunghezza zero
Tutte le implementazioni note di @command{awk} ignorano senza
mandare alcun messaggio i file di
lunghezza zero. Questo @`e un effetto collaterale del ciclo implicito di
@command{awk} "leggi un record e confrontalo con le regole": quando
@command{awk} cerca di leggere un record da un file vuoto, riceve immediatamente
un'indicazione di fine-file [@dfn{end-of-file}], chiude il file,
e prosegue con il
successivo @value{DF} presente nella riga di comando, @emph{senza}
eseguire alcun codice
di programma @command{awk} a livello di utente.
Usando la variabile @code{ARGIND} di @command{gawk}
(@pxref{Variabili predefinite}), @`e possibile accorgersi quando un @value{DF}
@`e stato saltato. Simile al file di libreria illustrato in
@ref{Funzione filetrans}, il seguente file di libreria chiama una funzione
di nome @code{zerofile()} che l'utente deve fornire. Gli argomenti passati
sono il @value{FN} e la posizione del file in @code{ARGV}:
@cindex @code{zerofile.awk} (programma)
@example
@c file eg/lib/zerofile.awk
# zerofile.awk --- file di libreria per elaborare file in input vuoti
@c endfile
@ignore
@c file eg/lib/zerofile.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# June 2003
@c endfile
@end ignore
@c file eg/lib/zerofile.awk
BEGIN @{ Argind = 0 @}
ARGIND > Argind + 1 @{
for (Argind++; Argind < ARGIND; Argind++)
zerofile(ARGV[Argind], Argind)
@}
ARGIND != Argind @{ Argind = ARGIND @}
END @{
if (ARGIND > Argind)
for (Argind++; Argind <= ARGIND; Argind++)
zerofile(ARGV[Argind], Argind)
@}
@c endfile
@end example
La variabile definita dall'utente @code{Argind} permette al programma
@command{awk}
di tracciare il suo percorso all'interno di @code{ARGV}. Ogniqualvolta il
programma rileva che @code{ARGIND} @`e maggiore di @samp{Argind + 1}, vuol dire
che uno o pi@`u file vuoti sono stati tralasciati. L'azione chiama poi
@code{zerofile()} per ogni file che @`e stato saltato, incrementando
ogni volta @code{Argind}.
La regola @samp{Argind != ARGIND} tiene semplicemente aggiornato @code{Argind}
nel caso che non ci siano file vuoti.
Infine, la regola @code{END} prende in considerazione il caso di un qualsiasi
file vuoto alla fine degli argomenti nella riga di comando. Si noti che nella
condizione del ciclo @code{for}, la verifica usa l'operatore @samp{<=}, non
@samp{<}.
@node Ignorare assegnamenti di variabili
@subsection Trattare assegnamenti di variabile come @value{FNS}
@cindex assegnamento @subentry di variabile @subentry visti come nomi di file
@cindex file @subentry nomi di @subentry assegnamenti di variabile visti come
@cindex nomi @subentry di file @subentry assegnamenti di variabile visti come
Occasionalmente, potrebbe essere pi@`u opportuno che @command{awk} non elabori gli
assegnamenti di variabile presenti sulla riga di comando
(@pxref{Opzioni di assegnamento}).
In particolare, se si ha un @value{FN} che contiene un carattere @samp{=},
@command{awk} tratta il @value{FN} come un assegnamento e non lo elabora.
Alcuni utenti hanno suggerito un'opzione aggiuntiva da riga di comando per
@command{gawk} per disabilitare gli assegnamenti dati sulla riga di comando.
Comunque, poche righe di codice di programmazione in un file di libreria
hanno lo stesso effetto:
@cindex @code{noassign.awk} (programma)
@cindex programma @subentry @code{noassign.awk}
@example
@c file eg/lib/noassign.awk
# noassign.awk --- file di libreria per evitare la necessit@`a
# di una speciale opzione per disabilitare gli assegnamenti da
# riga di comando
@c endfile
@ignore
@c file eg/lib/noassign.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# October 1999
@c endfile
@end ignore
@c file eg/lib/noassign.awk
function disable_assigns(argc, argv, i)
@{
for (i = 1; i < argc; i++)
if (argv[i] ~ /^[a-zA-Z_][a-zA-Z0-9_]*=.*/)
argv[i] = ("./" argv[i])
@}
BEGIN @{
if (No_command_assign)
disable_assigns(ARGC, ARGV)
@}
@c endfile
@end example
Il programma va poi eseguito in questo modo:
@example
awk -v No_command_assign=1 -f noassign.awk -f vostro_programma.awk *
@end example
La funzione esegue un ciclo che esamina ogni argomento.
Antepone @samp{./} a
qualsiasi argomento che abbia la forma di un assegnamento
di variabile, trasformando cos@`{@dotless{i}} quell'argomento in un @value{FN}.
L'uso di @code{No_command_assign} consente di disabilitare assegnamenti di
variabile dati sulla riga di comando al momento dell'invocazione,
assegnando alla variabile un valore @dfn{vero}.
Se non viene impostata, la variabile @`e inizializzata a zero (cio@`e
@dfn{falso}), e gli argomenti sulla riga di comando
non vengono modificati.
@node Funzione getopt
@section Elaborare opzioni specificate sulla riga di comando
@cindex libreria di funzioni @command{awk} @subentry opzioni sulla riga di comando
@cindex funzioni @subentry libreria di @subentry opzioni sulla riga di comando
@cindex riga di comando @subentry opzioni @subentry elaborazione di
@cindex opzioni @subentry sulla riga di comando @subentry elaborazione di
@cindex funzioni @subentry di libreria C
@cindex argomenti @subentry elaborazione di
La maggior parte dei programmi di utilit@`a su sistemi compatibili con POSIX
prevedono opzioni presenti sulla riga di comando che possono essere usate per
cambiare il modo in cui un programma si comporta. @command{awk} @`e un esempio di
tali programmi (@pxref{Opzioni}).
Spesso le opzioni hanno degli @dfn{argomenti} (cio@`e, dati che servono al
programma per eseguire correttamente le opzioni specificate
sulla riga di comando).
Per esempio, l'opzione @option{-F} di @command{awk} richiede di usare la stringa
specificata
come separatore di campo. La prima occorrenza, sulla riga di comando, di
@option{--} o di una stringa che non inizia con @samp{-} segnala la fine
delle opzioni.
@cindex @code{getopt()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getopt()}
I moderni sistemi Unix hanno una funzione C chiamata @code{getopt()} per
elaborare gli argomenti presenti
sulla riga di comando. Il programmatore fornisce una
stringa che descrive le opzioni, ognuna delle quali consiste di
una sola lettera. Se un'opzione richiede un
argomento, nella stringa l'opzione @`e seguita da due punti (@code{:}).
A @code{getopt()} vengono anche
passati il numero e i valori degli argomenti presenti sulla riga di comando
e viene chiamata in un ciclo.
@code{getopt()} scandisce gli argomenti della riga di comando cercando
le lettere delle opzioni.
A ogni passaggio del ciclo restituisce un carattere
singolo che rappresenta la successiva lettera di opzione trovata, o @samp{?}
se viene trovata un'opzione non prevista.
Quando restituisce @minus{}1, non ci sono ulteriori
opzioni da trattare sulla riga di comando.
Quando si usa @code{getopt()}, le opzioni che non prevedono argomenti
possono essere raggruppate.
Inoltre, le opzioni che hanno argomenti richiedono obbligatoriamente che
l'argomento sia specificato.
L'argomento pu@`o seguire immediatamente la lettera
dell'opzione, o pu@`o costituire un argomento separato sulla riga di comando.
Dato un ipotetico programma che ha tre opzioni sulla riga di comando,
@option{-a}, @option{-b} e @option{-c}, dove
@option{-b} richiede un argomento, tutti i seguenti sono modi validi per
invocare il programma:
@example
programma -a -b pippo -c dati1 dati2 dati3
programma -ac -bpippo -- dati1 dati2 dati3
programma -acbpippo dati1 dati2 dati3
@end example
Si noti che quando l'argomento @`e raggruppato con la sua opzione,
la parte rimanente
dell'argomento @`e considerato come argomento dell'opzione.
In quest'esempio, @option{-acbpippo} indica che tutte le opzioni
@option{-a}, @option{-b} e @option{-c} sono presenti,
e che @samp{pippo} @`e l'argomento dell'opzione @option{-b}.
@code{getopt()} fornisce quattro variabili esterne a disposizione del
programmatore:
@table @code
@item optind
L'indice nel vettore dei valori degli argomenti (@code{argv}) dove si pu@`o
trovare il primo argomento sulla riga di comando che non sia un'opzione.
@item optarg
Il valore (di tipo stringa) dell'argomento di un'opzione.
@item opterr
Solitamente @code{getopt()} stampa un messaggio di errore quando trova un'opzione
non valida. Impostando @code{opterr} a zero si disabilita questa funzionalit@`a.
(un'applicazione potrebbe voler stampare un proprio messaggio di errore.)
@item optopt
La lettera che rappresenta l'opzione sulla riga di comando.
@end table
Il seguente frammento di codice C mostra come @code{getopt()} potrebbe
elaborare gli argomenti della riga di comando per @command{awk}:
@example
int
main(int argc, char *argv[])
@{
@dots{}
/* stampa un appropriato messaggio */
opterr = 0;
while ((c = getopt(argc, argv, "v:f:F:W:")) != -1) @{
switch (c) @{
case 'f': /* file */
@dots{}
break;
case 'F': /* separatore di campo */
@dots{}
break;
case 'v': /* assegnamento di variabile */
@dots{}
break;
case 'W': /* estensione */
@dots{}
break;
case '?':
default:
messaggio_di_aiuto();
break;
@}
@}
@dots{}
@}
@end example
La versione fornita dal progetto GNU dei programmi di utilit@`a
originali Unix hanno popolarizzato l'uso della versione lunga
delle opzioni immesse nella riga di comando. Per esempio,
@option{--help} in aggiunta a @option{-h}. Gli argomenti per queste
opzioni lunghe sono forniti come argomenti separati [da uno o
pi@`u spazi] sulla riga di comando (@samp{--source '@var{program-text}'})
oppure sono separati dalla relativa opzione da un segno @samp{=}
(@samp{--source='@var{program-text}'}).
Incidentalmente, @command{gawk} al suo interno usa la funzione GNU
@code{getopt_long()} per elaborare sia le normali opzioni che quelle lunghe
in stile GNU
(@pxref{Opzioni}).
L'astrazione fornita da @code{getopt()} @`e molto utile ed @`e piuttosto
comoda anche nei programmi @command{awk}. Di seguito si riporta una
versione @command{awk} di @code{getopt()} che accetta sia le opzioni+
lunghe che quelle corte.
Questa funzione mette in evidenza uno dei
maggiori punti deboli di @command{awk}, che @`e quello di essere molto carente
nella manipolazione di caratteri singoli. La funzione deve usare ripetute
chiamate a @code{substr()} per accedere a caratteri singoli
(@pxref{Funzioni per stringhe}).@footnote{Questa funzione
@`e stata scritta prima che @command{gawk} acquisisse la capacit@`a di
dividere le stringhe in caratteri singoli usando @code{""} come separatore.
@`E stata lasciata cos@`{@dotless{i}}, poich@'e l'uso di @code{substr()} @`e pi@`u portabile.}
La spiegazione della funzione viene data
man mano che si elencano i pezzi di codice che la compongono:
@cindex @code{getopt()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getopt()}
@example
@c file eg/lib/getopt.awk
# getopt.awk --- imita in awk la funzione di libreria C getopt(3)
# Supporta anche le opzioni lunghe.
@c endfile
@ignore
@c file eg/lib/getopt.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
#
# Initial version: March, 1991
# Revised: May, 1993
# Long options added by Greg Minshall, January 2020
@c endfile
@end ignore
@c file eg/lib/getopt.awk
# Variabili esterne:
# Optind -- indice in ARGV del primo argomento che non @`e un'opzione
# Optarg -- valore di tipo stringa dell'argomento dell'opzione corrente
# Opterr -- se diverso da zero, viene stampato un messaggio diagnostico
# Optopt -- lettera dell'opzione corrente
# Restituisce:
# -1 alla fine delle opzioni
# "?" per un'opzione non riconosciuta
# una stringa che rappresenta l'opzione corrente
# Dati privati:
# _opti -- indice in un'opzione multipla, p.es., -abc
@c endfile
@end example
La funzione inizia con commenti che elencano e descrivono le variabili globali
utilizzate, spiegano quali sono i codici di ritorno, il loro significato, e
ogni altra variabile che @`e
``esclusiva'' a questa funzione di libreria. Tale
documentazione @`e essenziale per qualsiasi programma, e in modo particolare per
le funzioni di libreria.
La funzione @code{getopt()} dapprima controlla di essere stata effettivamente
chiamata con una stringa di opzioni (il parametro @code{opzioni}). Se
sia @code{opzioni} che @code{opzioni_lunghe} hanno lunghezza zero,
@code{getopt()} restituisce immediatamente @minus{}1:
@cindex @code{getopt()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getopt()}
@example
@c file eg/lib/getopt.awk
function getopt(argc, argv, opzioni, opzioni_lunghe, unaopz, i)
@{
if (length(opzioni) == 0 && length(opzioni_lunghe) == 0)
return -1 # nessuna opzione specificata
@group
if (argv[Optind] == "--") @{ # fatto tutto
Optind++
_opti = 0
return -1
@end group
@} else if (argv[Optind] !~ /^-[^:[:space:]]/) @{
_opti = 0
return -1
@}
@c endfile
@end example
Il successivo controllo cerca la fine delle opzioni. Due trattini
(@option{--}) marcano la fine delle opzioni da riga di comando, e lo stesso
fa qualsiasi argomento sulla riga di comando che non inizi con @samp{-}
(a meno che non sia un argomento all'opzione immediatamente precedente).
@code{Optind} @`e usato per scorrere il vettore degli argomenti presenti
sulla riga di comando; mantiene il suo valore attraverso chiamate
successive a @code{getopt()}, perch@'e @`e una variabile globale.
L'espressione regolare @code{@w{/^-[^:[:space:]/}}, chiede di cercare un
@samp{-} seguito da qualsiasi cosa che non sia uno spazio vuoto o un carattere
di due punti (@code{:}).
Se l'argomento corrente sulla riga di comando non corrisponde a
quest'espressione regolare, vuol dire che non si tratta di un'opzione, e
quindi viene terminata l'elaborazione delle opzioni.
A questo punto si controlla se stiamo elaborando un'opzione corta (che
consiste di una sola lettera), oppure un'opzione lunga (indicata da due
trattini, p.es. @samp{--filename}). Se si tratta di un'opzione corta,
il programma prosegue cos@`{@dotless{i}}:
@example
@c file eg/lib/getopt.awk
if (argv[Optind] !~ /^--/) @{ # se opzione corta
if (_opti == 0)
_opti = 2
unaopz = substr(argv[Optind], _opti, 1)
Optopt = unaopz
i = index(opzioni, unaopz)
if (i == 0) @{
if (Opterr)
printf("%c -- opzione non ammessa\n", unaopz) > "/dev/stderr"
if (_opti >= length(argv[Optind])) @{
Optind++
_opti = 0
@} else
_opti++
return "?"
@}
@c endfile
@end example
La variabile @code{_opti} tiene traccia della posizione nell'argomento
della riga di comando correntemente in esame
(@code{argv[Optind]}). Se opzioni multiple sono
raggruppate con un @samp{-} (p.es., @option{-abx}), @`e necessario
restituirle all'utente una per volta.
Se @code{_opti} @`e uguale a zero, viene impostato a due, ossia all'indice
nella
stringa del successivo carattere da esaminare (@samp{-}, che @`e alla
posizione uno viene ignorato).
La variabile @code{unaopz} contiene il carattere,
ottenuto con @code{substr()}. Questo @`e salvato in @code{Optopt} per essere
usato dal programma principale.
Se @code{unaopz} non @`e nella stringa delle opzioni @code{opzioni},
si tratta di un'opzione
non valida. Se @code{Opterr} @`e diverso da zero, @code{getopt()} stampa un
messaggio di errore sullo @dfn{standard error} che @`e simile al messaggio
emesso dalla versione C di @code{getopt()}.
Poich@'e l'opzione non @`e valida, @`e necessario tralasciarla e passare al successivo
carattere di opzione. Se @code{_opti} @`e maggiore o uguale alla lunghezza
dell'argomento corrente della riga di comando, @`e necessario passare al
successivo argomento, in modo che @code{Optind} venga incrementato e
@code{_opti} sia reimpostato a zero. In caso contrario, @code{Optind} viene
lasciato com'@`e e @code{_opti} viene soltanto incrementato.
In ogni caso, poich@'e l'opzione non @`e valida, @code{getopt()} restituisce
@code{"?"}. Il programma principale pu@`o esaminare @code{Optopt} se serve
conoscere quale lettera di opzione @`e quella non valida. Proseguendo:
@example
@c file eg/lib/getopt.awk
if (substr(opzioni, i + 1, 1) == ":") @{
# ottiene un argomento di opzione
if (length(substr(argv[Optind], _opti + 1)) > 0)
Optarg = substr(argv[Optind], _opti + 1)
else
Optarg = argv[++Optind]
_opti = 0
@} else
Optarg = ""
@c endfile
@end example
Se l'opzione richiede un argomento, la lettera di opzione @`e seguita da
due punti (@code{:})
nella stringa @code{opzioni}. Se rimangono altri caratteri nell'argomento
corrente sulla riga di comando (@code{argv[Optind]}), il resto di quella stringa
viene assegnato a @code{Optarg}. Altrimenti, viene usato il successivo
argomento sulla riga di comando (@samp{-xFOO} piuttosto che
@samp{@w{-x FOO}}). In
entrambi i casi, @code{_opti} viene reimpostato a zero, perch@'e non ci sono altri
caratteri da esaminare nell'argomento corrente sulla riga di comando.
Continuando:
@example
@c file eg/lib/getopt.awk
if (_opti == 0 || _opti >= length(argv[Optind])) @{
Optind++
_opti = 0
@} else
_opti++
return unaopz
@c endfile
@end example
Infine, per un'opzione corta, se @code{_opti} @`e zero o maggiore della
lunghezza dell'argomento corrente sulla riga di comando, significa che
l'elaborazione di quest'elemento in @code{argv} @`e terminata, quindi
@code{Optind} @`e incrementato per puntare al successivo elemento
in @code{argv}. Se nessuna delle condizioni @`e vera, viene incrementato
solo @code{_opti}, cosicch@'e la successiva lettera di opzione pu@`o
essere elaborata con la successiva chiamata a @code{getopt()}.
D'altra parte, se il test precedente determina che si ha a che fare con
un'opzione lunga, il programma prosegue in maniera differente:
@example
@c file eg/lib/getopt.awk
@} else @{
j = index(argv[Optind], "=")
if (j > 0)
unaopz = substr(argv[Optind], 3, j - 3)
else
unaopz = substr(argv[Optind], 3)
Optopt = unaopz
@c endfile
@end example
Per prima cosa cerchiamo di vedere se quest'opzione contiene al suo
interno un segno "=", in quanto per le opzioni lunghe
(p.es. @samp{--unaopzione}) @`e possibile che il relativo argomento
sia specificato sia come @samp{--unaopzione=valore} che come
@samp{@w{--unaopzione valore}}.
@example
@c file eg/lib/getopt.awk
i = match(opzioni_lunghe, "(^|,)" unaopz "($|[,:])")
if (i == 0) @{
if (Opterr)
printf("%s -- opzione non ammessa\n", unaopz) > "/dev/stderr"
Optind++
return "?"
@}
@c endfile
@end example
Poi, si tenta di trovare l'opzione corrente in @code{opzioni_lunghe}.
L'espressione regolare fornita a @code{match()},
@code{@w{"(^|,)" unaopz "($|[,:])"}},
trova una corrispondenza per quest'opzione all'inizio di
@code{opzioni_lunghe}, o all'inizio di una successiva opzione lunga
(l'opzione lunga precedente dovrebbe essere delimitata da una
virgola) e, comunque, o alla fine della stringa @code{opzioni_lunghe}
(@samp{$}), oppure seguita da una virgola
(che separa quest'opzione da un'opzione successiva) da un
":" (che indica che quest'opzione lunga accetta un argomento
(@samp{@w{[,:]}}).
Utilizzando quest'espressione regolare, si controlla che l'opzione
corrente @`e presente oppure no in @code{opzioni_lunghe} (anche nel caso
in cui la stringa @code{opzioni_lunghe} non sia stata specificata, il test
dar@`a un risultato negativo). In caso di errore, si pu@`o stampare un
messaggio di errore e poi restituire @code{"?"}.
Si continua poi:
@example
@c file eg/lib/getopt.awk
if (substr(opzioni_lunghe, i+1+length(unaopz), 1) == ":") @{
if (j > 0)
Optarg = substr(argv[Optind], j + 1)
else
Optarg = argv[++Optind]
@} else
Optarg = ""
@c endfile
@end example
A questo punto si vede se quest'opzione accetta un argomento e, se
cos@`{@dotless{i}} @`e, si imposta @code{Optarg} al valore di tale argomento
(sia che si tratti del valore che segue il segno "=" sulla riga
di comando, sia che si tratti del successivo argomento sulla riga
si comando stessa).
@example
@c file eg/lib/getopt.awk
Optind++
return unaopz
@}
@}
@c endfile
@end example
Incrementiamo @code{Optind} (che era gi@`a stato incrementato una volta
se un argomento richiesto era separato dalla relativa opzione con un
segno di "="), e restituiamo l'opzione lunga (senza i trattini iniziali).
La regola @code{BEGIN} inizializza sia @code{Opterr} che @code{Optind} a uno.
@code{Opterr} viene impostato a uno, perch@'e il comportamento di default per
@code{getopt()} @`e quello di stampare un messaggio diagnostico dopo aver visto
un'opzione non valida. @code{Optind} @`e impostato a uno, perch@'e non
c'@`e alcun motivo
per considerare il nome del programma, che @`e in @code{ARGV[0]}:
@example
@c file eg/lib/getopt.awk
BEGIN @{
Opterr = 1 # il default @`e eseguire una diagnosi
Optind = 1 # salta ARGV[0]
# programma di controllo
if (_getopt_test) @{
_myshortopts = "ab:cd"
_mylongopts = "longa,longb:,otherc,otherd"
while ((_go_c = getopt(ARGC, ARGV, _myshortopts, _mylongopts)) != -1)
printf("c = <%s>, Optarg = <%s>\n", _go_c, Optarg)
printf("argomenti che non sono opzioni:\n")
for (; Optind < ARGC; Optind++)
printf("\tARGV[%d] = <%s>\n", Optind, ARGV[Optind])
@}
@}
@c endfile
@end example
Il resto della regola @code{BEGIN} @`e un semplice programma di controllo. Qui
sotto si riportano i risultati di
alcune esecuzioni di prova
del programma di controllo:
@example
$ @kbd{awk -f getopt.awk -v _getopt_test=1 -- -a -cbARG bax -x}
@print{} c = , Optarg = <>
@print{} c = , Optarg = <>
@print{} c = , Optarg =
@print{} argomenti che non sono opzioni:
@print{} ARGV[3] =
@print{} ARGV[4] = <-x>
$ @kbd{awk -f getopt.awk -v _getopt_test=1 -- -a -x -- xyz abc}
@print{} c = , Optarg = <>
@error{} x -- opzione non ammessa
@print{} c = , Optarg = <>
@print{} argomenti che non sono opzioni:
@print{} ARGV[4] =
@print{} ARGV[5] =
$ @kbd{awk -f getopt.awk -v _getopt_test=1 -- -a \}
> @kbd{--longa -b xx --longb=foo=bar --otherd --otherc arg1 arg2}
@print{} c = , Optarg = <>
@print{} c = , Optarg = <>
@print{} c = , Optarg =
@print{} c = , Optarg =
@print{} c = , Optarg = <>
@print{} c = , Optarg = <>
@print{} argomenti che non sono opzioni:
@print{} ARGV[8] =
@print{} ARGV[9] =
@end example
In tutte le esecuzioni, il primo @option{--} fa terminare gli argomenti dati
ad @command{awk}, in modo che @command{awk} non tenti di interpretare le opzioni
@option{-a}, etc. come sue opzioni.
@quotation NOTA
Dopo che @code{getopt()} @`e terminato,
il codice a livello utente deve eliminare tutti gli elementi
di @code{ARGV} da
1 a @code{Optind}, in modo che @command{awk} non tenti di elaborare le opzioni
sulla riga di comando come @value{FNS}.
@end quotation
Usare @samp{#!} con l'opzione @option{-E} pu@`o essere d'aiuto per evitare
conflitti tra le opzioni del proprio programma e quelle di @command{gawk},
poich@'e l'opzione @option{-E} fa s@`{@dotless{i}} che @command{gawk} abbandoni
l'elaborazione di ulteriori opzioni.
(@pxref{@dfn{Script} eseguibili} e
@ifnotdocbook
@pxref{Opzioni}).
@end ifnotdocbook
@ifdocbook
@ref{Opzioni}).
@end ifdocbook
Molti degli esempi presentati in
@ref{Programmi di esempio},
usano @code{getopt()} per elaborare i propri argomenti.
@node Funzioni Passwd
@section Leggere la lista degli utenti
@cindex libreria di funzioni @command{awk} @subentry leggere la lista degli utenti
@cindex funzioni @subentry libreria di @subentry leggere la lista degli utenti
@cindex utenti @subentry leggere la lista degli
@cindex lista degli utenti @subentry leggere la
@cindex @code{PROCINFO} (vettore)
@cindex vettore @subentry @code{PROCINFO}
Il vettore @code{PROCINFO}
(@pxref{Variabili predefinite})
d@`a accesso ai numeri ID reale ed effettivo dell'utente e del gruppo e, se
disponibili, alla serie di gruppi ulteriori a cui l'utente appartiene.
Comunque, poich@'e questi sono numeri, non forniscono informazioni molto utili per
l'utente medio. Bisogna trovare un modo per reperire informazioni
sull'utente associate con i numeri ID dell'utente e del gruppo. Questa
@value{SECTION} illustra una raccolta di funzioni per ottenere le informazioni
dalla lista gli utenti. @xref{Funzioni Group} per una raccolta di
funzioni simili per ottenere informazioni dalla lista dei gruppi.
@cindex @code{getpwent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getpwent()}
@cindex @code{getpwent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getpwent()}
@cindex utenti @subentry informazioni riguardo agli @subentry ottenere
@cindex login @subentry informazioni
@cindex account @subentry informazioni sugli
@cindex password @subentry file delle
@cindex file @subentry delle password
Lo standard POSIX non definisce il file dove sono mantenute le informazioni
degli utenti. Invece, fornisce il file d'intestazione @code{}
e diverse @dfn{subroutine} del linguaggio C per ottenere informazioni sugli
utenti. La funzione primaria @`e @code{getpwent()}, che sta per ``get password
entry''. La ``password'' proviene dal file originale della lista
degli utenti, @file{/etc/passwd}, che contiene le informazioni sugli utenti
assieme alle password criptate (da cui il nome).@footnote{Questo @`e
vero per le versioni pi@`u antiche di Unix. In quelle pi@`u recenti,
la @dfn{password} di ogni utente @`e stata trasferita nel file @file{/etc/shadow},
un file non accessibile dall'utente normale. La struttura del file
@file{/etc/passwd} @`e rimasta la stessa, ma al posto del campo @dfn{password}
c'@`e una @code{x}.}
@cindex @command{pwcat} (programma)
Sebbene un programma @command{awk} possa semplicemente leggere
@file{/etc/passwd} direttamente, questo file pu@`o non contenere tutte le
informazioni su tutti gli utenti del sistema.@footnote{Capita spesso che le
informazioni sulla password siano memorizzate in una lista in rete.} Per
essere sicuri di poter produrre una versione leggibile e completa della banca
dati degli utenti, @`e necessario scrivere un piccolo programma in C che chiama
@code{getpwent()}. @code{getpwent()} viene definita in modo da restituire un
puntatore a una @code{struct passwd}. Ogni volta che viene chiamata,
restituisce l'elemento successivo della lista. Quando non ci sono pi@`u
elementi, restituisce @code{NULL}, il puntatore nullo. Quando accade ci@`o, il
programma C dovrebbe chiamare @code{endpwent()} per chiudere la lista..
Quel che segue @`e @command{pwcat}, un programma in C che ``concatena'' la
lista delle password:
@example
@c file eg/lib/pwcat.c
/*
* pwcat.c
*
* Genera una versione stampabile della lista delle password.
*/
@c endfile
@ignore
@c file eg/lib/pwcat.c
/*
* Arnold Robbins, arnold@@skeeve.com, May 1993
* Public Domain
* December 2010, move to ANSI C definition for main().
*/
#if HAVE_CONFIG_H
#include
#endif
@c endfile
@end ignore
@c file eg/lib/pwcat.c
#include
#include
@c endfile
@ignore
@c file eg/lib/pwcat.c
#if defined (STDC_HEADERS)
#include
#endif
@c endfile
@end ignore
@c file eg/lib/pwcat.c
int
main(int argc, char **argv)
@{
struct passwd *p;
while ((p = getpwent()) != NULL)
@c endfile
@ignore
@c file eg/lib/pwcat.c
#ifdef ZOS_USS
printf("%s:%ld:%ld:%s:%s\n",
p->pw_name, (long) p->pw_uid,
(long) p->pw_gid, p->pw_dir, p->pw_shell);
#else
@c endfile
@end ignore
@c file eg/lib/pwcat.c
printf("%s:%s:%ld:%ld:%s:%s:%s\n",
p->pw_name, p->pw_passwd, (long) p->pw_uid,
(long) p->pw_gid, p->pw_gecos, p->pw_dir, p->pw_shell);
@c endfile
@ignore
@c file eg/lib/pwcat.c
#endif
@c endfile
@end ignore
@c file eg/lib/pwcat.c
endpwent();
return 0;
@}
@c endfile
@end example
Se non si conosce il linguaggio C, non @`e il caso di preoccuparsi.
L'output di @command{pwcat} @`e la lista degli utenti, nel formato
tradizionale del file @file{/etc/passwd} con campi separati da due punti (@code{:}).
I campi sono:
@table @asis
@item Login name
Il nome di login dell'utente.
@item Encrypted password
La password criptata dell'utente. Pu@`o non essere disponibile su alcuni sistemi.
@item User-ID
L'ID numerico dell'utente.
(Su alcuni sistemi, @`e un numero di formato @code{long} [32bit]
del linguaggio C, e non nel formato @code{int} [16bit].
Quindi, lo cambieremo in @code{long} per sicurezza.)
@item Group-ID
L'ID di gruppo numerico dell'utente.
(Valgono le stesse considerazioni su @code{long} al posto di @code{int}.)
@item Full name
Il nome completo dell'utente, e talora altre informazioni associate
all'utente.
@item Home directory
La directory di login (o ``home'') (nota ai programmatori di shell come
@code{$HOME}).
@item Login shell
Il programma che viene eseguito quando l'utente effettua l'accesso. Questo @`e
comunemente una shell, come Bash.
@end table
Di seguito si riportano alcune righe di un possibile output di @command{pwcat}:
@cindex Jacobs, Andrew
@cindex Robbins @subentry Arnold
@cindex Robbins @subentry Miriam
@example
$ @kbd{pwcat}
@print{} root:x:0:1:Operator:/:/bin/sh
@print{} nobody:x:65534:65534::/:
@print{} daemon:x:1:1::/:
@print{} sys:x:2:2::/:/bin/csh
@print{} bin:x:3:3::/bin:
@print{} arnold:x:2076:10:Arnold Robbins:/home/arnold:/bin/sh
@print{} miriam:x:112:10:Miriam Robbins:/home/miriam:/bin/sh
@print{} andy:x:113:10:Andy Jacobs:/home/andy:/bin/sh
@dots{}
@end example
Dopo quest'introduzione, di seguito si riporta un gruppo di funzioni per
ottenere informazioni sugli utenti. Ci sono diverse funzioni, che
corrispondono alle omonime funzioni C:
@cindex @code{_pw_init()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{_pw_init()}
@example
@c file eg/lib/passwdawk.in
# passwd.awk --- accedere alle informazioni del file delle password
@c endfile
@ignore
@c file eg/lib/passwdawk.in
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised October 2000
# Revised December 2010
@c endfile
@end ignore
@c file eg/lib/passwdawk.in
BEGIN @{
# modificare per adattarlo al sistema in uso
_pw_awklib = "/usr/local/libexec/awk/"
@}
function _pw_init( oldfs, oldrs, olddol0, pwcat, using_fw, using_fpat)
@{
if (_pw_inizializzato)
return
oldfs = FS
oldrs = RS
olddol0 = $0
using_fw = (PROCINFO["FS"] == "FIELDWIDTHS")
using_fpat = (PROCINFO["FS"] == "FPAT")
FS = ":"
RS = "\n"
pwcat = _pw_awklib "pwcat"
while ((pwcat | getline) > 0) @{
_pw_byname[$1] = $0
_pw_byuid[$3] = $0
_pw_bycount[++_pw_totale] = $0
@}
close(pwcat)
_pw_contatore = 0
_pw_inizializzato = 1
FS = oldfs
if (using_fw)
FIELDWIDTHS = FIELDWIDTHS
else if (using_fpat)
FPAT = FPAT
RS = oldrs
$0 = olddol0
@}
@c endfile
@end example
@cindex @code{BEGIN} (regola) @subentry programma @code{pwcat}
@cindex regola @subentry @code{BEGIN} @subentry programma @code{pwcat}
La regola @code{BEGIN} imposta una variabile privata col nome
della directory in cui si
trova @command{pwcat}.
Poich@'e @`e destinata a essere usata da una routine di
libreria di @command{awk}, si @`e scelto di metterla in
@file{/usr/local/libexec/awk}; comunque, in un altro sistema potrebbe
essere messa in una directory differente.
La funzione @code{_pw_init()} mette tre copie delle informazioni sull'utente in
tre vettori associativi. I vettori sono indicizzati per nome-utente
(@code{_pw_byname}), per numero di ID-utente (@code{_pw_byuid}), e per ordine di
occorrenza (@code{_pw_bycount}).
La variabile @code{_pw_inizializzato} @`e usata per
efficienza, poich@'e in questo modo @code{_pw_init()}
viene chiamata solo una volta.
@cindex @code{PROCINFO} (vettore) @subentry verificare la divisione in campi
@cindex vettore @subentry @code{PROCINFO} @subentry verificare la divisione in campi
@cindex @code{getline} (comando) @subentry funzione definita dall'utente, @code{_pw_init()}
@cindex comando @subentry @code{getline} @subentry funzione definita dall'utente, @code{_pw_init()}
Poich@'e questa funzione usa @code{getline} per leggere informazioni da
@command{pwcat}, dapprima salva i valori di @code{FS}, @code{RS} e @code{$0}.
Annota nella variabile @code{using_fw} se la suddivisione in campi
usando @code{FIELDWIDTHS} @`e attiva o no.
Far questo @`e necessario, poich@'e queste funzioni potrebbero essere chiamate da
qualsiai parte all'interno di un programma dell'utente, e l'utente pu@`o
suddividere i record in campi a suo piacimento.
Ci@`o rende possibile ripristinare il corretto meccanismo di suddivisione dei
campi in un secondo momento. La verifica pu@`o restituire solo @dfn{vero} per
@command{gawk}.
Il risultato pu@`o essere @dfn{falso} se si usa
@code{FS} o @code{FPAT},
o in qualche altra implementazione di @command{awk}.
Il codice che controlla se si sta usando @code{FPAT}, utilizzando
@code{using_fpat} e @code{PROCINFO["FS"]}, @`e simile.
La parte principale della funzione usa un ciclo per leggere le righe della
lista, suddividere le righe in campi, e poi memorizzare la riga
all'interno di ogni vettore a seconda delle necessit@`a. Quando il ciclo @`e
completato, @code{@w{_pw_init()}} fa pulizia chiudendo la @dfn{pipe},
impostando @code{@w{_pw_inizializzato}} a uno, e ripristinando @code{FS}
(e @code{FIELDWIDTHS} o @code{FPAT}
se necessario), @code{RS} e @code{$0}.
L'uso di @code{@w{_pw_contatore}} verr@`a spiegato a breve.
@cindex @code{getpwnam()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getpwnam()}
La funzione @code{getpwnam()} ha un nome utente come argomento di tipo
stringa. Se
quell'utente @`e presente nella lista, restituisce la riga appropriata.
Altrimenti, il riferimento a un elemento inesistente del vettore
aggiunge al vettore stesso un elemento il cui valore @`e la stringa nulla:
@cindex @code{getpwnam()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getpwnam()}
@example
@group
@c file eg/lib/passwdawk.in
function getpwnam(nome)
@{
_pw_init()
return _pw_byname[nome]
@}
@c endfile
@end group
@end example
@cindex @code{getpwuid()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getpwuid()}
In modo simile, la funzione @code{getpwuid()} ha per argomento
il numero ID di un utente.
Se un utente con quel numero si trova nella lista, restituisce la riga
appropriata. Altrimenti restituisce la stringa nulla:
@cindex @code{getpwuid()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getpwuid()}
@example
@c file eg/lib/passwdawk.in
function getpwuid(uid)
@{
_pw_init()
return _pw_byuid[uid]
@}
@c endfile
@end example
@cindex @code{getpwent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getpwent()}
La funzione @code{getpwent()} scorre semplicemnte la lista, un elemento
alla volta. Usa @code{_pw_contatore} per tener traccia della posizione corrente
nel vettore @code{_pw_bycount}:
@cindex @code{getpwent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getpwent()}
@example
@c file eg/lib/passwdawk.in
function getpwent()
@{
_pw_init()
if (_pw_contatore < _pw_totale)
return _pw_bycount[++_pw_contatore]
return ""
@}
@c endfile
@end example
@cindex @code{endpwent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{endpwent()}
La funzione @code{@w{endpwent()}} reimposta @code{@w{_pw_contatore}} a zero,
in modo che chiamate successive a @code{getpwent()} ricomincino da capo:
@cindex @code{endpwent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{endpwent()}
@example
@c file eg/lib/passwdawk.in
function endpwent()
@{
_pw_contatore = 0
@}
@c endfile
@end example
In questa serie di funzioni, il fatto che ogni subroutine chiami
@code{@w{_pw_init()}}
per inizializzare il vettore della lista utenti risponde a una precisa
scelta progettuale.
Il lavoro necessario per eseguire un processo separato che generi la
lista degli utenti, e l'I/O per esaminarla, si ha solo se il programma
principale dell'utente chiama effettivamente una di queste funzioni.
Se questo
file di libreria viene caricato assieme a un programma dell'utente, ma non
viene mai chiamata nessuna delle routine, non c'@`e nessun lavoro aggiuntivo
richiesto in fase di esecuzione.
(L'alternativa @`e quella di spostare il corpo di @code{@w{_pw_init()}}
all'interno di una regola @code{BEGIN}, che esegua sempre @command{pwcat}.
Questo semplifica il codice ma richiede di eseguire un processo extra
il cui risultato potrebbe non essere mai utilizzato dal programma.)
A sua volta, chiamare ripetutamente @code{_pw_init()} non @`e troppo
dispendioso, perch@'e la
variabile @code{_pw_inizializzato} permette di evitare di leggere
i dati relativi agli utenti pi@`u di una
volta. Se la preoccupazione @`e quella di minimizzare il tempo di
esecuzione del programma @command{awk},
il controllo di @code{_pw_inizializzato} potrebbe essere spostato
al di fuori di @code{_pw_init()} e duplicato in tutte le altre funzioni.
In pratica, questo non @`e necessario, poich@'e la maggior parte dei
programmi di @command{awk}
@`e I/O-bound@footnote{I programmi si distinguono tradizionalemente in
CPU-bound e I/O-bound. Quelli CPU-bound effettuano elaborazioni che non
richiedono molta attivit@`a di I/O, come ad esempio la preparazione di una
tavola di numeri primi. Quelli I/O bound leggono dei file, ma richiedono
poca attivit@`a di elaborazione per ogni record letto.},
e una tale modifica complicherebbe inutilmente il codice.
Il programma @command{id} in @ref{Programma id}
usa queste funzioni.
@node Funzioni Group
@section Leggere la lista dei gruppi
@cindex libreria di funzioni @command{awk} @subentry leggere la lista dei gruppi
@cindex funzioni @subentry libreria di @subentry leggere la lista dei gruppi
@cindex gruppi @subentry lista dei @subentry leggere la
@cindex lista dei gruppi @subentry leggere la
@cindex @code{PROCINFO} (vettore) @subentry appartenenza a gruppi e
@cindex @code{getgrent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getgrent()}
@cindex @code{getgrent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getgrent()}
@cindex gruppi @subentry informazioni sui
@cindex account @subentry informazioni sugli
@cindex gruppi @subentry file dei
@cindex file @subentry dei gruppi
Molto di quel che @`e stato detto
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzioni Passwd}
vale anche per la lista dei gruppi. Sebbene questa sia tradizionalmente
contenuta in
un file ben noto (@file{/etc/group}) in un altrettanto noto formato,
lo standard
POSIX prevede solo una serie di routine della libreria C
(@code{} e @code{getgrent()})
per accedere a tali informazioni.
Anche se il file suddetto @`e disponibile, potrebbe non contenere delle
informazioni
complete. Perci@`o, come per la lista degli utenti, @`e necessario avere un
piccolo programma in C che genera la lista dei gruppi come suo output.
@command{grcat}, un programma in C che fornisce la lista dei gruppi,
@`e il seguente:
@cindex @command{grcat} (programma C)
@cindex programma C @subentry @command{grcat}
@example
@c file eg/lib/grcat.c
/*
* grcat.c
*
* Genera una versione stampabile della lista dei gruppi.
*/
@c endfile
@ignore
@c file eg/lib/grcat.c
/*
* Arnold Robbins, arnold@@skeeve.com, May 1993
* Public Domain
* December 2010, move to ANSI C definition for main().
*/
#if HAVE_CONFIG_H
#include
#endif
#if defined (STDC_HEADERS)
#include
#endif
#ifndef HAVE_GETGRENT
int main() { return 0; }
#else
@c endfile
@end ignore
@c file eg/lib/grcat.c
#include
#include
int
main(int argc, char **argv)
@{
struct group *g;
int i;
while ((g = getgrent()) != NULL) @{
@c endfile
@ignore
@c file eg/lib/grcat.c
#ifdef HAVE_STRUCT_GROUP_GR_PASSWD
@c endfile
@end ignore
@c file eg/lib/grcat.c
printf("%s:%s:%ld:", g->gr_name, g->gr_passwd,
(long) g->gr_gid);
@c endfile
@ignore
@c file eg/lib/grcat.c
#else
printf("%s:*:%ld:", g->gr_name, (long) g->gr_gid);
#endif
@c endfile
@end ignore
@c file eg/lib/grcat.c
for (i = 0; g->gr_mem[i] != NULL; i++) @{
printf("%s", g->gr_mem[i]);
@group
if (g->gr_mem[i+1] != NULL)
putchar(',');
@}
@end group
putchar('\n');
@}
endgrent();
return 0;
@}
@c endfile
@ignore
@c file eg/lib/grcat.c
#endif /* HAVE_GETGRENT */
@c endfile
@end ignore
@end example
Ciascuna riga nella lista dei gruppi rappresenta un gruppo. I campi sono
separati da due punti (@code{:}) e rappresentano le seguenti informazioni:
@table @asis
@item Nome del gruppo
Il nome del gruppo.
@item Password del gruppo
La password del gruppo criptata. In pratica, questo campo non viene mai usato;
normalmente @`e vuoto o impostato a @samp{x}.
@item Numero ID del gruppo
Il numero ID del gruppo in formato numerico;
l'associazione del nome al numero dev'essere univoca all'interno di questo file.
(Su alcuni sistemi, @`e un numero nel formato @code{long} [32bit]
del linguaggio C, e non nel formato @code{int} [16bit].
Quindi, lo cambieremo in @code{long} per sicurezza.)
@item Lista dei membri del gruppo
Una lista di nomi utente separati da virgole.
Questi utenti sono i membri del gruppo.
I sistemi Unix moderni consentono agli utenti di appartenere a
diversi gruppi simultaneamente. Se il sistema in uso @`e uno di questi, ci sono
elementi in @code{PROCINFO} che vanno da @code{"group1"} fino a
@code{"group@var{N}"} per quei numeri di ID di gruppo.
(Si noti che @code{PROCINFO} @`e un'estensione @command{gawk};
@pxref{Variabili predefinite}.)
@end table
Di seguito si riporta quel che @command{grcat} potrebbe produrre:
@example
$ @kbd{grcat}
@print{} wheel:x:0:arnold
@print{} nogroup:x:65534:
@print{} daemon:x:1:
@print{} kmem:x:2:
@print{} staff:x:10:arnold,miriam,andy
@print{} other:x:20:
@dots{}
@end example
Qui ci sono le funzioni per ottenere informazioni relative alla lista dei
gruppi. Ce ne sono diverse, costruite sul modello delle omonime funzioni della
libreria C:
@cindex @code{getline} (comando) @subentry funzione definita dall'utente, @code{_gr_init()}
@cindex comando @subentry @code{getline} @subentry funzione definita dall'utente, @code{_gr_init()}
@cindex @code{_gr_init()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{_gr_init()}
@example
@c file eg/lib/groupawk.in
# group.awk --- funzioni per il trattamento del file dei gruppi
@c endfile
@ignore
@c file eg/lib/groupawk.in
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised October 2000
# Revised December 2010
@c endfile
@end ignore
@c line break on _gr_init for smallbook
@c file eg/lib/groupawk.in
BEGIN @{
# Modificare in base alla struttura del proprio sistema
_gr_awklib = "/usr/local/libexec/awk/"
@}
function _gr_init( oldfs, oldrs, olddol0, grcat,
using_fw, using_fpat, n, a, i)
@{
if (_gr_inizializzato)
return
oldfs = FS
oldrs = RS
olddol0 = $0
using_fw = (PROCINFO["FS"] == "FIELDWIDTHS")
using_fpat = (PROCINFO["FS"] == "FPAT")
FS = ":"
RS = "\n"
grcat = _gr_awklib "grcat"
while ((grcat | getline) > 0) @{
if ($1 in _gr_byname)
_gr_byname[$1] = _gr_byname[$1] "," $4
else
_gr_byname[$1] = $0
if ($3 in _gr_bygid)
_gr_bygid[$3] = _gr_bygid[$3] "," $4
else
_gr_bygid[$3] = $0
n = split($4, a, "[ \t]*,[ \t]*")
for (i = 1; i <= n; i++)
if (a[i] in _gr_groupsbyuser)
_gr_groupsbyuser[a[i]] = _gr_groupsbyuser[a[i]] " " $1
else
_gr_groupsbyuser[a[i]] = $1
_gr_bycount[++_gr_contatore] = $0
@}
close(grcat)
_gr_contatore = 0
_gr_inizializzato++
FS = oldfs
if (using_fw)
FIELDWIDTHS = FIELDWIDTHS
else if (using_fpat)
FPAT = FPAT
RS = oldrs
$0 = olddol0
@}
@c endfile
@end example
La regola @code{BEGIN} imposta una variabile privata con il nome della
directory in cui si trova @command{grcat}.
Poich@'e @`e destinata a essere usata da una routine di
libreria di @command{awk}, si @`e scelto di metterla in
@file{/usr/local/libexec/awk}; comunque, in un altro sistema potrebbe
essere messa in una directory differente.
Queste routine seguono le stesse linee generali delle routine per formare la
lista degli utenti (@pxref{Funzioni Passwd}).
La variabile @code{@w{_gr_inizializzato}} @`e usata per
essere sicuri che la lista venga letta una volta sola.
La funzione @code{@w{_gr_init()}} dapprima salva @code{FS},
@code{RS} e
@code{$0}, e poi imposta @code{FS} e @code{RS} ai valori da usare nel
passare in rassegna le informazioni di gruppo. Inoltre
viene annotato se si stanno usando @code{FIELDWIDTHS} o @code{FPAT}, per
poter poi
ripristinare il meccanismo di suddivisione in campi appropriato.
Le informazioni sui gruppi sono memorizzate in diversi vettori associativi.
I vettori sono indicizzati per nome di gruppo (@code{@w{_gr_byname}}), per
numero ID del gruppo (@code{@w{_gr_bygid}}), e per posizione nella lista
(@code{@w{_gr_bycount}}). C'@`e un vettore aggiuntivo indicizzato per nome utente
(@code{@w{_gr_groupsbyuser}}), che @`e una lista, separata da spazi, dei
gruppi ai quali ciascun utente appartiene.
Diversamente dalla lista degli utenti, @`e possibile avere pi@`u record
nella lista per lo stesso gruppo. Questo @`e frequente quando un gruppo ha
un gran numero di membri. Un paio di tali voci potrebbero essere come queste:
@example
tvpeople:x:101:johnny,jay,arsenio
tvpeople:x:101:david,conan,tom,joan
@end example
Per questo motivo, @code{_gr_init()} controlla se un nome di gruppo o un numero
di ID di gruppo @`e stato gi@`a visto. Se cos@`{@dotless{i}} fosse, i nomi utente vanno
semplicemente concatenati con la precedente lista di utenti.@footnote{C'@`e un
piccolo problema col codice appena illustrato. Supponiamo che la prima volta
non ci siano nomi. Questo codice aggiunge i nomi con una virgola iniziale.
Inoltre non controlla che ci sia un @code{$4}.}
Infine, @code{_gr_init()} chiude la @dfn{pipe} a @command{grcat}, ripristina
@code{FS} (e @code{FIELDWIDTHS} o @code{FPAT}, se necessario), @code{RS} e
@code{$0}, inizializza @code{_gr_contatore} a zero
(per essere usato pi@`u tardi), e rende @code{_gr_inizializzato} diverso da zero.
@cindex @code{getgrnam()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getgrnam()}
La funzione @code{getgrnam()} ha come argomento un nome di gruppo, e se quel
gruppo esiste, viene restituito.
Altrimenti, il riferimento a un elemento inesistente del vettore
aggiunge al vettore stesso un elemento il cui valore @`e la stringa nulla:
@cindex @code{getgrnam()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getgrnam()}
@example
@c file eg/lib/groupawk.in
function getgrnam(group)
@{
_gr_init()
return _gr_byname[group]
@}
@c endfile
@end example
@cindex @code{getgrgid()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getgrgid()}
La funzione @code{getgrgid()} @`e simile; ha come argomento un numero ID di
gruppo e controlla le informazioni assiciate con quell'ID di gruppo:
@cindex @code{getgrgid()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getgrgid()}
@example
@c file eg/lib/groupawk.in
function getgrgid(gid)
@{
_gr_init()
return _gr_bygid[gid]
@}
@c endfile
@end example
@cindex @code{getgruser()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getgruser()}
La funzione @code{getgruser()} non ha un equivalente in C. Ha come argomento un
nome-utente e restituisce l'elenco dei gruppi di cui l'utente @`e membro:
@cindex @code{getgruser()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getgruser()}
@example
@c file eg/lib/groupawk.in
function getgruser(user)
@{
_gr_init()
return _gr_groupsbyuser[user]
@}
@c endfile
@end example
@cindex @code{getgrent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getgrent()}
La funzione @code{getgrent()} scorre la lista un elemento alla volta.
Usa @code{_gr_contatore} per ricordare la posizione corrente nella lista:
@cindex @code{getgrent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{getgrent()}
@example
@c file eg/lib/groupawk.in
function getgrent()
@{
_gr_init()
if (++_gr_contatore in _gr_bycount)
return _gr_bycount[_gr_contatore]
@group
return ""
@}
@end group
@c endfile
@end example
@cindex @code{endgrent()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{endgrent()}
La funzione @code{endgrent()} reimposta @code{_gr_contatore} a zero in modo che
@code{getgrent()} possa ricominciare da capo:
@cindex @code{endgrent()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{endgrent()}
@example
@c file eg/lib/groupawk.in
function endgrent()
@{
_gr_contatore = 0
@}
@c endfile
@end example
Come con le routine per la lista degli utenti, ogni funzione chiama
@code{_gr_init()} per inizializzare i vettori.
Cos@`{@dotless{i}} facendo si avr@`a il solo
lavoro aggiuntivo di eseguire @command{grcat} se queste funzioni vengono
usate (rispetto a spostare il corpo di @code{_gr_init()} all'interno della
regola @code{BEGIN}).
La maggior parte del lavoro consiste nell'ispezionare la lista e nel
costruire i vari vettori associativi. Le funzioni che l'utente chiama sono
di per s@'e molto semplici, poich@'e si appoggiano sui vettori associativi di
@command{awk} per fare il lavoro.
Il programma @command{id} in @ref{Programma id}
usa queste funzioni.
@node Visitare vettori
@section Attraversare vettori di vettori
@iftex
La
@end iftex
@ref{Vettori di vettori} trattava di come @command{gawk}
mette a disposizione vettori di vettori. In particolare, qualsiasi elemento di
un vettore pu@`o essere uno scalare o un altro vettore. La funzione
@code{isarray()} (@pxref{Funzioni per i tipi})
permette di distinguere un vettore
da uno scalare.
La seguente funzione, @code{walk_array()}, attraversa ricorsivamente
un vettore, stampando gli indici e i valori di ogni elemento.
Viene chiamata col vettore e con una stringa che contiene il nome
del vettore:
@cindex @code{walk_array()} @subentry funzione definita dall'utente
@cindex funzione definita dall'utente @subentry @code{walk_array()}
@example
@c file eg/lib/walkarray.awk
function walk_array(vett, nome, i)
@{
for (i in vett) @{
if (isarray(vett[i]))
walk_array(vett[i], (nome "[" i "]"))
else
printf("%s[%s] = %s\n", nome, i, vett[i])
@}
@}
@c endfile
@end example
@noindent
Funziona eseguendo un ciclo su ogni elemento del vettore. Se un dato elemento
@`e esso stesso un vettore, la funzione chiama s@'e stessa ricorsivamente,
passando il sottovettore e una nuova stringa che rappresenta l'indice corrente.
In caso contrario, la funzione stampa semplicemente il nome, l'indice e il
valore dell'elemento.
Qui di seguito si riporta un programma principale che ne mostra l'uso:
@example
BEGIN @{
a[1] = 1
a[2][1] = 21
a[2][2] = 22
a[3] = 3
a[4][1][1] = 411
a[4][2] = 42
walk_array(a, "a")
@}
@end example
Quando viene eseguito, il programma produce il seguente output:
@example
$ @kbd{gawk -f walk_array.awk}
@print{} a[1] = 1
@print{} a[2][1] = 21
@print{} a[2][2] = 22
@print{} a[3] = 3
@print{} a[4][1][1] = 411
@print{} a[4][2] = 42
@end example
La funzione appena illustrata stampa semplicemente il nome e il valore
di ogni elemento costituito da un vettore scalare. Comunque @`e facile
generalizzarla, passandole il nome di una funzione da chiamare
quando si attraversa un vettore. La funzione modificata @`e simile a questa:
@example
@c file eg/lib/processarray.awk
function process_array(vett, nome, elab, do_arrays, i, nuovo_nome)
@{
for (i in vett) @{
nuovo_nome = (nome "[" i "]")
if (isarray(vett[i])) @{
if (do_arrays)
@@elab(nuovo_nome, vett[i])
process_array(vett[i], nuovo_nome, elab, do_arrays)
@} else
@@elab(nuovo_nome, vett[i])
@}
@}
@c endfile
@end example
Gli argomenti sono i seguenti:
@table @code
@item vett
Il vettore.
@item nome
Il nome del vettore (una stringa).
@item elab
Il nome della funzione da chiamare.
@item do_arrays
Se vale @dfn{vero}, la funzione pu@`o gestire elementi che sono sottovettori.
@end table
Se devono essere elaborati sottovettori, questo vien fatto prima di
attraversarne altri.
Quando viene eseguita con la seguente struttura, la funzione produce lo stesso
risultato della precedente versione di @code{walk_array()}:
@example
BEGIN @{
a[1] = 1
a[2][1] = 21
a[2][2] = 22
a[3] = 3
a[4][1][1] = 411
a[4][2] = 42
process_array(a, "a", "do_print", 0)
@}
function do_print(nome, elemento)
@{
printf "%s = %s\n", nome, elemento
@}
@end example
@node Sommario funzioni di libreria
@section Riassunto
@itemize @value{BULLET}
@item
Leggere i programmi @`e un eccellente metodo per imparare la "buona
programmazione". Le funzioni e i programmi contenuti in questo @value{CHAPTER}
e nel successivo si propongo questo obiettivo.
@item
Quando si scrivono funzioni di libreria di uso generale, si deve stare attenti
ai nomi da dare alle variabili globali, facendo in modo che non entrino in
conflitto con le variabili di un programma dell'utente.
@item
Le funzioni descritte qui appartengono alle seguenti categorie:
@c nested list
@table @asis
@item Problemi generali
Conversione di numeri in stringhe, verifica delle asserzioni, arrotondamenti,
generazione di numeri casuali, conversione di caratteri in numeri, unione di
stringhe, ottenimento di informazioni su data e ora facilmente usabili,
e lettura di un intero file in una volta sola
@item Gestione dei @value{DF}
Annotazione dei limiti di un @value{DF}, rilettura del file corrente,
ricerca di
file leggibili, ricerca di file di lunghezza zero, e trattamento degli
assegnamenti di variabili fatti sulla riga comando come @value{FNS}
@item Elaborazione di opzioni sulla riga di comando
Una versione @command{awk} della funzione del C standard @code{getopt()}
@item Lettura dei file degli utenti e dei gruppi
Due serie di routine equivalenti alle versioni disponibili nella libreria
del linguaggio C
@item Attraversamento di vettori di vettori
Due funzioni che attraversano un vettore di vettori fino in fondo
@end table
@c end nested list
@end itemize
@c EXCLUDE START
@node Esercizi con le librerie
@section Esercizi
@enumerate
@item
@iftex
Nella
@end iftex
@ifnottex
In
@end ifnottex
@ref{File vuoti}, abbiamo illustrato il programma @file{zerofile.awk},
che fa uso della variabile di @command{gawk} @code{ARGIND}. Questo problema pu@`o
essere risolto senza dipendere da @code{ARGIND}? Se s@`{@dotless{i}}, come?
@ignore
# zerofile2.awk --- same thing, portably
BEGIN @{
ARGIND = Argind = 0
for (i = 1; i < ARGC; i++)
Fnames[ARGV[i]]++
@}
FNR == 1 @{
while (ARGV[ARGIND] != FILENAME)
ARGIND++
Seen[FILENAME]++
if (Seen[FILENAME] == Fnames[FILENAME])
do
ARGIND++
while (ARGV[ARGIND] != FILENAME)
@}
ARGIND > Argind + 1 @{
for (Argind++; Argind < ARGIND; Argind++)
zerofile(ARGV[Argind], Argind)
@}
ARGIND != Argind @{
Argind = ARGIND
@}
END @{
if (ARGIND < ARGC - 1)
ARGIND = ARGC - 1
if (ARGIND > Argind)
for (Argind++; Argind <= ARGIND; Argind++)
zerofile(ARGV[Argind], Argind)
@}
@end ignore
@item
Come esercizio collegato, rivedere quel codice per gestire il caso in cui un
valore contenuto in @code{ARGV} sia un assegnamento di variabile.
@ignore
@c June 13 2015: Antonio points out that this is answered in the text. Ooops.
@item
@ref{Visitare vettori} ha illustrato una funzione che ispezionava un vettore
multidimensionale per stamparlo. Comunque, ispezionare un vettore ed elaborare
ogni elemento @`e un'operazione generica. Generalizzare la funzione
@code{walk_array()} agggiungendo un parametro aggiuntivo chiamato
@code{elab}.
Quindi, all'interno del ciclo, invece di stampare l'indice e il valore
dell'elemento del vettore, usare la sintassi della chiamata indiretta a una
funzione (@pxref{Chiamate indirette})
su @code{elab}, passandole l'indice e il valore.
Nel chiamare @code{walk_array()}, si passa il nome di una
funzione definita dall'utente che aspetta di ricevere un indice e un valore
per poi elaborare l'elemento.
Verificare la nuova versione stampando il vettore; si dovrebbe ottenere un
output identico a quello della versione originale.
@end ignore
@end enumerate
@c EXCLUDE END
@node Programmi di esempio
@chapter Programmi utili scritti in @command{awk}
@cindex programmi @command{awk} @subentry esempi di
@cindex esempio @subentry di programma @command{awk}
@c FULLXREF ON
@iftex
Il
@end iftex
@ref{Funzioni di libreria},
ha prospettato l'idea che la lettura di programmi scritti in un certo
linguaggio possa aiutare a imparare quel linguaggio. Questo
@value{CHAPTER} ripropone lo stesso tema, presentando una miscellanea di
programmi @command{awk} per il piacere di leggerli.
@c FULLXREF OFF
@ifnotinfo
Ci sono tre @value{SECTIONS}.
La prima spiega come eseguire i programmi descritti in questo
@value{CHAPTER}.
La seconda illustra la versione @command{awk}
di parecchi comuni programmi di utilit@`a disponibili in POSIX.
Si presuppone che si abbia gi@`a una certa familiarit@`a con questi programmi,
e che quindi i problemi a loro legati siano facilmente comprensibili.
Riscrivendo questi programmi in @command{awk},
ci si pu@`o focalizzare sulle particolarit@`a di @command{awk} nella
risoluzione dei problemi di programmazione.
La terza sezione @`e una collezione di programmi interessanti.
Essi mirano a risolvere un certo numero di differenti problemi di
manipolazione e di gestione dati. Molti dei programmi sono brevi, per
evidenziare la capacit@`a di @command{awk} di fare molte cose usando solo
poche righe di codice.
@end ifnotinfo
Molti di questi programmi usano le funzioni di libreria che sono state presentate
@iftex
nel
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzioni di libreria}.
@menu
* Eseguire esempi:: Come eseguire questi esempi.
* Cloni:: Cloni di programmi di utilit@`a comuni.
* Programmi vari:: Alcuni interessanti programmi in
@command{awk}.
* Sommario dei programmi:: Sommario dei programmi.
* Esercizi sui programmi:: Esercizi.
@end menu
@node Eseguire esempi
@section Come eseguire i programmi di esempio.
Per eseguire un dato programma, si procederebbe tipicamente cos@`{@dotless{i}}:
@example
awk -f @var{programma} -- @var{opzioni} @var{file}
@end example
@noindent
Qui, @var{programma} @`e il nome del programma @command{awk} (p.es.
@file{cut.awk}), @var{opzioni} sono le opzioni sulla riga di comando
per il programma che iniziano con un @samp{-}, e @var{file} sono i
@value{DF} in input.
Se il sistema prevede il meccanismo @samp{#!} di specifica di un
@dfn{interprete}
(@pxref{@dfn{Script} eseguibili}),
si pu@`o invece eseguire direttamente un programma:
@example
cut.awk -c1-8 i_miei_file > risultati
@end example
Se @command{awk} non @`e @command{gawk}, pu@`o invece essere necessario usare:
@example
cut.awk -- -c1-8 i_miei_file > risultati
@end example
@node Cloni
@section Reinventare la ruota per divertimento e profitto
@cindex programmi POSIX @subentry implementazione in @command{awk}
@cindex POSIX @subentry programmi @subentry implementazione in @command{awk}
Questa @value{SECTION} presenta un certo numero di programmi di utilit@`a
POSIX implementati in @command{awk}. Riscrivere questi programmi in
@command{awk} @`e spesso divertente,
perch@'e gli algoritmi possono essere espressi molto chiaramente, e il codice
@`e normalmente molto semplice e conciso. Ci@`o @`e possibile perch@'e @command{awk}
facilita molto le cose al programmatore.
Va precisato che questi programmi non sono necessariamente scritti per
sostituire le versioni installate sul sistema in uso.
Inoltre, nessuno di questi programmi @`e del tutto aderente ai pi@`u recenti
standard POSIX. Questo non @`e un problema; il loro scopo
@`e di illustrare la programmazione in linguaggio @command{awk} che serve nel
``mondo reale''.
I programmi sono presentati in ordine alfabetico.
@menu
* Programma cut:: Il programma di utilit@`a @command{cut}.
* Programma egrep:: Il programma di utilit@`a @command{egrep}.
* Programma id:: Il programma di utilit@`a @command{id}.
* Programma split:: Il programma di utilit@`a @command{split}.
* Programma tee:: Il programma di utilit@`a @command{tee}.
* Programma uniq:: Il programma di utilit@`a @command{uniq}.
* Programma wc:: Il programma di utilit@`a @command{wc}.
@end menu
@node Programma cut
@subsection Ritagliare campi e colonne
@cindex @command{cut} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{cut}
@cindex campi @subentry ritagliare
@cindex colonne @subentry ritagliare
Il programma di utilit@`a @command{cut} seleziona, o ``taglia'' (@dfn{cut}),
caratteri o campi dal suo standard input e li
spedisce al suo standard output.
I campi sono separati da caratteri TAB per default,
ma @`e possibile fornire un'opzione dalla riga di comando per cambiare il campo
@dfn{delimitatore} (cio@`e, il carattere che separa i campi). La definizione di
campo di @command{cut} @`e meno generale di quella di @command{awk}.
Un uso comune del comando @command{cut} potrebbe essere quello di estrarre
i nomi degli utenti correntemente collegati al sistema, a partire
dall'output del comando @command{who}. Per esempio, la seguente
pipeline genera una lista in ordine alfabetico, senza doppioni, degli utenti
correntemente collegati al sistema:
@example
who | cut -c1-8 | sort | uniq
@end example
Le opzioni per @command{cut} sono:
@table @code
@item -c @var{lista}
Usare @var{lista} come lista di caratteri da ritagliare. Elementi
all'interno della lista
possono essere separati da virgole, e intervalli di caratteri possono essere
separated da trattini. La lista
@samp{1-8,15,22-35} specifica i caratteri da 1 a 8, 15, e da 22 a 35.
@item -f @var{lista}
Usare @var{lista} come lista di campi da ritagliare.
@item -d @var{delimitatore}
Usare @var{delimitatore} come carattere che separa i campi invece del
carattere TAB.
@item -s
Evita la stampa di righe che non contengono il delimitatore di campo.
@end table
L'implementazione @command{awk} del comando @command{cut} usa la funzione
di libreria @code{getopt()}
(@pxref{Funzione getopt})
e la funzione di libreria @code{join()}
(@pxref{Funzione join}).
Il programma inizia con un commento che descrive le opzioni, le funzioni
di libreria necessarie, e una funzione @code{sintassi()} che stampa un
messaggio ed esce. @code{sintassi()} @`e chiamato se si specificano degli
argomenti non validi:
@cindex @code{cut.awk} (programma)
@cindex programma @subentry @code{cut.awk}
@example
@c file eg/prog/cut.awk
# cut.awk --- implementa cut in awk
@c endfile
@ignore
@c file eg/prog/cut.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
@c endfile
@end ignore
@c file eg/prog/cut.awk
# Opzioni:
# -f lista Ritagliare campi
# -d c Carattere di delimitazione di campo
# -c lista Ritagliare caratteri
#
# -s Sopprimere righe che non contengono il delimitatore
#
# Richiede le funzioni di libreria getopt() e join()
@group
function sintassi()
@{
print("Uso: cut [-f lista] [-d c] [-s] [file...]") > "/dev/stderr"
print(" cut [-c lista] [file...]") > "/dev/stderr"
exit 1
@}
@end group
@c endfile
@end example
@cindex @code{BEGIN} (regola) @subentry eseguire programmi @command{awk} e
@cindex regola @subentry @code{BEGIN} @subentry eseguire programmi @command{awk} e
@cindex @code{FS} (variabile) @subentry eseguire programmi @command{awk} e
@cindex variabile @subentry @code{FS} @subentry eseguire programmi @command{awk} e
Subito dopo c'@`e una regola @code{BEGIN} che analizza le opzioni della riga
di comando.
Questa regola imposta @code{FS} a un solo carattere TAB, perch@'e quello @`e
il separatore di campo di @command{cut} per default.
La regola poi imposta il separatore di campo in output allo stesso valore
del separatore di campo in input. Un ciclo che usa @code{getopt()} esamina
le opzioni della riga di comando. Una e una sola delle variabili
@code{per_campi} o @code{per_caratteri} @`e impostata a "vero", per indicare
che l'elaborazione sar@`a fatta per campi o per caratteri, rispettivamente.
Quando si ritaglia per caratteri, il separatore di campo in output @`e
impostato alla stringa nulla:
@example
@c file eg/prog/cut.awk
BEGIN @{
FS = "\t" # default
OFS = FS
while ((c = getopt(ARGC, ARGV, "sf:c:d:")) != -1) @{
if (c == "f") @{
per_campi = 1
lista_campi = Optarg
@} else if (c == "c") @{
per_caratteri = 1
lista_campi = Optarg
OFS = ""
@} else if (c == "d") @{
if (length(Optarg) > 1) @{
printf("cut: usa il primo carattere di %s" \
" come delimitatore\n", Optarg) > "/dev/stderr"
Optarg = substr(Optarg, 1, 1)
@}
fs = FS = Optarg
OFS = FS
if (FS == " ") # mette specifica in formato awk
FS = "[ ]"
@} else if (c == "s")
sopprimi = 1
else
sintassi()
@}
# Toglie opzioni da riga di comando
for (i = 1; i < Optind; i++)
ARGV[i] = ""
@c endfile
@end example
@cindex separatore di campo @subentry spazi come
@cindex spazi @subentry come separatore di campo
Nella scrittura del codice si deve porre particolare attenzione quando il
delimitatore di campo @`e uno spazio. Usare
un semplice spazio (@code{@w{" "}}) come valore per @code{FS} @`e
sbagliato: @command{awk} separerebbe i campi con serie di spazi,
TAB, e/o ritorni a capo, mentre devono essere separati solo da uno spazio.
Per far questo, salviamo il carattere di spazio originale nella variabile
@code{fs} per un uso futuro; dopo aver impostato @code{FS} a @code{"[ ]"} non
@`e possibile usarlo direttamente per vedere se il carattere delimitatore di
campo @`e nella stringa.
Si ricordi anche che dopo che si @`e finito di usare @code{getopt()}
(come descritto nella @ref{Funzione getopt}),
@`e necessario
eliminare tutti gli elementi del vettore @code{ARGV} da 1 a @code{Optind},
in modo che @command{awk} non tenti di elaborare le opzioni della riga di comando
come @value{FNS}.
Dopo aver elaborato le opzioni della riga di comando, il programma verifica
che le opzioni siano coerenti. Solo una tra le opzioni @option{-c}
e @option{-f} dovrebbe essere presente, ed entrambe richiedono una lista di
campi. Poi il programma chiama
@code{prepara_lista_campi()} oppure @code{prepara_lista_caratteri()} per
preparare la lista dei campi o dei caratteri:
@example
@c file eg/prog/cut.awk
if (per_campi && per_caratteri)
sintassi()
if (per_campi == 0 && per_caratteri == 0)
per_campi = 1 # default
@group
if (lista_campi == "") @{
print "cut: specificare lista per -c o -f" > "/dev/stderr"
exit 1
@}
@end group
if (per_campi)
prepara_lista_campi()
else
prepara_lista_caratteri()
@}
@c endfile
@end example
@code{prepara_lista_campi()} pone la lista campi, usando la virgola come
separatore, in un vettore. Poi, per
ogni elemento del vettore, controlla che esso non sia un intervallo. Se @`e
un intervallo, lo fa diventare un elenco. La funzione controlla l'intervallo
specificato, per assicurarsi che il primo numero sia minore del secondo.
Ogni numero nella lista @`e aggiunto al vettore @code{lista_c}, che
semplicemente elenca i campi che saranno stampati. Viene usata la normale
separazione in campi di @command{awk}. Il programma lascia ad @command{awk}
il compito di separare i campi:
@example
@c file eg/prog/cut.awk
function prepara_lista_campi( n, m, i, j, k, f, g)
@{
n = split(lista_campi, f, ",")
j = 1 # indice in lista_c
for (i = 1; i <= n; i++) @{
if (index(f[i], "-") != 0) @{ # un intervallo
m = split(f[i], g, "-")
@group
if (m != 2 || g[1] >= g[2]) @{
printf("cut: lista campi errata: %s\n",
f[i]) > "/dev/stderr"
exit 1
@}
@end group
for (k = g[1]; k <= g[2]; k++)
lista_c[j++] = k
@} else
lista_c[j++] = f[i]
@}
ncampi = j - 1
@}
@c endfile
@end example
La funzione @code{prepara_lista_caratteri()} @`e pi@`u complicata di
@code{prepara_lista_campi()}.
L'idea qui @`e di usare la variabile di @command{gawk} @code{FIELDWIDTHS}
(@pxref{Dimensione costante}),
che descrive input a larghezza costante. Quando si usa una lista di
caratteri questo @`e proprio il nostro caso.
Impostare @code{FIELDWIDTHS} @`e pi@`u complicato che semplicemente elencare
i campi da stampare. Si deve tener traccia dei campi da
stampare e anche dei caratteri che li separano, che vanno saltati.
Per esempio, supponiamo che si vogliano i caratteri da 1 a 8, 15,
e da 22 a 35. Per questo si specifica @samp{-c 1-8,15,22-35}. Il valore che
corrisponde a questo nella variabile @code{FIELDWIDTHS} @`e
@code{@w{"8 6 1 6 14"}}. Questi sono cinque campi, e quelli da stampare
sono @code{$1}, @code{$3}, e @code{$5}.
I campi intermedi sono @dfn{riempitivo} (@dfn{filler}),
ossia @`e ci@`o che separa i dati che si desidera estrarre.
@code{lista_c} lista i campi da stampare, e @code{t} traccia l'elenco
completo dei campi, inclusi i riempitivi:
@example
@c file eg/prog/cut.awk
function prepara_lista_caratteri( campo, i, j, f, g, n, m, t,
filler, ultimo, lungo)
@{
campo = 1 # contatore totale campi
n = split(lista_campi, f, ",")
j = 1 # indice in lista_c
for (i = 1; i <= n; i++) @{
if (index(f[i], "-") != 0) @{ # intervallo
m = split(f[i], g, "-")
if (m != 2 || g[1] >= g[2]) @{
printf("cut: lista caratteri errata: %s\n",
f[i]) > "/dev/stderr"
exit 1
@}
lungo = g[2] - g[1] + 1
if (g[1] > 1) # calcola lunghezza del riempitivo
filler = g[1] - ultimo - 1
else
filler = 0
@group
if (filler)
t[campo++] = filler
@end group
t[campo++] = lungo # lunghezza del campo
ultimo = g[2]
lista_c[j++] = campo - 1
@} else @{
if (f[i] > 1)
filler = f[i] - ultimo - 1
else
filler = 0
if (filler)
t[campo++] = filler
t[campo++] = 1
ultimo = f[i]
lista_c[j++] = campo - 1
@}
@}
FIELDWIDTHS = join(t, 1, campo - 1)
ncampi = j - 1
@}
@c endfile
@end example
Poi viene la regola che elabora i dati. Se l'opzione @option{-s} @`e stata
specificata, il flag @code{sopprimi}
@`e vero. La prima istruzione
@code{if} accerta che il record in input abbia il separatore di
campo. Se @command{cut} sta elaborando dei campi, e @code{sopprimi} @`e vero,
e il carattere di separazione dei campi non @`e presente nel record, il
record @`e ignorato.
Se il record @`e valido, @command{gawk} ha gi@`a separato i dati in campi,
usando il carattere in @code{FS} o usando campi a lunghezza fissa
e @code{FIELDWIDTHS}. Il ciclo scorre attraverso la lista di campi che
si dovrebbero stampare. Il campo corrispondente @`e stampato se contiene dati.
Se il campo successivo contiene pure dei dati, il carattere di separazione @`e
scritto tra i due campi:
@example
@c file eg/prog/cut.awk
@{
if (per_campi && sopprimi && index($0, fs) == 0)
next
for (i = 1; i <= ncampi; i++) @{
if ($lista_c[i] != "") @{
printf "%s", $lista_c[i]
if (i < ncampi && $lista_c[i+1] != "")
printf "%s", OFS
@}
@}
print ""
@}
@c endfile
@end example
Questa versione di @command{cut} utilizza la variabile @code{FIELDWIDTHS} di
@command{gawk} per ritagliare in base alla posizione dei caratteri. @`E
possibile, in altre implementazioni di @command{awk} usare @code{substr()}
(@pxref{Funzioni per stringhe}), ma
la cosa @`e molto pi@`u complessa.
La variabile @code{FIELDWIDTHS} fornisce una soluzione elegante al problema
di suddividere la riga in input in singoli caratteri.
@node Programma egrep
@subsection Ricercare espressioni regolari nei file
@cindex espressioni regolari @subentry ricerca di
@cindex ricerca @subentry in file @subentry di espressioni regolari
@cindex file @subentry ricercare espressioni regolari nei
@cindex @command{egrep} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{egrep}
Il programma di utilit@`a @command{egrep} ricerca occorrenze di espressioni
regolari all'interno di file. Usa
espressioni regolari che sono quasi identiche a quelle disponibili in
@iftex
@command{awk} (@pxrefil{Espressioni regolari}).
@end iftex
@ifnottex
@command{awk} (@pxref{Espressioni regolari}).
@end ifnottex
Si richiama cos@`{@dotless{i}}:
@display
@command{egrep} [@var{opzioni}] @code{'@var{espressione}'} @var{file} @dots{}
@end display
@var{espressione} @`e un'espressione regolare. Normalmente, l'espressione
regolare @`e protetta da apici per impedire alla shell di espandere ogni
carattere speciale come @value{FN}.
Normalmente, @command{egrep} stampa le righe per cui @`e stata trovata una
corrispondenza. Se nella riga di comando si richiede di operare su pi@`u di un
@value{FN}, ogni riga in output @`e preceduta dal nome del file, e dal segno
due punti (@code{:}).
Le opzioni di @command{egrep} sono le seguenti:
@table @code
@item -c
Stampa un contatore delle righe che corrispondono al criterio di ricerca,
e non le righe stesse.
@item -s
Funziona in silenzio. Non si produce alcun output ma il codice di ritorno
indica se il criterio di ricerca ha trovato almeno una corrispondenza.
@item -v
Inverte il senso del test. @command{egrep} stampa le righe che
@emph{non} soddisfano il criterio di ricerca ed esce con successo se il
criterio di ricerca non @`e soddisfatto.
@item -i
Ignora maiuscolo/minuscolo sia nel criterio di ricerca che nei dati in input.
@item -l
Stampa (elenca) solo i nomi dei file che corrispondono, e non le righe trovate.
@item -e @var{espressione}
Usa @var{espressione} come @dfn{regexp} da ricercare. Il motivo per cui
@`e prevista l'opzione @option{-e} @`e di
permettere dei criteri di ricerca che
inizino con un @samp{-}.
@end table
Questa versione usa la funzione di libreria @code{getopt()}
(@pxref{Funzione getopt})
e il programma di libreria che gestisce il passaggio da un file dati
al successivo
(@pxref{Funzione filetrans}).
Il programma inizia con un commento descrittivo e poi c'@`e una regola
@code{BEGIN}
che elabora gli argomenti della riga di comando usando @code{getopt()}.
L'opzione @option{-i} (ignora maiuscolo/minuscolo) @`e particolarmente facile
da implementare con @command{gawk}; basta usare la variabile predefinita
@code{IGNORECASE}
(@pxref{Variabili predefinite}):
@cindex @code{egrep.awk} (programma)
@cindex programma @subentry @code{egrep.awk}
@example
@c file eg/prog/egrep.awk
# egrep.awk --- simula egrep in awk
#
@c endfile
@ignore
@c file eg/prog/egrep.awk
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised September 2020
@c endfile
@end ignore
@c file eg/prog/egrep.awk
# Opzioni:
# -c conta le righe trovate
# -e l'argomento @`e un'espressione regolare
# -i ignora maiuscolo/minuscolo
# -l stampa solo nomi file
# -n aggiungi numeri linea in output
# -q quieto - usa solo il codice di ritorno
# -s silenzioso - non stampa messaggi di errore
# -v inverte test, successo se espression non trovata
# -x l'intera linea deve corrispondere
#
# Richiede la funzione getopt()
# Usa IGNORECASE, BEGINFILE ed ENDFILE
# Chiamare immettendo: gawk -f egrep.awk -- opzioni ...
BEGIN @{
while ((c = getopt(ARGC, ARGV, "ce:ilnqsvx")) != -1) @{
if (c == "c")
conta_e_basta++
else if (c == "e")
criterio_di_ricerca = Optarg
else if (c == "i")
IGNORECASE = 1
else if (c == "l")
solo_nomi_file++
else if (c == "n")
numero_riga++
else if (c == "q")
non_stampare++
else if (c == "s")
non_stampare_errori++
else if (c == "v")
inverti_test++
else if (c == "x")
riga_intera++
else
sintassi()
@}
@c endfile
@end example
@noindent
Si noti il commento relativo alla chiamata del programma:
Poich@'e parecchie opzioni possono essere sepcificate anche per
@command{gawk}, occorre immettere @option{--} per far s@`@{dotless{i}} che
@command{gawk} non prosegua nell'analisi delle opzioni.
Nel seguito c'@`e il codice che gestisce il comportamento specifico di
@command{egrep}. Se non @`e fornito esplicitamente alcun criterio di ricerca
tramite l'opzione @option{-e}, si usa il primo argomento sulla riga di
comando che non sia un'opzione.
Gli argomenti della riga di comando di @command{awk} fino ad
@code{ARGV[Optind]} vengono cancellati,
in modo che @command{awk} non tenti di elaborarli come file. Se
non @`e stato specificato alcun nome di file, si usa lo standard input, e se
@`e presente pi@`u di un nome di file, lo si annota, in modo che i @value{FNS}
vengano scritti prima di ogni riga di output corrispondente:
@example
@c file eg/prog/egrep.awk
if (criterio_di_ricerca == "")
criterio_di_ricerca = ARGV[Optind++]
if (criterio_di_ricerca == "")
sintassi()
for (i = 1; i < Optind; i++)
ARGV[i] = ""
if (Optind >= ARGC) @{
ARGV[1] = "-"
ARGC = 2
@} else if (ARGC - Optind > 1)
elabora_nomi_file++
@}
@c endfile
@end example
La regola @code{BEGINFILE} viene eseguita quando si inizia a
elaborare un nuovo file. In questo caso, essa @`e piuttosto semplice;
inizializza la variabile @code{contatore_file} a zero.
@code{contatore_file} viene incrementata ogni volta che una riga
nel file corrente corrisponde all'espressione di ricerca.
Qui si implementa anche l'opzione @option{-s}.
Si controlla se @code{ERRNO} @`e stato impostato,
e se l'opzione @option{-s} era stata specificata.
In tal caso, @`e necessario passare al file successivo
[di solito, perch@'e questo file non @`e leggibile].
Altrimenti @command{gawk} termina l'esecuzione
con un messaggio di errore:
@example
@c file eg/prog/egrep.awk
BEGINFILE @{
contatore_file = 0
if (ERRNO && nessun_errore)
nextfile
@}
@c endfile
@end example
La regola @code{ENDFILE} viene eseguita alla fine dell'elaborazione
di ogni file. Genera dell'output solo quando l'utente richiede un
contatore del numero di righe che sono state trovate corrispondere.
La variabile @code{non_stampare} @`e vera qualora si chieda di
impostare solo il codice di ritorno.
La variabile @code{conta_e_basta} @`e vera qualora si chieda solo
il numero delle righe che sono state trovare corrispondere.
@command{egrep} quindi stampa il contatore delle corrispondenze
trovate solo se sia la stampa che il conteggio righe sono richieste.
Il formato dell'output dev'essere adattato, a seconda del numero di
file da elaborare. Infine @code{contatore_file} @`e aggiunto
a @code{totale}, in modo da poter stabilire il numero totale di
righe corrispondenti all'espressione cercata:
@example
@c file eg/prog/egrep.awk
ENDFILE @{
if (! non_stampare && conta_e_basta) @{
if (elabora_nomi_file)
print file ":" contatore_file
else
print contatore_file
@}
@group
totale += contatore_file
@}
@end group
@c endfile
@end example
La regola seguente fa il grosso del lavoro per trovare righe corrispondenti
al criterio di ricerca fornito. La variabile
@code{corrisponde} @'e vera (diversa da zero) se la riga @'e individuata
dal criterio di ricerca.
Se l'utente ha specificato che la riga intera deve corrispondere
(con l'opzione @option{-x}), il codice controlla la condizione
verificando i valori delle variabili @code{RSTART} e @code{RLENGTH}.
Se questi indicano che la corrispondenza non coincide con l'intera
riga, la variabile @code{corrisponde} @`e impostata a zero (falsa).
Se l'utente chiede invece le righe che @emph{non} corrispondono,
il senso di @code{corrisponde} @`e invertito, usando l'operatore @samp{!}.
@code{contatore_file} @`e incrementato con il valore di
@code{corrisponde}, che vale uno o zero, a seconda che la corrispondenza sia
stata trovata oppure no. Se la riga non corrisponde, l'istruzione
@code{next} passa ad esaminare il record successivo.
Vengono effettuati anche altri controlli, ma soltanto se non
si sceglie di contare le righe. Prima di tutto, se l'utente desidera solo
il codice di ritorno (@code{non_stampare} @`e vero), @`e sufficiente sapere
che @emph{una} riga nel file corrisponde, e si pu@`o passare al file successivo
usando @code{nextfile}. Analogamente, se stiamo solo stampando @value{FNS},
possiamo stampare il @value{FN}, e quindi saltare al file successivo con
@code{nextfile}.
Infine, ogni riga viene stampata, preceduta, se necessario, dal @value{FN} e
dai due punti (@code{:}):
@cindex @code{!} (punto esclamativo) @subentry operatore @code{!}
@cindex punto esclamativo (@code{!}) @subentry operatore @code{!}
@example
@c file eg/prog/egrep.awk
@{
corrisponde = ($0 ~ criterio_di_ricerca)
if (corrisponde && riga_intera && (RSTART != 1 || RLENGTH != length()))
corrisponde = 0
if (inverti_test)
corrisponde = ! corrisponde
contatore_file += corrisponde # 1 o 0
if (! corrisponde)
next
if (! conta_e_basta) @{
if (non_stampare)
nextfile
if (solo_nomi_file) @{
print FILENAME
nextfile
@}
if (elabora_nomi_file)
if (numero_riga)
print FILENAME ":" FNR ":" $0
else
print FILENAME ":" $0
else
print
@}
@}
@c endfile
@end example
La regola @code{END} serve a produrre il codice di ritorno corretto. Se
non ci sono corrispondenze, il codice di ritorno @`e uno;
altrimenti, @`e zero:
@example
@c file eg/prog/egrep.awk
END @{
exit (totale == 0)
@}
@c endfile
@end example
La funzione @code{sintassi()} stampa un messaggio per l'utente, nel caso
siano state specificate opzioni non valide, e quindi esce:
@example
@c file eg/prog/egrep.awk
function sintassi()
@{
print("Uso:\tegrep [-cilnqsvx] [-e criterio_di_ricerca] [file ...]")\
> "/dev/stderr"
print("\tegrep [-cilnqsvx] criterio_di_ricerca [file ...]") > "/dev/stderr"
exit 1
@}
@c endfile
@end example
@node Programma id
@subsection Stampare informazioni sull'utente
@cindex stampare @subentry informazioni utente
@cindex utenti @subentry informazioni riguardo agli @subentry stampare
@cindex @command{id} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{id}
Il programma di utilit@`a @command{id} elenca i numeri identificativi (ID)
reali ed effettivi di un utente, e l'insieme dei gruppi a cui l'utente
appartiene, se ve ne sono.
@command{id} stampa i numeri identificativi di utente e di gruppo solo se
questi sono differenti da quelli reali. Se possibile, @command{id} elenca
anche i corrispondenti nomi di utente e di gruppo.
L'output potrebbe essere simile a questo:
@example
$ @kbd{id}
@print{} uid=1000(arnold) gid=1000(arnold) groups=1000(arnold),4(adm),7(lp),27(sudo)
@end example
@cindex @code{PROCINFO} (vettore) @subentry @dfn{process ID} di utente e di gruppo e
@cindex vettore @subentry @code{PROCINFO} @subentry @dfn{process ID} di utente e di gruppo e
Questa informazione @`e parte di ci@`o che @`e reso disponibile dal vettore
@code{PROCINFO} di @command{gawk} (@pxref{Variabili predefinite}).
Comunque, il programma di utilit@`a @command{id} fornisce un output pi@`u
comprensibile che non una semplice lista di numeri.
La versione POSIX di @command{id} prevede numerose opzioni che consentono
di controllare il formato dell'output, come stampare solo gli @dfn{id}
reali, o stampare solo numeri o solo nomi. Inoltre, @`e possibile stampare
informazioni riguardo a un dato utente, invece che solo quelle relative
all'utente corrente.
Quel che segue @`e una versione del comando POSIX @command{id} scritta in
@command{awk}.
Usa la funzione di libreria @code{getopt()}
(@pxref{Funzione getopt}),
le funzioni di libreria del database che descrive gli utenti
(@pxref{Funzioni Passwd}),
Usa le funzioni di libreria che riguardano il database degli utenti
(@pxref{Funzioni Passwd})
e le funzioni di libreria che riguardano il database dei gruppi
(@pxref{Funzioni Group}).
Il programma @`e abbastanza semplice. Tutto il lavoro @`e svolto nella regola
@code{BEGIN}.
Inizia com dei commenti di spiegazioni, una lista di opzioni e infine
una funzione @code{sintassi()} function:
@cindex @code{id.awk} (programma)
@cindex programma @subentry @code{id.awk}
@example
@c file eg/prog/id.awk
# id.awk --- implement id in awk
#
# Richiede funzioni di libreria per utente e gruppo e getopt
@c endfile
@ignore
@c file eg/prog/id.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised February 1996
# Revised May 2014
# Revised September 2014
# Revised September 2020
@c endfile
@end ignore
@c file eg/prog/id.awk
# l'output @`e:
# uid=12(pippo) euid=34(pluto) gid=3(paperino) \
# egid=5(paperina) groups=9(nove),2(due),1(uno)
# Opzioni:
# -G Scrive tutti gli id di gruppo come numeri separati da spazi
# (ruid, euid, groups)
# -g Scrive solo euid come numero
# -n Scrive il nome invece del valore numerico (con -g/-G/-u)
# -r Scrive ruid/rguid incece di euid (id effettivo)
# -u Scrive solo euid (id effettivo) dell'utente, come numero
@group
function sintassi()
@{
printf("Uso:\n" \
"\tid [user]\n" \
"\tid −G [−n] [user]\n" \
"\tid −g [−nr] [user]\n" \
"\tid −u [−nr] [user]\n") > "/dev/stderr"
exit 1
@}
@end group
@c endfile
@end example
Il primo passo @`e quello di scandire le opzioni usando @code{getopt()},
e di impostare varie variabili di tipo flag a seconda delle opzioni
specificate:
@example
@c file eg/prog/id.awk
BEGIN @{
# scansione argomenti specificati
while ((c = getopt(ARGC, ARGV, "Ggnru")) != -1) @{
if (c == "G")
groupset_only++
else if (c == "g")
egid_only++
else if (c == "n")
names_not_groups++
else if (c == "r")
real_ids_only++
else if (c == "u")
euid_only++
else
sintassi()
@}
@c endfile
@end example
Il passo successivo @`e quello di controllare che non siano state
specificate opzioni mutualmente esclusive.
Le opzioni @option{-G} e @option{-r} sono di questo tipo.
Inoltre, non @`e possibile specificare pi@`u di un nome utente
sulla riga di comando:
@example
@c file eg/prog/id.awk
if (groupset_only && real_ids_only)
sintassi()
else if (ARGC - Optind > 1)
sintassi()
@c endfile
@end example
I numeri dell'ID di utente e di gruppo sono ottenuti
dal vettore @code{PROCINFO} dell'utente corrente, oppure
dal database degli utenti e delle password, per un
utente il cui nome sia stato specificato nella riga di
comando.
In quest'ultimo caos, viene impostato il flag @code{real_ids_only},
poich@'e non @`e possibile stampare informazioni riguardo agli
ID di utente e di gruppo effettivi:
@example
@c file eg/prog/id.awk
if (ARGC - Optind == 0) @{
# ottieni informazioni for l'utente corrente
uid = PROCINFO["uid"]
euid = PROCINFO["euid"]
gid = PROCINFO["gid"]
egid = PROCINFO["egid"]
for (i = 1; ("group" i) in PROCINFO; i++)
groupset[i] = PROCINFO["group" i]
@} else @{
scrivi_info_utente(ARGV[ARGC-1])
real_ids_only++
@}
@c endfile
@end example
Il test contenuto nel ciclo @code{for} @`e degno di nota.
Ogni ulteriore gruppo nel vettore @code{PROCINFO} ha come indice
da @code{"group1"} a @code{"group@var{N}"} per qualche valore di
@var{N} (ovvero, il numero totale di gruppi ulteriori).
Peraltro, non sappiamo in anticipo quanti siano questi gruppi
supplementari.
Questo ciclo funziona, a partire dal valore uno, concatenando il valore
a @code{"group"}, e usando poi l'istruzione @code{in} per verificare se
tale valore @`e presente nel vettore (@pxref{Visitare elementi}).
Dopo alcune iterazioni, @code{i} supera il valore dell'ultimo gruppo
presente nel vettore, e il ciclo termina.
Il ciclo funziona correttamente anche se @emph{non} ci sono gruppi
ulteriori; in tal caso la condizione non @`e verificata fin dal
primo tentativo di verifica, e il corpo del ciclo non viene mai
eseguito.
A questo punto, a seconda delle opzioni, si decide quale
informazione stampare.
Per l'opzione @option{-G} (stampare solo l'insieme dei gruppo), occorre
poi scegliere se stampare nomi o numeri. In entrambi i casi, il programma
esce dopo aver eseguito la stampa:
@example
@c file eg/prog/id.awk
if (groupset_only) @{
if (names_not_groups) @{
for (i = 1; i in groupset; i++) @{
entry = getgrgid(groupset[i])
name = ottieni_primo_campo(entry)
printf("%s", name)
if ((i + 1) in groupset)
printf(" ")
@}
@} else @{
for (i = 1; i in groupset; i++) @{
printf("%u", groupset[i])
if ((i + 1) in groupset)
printf(" ")
@}
@}
print "" # a-capo finale
exit 0
@}
@c endfile
@end example
Altrimenti, per l'opzione @option{-g} (solo il group ID effettivo), si
controlla se @`e stata anche specificata l'opzione @option{-r}, nel qual
caso bisogna usare il group ID reale.
Occorre poi scegliere, in base all'opzione @option{-n}, se stampare
nomi o numeri. Anche qui il programma esce dopo aver eseguito la stampa:
@example
@c file eg/prog/id.awk
else if (egid_only) @{
id = real_ids_only ? gid : egid
if (names_not_groups) @{
entry = getgrgid(id)
name = ottieni_primo_campo(entry)
printf("%s\n", name)
@} else @{
printf("%u\n", id)
@}
exit 0
@}
@c endfile
@end example
La funzione @code{ottieni_primo_campo()} estrae il nome del gruppo dalla
descrizione del group ID stesso, contenuta nel database dei gruppi.
Una logica simile viene seguita per l'opzione @option{-u}
(solo user ID effettivo), combinata con le opzioni @option{-r} e @option{-n}:
@example
@c file eg/prog/id.awk
else if (euid_only) @{
id = real_ids_only ? uid : euid
if (names_not_groups) @{
entry = getpwuid(id)
name = ottieni_primo_campo(entry)
printf("%s\n", name)
@} else @{
printf("%u\n", id)
@}
exit 0
@}
@c endfile
@end example
A questo punto non abbiamo ancora finito, e quindi stampiamo
l'output normale, di default, a riguardo dell'utente corrente
o dell'utente che era stato specificato sulla riga di comando.
Iniziamo a stmpare l'user ID reale:
@example
@c file eg/prog/id.awk
printf("uid=%d", uid)
pw = getpwuid(uid)
stampa_primo_campo(pw)
@c endfile
@end example
La funzione @code{stampa_primo_campo()} stampa il nome dell'utente
dalla descrizione contenuta nel file password, racchiusa tra
parentesi. Vedere qui sotto.
Poi si stampa l'user ID effettivo:
@example
@c file eg/prog/id.awk
if (euid != uid && ! real_ids_only) @{
printf(" euid=%d", euid)
pw = getpwuid(euid)
stampa_primo_campo(pw)
@}
@c endfile
@end example
Una logica simile si applica ai group ID reale ed effettivo:
@example
@c file eg/prog/id.awk
printf(" gid=%d", gid)
pw = getgrgid(gid)
stampa_primo_campo(pw)
if (egid != gid && ! real_ids_only) @{
printf(" egid=%d", egid)
pw = getgrgid(egid)
stampa_primo_campo(pw)
@}
@c endfile
@end example
Per finire, stampiamo l'insieme dei gruppi e l'a-capo finale:
@example
@c file eg/prog/id.awk
for (i = 1; i in groupset; i++) @{
if (i == 1)
printf(" gruppi=")
group = groupset[i]
printf("%d", group)
pw = getgrgid(group)
stampa_primo_campo(pw)
if ((i + 1) in groupset)
printf(",")
@}
print ""
@}
@c endfile
@end example
La funzione @code{ottieni_primo_campo()} estrae il primo campo
da una riga del file delle password o da quello dei gruppi,
perch@'e venga usato come nome utente o nome del gruppo.
I campi in questi file sono separati da caratteri @samp{:}:
@example
@c file eg/prog/id.awk
function ottieni_primo_campo(str, a)
@{
if (str != "") @{
split(str, a, ":")
return a[1]
@}
@}
@c endfile
@end example
Questa funzione @`e poi usata dalla funzione @code{stampa_primo_campo()}
per stampare il nome trovato, racchiuso tra parentesi:
@example
@c file eg/prog/id.awk
function stampa_primo_campo(str)
@{
first = ottieni_primo_campo(str)
printf("(%s)", first)
@}
@c endfile
@end example
Queste due funzioni semplicemente contengono delle istruzioni che vengono
usate pi@`u volte, e ci@`o rende il programma pi@`u corto e pi@`u leggibile.
In particolare, l'aver spostato il controllo se una stringa @`e la stringa
nulla nella funzione @code{ottieni_primo_campo()} fa risparmiare parecchie
righe di istruzioni.
Da ultimo, la funzione @code{scrivi_info_utente()} si procura le
informazioni su utente, gruppo e gruppi di appartenenza per l'utente
indicato nel comando. Il codice @`e abbastanza semplice e si limita
a uscire dal programma se l'utente in questione non esiste:
@example
@c file eg/prog/id.awk
function scrivi_info_utente(user,
pwent, fields, groupnames, grent, groups, i)
@{
pwent = getpwnam(user)
if (pwent == "") @{
printf("id: '%s': utente inesistente\n", user) > "/dev/stderr"
exit 1
@}
split(pwent, fields, ":")
uid = fields[3] + 0
gid = fields[4] + 0
@c endfile
@end example
Procurarsi l'insieme dei gruppi @`e un po' complicato.
La routine di libreria @code{getgruser()} restituisce una lista
di @emph{nomi} di gruppo. Tali nomi vanno passati in rassegna
e convertiti di nuovo in numeri di gruppo, in modo che il resto
del programma funzioni come ci si aspetta che faccia:
@example
@ignore
@c file eg/prog/id.awk
@c endfile
@end ignore
@c file eg/prog/id.awk
groupnames = getgruser(user)
split(groupnames, groups, " ")
for (i = 1; i in groups; i++) @{
grent = getgrnam(groups[i])
split(grent, fields, ":")
groupset[i] = fields[3] + 0
@}
@}
@c endfile
@end example
@node Programma split
@subsection Suddividere in pezzi un file grosso
@cindex file @subentry suddividere
@cindex @code{split} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @code{split}
Il programma di utilit@`a @command{split} divide grossi file di testo
in pezzi pi@`u piccoli.
La sintassi, che @`e quella prevista dallo standard POSIX per
@command{split}, @`e la seguente:
@display
@command{split} [@option{-l} @var{contatore}] [@option{-a} @var{lunghezza-suffisso}] [@var{file} [@var{nome-output-file}]]
@command{split} @option{-b} @var{N}[@code{k}|@code{m}]] [@option{-a} @var{lunghezza-suffisso}] [@var{file} [@var{nome-output-file}]]
@end display
Per default,
i file di output avranno nome @file{xaa}, @file{xab}, e cos@`{@dotless{i}} via.
Ogni file contiene 1.000 righe, con la probabile eccezione dell'ultimo file.
Il programma @command{split} si @`e evoluto col passare del tempo, e la
corrente versione POSIX @`e pi@`u complessa della version Unix originale.
Le opzioni, e quello che specificano, sono dettagliate di seguito:
@table @asis
@item @option{-a} @var{lunghezza-suffisso}
Chiede di usare @var{lunghezza-suffisso} caratteri di suffisso.
Per esempio, se @var{lunghezza-suffisso}
vale quattro, i nomi dei file in output andranno da @file{xaaaa} a @file{xzzzz}.
@item @option{-b} @var{N}[@code{k}|@code{m}]]
Invece di chiedere che un file contenga un dato numero di righe,
ogni file dovrebbe essere lungo (al massimo) @var{N} byte.
Se si specifica la lettera @samp{k}, il numero @var{N} viene
moltiplicato per 1.024, ossia diviene il numero di kilobyte.
Se si specifica la lettera @samp{m}, il numero @var{N} viene
moltiplicato per 1.048.576 (@math{1.024 @value{PER} 1.024})
ossia diviene il numero di megabyte.
(Quest'opzione @`e mutuamente esclusiva con l'opzione @option{-l}).
@item @option{-l} @var{contatore}
Ogni file dovrebbe avere al massimo @var{contatore} righe, al posto del
valore di default, che @`e 1.000.
(Quest'opzione @`e mutuamente esclusiva con l'opzione @option{-b}).
@end table
Se specificato, @var{file} @`e il nome del file in input da leggere.
Altrimenti viene letto lo standard input.
Se specificato, @var{nome-output-file} @`e il prefisso da anteporre
ai nomi dei file in output, invece di usare @samp{x}.
Per utilizzare l'opzione @option{-b} di @command{split},
@command{gawk} dovrebbe essere chiamato specificando anche
per @command{gawk} l'opzione @option{-b} (@pxref{Opzioni}),
oppure con la variabile di ambiente @env{LC_ALL} impostata a @samp{C},
in modo che ogni byte in input sia considerato come un carattere a s@'e
stante.@footnote{Per usare l'opzione @option{-b} due volte occorre
separare le opzioni di @command{gawk} da quelle del programma.
Per esempio:
@samp{gawk -f getopt.awk -f split.awk -b -- -b 42m file-molto-grosso.txt split-}.}
Ecco un'implementazione di @command{split} in @command{awk}. Viene utilizzata
la funzione @code{getopt()} presentata in @ref{Funzione getopt}.
Il programma inizia con un commento descrittivo e poi con la
funzione @code{sintassi()} che ne descrive le opzioni:
@cindex @code{split.awk} (programma)
@cindex programma @subentry @code{split.awk}
@example
@c file eg/prog/split.awk
# split.awk --- comando split scritto in awk
#
# Richiede la funzione di libreria getopt()
@c endfile
@ignore
@c file eg/prog/split.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised slightly, May 2014
# Rewritten September 2020
@c endfile
@end ignore
@c file eg/prog/split.awk
function sintassi()
@{
print("Uso: split [-l contatore] [-a lunghezza-suffisso] [file [nome-output-file]]") > "/dev/stderr"
print(" split [-b N[k|m]] [-a lunghezza-suffisso] [file [nome-output-file]]") > "/dev/stderr"
exit 1
@}
@c endfile
@end example
Poi, in una regola @code{BEGIN}, si impostano i valore di default e si
analizzano gli argomenti.
In seguito si inizializzano le strutture di dati da usare per generare
il suffisso, da @samp{aa@dots{}} a @samp{zz@dots{}}. Infine si imposta
il nome del primo file di output:
@example
@c file eg/prog/split.awk
BEGIN @{
# Impostazione valori di default:
Lunghezza_suffisso = 2
Contatore_righe = 1000
Contatore_byte = 0
Outfile = "x"
analizza_argomenti()
inizializza_suffisso()
Output_file = (Outfile calcola_suffisso())
@}
@c endfile
@end example
L'analisi degli argomenti @`e semplice. Il programma segue la nostra
convenzione (@pxref{Nomi di variabili di libreria}) di far iniziare
con una lettera maiuscola i nomi di importanti variabili globali:
@example
@c file eg/prog/split.awk
function analizza_argomenti( i, c, l, modificatore)
@{
while ((c = getopt(ARGC, ARGV, "a:b:l:")) != -1) @{
if (c == "a")
Lunghezza_suffisso = Optarg + 0
else if (c == "b") @{
Contatore_byte = Optarg + 0
Contatore_righe = 0
l = length(Optarg)
modificatore = substr(Optarg, l, 1)
if (modificatore == "k")
Contatore_byte *= 1024
else if (modificatore == "m")
Contatore_byte *= 1024 * 1024
@} else if (c == "l") @{
Contatore_righe = Optarg + 0
Contatore_byte = 0
@} else
sintassi()
@}
# Togli le opzioni dalla riga di comando
for (i = 1; i < Optind; i++)
ARGV[i] = ""
# Controlla se @`e stato specificato un prefisso
if (ARGV[Optind]) @{
Optind++
# Controlla se il prefisso @`e differente
if (ARGV[Optind]) @{
Outfile = ARGV[Optind]
ARGV[Optind] = ""
if (++Optind < ARGC)
sintassi()
@}
@}
@}
@c endfile
@end example
Gestire il valore del suffisso da apporre a @code{nome-output-file}
@`e un problema interessante. Per un suffisso di una data lunghezza,
diciamo tre, i valori partono da @samp{aaa}, @samp{aab}, @samp{aac},
etc., fino ad arrivare a @samp{zzx}, @samp{zzy}, e infine @samp{zzz}.
Ci sono due aspetti importanti da considerare qui:
@itemize @bullet
@item
Si deve essere in grado di generare facilmente tali suffissi e in
particolare di gestire facilmente lo ``scorrimento''; per esempio,
passare da @samp{abz} ad @samp{aca}.
@item
Si deve poter determinare se abbiamo utilizzato tutti i prefissi,
in modo che, nel caso ci siano ulteriori dati (da suddividere) si
possa stampare un messaggio di errore e terminare il programma.
Il trucco @`e di gestire una tale situazione @emph{dopo} aver usato
l'ultimo suffisso disponibile, e non quando viene generato l'ultimo
suffisso stesso.
@end itemize
Il calcolo @`e gestito da @code{calcola_suffisso()}.
Tale funzione @`e chiamata ogni volta che si deve aprire un nuovo file.
Il flusso della funzione @`e piuttosto tortuoso, perch@'e si vuole generare
diciamo fino a @samp{zzzz} e utilizzarlo, ed emettere un messaggio di errore
solo dopo che tutti i suffissi di @code{nome-output-file} sono stati
utilizzati. I passi logici da seguire sono questi:
@enumerate 1
@item
Generare il suffisso, salvandolo in @code{risultato} per poi
restituirlo.
Per far ci@`o, si usa il vettore ausiliario @code{Indice_suff}
che contiene un elemento per ogni lettera nel suffisso.
Ogni elemento @`e un numero
compreso fra 1 e 26, che fa da indice in una stringa che contiene
tutte le lettere minuscole dell'alfabeto inglese.
Il vettore @`e inizializzato dalla funzione @code{inizializza_suffisso()}.
Il @code{risultato} @`e costruito una lettera alla volta, usando
la funzione @code{substr()}.
@item
Preparare le strutture di dati per la prossima volta in cui
@code{calcola_suffisso()} sar@`a chiamato. Per fare ci@`o,
si esegue un ciclo sui valori di @code{Indice_suff}, procedendo
@emph{all'indietro}.
Se l'elemento corrente @`e minore di 26, @`e incrementato, e il ciclo
si interrompe (@samp{abq} diventa @samp{abr}). Altrimenti, all'elemento
viene di nuovo assegnato il valore 1, e si passa all'elemento precedente
nella lista (per passare da @samp{abz} ad @samp{aca}).
Quindi, il vettore @code{Indice_suff} @`e sempre ``un passo avanti'' rispetto
al suffisso di @code{nome-output-file} da restituire.
@item
Controllare se abbiamo superato l'ultimo dei possibili valori per
il suffisso di @code{nome-output-file}.
Se la variabile @code{Raggiunta_la_fine} @`e impostata a "vero", si stampa
un messaggio e si termina il programma.
Altrimenti, si controlla se @code{Indice_suff} descrive un suffisso in cui
tutte le lettere sono delle @samp{z}.
Se @`e questo il caso, stiamo per restituire l'ultimo suffisso possibile,
si deve impostare a "vero" la variabile @code{Raggiunta_la_fine}, in modo che
la @emph{prossima} chiamata a @code{calcola_suffisso()} faccia terminare
il programma con un errore.
@end enumerate
Fisicamente, questi passi nella funzione sono nell'ordine 3, 1, 2:
@example
@c file eg/prog/split.awk
function calcola_suffisso( i, risultato, alfabeto)
@{
# Passo logico 3
if (Raggiunta_la_fine) @{
printf("split: troppi file!\n") > "/dev/stderr"
exit 1
@} else if (all_ultimo_file())
Raggiunta_la_fine = 1 # Errore quando si vuol superare 'zzz'
# Passo logico 1
risultato = ""
alfabeto = "abcdefghijklmnopqrstuvwxyz"
for (i = 1; i <= Lunghezza_suffisso; i++)
risultato = risultato substr(alfabeto, Indice_suff[i], 1)
# Passo logico 2
for (i = Lunghezza_suffisso; i >= 1; i--) @{
if (++Indice_suff[i] > 26) @{
Indice_suff[i] = 1
@} else
break
@}
return risultato
@}
@c endfile
@end example
Il vettore @code{Indice_suff} e la variabile @code{Raggiunta_la_fine}
sono inizializzate da @code{inizializza_suffisso()}:
@example
@c file eg/prog/split.awk
function inizializza_suffisso( i)
@{
for (i = 1; i <= Lunghezza_suffisso; i++)
Indice_suff[i] = 1
Raggiunta_la_fine = 0
@}
@c endfile
@end example
La funzione @code{all_ultimo_file()} restituisce "vero" se @code{Indice_suff}
descrive un suffisso in cui tutti i caratteri sono @samp{z}, e lo fa
controllando che tutti gli elementi del vettore valgano 26:
@example
@c file eg/prog/split.awk
function all_ultimo_file( i, se_ultimo)
@{
se_ultimo = 1
for (i = 1; i <= Lunghezza_suffisso; i++) @{
se_ultimo = se_ultimo && (Indice_suff[i] == 26)
@}
return se_ultimo
@}
@c endfile
@end example
Il lavoro vero e proprio di dividere il file in input @`e fatto dalle due
regole seguenti.
Poich@'e dividere contando le righe e dividere contando i byte sono due
opzioni mutuamente esclusive, lo si fa semplicemente usando due regole,
una per quando @code{Contatore_righe} @`e maggiore di zero, e l'altra
per quando @code{Contatore_byte} @`e maggiore di zero.
La variabile @code{righe_totali} conta quante righe sono state elaborate
finora. Quando il suo valore supera @code{Contatore_righe}, occorre
chiudere il file precedente e passare ad uno nuovo:
@example
@c file eg/prog/split.awk
Contatore_righe > 0 @{
if (++righe_totali > Contatore_righe) @{
close(Output_file)
Output_file = (Outfile calcola_suffisso())
righe_totali = 1
@}
print > Output_file
@}
@c endfile
@end example
La regola per elaborare i byte @`e pi@`u complessa. Poich@'e @`e molto
probabile che le righe siano di lunghezza variabile, il limite indicato
da @code{Contatore_byte} pu@`o essere raggiunto all'interno di uno dei
record in input. In tal caso @command{split} deve scrivere la parte
iniziale del record in input, fino a @code{Contatore_byte}
byte, chiudere il file, aprirne uno nuovo e scrivere il resto del record
sul file nuovo.
Il codice che segue fa esattamente tutto ci@`o:
@example
@c file eg/prog/split.awk
Contatore_byte > 0 @{
# `+ 1' @`e per il carattere di fine riga che va aggiunto
if (righe_totali + length($0) + 1 > Contatore_byte) @{ # Supera il limite
# Calcola byte a inizio record
byte_iniziali = Contatore_byte - righe_totali
# Scrivi i byte iniziali
printf("%s", substr($0, 1, byte_iniziali)) > Output_file
# Chiudi il vecchio file, aprine uno nuovo
close(Output_file)
Output_file = (Outfile calcola_suffisso())
# Prepara i primi byte per il nuovo file
$0 = substr($0, byte_iniziali + 1) # Byte finali del record
righe_totali = 0
@}
# Scrivi record intero o la parte finale restante
righe_totali += length($0) + 1
print > Output_file
@}
@c endfile
@end example
Infine, la regola @code{END} fa la manutenzione finale, chiudendo l'ultimo
file in output:
@example
@c file eg/prog/split.awk
END @{
close(Output_file)
@}
@c endfile
@end example
@node Programma tee
@subsection Inviare l'output su pi@`u di un file
@cindex file @subentry multipli @subentry duplicare l'output su
@cindex output @subentry duplicarlo su pi@`u file
@cindex @code{tee} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @code{tee}
Il programma @code{tee} @`e noto come @dfn{pipe fitting} (tubo secondario).
@code{tee} copia il suo standard input al suo standard output e inoltre lo
duplica scrivendo sui file indicati nella riga di comando. La sua sintassi
@`e la seguente:
@display
@command{tee} [@option{-a}] @var{file} @dots{}
@end display
L'opzione @option{-a} chiede a @code{tee} di aggiungere in fondo al file
indicato, invece che riscriverlo dall'inizio.
La regola @code{BEGIN} dapprima fa una copia di tutti gli argomenti presenti
sulla riga di comando, in un vettore di nome @code{copia}.
@code{ARGV[0]} non serve, e quindi non viene copiato.
@code{tee} non pu@`o usare @code{ARGV} direttamente, perch@'e @command{awk} tenta
di elaborare ogni @value{FN} in @code{ARGV} come dati in input.
@cindex @dfn{flag} (indicatore), variabili di tipo
@cindex variabili @subentry di tipo indicatore (@dfn{flag})
Se il primo argomento @`e @option{-a}, la variabile flag
@code{append} viene impostata a vero, e sia @code{ARGV[1]} che
@code{copia[1]} vengono cancellati. Se @code{ARGC} @`e minore di due, nessun
@value{FN} @`e stato fornito, e @code{tee} stampa un messaggio di sintassi ed
esce.
Infine, @command{awk} viene obbligato a leggere lo standard input
impostando @code{ARGV[1]} al valore @code{"-"} e @code{ARGC} a due:
@cindex @code{tee.awk} (programma)
@cindex programma @subentry @code{tee.awk}
@example
@c file eg/prog/tee.awk
# tee.awk --- tee in awk
#
# Copia lo standard input a tutti i file di output indicati.
# Aggiunge in fondo se viene data l'opzione -a.
#
@c endfile
@ignore
@c file eg/prog/tee.awk
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised December 1995
@c endfile
@end ignore
@c file eg/prog/tee.awk
BEGIN @{
for (i = 1; i < ARGC; i++)
copia[i] = ARGV[i]
if (ARGV[1] == "-a") @{
append = 1
delete ARGV[1]
delete copia[1]
ARGC--
@}
if (ARGC < 2) @{
print "Uso: tee [-a] file ..." > "/dev/stderr"
exit 1
@}
ARGV[1] = "-"
ARGC = 2
@}
@c endfile
@end example
La seguente regola @`e sufficiente da sola a eseguire il lavoro. Poich@'e non @`e
presente alcun criterio di ricerca, la regola @`e eseguita per ogni riga di
input. Il corpo della regola si limita a stampare la riga su ogni file
indicato nella riga di comando, e poi sullo standard output:
@example
@c file eg/prog/tee.awk
@{
# spostare l'if fuori dal ciclo ne velocizza l'esecuzione
if (append)
for (i in copia)
print >> copia[i]
else
for (i in copia)
print > copia[i]
print
@}
@c endfile
@end example
@noindent
@`E anche possibile scrivere il ciclo cos@`{@dotless{i}}:
@example
@group
for (i in copia)
if (append)
print >> copia[i]
@end group
@group
else
print > copia[i]
@end group
@end example
@noindent
Questa forma @`e pi@`u concisa, ma anche meno efficiente. L'@samp{if} @`e
eseguito per ogni record e per ogni file di output. Duplicando il corpo
del ciclo, l'@samp{if} @`e eseguito solo una volta per ogni record in input.
Se ci sono
@var{N} record in input e @var{M} file di output, il primo metodo esegue solo
@var{N} istruzioni @samp{if}, mentre il secondo esegue
@var{N}@code{*}@var{M} istruzioni @samp{if}.
Infine, la regola @code{END} fa pulizia, chiudendo tutti i file di output:
@example
@c file eg/prog/tee.awk
END @{
for (i in copia)
close(copia[i])
@}
@c endfile
@end example
@node Programma uniq
@subsection Stampare righe di testo non duplicate
@cindex stampare @subentry righe di testo non duplicate
@cindex testo @subentry stampare @subentry righe non duplicate di
@cindex @command{uniq} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{uniq}
Il programma di utilit@`a @command{uniq} legge righe di dati ordinati sul suo
standard input, e per default rimuove righe duplicate. In altre parole,
stampa solo righe uniche; da cui il
nome. @command{uniq} ha diverse opzioni. La sintassi @`e la seguente:
@display
@command{uniq} [@option{-udc} [@code{-f @var{n}}] [@code{-s @var{n}}]] [@var{file_input} [@var{file_output}]]
@end display
Le opzioni per @command{uniq} sono:
@table @code
@item -d
Stampa solo righe ripetute (duplicate).
@item -u
Stampa solo righe non ripetute (uniche).
@item -c
Contatore righe. Quest'opzione annulla le opzioni @option{-d} e @option{-u}.
Sia le righe ripetute che quelle non ripetute vengono contate.
@item -f @var{n}
Salta @var{n} campi prima di confrontare le righe. La definizione di campo
@`e simile al default di @command{awk}: caratteri non bianchi, separati da
sequenze di spazi e/o TAB.
@item -s @var{n}
Salta @var{n} caratteri prima di confrontare le righe. Eventuali campi
specificati con @option{-f} sono saltati prima.
@item @var{file_input}
I dati sono letti dal file in input specificato sulla riga di comando, invece
che dallo standard input.
@item @var{file_output}
L'output generato @`e scritto sul file di output specificato, invece che sullo
standard output.
@end table
Normalmente @command{uniq} si comporta come se siano state specificate entrambe
le opzioni @option{-d} e @option{-u}.
@command{uniq} usa la
funzione di libreria @code{getopt()}
(@pxref{Funzione getopt})
e la funzione di libreria @code{join()}
(@pxref{Funzione join}).
Il programma inizia con una funzione @code{sintassi()} e poi con una breve
spiegazione delle opzioni e del loro significato, sotto forma di commenti:
@cindex @code{uniq.awk} (programma)
@cindex programma @subentry @code{uniq.awk}
@example
@c file eg/prog/uniq.awk
@group
# uniq.awk --- implementa uniq in awk
#
# Richiede le funzioni di libreria getopt() e join()
@end group
@c endfile
@ignore
@c file eg/prog/uniq.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Updated August 2020 to current POSIX
@c endfile
@end ignore
@c file eg/prog/uniq.awk
function sintassi()
@{
print("Uso: uniq [-udc [-f campi]] [-s caratteri] [ in [ out ]]") > "/dev/stderr"
exit 1
@}
# -c contatore di righe. prevale su -d e -u
# -d solo righe ripetute
# -u solo righe non ripetute
# -f -n salta n campi
# -s -n salta n caratteri, salta prima eventuali campi
@c endfile
@end example
Lo standard POSIX per il comando @command{uniq} consente che le opzioni
inizino con @samp{+} come pure con @samp{-}. Una regola iniziale
@code{BEGIN} scorre gli argomenti della riga di comando e sostituisce
ogni @samp{+} iniziale con @samp{-} in modo che la funzione @code{getopt()}
possa scandire le opzioni:
@example
@c file eg/prog/uniq.awk
# Dal 2020, '+' pu@`o essere usato come carattere iniziale per
# specificare un'opzione, in aggiunta a '-'.
# L'utilizzo, precedentemente consentito, di -N per saltare dei campi
# e di +N per saltare dei caratteri, non @`e pi@`u ammesso, e non @`e
# supportato da questa versione.
BEGIN @{
# Converte + a - in modo che getopt possa gestire le opzioni
for (i = 1; i < ARGC; i++) @{
first = substr(ARGV[i], 1, 1)
if (ARGV[i] == "--" || (first != "-" && first != "+"))
break
else if (first == "+")
# Rimpiazza "+" con "-"
ARGV[i] = "-" substr(ARGV[i], 2)
@}
@}
@c endfile
@end example
La successiva regola @code{BEGIN} gestisce gli argomenti e le opzioni
specificate sulla riga di comando.
Se non @`e specificata alcuna opzione, vengono usate quelle di default,
che stampano sia le righe ripetute che quelle non ripetute.
Il file di output, se specificato, @`e assegnato alla variabile
@code{g}. In precedenza, @code{file_output} viene inizializzata
allo standard output, @file{/dev/stdout}:
@example
@c file eg/prog/uniq.awk
BEGIN @{
contatore = 1
file_output = "/dev/stdout"
opts = "udcf:s:"
while ((c = getopt(ARGC, ARGV, opts)) != -1) @{
if (c == "u")
solo_non_ripetute++
else if (c == "d")
solo_ripetute++
else if (c == "c")
conta_record++
else if (c == "f")
contatore_file = Optarg + 0
else if (c == "s")
contatore_caratteri = Optarg + 0
else
sintassi()
@}
for (i = 1; i < Optind; i++)
ARGV[i] = ""
if (solo_ripetute == 0 && solo_non_ripetute == 0)
solo_ripetute = solo_non_ripetute = 1
if (ARGC - Optind == 2) @{
file_output = ARGV[ARGC - 1]
ARGV[ARGC - 1] = ""
@}
@}
@c endfile
@end example
La funzione seguente, @code{se_sono_uguali()}, confronta la riga corrente,
@code{$0}, con la riga precedente, @code{ultima}. Gestisce il salto di
campi e caratteri. Se non sono stati richiesti n@'e contatori di campo n@'e
contatori di carattere, @code{se_sono_uguali()} restituisce uno o zero a
seconda del risultato di un semplice confronto tra le stringhe @code{ultima}
e @code{$0}.
In caso contrario, le cose si complicano. Se devono essere saltati dei campi,
ogni riga viene suddivisa in un vettore, usando @code{split()}
(@pxref{Funzioni per stringhe}); i campi desiderati sono poi nuovamente uniti in
un'unica riga usando @code{join()}. Le righe ricongiunte vengono
immagazzinate in @code{campi_ultima} e @code{campi_corrente}. Se non ci
sono campi da saltare, @code{campi_ultima} e @code{campi_corrente} sono
impostati a @code{ultima} e @code{$0}, rispettivamente. Infine, se
occorre saltare dei caratteri, si usa @code{substr()} per eliminare i primi
@code{conta_caratteri} caratteri in @code{campi_ultima} e
@code{campi_corrente}. Le due stringhe sono poi confrontare e
@code{se_sono_uguali()} restituisce il risultato del confronto:
@example
@c file eg/prog/uniq.awk
@group
function se_sono_uguali( n, m, campi_ultima, campi_corrente,\
vettore_ultima, vettore_corrente)
@{
if (contatore_file == 0 && conta_caratteri == 0)
return (ultima == $0)
@end group
if (contatore_file > 0) @{
n = split(ultima, vettore_ultima)
m = split($0, vettore_corrente)
campi_ultima = join(vettore_ultima, contatore_file+1, n)
campi_corrente = join(vettore_corrente, contatore_file+1, m)
@} else @{
campi_ultima = ultima
campi_corrente = $0
@}
if (conta_caratteri) @{
campi_ultima = substr(campi_ultima, conta_caratteri + 1)
campi_corrente = substr(campi_corrente, conta_caratteri + 1)
@}
@group
return (campi_ultima == campi_corrente)
@}
@end group
@c endfile
@end example
Le due regole seguenti sono il corpo del programma. La prima @`e eseguita solo
per la prima riga dei dati. Imposta @code{ultima} al record corrente
@code{$0}, in modo che le righe di testo successive abbiano qualcosa con cui
essere confrontate.
La seconda regola fa il lavoro. La variabile @code{uguale} vale uno o zero,
a seconda del risultato del confronto effettuato in @code{se_sono_uguali()}.
Se @command{uniq} sta contando le righe ripetute, e le righe sono uguali,
viene incrementata la variabile @code{contatore}.
Altrimenti, viene stampata la riga e azzerato @code{contatore},
perch@'e le due righe non sono uguali.
Se @command{uniq} non sta contando, e se le righe sono uguali,
@code{contatore} @`e incrementato.
Non viene stampato niente, perch@'e l'obiettivo @`e quello di rimuovere i duplicati.
Altrimenti, se @command{uniq} sta contando le righe ripetute e viene trovata pi@`u
di una riga, o se @command{uniq} sta contando le righe non ripetute
e viene trovata solo una riga, questa riga viene stampata, e @code{contatore} @`e
azzerato.
Infine, una logica simile @`e usata nella regola @code{END} per stampare
l'ultima riga di dati in input:
@example
@c file eg/prog/uniq.awk
NR == 1 @{
ultima = $0
next
@}
@{
uguale = se_sono_uguali()
if (conta_record) @{ # prevale su -d e -u
if (uguale)
contatore++
else @{
printf("%4d %s\n", contatore, ultima) > file_output
ultima = $0
contatore = 1 # reset
@}
next
@}
if (uguale)
contatore++
else @{
if ((solo_ripetute && contatore > 1) ||
(solo_non_ripetute && contatore == 1))
print ultima > file_output
ultima = $0
contatore = 1
@}
@}
END @{
if (conta_record)
printf("%4d %s\n", contatore, ultima) > file_output
@group
else if ((solo_ripetute && contatore > 1) ||
(solo_non_ripetute && contatore == 1))
print ultima > file_output
close(file_output)
@}
@end group
@c endfile
@end example
Incidentalmente, questo programma non segue la convenzione,
raccomandabile, di assegnare alle variabili globali un nome
con la lettera iniziale maiuscola. Se lo si fosse fatto, il programma
sarebbe stato un po' pi@`u semplice da comprendere.
@ifset FOR_PRINT
@cindex Kernighan, Brian @subentry citazioni di
La logica per scegliere quali righe stampare rappresenta una
@dfn{macchina a stati},
che @`e ``un dispositivo che pu@`o trovarsi in una tra un dato numero
di condizioni stabili, a seconda della sua condizione precedente e del valore
corrente dei suoi input.''@footnote{Questa @`e la definizione data in
@uref{https://www.lexico.com/en/definition/state_machine}.}
Brian Kernighan suggerisce che
``un approccio alternativo alle macchine a stati @`e di leggere tutto l'input
e metterlo in un vettore, e poi usare l'indicizzazione. @`E quasi sempre pi@`u
facile da programmare e, per la maggior parte degli input in cui si pu@`o
usare, altrettanto veloce in esecuzione.'' Riscrivere la logica del
programma seguendo questa indicazione.
@end ifset
@node Programma wc
@subsection Contare cose
@cindex contare parole, righe, caratteri e byte
@cindex input @subentry contare elementi in
@cindex parole @subentry contare le
@cindex caratteri @subentry contare i
@cindex righe @subentry contare le
@cindex byte @subentry contare i
@cindex @command{wc} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{wc}
Il programma di utilit@`a @command{wc} (@dfn{word count}, contatore di parole)
conta righe, parole, caratteri e byte in uno o pi@`u file in input.
@menu
* Byte vs. Caratteri:: Moderni insiemi di caratteri.
* Usare le estensioni:: Una breve introduzione alle estensioni.
* Programmma @command{wc}:: Codice per @file{wc.awk}.
@end menu
@node Byte vs. Caratteri
@subsubsection Moderni insiemi di caratteri
Agli inizi dell'era dei computer, un solo byte era usato per contenere
un carattere. Gli insiemi di caratteri pi@`u comuni erano ASCII ed EBCDIC,
ognuno dei quali permetteva di rappresentare tutte le lettere della lingua
inglese, maiuscole e minuscole, i 10 numeri indo-arabi, da 0 a 9, e un
certo numero di altri caratteri di controllo e di interpunzione.
Oggi, l'insieme di caratteri pi@`u utilizzato @`e Unicode (di cui l'originale
ASCII @`e un piccolo sottoinsieme). Unicode permette di rappresentare
decine di migliaia di caratteri differenti (chiamati @dfn{code points},
punti di codice), che sono usati nella maggior parte dei linguaggi umani
esistenti (vivi e morti) e in un certo numero di linguaggi non umani (come il
Klingon e il linguaggio degli elfi di J.R.R.@: Tolkien).
Per risparmiare spazio nei file, i @dfn{code points} Unicode sono
@dfn{codificati}, e la rappresentazione di ogni carattere pu@`o richiedere
da uno a quattro byte nel file. UTF-8 @`e verosimilmente la pi@`u diffusa
fra queste codifiche multi-byte (@dfn{multibyte encodings}).
Lo standard POSIX richiede che @command{awk} gestisca dei caratteri,
non dei byte. Per questo motivo, in @command{gawk}, le funzioni
@code{length()}, @code{substr()}, @code{split()}, @code{match()} e
le altre funzioni di manipolazione di stringhe
(@pxref{Funzioni per stringhe}) funzionano tutte elaborando dei caratteri,
come definiti dall'insieme di caratteri locale [a una determinata lingua]
e non elaborando dei byte. (Incidentalmente, non tutte le implementazioni
di @command{awk} si comportano cos@`{@dotless{i}}).
Non esiste una maniera standard, internamente definita, per distinguere
i byte dai caratteri in un programma @command{awk}. Per una implementazione
con @command{awk} del comando @command{wc}, che necessita di utilizzare
una tale distinzione, sar@`a quindi necessario usare un'estensione esterna.
@node Usare le estensioni
@subsubsection Una breve introduzione alle estensioni
Le estensioni che si possono caricare in @command{gawk} sono presentate
in maniera completa in @ref{Estensioni dinamiche}.
Le estensioni consentono di aggiungere funzioni a @command{gawk}, e queste
possono anche essere dei codici scritti nei linguaggi C o C++.
Per quanto riguarda
@file{wc.awk}, @`e sufficiente sapere che l'estensione viene caricata
con la direttiva @code{@@load}, e la funzione ulteriore che dovr@`a essere
usata si chiama @code{mbs_length()}. Questa funzione restiuisce il numero
di byte in una stringa, e non il numero di caratteri.
L'estensione @code{"mbs"} fa parte del progetto @code{gawkextlib}.
@xref{gawkextlib} for ulteriori informazioni.
@node Programmma @command{wc}
@subsubsection Codice per @file{wc.awk}
La sintassi per @command{wc} @`e la seguente:
@display
@command{wc} [@option{-lwcm}] [@var{file} @dots{}]
@end display
Se nessun file @`e specificato sulla riga di comando, @command{wc} legge il suo
standard input. Se ci sono pi@`u file, stampa anche il contatore totale di
tutti i file. Le opzioni e il loro significato sono i seguenti:
@table @code
@item -l
Conta solo le righe.
@item -w
Conta solo le parole.
Una ``parola'' @`e una sequenza contigua di caratteri non bianchi, separata da
spazi e/o TAB. Fortunatamente, questo @`e il modo normale in cui @command{awk}
separa i campi nei suoi record in input.
@item -c
Conta solo i byte.
Un tempo, la lettera @samp{c} di questa opzione stava per ``caratteri.''
Ma, come spiegato pi@`u sopra, byte e carattere non sono pi@`u sinonimi
tra loro.
@item -m
Conta solo caratteri.
@end table
L'implementazione di @command{wc} in @command{awk} @`e particolarmente
elegante, perch@'e @command{awk} fa molto lavoro al posto nostro;
divide le righe in parole (cio@`e, campi) e le conta, conta le righe
(cio@`e, i record), e pu@`o facilmente dire quanto @`e lunga una riga,
misurata in caratteri.
Questo programma usa la funzione di libreria @code{getopt()}
(@pxref{Funzione getopt})
e le funzioni di passaggio da un file all'altro
(@pxref{Funzione filetrans}).
Questa versione ha una differenza significativa rispetto alle versioni
meno recenti di @command{wc}: stampa sempre i contatori rispettando l'ordine
righe, parole, caratteri e byte. Le versioni meno recenti rilevano l'ordine
in cui sono specificate le opzioni @option{-l}, @option{-w} e @option{-c}
sulla riga di comando, e stampano i contatori in quell'ordine.
Lo standard POSIX, peraltro, non impone di fare cos@`{@dotless{i}}.
La regola @code{BEGIN} elabora gli argomenti. La variabile
@code{stampa_totale} @`e vera se pi@`u di un file @`e presente sulla
riga di comando:
@cindex @code{wc.awk} (programma)
@cindex programma @subentry @code{wc.awk}
@example
@c file eg/prog/wc.awk
# wc.awk --- conta righe, parole, caratteri, byte
@c endfile
@ignore
@c file eg/prog/wc.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised September 2020
@c endfile
@end ignore
@c file eg/prog/wc.awk
# Opzioni:
# -l conta solo righe
# -w conta solo parole
# -c conta solo byte
# -m conta solo caratteri
#
# Il default @`e di contare righe, parole, byte
#
# Richiede le funzioni di libreria getopt()
# e il programma di libreria che gestisce
# il passaggio da un file dati al successivo
# Richiede l'estensione mbs di gawkextlib
@@load "mbs"
BEGIN @{
# consente a getopt() di stampare un messaggio se si specificano
# opzioni non valide. Noi le ignoriamo
while ((c = getopt(ARGC, ARGV, "lwcm")) != -1) @{
if (c == "l")
conta_righe = 1
else if (c == "w")
conta_parole = 1
else if (c == "c")
conta_byte = 1
else if (c == "m")
conta_caratteri = 1
@}
for (i = 1; i < Optind; i++)
ARGV[i] = ""
# se nessuna opzione @`e specificata,
# conta righe, parole, byte
if (! conta_righe && ! conta_parole && ! conta_caratteri && ! conta_byte)
conta_righe = conta_parole = conta_byte = 1
stampa_totale = (ARGC - i > 1)
@}
@c endfile
@end example
La funzione @code{beginfile()} @`e semplice; si limita ad azzerare i contatori
di righe, parole, caratteri e byte, e salva il valore corrente di @value{FN} in
@code{nome_file}:
@example
@c file eg/prog/wc.awk
function beginfile(file)
@{
righe = parole = caratteri = byte = 0
nome_file = FILENAME
@}
@c endfile
@end example
La funzione @code{endfile()} aggiunge i numeri del file corrente al totale
di righe, parole, e caratteri. Poi stampa i numeri relativi al file appena
letto. La funzione
@code{beginfile()} azzera i numeri relativi al @value{DF} seguente:
@example
@c file eg/prog/wc.awk
function endfile(file)
@{
totale_righe += righe
totale_parole += parole
totale_caratteri += caratteri
totale_byte += byte
if (conta_righe)
printf "\t%d", righe
@group
if (conta_parole)
printf "\t%d", parole
@end group
if (conta_caratteri)
printf "\t%d", caratteri
if (conta_byte)
printf "\t%d", byte
printf "\t%s\n", nome_file
@}
@c endfile
@end example
C'@`e una regola che viene eseguita per ogni riga. Aggiunge la lunghezza
del record pi@`u uno, a @code{caratteri}. Aggiungere uno alla lunghezza
del record @`e necessario, perch@'e il carattere a-capo, che separa i record
tra loro (il valore della variabile @code{RS}) non fa parte del record
stesso, e quindi non @`e incluso nella sua lunghezza. Analogamente, si
aggiunge la lunghezza del record in byte, pi@`u uno, a @code{byte}.
Poi, @code{righe} @`e incrementata per ogni riga letta, e @code{parole}
@`e incrementata con il valore di @code{NF}, che @`e il numero di ``parole''
su questa riga:
@example
@c file eg/prog/wc.awk
# per ogni riga...
@{
caratteri += length($0) + 1 # aggiunge il ritorno a capo
byte += mbs_length($0) + 1
righe++
parole += NF
@}
@c endfile
@end example
Infine, la regola @code{END} si limita a stampare i totali per tutti i file:
@example
@c file eg/prog/wc.awk
END @{
if (stampa_totale) @{
if (conta_righe)
printf "\t%d", totale_righe
if (conta_parole)
printf "\t%d", totale_parole
if (conta_caratteri)
printf "\t%d", totale_caratteri
if (conta_byte)
printf "\t%d", totale_byte
print "\ttotale"
@}
@}
@c endfile
@end example
@node Programmi vari
@section Un paniere di programmi @command{awk}
Questa @value{SECTION} @`e un ``paniere'' che contiene vari programmi.
Si spera che siano interessanti e divertenti.
@menu
* Programma dupword:: Trovare parole duplicate in un documento.
* Programma alarm:: Un programma di sveglia.
* Programma translate:: Un programma simile al programma di utilit@`a
@command{tr}.
* Programma labels:: Stampare etichette per lettere.
* Programma utilizzo parole:: Un programma per produrre un contatore
dell'uso di parole in un testo.
* Programma riordino diario:: Eliminare righe doppie da un file di
cronologia.
* Programma extract :: Estrarre programmi da file sorgenti Texinfo.
* Programma sed semplice:: Un semplice editor di flusso.
* Programma igawk:: Un programma per fornire ad
@command{awk} la possibilit@`a di includere
file.
* Programma anagram:: Trovare anagrammi da una lista di parole.
* Programma signature:: La gente fa cose stupefacenti se ha troppo
tempo libero.
@end menu
@node Programma dupword
@subsection Trovare parole duplicate in un documento
@cindex parole @subentry duplicate @subentry ricerca di
@cindex ricerca @subentry di parole
@cindex documenti @subentry ricerca in
Un errore comune quando si scrive un testo lungo @`e quello di ripetere
accidentalmente delle parole. Tipicamente lo si pu@`o vedere in testi del tipo
``questo programma fa quanto segue segue@dots{}'' Quando il testo @`e pubblicato in rete, spesso
le parole duplicate sono poste tra il termine di
una riga e l'inizio di un'altra, il che rende difficile scoprirle.
@c as here!
Questo programma, @file{dupword.awk}, legge un file una riga alla volta
e cerca le occorrenze adiacenti della stessa parola. Conserva anche
l'ultima parola di ogni riga (nella variabile @code{precedente}) per
confrontarla con la prima parola sulla riga successiva.
@cindex Texinfo
Le prime due istruzioni fanno s@`{@dotless{i}} che la riga sia tutta in minuscolo,
in modo che, per esempio, ``Il'' e ``il'' risultino essere la stessa parola.
L'istruzione successiva sostituisce i caratteri che sono non alfanumerici e
diversi dagli
spazi bianchi con degli spazi, in modo che neppure la punteggiatura influenzi
i confronti.
I caratteri sono rimpiazzati da spazi in modo che i controlli di formattazione
non creino parole prive di senso (p.es., l'espressione Texinfo
@samp{@@code@{NF@}} diventa @samp{codeNF}, se ci si limita a eliminare la
punteggiatura). Il record @`e poi
suddiviso di nuovo in campi, producendo cos@`{@dotless{i}} solo la lista delle parole
presenti sulla riga, esclusi eventuali campi nulli.
Se, dopo aver rimosso tutta la punteggiatura, non rimane alcun campo, il
record corrente @`e saltato. In caso contrario, il programma esegue il ciclo
per ogni parola, confrontandola con quella che la precede:
@cindex @code{dupword.awk} (programma)
@cindex programma @subentry @code{dupword.awk}
@example
@c file eg/prog/dupword.awk
# dupword.awk --- trova parole duplicate in un testo
@c endfile
@ignore
@c file eg/prog/dupword.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# December 1991
# Revised October 2000
@c endfile
@end ignore
@c file eg/prog/dupword.awk
@{
$0 = tolower($0)
gsub(/[^[:alnum:][:blank:]]/, " ");
$0 = $0 # divide di nuovo in campi
if (NF == 0)
next
if ($1 == prec)
printf("%s:%d: duplicato %s\n",
nome_file, FNR, $1)
for (i = 2; i <= NF; i++)
if ($i == $(i-1))
printf("%s:%d: duplicato %s\n",
nome_file, FNR, $i)
prec = $NF
@}
@c endfile
@end example
@node Programma alarm
@subsection Un programma di sveglia
@cindex insonnia @subentry cura per
@cindex Robbins @subentry Arnold
@quotation
@i{Nessuna cura contro l'insonnia @`e efficace quanto una sveglia che suona.}
@author Arnold Robbins
@end quotation
@cindex Quanstrom, Erik
@ignore
Date: Sat, 15 Feb 2014 16:47:09 -0500
Subject: Re: 9atom install question
Message-ID:
From: Erik Quanstrom
To: Aharon Robbins
yes.
- erik
Aharon Robbins wrote:
>> sleep is for web developers.
>
>Can I quote you, in the gawk manual?
>
>Thanks,
>
>Arnold
@end ignore
@quotation
@i{Il sonno @`e per sviluppatori web.}
@author Erik Quanstrom
@end quotation
@cindex tempo @subentry sveglia @subentry programma di esempio
@cindex sveglia @subentry programma di esempio
Il seguente programma @`e un semplice programma di ``sveglia''.
Si pu@`o specificare un'ora del giorno e un messaggio opzionale. All'ora
specificata, il programma stampa il messaggio sullo standard output. Inoltre,
si pu@`o specificare il numero di volte in cui il messaggio va ripetuto, e
anche un intervallo di tempo (ritardo) tra ogni ripetizione.
Questo programma usa la funzione @code{getlocaltime()}
@iftex
dalla
@end iftex
@ifnottex
da
@end ifnottex
@ref{Funzione getlocaltime}.
@cindex ASCII
Tutto il lavoro @`e svolto nella regola @code{BEGIN}. La prima parte @`e
il controllo degli argomenti e l'impostazione dei valori di default:
l'intervallo prima di ripetere, il contatore, e il messaggio da stampare.
Se l'utente ha fornito un messaggio che non contiene il carattere ASCII BEL
(noto come carattere ``campanello'', @code{"\a"}), questo viene aggiunto al
messaggio. (Su molti sistemi, stampare il carattere ASCII BEL genera un suono
udibile. Quindi, quando la sveglia suona, il sistema richiama l'attenzione
su di s@'e nel caso che l'utente non stia guardando il computer.)
Per amor di variet@`a, questo programma usa un'istruzione @code{switch}
(@pxref{Istruzione switch}), ma l'elaborazione potrebbe anche essere fatta
con una serie di istruzioni @code{if}-@code{else}.
Ecco il programma:
@cindex @code{alarm.awk} (programma)
@cindex programma @subentry @code{alarm.awk}
@example
@c file eg/prog/alarm.awk
# alarm.awk --- impostare una sveglia
#
# Richiede la funzione di libreria getlocaltime()
# che si trova in gettime.awk
@c endfile
@ignore
@c file eg/prog/alarm.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised December 2010
@c endfile
@end ignore
@c file eg/prog/alarm.awk
# Uso: alarm a_che_ora [ "messaggio" [ contatore [ ritardo ] ] ]
BEGIN @{
# Controllo iniziale congruit@`a argomenti
sintassi1 = "Uso: alarm a_che_ora ['messaggio' [contatore [ritardo]]]"
sintassi2 = sprintf("\t(%s) formato ora: ::= hh:mm", ARGV[1])
if (ARGC < 2) @{
print sintassi1 > "/dev/stderr"
print sintassi2 > "/dev/stderr"
exit 1
@}
switch (ARGC) @{
case 5:
ritardo = ARGV[4] + 0
# vai al caso seguente
case 4:
contatore = ARGV[3] + 0
# vai al caso seguente
case 3:
messaggio = ARGV[2]
break
default:
if (ARGV[1] !~ /[[:digit:]]?[[:digit:]]:[[:digit:]]@{2@}/) @{
print sintassi1 > "/dev/stderr"
print sintassi2 > "/dev/stderr"
exit 1
@}
break
@}
# imposta i valori di default per quando arriva l'ora desiderata
if (ritardo == 0)
ritardo = 180 # 3 minuti
@group
if (contatore == 0)
contatore = 5
@end group
if (messaggio == "")
messaggio = sprintf("\aAdesso sono le %s!\a", ARGV[1])
else if (index(message, "\a") == 0)
messaggio = "\a" messaggio "\a"
@c endfile
@end example
La successiva @value{SECTION} di codice scompone l'ora specificata in ore e
minuti, la converte (se @`e il caso) al formato 24-ore, e poi calcola il
relativo numero di secondi dalla mezzanotte. Poi trasforma l'ora corrente in
un contatore dei secondi dalla
mezzanotte. La differenza tra i due @`e il tempo di attesa che deve passare
prima di far scattare la sveglia:
@example
@c file eg/prog/alarm.awk
# scomponi ora della sveglia
split(ARGV[1], ore_minuti, ":")
ora = ore_minuti[1] + 0 # trasforma in numero
minuto = ore_minuti[2] + 0 # trasforma in numero
# ottiene ora corrente divisa in campi
getlocaltime(adesso)
# se l'ora desiderata @`e in formato 12-ore ed @`e nel pomeriggio
# (p.es., impostare `alarm 5:30' alle 9 del mattino
# vuol dire far suonare la sveglia alle 5:30 pomeridiane)
# aggiungere 12 all'ora richiesta
if (ora < 12 && adesso["hour"] > ora)
ora += 12
# imposta l'ora in secondi dalla mezzanotte
sveglia = (ora * 60 * 60) + (minuto * 60)
# ottieni l'ora corrente in secondi dalla mezzanotte
corrente = (adesso["hour"] * 60 * 60) + \
(adesso["minute"] * 60) + adesso["second"]
# quanto restare appisolati
sonno = sveglia - corrente
if (sonno <= 0) @{
print "alarm: l'ora @`e nel passato!" > "/dev/stderr"
exit 1
@}
@c endfile
@end example
@cindex @command{sleep} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{sleep}
Infine, il programma usa la funzione @code{system()}
(@pxref{Funzioni di I/O})
per chiamare il programma di utilit@`a @command{sleep}. Il programma di utilit@`a
@command{sleep} non fa altro che aspettare per il numero di secondi
specificato. Se il codice di ritorno restituito @`e diverso da zero, il
programma suppone che @command{sleep} sia stato interrotto ed esce. Se
@command{sleep} @`e terminato con un codice di ritorno corretto, (zero), il
programma stampa il messaggio in un ciclo, utilizzando ancora @command{sleep}
per ritardare per il numero di secondi necessario:
@example
@c file eg/prog/alarm.awk
# zzzzzz..... esci se sleep @`e interrotto
if (system(sprintf("sleep %d", sonno)) != 0)
exit 1
# @`e ora di avvisare!
command = sprintf("sleep %d", ritardo)
for (i = 1; i <= contatore; i++) @{
print messaggio
# se il comando sleep @`e interrotto, esci
if (system(command) != 0)
break
@}
exit 0
@}
@c endfile
@end example
@node Programma translate
@subsection Rimpiazzare o eliminare caratteri
@cindex caratteri @subentry rimpiazzare
@cindex rimpiazzare @subentry caratteri in un file
@cindex @command{tr} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{tr}
Il programma di utilit@`a di sistema @command{tr} rimpiazza caratteri. Per
esempio, @`e spesso usato per trasformare lettere maiuscole in lettere minuscole
in vista di ulteriori elaborazioni:
@example
@var{generare dei dati} | tr 'A-Z' 'a-z' | @var{elaborare dei dati} @dots{}
@end example
@command{tr} richiede due liste di caratteri.@footnote{Su alcuni sistemi
pi@`u datati, incluso Solaris, la versione di sistema di @command{tr} pu@`o
richiedere che le liste siano scritte come espressioni di intervallo,
racchiuse in parentesi quadre
(@samp{[a-z]}) e tra apici, per evitare che la shell effettui
espansioni di @value{FN}. Questo non @`e un miglioramento.} Quando
si elabora l'input, il primo carattere della prima lista @`e rimpiazzato con il
primo carattere della seconda lista, il secondo carattere della prima lista @`e
rimpiazzato con il secondo carattere della seconda lista, e cos@`{@dotless{i}} via. Se ci
sono pi@`u caratteri nella lista ``da'' che in quella ``a'', l'ultimo carattere
della lista ``a'' @`e usato per i restanti caratteri della lista ``da''.
In un lontano passato,
@c early or mid-1989!
un utente propose di aggiungere una funzione di traslitterazione a
@command{gawk}.
@c Wishing to avoid gratuitous new features,
@c at least theoretically
Il programma seguente @`e stato scritto per dimostrare che la traslitterazione
di caratteri poteva essere fatta con una funzione definita dall'utente.
Questo programma non @`e cos@`{@dotless{i}} completo come il programma di utilit@`a di sistema
@command{tr}, ma svolge buona parte dello stesso lavoro.
Il programma @command{translate} @`e stato scritto molto prima che @command{gawk}
fosse in grado di separare ciascun carattere di una stringa in elementi
distinti di un vettore. Questo @`e il motivo per cui usa ripetutamente le
funzioni predefinite @code{substr()}, @code{index()}, e @code{gsub()}
(@pxref{Funzioni per stringhe}).
Ci sono due funzioni. La prima, @code{traduci_stringa()},
richiede tre argomenti:
@table @code
@item da
Una lista di caratteri da cui traslitterare
@item a
Una lista di caratteri a cui traslitterare
@item stringa
La stringa su cui effettuare la traslitterazione
@end table
I vettori associativi facilitano molto la parte di traslitterazione.
@code{vettore_trad} contiene i caratteri ``a'', indicizzato dai
caratteri ``da''. Poi un semplice
ciclo scandisce @code{da}, un carattere alla volta. Per ogni carattere
in @code{da}, se il carattere compare in @code{stringa}
@`e rimpiazzato con il corrispondente carattere @code{a}.
La funzione @code{traducilo()} chiama @code{traduci_stringa()}, usando @code{$0}
come stringa. Il programma principale imposta due variabili globali, @code{DA} e
@code{A}, dalla riga di comando, e poi modifica @code{ARGV} in modo che
@command{awk} legga dallo standard input.
Infine, la regola di elaborazione si limita a chiamare @code{traducilo()}
per ogni record:
@cindex @code{translate.awk} (programma)
@cindex programma @subentry @code{translate.awk}
@example
@c file eg/prog/translate.awk
# translate.awk --- fa cose simili al comando tr
@c endfile
@ignore
@c file eg/prog/translate.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# August 1989
# February 2009 - bug fix
@c endfile
@end ignore
@c file eg/prog/translate.awk
# Bug: non gestisce cose del tipo tr A-Z a-z; deve essere
# descritto carattere per carattere.
# Tuttavia, se `a' @`e pi@`u corto di `da',
# l'ultimo carattere in `a' @`e usato per il resto di `da'.
function traduci_stringa(da, a, stringa, lf, lt, lstringa, vettore_trad,
i, c, risultato)
@{
lf = length(da)
lt = length(a)
lstringa = length(stringa)
for (i = 1; i <= lt; i++)
vettore_trad[substr(da, i, 1)] = substr(a, i, 1)
if (lt < lf)
for (; i <= lf; i++)
vettore_trad[substr(da, i, 1)] = substr(a, lt, 1)
for (i = 1; i <= lstringa; i++) @{
c = substr(stringa, i, 1)
if (c in vettore_trad)
c = vettore_trad[c]
risultato = risultato c
@}
return risultato
@}
function traducilo(da, a)
@{
return $0 = traduci_stringa(da, a, $0)
@}
# programma principale
BEGIN @{
@group
if (ARGC < 3) @{
print "Uso: translate da a" > "/dev/stderr"
exit
@}
@end group
DA = ARGV[1]
A = ARGV[2]
ARGC = 2
ARGV[1] = "-"
@}
@{
traducilo(DA, A)
print
@}
@c endfile
@end example
@`E possibile effettuare la traslitterazione di caratteri in una funzione a
livello utente, ma non @`e detto che sia efficiente, e noi (sviluppatori
di @command{gawk}) abbiamo iniziato a prendere in considerazione l'aggiunta di una funzione.
Tuttavia, poco dopo aver scritto questo programma, abbiamo saputo che Brian
Kernighan aveva aggiunto le funzioni @code{toupper()} e @code{tolower()} alla
sua versione di @command{awk} (@pxref{Funzioni per stringhe}). Queste
funzioni gestiscono la maggior parte dei casi in cui serva la traslitterazione
di caratteri, e quindi abbiamo deciso di limitarci ad aggiungere le stesse
funzioni a @command{gawk}, e di disinteressarci del resto.
Un miglioramento ovvio a questo programma sarebbe di impostare il vettore
@code{vettore_trad} solo una volta, in una regola @code{BEGIN}. Tuttavia, ci@`o
presuppone che le liste ``da'' e ``a'' non cambino mai durante tutta
l'esecuzione del programma.
Un altro miglioramento ovvio @`e di consentire l'uso di intervalli, come
@samp{a-z}, come consentito dal programma di utilit@`a @command{tr}. Si pu@`o
trarre ispirazione dal codice di @file{cut.awk} (@pxref{Programma cut}).
@node Programma labels
@subsection Stampare etichette per lettere
@cindex stampare @subentry etichette per lettera
@cindex etichette per lettera @subentry stampare
Ecco un programma ``del mondo-reale''@footnote{``Del mondo-reale'' @`e definito
come ``un programma effettivamente usato per realizzare qualcosa''.}.
Questo @dfn{script} legge elenchi di nomi e indirizzi, e genera etichette per
lettera. Ogni pagina di etichette contiene 20 etichette, su due file da 10
etichette l'una. Gli indirizzi non possono contenere pi@`u di cinque righe di
dati. Ogni indirizzo @`e separato dal successivo da una riga bianca.
L'idea di base @`e di leggere dati per 20 etichette. Ogni riga di ogni etichetta
@`e immagazzinata nel vettore @code{riga}. L'unica regola si occupa di riempire
il vettore @code{riga} e di stampare la pagina dopo che sono state lette 20
etichette.
La regola @code{BEGIN} si limita a impostare @code{RS} alla stringa vuota, in
modo che @command{awk} divida un record dal successivo quando incontra una riga
bianca.
(@pxref{Record}).
Inoltre imposta @code{LIMITE_LINEE} a 100,
perch@'e 100 @`e il massimo numero di righe sulla pagina
@iftex
(@math{20 @cdot 5 = 100}).
@end iftex
@ifnottex
@ifnotdocbook
(20 * 5 = 100).
@end ifnotdocbook
@end ifnottex
@docbook
(20 ⋅ 5 = 100).
@end docbook
Il grosso del lavoro @`e svolto nella funzione @code{stampa_pagina()}.
Le righe che compongono le etichette sono immagazzinate sequenzialmente nel vettore
@code{riga}. Ma occorre stamparle in
orizzontale: @code{riga[1]} a fianco di @code{riga[6]}, @code{riga[2]} a
fianco di @code{riga[7]}, e cos@`{@dotless{i}} via. Questo si pu@`o fare utilizzando due
cicli. Quello pi@`u esterno, controllato dalla variabile @code{i}, gestisce 10
righe di dati, ovvero la stampa di due etichette una a fianco dell'altra.
Il ciclo pi@`u interno
controllato dalla variabile @code{j}, gestisce le singole righe che compongono
ognuno degli indirizzi.
Poich@'e @code{j} varia da 0 a 4, @samp{i+j} @`e la riga @code{j}-esima
dell'indirizzo di sinistra, e @samp{i+j+5} @`e quella stampata alla sua destra.
L'output @`e simile a quello mostrato qui sotto:
@example
riga 1 riga 6
riga 2 riga 7
riga 3 riga 8
riga 4 riga 9
riga 5 riga 10
@dots{}
@end example
@noindent
La stringa di formato per @code{printf} @samp{%-41s} allinea a
sinistra i dati, e li stampa in un campo di lunghezza fissa.
Come nota finale, un'ulteriore riga bianca extra viene stampata alle righe 21 e
61, per mantenere entro i bordi l'output sulle etichette. Ci@`o dipende dalla
particolare marca di etichette in uso quando il programma @`e stato scritto.
Si noti anche che ci sono due righe bianche a inizio pagina e due righe
bianche a fine pagina.
La regola @code{END} si occupa di stampare l'ultima pagina di
etichette; @`e improbabile che il numero di indirizzi da stampare sia un
multiplo esatto di 20:
@cindex @code{labels.awk} (programma)
@cindex programma @subentry @code{labels.awk}
@example
@c file eg/prog/labels.awk
# labels.awk --- stampare etichette per lettera
@c endfile
@ignore
@c file eg/prog/labels.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# June 1992
# December 2010, minor edits
@c endfile
@end ignore
@c file eg/prog/labels.awk
# Ogni etichetta @`e 5 righe di dati, qualcuna delle quali pu@`o essere bianca.
# I fogli con le etichetta hanno 2 righe bianche in cima alla pagina e altre 2
# a fine pagina.
BEGIN @{ RS = "" ; LIMITE_LINEE = 100 @}
function stampa_pagina( i, j)
@{
if (NUMEROrighe <= 0)
return
printf "\n\n" # in cima
for (i = 1; i <= NUMEROrighe; i += 10) @{
if (i == 21 || i == 61)
print ""
for (j = 0; j < 5; j++) @{
if (i + j > LIMITE_LINEE)
break
printf " %-41s %s\n", riga[i+j], riga[i+j+5]
@}
print ""
@}
printf "\n\n" # in fondo
delete riga
@}
# regola principale
@{
if (contatore >= 20) @{
stampa_pagina()
contatore = 0
NUMEROrighe = 0
@}
n = split($0, a, "\n")
for (i = 1; i <= n; i++)
riga[++NUMEROrighe] = a[i]
for (; i <= 5; i++)
riga[++NUMEROrighe] = ""
contatore++
@}
END @{
stampa_pagina()
@}
@c endfile
@end example
@node Programma utilizzo parole
@subsection Generare statistiche sulla frequenza d'uso delle parole
@cindex parole @subentry statistica utilizzo delle
@cindex statistica utilizzo delle parole
Quando si lavora con una grande quantit@`a di testo, pu@`o essere interessante
sapere quanto spesso ricorrono le diverse parole. Per esempio, un autore pu@`o
fare un uso eccessivo di certe parole, e in questo caso si potrebbero
trovare sinonimi da sostituire a
parole che appaiono troppo spesso.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SUBSECTION} spiega come
scrivere un programma per contare le parole e presentare in un formato
utile le informazioni relative alla loro frequenza.
A prima vista, un programma come questo sembrerebbe essere sufficiente:
@example
# wordfreq-first-try.awk --- stampa lista frequenze utilizzo parole
@{
for (i = 1; i <= NF; i++)
freq[$i]++
@}
@group
END @{
for (word in freq)
printf "%s\t%d\n", word, freq[word]
@}
@end group
@end example
Il programma si affida al meccanismo con cui @command{awk} divide i campi per
default, per suddividere ogni riga in ``parole'' e usa un vettore associativo
di nome @code{freq}, che ha per indici le singole parole, per contare il
numero di volte che ogni parola viene usata. Nella regola @code{END}, stampa i
contatori.
Questo programma ha parecchi problemi che lo rendono praticamente inutile
su file di testo reali:
@itemize @value{BULLET}
@item
Il linguaggio @command{awk} considera i caratteri maiuscoli e minuscoli come
distinti (non equivalenti). Quindi, ``barista'' e ``Barista'' sono
considerate parole differenti. Questo non @`e un comportamento auspicabile,
perch@'e le parole iniziano con la lettera maiuscola se sono a inizio frase in
un testo normale, e un analizzatore di frequenze dovrebbe ignorare la
distinzione maiuscolo/minuscolo.
@item
Le parole sono individuate usando la convenzione @command{awk} secondo cui i
campi sono separati solo da spazi bianchi. Altri caratteri nell'input
(tranne il ritorno a capo) non hanno alcun particolare significato per
@command{awk}. Questo significa che i segni di interpunzione sono visti come
parte di una parola.
@item
L'output non @`e scritto in alcun ordine utile. Si @`e probabilmente pi@`u
interessati a sapere quali parole ricorrono pi@`u di frequente, o ad avere
una tabella in ordine alfabetico che mostra quante volte ricorre ogni parola.
@end itemize
@cindex @command{sort} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{sort}
Il primo problema si pu@`o risolvere usando @code{tolower()} per rimuovere la
distinzione maiuscolo/minuscolo. Il secondo problema si pu@`o risolvere usando
@code{gsub()} per rimuovere i caratteri di interpunzione. Infine, per
risolvere il terzo problema si pu@`o usare il programma di utilit@`a
@command{sort} per elaborare l'output dello @dfn{script} @command{awk}. Ecco la
nuova versione del programma:
@cindex @code{wordfreq.awk} (programma)
@cindex programma @subentry @code{wordfreq.awk}
@example
@c file eg/prog/wordfreq.awk
# wordfreq.awk --- stampa la lista con la frequenza delle parole
@{
$0 = tolower($0) # togli maiuscolo/minuscolo
# togli interpunzione
gsub(/[^[:alnum:]_[:blank:]]/, "", $0)
for (i = 1; i <= NF; i++)
freq[$i]++
@}
@c endfile
END @{
for (word in freq)
printf "%s\t%d\n", word, freq[word]
@}
@end example
La @dfn{regexp} @code{/[^[:alnum:]_[:blank:]]/} si poteva scrivere come
@code{/[[:punct:]]/}, ma in questo modo il caratteri trattino basso sarebbe
stato rimosso, mentre si desidera conservarlo.
Supponendo di aver salvato questo programma in un file di nome
@file{wordfreq.awk},
e che i dati siano in @file{file1}, il seguente comando con @dfn{pipeline}:
@example
awk -f wordfreq.awk file1 | sort -k 2nr
@end example
@noindent
produce una tabella delle parole che appaiono in @file{file1} in ordine
descrescente di frequenza.
Il programma @command{awk} da solo gestisce adeguatamente i dati e produce
una tabella delle frequenza che non @`e ordinata.
L'output di @command{awk} @`e poi messo in ordine dal programma di utilit@`a
@command{sort} e stampato sullo schermo.
Le opzioni passate a @command{sort}
richiedono un ordinamento che usi come chiave il secondo campo di ogni riga
in input (saltando il primo campo), che le chiavi di ordinamento siano
trattate come quantit@`a numeriche
(altrimenti @samp{15} sarebbe stampato prima di @samp{5}), e che l'ordinamento
sia fatto in ordine decrescente (inverso).
Il comando @command{sort} potrebbe anche essere richiamato dall'interno del
programma, cambiando l'azione da fare nella regola @code{END} a:
@example
@c file eg/prog/wordfreq.awk
END @{
sort = "sort -k 2nr"
for (word in freq)
printf "%s\t%d\n", word, freq[word] | sort
close(sort)
@}
@c endfile
@end example
Questa maniera di ordinare dev'essere usata su sistemi che non hanno delle
vere e proprie @dfn{pipe} a livello di riga di comando (o di procedura di
comandi).
Si veda la documentazione generale riguardo al sistema operativo per maggiori
informazioni su come usare il programma @command{sort}.
@node Programma riordino diario
@subsection Eliminare duplicati da un file non ordinato
@cindex righe @subentry duplicate @subentry rimuovere
@cindex rimuovere righe duplicate
Il programma @command{uniq}
(@pxref{Programma uniq})
rimuove righe duplicate da dati @emph{ordinati}.
Si supponga, tuttavia, di dover rimuovere righe duplicate da un @value{DF},
ma di voler conservare l'ordine in cui le righe sono state scritte. Un buon
esempio di questo tipo potrebbe essere un file della cronologia dei comandi
della shell. Il file della cronologia dei comandi
mantiene copia di tutti i comandi che sono stati dati, e non @`e
insolito ripetere un comando molte volte di fila. Occasionalmente si
potrebbe voler compattare la cronologia togliendo le righe duplicate.
Tuttavia sarebbe opportuno mantenere l'ordine originale dei comandi.
Questo semplice programma fa questo. Usa due vettori. Il vettore @code{dati}
ha come indice il testo di ogni riga.
Per ogni riga, @code{dati[$0]} @`e incrementato di uno.
Se una particolare riga non @`e stata ancora vista, @code{dati[$0]} @`e zero.
In tal caso, il testo della riga @`e immagazzinato in @code{righe[contatore]}.
Ogni elemento del vettore @code{righe} @`e un comando unico, e gli
indici di @code{righe} indicano l'ordine in cui quelle righe sono state
incontrate.
La regola @code{END} stampa semplicemente le righe, in ordine:
@cindex Rakitzis, Byron
@cindex @code{histsort.awk} (programma)
@cindex programma @subentry @code{histsort.awk}
@example
@c file eg/prog/histsort.awk
# histsort.awk --- compatta un file della cronologia dei comandi della shell
# Grazie a Byron Rakitzis per l'idea generale
@c endfile
@ignore
@c file eg/prog/histsort.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
@c endfile
@end ignore
@c file eg/prog/histsort.awk
@group
@{
if (dati[$0]++ == 0)
righe[++contatore] = $0
@}
@end group
@group
END @{
for (i = 1; i <= contatore; i++)
print righe[i]
@}
@end group
@c endfile
@end example
Questo programma pu@`o essere un punto di partenza per generare altre
informazioni utili.
Per esempio, usando la seguente istruzione @code{print} nella regola
@code{END} permette di sapere quante volte viene usato un certo comando:
@example
print dati[righe[i]], righe[i]
@end example
@noindent
Questo si pu@`o fare perch@'e @code{dati[$0]} @`e incrementato ogni volta che una
riga @`e stata trovata.
@c rick@openfortress.nl, Tue, 24 Dec 2019 13:43:06 +0100
Rick van Rein offre il seguente programma in una riga per fare lo stesso
lavoro, ossia rimuovere le righe doppie da un testo che non sia stato
precedentemente ordinato alfabeticamente:
@example
awk '@{ if (! visto[$0]++) print @}'
@end example
Questo programma pu@`o essere ulteriormente semplificato, con il rischio
di diventare quasi indecifrabile:
@example
awk '! visto[$0]++'
@end example
@noindent
Questa versione usa l'espressione come regola da soddisfare,
ed esegue l'azione di default di @command{awk} (ossia stampa
la riga), quando la regola @`e verificata [ossia se il record non
@`e stato ancora "visto"].
@node Programma extract
@subsection Estrarre programmi da un file sorgente Texinfo
@cindex Texinfo @subentry estrarre programma da file sorgente
@cindex estrarre programma da file sorgente Texinfo
@cindex file @subentry Texinfo @subentry estrarre programma da
@ifnotinfo
Sia questo capitolo che il precedente
(@ref{Funzioni di libreria})
presentano un numero elevato di programmi @command{awk}.
@end ifnotinfo
@ifinfo
I nodi
@ref{Funzioni di libreria},
e @ref{Programmi di esempio},
sono nodi al livello pi@`u elevato, e
contengono nodi che descrivono un numero elevato di programmi @command{awk}.
@end ifinfo
Se si vuole fare pratica con questi programmi, @`e fastidioso doverli
digitare di nuovo manualmente. @`E per questo che abbiamo pensato a un programma
in grado di estrarre parti di un file in input Texinfo e metterli in file
separati.
@cindex Texinfo
Questo @value{DOCUMENT} @`e scritto in @uref{https://www.gnu.org/software/texinfo/, Texinfo},
il programma di formattazione di documenti del progetto GNU.
Un solo file sorgente Texinfo pu@`o essere usato per produrre sia la
documentazione stampata, usando @TeX{}, sia quella online.
@ifnotinfo
(Texinfo @`e esaurientemente documentato nel libro
@cite{Texinfo---The GNU Documentation Format},
disponibile alla Free Software Foundation,
e anche @uref{https://www.gnu.org/software/texinfo/manual/texinfo/, online}.)
@end ifnotinfo
@ifinfo
(Il linguaggio Texinfo @`e descritto esaurientemente, a partire da
@inforef{Top, , Texinfo, texinfo,Texinfo --- The GNU Documentation Format}.)
@end ifinfo
Per quel che ci riguarda, @`e sufficiente sapere tre cose riguardo ai file di
input Texinfo:
@itemize @value{BULLET}
@item
Il simbolo ``chiocciola'' (@samp{@@}) @`e speciale per
Texinfo, proprio come la barra inversa (@samp{\}) lo @`e per il linguaggio C
o per @command{awk}. I simboli @samp{@@} sono rappresentati nel sorgente
Texinfo come @samp{@@@@}.
@item
I commenti iniziano con @samp{@@c} o con @samp{@@comment}.
Il programma di estrazione file funziona usando dei commenti speciali che
sono posti all'inizio di una riga.
@item
Righe contenenti comandi @samp{@@group} e @samp{@@end group} racchiudono testi
di esempio che non dovrebbero andare a cavallo di due pagine.
(Sfortunatamente, @TeX{} non @`e sempre in grado di fare le cose in maniera
esatta, e quindi va un po' aiutato).
@end itemize
Il programma seguente, @file{extract.awk}, legge un file sorgente Texinfo
e fa due cose, basandosi sui commenti speciali.
Dopo aver visto il commento @samp{@w{@@c system @dots{}}},
esegue un comando, usando il testo del comando contenuto nella
riga di controllo e passandolo alla funzione @code{system()}
(@pxref{Funzioni di I/O}).
Dopo aver trovato il commento @samp{@@c file @var{nome_file}}, ogni riga
successiva @`e spedita al file @var{nome_file}, fino a che si trova un
commento @samp{@@c endfile}.
Le regole in @file{extract.awk} sono soddisfatte sia quando incontrano
@samp{@@c} che quando incontrano @samp{@@comment} e quindi la parte
@samp{omment} @`e opzionale.
Le righe che contengono @samp{@@group} e @samp{@@end group} sono semplicemente
ignorate.
@file{extract.awk} usa la funzione di libreria @code{join()}
(@pxref{Funzione join}).
I programmi di esempio nel sorgente Texinfo online di @cite{@value{TITLE}}
(@file{gawktexi.in}) sono stati tutti inseriti tra righe @samp{file} e righe
@samp{endfile}. La distribuzione di @command{gawk} usa una copia di
@file{extract.awk} per estrarre i programmi di esempio e per installarne
molti in una particolare directory dove @command{gawk} li pu@`o trovare.
Il file Texinfo ha un aspetto simile a questo:
@example
@dots{}
Questo programma ha una regola @@code@{BEGIN@}
che stampa un messaggio scherzoso:
@@example
@@c file esempi/messages.awk
BEGIN @@@{ print "Non v'allarmate!" @@@}
@@c endfile
@@end example
Stampa anche qualche avviso conclusivo:
@@example
@@c file esempi/messages.awk
END @@@{ print "Evitate sempre gli archeologi annoiati!" @@@}
@@c endfile
@@end example
@dots{}
@end example
Il programma @file{extract.awk} inizia con l'impostare @code{IGNORECASE} a
uno, in modo che un miscuglio di lettere maiuscole e minuscole nelle direttive
non faccia differenza.
La prima regola gestisce le chiamate a @code{system()}, controllando che sia
stato fornito un comando (@code{NF} dev'essere almeno tre) e controllando
anche che il comando termini con un codice di ritorno uguale a zero, che sta
a significare che tutto @`e andato bene:
@cindex @code{extract.awk} (programma)
@cindex programma @subentry @code{extract.awk}
@example
@c file eg/prog/extract.awk
# extract.awk --- estrae file ed esegue programmi dal file Texinfo
@c endfile
@ignore
@c file eg/prog/extract.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised September 2000
@c endfile
@end ignore
@c file eg/prog/extract.awk
BEGIN @{ IGNORECASE = 1 @}
/^@@c(omment)?[ \t]+system/ @{
if (NF < 3) @{
e = ("extract: " FILENAME ":" FNR)
e = (e ": riga `system' con formato errato")
print e > "/dev/stderr"
next
@}
$1 = ""
$2 = ""
stat = system($0)
if (stat != 0) @{
e = ("extract: " FILENAME ":" FNR)
e = (e ": attenzione: system ha restituito " stat)
print e > "/dev/stderr"
@}
@}
@c endfile
@end example
@noindent
La variabile @code{e} @`e stata usata per far s@`{@dotless{i}} che la regola
sia agevolemente contenuta nella @value{PAGE}.
La seconda regola gestisce il trasferimento di dati in un file. Verifica che
nella direttiva sia stato fornito un @value{FN}.
Se il nome del file non @`e quello del file corrente, il file
corrente viene chiuso. Mantenere aperto il file corrente finch@'e non si trova
un nuovo nome file permette di usare la ridirezione @samp{>} per stampare i
contenuti nel file, semplificando la gestione dei file aperti.
Il ciclo @code{for} esegue il lavoro. Legge le righe usando @code{getline}
(@pxref{Getline}).
Se si raggiunge una fine-file inattesa, viene chiamata la funzione
@code{@w{fine_file_inattesa()}}. Se la riga @`e una riga ``endfile'',
il ciclo viene abbandonato.
Se la riga inizia con @samp{@@group} o @samp{@@end group}, la riga viene
ignorata, e si passa a quella seguente. Allo stesso modo, eventuali commenti
all'interno degli esempi vengono ignorati.
Il grosso del lavoro @`e nelle poche righe che seguono. Se la riga non ha
simboli @samp{@@}, il programma la pu@`o
stampare cos@`{@dotless{i}} com'@`e. Altrimenti, ogni @samp{@@} a inizio parola dev'essere
eliminato.
Per rimuovere i simboli @samp{@@}, la riga viene divisa nei singoli elementi
del vettore @code{a}, usando la funzione @code{split()}
(@pxref{Funzioni per stringhe}).
Il simbolo @samp{@@} @`e usato come carattere di separazione.
Ogni elemento del vettore @code{a} che risulti vuoto indica due caratteri
@samp{@@} contigui nella riga originale. Per ogni due elementi vuoti
(@samp{@@@@} nel file originale), va inserito un solo simbolo @samp{@@} nel
file in output.
Una volta terminato di esaminare il vettore, viene chiamata la funzione @code{join()}
specificando nella chiamata il valore di @code{SUBSEP}
(@pxref{Vettori multidimensionali}),
per riunire nuovamente i pezzi in una riga sola.
La riga @`e poi stampata nel file di output:
@example
@c file eg/prog/extract.awk
/^@@c(omment)?[ \t]+file/ @{
if (NF != 3) @{
e = ("extract: " FILENAME ":" FNR ": riga `file' con formato errato")
print e > "/dev/stderr"
next
@}
if ($3 != file_corrente) @{
if (file_corrente != "")
lista_file[file_corrente] = 1 # memorizza per chiudere dopo
file_corrente = $3
@}
for (;;) @{
if ((getline riga) <= 0)
fine_file_inattesa()
if (riga ~ /^@@c(omment)?[ \t]+endfile/)
break
else if (riga ~ /^@@(end[ \t]+)?group/)
continue
else if (riga ~ /^@@c(omment+)?[ \t]+/)
continue
if (index(riga, "@@") == 0) @{
print riga > file_corrente
continue
@}
# gestisci istruzioni che convertono caratteri accentati
if (index(riga, "gsub(\"@@@@") > 0) @{
gsub("@@@{","@{",riga)
gsub("@@@}","@}",riga)
gsub("@@@@","@@",riga)
print riga > file_corrente
continue
@}
# istruzioni che convertono caratteri accentati
gsub("@@`a","Ã ",riga)
gsub("@@`e","è",riga)
gsub("@@'e","é",riga)
gsub("@@`@{@@dotless@{i@}@}","ì",riga)
gsub("@@`o","ò",riga)
gsub("@@`u","ù",riga)
# riga contiene ancora caratteri @@?
if (index(riga, "@@") == 0) {
print riga > file_corrente
continue
@}
n = split(riga, a, "@@")
# if a[1] == "", vuol dire riga che inizia per @@,
# non salvare un @@
for (i = 2; i <= n; i++) @{
if (a[i] == "") @{ # era un @@@@
a[i] = "@@"
if (a[i+1] == "")
i++
@}
@}
@group
print join(a, 1, n, SUBSEP) > file_corrente
@}
@}
@end group
@c endfile
@end example
@`E importante notare l'uso della ridirezione @samp{>} .
L'output fatto usando @samp{>} apre il file solo la prima volta; il file resta
poi aperto, e ogni scrittura successiva @`e aggiunta in fondo al file.
(@pxref{Ridirezione}).
Ci@`o rende agevole mischiare testo del programma e commenti esplicativi
(come @`e stato fatto qui) nello stesso file sorgente, senza nessun problema.
Il file viene chiuso solo quando viene trovato un nuovo nome di
@value{DF} oppure alla fine del file in input.
Quando si incontra un nuovo @value{FN}, invece di chiudere il file,
il programma memorizza il nome del file corrente in @code{lista_file}.
Ci@`o rende possibile mischiare il codice per pi@`u di un file nel file
sorgente Texinfo in input. (Precedenti versioni di questo programma
chiudevano @emph{davvero} il file. Ma, a causa della ridirezione
@samp{>}, un file le cui parti non erano tutte una di seguito all'altra
finiva per contenere errori.)
Una regola @code{END} effettua la chiusura di tutti i file aperti, quando
l'elaborazione @`e stata completata:
@example
@c file eg/prog/extract.awk
@group
END @{
close(file_corrente) # chiudi l'ultimo file
for (f in lista_file) # chiudi tutti gli altri
close(f)
@}
@end group
@c endfile
@end example
Per finire, la funzione @code{@w{fine_file_inattesa()}} stampa un
appropriato messaggio di errore ed esce:
@example
@c file eg/prog/extract.awk
@group
function fine_file_inattesa()
@{
printf("extract: %s:%d: fine-file inattesa, o errore\n",
FILENAME, FNR) > "/dev/stderr"
exit 1
@}
@end group
@c endfile
@end example
@node Programma sed semplice
@subsection Un semplice editor di flusso
@cindex @command{sed} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{sed}
@cindex editori di flusso
@cindex flusso @subentry editori di
Il programma di utilit@`a @command{sed} @`e un @dfn{editore di flusso},
ovvero un programma che legge un flusso di dati, lo modifica, e scrive il file
cos@`{@dotless{i}} modificato.
@`E spesso usato per fare modifiche generalizzate a un grosso file, o a un
flusso di dati generato da una @dfn{pipeline} di comandi.
Sebbene @command{sed} sia un programma piuttosto complesso di suo, l'uso che
se ne fa solitamente @`e di effettuare delle sostituzioni globali attraverso
una @dfn{pipeline}:
@example
@var{comando1} < dati.originali | sed 's/vecchio/nuovo/g' | @var{comando2} > risultato
@end example
Qui, @samp{s/vecchio/nuovo/g} chiede a @command{sed} di ricercare la
@dfn{regexp} @samp{vecchio} in ogni riga di input e di sostituirla
dappertutto con il testo @samp{nuovo} (cio@`e, in tutte le occorrenze di
ciascuna riga). Questo @`e simile a quello che fa la funzione di @command{awk}
@code{gsub()}
(@pxref{Funzioni per stringhe}).
Il programma seguente, @file{awksed.awk}, accetta almeno due argomenti dalla
riga di comando: l'espressione da ricercare e il testo con cui rimpiazzarla.
Ogni ulteriore argomento @`e considerato
come un nome di @value{DF} da elaborare. Se non ne viene fornito alcuno, si
usa lo standard input:
@cindex Brennan, Michael
@cindex @command{awksed.awk} (programma)
@cindex programma @subentry @command{awksed.awk}
@c @cindex simple stream editor
@c @cindex stream editor, simple
@example
@c file eg/prog/awksed.awk
# awksed.awk --- fa s/pippo/pluto/g usando solo print
# Ringraziamenti a Michael Brennan per l'idea
@c endfile
@ignore
@c file eg/prog/awksed.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# August 1995
@c endfile
@end ignore
@c file eg/prog/awksed.awk
function sintassi()
@{
print "Uso: awksed espressione rimpiazzo [file...]" > "/dev/stderr"
exit 1
@}
@group
BEGIN @{
# valida argomenti
if (ARGC < 3)
sintassi()
@end group
RS = ARGV[1]
ORS = ARGV[2]
# non usare argomenti come nomi di file
ARGV[1] = ARGV[2] = ""
@}
@group
# guarda, mamma, senza mani!
@{
if (RT == "")
printf "%s", $0
else
print
@}
@end group
@c endfile
@end example
Il programma fa assegnamento sulla capacit@`a di @command{gawk} di avere come
@code{RS} una @dfn{regexp},
e anche sul fatto che @code{RT} viene impostato al testo che effettivamente
delimita il record (@pxref{Record}).
L'idea @`e di usare @code{RS} come espressione da ricercare. @command{gawk}
automaticamente imposta @code{$0} al testo che compare tra due corrispondenze
all'espressione di ricerca.
Questo @`e appunto il testo che vogliamo conservare inalterato. Quindi,
impostando @code{ORS} al testo che si vuole sostituire, una semplice
istruzione @code{print} scrive il testo che si vuole mantenere, seguito dal
testo che si vuole invece sostituire.
C'@`e un problema in questo schema, ossia cosa fare se l'ultimo record
non termina con un testo che corrisponde a @code{RS}. Usando un'istruzione
@code{print} incondizionatamente stampa il testo da sostituire, il che non
@`e corretto.
Tuttavia, se il file non termina con del testo che corrisponde a @code{RS},
@code{RT} @`e impostata alla stringa nulla. In tal caso, si pu@`o stampare
@code{$0} usando @code{printf}
(@pxref{Printf}).
La regola @code{BEGIN} gestisce la preparazione, controllando che ci sia
il numero giusto di argomenti e chiamando @code{sintassi()} se c'@`e un problema.
Poi imposta @code{RS} e @code{ORS} dagli argomenti della riga di comando e
imposta @code{ARGV[1]} e @code{ARGV[2]} alla stringa nulla, per impedire che
vengano considerati dei @value{FNS}
(@pxref{ARGC e ARGV}).
La funzione @code{sintassi()} stampa un messaggio di errore ed esce.
Per finire, l'unica regola gestisce lo schema di stampa delineato pi@`u sopra,
usando @code{print} o @code{printf} come richiesto, a seconda del valore di
@code{RT}.
@node Programma igawk
@subsection Una maniera facile per usare funzioni di libreria
@cindex libreria di funzioni @command{awk} @subentry programma di esempio per usare una
@cindex funzioni @subentry libreria di @subentry programma di esempio per usare una
@iftex
Nella
@end iftex
@ifnottex
In
@end ifnottex
@ref{Includere file}, abbiamo visto come @command{gawk} preveda la
possibilit@`a di includere file. Tuttavia, questa @`e un'estensione @command{gawk}.
Questa @value{SECTION} evidenzia l'utilit@`a di rendere l'inclusione di
file disponibile per @command{awk} standard, e mostra come farlo utilizzando
una combinazione di programmazione di shell e di @command{awk}.
Usare funzioni di libreria in @command{awk} pu@`o presentare molti vantaggi.
Incoraggia il riutilizzo di codice e la scrittura di funzioni di tipo
generale. I programmi sono pi@`u snelli e quindi pi@`u comprensibili.
Tuttavia, usare funzioni di libreria @`e facile solo in fase di scrittura di
programmi @command{awk}; @`e invece complicato al momento di eseguirli,
rendendo necessario specificare molte opzioni @option{-f}. Se @command{gawk}
non @`e disponibile, non lo sono neppure la variabile d'ambiente @env{AWKPATH} e
la possibilit@`a di conservare funzioni @command{awk} in una directory di
libreria (@pxref{Opzioni}).
Sarebbe bello poter scrivere programmi nel modo seguente:
@example
# funzioni di libreria
@@include getopt.awk
@@include join.awk
@dots{}
# programma principale
BEGIN @{
while ((c = getopt(ARGC, ARGV, "a:b:cde")) != -1)
@dots{}
@dots{}
@}
@end example
Il programma seguente, @file{igawk.sh}, fornisce questo servizio.
Simula la ricerca da parte di @command{gawk} della variabile d'ambiente
@env{AWKPATH} e permette anche delle inclusioni @dfn{nidificate} (cio@`e,
un file che @`e stato incluso tramite
@code{@@include} pu@`o contenere ulteriori istruzioni @code{@@include}).
@command{igawk} tenta di includere ogni file una volta sola, in modo che delle
inclusioni nidificate non contengano accidentalmente una funzione di libreria
pi@`u di una volta.
@command{igawk} dovrebbe comportarsi esternamente proprio come @command{gawk}.
Questo vuol dire che dovrebbe accettare sulla riga di comando tutti gli
argomenti di @command{gawk}, compresa
la capacit@`a di specificare pi@`u file
sorgenti tramite l'opzione @option{-f}
e la capacit@`a di mescolare istruzioni da riga di comando e file di sorgenti di
libreria.
Il programma @`e scritto usando il linguaggio della shell POSIX
(@command{sh}).@footnote{Una spiegazione dettagliata del linguaggio della
@command{sh} non rientra negli intenti di questo libro. Qualche spiegazione
sommaria viene fornita, ma se si desidera una comprensione pi@`u dettagliata, si
dovrebbe consultare un buon libro sulla programmazione della shell.}
Il funzionamento @`e il seguente:
@enumerate
@item
Esegue un ciclo attraverso gli argomenti, salvando tutto ci@`o che non si presenta come
codice sorgente @command{awk}, per quando il programma espanso sar@`a eseguito.
@item
Per ogni argomento che rappresenta del codice @command{awk}, mette l'argomento
in una variabile di shell che verr@`a espansa. Ci sono due casi:
@enumerate a
@item
Un testo letterale, fornito con l'opzione @option{-e} o @option{--source}.
Questo testo viene aggiunto direttamente in fondo.
@item
@value{FNS} sorgenti, forniti con l'opzione @option{-f}. Usiamo il trucchetto
di aggiungere @samp{@@include @var{nome_file}} in fondo ai contenuti della
variabile di shell. Poich@'e il programma di inclusione dei file funziona
allo stesso modo in cui funziona @command{gawk}, ne risulta che il file viene
incluso nel programma al punto giusto.
@end enumerate
@item
Esegue un programma (naturalmente @command{awk}) sui contenuti della variabile
di shell per espandere le istruzioni
@code{@@include}. Il programma espanso @`e messo in una seconda variabile di
shell.
@item
Esegue il programma espanso richiamando @command{gawk} e tutti gli altri
argomenti originalmente forniti dall'utente sulla riga di comando (come p.es.
dei nomi di @value{DF}).
@end enumerate
Questo programma usa variabili di shell in quantit@`a: per immagazzinare
argomenti della riga di comando e
il testo del programma @command{awk} che espander@`a il programma dell'utente,
per il programma originale dell'utente e per il programma espanso. Questo
modo di procedere risolve potenziali
problemi che potrebbero presentarsi se si usassero invece dei file temporanei,
ma rende lo @dfn{script} un po' pi@`u complicato.
La parte iniziale del programma attiva il tracciamento della shell se il primo
argomento @`e @samp{debug}.
La parte successiva esegue un ciclo che esamina ogni argomento della riga di
comando.
Ci sono parecchi casi da esaminare:
@c @asis for docbook
@table @asis
@item @option{--}
Quest'opzione termina gli argomenti per @command{igawk}. Tutto quel che segue
dovrebbe essere passato al programma @command{awk} dell'utente senza essere
preso in considerazione.
@item @option{-W}
Questo indica che l'opzione successiva @`e propria di @command{gawk}. Per
facilitare l'elaborazione degli argomenti, l'opzione @option{-W} @`e aggiunta
davanti agli argomenti rimanenti, e il
ciclo continua. (Questo @`e un trucco di programmazione della @command{sh}.
Non @`e il caso di preoccuparsene se non si ha familiarit@`a con il comando
@command{sh}.)
@item @option{-v}, @option{-F}
Queste opzioni sono conservate e lasciate da gestire a @command{gawk}.
@item @option{-f}, @option{--file}, @option{--file=}, @option{-Wfile=}
Il @value{FN} @`e aggiunto alla variabile di shell @code{programma}, insieme
a un'istruzione @code{@@include}.
Il programma di utilit@`a @command{expr} @`e usato per eliminare la parte
iniziale dell'argomento (p.es., @samp{--file=}).
(La sintassi tipica di @command{sh} richiederebbe di usare il comando
@command{echo} e il programma di utilit@`a @command{sed} per far questo.
Sfortunatamente, alcune versioni di @command{echo} valutano le sequenze
di protezione contenute nei loro argomenti, e questo potrebbe finire per
alterare il testo del programma.
L'uso di @command{expr} evita questo problema.)
@item @option{--source}, @option{--source=}, @option{-Wsource=}
Il testo sorgente @`e aggiunto in fondo a @code{programma}.
@item @option{--version}, @option{-Wversion}
@command{igawk} stampa il proprio numero di versione, esegue
@samp{gawk --version} per ottenere l'informazione relativa alla versione di
@command{gawk}, ed esce.
@end table
Se nessuno degli argomenti
@option{-f}, @option{--file}, @option{-Wfile}, @option{--source},
o @option{-Wsource} @`e stato fornito, il primo argomento che non @`e un'opzione
dovrebbe essere il programma @command{awk}. Se non ci sono argomenti rimasti
sulla riga di comando, @command{igawk} stampa un messaggio di errore ed esce.
Altrimenti, il primo argomento @`e aggiunto in fondo a @code{programma}.
In qualsiasi caso, dopo che gli argomenti sono stati elaborati,
la variabile di shell
@code{programma} contiene il testo completo del programma originale
@command{awk}.
Il programma @`e il seguente:
@cindex @code{igawk.sh} (programma)
@cindex programma @subentry @code{igawk.sh}
@example
@c file eg/prog/igawk.sh
#! /bin/sh
# igawk --- come gawk ma abilita l'uso di @@include
@c endfile
@ignore
@c file eg/prog/igawk.sh
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# July 1993
# December 2010, minor edits
# Antonio Colombo, October 2020, test for Italian accented letters
@c endfile
@end ignore
@c file eg/prog/igawk.sh
if [ "$1" = debug ]
then
set -x
shift
fi
# Un ritorno a capo letterale,
# per formattare correttamente il testo del programma
n='
'
# Inizializza delle variabili alla stringa nulla
programma=
opts=
while [ $# -ne 0 ] # ciclo sugli argomenti
do
case $1 in
--) shift
break ;;
-W) shift
# Il costrutto $@{x?'messaggio qui'@} stampa un
# messaggio diagnostico se $x @`e la stringa nulla
set -- -W"$@{@@?'manca operando'@}"
continue ;;
-[vF]) opts="$opts $1 '$@{2?'manca operando'@}'"
shift ;;
-[vF]*) opts="$opts '$1'" ;;
-f) programma="$programma$n@@include $@{2?'manca operando'@}"
shift ;;
-f*) f=$(expr "$1" : '-f\(.*\)')
programma="$programma$n@@include $f" ;;
-[W-]file=*)
f=$(expr "$1" : '-.file=\(.*\)')
programma="$programma$n@@include $f" ;;
-[W-]file)
programma="$programma$n@@include $@{2?'manca operando'@}"
shift ;;
-[W-]source=*)
t=$(expr "$1" : '-.source=\(.*\)')
programma="$programma$n$t" ;;
-[W-]source)
programma="$programma$n$@{2?'manca operando'@}"
shift ;;
-[W-]version)
echo igawk: version 3.0 1>&2
gawk --version
exit 0 ;;
-[W-]*) opts="$opts '$1'" ;;
*) break ;;
esac
shift
done
if [ -z "$programma" ]
then
programma=$@{1?'manca programma'@}
shift
fi
# A questo punto, `programma' contiene il programma.
@c endfile
@end example
Il programma @command{awk} che elabora le direttive @code{@@include}
@`e immagazzinato nella variabile di shell @code{progr_che_espande}. Ci@`o serve
a mantenere leggibile lo @dfn{script}. Questo programma @command{awk} legge
tutto il programma dell'utente, una riga per volta, usando @code{getline}
(@pxref{Getline}). I @value{FNS} in input e le istruzioni @code{@@include}
sono gestiti usando una pila. Man mano che viene trovata una @code{@@include},
il valore corrente di @value{FN} @`e
``spinto'' sulla pila e il file menzionato nella direttiva @code{@@include}
diventa il @value{FN} corrente. Man mano che un file @`e finito,
la pila viene ``disfatta'', e il precedente file in input diventa nuovamente il
file in input corrente. Il processo viene iniziato ponendo il file originale
come primo file sulla pila.
La funzione @code{percorso()} trova qual @`e il percorso completo di un file.
Simula il comportamento di @command{gawk} quando utilizza la variabile
d'ambiente @env{AWKPATH}
(@pxref{AWKPATH (Variabile)}).
Se un @value{FN} contiene una @samp{/}, non viene effettuata la ricerca del
percorso. Analogamente, se il
@value{FN} @`e @code{"-"}, viene usato senza alcuna modifica. Altrimenti,
il @value{FN} @`e concatenato col nome di ogni directory nella lista dei
percorsi, e vien fatto un tentativo per aprire il @value{FN} cos@`{@dotless{i}} generato.
Il solo modo di controllare se un file @`e leggibile da @command{awk} @`e di
andare avanti e tentare di leggerlo con
@code{getline}; questo @`e quel che
@code{percorso()} fa.@footnote{In alcune versioni molto datate di
@command{awk}, il test @samp{getline da_buttare < t} pu@`o ripetersi in un ciclo
infinito se il file esiste ma @`e vuoto.}
Se il file pu@`o essere letto, viene chiuso e viene restituito il valore di
@value{FN}:
@ignore
An alternative way to test for the file's existence would be to call
@samp{system("test -r " t)}, which uses the @command{test} utility to
see if the file exists and is readable. The disadvantage to this method
is that it requires creating an extra process and can thus be slightly
slower.
@end ignore
@example
@c file eg/prog/igawk.sh
progr_che_espande='
function percorso(file, i, t, da_buttare)
@{
if (index(file, "/") != 0)
return file
if (file == "-")
return file
for (i = 1; i <= n_dir; i++) @{
t = (lista_percorsi[i] "/" file)
@group
if ((getline da_buttare < t) > 0) @{
# found it
close(t)
return t
@}
@end group
@}
return ""
@}
@c endfile
@end example
Il programma principale @`e contenuto all'interno di una regola @code{BEGIN}.
La prima cosa che fa @`e di impostare il vettore @code{lista_percorsi} usato
dalla funzione @code{percorso()}. Dopo aver diviso la lista usando come
delimitatore @samp{:}, gli elementi nulli sono sostituiti da @code{"."},
che rappresenta la directory corrente:
@example
@c file eg/prog/igawk.sh
BEGIN @{
percorsi = ENVIRON["AWKPATH"]
n_dir = split(percorsi, lista_percorsi, ":")
for (i = 1; i <= n_dir; i++) @{
if (lista_percorsi[i] == "")
lista_percorsi[i] = "."
@}
@c endfile
@end example
La pila @`e inizializzata con @code{ARGV[1]}, che sar@`a @code{"/dev/stdin"}.
Il ciclo principale viene subito dopo. Le righe in input sono lette una dopo
l'altra. Righe che non iniziano con @code{@@include} sono stampate cos@`{@dotless{i}} come
sono.
Se la riga inizia con @code{@@include}, il @value{FN} @`e in @code{$2}.
La funzione @code{percorso()} @`e chiamata per generare il percorso completo.
Se questo non riesce, il programma stampa un messaggio di errore e continua.
Subito dopo occorre controllare se il file sia gi@`a stato incluso. Il vettore
@code{gia_fatto} @`e indicizzato dal nome completo di ogni @value{FN} incluso
e tiene traccia per noi di questa informazione. Se un file viene visto pi@`u
volte, viene stampato un messaggio di avvertimento. Altrimenti il nuovo
@value{FN} @`e aggiunto alla pila e l'elaborazione continua.
Infine, quando @code{getline} giunge alla fine del file in input, il file
viene chiuso, e la pila viene elaborata. Quando @code{indice_pila} @`e minore
di zero, il programma @`e terminato:
@example
@c file eg/prog/igawk.sh
indice_pila = 0
input[indice_pila] = ARGV[1] # ARGV[1] @`e il primo file
for (; indice_pila >= 0; indice_pila--) @{
while ((getline < input[indice_pila]) > 0) @{
if (tolower($1) != "@@include") @{
print
continue
@}
cammino = percorso($2)
if (cammino == "") @{
printf("igawk: %s:%d: non riesco a trovare %s\n",
input[indice_pila], FNR, $2) > "/dev/stderr"
continue
@}
if (! (cammino in gia_fatto)) @{
gia_fatto[cammino] = input[indice_pila]
input[++indice_pila] = cammino # aggiungilo alla pila
@} else
print $2, "incluso in", input[indice_pila],
"era gi@`a incluso in",
gia_fatto[cammino] > "/dev/stderr"
@}
close(input[indice_pila])
@}
@}' # l'apice chiude la variabile `progr_che_espande'
programma_elaborato=$(gawk -- "$progr_che_espande" /dev/stdin << EOF
$programma
EOF
)
@c endfile
@end example
Il costrutto di shell @samp{@var{comando} << @var{marcatore}} @`e chiamato
@dfn{here document} (@dfn{documento sul posto}). Ogni riga presente nello
script di shell fino al @var{marcatore} @`e passato in input a @var{comando}.
La shell elabora i contenuti dell'@dfn{here document} sostituendo, dove serve,
variabili e comandi (ed eventualmente altre cose, a seconda della shell
in uso).
Il costrutto di shell @samp{$(@dots{})} @`e chiamato @dfn{sostituzione di comando}.
L'output del comando posto all'interno delle parentesi @`e sostituito
nella riga di comando.
Poich@'e il risultato @`e usato in un assegnamento di variabile,
viene salvato come un'unica stringa di caratteri, anche se il risultato
contiene degli spazi bianchi.
Il programma espanso @`e salvato nella variabile @code{programma_elaborato}.
Il tutto avviene secondo le fasi seguenti:
@enumerate
@item
Si esegue @command{gawk} con il programma che gestisce le @code{@@include}
(il valore della variabile di shell
@code{progr_che_espande}) leggendo lo standard input.
@item
Lo standard input contiene il programma dell'utente,
nella variabile di shell @code{programma}.
L'input @`e passato a @command{gawk} tramite un @dfn{here document}.
@item
I risultati di questo processo sono salvati nella variabile di shell
@code{programma_elaborato} usando la sostituzione di comando.
@end enumerate
L'ultima fase @`e la chiamata a @command{gawk} con il programma espanso,
insieme alle opzioni originali e agli argomenti della riga di comando che
l'utente aveva fornito:
@example
@c file eg/prog/igawk.sh
eval gawk $opts -- '"$programma_elaborato"' '"$@@"'
@c endfile
@end example
Il comando @command{eval} @`e una struttura della shell che riesegue
l'elaborazione dei parametri della riga di comando. Gli apici proteggono le
parti restanti.
Questa versione di @command{igawk} @`e la quinta versione di questo programma.
Ci sono quattro semplificazioni migliorative:
@itemize @value{BULLET}
@item
L'uso di @code{@@include} anche per i file specificati tramite l'opzione
@option{-f} consente di semplificare di molto la preparazione del programma
iniziale @command{awk}; tutta l'elaborazione delle istruzioni @code{@@include}
pu@`o essere svolta in una sola volta.
@item
Non tentare di salvare la riga letta tramite @code{getline} all'interno della
funzione @code{percorso()} quando si controlla se il file @`e accessibile
per il successivo uso nel programma principale semplifica notevolmente
le cose.
@item
Usare un ciclo di @code{getline} nella regola @code{BEGIN} rende possibile
fare tutto in un solo posto. Non @`e necessario programmare un ulteriore ciclo
per elaborare le istruzioni @code{@@include} nidificate.
@item
Invece di salvare il programma espanso in un file temporaneo, assegnarlo a
una variabile di shell evita alcuni potenziali problemi di sicurezza.
Ci@`o per@`o ha lo svantaggio di basare lo @dfn{script} su funzionalit@`a del
linguaggio @command{sh}, il che rende pi@`u difficile la comprensione a chi non
abbia familiarit@`a con il comando
@command{sh}.
@end itemize
Inoltre, questo programma dimostra come spesso valga la pena di utilizzare
insieme la programmazione della @command{sh} e quella di @command{awk}.
Solitamente, si pu@`o fare parecchio senza dover ricorrere alla programmazione
di basso livello in C o C++, ed @`e spesso pi@`u facile fare certi tipi di
manipolazioni di stringhe e argomenti usando la shell, piuttosto che
@command{awk}.
Infine, @command{igawk} dimostra che non @`e sempre necessario aggiungere nuove
funzionalit@`a a un programma; queste possono spesso essere aggiunte in
cima.@footnote{@command{gawk}
@`e in grado di elaborare istruzioni @code{@@include} al suo stesso interno, per
permettere l'uso di programmi @command{awk} come @dfn{script} Web CGI.}
@node Programma anagram
@subsection Trovare anagrammi da una lista di parole
@cindex anagrammi @subentry trovare
Un'interessante sfida per il programmatore @`e quella di cercare @dfn{anagrammi} in una
lista di parole (come
@file{/usr/share/dict/italian} presente in molti sistemi GNU/Linux).
Una parola @`e un anagramma di un'altra se entrambe le parole contengono
le stesse lettere
(p.es., ``branzino'' e ``bronzina'').
La Colonna 2, Problema C, della seconda edizione del libro di Jon Bentley
@cite{Programming Pearls}, presenta un algoritmo elegante.
L'idea @`e di assegnare a parole che sono anagrammi l'una dell'altra una
firma comune, e poi di ordinare tutte le parole in base alla loro
firma e di stamparle.
Il Dr.@: Bentley fa notare che prendere tutte le lettere di ogni parola ed
elencarle in ordine alfabetico produce queste firme comuni.
Il programma seguente usa vettori di vettori per riunire
parole con la stessa firma, e l'ordinamento di vettori per stampare le
parole trovate in ordine alfabetico:
@cindex @code{anagram.awk} (programma)
@cindex programma @subentry @code{anagram.awk}
@example
@c file eg/prog/anagram.awk
# anagram.awk --- Un'implementazione dell'algoritmo per trovare anagrammi
# dalla seconda edizione
# del libro di Jon Bentley "Programming Pearls".
# Addison Wesley, 2000, ISBN 0-201-65788-0.
# Colonna 2, Problema C, sezione 2.8, pp 18-20.
@c endfile
@ignore
@c file eg/prog/anagram.awk
#
# Questo programma richiede gawk 4.0 o una versione successiva.
# Funzionalit@`a di gawk richieste:
# - veri vettori multidimensionali
# - split() con separatore "" per separare ogni singolo carattere
# - le funzioni asort() e asorti()
#
# Vedere https://savannah.gnu.org/projects/gawk.
#
# Arnold Robbins
# arnold@@skeeve.com
# Public Domain
# January, 2011
@c endfile
@end ignore
@c file eg/prog/anagram.awk
/'s$/ @{ next @} # Salta i genitivi sassoni
@c endfile
@end example
Il programma inizia con un'intestazione, e poi una regola per saltare
i genitivi sassoni eventualmente contenuti nel file che contiene la lista di
parole. La regola
successiva costruisce la struttura dei dati. Il primo indice del vettore
@`e rappresentato dalla firma; il secondo @`e la parola stessa:
@example
@c file eg/prog/anagram.awk
@{
chiave = da_parola_a_chiave($1) # costruisce la firma
data[chiave][$1] = $1 # Immagazzina parola con questa firma
@}
@c endfile
@end example
La funzione @code{da_parola_a_chiave()} crea la firma.
Divide la parola in lettere singole, mette in ordine alfabetico le lettere,
e poi le rimette ancora insieme:
@example
@c file eg/prog/anagram.awk
# da_parola_a_chiave --- divide parole in lettere, ordina e riunisce
function da_parola_a_chiave(parola, a, i, n, risultato)
@{
n = split(parola, a, "")
asort(a)
for (i = 1; i <= n; i++)
risultato = risultato a[i]
return risultato
@}
@c endfile
@end example
Infine, la regola @code{END} percorre tutto il vettore e stampa
le liste degli anagrammi. L'output @`e poi passato al
comando di sistema @command{sort} perch@'e altrimenti gli
anagrammi sarebbero elencati in ordine arbitrario:
@example
@c file eg/prog/anagram.awk
END @{
sort = "sort"
for (chiave in data) @{
# ordina parole con la stessa chiave
n_parole = asorti(data[chiave], parole)
if (n_parole == 1)
continue
# e stampa. Problema minore: uno spazio extra a fine di ogni riga
for (j = 1; j <= n_parole; j++)
printf("%s ", parole[j]) | sort
print "" | sort
@}
close(sort)
@}
@c endfile
@end example
Ecco una piccola parte dell'output quando il programma @`e eseguito:
@example
$ @kbd{gawk -f anagram.awk /usr/share/dict/italian | grep '^b'}
@dots{}
baraste bastare serbata
barasti basarti
baratro tabarro
barattoli ribaltato tribolata
barbieri birberia
barche brache
barcollerei corbelleria
bare erba
bareremmo brameremo
barili librai
@dots{}
@end example
@node Programma signature
@subsection E ora per qualcosa di completamente differente
@cindex @code{signature} (programma)
@cindex programma @subentry @code{signature}
@cindex Brini, Davide
Il programma seguente @`e stato scritto da Davide Brini
@c (@email{dave_br@@gmx.com})
ed @`e pubblicato sul @uref{http://backreference.org/2011/02/03/obfuscated-awk/,
suo sito web}.
Serve come sua firma nel gruppo Usenet @code{comp.lang.awk}.
Questi sono i termini da lui stabiliti per il copyright:
@quotation
Copyright @copyright{} 2008 Davide Brini
Copying and distribution of the code published in this page, with or without
modification, are permitted in any medium without royalty provided the copyright
notice and this notice are preserved.
@end quotation
Ecco il programma:
@example
@group
awk 'BEGIN@{O="~"~"~";o="=="=="==";o+=+o;x=O""O;while(X++<=x+o+o)c=c"%c";
printf c,(x-O)*(x-O),x*(x-o)-o,x*(x-O)+x-O-o,+x*(x-O)-x+o,X*(o*o+O)+x-O,
X*(X-x)-o*o,(x+X)*o*o+o,x*(X-x)-O-O,x-O+(O+o+X+x)*(o+O),X*X-X*(x-O)-x+O,
O+X*(o*(o+O)+O),+x+O+X*o,x*(x-o),(o+X+x)*o*o-(x-O-O),O+(X-x)*(X+O),x-O@}'
@end group
@end example
@c genera l'email del tizio:
@c dave_br@gmx.com
@cindex Johansen, Chris
Viene lasciato al lettore il piacere di stabilire cosa fa il programma.
(Se si @`e sull'orlo della disperazione nel tentativo di comprensione, si veda
la spiegazione di Chris Johansen,
che @`e contenuta nel file sorgente Texinfo di questo @value{DOCUMENT}.)
@ignore
To: "Arnold Robbins"
Date: Sat, 20 Aug 2011 13:50:46 -0400
Subject: The GNU Awk User's Guide, Section 13.3.11
From: "Chris Johansen"
Message-ID:
Arnold, tu non mi conosci, ma c'@`e un sottile legame tra noi. Mia moglie @`e
Barbara A. Field, FAIA, GIT '65 (B. Arch.).
Ho un paio di copie cartacee di "Effective Awk Programming" da
anni, ed ora sto leggendo di nuovo la versione Kindle di "The GNU Awk User's
Guide". Quando sono arrivato alla sezione 13.3.11, ho riformattato e
brevemente commentato lo @dfn{script} di firma di Davide Brin per comprenderne il funzionamento.
Mi pare che questo possa avere un valore pedagogico come esempio
(sia pure imperfetto) del significato di spazi bianchi e commenti, e un
punto di partenza per una tale discussione. Sicuramente ha aiutato _me_ a
capire quel che succede. Se vuoi
usarlo, com'@`e o modificato, sentiti libero di farlo (a condizione di
rispettare i vincoli posti da Davide, naturalmente, che credo siano stati
da me rispettati).
Se dovessi includere questa spiegazione in una futura edizione, la inserirei
a una certa distanza dalla sezione 13.3.11, diciamo come una nota o come
un'appendice, in modo da non rivelare immediatamente la soluzione dell'enigma.
Cordiali saluti,
--
Chris Johansen {johansen at main dot nc dot us}
. . . collapsing the probability wave function, sending ripples of
certainty through the space-time continuum.
#! /usr/bin/gawk -f
# Da "13.3.11 E ora per qualcosa di completamente differente"
# https://www.gnu.org/software/gawk/manual/html_node/Signature-Program.html#Signature-Program
# Copyright @copyright{} 2008 Davide Brini
# Copying and distribution of the code published in this page, with
# or without modification, are permitted in any medium without
# royalty provided the copyright notice and this notice are preserved.
BEGIN {
O = "~" ~ "~"; # 1
o = "==" == "=="; # 1
o += +o; # 2
x = O "" O; # 11
while ( X++ <= x + o + o ) c = c "%c";
# O vale 1
# o vale 2
# x vale 11
# X vale 17
# c vale "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"
printf c,
( x - O )*( x - O), # 100 d
x*( x - o ) - o, # 97 a
x*( x - O ) + x - O - o, # 118 v
+x*( x - O ) - x + o, # 101 e
X*( o*o + O ) + x - O, # 95 _
X*( X - x ) - o*o, # 98 b
( x + X )*o*o + o, # 114 r
x*( X - x ) - O - O, # 64 @
x - O + ( O + o + X + x )*( o + O ), # 103 g
X*X - X*( x - O ) - x + O, # 109 m
O + X*( o*( o + O ) + O ), # 120 x
+x + O + X*o, # 46 .
x*( x - o), # 99 c
( o + X + x )*o*o - ( x - O - O ), # 111 0
O + ( X - x )*( X + O ), # 109 m
x - O # 10 \n
}
@end ignore
@node Sommario dei programmi
@section Sommario
@itemize @value{BULLET}
@item
I programmi illustrati in questo @value{CHAPTER}
ripropongo la tesi secondo cui leggere programmi @`e una maniera eccellente
per imparare a fare della buona programmazione.
@item
Usare @samp{#!} per rendere i programmi @command{awk} direttamente eseguibili
ne rende pi@`u semplice l'uso. In alternativa, si pu@`o invocare un
programma usando @samp{awk -f @dots{}}.
@item
Reimplementare programmi POSIX standard in @command{awk} @`e un esercizio
piacevole; il potere espressivo di @command{awk} consente di scrivere tali
programmi usando relativamente poche righe di codice, nonostante i programmi
risultanti siano funzionalmente completi e utilizzabili.
@item
Una delle debolezze della versione standard di @command{awk} riguarda il
lavorare con singoli caratteri. La possibilit@`a di usare @code{split()} con
la stringa nulla come separatore pu@`o semplificare considerevolmente tale
compito.
@item
Gli esempi proposti dimostrano l'utilit@`a delle funzioni di libreria introdotte
@iftex
nel
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzioni di libreria}
per un numero (sia pur piccolo) di programmi reali.
@item
Oltre a reinventare la ruota POSIX, altri programmi risolvono una serie di
problemi interessanti, come trovare delle parole duplicate in un testo,
stampare etichette per lettere, e trovare anagrammi.
@end itemize
@c EXCLUDE START
@node Esercizi sui programmi
@section Esercizi
@enumerate
@item
Riscrivere @file{cut.awk} (@pxref{Programma cut})
usando @code{split()} con @code{""} come separatore.
@item
@iftex
Nella
@end iftex
@ifnottex
In
@end ifnottex
@ref{Programma egrep}, @`e detto che @samp{egrep -i} potrebbe essere
simulato in versioni di @command{awk} che non prevedono @code{IGNORECASE}
usando @code{tolower()} sulla riga e nei criteri di ricerca. In una nota a
pi@`e di pagina @`e anche detto che questa soluzione ha un problema: in output
viene scritta la riga tradotta (a lettere minuscole), e non quella originale.
Risolvere questo problema.
@c Exercise: Fix this, w/array and new line as key to original line
@item
La versione POSIX di @command{id} accetta opzioni che controllano quali
informazioni stampare. Modificare la versione @command{awk}
(@pxref{Programma id}) per accettare gli stessi argomenti e funzionare allo
stesso modo.
@item
Il programma @code{split.awk} (@pxref{Programma split}) presuppone che le
lettere siano contigue nella codifica dei caratteri,
il che non @`e vero per sistemi che usano la codifica EBCDIC.
Risolvere questo problema.
(Suggerimento: Considerare un modo diverso di analizzare l'alfabeto,
senza appoggiarsi sulle funzioni @code{ord()} e @code{chr()}.)
@item
@cindex Kernighan, Brian @subentry citazioni di
Nel programma @file{uniq.awk} (@pxref{Programma uniq}, la
logica per scegliere quali righe stampare rappresenta una
@dfn{macchina a stati},
ossia ``un dispositivo che pu@`o essere in uno di un insieme di stati
stabili, a seconda dello stato in cui si trovava in precedenza, e del
valore corrente dei suoi
input.''@footnote{Questo @`e la definizione trovata in
@uref{https://www.lexico.com/en/definition/state_machine}.}
Brian Kernighan suggerisce che
``un approccio alternativo alle macchine a stati @`e di leggere tutto l'input
e metterlo in un vettore, e po usare l'indicizzazione. @`E quasi sempre pi@`u
semplice da programmare, e per la maggior parte degli input in cui si pu@`o
usare, altrettanto veloce in esecuzione.'' Riscrivere la logica del
programma seguendo questa indicazione.
@item
Perch@'e il programma @file{wc.awk} (@pxref{Programma wc}) non pu@`o
limitarsi a usare il valore di @code{FNR} nella funzione @code{endfile()}?
Suggerimento: Esaminare il codice
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzione filetrans}.
@ignore
@command{wc} can't just use the value of @code{FNR} in
@code{endfile()}. If you examine the code in @ref{Filetrans Function},
you will see that @code{FNR} has already been reset by the time
@code{endfile()} is called.
@end ignore
@item
La manipolazione di singoli caratteri nel programma @command{translate}
(@pxref{Programma translate}) @`e farraginosa usando le funzione standard
@command{awk}. Poich@'e @command{gawk} pu@`o dividere stringhe in caratteri
singoli usando come separatore @code{""}, come si potrebbe usare questa
funzionalit@`a per semplificare il programma?
@item
Il programma @file{extract.awk} (@pxref{Programma extract}) @`e stato
scritto prima che @command{gawk} avesse a disposizione la funzione
@code{gensub()}. Usarla per semplificare il codice.
@item
Si confronti la velocit@`a di esecuzione del programma @file{awksed.awk}
(@pxref{Programma sed semplice}) con il pi@`u diretto:
@example
BEGIN @{
stringa = ARGV[1]
rimpiazzo = ARGV[2]
ARGV[1] = ARGV[2] = ""
@}
@{ gsub(stringa, rimpiazzo); print @}
@end example
@item
Quali sono vantaggi e svantaggi di @file{awksed.awk} rispetto al vero
programma di utilit@`a @command{sed}?
@ignore
Advantage: egrep regexps
speed (?)
Disadvantage: no & in replacement text
Others?
@end ignore
@item
@iftex
Nella
@end iftex
@ifnottex
In
@end ifnottex
@ref{Programma igawk}, si @`e detto che non tentando di salvare la riga
letta con @code{getline} nella funzione @code{percorso()}, mentre si
controlla l'accessibilit@`a del file da usare nel programma principale,
semplifica notevolmente le cose. Quale problema @`e peraltro generato cos@`{@dotless{i}}
facendo?
@c answer, reading from "-" o /dev/stdin
@cindex percorso di ricerca @subentry per file sorgente
@cindex ricerca @subentry percorso di, per file sorgente
@cindex file @subentry sorgente @subentry percorso di ricerca per
@cindex directory @subentry ricerca
@item
Come ulteriore esempio dell'idea che non sempre @`e necessario aggiungere
nuove funzionalit@`a a un programma, si consideri l'idea di avere due file in
una directory presente nel percorso di ricerca:
@table @file
@item default.awk
Questo file contiene un insieme di funzioni di libreria di default, come
@code{getopt()} e @code{assert()}.
@item sito.awk
Questo file contiene funzioni di libreria che sono specifiche di
un sito o di un'installazione; cio@`e, funzioni sviluppate localmente.
Mantenere due file separati consente a @file{default.awk} di essere
modificato in seguito a nuove versioni di @command{gawk}, senza che
l'amministratore di sistema debba ogni volta aggiornarlo aggiungendo le
funzioni locali.
@end table
Un utente
@c Karl Berry, karl@ileaf.com, 10/95
ha suggerito che @command{gawk} venga modificato per leggere automaticamente
questi file alla partenza. Piuttosto, sarebbe molto semplice
modificare @command{igawk} per farlo. Poich@'e @command{igawk} @`e capace di
elaborare direttive @code{@@include}
nidificate, @file{default.awk} potrebbe contenere semplicemente la lista di
direttive @code{@@include} con le funzioni di libreria desiderate.
Fare questa modifica.
@item
Modificare @file{anagram.awk} (@pxref{Programma anagram}), per evitare di
usare il programma di utilit@`a esterno @command{sort}.
@end enumerate
@c EXCLUDE END
@ifnotinfo
@part @value{PART3}Andare oltre @command{awk} con @command{gawk}
@end ifnotinfo
@ifdocbook
La Parte III riguarda funzionalit@`a proprie di @command{gawk}.
Contiene i seguenti capitoli:
@itemize @value{BULLET}
@item
@ref{Spazi di nomi}
@item
@ref{Funzionalit@`a avanzate}
@item
@ref{Internazionalizzazione}
@item
@ref{Debugger}
@item
@ref{Calcolo con precisione arbitraria}
@item
@ref{Estensioni dinamiche}
@end itemize
@end ifdocbook
@node Funzionalit@`a avanzate
@chapter Funzionalit@`a avanzate di @command{gawk}
@cindex @command{gawk} @subentry funzionalit@`a avanzate
@cindex avanzate @subentry funzionalit@`a @subentry di @command{gawk}
@ignore
Contributed by: Peter Langston
Found in Steve English's "signature" line:
"Write documentation as if whoever reads it is a violent psychopath
who knows where you live."
@end ignore
@cindex Langston, Peter
@cindex English, Steve
@quotation
@i{Scrivete la documentazione supponendo che chiunque la legger@`a sia uno psicopatico
violento, che conosce il vostro indirizzo di casa.}
@author Steve English, citato da Peter Langston
@end quotation
Questo @value{CHAPTER} tratta delle funzionalit@`a avanzate in @command{gawk}.
@`E un po' come un ``pacco sorpresa'' di argomenti che non sono collegati tra di
loro in altro modo.
Per prima cosa, vediamo un'opzione da riga di comando che consente a
@command{gawk} di riconoscere i numeri non-decimali nei dati in input, e non
soltanto nei programmi @command{awk}.
Poi vengono illustrate delle funzionalit@`a speciali di @command{gawk} per
l'ordinamento di vettori. Quindi viene trattato dettagliatamente l'I/O
bidirezionale, di cui si @`e fatto cenno in precedenti parti di questo
@value{DOCUMENT}, assieme ai fondamenti sulle reti TCP/IP.
Infine, vediamo come @command{gawk}
pu@`o tracciare il @dfn{profilo} di un programma @command{awk}, cos@`{@dotless{i}} che si
possa ritoccarlo per migliorarne le prestazioni.
@c FULLXREF ON
Altre funzionalit@`a avanzate vengono trattate separatamente dedicando un
@value{CHAPTER} per ciascuna di esse:
@itemize @value{BULLET}
@item
@iftex
Il
@end iftex
@ref{Internazionalizzazione}, parla di come internazionalizzare
i propri programmi @command{awk}, in modo che parlino pi@`u lingue
nazionali.
@item
@iftex
Il
@end iftex
@ref{Debugger}, descrive il debugger dalla riga di comando disponibile
all'interno di
@command{gawk} per individuare errori nei programmi @command{awk}.
@item
@iftex
Il
@end iftex
@ref{Calcolo con precisione arbitraria}, illustra come si pu@`o usare
@command{gawk} per eseguire calcoli con precisione arbitraria.
@item
@iftex
Il
@end iftex
@ref{Estensioni dinamiche},
tratta della capacit@`a di aggiungere dinamicamente nuove funzioni predefinite a
@command{gawk}.
@end itemize
@c FULLXREF OFF
@menu
* Dati non decimali:: Consentire dati di input non decimali.
* Ordinamento di vettori:: Modi per controllare la visita di un vettore
e il suo ordinamento.
* I/O bidirezionale:: Comunicazione bidirezionale con un altro
processo.
* Reti TCP/IP:: Usare @command{gawk} per programmazione di rete.
* Profilare:: Profilare i propri programmi @command{awk}.
* Sommario funzionalit@`a avanzate:: Sommario delle funzionalit@`a avanzate.
@end menu
@node Dati non decimali
@section Consentire dati di input non decimali
@cindex opzione @subentry @option{--non-decimal-data}
@cindex @option{--non-decimal-data} (opzione)
@c @cindex funzionalit@`a @subentry avanzate, dati di input non decimali
@cindex input @subentry dati non decimali
@cindex costanti @subentry non decimali
Se si esegue @command{gawk} con l'opzione @option{--non-decimal-data},
si possono avere valori in base diversa da dieci nei dati di input:
@example
$ @kbd{echo 0123 123 0x123 |}
> @kbd{gawk --non-decimal-data '@{ printf "%d, %d, %d\n", $1, $2, $3 @}'}
@print{} 83, 123, 291
@end example
Affinch@'e questa funzionalit@`a sia disponibile, i programmi devono essere
scritti in modo che @command{gawk} tratti i dati come valori numerici:
@example
$ @kbd{echo 0123 123 0x123 | gawk '@{ print $1, $2, $3 @}'}
@print{} 0123 123 0x123
@end example
@noindent
L'istruzione @code{print} tratta le sue espressioni come se fossero stringhe.
Sebbene i campi possano comportarsi come numeri, quando necessario,
essi rimangono sempre stringhe, per cui @code{print} non cerca di elaborarli
come se fossero numeri. Si deve aggiungere zero a un campo affich@'e venga
considerato come un numero. Per esempio:
@example
$ @kbd{echo 0123 123 0x123 | gawk --non-decimal-data '}
> @kbd{@{ print $1, $2, $3}
> @kbd{print $1 + 0, $2 + 0, $3 + 0 @}'}
@print{} 0123 123 0x123
@print{} 83 123 291
@end example
Poich@'e capita comunemente di avere dati di tipo decimale con degli zeri iniziali,
e poich@'e l'uso di questa funzionalit@`a pu@`o portare a risultati inattesi, il
comportamento di default @`e quello lasciarla disabilitata. Se si vuole, la si
deve richiedere esplicitamente.
@cindex programmazione @subentry convenzioni di @subentry opzione @code{--non-decimal-data}
@cindex @option{--non-decimal-data} (opzione) @subentry funzione @code{strtonum()} e
@cindex opzione @subentry @option{--non-decimal-data} @subentry funzione @code{strtonum()} e
@cindex @code{strtonum()} (funzione @command{gawk}) @subentry opzione @code{--non-decimal-data} e
@quotation ATTENZIONE
@emph{L'uso di questa opzione non @`e consigliata.}
Pu@`o provocare errori molto seri eseguendo vecchi programmi.
Al suo posto @`e meglio usare la funzione @code{strtonum()} per convertire i dati
(@pxref{Funzioni per stringhe}).
Questo rende i programmi pi@`u facili da scrivere e pi@`u facili da leggere, e
porta a risultati meno inattesi.
Quest'opzione potrebbe sparire dalle versioni future di @command{gawk}.
@end quotation
@node Ordinamento di vettori
@section Controllare la visita di un vettore e il suo ordinamento
@command{gawk} permette di controllare l'ordine con cui un ciclo
@samp{for (@var{indice} in @var{vettore})}
attraversa un vettore.
Inoltre, due funzioni predefinite, @code{asort()} e @code{asorti()},
permettono di mettere in ordine i vettori sulla base, rispettivamente, dei
valori e degli indici del vettore. Queste due funzioni danno anche il
controllo sui criteri in base ai quali riordinare gli elementi del vettore.
@menu
* Controllare visita vettori:: Come usare PROCINFO["sorted_in"].
* Funzioni di ordinamento di vettori:: Come usare @code{asort()} e @code{asorti()}.
@end menu
@node Controllare visita vettori
@subsection Controllare visita vettori
Per default, l'ordine secondo il quale un ciclo @samp{for (@var{indice} in
@var{vettore})} scorre un vettore non @`e definito; in genere si basa
sull'implementazione interna dei vettori all'interno di @command{awk}.
Spesso, tuttavia, si vorrebbe poter eseguire un ciclo sugli elementi in un
determinato ordine scelto dall'utente programmatore. Con @command{gawk}
si pu@`o fare.
@iftex
La
@end iftex
@ref{Controllare visita} parla di come si possono assegnare valori speciali
predefiniti a @code{PROCINFO["sorted_in"]} per controllare l'ordine secondo il
quale @command{gawk} attraversa un vettore
durante un ciclo @code{for}.
Inoltre, il valore di @code{PROCINFO["sorted_in"]} pu@`o essere un nome di
funzione.@footnote{Questo @`e il motivo per cui gli ordinamenti predefiniti
iniziano con il carattere @samp{@@}, che non pu@`o essere usato in un
identificativo.}
Questo consente di scorrere un vettore sulla base di un qualsiasi criterio
personalizzato. Gli elementi del vettore vengono ordinati in accordo col valore
ritornato da questa funzione. La funzione che fa il confronto dovrebbe essere
definita con almeno quattro argomenti:
@example
function confronta(i1, v1, i2, v2)
@{
@var{confronta gli elementi 1 e 2 in qualche modo}
@var{return < 0; 0; o > 0}
@}
@end example
Qui, @code{i1} e @code{i2} sono gli indici, e @code{v1} e @code{v2}
sono i corrispondenti valori dei due elementi che si stanno confrontando.
@code{v1} oppure @code{v2}, o entrambi, possono essere vettori se il vettore
che si sta visitando contiene sottovettori come valori.
(@xref{Vettori di vettori} per maggiori informazioni sui sottovettori.)
I tre possibili codici di ritorno sono interpretati nel seguente modo:
@table @code
@item confronta(i1, v1, i2, v2) < 0
L'indice @code{i1} viene prima dell'indice @code{i2} durante l'avanzamento
del ciclo.
@item confronta(i1, v1, i2, v2) == 0
Gli indici @code{i1} e @code{i2}
sono equivalenti, ma l'ordine tra loro non @`e definito.
@item confronta(i1, v1, i2, v2) > 0
L'indice @code{i1} viene dopo l'indice @code{i2} durante l'avanzamento del
ciclo.
@end table
La prima funzione di confronto pu@`o essere usata per scorrere un vettore
secondo l'ordine numerico degli indici:
@example
@group
function cfr_ind_num(i1, v1, i2, v2)
@{
# confronto di indici numerici, ordine crescente
return (i1 - i2)
@}
@end group
@end example
La seconda funzione scorre un vettore secondo l'ordine delle stringhe
dei valori degli elementi piuttosto che secondo gli indici:
@example
function cfr_val_str(i1, v1, i2, v2)
@{
# confronto di valori di stringa, ordine crescente
v1 = v1 ""
v2 = v2 ""
if (v1 < v2)
return -1
return (v1 != v2)
@}
@end example
La terza funzione di confronto restituisce dapprima tutti i numeri, e dopo
questi le stringhe numeriche senza spazi iniziali o finali, durante
l'avanzamento del ciclo:
@example
function cfr_val_num_str(i1, v1, i2, v2, n1, n2)
@{
# confronto mettendo i numeri prima dei valori di stringa,
# ordine crescente
n1 = v1 + 0
n2 = v2 + 0
if (n1 == v1)
return (n2 == v2) ? (n1 - n2) : -1
else if (n2 == v2)
return 1
return (v1 < v2) ? -1 : (v1 != v2)
@}
@end example
Qui vediamo un programma principale che mostra come @command{gawk}
si comporta usando ciascuna delle funzioni precedenti:
@example
BEGIN @{
data["uno"] = 10
data["due"] = 20
data[10] = "uno"
data[100] = 100
data[20] = "due"
f[1] = "cfr_ind_num"
f[2] = "cfr_val_str"
f[3] = "cfr_val_num_str"
for (i = 1; i <= 3; i++) @{
printf("Funzione di ordinamento: %s\n", f[i])
PROCINFO["sorted_in"] = f[i]
for (j in data)
printf("\tdata[%s] = %s\n", j, data[j])
print ""
@}
@}
@end example
I risultati dell'esecuzione del programma sono questi:
@example
$ @kbd{gawk -f compdemo.awk}
@print{} Funzione di ordinamento: cfr_ind_num @ii{Ordinamento per indice numerico}
@print{} data[uno] = 10
@print{} data[due] = 20 @ii{Entrambe le stringhe sono numericamente zero}
@print{} data[10] = uno
@print{} data[20] = due
@print{} data[100] = 100
@print{}
@print{} Funzione di ordinamento: cfr_val_str @ii{Ordinamento per valore degli}
@print{} @ii{elementi come stringhe}
@print{} data[uno] = 10
@print{} data[100] = 100 @ii{La stringa 100 @`e minore della stringa 20}
@print{} data[due] = 20
@print{} data[20] = due
@print{} data[10] = uno
@print{}
@print{} Funzione di ordinamento: cfr_val_num_str @ii{Ordinamento con tutti i}
@print{} @ii{valori numerici prima di tutte le stringhe}
@print{} data[uno] = 10
@print{} data[due] = 20
@print{} data[100] = 100
@print{} data[20] = due
@print{} data[10] = uno
@end example
Si provi a ordinare gli elementi di un file delle password del sistema GNU/Linux
in base al nome d'accesso dell'utente. Il seguente programma ordina i record
secondo una specifica posizione del campo e pu@`o essere usato per questo scopo:
@example
# passwd-sort.awk --- semplice programma per ordinare in base alla
# posizione del campo
# la posizione del campo @`e specificata dalla variabile globale POS
function per_campo(i1, v1, i2, v2)
@{
# confronto per valore, come stringa, e in ordine crescente
return v1[POS] < v2[POS] ? -1 : (v1[POS] != v2[POS])
@}
@{
for (i = 1; i <= NF; i++)
a[NR][i] = $i
@}
@group
END @{
PROCINFO["sorted_in"] = "per_campo"
@end group
if (POS < 1 || POS > NF)
POS = 1
for (i in a) @{
for (j = 1; j <= NF; j++)
printf("%s%c", a[i][j], j < NF ? ":" : "")
print ""
@}
@}
@end example
Il primo campo di ogni elemento del file delle password @`e il nome d'accesso
dell'utente, e i campi sono separati tra loro da due punti (@code{:}).
Ogni record definisce un sottovettore,
con ogni campo come elemento nel sottovettore.
L'esecuzione del programma produce
il seguente output:
@example
$ @kbd{gawk -v POS=1 -F: -f sort.awk /etc/passwd}
@print{} adm:x:3:4:adm:/var/adm:/sbin/nologin
@print{} apache:x:48:48:Apache:/var/www:/sbin/nologin
@print{} avahi:x:70:70:Avahi daemon:/:/sbin/nologin
@dots{}
@end example
Il confronto normalmente dovrebbe restituire sempre lo stesso valore quando
vien dato come argomento un preciso paio di elementi del vettore. Se viene
restituito un risultato non coerente, l'ordine @`e indefinito. Questo
comportamento pu@`o essere sfruttato per introdurre un ordinamento casuale in
dati apparentemente ordinati:
@example
function ordina_a_caso(i1, v1, i2, v2)
@{
# ordine casuale (attenzione: potrebbe non finire mai!)
return (2 - 4 * rand())
@}
@end example
Come gi@`a accennato, l'ordine degli indici @`e arbitrario se due elementi
risultano uguali. Normalmente questo non @`e un problema, ma lasciare che
elementi di uguale valore compaiano in ordine arbitrario pu@`o essere un
problema, specialmente quando si confrontano valori di elementi di un elenco.
L'ordine parziale di elementi uguali pu@`o cambiare quando il vettore viene
visitato di nuovo, se nel vettore vengono aggiunti o rimossi elementi. Un modo
per superare l'ostacolo quando si confrontano elementi con valori uguali @`e
quello di includere gli indici nelle regole di confronto. Si noti che questo
potrebbe rendere meno efficiente l'attraversamento del ciclo, per cui si
consiglia di farlo solo se necessario. Le seguenti funzioni di confronto
impongono un ordine deterministico, e si basano sul fatto che gli indici
(di stringa) di due elementi non sono mai uguali:
@example
function per_numero(i1, v1, i2, v2)
@{
# confronto di valori numerici (e indici), ordine decrescente
return (v1 != v2) ? (v2 - v1) : (i2 - i1)
@}
@group
function per_stringa(i1, v1, i2, v2)
@{
# confronto di valori di stringa (e indici), ordine decrescente
v1 = v1 i1
v2 = v2 i2
return (v1 > v2) ? -1 : (v1 != v2)
@}
@end group
@end example
@c Avoid using the term ``stable'' when describing the unpredictable behavior
@c if two items compare equal. Usually, the goal of a "stable algorithm"
@c is to maintain the original order of the items, which is a meaningless
@c concept for a list constructed from a hash.
Una funzione di confronto personalizzata spesso pu@`o semplificare
l'attraversamento del
ciclo ordinato, e il solo limite @`e il cielo, quando si va a progettare
una funzione di questo tipo.
Quando i confronti tra stringhe son fatti durante un'operazione di ordinamento,
per valori di elementi che, uno o entrambi, non sono numeri, o per
indici di elementi gestiti come stringhe, il valore di @code{IGNORECASE}
(@pxref{Variabili predefinite}) controlla se
i confronti trattano corrispondenti lettere maiuscole e minuscole
come equivalenti o come distinte.
Un'altra cosa da tenere a mente @`e che nel caso di sottovettori, i valori degli
elementi possono essere a loro volta dei vettori; una funzione di confronto in
produzione dovrebbe usare la funzione @code{isarray()}
(@pxref{Funzioni per i tipi})
per controllare ci@`o, e scegliere un ordinamento preciso per i sottovettori.
@cindex modalit@`a POSIX
Tutti gli ordinamenti basati su @code{PROCINFO["sorted_in"]}
sono disabilitati in modalit@`a POSIX,
perch@'e il vettore @code{PROCINFO} in questo caso non @`e speciale.
Come nota a margine, si @`e visto che ordinare gli indici del vettore prima di
scorrere il vettore porta a un incremento variabile dal 15% al 20% del tempo di
esecuzione dei programmi @command{awk}. Per questo motivo l'attraversamento
ordinato di vettori non @`e il default.
@c The @command{gawk}
@c maintainers believe that only the people who wish to use a
@c feature should have to pay for it.
@node Funzioni di ordinamento di vettori
@subsection Ordinare valori e indici di un vettore con @command{gawk}
@cindex vettori @subentry ordinamento @subentry @code{asort()} (funzione @command{gawk})
@cindex vettori @subentry ordinamento @subentry @code{asorti()} (funzione @command{gawk})
@cindexgawkfunc{asort}
@cindex @code{asort()} (funzione @command{gawk}) @subentry ordinamento di vettori
@cindex funzione @subentry @code{asort()} (@command{gawk}) @subentry ordinamento di vettori
@cindex @code{asort()} (funzione @command{gawk}) @subentry effetti collaterali
@cindex funzione @subentry @code{asort()} (@command{gawk}) @subentry effetti collaterali
@cindexgawkfunc{asorti}
@cindex @code{asorti()} (funzione @command{gawk}) @subentry ordinamento di vettori
@cindex funzione @subentry @code{asorti()} (@command{gawk}) @subentry ordinamento di vettori
@cindex @code{asorti()} (funzione @command{gawk}) @subentry effetti collaterali
@cindex funzione @subentry @code{asorti()} (@command{gawk}) @subentry effetti collaterali
@cindex @code{sort()} (funzione) @subentry ordinamento di vettori
@cindex funzione @subentry @code{sort()} @subentry ordinamento di vettori
Nella maggior parte delle implementazioni di @command{awk}, ordinare un vettore
richiede una funzione @code{sort()}. Questo pu@`o essere istruttivo per provare
diversi algoritmi di ordinamento, ma normalmente non @`e questo lo scopo del
programma. In @command{gawk} ci sono le funzioni predefinite @code{asort()} e
@code{asorti()} (@pxref{Funzioni per stringhe}) per i vettori ordinati.
Per esempio:
@example
@var{riempire il vettore} dati
n = asort(dati)
for (i = 1; i <= n; i++)
@var{fare qualcosa con} dati[i]
@end example
Dopo la chiamata ad @code{asort()}, il vettore @code{dati} @`e indicizzato da 1
a @var{n}, il numero totale di elementi in @code{dati}.
(Questo conteggio @`e il codice di ritorno di @code{asort()}).
@code{dati[1]} @value{LEQ} @code{dati[2]} @value{LEQ} @code{dati[3]}, e cos@`{@dotless{i}}
via. Il confronto di default @`e basato sul tipo di elementi
(@pxref{Tipi di variabile e confronti}).
Tutti i valori numerici vengono prima dei valori di stringa,
che a loro volta vengono prima di tutti i sottovettori.
@cindex effetti collaterali @subentry funzione @subentry @code{asort()}
@cindex funzione @subentry @code{asort()} @subentry effetti collaterali
@cindex effetti collaterali @subentry funzione @subentry @code{asorti()}
@cindex funzione @subentry @code{asorti()} @subentry effetti collaterali
Un effetto collaterale rilevante nel chiamare @code{asort()} @`e che
@emph{gli indici originali del vettore vengono persi irreparabilmente}.
Poich@'e questo non sempre @`e opportuno, @code{asort()} accetta un
secondo argomento:
@example
@var{populate the array} orig
n = asort(orig, dest)
for (i = 1; i <= n; i++)
@var{fai qualcosaa con} dest[i]
@end example
In questo caso, @command{gawk} copia il vettore @code{orig} nel vettore
@code{dest} e ordina @code{dest}, distruggendo i suoi indici.
Tuttavia il vettore @code{orig} non viene modificato.
Spesso, ci@`o di cui si ha bisogno @`e di ordinare per i valori degli
@emph{indici} invece che per i valori degli elementi. Per far questo si usa la
funzione @code{asorti()}. L'interfaccia e il comportamento sono identici a
quelli di @code{asort()}, solo che per l'ordinamento vengono usati i valori
degli indici, che diventano i valori del vettore risultato:
@example
@{ orig[$0] = una_funz($0) @}
END @{
n = asorti(orig, dest)
for (i = 1; i <= n; i++) @{
@ii{Lavora direttamente con gli indici ordinati:}
@var{fa qualcosa con} dest[i]
@dots{}
@ii{Accede al vettore originale attraverso gli indici ordinati:}
@var{fa qualcosa con} orig[dest[i]]
@}
@}
@end example
Fin qui, tutto bene. Ora inizia la parte interessante. Sia @code{asort()}
che @code{asorti()} accettano un terzo argomento di stringa per controllare il
confronto di elementi del vettore. Quando abbiamo introdotto @code{asort()} e
@code{asorti()} nella @ref{Funzioni per stringhe}, abbiamo ignorato questo terzo
argomento; comunque, @`e giunto il momento di descrivere come questo argomento
influenza queste due funzioni.
Fondamentalmente, il terzo argomento specifica come dev'essere ordinato il
vettore. Ci sono due possibilit@`a. Come per @code{PROCINFO["sorted_in"]},
quest'argomento pu@`o essere uno degli argomenti predefiniti che @command{gawk}
fornisce (@pxref{Controllare visita}), o pu@`o essere il nome di una funzione
definita dall'utente (@pxref{Controllare visita vettori}).
Nell'ultimo caso, @emph{la funzione pu@`o confrontare gli elementi in qualunque
modo si voglia}, prendendo in considerazione solo gli indici, solo i valori,
o entrambi. Questo @`e estremamente potente.
Una volta che il vettore @`e ordinato, @code{asort()} prende i @emph{valori} nel
loro ordine finale e li usa per riempire il vettore risultato, mentre
@code{asorti()} prende gli @emph{indici} nel loro ordine finale e li usa per
riempire il vettore risultato.
@cindex conteggio riferimenti @subentry ordinamento vettori
@quotation NOTA
Copiare indici ed elementi non @`e dispendioso in termini di memoria.
Internamente, @command{gawk} mantiene un @dfn{conteggio dei riferimenti} ai
dati. Per esempio, dopo che @code{asort()} copia il primo vettore nel
secondo, in memoria c'@`e ancora una sola copia dei dati degli elementi
del vettore originale, ed entrambi i vettori accedono all'unica copia di
valori che esiste in memoria.
@end quotation
@c Document It And Call It A Feature. Sigh.
@cindex @command{gawk} @subentry variabile @subentry @code{IGNORECASE} in
@cindex vettori @subentry ordinamento @subentry variabile @code{IGNORECASE} e
@cindex @code{IGNORECASE} (variabile) @subentry funzioni di ordinamento dei vettori e
@cindex variabile @subentry @code{IGNORECASE} @subentry funzioni di ordinamento dei vettori e
Poich@'e @code{IGNORECASE} influenza i confronti tra stringhe, il valore di
@code{IGNORECASE} influisce anche sull'ordinamento sia con @code{asort()} che
con @code{asorti()}.
Si noti inoltre che l'ordinamento della localizzazione @emph{non} entra in
gioco; i confronti sono basati solamente sul valore dei
caratteri.@footnote{Ci@`o @`e vero perch@'e il confronto basato sulla localizzazione
avviene solo quando si @`e in modalit@`a POSIX-compatibile, e poich@'e @code{asort()}
e @code{asorti()} sono estensioni di @command{gawk}, esse non sono disponibili
in quel caso.}
L'esempio seguente mostra l'uso di una funzione di confronto usata con
@code{asort()}. La funzione di confronto, @code{confronta_in_minuscolo()},
trasforma gli elementi da confrontare in lettere minuscole, in modo da avere
confronti che non dipendono da maiuscolo/minuscolo.
@example
@group
# confronta_in_minuscolo --- confronta stringhe ignorando maiuscolo/minuscolo
function confronta_in_minuscolo(i1, v1, i2, v2, l, r)
@{
l = tolower(v1)
@end group
r = tolower(v2)
if (l < r)
return -1
else if (l == r)
return 0
else
return 1
@}
@end example
E questo programma pu@`o essere usato per provarla:
@example
# programma di test
BEGIN @{
Letters = "abcdefghijklmnopqrstuvwxyz" \
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
split(Letters, data, "")
asort(data, risultato, "confronta_in_minuscolo")
j = length(risultato) # numero elementi del vettore "risultato"
for (i = 1; i <= j; i++) @{
printf("%s", risultato[i])
if (i % (j/2) == 0)
# a met@`a, la stampa del vettore va a capo
printf("\n")
else
printf(" ")
@}
@}
@end example
Se si esegue il programma, si ottiene:
@example
$ @kbd{gawk -f confronta_in_minuscolo.awk}
@print{} A a B b c C D d e E F f g G H h i I J j k K l L M m
@print{} n N O o p P Q q r R S s t T u U V v w W X x y Y z Z
@end example
@node I/O bidirezionale
@section Comunicazioni bidirezionali con un altro processo
@c 8/2014. Neither Mike nor BWK saw this as relevant. Commenting it out.
@ignore
@cindex Brennan, Michael
@cindex programmers @subentry attractiveness of
@smallexample
@c Path: cssun.mathcs.emory.edu!gatech!newsxfer3.itd.umich.edu!news-peer.sprintlink.net!news-sea-19.sprintlink.net!news-in-west.sprintlink.net!news.sprintlink.net!Sprint!204.94.52.5!news.whidbey.com!brennan
From: brennan@@whidbey.com (Mike Brennan)
Newsgroups: comp.lang.awk
Subject: Re: Learn the SECRET to Attract Women Easily
Date: 4 Aug 1997 17:34:46 GMT
@c Organization: WhidbeyNet
@c Lines: 12
Message-ID: <5s53rm$eca@@news.whidbey.com>
@c References: <5s20dn$2e1@chronicle.concentric.net>
@c Reply-To: brennan@whidbey.com
@c NNTP-Posting-Host: asn202.whidbey.com
@c X-Newsreader: slrn (0.9.4.1 UNIX)
@c Xref: cssun.mathcs.emory.edu comp.lang.awk:5403
On 3 Aug 1997 13:17:43 GMT, Want More Dates???
wrote:
>Learn the SECRET to Attract Women Easily
>
>The SCENT(tm) Pheromone Sex Attractant For Men to Attract Women
The scent of awk programmers is a lot more attractive to women than
the scent of perl programmers.
--
Mike Brennan
@c brennan@@whidbey.com
@end smallexample
@end ignore
@cindex funzionalit@`a @subentry avanzate @subentry processi, comunicare con
@cindex processi @subentry comunicazioni bidirezionali con
Spesso @`e utile poter
inviare dati a un programma separato che
li elabori e in seguito leggere il risultato. Questo pu@`o essere sempre
fatto con file temporanei:
@example
# Scrivere i dati per l'elaborazione
filetemp = ("mieidati." PROCINFO["pid"])
while (@var{non dipendente dai dati})
print @var{dati} | ("sottoprogramma > " filetemp)
close("sottoprogramma > " filetemp)
# Legge il risultato, rimuove filetemp quando ha finito
while ((getline nuovidati < filetemp) > 0)
@var{elabora} nuovidati @var{secondo le esigenze}
close(filetemp)
system("rm " filetemp)
@end example
@noindent
Questo funziona, ma non @`e elegante. Tra le altre cose, richiede che il
programma venga eseguito in una directory che non pu@`o essere condivisa tra gli
utenti; per esempio, @file{/tmp} non pu@`o esserlo, poich@'e potrebbe accadere che
un altro utente stia usando un file temporaneo con lo stesso
nome.@footnote{Michael Brennan suggerisce l'uso di @command{rand()} per
generare @value{FNS} unici. Questo @`e un punto valido; tuttavia, i file
temporanei rimangono pi@`u difficili da usare delle @dfn{pipe} bidirezionali.} @c 8/2014
@cindex coprocessi
@cindex input/output @subentry bidirezionale
@cindex @code{|} (barra verticale) @subentry operatore @code{|&} (I/O)
@cindex barra verticale (@code{|}) @subentry operatore @code{|&} (I/O)
@cindex @command{csh} (comando di utilit@`a) @subentry operatore @code{|&}, confronto con
@cindex comando @subentry @command{csh} @subentry operatore @code{|&}, confronto con
Comunque, con @command{gawk}, @`e possibile aprire una @dfn{pipe}
@emph{bidirezionale}
verso un altro processo. Il secondo processo @`e chiamato @dfn{coprocesso},
poich@'e viene eseguito in parallelo con @command{gawk}. La connessione
bidirezionale viene creata usando l'operatore @samp{|&} (preso in prestito
dalla shell Korn, @command{ksh}):@footnote{Questo @`e molto diverso dallo stesso
operatore nella C shell e in Bash.}
@example
do @{
print @var{dati} |& "sottoprogramma"
"sottoprogramma" |& getline risultato
@} while (@var{ci sono ancora dati da elaborare})
close("sottoprogramma")
@end example
La prima volta che viene eseguita un'operazione I/O usando l'operatore
@samp{|&},
@command{gawk} crea una @dfn{pipeline} bidirezionale verso un processo figlio
che esegue l'altro programma. L'output creato con @code{print} o con
@code{printf} viene scritto nello standard input del programma, e il contenuto
dello standard output del programma pu@`o essere letto dal programma
@command{gawk} usando @code{getline}.
Come accade coi processi avviati con @samp{|}, il sottoprogramma pu@`o
essere un qualsiasi programma, o una @dfn{pipeline} di programmi, che pu@`o essere
avviato dalla shell.
Ci sono alcune avvertenze da tenere presenti:
@itemize @value{BULLET}
@item
Per come funziona internamente @command{gawk}, lo standard error
dei coprocessi va nello stesso posto dove va lo standard error del
genitore @command{gawk}. Non @`e possibile leggere lo standard error del
figlio separatamente.
@cindex stalli
@cindex abbracci mortali
@cindex @dfn{deadlocks} @subentry vedi stalli
@cindex bufferizzazione @subentry dell'input/output
@cindex input/output @subentry bufferizzazione
@cindex @code{getline} (comando) @subentry stalli e
@item
La permanenza in memoria (bufferizzazione) dell'I/O del sottoprocesso potrebbe
essere un problema. @command{gawk} automaticamente scrive su disco tutto
l'output spedito tramite la @dfn{pipe} al coprocesso.
Tuttavia, se il coprocesso non scrive su disco il suo output,
@command{gawk} potrebbe bloccarsi mentre esegue una @code{getline} per leggere
il risultato del coprocesso. Questo pu@`o portare a una situazione
conosciuta come @dfn{stallo} (@dfn{deadlock}, abbraccio mortale), in cui ciascun
processo rimane in attesa
che l'altro processo faccia qualcosa.
@end itemize
@cindex @code{close()} (funzione) @subentry @dfn{pipe} bidirezionali e
@cindex funzione @subentry @code{close()} @subentry @dfn{pipe} bidirezionali e
@`E possibile chiudere una @dfn{pipe} bidirezionale con un coprocesso solo in una
direzione, fornendo un secondo argomento, @code{"to"} o @code{"from"}, alla
funzione @code{close()} (@pxref{Chiusura file e @dfn{pipe}}).
Queste stringhe dicono a @command{gawk} di chiudere la @dfn{pipe}, rispettivamente
nella direzione che invia i dati al coprocesso e nella direzione che legge da
esso.
@cindex @command{sort} (programma di utilit@`a) @subentry coprocessi e
@cindex programma di utilit@`a @subentry @command{sort} @subentry coprocessi e
Questo @`e particolarmente necessario per usare il programma di utilit@`a
di sistema @command{sort} come parte di un coprocesso;
@command{sort} deve leggere @emph{tutti} i dati di input
prima di poter produrre un qualsiasi output.
Il programma @command{sort} non riceve un'indicazione di fine-file
(end-of-file) finch@'e @command{gawk} non chiude l'estremit@`a in scrittura della
@dfn{pipe}.
Una volta terminata la scrittura dei dati sul programma @command{sort},
si pu@`o chiudere il lato @code{"to"} della @dfn{pipe}, e quindi iniziare a leggere
i dati ordinati via @code{getline}.
Per esempio:
@example
BEGIN @{
comando = "LC_ALL=C sort"
n = split("abcdefghijklmnopqrstuvwxyz", a, "")
for (i = n; i > 0; i--)
print a[i] |& comando
close(comando, "to")
while ((comando |& getline line) > 0)
print "ricevuto", line
close(comando)
@}
@end example
Questo programma scrive le lettere dell'alfabeto in ordine inverso, uno per
riga, attraverso la @dfn{pipe} bidirezionale verso @command{sort}. Poi chiude la
direzione di scrittura della @dfn{pipe}, in modo che @command{sort} riceva
un'indicazione di fine-file. Questo fa in modo che @command{sort} ordini i
dati e scriva i dati ordinati nel programma @command{gawk}. Una volta che
tutti i dati sono stati letti, @command{gawk} termina il coprocesso ed esce.
@cindex ASCII
Come nota a margine, l'assegnamento @samp{LC_ALL=C} nel comando @command{sort}
assicura che @command{sort} usi l'ordinamento tradizionale di Unix (ASCII).
Ci@`o non @`e strettamente necessario in questo caso, ma @`e bene sapere come farlo.
Occorre prestare attenzione quando si chiude il lato @code{"from"} di una
@dfn{pipe} bidirezionale; in tal caso @command{gawk} attende che il
processo-figlio termini, il che pu@`o causare lo stallo del programma
@command{awk} in esecuzione. (Per questo motivo, questa particolare
funzionalit@`a @`e molto meno usata, in pratica, di quella che consente la
possibilit@`a di chiudere il lato @code{"to"} della @dfn{pipe}.)
@quotation ATTENZIONE
Normalmente,
@`e un errore fatale (che fa terminare il programma @command{awk})
scrivere verso il lato @code{"to"} di una @dfn{pipe} bidirezionale che
@`e stata chiusa, e lo stesso vale se si legge dal lato @code{"from"}
di una @dfn{pipe} bidirezionale che sia stata chiusa.
@`E possibile impostare @code{PROCINFO["@var{comando}", "NONFATAL"]}
per far s@`{@dotless{i}} che tali operazioni non provochino la fine del programma
@command{awk}. Se lo si fa, @`e necessario controllare il valore
di @code{ERRNO} dopo ogni istruzione @code{print}, @code{printf},
o @code{getline}.
@xref{Continuazione dopo errori} per ulteriori informazioni.
@end quotation
@cindex @command{gawk} @subentry vettore @subentry @code{PROCINFO} in
@cindex @code{PROCINFO} (vettore) @subentry comunicazioni attraverso le @dfn{pty} e
@cindex vettore @subentry @code{PROCINFO} @subentry comunicazioni attraverso le @dfn{pty} e
Per le comunicazioni bidirezionali si possono anche usare delle pseudo @dfn{tty}
(@dfn{pty}) al posto delle @dfn{pipe}, se il sistema in uso le prevede.
Questo vien fatto, a seconda del comando da usare, impostando un elemento
speciale nel vettore @code{PROCINFO}
(@pxref{Variabili auto-assegnate}),
in questo modo:
@example
comando = "sort -nr" # comando, salvato in una variabile
PROCINFO[comando, "pty"] = 1 # aggiorna PROCINFO
print @dots{} |& comando # avvia la @dfn{pipe} bidirezionale
@dots{}
@end example
@noindent
Se il sistema in uso non ha le @dfn{pty}, o se tutte le @dfn{pty} del sistema
sono in uso, @command{gawk} automaticamente torna a usare le @dfn{pipe}
regolari.
Usare le @dfn{pty} in genere evita i problemi di stallo del buffer descritti
precedentemente, in cambio di un piccolo calo di prestazioni. Ci@`o dipende
dal fatto che la gestione delle @dfn{tty} @`e fatta una riga per volta.
Su sistemi che hanno il comando @command{stdbuf} (parte del pacchetto
@uref{https://www.gnu.org/software/coreutils/coreutils.html,
GNU Coreutils}), si pu@`o usare tale programma, invece delle @dfn{pty}.
Si noti anche che le @dfn{pty} non sono completamente trasparenti.
Alcuni codici di controllo binari, come @kbd{Ctrl-d} per indicare la
condizione di file-file, sono interpetati dal gestore di @dfn{tty}
e non sono passati all'applicazione.
@quotation ATTENZIONE
In ultima analisi, i coprocessi danno adito alla possibilit@`a di uno
@dfn{stallo} (deadlock) tra @command{gawk} e il programma in esecuzione
nel coprocesso. Ci@`o pu@`o succedere se si inviano ``troppi'' dati al
coprocesso, prima di leggere dati inviati dallo stesso; entrambi i
processi sono bloccati sulla scrittura dei dati, e nessuno dei due
@`e disponibile a leggere quelli che sono gi@`a stati scritti dall'altro.
Non c'@`e modo di evitare completamente una tale situazione; occorre una
programmazione attenta, insieme alla conoscenza del comportamento del
coprocesso.
@end quotation
@c From email send January 4, 2018.
L'esempio seguente, preparato da Andrew Schorr, dimostra come
l'utilizzo delle @dfn{pty} pu@`o servire a evitare situazioni
di stallo connesse con i buffer
Si supponga che @command{gawk} non sia in grado di sommare dei numeri.
Si potrebbe usare un coprocesso per farlo. Ecco un programma fin troppo
semplice, che pu@`o svolgere tale funzione:
@example
$ @kbd{cat add.c}
#include
int
main(void)
@{
int x, y;
while (scanf("%d %d", & x, & y) == 2)
printf("%d\n", x + y);
return 0;
@}
$ @kbd{cc -O add.c -o add} @ii{Compilazione del programma}
@end example
Si potrebbe poi scrivere un programma @command{gawk} fin troppo semplice,
per sommare dei numeri passandoli al coprocesso:
@example
$ @kbd{echo 1 2 |}
> @kbd{gawk -v cmd=./add '@{ print |& cmd; cmd |& getline x; print x @}'}
@end example
E il programma andrebbe in stallo, poich@'e, @file{add.c} non chiama a sua
volta @samp{setlinebuf(stdout)}. Il programma @command{add} si blocca.
Ora, si provi invece con:
@example
$ @kbd{echo 1 2 |}
> @kbd{gawk -v cmd=add 'BEGIN @{ PROCINFO[cmd, "pty"] = 1 @}}
> @kbd{ @{ print |& cmd; cmd |& getline x; print x @}'}
@print{} 3
@end example
Usando una @dfn{pty}, @command{gawk} fa s@`{@dotless{i}} che la libreria di I/O
determini di avere a che fare con una sessione interattiva, e quindi
utilizzi per default una riga alla volta come buffer.
E ora, magicamente, funziona!
@node Reti TCP/IP
@section Usare @command{gawk} per la programmazione di rete
@cindex funzionalit@`a @subentry avanzate @subentry programmazione di rete
@cindex avanzate @subentry funzionalit@`a @subentry programmazione di rete
@cindex reti @subentry programmazione di
@cindex TCP/IP
@cindex @code{/inet/@dots{}}, file speciali (in @command{gawk})
@cindex file @subentry speciali @subentry @code{/inet/@dots{}} (in @command{gawk})
@cindex @code{/inet4/@dots{}}, file speciali (in @command{gawk})
@cindex file @subentry speciali @subentry @code{/inet4/@dots{}} (in @command{gawk})
@cindex @code{/inet6/@dots{}}, file speciali (in @command{gawk})
@cindex file @subentry speciali @subentry @code{/inet6/@dots{}} (in @command{gawk})
@cindex @code{EMRED} (codice di errore di fantasia)
@ifnotdocbook
@quotation
@code{EMRED}:@*
@ @ @ @ @i{A host is a host from coast to coast,@*
@ @ @ @ and nobody talks to a host that's close,@*
@ @ @ @ unless the host that isn't close@*
@ @ @ @ is busy, hung, or dead.}
@code{EMRED}:@*
@ @ @ @ @i{Un computer @`e un computer lontano o vicino,@*
@ @ @ @ e nessuno parla con un computer vicino,@*
@ @ @ @ a meno che il computer lontano@*
@ @ @ @ sia occupato, fuori linea, o spento.}
@author Mike O'Brien (noto anche come Mr.@: Protocol)
@end quotation
@end ifnotdocbook
@docbook
Mike O'Brien (aka Mr. Protocol)
EMRED:
A host is a host from coast to coast,
and no-one can talk to host that's close,
unless the host that isn't close
is busy, hung, or dead.
@end docbook
Oltre a poter aprire una @dfn{pipeline} bidirezionale verso un coprocesso
sullo stesso sistema
(@pxref{I/O bidirezionale}),
@`e possibile attivare una connessione bidirezionale verso un altro processo
o verso un altro sistema attraverso una connessione di rete IP.
Si pu@`o pensare a questo semplicemente come a una @dfn{pipeline} bidirezionale
@emph{molto lunga} verso un coprocesso.
Il modo in cui @command{gawk} stabilisce quando usare una rete TCP/IP @`e
mediante il riconoscimento di speciali @value{FNS} che iniziano con
@samp{/inet/}, con @samp{/inet4/} o con @samp{/inet6/}.
La sintassi completa del @value{FN} speciale @`e
@file{/@var{tipo-rete}/@var{protocollo}/@var{porta-locale}/@var{host-remoto}/@var{porta-remota}}.
I componenti sono:
@table @var
@item tipo-rete
Specifica il tipo di connessione a internet da stabilire.
Si usa @samp{/inet4/} per usare solo IPv4, e
@samp{/inet6/} per usare solo IPv6.
Il semplice @samp{/inet/} (che usualmente @`e l'unica opzione) usa
il tipo di default del sistema, quasi certamente IPv4.
@item protocollo
Il protocollo da usare sull'IP. Questo dev'essere o @samp{tcp} o
@samp{udp}, per una connessione IP rispettivamente TCP o UDP.
TCP dovrebbe venir usato per la maggior parte delle applicazioni.
@item porta-locale
@cindex @code{getaddrinfo()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{getaddrinfo()}
Il numero di porta TCP o UDP da usare. Si usa un numero di porta di valore
@samp{0} quando si vuole che sia il sistema a scegliere una porta.
Questo @`e quel che si dovrebbe fare quando si scrive un'applicazione
cliente TCP o UDP.
Si pu@`o usare anche un nome di un servizio noto, come @samp{smtp}
o @samp{http}, nel qual caso @command{gawk} tenta di determinare
il numero di porta predefinito usando la funzione C @code{getaddrinfo()}.
@item host-remoto
L'indirizzo IP o il nome di dominio completamente qualificato dell'host
internet al quale ci si vuol connettere.
@item porta-remota
Il numero di porta TCP o UDP da usare sul particolare @var{host remoto}.
Anche in questo caso, si usi @samp{0} se non ci sono preferenze,
o alternativamente, un nome di servizio comunemente noto.
@end table
@cindex @command{gawk} @subentry variabile @subentry @code{ERRNO} in
@cindex @code{ERRNO} (variabile)
@cindex variabile @subentry @code{ERRNO}
@quotation NOTA
Un insuccesso nell'apertura di un socket bidirezionale dar@`a luogo alla
segnalazione di un errore non fatale al codice chiamante.
Il valore di @code{ERRNO} indica l'errore (@pxref{Variabili auto-assegnate}).
@end quotation
Si consideri il seguente esempio molto semplice:
@example
BEGIN @{
Servizio = "/inet/tcp/0/localhost/daytime"
Servizio |& getline
print $0
close(Servizio)
@}
@end example
Questo programma legge la data e l'ora corrente dal server @code{daytime}
TCP del sistema locale.
Stampa poi il risultato e chiude la connessione.
Poich@'e questo tema @`e molto ampio, l'uso di @command{gawk} per
la programmazione TCP/IP viene documentato separatamente.
@ifinfo
Si veda
@inforef{Top, , General Introduction, gawkinet, @value{GAWKINETTITLE}},
@end ifinfo
@ifnotinfo
Si veda
@uref{https://www.gnu.org/software/gawk/manual/gawkinet/,
@cite{@value{GAWKINETTITLE}}},
che fa parte della distribuzione @command{gawk},
@end ifnotinfo
per una introduzione e trattazione molto pi@`u completa e con molti
esempi.
@quotation NOTA
@command{gawk} pu@`o aprire solo socket diretti. Al momento non c'@`e alcun modo
per accedere ai servizi disponibili su Secure Socket Layer
(SSL); questo comprende qualsiasi servizio web il cui URL inizia con
@samp{https://}.
@end quotation
@node Profilare
@section Profilare i propri programmi @command{awk}
@cindex programmi @command{awk} @subentry profilare
@cindex profilare programmi @command{awk}
@cindex @code{awkprof.out} @subentry file
@cindex file @subentry @file{awkprof.out}
@`E possibile tener traccia dell'esecuzione dei propri programmi @command{awk}.
Ci@`o si pu@`o fare passando l'opzione @option{--profile} a @command{gawk}.
Al termine dell'esecuzione, @command{gawk} crea un profilo del programma in un
file chiamato @file{awkprof.out}. A causa dell'attivit@`a di profilazione
l'esecuzione del programma @`e pi@`u lenta fino al 45% rispetto al normale.
@cindex @option{--profile} (opzione)
@cindex opzione @subentry @option{--profile}
Come mostrato nel seguente esempio,
l'opzione @option{--profile} pu@`o essere usata per cambiare il nome del file
su cui @command{gawk} scriver@`a il profilo:
@example
gawk --profile=mioprog.prof -f mioprog.awk dati1 dati2
@end example
@noindent
Nell'esempio precedente, @command{gawk} mette il profilo in
@file{mioprog.prof} anzich@'e in @file{awkprof.out}.
Vediamo ora una sessione d'esempio che mostra un semplice programma
@command{awk}, i suoi dati in input, e il risultato dell'esecuzione di
@command{gawk} con l'opzione @option{--profile}. Innanzitutto, il
programma @command{awk}:
@example
BEGIN @{ print "Prima regola BEGIN" @}
END @{ print "Prima regola END" @}
/pippo/ @{
print "trovato /pippo/, perbacco"
for (i = 1; i <= 3; i++)
sing()
@}
@{
if (/pippo/)
print "l'if @`e vero"
else
print "l'else @`e vero"
@}
BEGIN @{ print "Seconda regola BEGIN" @}
END @{ print "Seconda regola END" @}
function sing( ignora)
@{
print "Devo essere io!"
@}
@end example
Questi sono i dati in input:
@example
pippo
pluto
paperino
pippo
cianfrusaglie
@end example
E questo @`e il file @file{awkprof.out} che @`e il risultato dell'esecuzione
del profilatore di @command{gawk} su questo programma e sui dati (quest'esempio
dimostra anche che i programmatori di @command{awk} a volte si alzano molto
presto al mattino per lavorare):
@cindex @code{BEGIN} (regola) @subentry profilazione e
@cindex regola @subentry @code{BEGIN} @subentry profilazione e
@cindex @code{END} (regola) @subentry profilazione e
@cindex regola @subentry @code{END} @subentry profilazione e
@example
# profilo gawk, creato Mon Sep 29 05:16:21 2014
# BEGIN regola(e)
BEGIN @{
1 print "Prima regola BEGIN"
@}
BEGIN @{
1 print "Seconda regola BEGIN"
@}
# Regola(e)
5 /pippo/ @{ # 2
2 print "trovato /pippo/, perbacco"
6 for (i = 1; i <= 3; i++) @{
6 sing()
@}
@}
5 @{
5 if (/pippo/) @{ # 2
2 print "l'if @`e vero"
3 @} else @{
3 print "l'else @`e vero"
@}
@}
# END regola(e)
END @{
1 print "Prima regola END"
@}
END @{
1 print "Seconda regola END"
@}
# Funzioni, in ordine alfabetico
6 function sing(ignora)
@{
6 print "Devo essere io!"
@}
@end example
Quest'esempio illustra molte caratteristiche fondamentali dell'output
della profilazione.
Queste sono:
@itemize @value{BULLET}
@item
Il programma viene stampato nell'ordine: regole @code{BEGIN},
regole @code{BEGINFILE},
regole criterio di ricerca--azione,
regole @code{ENDFILE}, regole @code{END}, e funzioni, elencate
in ordine alfabetico.
Le regole @code{BEGIN} ed @code{END} multiple conservano le loro
distinte identit@`a, cos@`{@dotless{i}} come le regole @code{BEGINFILE} ed @code{ENDFILE}
multiple.
@cindex criteri di ricerca @subentry conteggi in un profilo
@item
Le regole criterio di ricerca--azione hanno due conteggi.
Il primo conteggio, a sinistra della regola, mostra quante volte
il criterio di ricerca della regola @`e stato @emph{testato}.
Il secondo conteggio, alla destra della parentesi graffa aperta,
all'interno di un commento,
mostra quante volte l'azione della regola @`e stata @emph{eseguita}.
La differenza tra i due indica quante volte il criterio di ricerca della regola
@`e stato valutato come falso.
@item
Analogamente,
il conteggio per un'istruzione @code{if}-@code{else} mostra quante volte
la condizione @`e stata testata.
Alla destra della parentesi graffa sinistra aperta per il corpo di @code{if}
c'@`e un conteggio che mostra quante volte la condizione @`e stata trovata vera.
Il conteggio per @code{else} indica
quante volte la verifica non ha avuto successo.
@cindex cicli @subentry conteggi per l'intestazione @subentry in un profilo
@item
Il conteggio per un ciclo (come @code{for}
o @code{while}) mostra quante volte il test del ciclo @`e stato eseguito.
(Per questo motivo, non si pu@`o solamente guardare il conteggio sulla prima
istruzione in una regola per determinare quante volte la regola @`e stata
eseguita. Se la prima istruzione @`e un ciclo, il conteggio @`e ingannevole.)
@cindex funzione definita dall'utente @subentry conteggi @subentry in un profilo
@item
Per le funzioni definite dall'utente, il conteggio vicino alla parola chiave
@code{function} indica quante volte la funzione @`e stata chiamata.
I conteggi vicino alle istruzioni nel corpo mostrano quante volte
quelle istruzioni sono state eseguite.
@cindex @code{@{@}} (parentesi graffe)
@cindex parentesi @subentry graffe (@code{@{@}})
@item
L'impaginazione usa lo stile ``K&R'' con le tabulazioni.
Le parentesi graffe sono usate dappertutto, anche dove il corpo di un
@code{if}, di un @code{else} o di un ciclo @`e formato da un'unica istruzione.
@cindex @code{()} (parentesi) @subentry in un profilo
@cindex parentesi @subentry (@code{()}) @subentry in un profilo
@item
Le parentesi vengono usate solo dov'@`e necessario, come si rileva dalla
struttura del programma e dalle regole di precedenza.
Per esempio, @samp{(3 + 5) * 4} significa sommare tre e cinque, quindi
moltiplicare il totale per quattro. Di contro, @samp{3 + 5 * 4} non ha
parentesi, e significa @samp{3 + (5 * 4)}.
Tuttavia, le parentesi inserite esplicitamente nel programma sorgente
sono conservate come sono state scritte.
@ignore
@item
All string concatenations are parenthesized too.
(This could be made a bit smarter.)
@end ignore
@item
Le parentesi vengono usate attorno agli argomenti di @code{print}
e @code{printf} solo quando l'istruzione
@code{print} o @code{printf} @`e seguita da una ridirezione.
Similarmente, se
l'oggetto di una ridirezione non @`e uno scalare, viene messo tra parentesi.
@item
@command{gawk} mette dei commenti iniziali
davanti alle regole @code{BEGIN} ed @code{END},
alle regole @code{BEGINFILE} ed @code{ENDFILE},
alle regole criterio_di_ricerca--azione e alle funzioni.
@item
Le funzioni sono elencate in ordine alfabetico. Per prime sono elencate
in ordine alfabetico le funzioni che appartengono allo spazio-dei-nomi
@code{awk}. Poi sono elencate le funzioni contenute negli altri
spazi-dei-nomi. Ogni spazio-dei-nomi @`e elencato in ordine alfabetico
e le funzioni in esso contenute sono anch'esse elencate in ordine
alfabetico.
@end itemize
La versione profilata del proprio programma potrebbe non apparire esattamente
come quella scritta durante la stesura del programma. Questo perch@'e
@command{gawk} crea la versione profilata facendo una ``stampa elegante'' della
sua rappresentazione interna del programma. Un vantaggio di ci@`o @`e che
@command{gawk} pu@`o produrre una rappresentazione standard.
Inoltre, cose come:
@example
/pippo/
@end example
@noindent
appaiono come:
@example
/pippo/ @{
print
@}
@end example
@noindent
che @`e corretto, ma probabilmente inatteso.
(Se un programma usa sia @samp{print $0} che un semplice
@samp{print}, tale differenza @`e mantenuta.)
@cindex profilare programmi @command{awk} @subentry dinamicamente
@cindex @command{gawk} @subentry programma @subentry profilazione dinamica
@cindex @command{gawk} @subentry profilare programmi
@cindex profilazione @subentry dinamica
Oltre a creare profili una volta completato il programma,
@command{gawk} pu@`o generare un profilo mentre @`e in esecuzione.
Questo @`e utile se il proprio programma @command{awk} entra in un ciclo
infinito e si vuol vedere cosa @`e stato eseguito.
Per usare questa funzionalit@`a, bisogna eseguire @command{gawk} con l'opzione
@option{--profile} in background:
@example
$ @kbd{gawk --profile -f mioprog &}
[1] 13992
@end example
@cindex @command{kill} (comando) @subentry profilazione dinamica e
@cindex comando @subentry @command{kill} @subentry profilazione dinamica e
@cindex @code{USR1} (segnale) @subentry per profilazione dinamica
@cindex @code{SIGUSR1} (segnale) (per profilazione dinamica)
@cindex segnali @subentry @code{USR1}/@code{SIGUSR1} (per profilazione)
@noindent
La shell stampa un numero di job e il numero di ID del relativo processo;
in questo caso, 13992. Si usi il comando @command{kill} per inviare il
segnale @code{USR1} a @command{gawk}:
@example
$ @kbd{kill -USR1 13992}
@end example
@noindent
Come al solito, la versione profilata del programma @`e scritta nel file
@file{awkprof.out}, o in un file differente se ne viene specificato uno
con l'opzione @option{--profile}.
Assieme al profilo regolare, come mostrato in precedenza, il file del profilo
include una traccia di ogni funzione attiva:
@example
# `Stack' (Pila) Chiamate Funzione:
# 3. paperino
# 2. pluto
# 1. pippo
# -- main --
@end example
Si pu@`o inviare a @command{gawk} il segnale @code{USR1} quante volte si vuole.
Ogni volta, il profilo e la traccia della chiamata alla funzione vengono
aggiunte in fondo al file di profilo creato.
@cindex @code{HUP} (segnale) @subentry per profilazione dinamica
@cindex @code{SIGHUP} (segnale) (per profilazione dinamica)
@cindex segnali @subentry @code{HUP}/@code{SIGHUP} (per profilazione)
Se si usa il segnale @code{HUP} invece del segnale @code{USR1}, @command{gawk}
genera il profilo e la traccia della chiamata alla funzione ed esce.
@cindex @code{INT} (segnale) (MS-Windows)
@cindex @code{SIGINT} (segnale) (MS-Windows)
@cindex segnali @subentry @code{INT}/@code{SIGINT} (MS-Windows)
@cindex @code{QUIT} (segnale) (MS-Windows)
@cindex @code{SIGQUIT} (segnale) (MS-Windows)
@cindex segnali @subentry @code{QUIT}/@code{SIGQUIT} (MS-Windows)
Quando @command{gawk} viene eseguito sui sistemi MS-Windows, usa i segnali
@code{INT} e @code{QUIT} per generare il profilo, e nel
caso del segnale @code{INT}, @command{gawk} esce. Questo perch@'e
questi sistemi non prevedono il comando @command{kill}, per cui gli unici
segnali che si possono trasmettere a un programma sono quelli generati dalla
tastiera. Il segnale @code{INT} @`e generato dalle combinazioni di tasti
@kbd{Ctrl-c} o @kbd{Ctrl-BREAK}, mentre il segnale
@code{QUIT} @`e generato dalla combinazione di tasti @kbd{Ctrl-\}.
@cindex stampa elegante
Infine, @command{gawk} accetta anche un'altra opzione, @option{--pretty-print}.
Quando viene chiamato in questo modo, @command{gawk} fa una ``stampa elegante''
del programma nel file @file{awkprof.out}, senza conteggi sull'esecuzione.
@quotation NOTA
Una volta, l'opzione @option{--pretty-print} eseguiva anche il programma.
Ora non pi@`u.
@end quotation
@cindex profilazione @subentry differenza rispetto alla stampa elegante
@cindex stampa elegante @subentry differenza rispetto alla profilazione
C'@`e una differenza significativa tra l'output creato durante la profilazione,
e quello creato durante la stampa elegante. L'output della stampa elegante
preserva i commenti originali che erano nel programma, anche se la loro
posizione pu@`o non corrispondere esattamente alle posizioni originali che
avevano nel codice sorgente. Tuttavia, nessun commento dovrebbe andare
perso. Inoltre, @command{gawk} fa del suo meglio
per mantenere la distinzione tra commenti posti dopo delle istruzioni e
commenti su righe a s@'e stanti. Tuttavia, non sempre questo pu@`o avvenire
in maniera perfetta.
Comunque, per una precisa scelta progettuale, l'output della profilazione
@emph{omette} i commenti del programma originale. Questo permette di
concentrarsi sui dati del conteggio di esecuzione ed evita la tentazione di
usare il profilatore per creare una stampa elegante.
Oltre a ci@`o, l'output stampato in modo elegante non ha l'indentazione iniziale
che ha l'output della profilazione. Questo rende agevole la stampa elegante
del proprio codice una volta completato lo sviluppo, usando poi il risultato
come versione finale del programma.
Poich@'e la rappresentazione interna del programma @`e formattata per
essere aderente al programma @command{awk} in questione, la profilazione
e la stampa elegante (opzione @option{--pretty-print}) disabilitano
automaticamente le optimizzazioni di default di @command{gawk}.
La profilazione e la stampa elegante mantengono anche il formato originale
delle costanti numeriche; se sono stati usati dei valori ottali o esadecimali
nel codice sorgente, questi compariranno nell'output nello stesso
formato con cui sono stati inseriti.
@node Sommario funzionalit@`a avanzate
@section Sommario
@itemize @value{BULLET}
@item
L'opzione @option{--non-decimal-data} fa s@`{@dotless{i}} che @command{gawk} tratti
i dati di input che hanno l'aspetto ottale ed esadecimale come valori ottali ed
esadecimali. L'opzione dovrebbe essere usata con prudenza o non usata affatto;
@`e preferibile l'uso di @code{strtonum()}.
Si noti che quest'opzione potrebbe sparire nelle prossime versioni di
@command{gawk}.
@item
Si pu@`o prendere il completo controllo dell'ordinamento nello scorrere il
vettore con @samp{for (@var{indice} in @var{vettore})}, impostando
@code{PROCINFO["sorted_in"]} al nome di una funzione definita dall'utente che
fa il confronto tra elementi del vettore basandosi su indice e valore.
@item
Analogamente, si pu@`o fornire il nome di una funzione di confronto definita
dall'utente come terzo argomento di @code{asort()} o di @command{asorti()} per
controllare come queste funzioni ordinano i vettori. O si pu@`o fornire una delle
stringhe di controllo predefinite che funzionano per
@code{PROCINFO["sorted_in"]}.
@item
Si pu@`o usare l'operatore @samp{|&} per creare una @dfn{pipe} bidirezionale
verso un coprocesso. Si legge dal coprocesso con @code{getline}, ci si
scrive sopra con @code{print} o con @code{printf}. Usare @code{close()}
per bloccare il coprocesso completamente o, se necessario, chiudere le
comunicazioni bidirezionali in una direzione.
@item
Usando degli speciali @value{FNS} con l'operatore @samp{|&}, si pu@`o aprire una
connessione TCP/IP (o UDP/IP) verso host remoti su internet. @command{gawk}
supporta sia IPv4 che IPv6.
@item
Si possono generare profili del proprio programma con i conteggi del numero
di esecuzione di ogni singola
istruzione. Questo pu@`o essere d'aiuto nel determinare quali parti del programma
potrebbero portar via la maggior parte del tempo, consentendo cos@`{@dotless{i}} di
aggiustarli pi@`u agevolmente. Inviando il segnale @code{USR1} durante la
profilazione @command{gawk} scrive il profilo, includendo lo
@dfn{stack} della chiamata alla funzione e prosegue nell'elaborazione.
@item
Si pu@`o anche fare solo una ``stampa elegante'' del programma.
@end itemize
@node Internazionalizzazione
@chapter Internazionalizzazione con @command{gawk}
Tanto tempo fa i produttori di computer
scrivevano software che comunicava solo in inglese.
Col passare del tempo, i venditori di hardware e di software si sono
resi conto che se i loro sistemi avessero comunicato anche nelle lingue
materne di paesi dove non si parlava inglese,
ci@`o avrebbe avuto come risultato un incremento delle vendite.
Per questo motivo, l'internazionalizzazione e la localizzazione
di programmi e sistemi software @`e divenuta una pratica comune.
@cindex internazionalizzazione @subentry localizzazione
@cindex @command{gawk} @subentry internazionalizzazione e @seeentry{internazionalizzazione}
@cindex internazionalizzazione @subentry localizzazione @subentry @command{gawk} e
Per molti anni la possibilit@`a di fornire l'internazionalizzazione
era sostanzialmente limitata ai programmi scritti in C e C++.
Questo @value{CHAPTER} descrive la libreria @dfn{ad hoc} utilizzata da
@command{gawk}
per l'internazionalizzazione e anche il modo in cui le funzionalit@`a che
consentono l'internazionalizzazione sono rese disponibili da @command{gawk}
a ogni programma scritto in @command{awk}.
La disponibilit@`a dell'internazionalizzazione a livello di programma
@command{awk} offre ulteriore flessibilit@`a agli sviluppatori di software:
non sono pi@`u obbligati a scrivere in C o C++ quando l'internazionalizzazione
@`e necessaria in un programma.
@menu
* I18N e L10N:: Internazionalizzazione e localizzazione.
* Utilizzare @command{gettext}:: Come funziona il comando GNU @command{gettext}.
* I18N per programmatore:: Funzionalit@`a per il programmatore.
* I18N per traduttore:: Funzionalit@`a per il traduttore.
* Esempio I18N:: Un semplice esempio di internazionalizzazione.
* Gawk internazionalizzato:: Anche @command{gawk} @`e internazionalizzato.
* Sommario I18N:: Sommario dell'internazionalizzazione.
@end menu
@node I18N e L10N
@section Internazionalizzazione e localizzazione
@cindex programmi @command{awk} @subentry internazionalizzare
@cindex internazionalizzazione @subentry di programmi @command{awk}
@cindex localizzazione @seealso{internazionalizzazione}
@cindex localizzazione
@dfn{Internazionalizzazione} significa scrivere (o modificare) un programma
una volta sola,
in maniera tale che possa usare pi@`u di una lingua senza
bisogno di ulteriori modifiche al file sorgente.
@dfn{Localizzazione}
significa fornire i dati necessari perch@'e un programma
internazionalizzato sia in grado di funzionare con una data lingua.
Questi termini si riferiscono comunemente a funzionalit@`a quali la lingua
usata per stampare messaggi di errore, quella usata per leggere
risposte, e alle informazioni
relative al modo di leggere e di stampare dati di tipo numerico o valutario.
@node Utilizzare @command{gettext}
@section Il comando GNU @command{gettext}
@cindex internazionalizzazione @subentry di programmi @command{awk}
@cindex @command{gettext} @subentry libreria
@cindex libreria @command{gettext}
@command{gawk} usa il comando GNU @command{gettext} per rendere disponibili
le proprie funzionalit@`a di internazionalizzazione.
L'attenzione del comando GNU @command{gettext} @`e rivolta principalmente
ai messaggi: stringhe di caratteri stampate da un programma, sia
direttamente sia usando la formattazione prevista dalle istruzioni
@code{printf} o @code{sprintf()}.@footnote{Per alcuni sistemi operativi,
la relativa versione di @command{gawk}
non supporta il comando GNU @command{gettext}.
Per questo motivo, queste funzionalit@`a non sono disponibili nel caso
si stia lavorando con uno di questi sistemi operativi. Siamo spiacenti.}
@cindex portabilit@`a @subentry libreria @command{gettext} e
Quando si usa il comando GNU @command{gettext}, ogni applicazione ha il
proprio @dfn{dominio di testo}. Questo @`e un nome unico come,
p.es., @samp{kpilot} o @samp{gawk},
che identifica l'applicazione.
Un'applicazione completa pu@`o avere pi@`u componenti: programmi scritti
in C o C++, come pure @dfn{script} di @command{sh} o di @command{awk}.
Tutti i componenti usano lo stesso dominio di testo.
Per andare sul concreto, si supponga di scrivere un'applicazione
chiamata @command{guide}. L'internazionalizzazione per quest'applicazione
pu@`o essere implementata seguendo nell'ordine i passi qui delineati:
@enumerate
@item
Il programmatore esamina i sorgenti di tutti i componenti dell'applicazione
@command{guide} e prende nota di ogni stringa che potrebbe aver bisogno
di traduzione.
Per esempio, @code{"`-F': option required"} @`e una stringa che sicuramente
necessita di una traduzione.
Una tabella che contenga stringhe che sono nomi di opzioni @emph{non}
necessita di traduzione.
(P.es., l'opzione di @command{gawk} @option{--profile}
dovrebbe restare immutata, a prescindere dalla lingua locale).
@cindex @code{textdomain()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{textdomain()}
@item
Il programmatore indica il dominio di testo dell'applicazione
(@command{"guide"}) alla libreria @command{gettext},
chiamando la funzione @code{textdomain()}.
@cindex @file{.pot} (file)
@cindex file @subentry @file{.pot}
@cindex @dfn{portable object template} (@file{.pot}) (file)
@cindex file @subentry @dfn{portable object template} (@file{.pot})
@item
I messaggi dell'applicazione che vanno tradotti sono estratti dal codice
sorgente e messi in un file di tipo
@dfn{portable object template}
[modello di oggetto portabile]
di nome @file{guide.pot},
che elenca le stringhe e le relative traduzioni.
Le traduzioni sono inizialmente vuote
(esiste la struttura che definisce la stringa tradotta, ma la stringa
tradotta @`e una stringa nulla).
Il messaggio originale (normalmente in inglese) @`e utilizzato come chiave
di riferimento per le traduzioni.
@cindex @file{.po} (file)
@cindex file @subentry @file{.po}
@cindex @dfn{portable object} file (@file{.po})
@cindex file @subentry @dfn{portable object} (@file{.po})
@item
Per ogni lingua per cui sia disponibile un traduttore, il file
@file{guide.pot} @`e copiato in un file di tipo
@dfn{portable object}
[oggetto portabile]
(dal suffisso @file{.po})
e le traduzioni sono effettuate su quel file,
che viene distribuito con l'applicazione.
Per esempio, potrebbe esserci un file @file{it.po} per la traduzione italiana.
@cindex @file{.gmo} (file)
@cindex file @subentry @file{.gmo}
@cindex @dfn{message object} file (@file{.mo})
@cindex file @subentry @dfn{message object} (@file{.mo})
@item
Il file @file{.po} di ogni lingua @`e convertito in un formato binario,
detto @dfn{message object} (file @file{.gmo}).
Un file di tipo @dfn{message object} contiene i messaggi originali e le loro
traduzioni in un formato binario che facilita il ritrovamento delle
traduzioni quando l'applicazione viene eseguita.
@item
Quando @command{guide} @`e compilato e installato, i file binari contenenti le
traduzioni sono installati in una directory standard.
@cindex @code{bindtextdomain()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{bindtextdomain()}
@item
Durante la fase di prova e sviluppo, @`e possibile chiedere a @command{gettext}
di usare un file @file{.gmo} in una directory diversa da quella standard,
usando la funzione @code{bindtextdomain()}.
@cindex @file{.gmo} (file) @subentry specificare la directory di
@cindex file @subentry @file{.gmo} @subentry specificare la directory di
@cindex @dfn{message object} file (@file{.mo}) @subentry specificare la directory di
@cindex file @subentry @dfn{message object} (@file{.mo}) @subentry specificare la directory di
@item
Quando viene eseguito, il programma @command{awk} @command{guide} cerca ogni
stringa da tradurre facendo una chiamata a @code{gettext()}. La stringa
ricevuta in ritorno @`e la stringa tradotta, se @`e stata trovata, o la stringa
originale, se una traduzione non @`e disponibile.
@item
Se necessario, @`e possibile procurarsi dei messaggi tradotti da un dominio di
testo diverso da quello proprio dell'applicazione, senza dover altalenare fra
questo secondo dominio e quello dell'applicazione.
@end enumerate
@cindex @code{gettext()} @subentry funzione di libreria C
@cindex funzione di libreria C @subentry @code{gettext()}
In C (o C++), la marcatura della stringa la ricerca dinamica
della traduzione si fanno inserendo ogni stringa da tradurre in una chiamata
a @code{gettext()}:
@example
printf("%s", gettext("Don't Panic!\n"));
@end example
Gli strumenti software che estraggono messaggi dal codice sorgente
individuano tutte le stringhe racchiuse nelle chiamate a @code{gettext()}.
@cindex @code{_} (trattino basso) @subentry macro C
@cindex trattino basso (@code{_}) @subentry macro C
Gli sviluppatori del comando GNU @command{gettext}, riconoscendo che
continuare a immettere @samp{gettext(@dots{})} @`e sia faticoso che poco
elegante da vedere, usano la macro @samp{_} (un trattino basso) per
facilitare la cosa:
@example
/* Nel file di intestazione standard: */
#define _(str) gettext(str)
/* Nel testo del programma: */
printf("%s", _("Don't Panic!\n"));
@end example
@cindex internazionalizzazione @subentry localizzazione @subentry categorie di localizzazione
@cindex @command{gettext} @subentry libreria @subentry categorie di localizzazione
@cindex libreria @command{gettext} @subentry categorie di localizzazione
@cindex categoria di localizzazione
@cindex localizzazione @subentry categorie di
@noindent
Questo permette di ridurre la digitazione extra a solo tre caratteri per
ogni stringa da tradurre e inoltre migliora di molto la leggibit@`a.
Ci sono @dfn{categorie} di localizzazione per tipi diversi di informazioni
legate a una particolare localizzazione.
Le categorie di localizzazione note a @command{gettext} sono:
@table @code
@cindex @code{LC_MESSAGES} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_MESSAGES} (variabile d'ambiente)
@item LC_MESSAGES
Testo dei messaggi. Questa @`e la categoria di default usata all'interno di
@command{gettext}, ma @`e possibile specificarne esplicitamente una differente,
se necessario. (Questo non @`e quasi mai necessario.)
@cindex ordinare caratteri in lingue differenti
@cindex @code{LC_COLLATE} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_COLLATE} (variabile d'ambiente)
@item LC_COLLATE
Informazioni sull'ordinamento alfabetico (cio@`e, come caratteri diversi e/o
gruppi di carattere sono ordinati in un dato linguaggio).
@c ad esempio i vari caratteri accentati in italiano, vanno ordinati
@c insieme alla loro lettera "principale" (e @`e @'e).
@cindex @code{LC_CTYPE} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_CTYPE} (variabile d'ambiente)
@item LC_CTYPE
Informazioni sui singoli caratteri (alfabetico, numerico, maiuscolo
o minuscolo, etc.), come pure sulla codifica dei caratteri.
@ignore
In June 2001 Bruno Haible wrote:
- Description of LC_CTYPE: It determines both
1. character encoding,
2. character type information.
(For example, in both KOI8-R and ISO-8859-5 the character type information
is the same - cyrillic letters could as 'alpha' - but the encoding is
different.)
@end ignore
Quest'informazione @`e utilizzata per stabilire le classi di caratteri come
definite nello standard POSIX, nelle espressioni regolari,
come p. es. @code{/[[:alnum:]]/}
(@pxref{Espressioni tra parentesi quadre}).
@cindex informazioni di tipo monetario @subentry localizzazione
@cindex monete @subentry simboli di (nella localizzazione)
@cindex simboli di monete (nella localizzazione)
@cindex monete @subentry rappresentazioni di (nella localizzazione)
@cindex internazionalizzazione @subentry localizzazione @subentry informazioni di tipo monetario
@cindex internazionalizzazione @subentry localizzazione @subentry simboli di monete
@cindex rappresentazioni di monete (nella localizzazione)
@cindex @code{LC_MONETARY} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_MONETARY} (variabile d'ambiente)
@item LC_MONETARY
Le informazioni di tipo monetario, quali il simbolo della moneta, e se
il simbolo va prima o dopo il valore numerico.
@cindex @code{LC_NUMERIC} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_NUMERIC} (variabile d'ambiente)
@item LC_NUMERIC
Informazioni di tipo numerico, quali il carattere da usare per separare le
cifre decimali e quello per separare le migliaia.@footnote{Gli americani usano
una virgola ogni tre cifre decimali, e un punto per separare la parte decimale
di un numero, mentre molti europei (fra cui gli italiani) fanno esattamente
l'opposto: 1,234.56 invece che 1.234,56.}
@cindex tempo @subentry localizzazione e
@cindex date @subentry informazioni relative alla localizzazione
@cindex @code{LC_TIME} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_TIME} (variabile d'ambiente)
@item LC_TIME
Informazioni relative alle date e alle ore,
come l'uso di ore nel formato a 12 ore oppure a 24 ore, il mese stampato
prima o dopo il giorno in una data, le abbreviazioni dei mesi nella lingua
locale, e cos@`{@dotless{i}} via.
@cindex @code{LC_ALL} (variabile d'ambiente) @subentry categoria di localizzazione
@cindex categoria di localizzazione @subentry @code{LC_ALL} (variabile d'ambiente)
@item LC_ALL
Tutte le categorie viste sopra. (Non molto utile nel contesto del comando
@command{gettext}.)
@end table
@quotation NOTA
@cindex @env{LANGUAGE} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{LANGUAGE}
Come descritto in @ref{Localizzazioni}, le variabili d'ambiente
che hanno lo stesso nome delle categorie di localizzazione
(@env{LC_CTYPE}, @env{LC_ALL}, etc.) influenzano il comportamento di
@command{gawk} (e quello di altri programmi di utilit@`a).
Solitamente, queste variabili influenzano anche il modo con cui
la libreria @code{gettext} trova le traduzioni. Tuttavia, la
variabile d'ambiente @env{LANGUAGE} prevale sulle variabili
della famiglia @env{LC_@var{xxx}}. Molti sistemi GNU/Linux possono
aver definito questa variabile senza esplicitamente notificarlo
all'utente, e questo potrebbe far s@`{@dotless{i}} che @command{gawk} non riesca a
trovare le traduzioni corrette. Se si incontra questa situazione,
occorre controllare se la variabile d'ambiente @env{LANGUAGE} @`e
definita, e, in questo caso, va usato il comando @command{unset}
per rimuoverla.
@end quotation
@cindex @env{GAWK_LOCALE_DIR} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{GAWK_LOCALE_DIR}
Per il test di traduzioni dei messaggi inviati da @command{gawk} stesso, si pu@`o
impostare la variabile d'ambiente @env{GAWK_LOCALE_DIR}. Si veda la
documentazione per la funzione C @code{bindtextdomain()}, e si veda anche
@ref{Altre variabili d'ambiente}.
@node I18N per programmatore
@section Internazionalizzare programmi @command{awk}
@cindex programmi @command{awk} @subentry internazionalizzare
@cindex internazionalizzazione @subentry di programmi @command{awk}
@command{gawk} prevede le seguenti variabili per l'internazionalizzazione:
@table @code
@cindex @code{TEXTDOMAIN} (variabile)
@cindex variabile @subentry @code{TEXTDOMAIN}
@item TEXTDOMAIN
Questa variabile indica il dominio di testo dell'applicazione.
Per compatibilit@`a con il comando GNU @command{gettext}, il valore di default
@`e @code{"messages"}.
@cindex internazionalizzazione @subentry localizzazione @subentry stringhe marcate
@cindex stringa @subentry marcata @subentry per localizzazione
@item _"questo @`e un messaggio da tradurre"
Costanti di tipo stringa marcate con un trattino basso iniziale
sono candidate per essere tradotte al momento dell'esecuzione del
programma @command{gawk}.
Costanti di tipo stringa non precedute da un trattino basso non
verranno tradotte.
@end table
@command{gawk} fornisce le seguenti funzioni al servizio
dell'internazionalizzazione:
@table @code
@cindexgawkfunc{dcgettext}
@item @code{dcgettext(@var{string}} [@code{,} @var{dominio} [@code{,} @var{categoria}]]@code{)}
Restituisce la traduzione di @var{stringa} nel
dominio di testo @var{dominio} per la categoria di localizzazione @var{categoria}.
Il valore di default per @var{dominio} @`e il valore corrente di @code{TEXTDOMAIN}.
Il valore di default per @var{categoria} @`e @code{"LC_MESSAGES"}.
Se si assegna un valore a @var{categoria}, dev'essere una stringa uguale a
una delle categorie di localizzazione note, descritte
@ifnotinfo
nella precedente @value{SECTION}.
@end ifnotinfo
@ifinfo
@ref{Utilizzare @command{gettext}}.
@end ifinfo
Si deve anche specificare un dominio di testo. Si usi @code{TEXTDOMAIN} se
si desidera usare il dominio corrente.
@quotation ATTENZIONE
L'ordine degli argomenti per la versione @command{awk}
della funzione @code{dcgettext()} @`e differente, per una scelta di progetto,
dall'ordine degli argomenti passati alla funzione C che ha lo stesso nome.
L'ordine della versione @command{awk} @`e stato scelto per amore di
semplicit@`a e per consentire di avere dei valori di default per gli
argomenti che fossero il pi@`u possibile simili, come stile, a quello di
@command{awk}.
@end quotation
@cindexgawkfunc{dcngettext}
@item @code{dcngettext(@var{stringa1}, @var{stringa2}, @var{numero}} [@code{,} @var{dominio} [@code{,} @var{categoria}]]@code{)}
Restituisce la forma, singolare o plurale, da usare a seconda del valore
di @var{numero} per la
traduzione di @var{stringa1} e @var{stringa2} nel dominio di testo
@var{dominio} per la categoria di localizzazione @var{categoria}.
@var{stringa1} @`e la variante al singolare in inglese di un messaggio,
e @var{stringa2} @`e la variante al plurale in inglese dello stesso messaggio.
Il valore di default per @var{dominio} @`e il valore corrente di @code{TEXTDOMAIN}.
Il valore di default per @var{categoria} @`e @code{"LC_MESSAGES"}.
Valgono le stesse osservazioni riguardo all'ordine degli argomenti
fatte a proposito della funzione @code{dcgettext()}.
@cindex @file{.gmo} (file) @subentry specificare la directory di
@cindex file @subentry @file{.gmo} @subentry specificare la directory di
@cindex @dfn{message object} file (@file{.mo}) @subentry specificare la directory di
@cindex file @subentry @dfn{message object} (@file{.mo}) @subentry specificare la directory di
@cindexgawkfunc{bindtextdomain}
@item @code{bindtextdomain(@var{directory}} [@code{,} @var{dominio} ]@code{)}
Cambia la directory nella quale
@command{gettext} va a cercare i file @file{.gmo}, per il caso in cui questi
non possano risiedere nelle posizioni standard
(p.es., in fase di test).
Restituisce la directory alla quale @var{dominio} @`e ``collegato''.
Il @var{dominio} di default @`e il valore di @code{TEXTDOMAIN}.
Se l'argomento @var{directory} @`e impostato alla stringa nulla (@code{""}),
@code{bindtextdomain()} restituisce il collegamento corrente applicabile
al @var{dominio} specificato.
@end table
Per usare queste funzionalit@`a in un programma @command{awk},
va seguita la procedura qui indicata:
@enumerate
@cindex @code{BEGIN} (regola) @subentry variabile @code{TEXTDOMAIN} e
@cindex regola @subentry @code{BEGIN} @subentry variabile @code{TEXTDOMAIN} e
@cindex @code{TEXTDOMAIN} (variabile) @subentry @code{BEGIN} (regola) e
@cindex variabile @subentry @code{TEXTDOMAIN} @subentry @code{BEGIN} (regola) e
@item
Impostare la variabile @code{TEXTDOMAIN} al dominio di testo del
programma. @`E meglio fare ci@`o all'interno di una regola @code{BEGIN}
(@pxref{BEGIN/END}),
ma si pu@`o anche fare dalla riga di comando, usando l'opzione @option{-v}
(@pxref{Opzioni}):
@example
BEGIN @{
TEXTDOMAIN = "guide"
@dots{}
@}
@end example
@cindex @code{_} (trattino basso) @subentry stringa traducibile
@cindex trattino basso (@code{_}) @subentry stringa traducibile
@item
Marcare tutte le stringhe traducibili anteponendo loro un
trattino basso (@samp{_}). Il trattino @emph{deve} essere adiacente ai
doppi apici di apertura della stringa. Per esempio:
@example
print _"hello, world"
x = _"you goofed"
printf(_"Number of users is %d\n", nusers)
@end example
@item
Se le stringhe da visualizzare sono create dinamicamente, @`e ancora possibile
tradurle, usando la funzione predefinita @code{dcgettext()}:@footnote{I miei
ringraziamenti a Bruno Haible per questo esempio.}
@example
if (assonnato)
messaggio = dcgettext("%d clienti mi scocciano\n", "adminprog")
else
messaggio = dcgettext("mi diverto con %d clienti\n", "adminprog")
printf(messaggio, numero_clienti)
@end example
In questo esempio, la chiamata a @code{dcgettext()} specifica un diverso
dominio di testo (@code{"adminprog"}) in cui trovare il
messaggio, ma usa la categoria di default @code{"LC_MESSAGES"}.
Il precedente esempio funziona solo se @code{numero_clienti} @`e un numero maggiore
di uno.
Per questo esempio sarebbe pi@`u appropriato usare la funzione @code{dcngettext()}:
@example
if (assonnato)
messaggio = dcngettext("%d cliente mi scoccia\n",
"%d clienti mi scocciano\n",
numero_clienti, "adminprog")
else
messaggio = dcngettext("mi diverto con %d cliente\n",
"mi diverto con %d clienti\n",
numero_clienti, "adminprog")
printf(messaggio, numero_clienti)
@end example
@cindex @code{LC_MESSAGES} (variabile d'ambiente) @subentry categoria di localizzazione @subentry funzione @code{bindtextdomain()} di (@command{gawk})
@item
In fase di sviluppo, si pu@`o scegliere di tenere il file @file{.gmo}
in una directory a parte, solo per provarlo. Ci@`o si fa
con la funzione predefinita @code{bindtextdomain()}:
@example
BEGIN @{
TEXTDOMAIN = "guide" # dominio di testo regolare
if (Testing) @{
# dove trovare il file in prova
bindtextdomain("testdir")
# joe si occupa del programma adminprog
bindtextdomain("../joe/testdir", "adminprog")
@}
@dots{}
@}
@end example
@end enumerate
@xref{Esempio I18N}
per un programma di esempio che illustra i passi da seguire per creare
e usare traduzioni nei programmi @command{awk}.
@node I18N per traduttore
@section Traduzione dei programmi @command{awk}
@cindex @file{.po} (file)
@cindex file @subentry @file{.po}
@cindex @dfn{portable object} file (@file{.po})
@cindex file @subentry @dfn{portable object} (@file{.po})
Dopo aver marcato le stringhe che si desidera tradurre in un programma,
queste vanno estratte per creare il file iniziale @file{.pot}.
Durante la traduzione, @`e spesso utile modificare l'ordine nel quale
gli argomenti passati a @code{printf} vengono stampati.
L'opzione da riga di comando @option{--gen-pot} di @command{gawk} serve a
estrarre i messaggi, ed @`e esposta qui di seguito.
Dopo di che, verr@`a illustrata la possibilit@`a di modificare l'ordine
in cui l'istruzione @code{printf} stampa gli argomenti che le sono passati
in fase di esecuzione.
@menu
* Estrazione di stringhe:: Estrarre stringhe marcate.
* Ordinamento di printf:: Riordinare argomenti @code{printf}
* Portabilit@`a nell'I18N:: Problemi di portabilit@`a a livello di @command{awk}.
@end menu
@node Estrazione di stringhe
@subsection Estrarre stringhe marcate
@cindex stringa @subentry estrazione di
@cindex @option{--gen-pot} (opzione)
@cindex opzione @subentry @option{--gen-pot}
@cindex opzioni @subentry sulla riga di comando @subentry estrazione stringhe
@cindex riga di comando @subentry opzioni @subentry estrazione stringhe
@cindex stringa @subentry marcata @subentry estrazione di (internazionalizzazione)
@cindex marcate @subentry estrazione di stringhe (internazionalizzazione)
@cindex estrazione di stringhe marcate (internazionalizzazione)
@cindex @option{--gen-pot} (opzione)
@cindex opzione @subentry @option{--gen-pot}
Una volta che il programma @command{awk} funziona, e tutte le stringhe
sono state marcate ed @`e stato impostato (e forse fissato) il dominio di
testo, @`e ora di preparare le traduzioni.
Per prima cosa, usando l'opzione di riga di comando @option{--gen-pot},
si crea il file iniziale @file{.pot}:
@example
gawk --gen-pot -f guide.awk > guide.pot
@end example
@cindex @code{xgettext} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @code{xgettext}
Quando viene chiamato specificando @option{--gen-pot}, @command{gawk} non
esegue il programma. Il programma viene esaminato come al solito, e tutte
le stringhe che sono state marcate per essere tradotte vengono scritte nello
standard output, nel formato di un file Portable Object di GNU
@command{gettext}.
L'output comprende anche quelle stringhe costanti che appaiono come primo
argomento della funzione @code{dcgettext()} o come primo e secondo
argomento della funzione @code{dcngettext()}.@footnote{Il comando di utilit@`a
@command{xgettext} che fa parte del pacchetto distribuito come
@command{gettext} @`e in grado di gestire i file di tipo @file{.awk}.}
Il file @file{.pot} cos@`{@dotless{i}} generato
andrebbe distribuito insieme al programma @command{awk}; i traduttori
potranno eventualmente utilizzarlo per preparare delle traduzioni, le quali
potranno a loro volta essere distribuite.
@xref{Esempio I18N}
per una lista esauriente dei passi necessari per creare e testare
traduzioni per il programma @command{guide}.
@node Ordinamento di printf
@subsection Riordinare argomenti di @code{printf}
@cindex @code{printf} (istruzione) @subentry specificatori di posizione
@cindex istruzione @subentry @code{printf} @subentry specificatori di posizione
@cindex posizione @subentry specificatori di @subentry istruzione @code{printf}
@cindex specificatori di posizione @subentry istruzione @code{printf}
Le stringhe di formattazione per @code{printf} e @code{sprintf()}
(@pxref{Printf})
hanno un problema speciale con le traduzioni.
Si consideri il seguente esempio:@footnote{Questo esempio @`e preso in
prestito dal manuale del comando GNU @command{gettext}.}
@example
printf(_"String `%s' has %d characters\n",
string, length(string)))
@end example
Una possibile traduzione in italiano di questo messaggio potrebbe essere:
@example
"%d @`e la lunghezza della stringa `%s'\n"
@end example
Il problema dovrebbe essere ovvio: l'ordine delle specifiche di
formattazione @`e differente da quello originale!
@code{gettext()}, che pure pu@`o restituire la stringa tradotta
in fase di esecuzione, non @`e in grado di cambiare l'ordine degli argomenti
nella chiamata a @code{printf}.
Per risolvere questo problema, gli specificatori di formato di @code{printf}
possono avere un elemento in pi@`u, opzionale, detto @dfn{specificatore
di posizione}. Per esempio:
@example
"%2$d @`e la lunghezza della stringa `%1$s'\n"
@end example
Qui, lo specificatore di posizione consiste in un numero intero, che indica
quale argomento utilizzare, seguito da un carattere @samp{$}.
I numeri partono da uno, e la stringa di formattazione vera e propria
@emph{non} @`e inclusa. Quindi, nell'esempio seguente, @samp{stringa} @`e
il primo argomento e @samp{length(stringa)} @`e il secondo:
@example
$ @kbd{gawk 'BEGIN @{}
> @kbd{stringa = "Non v\47allarmate!"}
> @kbd{printf "%2$d caratteri compongono \"%1$s\"\n",}
> @kbd{stringa, length(stringa)}
> @kbd{@}'}
@print{} 16 caratteri compongono "Non v\47allarmate!"
@end example
Se presenti, gli specificatori di posizione precedono, nella specifica di
formato, i flag, la larghezza del campo e/o la precisione.
Gli specificatori di posizione possono essere usati anche se si specifica una
larghezza dinamica dei campi, e della capacit@`a di precisione:
@example
$ @kbd{gawk 'BEGIN @{}
> @kbd{printf("%*.*s\n", 10, 20, "hello")}
> @kbd{printf("%3$*2$.*1$s\n", 20, 10, "hello")}
> @kbd{@}'}
@print{} hello
@print{} hello
@end example
@quotation NOTA
Se si usa @samp{*} con uno specificatore di posizione, il carattere @samp{*}
viene per primo, seguito dal numero che indica la posizione, a sua volta
seguito dal @samp{$}.
Ci@`o pu@`o parere poco intuitivo.
@end quotation
@cindex istruzione @subentry @code{printf} @subentry specificatori di posizione, frammisti a formati standard
@cindex @code{printf} (istruzione) @subentry specificatori di posizione @subentry frammisti a formati standard
@cindex specificatori di posizione @subentry istruzione @code{printf} @subentry frammisti a formati standard
@cindex formato @subentry specificatori di posizione @subentry frammisti a specificatori non standard
@cindex specificatori di formato @subentry frammisti a specificatori di posizione non standard
@command{gawk} non consente di mischiare specificatori di formato standard
con altri contenenti degli specificatori di posizione in una stessa stringa di
formato:
@example
@group
$ @kbd{gawk 'BEGIN @{ printf "%d %3$s\n", 1, 2, "ciao" @}'}
@error{} gawk: riga com.:1: fatale: `count$' va usato per tutti
@error{} i formati o per nessuno
@end group
@end example
@quotation NOTA
Ci sono alcuni casi patologici in cui @command{gawk} potrebbe non inviare
alcun messaggio diagnostico, anche quando sarebbe necessario.
In tali casi, l'output pu@`o non essere quello atteso.
Rimane sempre una pessima idea quella di tentare di mischiare i formati,
anche se @command{gawk} non riesce ad accorgersene.
@end quotation
Sebbene gli specificatori di posizione possano essere usati direttamente nei
programmi @command{awk}, il motivo per cui sono stati introdotti @`e perch@'e
siano d'aiuto nel produrre traduzioni corrette della stringa di
formattazione in lingue differenti da quella nella quale il programma @`e stato
originariamente scritto.
@node Portabilit@`a nell'I18N
@subsection Problemi di portabilit@`a a livello di @command{awk}
@cindex portabilit@`a @subentry internazionalizzazione e
@cindex internazionalizzazione @subentry localizzazione @subentry portabilit@`a e
Le funzionalit@`a di internazionalizzazione di @command{gawk} sono state
appositamente implementate per avere il minimo impatto possibile sulla
portabilit@`a, verso altre versioni di @command{awk}, dei programmi
@command{awk} che ne fanno uso.
Si consideri questo programma:
@example
BEGIN @{
TEXTDOMAIN = "guide"
if (Test_Guide) # da impostare tramite -v
bindtextdomain("/test/guide/messages")
print _"don't panic!"
@}
@end example
@noindent
Per il modo in cui @`e scritto, non funzioner@`a con altre versioni di
@command{awk}.
Tuttavia, @`e in realt@`a quasi portabile, e richiede modifiche minime:
@itemize @value{BULLET}
@cindex @code{TEXTDOMAIN} (variabile) @subentry portabilit@`a e
@cindex variabile @subentry @code{TEXTDOMAIN} @subentry portabilit@`a e
@item
Le assegnazioni di valori a @code{TEXTDOMAIN} non avranno effetto alcuno,
perch@'e @code{TEXTDOMAIN} non @`e una variabile speciale in altre
implementazioni di @command{awk}.
@item
Versioni Non-GNU di @command{awk} considerano le stringhe marcate
come la concatenazione di una variabile di nome @code{_} con la stringa che
viene subito dopo.@footnote{Questo @`e
un buon materiale per una gara di ``Oscurit@`a @command{awk}''.}
Tipicamente, la variabile @code{_} ha come valore la stringa nulla
(@code{""}), il che produce come risultato la stringa
originale.
@item
Definendo delle funzioni ``fittizie'' per sostituire @code{dcgettext()},
@code{dcngettext()} e @code{bindtextdomain()}, il programma @command{awk}
pu@`o essere reso eseguibile, ma
tutti i messaggi verranno inviati nella lingua originale del programma.
Per esempio:
@cindex @code{bindtextdomain()} (funzione @command{gawk}) @subentry portabilit@`a e
@cindex funzione @subentry @code{bindtextdomain()} (@command{gawk}) @subentry portabilit@`a e
@cindex @code{dcgettext()} (funzione @command{gawk}) @subentry portabilit@`a e
@cindex funzione @subentry @code{dcgettext()} (@command{gawk}) @subentry portabilit@`a e
@cindex @code{dcngettext()} (funzione @command{gawk}) @subentry portabilit@`a e
@cindex funzione @subentry @code{dcngettext()} (@command{gawk}) @subentry portabilit@`a e
@example
@c file eg/lib/libintl.awk
function bindtextdomain(dir, domain)
@{
return dir
@}
function dcgettext(string, domain, category)
@{
return string
@}
function dcngettext(string1, string2, number, domain, category)
@{
return (number == 1 ? string1 : string2)
@}
@c endfile
@end example
@item
L'uso di specificazioni di posizione in @code{printf} o
@code{sprintf()} @emph{non} @`e portabile.
Per supportare @code{gettext()} nella programmazione in linguaggio C,
molte versioni C di @code{sprintf()} supportano specificatori di posizione.
Ma la cosa funziona solo se nella chiamata di funzione sono stati specificati
argomenti a sufficienza. Molte
versioni di @command{awk} passano i formati e gli argomenti di @code{printf},
senza modificarli, alla funzione di libreria in linguaggio C @code{sprintf()},
ma solo un formato e un argomento alla volta. Quel che succede se si usa una
specificazione di posizione resta indeterminato.
Tuttavia, poich@'e le specificazioni di posizione sono usate principalmente
per le stringhe di formattazione @emph{tradotte}, e poich@'e le versioni
non-GNU di @command{awk} non utilizzano mai le stringhe tradotte, ci@`o non
dovrebbe, in pratica, causare problemi.
@end itemize
@node Esempio I18N
@section Un semplice esempio di internazionalizzazione.
Vediamo ora un esempio dettagliato di come internazionalizzare e localizzare
un semplice programma @command{awk}, usando come nostro programma sorgente
originale il file @file{guide.awk}:
@example
@c file eg/prog/guide.awk
BEGIN @{
TEXTDOMAIN = "guide"
bindtextdomain(".") # per la fase di test
print _"Don't Panic"
print _"The Answer Is", 42
print "Pardon me, Zaphod who?"
@}
@c endfile
@end example
@noindent
Eseguire @samp{gawk --gen-pot} per creare il file @file{.pot}:
@example
$ @kbd{gawk --gen-pot -f guide.awk > guide.pot}
@end example
@noindent
Questo produce:
@example
@c file eg/data/guide.po
#: guide.awk:4
msgid "Don't Panic"
msgstr ""
#: guide.awk:5
msgid "The Answer Is"
msgstr ""
@c endfile
@end example
Questo modello di @dfn{portable object} va salvato e riutilizzato per ogni
lingua in cui l'applicazione viene tradotta. La stringa @code{msgid} @`e
seguita dalla stringa originale da tradurre, e la stringa @code{msgstr}
conterr@`a la traduzione.
@quotation NOTA
Le stringhe non aventi come prefisso un trattino basso non sono inserite
nel file @file{guide.pot}.
@end quotation
Successivamente, i messaggi devono essere tradotti.
Questa @`e una traduzione in un ipotetico dialetto dell'inglese,
chiamato ``Mellow'':@footnote{Forse sarebbe meglio chiamarlo
``Hippy.'' Meglio non indagare oltre.}
@example
@group
$ @kbd{cp guide.pot guide-mellow.po}
@var{Aggiungere traduzioni al file} guide-mellow.po @dots{}
@end group
@end example
@noindent
Ecco le traduzioni:
@example
@c file eg/data/guide-mellow.po
#: guide.awk:4
msgid "Don't Panic"
msgstr "Hey man, relax!"
#: guide.awk:5
msgid "The Answer Is"
msgstr "Like, the scoop is"
@c endfile
@end example
@cindex GNU/Linux
@quotation NOTA
Le istruzione che seguono valgono per un ambiente GNU/Linux con la
Libreria GNU C. Fate attenzione! I passi descritti possono
variare col tempo, e la descrizione seguente pu@`o non essere accurata
per tutte le distribuzione GNU/Linux, e la procedura pu@`o essere
interamente differente per altri sistemi operativi.
@end quotation
Il passo successivo @`e di creare la directory che contenga il file binario
con le traduzioni dei messaggi (file .mo [message object]) e
creare in quella directory il file @file{guide.mo}.
La directory ha un nome del tipo @file{@var{locale}/LC_MESSAGES}, dove
@var{locale} @`e un nome di localizzazione noto alle routine C
di @command{gettext}.
@cindex @env{LANGUAGE} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{LANGUAGE}
@cindex @env{LC_ALL} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{LC_ALL}
@cindex @env{LANG} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{LANG}
@cindex @env{LC_MESSAGES} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{LC_MESSAGES}
Come sapere quale localizzazione usare? Le routine C di @command{gettext}
usano quattro variabili d'ambiente. Esse sono, nell'ordine:
@env{$LANGUAGE}, @env{$LC_ALL}, @env{$LANG}, e
@env{$LC_MESSAGES}.@footnote{Pi@`u o meno... In effetti sembra che quando
la variabile d'ambiente @env{$LC_ALL} @`e impostata al valore @samp{C},
non viene effettuata alcuna traduzione. Vai a capire...}
Quindi, noi controlliamo il valore di @env{$LANGUAGE}:
@example
$ @kbd{echo $LANGUAGE}
@print{} en_US.UTF-8
@end example
@noindent
Il passo successivo @`e creare le directory:
@example
$ @kbd{mkdir en_US.UTF-8 en_US.UTF-8/LC_MESSAGES}
@end example
@cindex @file{.po} (file) @subentry conversione in @file{.mo}
@cindex file @subentry @file{.po} @subentry conversione in @file{.mo}
@cindex @file{.mo} (file) @subentry conversione da @file{.po}
@cindex file @subentry @file{.mo} @subentry conversione da @file{.po}
@cindex @dfn{portable object} file (@file{.po}) @subentry conversione in @dfn{message object} file
@cindex file @subentry @dfn{portable object} (@file{.po}) @subentry conversione in @dfn{message object} file
@cindex @dfn{message object} file (@file{.mo}) @subentry conversione da @dfn{portable object} file
@cindex file @subentry @dfn{message object} (@file{.mo}) @subentry conversione da @dfn{portable object} file
@cindex @command{msgfmt} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{msgfmt}
Il programma di utilit@`a @command{msgfmt} effettua la conversione del file
leggibile, in formato testo, @file{.po} nel file, in formato binario,
@file{.mo}.
Per default, @command{msgfmt} crea un file di nome @file{messages}.
A questo file dev'essere assegnato un nome appropriato, e va messo nella
directory predisposta (usando l'opzione @option{-o}) in modo che
@command{gawk} sia in grado di trovarlo:
@example
$ @kbd{msgfmt guide-mellow.po -o en_US.UTF-8/LC_MESSAGES/guide.mo}
@end example
Infine, eseguiamo il programma per provare se funziona:
@example
$ @kbd{gawk -f guide.awk}
@print{} Hey man, relax!
@print{} Like, the scoop is 42
@print{} Pardon me, Zaphod who?
@end example
Se le tre funzioni che rimpiazzano @code{dcgettext()}, @code{dcngettext()},
e @code{bindtextdomain()}
(@pxref{Portabilit@`a nell'I18N})
sono contenute in un file di nome @file{libintl.awk},
@`e possibile eseguire @file{guide.awk} senza modificarlo, nel modo seguente:
@example
$ @kbd{gawk --posix -f guide.awk -f libintl.awk}
@print{} Don't Panic
@print{} The Answer Is 42
@print{} Pardon me, Zaphod who?
@end example
@node Gawk internazionalizzato
@section @command{gawk} stesso @`e internazionalizzato
Il comando @command{gawk} stesso @`e stato internazionalizzato
usando il pacchetto GNU @command{gettext}.
(GNU @command{gettext} @`e descritto in
maniera esauriente in
@ifinfo
@inforef{Top, , GNU @command{gettext} utilities, gettext, GNU @command{gettext} utilities}.)
@end ifinfo
@ifnotinfo
@uref{https://www.gnu.org/software/gettext/manual/,
@cite{GNU @command{gettext} utilities}}.)
@end ifnotinfo
Al momento in cui questo libro @`e stato scritto, la versione pi@`u recente di
GNU @command{gettext} @`e
@uref{ftp://ftp.gnu.org/gnu/gettext/gettext-0.19.8.1.tar.gz,
@value{PVERSION} 0.19.8.1}.
Se esiste una traduzione dei messaggi di @command{gawk},
@command{gawk} invia messaggi, avvertimenti, ed errori fatali
utilizzando la lingua locale.
@node Sommario I18N
@section Sommario
@itemize @value{BULLET}
@item
Internazionalizzazione significa scrivere un programma in modo che
possa interagire in molte lingue senza che sia necessario cambiare il codice
sorgente.
Localizzazione significa fornire i dati necessari perch@'e un programma
internazionalizzato possa interagire usando una determinata lingua.
@item
@command{gawk} usa il comando GNU @command{gettext} per consentire
l'internazionalizzazione e la localizzazione di programmi @command{awk}.
Un dominio di testo di un programma identifica il programma, e consente di
raggruppare tutti i messaggi e gli altri dati del programma in un solo posto.
@item
Si marcano le stringhe in un programma da tradurre preponendo loro un
trattino basso. Una volta fatto questo, queste stringhe sono estratte
in un file @file{.pot}. Questo file @`e copiato, per ogni lingua, in un file
@file{.po} e i file @file{.po} sono
compilati in file @file{.gmo} che saranno usati in fase di
esecuzione del programma.
@item
@`E possibile usare specificazioni di posizione con le istruzioni
@code{sprintf()} e @code{printf} per modificare la posizione del valore
degli argomenti nelle stringhe di formato e nell'output. Ci@`o @`e utile nella
traduzione di stringhe di
formattazione dei messaggi.
@item
Le funzionalit@`a di internazionalizzazione sono state progettate in modo
da poter essere facilmente gestite in un programma @command{awk} standard.
@item
Anche il comando @command{gawk} @`e stato internazionalizzato e viene
distribuito con traduzioni in molte lingue dei messaggi inviati in fase di
esecuzione.
@end itemize
@node Debugger
@chapter Effettuare il debug dei programmi @command{awk}
@cindex debug @subentry dei programmi @command{awk}
@cindex programmi @command{awk} @subentry debug dei
@c The original text for this chapter was contributed by Efraim Yawitz.
Sarebbe bello se i programmi per il calcolatore funzionassero perfettamente la
prima volta che vengono eseguiti, ma nella vita reale questo accade raramente,
qualunque sia la complessit@`a dei programmi. Perci@`o la maggior parte dei
linguaggi di programmazione hanno a disposizione degli strumenti che facilitano
la ricerca di errori (@dfn{debugging}) nei programmi, e @command{awk} non fa
eccezione.
Il @dfn{debugger} di @command{gawk} @`e di proposito costruito sul modello del
debugger da riga di comando
@uref{https://www.gnu.org/software/gdb/, GNU Debugger (GDB)}.
Se si ha familiarit@`a con GDB, sar@`a facile imparare come usare @command{gawk}
per eseguire il debug dei propri programmi.
@menu
* Debugging:: Introduzione al debugger di @command{gawk}.
* Esempio di sessione di debug:: Esempio di sessione di debug.
* Lista dei comandi di debug:: Principali comandi di debug.
* Supporto per Readline:: Supporto per Readline.
* Limitazioni:: Limitazioni e piani per il futuro.
* Sommario sul debug:: Sommario sul debug.
@end menu
@node Debugging
@section Introduzione al debugger di @command{gawk}
Questa @value{SECTION}, dopo un'introduzione sul debug in generale, inizia
la trattazione del debug in @command{gawk}.
@menu
* Nozioni sul debug:: Generalit@`a sul debug.
* Terminologia nel debug:: Ulteriori nozioni sul debug.
* Debug di Awk:: Eseguire il debug di Awk.
@end menu
@node Nozioni sul debug
@subsection Generalit@`a sul debug
(Se si sono usati dei debugger in altri linguaggi, si pu@`o andare direttamente
alla @ref{Debug di Awk}.)
Naturalmente, un programma di debug non pu@`o correggere gli errori al posto del
programmatore, perch@'e non pu@`o sapere quello che il programmatore o gli utenti
considerano un ``bug'' e non una ``funzionalit@`a''. (Talvolta, anche noi umani
abbiamo difficolt@`a nel determinarlo.)
In quel caso, cosa ci si pu@`o aspettare da un tale strumento? La risposta
dipende dal linguaggio su cui si effettua il debug, comunque in generale ci si
pu@`o attendere almeno questo:
@cindex debugger @subentry funzionalit@`a del
@itemize @value{BULLET}
@item
La possibilit@`a di osservare l'esecuzione delle istruzioni di un programma una
per una, dando al programmatore l'opportunit@`a di pensare a quel che accade a
una scala temporale di secondi, minuti od ore, piuttosto che alla scala dei
nanosecondi alla quale normalmente viene eseguito il codice.
@item
L'opportunit@`a, non solo di osservare passivamente le operazioni del progamma,
ma di controllarlo e tentare diversi percorsi di esecuzione, senza dover
modificare i file sorgenti.
@item
La possibilit@`a di vedere i valori o i dati nel programma in qualsiasi punto
dell'esecuzione, e anche di cambiare i dati al volo, per vedere come questo
influisca su ci@`o che accade dopo. (Questo include spesso la capacit@`a di
esaminare le strutture interne dei dati oltre alle variabili che
sono state effettivamente definite nel codice del programma.)
@item
La possibilit@`a di ottenere ulteriori informazioni sullo stato del programma
o anche sulle sue strutture interne.
@end itemize
Tutti questi strumenti sono di grande aiuto e permettono di usare l'abilit@`a
che si possiede e la comprensione che si ha degli obiettivi del programma
per trovare dove si verificano i problemi (o, in alternativa, per
comprendere meglio la logica di un programma funzionante, di cui si sia
l'autore, o anche di un programma scritto da altri).
@node Terminologia nel debug
@subsection Concetti fondamentali sul debug
@cindex debugger @subentry terminologia
Prima di entrare nei dettagli, dobbiamo introdurre diversi
importanti concetti che valgono per tutti i debugger.
La seguente lista definisce i termini usati nel resto di
questo @value{CHAPTER}:
@table @dfn
@cindex @dfn{stack} (pila) delle chiamate @subentry nel debugger
@cindex debugger @subentry @dfn{stack} di chiamata
@cindex debugger @subentry pila di chiamata
@cindex @dfn{stack frame} (debugger)
@cindex debugger @subentry @dfn{stack frame}
@item @dfn{Stack frame}
Durante la loro esecuzione i programmi normalmente chiamano delle funzioni.
Una funzione pu@`o a sua volta chiamarne un'altra, o pu@`o richiamare se stessa
(ricorsione). La
catena di funzioni chiamate (il programma principale chiama A, che chiama B,
che chiama C) pu@`o essere vista come una pila di funzioni in esecuzione: la
funzione correntemente in esecuzione @`e quella in cima alla pila, e quando
questa finisce (ritorna al chiamante),
quella immediatamente sotto diventa la funzione
attiva. Tale pila (@dfn{stack}) @`e chiamata @dfn{call stack} (pila delle chiamate).
Per ciascuna funzione della pila delle chiamate (@dfn{call stack}), il sistema
mantiene un'area di dati che contiene i parametri della funzione, le variabili
locali e i codici di ritorno, e anche ogni altra informazione ``contabile''
necessaria per gestire la pila delle chiamate. Quest'area di dati @`e chiamata
@dfn{stack frame}.
Anche @command{gawk} segue questo modello, e permette l'accesso alla pila
delle chiamate e a ogni @dfn{stack frame}. @`E possibile esaminare la pila
delle chiamate, e anche sapere da dove ciascuna funzione sulla pila @`e stata
invocata. I comandi che stampano la pila delle chiamate stampano anche le
informazioni su ogni @dfn{stack frame} (come vedremo pi@`u avanti in dettaglio).
@item Punto d'interruzione
@cindex @code{breakpoint} (comando del debugger)
@cindex punto d'interruzione @subentry (@code{breakpoint})
@cindex debugger @subentry @code{breakpoint}
@cindex debugger @subentry punto d'interruzione
Durante le operazioni di debug, spesso si preferisce lasciare che il programma
venga eseguito finch@'e non raggiunge un certo punto, e da quel punto in poi si
continua l'esecuzione un'istruzione alla volta. Il modo per farlo @`e quello di
impostare un @dfn{punto d'interruzione} all'interno del programma. Un punto
d'interruzione @`e il punto dove l'esecuzione del programma dovrebbe
interrompersi (fermarsi), in modo da assumere il controllo dell'esecuzione del
programma. Si possono aggiungere e togliere quanti punti d'interruzione si
vogliono.
@item Punto d'osservazione
@cindex @dfn{watchpoint} (debugger)
@cindex punto d'osservazione @subentry(@code{watchpoint})
@cindex debugger @subentry @code{watchpoint}
@cindex debugger @subentry punto d'osservazione
Un punto d'osservazione @`e simile a un punto d'interruzione. La differenza @`e
che i punti d'interruzione sono orientati attorno al codice; fermano il
programma quando viene raggiunto un certo punto nel codice. Un punto
d'osservazione, invece, fa fermare il programma quando @`e stato
cambiato il @emph{valore di un dato}. Questo @`e utile, poich@'e a volte succede
che una variabile riceva un valore errato, ed @`e difficile rintracciare il punto
dove ci@`o accade solo leggendo il codice sorgente.
Usando un punto d'osservazione, si pu@`o fermare il programma in qualunque punto
vi sia un'assegnazione di variabile, e di solito si individua il codice che
genera l'errore abbastanza velocemente.
@end table
@node Debug di Awk
@subsection Il debug di @command{awk}
Il debug di un programma @command{awk} ha delle particolarit@`a proprie, che
non sono presenti in programmi scritti in altri linguaggi.
Prima di tutto, il fatto che i programmi @command{awk} ricevano generalmente
l'input riga per riga da uno o pi@`u file e operino su tali righe usando regole
specifiche, rende particolarmente agevole organizzare l'esame
dell'esecuzione del programma facendo riferimento a tali regole.
Come vedremo, ogni
regola @command{awk} viene trattata quasi come una chiamata di funzione, col
proprio specifico blocco di istruzioni.
Inoltre, poich@'e @command{awk} @`e un linguaggio deliberatamente molto
conciso, @`e facile perdere di vista tutto ci@`o che avviene ``dentro''
ogni riga di codice @command{awk}. Il debugger d@`a l'opportunit@`a di
guardare le singole istruzioni primitive la cui esecuzione @`e innescata
dai comandi di alto livello di @command{awk}.@footnote{Le ``istruzioni
primitive'' sono quelle dallo stesso @command{gawk}; il debugger
non permette di arrivare al livello delle istruzioni hardware della
macchina.}
@node Esempio di sessione di debug
@section Esempio di sessione di debug di @command{gawk}
@cindex esempio @subentry di sessione di debug
@cindex debug @subentry esempio di sessione
Per illustrare l'uso di @command{gawk} come debugger, vediamo un esempio di
sessione di debug. Come esempio verr@`a usata un'implementazione @command{awk}
(con errori)
del comando POSIX @command{uniq} descritta in precedenza (@pxref{Programma
uniq}).
@menu
* Invocazione del debugger:: Come far partire il debugger.
* Trovare il bug:: Trovare il bug.
@end menu
@node Invocazione del debugger
@subsection Come avviare il debugger
@cindex avviare il debugger
@cindex debugger @subentry come avviarlo
@cindex debugger @subentry comandi del @seeentry{comando del debugger}
Per avviare il debugger in @command{gawk} si richiama il comando esattamente
come al solito, specificando solo un'opzione aggiuntiva,
@option{--debug}, o la corrispondente opzione breve @option{-D}.
I file (o il file) che contengono
il programma e ogni codice ulteriore sono immessi sulla riga di comando come
argomenti a una o pi@`u opzioni @option{-f}. (@command{gawk} non @`e progettato per
eseguire il debug di programmi scritti sulla riga di comando, ma solo per
quello di programmi che risiedono su file.)
Nel nostro caso, il debugger verr@`a invocato in questo modo:
@example
$ @kbd{gawk -D -f getopt.awk -f join.awk -f uniq.awk -1 file_di_input}
@end example
@noindent
dove entrambi i file @file{getopt.awk} e @file{uniq.awk} sono in @env{$AWKPATH}.
(Gli utenti esperti di GDB o debugger simili dovrebbero tener presente che
questa sintassi @`e leggermente differente da quello che sono abituati a usare.
Col debugger di @command{gawk}, si danno gli argomenti per eseguire il
programma nella riga di comando al debugger piuttosto che come parte del
comando @code{run} al prompt del debugger.)
L'opzione @option{-1} @`e un'opzione per @file{uniq.awk}.
@cindex debugger @subentry prompt
@cindex prompt del debugger
Invece di eseguire direttamente il programma sul @file{file_di_input}, come
@command{gawk} farebbe normalmente, il debugger semplicemente carica
i file sorgenti del programma, li compila internamente, e poi mostra
la riga d'invito:
@example
gawk>
@end example
@noindent
da dove si possono impartire i comandi al debugger. Sin qui non @`e
stato ancora eseguito nessun codice.
@node Trovare il bug
@subsection Trovare il bug
Poniamo di avere un problema usando una versione (difettosa) di
@file{uniq.awk} in modalit@`a ``salta-campi'', perch@'e sembra non
trovare le righe che sono identiche a condizione di saltare il primo
campo, come:
@example
awk, ecco un programma meraviglioso!
gawk, ecco un programma meraviglioso!
@end example
Questo potrebbe accadere se noi pensassimo (come in C) che i campi in un record
siano numerati prendendo come base lo zero, per cui, invece di scrivere:
@example
campi_ultima = join(vettore_ultima, contatore_file+1, n)
campi_corrente = join(vettore_corrente, contatore_file+1, m)
@end example
@noindent
abbiamo scritto:
@example
campi_ultima = join(vettore_ultima, contatore_file, n)
campi_corrente = join(vettore_corrente, contatore_file, m)
@end example
La prima cosa da fare quando si tenta di indagare su un problema come questo @`e
quella di mettere un punto d'interruzione (@dfn{breakpoint}) nel programma, in modo
da poterlo vedere al lavoro e catturare quello che non va. Una posizione
ragionevole per un punto d'interruzione in @file{uniq.awk} @`e all'inizio della
funzione @code{se_sono_uguali()}, che confronta la riga corrente con la precedente.
Per impostare il punto d'interruzione, usare il comando @code{b} (@dfn{breakpoint}):
@cindex debugger @subentry impostare un punto d'interruzione
@cindex @code{breakpoint} (comando del debugger)
@cindex comando del debugger @subentry @code{breakpoint}
@cindex @code{break} (comando del debugger)
@cindex comando del debugger @subentry @code{break}
@cindex @code{b} (comando del debugger)
@cindex comando del debugger @subentry @code{b} (alias per @code{break})
@example
gawk> @kbd{b se_sono_uguali}
@print{} Breakpoint 1 impostato al file `uniq.awk', riga 63
@end example
Il debugger mostra il file e il numero di riga dove si trova il punto
d'interruzione. Ora bisogna immettere @samp{r} o @samp{run} e il programma
viene eseguito fino al primo punto d'interruzione:
@cindex debugger @subentry eseguire il programma
@cindex comando del debugger @subentry @code{run}
@cindex @code{run} (comando del debugger)
@example
gawk> @kbd{r}
@print{} Partenza del programma:
@print{} Mi fermo in Rule ...
@print{} Breakpoint 1, se_sono_uguali(n, m, campi_ultima, campi_corrente,
@print{} vettore_ultima, vettore_corrente)
@print{} a `uniq.awk':63
@print{} 63 if (contatore_file == 0 && conta_caratteri == 0)
gawk>
@end example
Ora possiamo osservare cosa accade all'interno del nostro programma.
Prima di tutto, vediamo come siamo arrivati a questo punto. Sulla riga di
comando battiamo @samp{bt} (che sta per ``backtrace''), e il debugger risponde
con un listato degli @dfn{stack frame} correnti:
@cindex debugger @subentry elementi pila @subentry visualizzazione
@cindex comando del debugger @subentry @code{bt} (alias per @code{backtrace})
@cindex @code{bt} (comando del debugger) @subentry (alias per @code{backtrace})
@cindex comando del debugger @subentry @code{backtrace}
@cindex @code{backtrace} (comando del debugger)
@example
gawk> @kbd{bt}
@print{} #0 se_sono_uguali(n, m, campi_ultima, campi_corrente,
@print{} vettore_ultima, vettore_corrente)
@print{} a `uniq.awk':63
@print{} #1 in main() a `uniq.awk':88
@end example
Questo ci dice che la funzione @code{se_sono_uguali()} @`e stata chiamata
dal programma principale alla riga 88 del file @file{uniq.awk}. (Questo non
sorprende, perch@'e @`e questa l'unica chiamata a @code{se_sono_uguali()} nel
programma, per@`o in programmi
pi@`u complessi, sapere chi ha chiamato una funzione e con quali parametri pu@`o
essere la chiave per trovare l'origine del problema.)
Ora che siamo in @code{se_sono_uguali()}, possiamo iniziare a guardare i valori di
alcune variabili. Immaginiamo di battere @samp{p n}
(@code{p} sta per @dfn{print} [stampa]). Ci aspetteremo di vedere il valore di
@code{n}, un parametro di @code{se_sono_uguali()}. In realt@`a, il debugger
ci d@`a:
@cindex comando del debugger @subentry @code{print}
@cindex @code{print} (comando del debugger)
@cindex comando del debugger @subentry @code{p} (alias per @code{print})
@cindex @code{p} (comando del debugger) @subentry (alias per @code{print})
@example
gawk> @kbd{p n}
@print{} n = untyped variable
@end example
@noindent
In questo caso, @code{n} @`e una variabile locale non inizializzata, perch@'e la
funzione @`e stata chiamata senza argomenti (@pxref{Chiamate di funzione}).
Una variabile pi@`u utile da visualizzare potrebbe essere la seguente:
@example
gawk> @kbd{p $0}
@print{} $0 = "gawk, ecco un programma meraviglioso!"
@end example
@noindent
All'inizio questo potrebbe lasciare un tantino perplessi, perch@'e @`e la seconda
riga dell'input del test. Vediamo @code{NR}:
@example
gawk> @kbd{p NR}
@print{} NR = 2
@end example
@noindent
Come si pu@`o vedere, @code{se_sono_uguali()} @`e stata chiamata solo per la seconda
riga del file. Naturalmente, ci@`o accade perch@'e il nostro programma contiene
una regola per @samp{NR == 1}:
@example
NR == 1 @{
ultima = $0
next
@}
@end example
Bene, controlliamo che questa funzioni correttamente:
@example
gawk> @kbd{p ultima}
@print{} ultima = "awk, ecco un programma meraviglioso!"
@end example
Tutto ci@`o che @`e stato fatto fin qui ha verificato che il programma funziona
come previsto fino alla chiamata a @code{se_sono_uguali()} compresa; quindi
il problema dev'essere all'interno di questa funzione. Per indagare
ulteriormente, iniziamo a ``scorrere una ad una'' le righe di
@code{se_sono_uguali()}. Cominciamo col battere @samp{n} (per ``next''
[successivo]):
@cindex comando del debugger @subentry @code{n} (alias per @code{next})
@cindex @code{n} (comando del debugger) @subentry (alias per @code{next})
@cindex comando del debugger @subentry @code{next}
@cindex @code{next} (comando del debugger)
@example
@group
gawk> @kbd{n}
@print{} 66 if (contatore_file > 0) @{
@end group
@end example
Questo ci dice che @command{gawk} ora @`e pronto per eseguire la riga 66, che
decide se assegnare alle righe il trattamento speciale ``salta-campi''
indicato dall'opzione sulla riga di comando @option{-1}. (Si noti che abbiamo
saltato da dov'eravamo prima, alla riga 63, a qui, perch@'e la condizione nella
riga 63, @samp{if (contatore_file == 0 && conta_caratteri == 0)}, era falsa.)
Continuando a scorrere le righe, ora raggiungiamo la divisione del record
corrente e dell'ultimo:
@example
gawk> @kbd{n}
@print{} 67 n = split(ultima, vettore_ultima)
gawk> @kbd{n}
@print{} 68 m = split($0, vettore_corrente)
@end example
A questo punto, potremmo stare a vedere in quante parti il nostro record
@`e stato suddiviso, quindi proviamo a osservare:
@example
gawk> @kbd{p n m vettore_ultima vettore_corrente}
@print{} n = 5
@print{} m = untyped variable
@print{} vettore_ultima = array, 5 elements
@print{} vettore_corrente = untyped variable
@end example
@noindent
(Il comando @code{p} pu@`o accettare pi@`u argomenti, analogamente
all'istruzione di @command{awk} @code{print}.)
Questo ci lascia piuttosto perplessi. Tutto ci@`o che abbiamo trovato @`e che ci
sono cinque elementi in @code{vettore_ultima}; @code{m} e @code{vettore_corrente} non hanno valori
perch@'e siamo alla riga 68 che non @`e ancora stata eseguita. Questa
informazione @`e abbastanza utile (ora sappiamo che nessuna delle parole @`e stata
lasciata fuori accidentalmente), ma sarebbe desiderabile vedere i valori
del vettore.
Una prima possibilit@`a @`e quella di usare degli indici:
@cindex debugger @subentry stampare singoli elementi di un vettore
@cindex stampare @subentry singoli elementi di un vettore @subentry nel debugger
@example
gawk> @kbd{p vettore_ultima[0]}
@print{} "0" non presente nel vettore `vettore_ultima'
@end example
@noindent
Oops!
@example
gawk> @kbd{p vettore_ultima[1]}
@print{} vettore_ultima["1"] = "awk,"
@end example
Questo metodo sarebbe piuttosto lento per un vettore con 100 elementi, per cui
@command{gawk} fornisce una scorciatoia (che fa venire in mente un altro
linguaggio che non nominiamo):
@cindex debugger @subentry stampare tutti gli elementi di un vettore
@cindex stampare @subentry tutti gli elementi di un vettore @subentry nel debugger
@example
gawk> @kbd{p @@vettore_ultima}
@print{} vettore_ultima["1"] = "awk,"
@print{} vettore_ultima["2"] = "ecco"
@print{} vettore_ultima["3"] = "un"
@print{} vettore_ultima["4"] = "programma"
@print{} vettore_ultima["5"] = "meraviglioso!"
@end example
Finora, sembra che tutto vada bene. Facciamo un altro passo,
o anche due:
@example
gawk> @kbd{n}
@print{} 69 campi_ultima = join(vettore_ultima, contatore_file, n)
gawk> @kbd{n}
@print{} 70 campi_corrente = join(vettore_corrente, contatore_file, m)
@end example
Bene, eccoci arrivati al nostro errore (ci spiace di aver rovinato la
sorpresa).
Quel che avevamo in mente era di unire i campi a partire dal secondo per
creare il record virtuale da confrontare, e se il primo campo aveva il numero
zero, questo avrebbe funzionato. Vediamo quel che abbiamo finora:
@example
gawk> @kbd{p campi_ultima campi_corrente}
@print{} campi_ultima = "awk, ecco un programma meraviglioso!"
@print{} campi_corrente = "gawk, ecco un programma meraviglioso!"
@end example
Ehi! queste frasi suonano piuttosto familiari! Sono esattamente i nostri
record di input originali, inalterati. Pensandoci un po' (il cervello umano @`e
ancora il miglior strumento di debug), ci si rende conto che eravamo fuori di
uno!
Usciamo dal debugger:
@example
gawk> @kbd{q}
@print{} Il programma @`e in esecuzione. Esco comunque (y/n)? @kbd{y}
@end example
@noindent
Quindi modifichiamo con un editore di testo:
@example
campi_ultima = join(vettore_ultima, contatore_file+1, n)
campi_corrente = join(vettore_corrente, contatore_file+1, m)
@end example
@noindent
e il problema @`e risolto!
@node Lista dei comandi di debug
@section I principali comandi di debug
L'insieme dei comandi del debugger di @command{gawk} pu@`o essere diviso nelle
seguenti categorie:
@itemize @value{BULLET}
@item
Controllo di punti d'interruzione
@item
Controllo di esecuzione
@item
Vedere e modificare dati
@item
Lavorare con le pile
@item
Ottenere informazioni
@item
Comandi vari
@end itemize
@cindex debugger @subentry ripetere dei comandi
@cindex ripetere dei comandi @subentry nel debugger
Ciascuna di esse @`e trattata
@ifnotinfo
nelle seguenti
@end ifnotinfo
@ifinfo
nei seguenti
@end ifinfo
@value{SUBSECTIONS}.
Nelle descrizioni seguenti, i comandi che possono essere abbreviati
mostrano l'abbreviazione su una seconda riga di descrizione.
Un nome di comando del debugger pu@`o essere anche troncato se la parte gi@`a scritta
non @`e ambigua. Il debugger ha la capacit@`a predefinita di ripetere
automaticamente il precedente comando semplicemente battendo @kbd{Invio}.
Questo vale per i comandi @code{list}, @code{next}, @code{nexti},
@code{step}, @code{stepi} e @code{continue} quando sono eseguiti senza
argomenti.
@menu
* Controllo dei breakpoint:: Controllo dei punti d'interruzione.
* Controllo esecuzione debugger:: Controllo di esecuzione.
* Vedere e modificare dati:: Vedere e modificare dati.
* Stack di esecuzione:: Lavorare con lo @dfn{stack}.
* Informazioni sul debugger:: Ottenere informazioni sullo stato del
programma e del debugger.
* Comandi vari del debugger:: Comandi vari del debugger.
@end menu
@node Controllo dei breakpoint
@subsection Controllo dei punti d'interruzione
Come abbiamo gi@`a visto, la prima cosa che si dovrebbe fare in una sessione di
debug @`e quella di definire dei punti d'interruzione, poich@'e altrimenti il
programma verr@`a eseguito come se non fosse sotto il debugger. I comandi per
controllare i punti d'interruzione sono:
@table @asis
@cindex comando del debugger @subentry @code{b} (alias per @code{break})
@cindex comando del debugger @subentry @code{break}
@cindex @code{break} (comando del debugger)
@cindex @code{b} (comando del debugger) @subentry (alias per @code{break})
@cindex impostare @subentry un punto d'interruzione
@cindex @code{breakpoint} (comando del debugger) @subentry impostare
@cindex punto d'interruzione @subentry (@code{break}) @subentry impostare
@item @code{break} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}] [@code{"@var{espressione}"}]
@itemx @code{b} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}] [@code{"@var{espressione}"}]
Senza argomenti, imposta un punto d'interruzione alla prossima istruzione
da eseguire nello @dfn{stack frame} selezionato.
Gli argomenti possono essere uno dei seguenti:
@c @asis for docbook
@c nested table
@table @asis
@item @var{n}
Imposta un punto d'interruzione alla riga numero @var{n} nel file sorgente
corrente.
@item @var{nome-file}@code{:}@var{n}
Imposta un punto d'interruzione alla riga numero @var{n} nel file sorgente
@var{nome-file}.
@item @var{funzione}
Imposta un punto d'interruzione all'ingresso (la prima istruzione eseguibile)
della funzione @var{funzione}.
@end table
A ogni punto d'interruzione @`e assegnato un numero che pu@`o essere usato per
cancellarlo dalla lista dei punti d'interruzione usando il comando
@code{delete}.
Specificando un punto d'interruzione, si pu@`o fornire anche una condizione.
Questa @`e
un'espressione @command{awk} (racchiusa tra doppi apici) che il debugger
valuta ogni volta che viene raggiunto quel punto d'interruzione. Se la
condizione @`e vera, il debugger ferma l'esecuzione e rimane in attesa di un
comando. Altrimenti, continua l'esecuzione del programma.
@cindex comando del debugger @subentry @code{clear}
@cindex @code{clear} (comando del debugger)
@cindex cancellare punto d'interruzione @subentry in una determinata posizione
@cindex punto d'interruzione @subentry (@code{breakpoint}) @subentry cancellare in una determinata posizione
@cindex @code{breakpoint} (comando del debugger) @subentry in una determinata posizione @subentry cancellare
@item @code{clear} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}]
Senza argomenti, cancella ogni eventuale punto d'interruzione all'istruzione
successiva
da eseguirsi nello @dfn{stack frame} selezionato. Se il programma si ferma in
un punto d'interruzione, quel punto d'interruzione viene cancellato in modo
che il programma non si fermi pi@`u in quel punto.
Gli argomenti possono essere uno tra i seguenti:
@c nested table
@table @asis
@item @var{n}
Cancella il punto (o i punti) d'interruzione impostato/i alla riga @var{n} nel
file sorgente corrente.
@item @var{nome-file}@code{:}@var{n}
Cancella il punto (o i punti) d'interruzione impostato/i alla riga @var{n} nel
file sorgente @var{nome-file}.
@item @var{funzione}
Cancella il punto (o i punti) d'interruzione impostato/i all'ingresso della
funzione @var{funzione}.
@end table
@cindex comando del debugger @subentry @code{condition}
@cindex @code{condition} (comando del debugger)
@cindex condizione dei punti d'interruzione
@item @code{condition} @var{n} @code{"@var{espressione}"}
Aggiunge una condizione al punto d'interruzione o al punto d'osservazione
esistente @var{n}. La condizione @`e un'espressione @command{awk}
@emph{racchiusa tra doppi apici} che il debugger valuta ogni volta che viene
raggiunto il punto d'interruzione o il punto d'osservazione. Se la condizione @`e
vera, il debugger ferma l'esecuzione e attende l'immissione di un comando.
Altrimenti, il debugger continua l'esecuzione del programma. Se l'espressione
della condizione non viene specificata, tutte le condizioni esistenti vengono
rimosse (cio@`e, il punto d'interruzione o di osservazione viene considerato
incondizionato).
@cindex comando del debugger @subentry @code{d} (alias per @code{delete})
@cindex comando del debugger @subentry @code{delete}
@cindex @code{delete} (comando del debugger)
@cindex @code{d} (comando del debugger) @subentry (alias per @code{delete})
@cindex cancellare punto d'interruzione @subentry per numero
@cindex punto d'interruzione @subentry (@code{breakpoint}) @subentry cancellare per numero
@cindex @code{breakpoint} (comando del debugger) @subentry cancellare per numero
@item @code{delete} [@var{n1 n2} @dots{}] [@var{n}--@var{m}]
@itemx @code{d} [@var{n1 n2} @dots{}] [@var{n}--@var{m}]
Cancella i punti d'interruzione specificati o un intervallo di punti
d'interruzione. Se non vengono forniti argomenti, cancella tutti i
punti d'interruzione esistenti.
@cindex comando del debugger @subentry @code{disable}
@cindex @code{disable} (comando del debugger)
@cindex disabilitare punto d'interruzione
@cindex punto d'interruzione @subentry (@code{disable}) @subentry come disabilitare o abilitare
@item @code{disable} [@var{n1 n2} @dots{} | @var{n}--@var{m}]
Disabilita punti d'interruzione specificati o un intervallo di essi. Senza
argomenti, disabilita tutti i punti d'interruzione.
@cindex comando del debugger @subentry @code{e} (alias per @code{enable})
@cindex comando del debugger @subentry @code{enable}
@cindex @code{enable} (comando del debugger)
@cindex @code{e} (comando del debugger) @subentry (alias per @code{enable})
@cindex abilitare un punto d'interruzione
@item @code{enable} [@code{del} | @code{once}] [@var{n1 n2} @dots{}] [@var{n}--@var{m}]
@itemx @code{e} [@code{del} | @code{once}] [@var{n1 n2} @dots{}] [@var{n}--@var{m}]
Abilita specifici punti d'interruzione o un intervallo di essi. Senza
argomenti, abilita tutti i punti d'interruzione.
Opzionalmente, si pu@`o specificare come abilitare i punti d'interruzione:
@c nested table
@table @code
@item del
Abilita dei punti d'interruzione @dfn{una tantum}, poi li cancella quando il
programma si ferma in quel punto.
@item once
Abilita dei punti d'interruzione @dfn{una tantum}, poi li cancella quando il
programma si ferma in quel punto.
@end table
@cindex comando del debugger @subentry @code{ignore}
@cindex @code{ignore} (comando del debugger)
@cindex ignorare un punto d'interruzione
@item @code{ignore} @var{n} @var{contatore}
Ignora il punto d'interruzione numero @var{n} le successive
@var{contatore} volte in cui viene raggiunto.
@cindex comando del debugger @subentry @code{t} (alias per @code{tbreak})
@cindex comando del debugger @subentry @code{tbreak}
@cindex @code{tbreak} (comando del debugger)
@cindex @code{t} (comando del debugger) @subentry (alias per @code{tbreak})
@cindex punto d'interruzione @subentry (@code{tbreak}) temporaneo
@cindex temporaneo @subentry punto d'interruzione
@item @code{tbreak} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}]
@itemx @code{t} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}]
Imposta un punto d'interruzione temporaneo (abilitato solo per la prima volta
che viene raggiunto). Gli argomenti sono gli stessi di @code{break}.
@end table
@node Controllo esecuzione debugger
@subsection Controllo di esecuzione
Dopo che i punti d'interruzione sono pronti, si pu@`o iniziare l'esecuzione del
programma, osservando il suo comportamento. Ci sono pi@`u comandi per
controllare l'esecuzione del programma di quelli visti nei precedenti esempi:
@table @asis
@cindex comando del debugger @subentry @code{commands}
@cindex @code{commands} (comando del debugger)
@cindex comando del debugger @subentry @code{silent}
@cindex @code{silent} (comando del debugger)
@cindex comando del debugger @subentry @code{end}
@cindex @code{end} (comando del debugger)
@cindex punto d'interruzione @subentry comandi da eseguire al
@cindex comandi da eseguire al punto d'interruzione
@item @code{commands} [@var{n}]
@itemx @code{silent}
@itemx @dots{}
@itemx @code{end}
Imposta una lista di comandi da eseguire subito dopo l'arresto del programma in
un punto d'interruzione o di osservazione. @var{n} @`e il numero del punto
d'interruzione o di osservazione. Se non si specifica un numero, viene usato
l'ultimo numero che @`e stato specificato. I comandi veri e propri seguono,
a cominciare dalla riga successiva, e hanno termine col comando @code{end}.
Se il comando @code{silent} @`e nella lista, i consueti messaggi sull'arresto del
programma a un punto d'interruzione e la riga sorgente non vengono stampati.
Qualsiasi comando nella lista che riprende l'esecuzione (p.es.,
@code{continue}) pone fine alla lista (un @code{end} implicito), e i comandi
successivi vengono ignorati.
Per esempio:
@example
gawk> @kbd{commands}
> @kbd{silent}
> @kbd{printf "Un punto d'interruzione silenzioso; i = %d\n", i}
> @kbd{info locals}
> @kbd{set i = 10}
> @kbd{continue}
> @kbd{end}
gawk>
@end example
@cindex comando del debugger @subentry @code{c} (alias per @code{continue})
@cindex comando del debugger @subentry @code{continue}
@cindex continuare esecuzione programma @subentry nel debugger
@cindex debugger @subentry continuare esecuzione programma
@cindex @code{continue} (comando del debugger)
@item @code{continue} [@var{contatore}]
@itemx @code{c} [@var{contatore}]
Riprende l'esecuzione del programma. Se si riparte da un punto d'interruzione
e viene specificato @var{contatore}, il punto d'interruzione in quella
posizione viene ignorato per le prossime @var{contatore} volte prima di
fermarsi nuovamente.
@cindex comando del debugger @subentry @code{finish}
@cindex @code{finish} (comando del debugger)
@item @code{finish}
Esegue fino a quando lo @dfn{stack frame} selezionato completa l'esecuzione.
Stampa il valore restituito.
@cindex comando del debugger @subentry @code{n} (alias per @code{next})
@cindex comando del debugger @subentry @code{next}
@cindex @code{next} (comando del debugger)
@cindex @code{n} (comando del debugger) @subentry (alias per @code{next})
@cindex esecuzione di un solo passo @subentry nel debugger
@item @code{next} [@var{contatore}]
@itemx @code{n} [@var{contatore}]
Continua l'esecuzione alla successiva riga sorgente, saltando le chiamate di
funzione. L'argomento @var{contatore} controlla il numero di ripetizioni
dell'azione, come in @code{step}.
@cindex comando del debugger @subentry @code{ni} (alias per @code{nexti})
@cindex comando del debugger @subentry @code{nexti}
@cindex @code{nexti} (comando del debugger)
@cindex @code{ni} (comando del debugger) @subentry (alias for @code{nexti})
@item @code{nexti} [@var{contatore}]
@itemx @code{ni} [@var{contatore}]
Esegue una o @var{contatore} istruzioni, comprese le chiamate di funzione.
@cindex comando del debugger @subentry @code{return}
@cindex @code{return} (comando del debugger)
@item @code{return} [@var{valore}]
Cancella l'esecuzione di una chiamata di funzione. Se @var{valore} (una
stringa o un numero) viene specificato, @`e usato come codice di ritorno della
funzione. Se usato in un frame diverso da quello pi@`u interno (la funzione
correntemente in esecuzione; cio@`e, il frame numero 0), ignora tutti i frame
pi@`u interni di quello selezionato, e il chiamante del frame selezionato
diventa il frame pi@`u interno.
@cindex comando del debugger @subentry @code{r} (alias per @code{run})
@cindex comando del debugger @subentry @code{run}
@cindex @code{run} (comando del debugger)
@cindex @code{r} (comando del debugger) @subentry (alias per @code{run})
@item @code{run}
@itemx @code{r}
Avvia/riavvia l'esecuzione del programma. Quando il programma viene riavviato,
il debugger mantiene i punti d'interruzione e di osservazione, la cronologia
dei comandi, la visualizzazione automatica di variabili, e le opzioni del
debugger.
@cindex comando del debugger @subentry @code{s} (alias per @code{step})
@cindex comando del debugger @subentry @code{step}
@cindex @code{step} (comando del debugger)
@cindex @code{s} (comando del debugger) @subentry (alias per @code{step})
@item @code{step} [@var{contatore}]
@itemx @code{s} [@var{contatore}]
Continua l'esecuzione finch@'e il controllo non raggiunge una diversa riga del
sorgente nello @dfn{stack frame} corrente, eseguendo ogni funzione chiamata
all'interno della riga. Se viene fornito l'argomento @var{contatore},
esegue il numero di istruzioni specificate prima di fermarsi, a meno che non
s'imbatta in un punto d'interruzione o di osservazione.
@cindex comando del debugger @subentry @code{si} (alias per @code{stepi})
@cindex comando del debugger @subentry @code{stepi}
@cindex @code{stepi} (comando del debugger)
@cindex @code{si} (comando del debugger) @subentry (alias per @code{stepi})
@item @code{stepi} [@var{contatore}]
@itemx @code{si} [@var{contatore}]
Esegue una o @var{contatore} istruzioni, comprese le chiamate di funzione.
(Per una spiegazione su cosa s'intende per ``istruzione'' in @command{gawk},
si veda l'output mostrato sotto @code{dump} nella
@ref{Comandi vari del debugger}.)
@cindex comando del debugger @subentry @code{u} (alias per @code{until})
@cindex comando del debugger @subentry @code{until}
@cindex @code{until} (comando del debugger)
@cindex @code{u} (comando del debugger) @subentry (alias per @code{until})
@item @code{until} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}]
@itemx @code{u} [[@var{nome-file}@code{:}]@var{n} | @var{funzione}]
Senza argomenti, prosegue l'esecuzione finch@'e non viene raggiunta una riga
dopo la riga corrente nello @dfn{stack frame} corrente.
Se viene specificato un argomento,
prosegue l'esecuzione finch@'e non viene raggiunto il punto specificato, o
lo @dfn{stack frame} corrente non termina l'esecuzione.
@end table
@node Vedere e modificare dati
@subsection Vedere e modificare dati
I comandi per vedere e modificare variabili all'interno di @command{gawk} sono:
@table @asis
@cindex comando del debugger @subentry @code{display}
@cindex @code{display} (comando del debugger)
@item @code{display} [@var{var} | @code{$}@var{n}]
Aggiunge la variabile @var{var} (o il campo @code{$@var{n}}) alla lista di
visualizzazione. Il valore della variabile o del campo @`e visualizzato ogni
volta che il programma s'interrompe.
Ogni variabile aggiunta alla lista @`e identificata da un numero univoco:
@example
gawk> @kbd{display x}
@print{} 10: x = 1
@end example
@noindent
La riga qui sopra mostra il numero di elemento assegnato, il nome della
variabile e il suo
valore corrente. Se la variabile di display fa riferimento a un parametro di
funzione, @`e cancellata silenziosamente dalla lista non appena l'esecuzione
raggiunge un contesto dove la variabile con quel nome non esiste pi@`u.
Senza argomenti, @code{display} mostra i valori correnti degli elementi della
lista.
@cindex comando del debugger @subentry @code{eval}
@cindex @code{eval} (comando del debugger)
@cindex valutare espressioni @subentry nel debugger
@item @code{eval "@var{istruzioni awk}"}
Valuta @var{istruzioni awk} nel contesto del programma in esecuzione.
Si pu@`o fare qualsiasi cosa che un programma @command{awk} farebbe: assegnare
valori a variabili, chiamare funzioni, e cos@`{@dotless{i}} via.
@quotation NOTA
Non @`e possibile usare @code{eval} per valutare un'espressione che contenga
una qualsiasi delle seguenti istruzioni:
@code{exit},
@code{getline},
@code{next},
@code{nextfile},
o
@code{return}.
@end quotation
@item @code{eval} @var{param}, @dots{}
@itemx @var{istruzioni awk}
@itemx @code{end}
Questa forma di @code{eval} @`e simile alla precedente, solo che permette di
definire
``variabili locali'' che esistono nel contesto delle @var{istruzioni awk},
invece di usare variabili o parametri di funzione gi@`a definiti nel programma.
@cindex comando del debugger @subentry @code{p} (alias per @code{print})
@cindex comando del debugger @subentry @code{print}
@cindex @code{print} (comando del debugger)
@cindex @code{p} (comando del debugger) @subentry (alias per @code{print})
@cindex stampare @subentry variabili @subentry nel debugger
@item @code{print} @var{var1}[@code{,} @var{var2} @dots{}]
@itemx @code{p} @var{var1}[@code{,} @var{var2} @dots{}]
Stampa i valori di una o pi@`u variabili o campi di @command{gawk}.
I campi devono essere indicizzati usando delle costanti:
@example
gawk> @kbd{print $3}
@end example
@noindent
Questo stampa il terzo campo del record di input (se il campo specificato non
esiste, stampa il @samp{campo nullo}). Una variabile pu@`o essere un elemento di
un vettore, avente come indice una
stringa di valore costante. Per stampare
il contenuto di un vettore, si deve anteporre il simbolo @samp{@@} al nome del
vettore:
@example
gawk> @kbd{print @@a}
@end example
@noindent
L'esempio stampa gli indici e i corrispondenti valori di tutti gli elementi
del vettore @code{a}.
@cindex comando del debugger @subentry @code{printf}
@cindex @code{printf} (comando del debugger)
@item @code{printf} @var{formato} [@code{,} @var{arg} @dots{}]
Stampa un testo formattato. Il @var{formato} pu@`o includere sequenze di
protezione, come @samp{\n}
(@pxref{Sequenze di protezione}).
Non viene stampato nessun ritorno a capo che non sia stato specificato
esplicitamente.
@cindex comando del debugger @subentry @code{set}
@cindex @code{set} (comando del debugger)
@cindex assegnamento @subentry di valori a variabili, nel debugger
@item @code{set} @var{var}@code{=}@var{valore}
Assegna un valore costante (numero o stringa) a una variabile o a un campo di
@command{awk}.
I valori di stringa devono essere racchiusi tra doppi apici
(@code{"}@dots{}@code{"}).
Si possono impostare anche delle variabili speciali di @command{awk}, come
@code{FS}, @code{NF}, @code{NR}, e cos@`{@dotless{i}} via.
@cindex comando del debugger @subentry @code{w} (alias per @code{watch})
@cindex comando del debugger @subentry @code{watch}
@cindex @code{watch} (comando del debugger)
@cindex @code{w} (comando del debugger) @subentry (alias per @code{watch})
@cindex impostare @subentry un punto d'osservazione
@item @code{watch} @var{var} | @code{$}@var{n} [@code{"@var{espressione}"}]
@itemx @code{w} @var{var} | @code{$}@var{n} [@code{"@var{espressione}"}]
Aggiunge la variabile @var{var} (o il campo @code{$@var{n}}) alla lista dei
punti d'osservazione. Il debugger quindi interrompe il programma ogni volta
che il valore della variabile o del campo cambia. A ogni elemento osservato
viene assegnato un numero che pu@`o essere usato per cancellarlo dalla lista
usando il comando @code{unwatch} [non-osservare pi@`u].
Definendo un punto d'osservazione, si pu@`o anche porre una condizione, che @`e
un'espressione @command{awk} (racchiusa tra doppi apici) che il debugger valuta
ogni volta che viene raggiunto il punto d'osservazione. Se la condizione @`e
vera, il debugger interrompe l'esecuzione e rimane in attesa di un comando.
Altrimenti, @command{gawk} prosegue nell'esecuzione del programma.
@cindex comando del debugger @subentry @code{undisplay}
@cindex @code{undisplay} (comando del debugger)
@cindex interruzione visualizzazioni automatiche @subentry nel debugger
@item @code{undisplay} [@var{n}]
Rimuove l'elemento numero @var{n} (o tutti gli elementi, se non vi sono
argomenti) dalla lista delle visualizzazioni automatiche.
@cindex comando del debugger @subentry @code{unwatch}
@cindex @code{unwatch} (comando del debugger)
@cindex cancellare punto d'osservazione
@item @code{unwatch} [@var{n}]
Rimuove l'elemento numero @var{n} (o tutti gli elementi, se non vi sono
argomenti) dalla lista dei punti d'osservazione.
@end table
@node @dfn{Stack} di esecuzione
@subsection Lavorare con lo @dfn{stack}
Ogni volta che si esegue un programma che contiene chiamate di funzione,
@command{gawk} mantiene una pila contenente la lista delle chiamate di funzione
che hanno portato al punto in cui il programma si trova in ogni momento. @`E
possibile vedere a che punto si trova il programma, e anche muoversi
all'interno della pila per vedere qual era lo stato delle cose nelle funzioni
che hanno chiamato quella in cui ci si trova. I comandi per far questo sono:
@table @asis
@cindex comando del debugger @subentry @code{bt} (alias per @code{backtrace})
@cindex comando del debugger @subentry @code{backtrace}
@cindex comando del debugger @subentry @code{where} (alias per @code{backtrace})
@cindex @code{backtrace} (comando del debugger)
@cindex @code{bt} (comando del debugger) @subentry (alias per @code{backtrace})
@cindex @code{where} (comando del debugger) @subentry (alias per @code{backtrace})
@cindex descrizione di @subentry @dfn{stack}, pila delle @subentry nel debugger
@cindex @dfn{stack} (pila) delle chiamate @subentry visualizzare nel debugger
@cindex pila (@dfn{stack}) delle chiamate @subentry visualizzare nel debugger
@cindex tracciatura @subentry a ritroso @subentry mostrare nel debugger
@item @code{backtrace} [@var{contatore}]
@itemx @code{bt} [@var{contatore}]
@itemx @code{where} [@var{contatore}]
Stampa a ritroso una traccia di tutte le chiamate di funzione (@dfn{stack frame}), o
i dei @var{contatore} frame pi@`u interni se @var{contatore} > 0. Stampa i
@var{contatore} frame pi@`u esterni se @var{contatore} < 0. La tracciatura a
ritroso mostra il nome e gli argomenti di ciascuna funzione, il sorgente
@value{FN}, e il numero di riga. L'alias @code{where} per @code{backtrace}
viene mantenuto per i vecchi utenti di GDB che potrebbero essere abituati a
quel comando.
@cindex comando del debugger @subentry @code{down}
@cindex @code{down} (comando del debugger)
@item @code{down} [@var{contatore}]
Sposta @var{contatore} (default 1) frame sotto la pila verso il frame pi@`u interno.
Poi seleziona e stampa il frame.
@cindex comando del debugger @subentry @code{f} (alias per @code{frame})
@cindex comando del debugger @subentry @code{frame}
@cindex @code{frame} (comando del debugger)
@cindex @code{f} (comando del debugger) @subentry (alias per @code{frame})
@item @code{frame} [@var{n}]
@itemx @code{f} [@var{n}]
Seleziona e stampa lo @dfn{stack frame} @var{n}. Il frame 0 @`e quello
correntemente in esecuzione, o il frame @dfn{pi@`u interno}, (chiamata di
funzione); il frame 1 @`e il frame che ha chiamato quello pi@`u interno. Il frame
col numero pi@`u alto @`e quello per il programma principale. Le informazioni
stampate comprendono il numero di frame, i nomi delle funzioni e degli
argomenti, i file sorgenti e le righe sorgenti.
@cindex comando del debugger @subentry @code{up}
@cindex @code{up} (comando del debugger)
@item @code{up} [@var{contatore}]
Sposta @var{contatore} (default 1) frame sopra la pila verso il frame pi@`u
esterno. Poi seleziona e stampa il frame.
@end table
@node Informazioni sul debugger
@subsection Ottenere informazioni sullo stato del programma e del debugger
Oltre che vedere i valori delle variabili, spesso si ha necessit@`a di ottenere
informazioni di altro tipo sullo stato del programma e dello stesso ambiente di
debug. Il debugger di @command{gawk} ha un comando che fornisce
quest'informazione, chiamato convenientemente @code{info}. @code{info}
@`e usato con uno dei tanti argomenti che dicono esattamente quel che si vuol
sapere:
@table @asis
@cindex comando del debugger @subentry @code{i} (alias per @code{info})
@cindex comando del debugger @subentry @code{info}
@cindex @code{info} (comando del debugger)
@cindex @code{i} (comando del debugger) @subentry (alias per @code{info})
@item @code{info} @var{cosa}
@itemx @code{i} @var{cosa}
Il valore di @var{cosa} dovrebbe essere uno dei seguenti:
@c nested table
@table @code
@item args
@cindex mostrare nel debugger @subentry argomenti delle funzioni
@cindex debugger @subentry mostrare argomenti delle funzioni
Elenca gli argomenti del frame selezionato.
@item break
@cindex mostrare nel debugger @subentry punti d'interruzione
@cindex debugger @subentry mostrare punti d'interruzione
Elenca tutti i punti d'interruzione attualmente impostati.
@item display
@cindex visualizzazioni automatiche @subentry nel debugger
@cindex debugger @subentry visualizzazioni automatiche
Elenca tutti gli elementi della lista delle visualizzazioni automatiche.
@item frame
@cindex descrizione di @subentry @dfn{stack frame} delle chiamate @subentry nel debugger
@cindex debugger @subentry descrizione degli @dfn{stack frame} delle chiamate
D@`a una descrizione degli @dfn{stack frame} selezionati.
@item functions
@cindex elencare @subentry definizioni delle funzioni @subentry nel debugger
@cindex debugger @subentry elencare definizioni delle funzioni
Elenca tutte le definizioni delle funzioni compresi i @value{FNS} e
i numeri di riga.
@item locals
@cindex mostrare nel debugger @subentry variabili locali
@cindex debugger @subentry mostrare variabili locali
Elenca le variabili locali dei frame selezionati.
@item source
@cindex mostrare nel debugger @subentry nome del file sorgente corrente
@cindex debugger @subentry mostrare il nome del file sorgente corrente
@cindex file @subentry sorgente corrente, mostrare nel debugger
Stampa il nome del file sorgente corrente. Ogni volta che il programma si
interrompe, il file sorgente corrente @`e il file che contiene l'istruzione
corrente. Quando il debugger viene avviato per la prima volta, il file
sorgente corrente @`e il primo file incluso attraverso l'opzione @option{-f}.
Il comando @samp{list @var{nome-file}:@var{numero-riga}} pu@`o essere usato in
qualsiasi momento per cambiare il sorgente corrente.
@item sources
@cindex mostrare nel debugger @subentry nome di tutti i file sorgente
@cindex debugger @subentry mostrare il nome di tutti i file sorgente
Elenca tutti i file sorgente del programma.
@item variables
@cindex elencare @subentry tutte le variabili locali @subentry nel debugger
@cindex debugger @subentry elencare tutte le variabili locali
Elenca tutte le variabili locali.
@item watch
@cindex mostrare nel debugger @subentry punti d'osservazione
@cindex debugger @subentry mostrare i punti d'osservazione
Elenca tutti gli elementi della lista dei punti d'osservazione.
@end table
@end table
Ulteriori comandi permettono di avere il controllo sul debugger, la capacit@`a di
salvare lo stato del debugger e la capacit@`a di eseguire comandi del debugger
da un file. I comandi sono:
@table @asis
@cindex comando del debugger @subentry @code{o} (alias per @code{option})
@cindex comando del debugger @subentry @code{option}
@cindex @code{option} (comando del debugger)
@cindex @code{o} (comando del debugger) @subentry (alias per @code{option})
@cindex visualizzare le opzioni del debugger
@cindex debugger @subentry opzioni del
@item @code{option} [@var{nome}[@code{=}@var{valore}]]
@itemx @code{o} [@var{nome}[@code{=}@var{valore}]]
Senza argomenti, visualizza le opzioni del debugger disponibili e i loro valori
correnti. @samp{option @var{nome}} mostra il valore corrente dell'opzione
cos@`{@dotless{i}} denominata. @samp{option @var{nome}=@var{valore}} assegna
un nuovo valore all'opzione.
Le opzioni disponibili sono:
@c nested table
@c asis for docbook
@table @asis
@item @code{history_size}
@cindex debugger @subentry dimensione della cronologia
Imposta il numero massimo di righe da mantenere nel file della cronologia
@file{./.gawk_history}. Il valore di default @`e 100.
@item @code{listsize}
@cindex debugger @subentry numero di righe nella lista di default
Specifica il numero di righe che @code{list} deve stampare. Il valore di
default @`e 15.
@item @code{outfile}
@cindex ridirezionare l'output di @command{gawk} @subentry nel debugger
@cindex debugger @subentry ridirezionare l'output di @command{gawk}
Invia l'output di @command{gawk} in un file; l'output del debugger @`e
visualizzato comunque anche
nello standard output. Assegnare come valore stringa vuota (@code{""})
reimposta l'output solo allo standard output.
@item @code{prompt}
@cindex debugger @subentry prompt
@cindex prompt del debugger
Cambia la riga per l'immissione dei comandi del debugger. Il valore di
default @`e @samp{@w{gawk> }}.
@item @code{save_history} [@code{on} | @code{off}]
@cindex debugger @subentry file della cronologia
Salva la cronologia dei comandi nel file @file{./.gawk_history}.
L'impostazione di default @`e @code{on}.
@item @code{save_options} [@code{on} | @code{off}]
@cindex salvataggio opzioni @subentry nel debugger
@cindex debugger @subentry salvataggio opzioni
Salva le opzioni correnti nel file @file{./.gawkrc} all'uscita.
L'impostazione di default @`e @code{on}.
Le opzioni sono lette di nuovo all'avvio della sessione successiva.
@item @code{trace} [@code{on} | @code{off}]
@cindex istruzioni @subentry tener traccia delle @subentry nel debugger
@cindex debugger @subentry tener traccia delle istruzioni
Attiva o disattiva il tracciamento delle istruzioni. L'impostazione di default
@`e @code{off}.
@end table
@cindex debugger @subentry salvare dei comandi su un file
@cindex salvare dei comandi su un file @subentry nel debugger
@item @code{save} @var{nome-file}
Salva i comandi eseguiti nella sessione corrente nel @value{FN} indicato,
in modo da poterli ripetere in seguito usando il comando @command{source}.
@item @code{source} @var{nome-file}
@cindex debugger @subentry leggere comandi da un file
@cindex leggere @subentry comandi da un file nel debugger
Esegue comandi contenuti in un file; un errore in un comando non impedisce
l'esecuzione dei comandi successivi. In un file di comandi sono consentiti
i commenti (righe che iniziano con @samp{#}).
Le righe vuote vengono ignorate; esse @emph{non}
ripetono l'ultimo comando.
Non si pu@`o riavviare il programma mettendo pi@`u di un comando @code{run}
nel file. Inoltre, la lista dei comandi pu@`o includere altri comandi
@code{source}; in ogni caso, il debugger di @command{gawk} non richiama lo
stesso file pi@`u di una volta per evitare ricorsioni infinite.
Oltre al comando @code{source}, o al posto di esso, si possono usare le opzioni
sulla riga di comando @option{-D @var{file}} o @option{--debug=@var{file}}
per eseguire comandi da un file in maniera non interattiva
(@pxref{Opzioni}).
@end table
@node Comandi vari del debugger
@subsection Comandi vari del debugger
Ci sono alcuni altri comandi che non rientrano nelle precedenti categorie,
come i seguenti:
@table @asis
@cindex comando del debugger @subentry @code{dump}
@cindex @code{dump} (comando del debugger)
@item @code{dump} [@var{nome-file}]
Riversa il @dfn{byte code} del programma nello standard output o nel file
definito in @var{nome-file}. Questo stampa una rappresentazione delle
istruzioni interne che @command{gawk} esegue per implementare i comandi
@command{awk} in un programma. Ci@`o pu@`o essere molto istruttivo, come
dimostra il seguente riversamento parziale del codice offuscato di
Davide Brini (@pxref{Programma signature}):
@smallexample
@group
gawk> @kbd{dump}
@print{} # BEGIN
@print{}
@print{} [ 1:0xfcd340] Op_rule : [in_rule = BEGIN] [source_file = brini.awk]
@end group
@print{} [ 1:0xfcc240] Op_push_i : "~" [MALLOC|STRING|STRCUR]
@print{} [ 1:0xfcc2a0] Op_push_i : "~" [MALLOC|STRING|STRCUR]
@print{} [ 1:0xfcc280] Op_match :
@print{} [ 1:0xfcc1e0] Op_store_var : O
@print{} [ 1:0xfcc2e0] Op_push_i : "==" [MALLOC|STRING|STRCUR]
@print{} [ 1:0xfcc340] Op_push_i : "==" [MALLOC|STRING|STRCUR]
@print{} [ 1:0xfcc320] Op_equal :
@print{} [ 1:0xfcc200] Op_store_var : o
@print{} [ 1:0xfcc380] Op_push : o
@print{} [ 1:0xfcc360] Op_plus_i : 0 [MALLOC|NUMCUR|NUMBER]
@print{} [ 1:0xfcc220] Op_push_lhs : o [do_reference = true]
@print{} [ 1:0xfcc300] Op_assign_plus :
@print{} [ :0xfcc2c0] Op_pop :
@print{} [ 1:0xfcc400] Op_push : O
@print{} [ 1:0xfcc420] Op_push_i : "" [MALLOC|STRING|STRCUR]
@print{} [ :0xfcc4a0] Op_no_op :
@print{} [ 1:0xfcc480] Op_push : O
@print{} [ :0xfcc4c0] Op_concat : [expr_count = 3] [concat_flag = 0]
@print{} [ 1:0xfcc3c0] Op_store_var : x
@print{} [ 1:0xfcc440] Op_push_lhs : X [do_reference = true]
@print{} [ 1:0xfcc3a0] Op_postincrement :
@print{} [ 1:0xfcc4e0] Op_push : x
@print{} [ 1:0xfcc540] Op_push : o
@print{} [ 1:0xfcc500] Op_plus :
@print{} [ 1:0xfcc580] Op_push : o
@print{} [ 1:0xfcc560] Op_plus :
@print{} [ 1:0xfcc460] Op_leq :
@print{} [ :0xfcc5c0] Op_jmp_false : [target_jmp = 0xfcc5e0]
@print{} [ 1:0xfcc600] Op_push_i : "%c" [MALLOC|STRING|STRCUR]
@print{} [ :0xfcc660] Op_no_op :
@print{} [ 1:0xfcc520] Op_assign_concat : c
@print{} [ :0xfcc620] Op_jmp : [target_jmp = 0xfcc440]
@dots{}
@print{} [ 2:0xfcc5a0] Op_K_printf : [expr_count = 17] [redir_type = ""]
@print{} [ :0xfcc140] Op_no_op :
@print{} [ :0xfcc1c0] Op_atexit :
@print{} [ :0xfcc640] Op_stop :
@print{} [ :0xfcc180] Op_no_op :
@print{} [ :0xfcd150] Op_after_beginfile :
@group
@print{} [ :0xfcc160] Op_no_op :
@print{} [ :0xfcc1a0] Op_after_endfile :
gawk>
@end group
@end smallexample
@cindex comando del debugger @subentry @code{exit}
@cindex @code{exit} (comando del debugger)
@cindex uscire dal debugger
@cindex debugger @subentry uscire dal
@item @code{exit}
Esce dal debugger.
Si veda la voce @samp{quit}, pi@`u avanti in quest'elenco.
@cindex comando del debugger @subentry @code{h} (alias per @code{help})
@cindex comando del debugger @subentry @code{help}
@cindex @code{help} (comando del debugger)
@cindex @code{h} (comando del debugger) @subentry (alias per @code{help})
@item @code{help}
@itemx @code{h}
Stampa una lista di tutti i comandi del debugger di @command{gawk} con un breve
sommario su come usarli. @samp{help @var{comando}} stampa l'informazione sul
comando @var{comando}.
@cindex comando del debugger @subentry @code{l} (alias per @code{list})
@cindex comando del debugger @subentry @code{list}
@cindex @code{list} (comando del debugger)
@cindex @code{l} (comando del debugger) @subentry (alias per @code{list})
@item @code{list} [@code{-} | @code{+} | @var{n} | @var{nome-file}@code{:}@var{n} | @var{n}--@var{m} | @var{funzione}]
@itemx @code{l} [@code{-} | @code{+} | @var{n} | @var{nome-file}@code{:}@var{n} | @var{n}--@var{m} | @var{funzione}]
Stampa le righe specificate (per default 15) dal file sorgente corrente
o il file chiamato @var{nome-file}. I possibili argomenti di @code{list}
sono i seguenti:
@c nested table
@table @asis
@item @code{-} (meno)
Stampa righe prima delle ultime righe stampate.
@item @code{+}
Stampa righe dopo le ultime righe stampate.
@code{list} senza argomenti fa la stessa cosa.
@item @var{n}
Stampa righe centrate attorno alla riga numero @var{n}.
@item @var{n}--@var{m}
Stampa righe dalla numero @var{n} alla numero @var{m}.
@item @var{nome-file}@code{:}@var{n}
Stampa righe centrate attorno alla riga numero @var{n} nel file sorgente
@var{nome-file}. Questo comando pu@`o cambiare il file sorgente corrente.
@item @var{funzione}
Stampa righe centrate attorno all'inizio della funzione @var{function}.
Questo comando pu@`o cambiare il file sorgente corrente.
@end table
@cindex comando del debugger @subentry @code{q} (alias per @code{quit})
@cindex comando del debugger @subentry @code{quit}
@cindex @code{quit} (comando del debugger)
@cindex @code{q} (comando del debugger) @subentry (alias per @code{quit})
@cindex uscire dal debugger
@cindex debugger @subentry uscire dal
@item @code{quit}
@itemx @code{q}
Esce dal debugger. Fare il debug @`e divertente, ma noi tutti a volte
dobbiamo far fronte ad altri impegni nella vita, e talvolta troviamo il bug
e possiamo tranquillamente passare a quello successivo! Come abbiamo visto
prima, se si sta eseguendo un programma, il debugger avverte quando si batte
@samp{q} o @samp{quit}, in modo da essere sicuri di voler realmente abbandonare
il debug.
@cindex comando del debugger @subentry @code{trace}
@cindex @code{trace} (comando del debugger)
@item @code{trace} [@code{on} | @code{off}]
Abilita o disabilita la stampa continua delle istruzioni che si stanno per
eseguire, assieme alle righe di @command{awk} che implementano.
L'impostazione di default @`e @code{off}.
@`E auspicabile che la maggior parte dei ``codici operativi'' (o ``opcode'')
in queste istruzioni siano sufficientemente autoesplicativi, e l'uso di
@code{stepi} e @code{nexti} mentre @code{trace} @`e abilitato li render@`a
familiari.
@end table
@node Supporto per Readline
@section Supporto per Readline
@cindex completamento dei comandi @subentry nel debugger
@cindex debugger @subentry completamento dei comandi nel
@cindex espansione della cronologia @subentry nel debugger
@cindex debugger @subentry espansione della cronologia
Se @command{gawk} @`e compilato con
@uref{http://cnswww.cns.cwru.edu/php/chet/readline/readline.html, la libreria
GNU Readline}, ci si pu@`o avvantaggiare delle sue funzionalit@`a riguardanti il
completamento dei comandi della libreria e l'espansione della cronologia. Sono
disponibili i seguenti tipi di completamento:
@table @asis
@item Completamentto dei comandi
Nomi dei comandi.
@item Completamento del @value{FN} del sorgente
@value{FFNS} dei sorgenti. I relativi comandi sono
@code{break},
@code{clear},
@code{list},
@code{tbreak}
e
@code{until}.
@item Completamento di argomento
Argomenti di un comando non numerici.
I relativi comandi sono @code{enable} e @code{info}.
@item Completamento del nome di variabile
Interessa i nomi delle variabili globali, e gli argomenti di funzione nel
contesto corrente se
il programma @`e in esecuzione. I relativi comandi sono
@code{display},
@code{print},
@code{set}
e
@code{watch}.
@end table
@node Limitazioni
@section Limitazioni
@cindex debugger @subentry limitazioni
@cindex limitazioni @subentry del debugger
Si spera che il lettore trovi il debugger di @command{gawk} utile e piacevole
da usare, ma come accade per ogni programma, specialmente nelle sue prime
versioni, ha ancora delle limitazioni. Quelle di cui @`e bene essere al corrente sono:
@itemize @value{BULLET}
@item
Nella versione presente, il debugger non d@`a una spiegazione dettagliata
dell'errore che
si @`e commesso quando si immette qualcosa che il debugger ritiene sbagliato.
La risposta invece @`e solamente @samp{syntax error}. Quando si arriva a capire
l'errore commesso, tuttavia, ci si sentir@`a come un vero guru.
@item
@c NOTE: no comma after the ref{} on purpose, due to following
@c parenthetical remark.
Se si studiano i ``dump'' dei codici operativi
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Comandi vari del debugger}
(o se si ha gi@`a familiarit@`a con i comandi interni di @command{gawk}),
ci si render@`a conto che gran parte della manipolaziona interna di dati
in @command{gawk}, cos@`{@dotless{i}} come in molti interpreti, @`e fatta su di una pila.
@code{Op_push}, @code{Op_pop}, e simili sono il pane quotidiano di
gran parte del codice di @command{gawk}.
Sfortunatamente, al momento, il debugger di @command{gawk} non consente
di esaminare i contenuti della pila.
Cio@`e, i risultati intermedi della valutazione delle espressioni sono sulla
pila, ma non @`e possibile stamparli. Invece, possono essere stampate solo
quelle variabili che sono state definite nel programma. Naturalmente, un
espediente per cercare di rimediare @`e di usare pi@`u variabili esplicite in
fase di debug e
poi cambiarle di nuovo per ottenere un codice forse pi@`u difficile da
comprendere, ma pi@`u ottimizzato.
@item
Non c'@`e alcun modo per guardare ``dentro'' al processo della compilazione delle
espressioni regolari per vedere se corrispondono a quel che si intendeva.
Come programmatore
di @command{awk}, ci si aspetta che chi legge conosca il significato di
@code{/[^[:alnum:][:blank:]]/}.
@item
Il debugger di @command{gawk} @`e progettato per essere usato eseguendo un
programma (con tutti i suoi parametri) dalla riga di comando, come descritto
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Invocazione del debugger}. Non c'@`e alcun modo (al momento) di modificare
o di ``entrare dentro'' l'esecuzione di un programma.
Questo sembra ragionevole per un linguaggio che @`e usato principalmente per
eseguire programmi piccoli e che non richiedono molto tempo di esecuzione.
@item
Il debugger di @command{gawk} accetta solo codice sorgente fornito con
l'opzione @option{-f}.
Se si sta usando uno @dfn{script} di shell che contiene un programma
@command{awk} che fa parte della riga di comando, e si deve usare il debugger,
si pu@`o scrivere lo @dfn{script} in un file temporaneo, e quindi usarlo come
programma, tramite l'opzione @option{-f}. Ci@`o si potrebbe fare nel modo
seguente:
@example
cat << \EOF > /tmp/script.$$
@dots{} @ii{Qui c'@`e il programma da eseguire}
EOF
gawk -D -f /tmp/script.$$
rm /tmp/script.$$
@end example
@end itemize
@ignore
@c 11/2016: This no longer applies after all the type cleanup work that's been done.
C'@`e un altro punto che vale la pena di trattare. I debugger convenzionali
vengono eseguiti in un processo (e quindi in una parte di memoria)
separato dal programma su cui eseguono il debug (il @dfn{debuggato}, se
si vuole).
Il debugger di @command{gawk} @`e diverso; @`e parte integrante di @command{gawk}.
Ci@`o rende possibile, in rari casi, che @command{gawk} diventi un eccellente
dimostratore del principio d'indeterminazione di Heisenberg, secondo il quale
il solo atto di osservare una cosa pu@`o modificarla. Si consideri il seguente
esempio:@footnote{Grazie a Hermann Peifer per quest'esempio.}
@example
$ @kbd{cat test.awk}
@print{} @{ print typeof($1), typeof($2) @}
$ @kbd{cat test.data}
@print{} abc 123
$ @kbd{gawk -f test.awk test.data}
@print{} strnum strnum
@end example
Questo @`e quel che ci si aspetta: il campo data ha l'attributo STRNUM
(@pxref{Tipi di variabile}). Ora vediamo cosa accade quando questo programma
viene eseguito sotto il debugger:
@example
$ @kbd{gawk -D -f test.awk test.data}
gawk> @kbd{w $1} @ii{Imposta un punto d'osservazione su} $1
@print{} Watchpoint 1: $1
gawk> @kbd{w $2} @ii{Imposta il punto d'osservazione su} $2
@print{} Watchpoint 2: $2
gawk> @kbd{r} @ii{Avvia il programma}
@print{} Partenza del programma:
@print{} Mi fermo in Rule ...
@print{} Watchpoint 1: $1 @ii{Scatta punto d'osservazione}
@print{} Old value: ""
@print{} New value: "abc"
@print{} main() a `test.awk':1
@print{} 1 @{ print typeof($1), typeof($2) @}
gawk> @kbd{n} @ii{Prosegui @dots{}}
@print{} Watchpoint 2: $2 @ii{Scatta punto d'osservazione}
@print{} Old value: ""
@print{} New value: "123"
@print{} main() a `test.awk':1
@print{} 1 @{ print typeof($1), typeof($2) @}
gawk> @kbd{n} @ii{Prende il risultato da} typeof()
@print{} strnum number @ii{Il risultato per} $2 @ii{non @`e corretto}
@c "normally" o "abnormally" @`e in inglese senza possibilit@`a di modifiche.
@print{} Programma completato normally, valore in uscita: 0
gawk> @kbd{quit}
@end example
In questo caso, la richiesta di confrontare il nuovo valore di @code{$2}
con quello vecchio ha richiesto che @command{gawk} lo valutasse e
stabilisse che era proprio un numero, e questo @`e riflesso nel risultato di
@code{typeof()}.
Casi come questi in cui il debugger non @`e trasparente rispetto all'esecuzione
del programma dovrebbero essere rari. Nel caso che se ne trovi uno, si
prega di segnalarlo (@pxref{Bug}).
@end ignore
@ignore
Look forward to a future release when these and other missing features may
be added, and of course feel free to try to add them yourself!
@end ignore
@node Sommario sul debug
@section Sommario
@itemize @value{BULLET}
@item
Raramente i programmi funzionano bene al primo colpo. Trovare gli errori
che contengono
viene chiamato @dfn{debugging}, e un programma che aiuta a trovarli @`e un
@dfn{debugger}. @command{gawk} ha un debugger incorporato che funziona in
modo molto simile al debugger GNU, GDB.
@item
I debugger possono eseguire il programma un'istruzione per volta, esaminare e
cambiare i
valori delle variabili e dei vettori, e fanno tante altre cose per
permettere di comprendere cosa sta facendo effettivamente il programma in un
dato momento (a differenza del comportamento atteso).
@item
Come la maggior parte dei debugger, il debugger di @command{gawk} funziona in
termini di @dfn{stack frame}, e si possono inserire sia punti d'interruzione
(interruzioni a un certo punto del codice) sia punti d'osservazione
(interruzioni quando il valore di un dato cambia).
@item
La serie di comandi del debugger @`e abbastanza completa, e permette di
monitorare i
punti d'interruzione, l'esecuzione, la visualizzazione e la
modifica dei dati, di lavorare con le pile, ottenere informazioni, e di
svolgere altri compiti.
@item
Se la libreria GNU Readline @`e disponibile al momento della compilazione di
@command{gawk}, viene usata dal debugger per fornire la cronologia della riga
di comando e delle modifiche apportate durante il debug.
@item
Normalmente, il debugger non influenza il programma che sta controllando,
ma questo pu@`o succedere occasionalmente.
@end itemize
@hyphenation{name-space name-spaces Name-space Name-spaces}
@node Spazi-dei-nomi
@chapter Spazi-dei-nomi in @command{gawk}
Questo @value{CHAPTER} descrive una funzionalit@`a disponibile solo in
@command{gawk}.
@quotation ATTENZIONE
La funzionalit@`a descritta in questo capitolo @`e nuova. @`E certamente
possibile, e perfino probabile, che ci siano degli angoli bui
(se non dei bug), ancora presenti nell'implementazione.
Chi ne trovasse, @`e pregato di notificarlo (@xref{Bug}).
@end quotation
@menu
* Spazio-dei-nomi globale:: Lo spazio-dei-nomi globale in
@command{awk} standard.
* Nomi qualificati:: Come qualificare nomi con uno
spazio-dei-nomi.
* Spazio-dei-nomi di default:: Lo spazio-dei-nomi di default.
* Cambiare lo spazio-dei-nomi:: Come cambiare lo spazio-dei-nomi.
* Regole per i nomi:: Regole per assegnare nomi a uno
spazio-dei-nomi ai suoi componenti.
* Gestione interna dei nomi:: Come i nomi sono gestiti internamente.
* Esempio di spazio-dei-nomi:: Esempio di codice che usa uno spazio-dei-nomi.
* Spazio-dei-nomi e funzionalit@`a:: Lo spazio-dei-nomi e le altre
funzionalit@`a di @command{gawk}.
* Sommario sugli spazi-dei-nomi:: Sommario sugli spazi-dei-nomi.
@end menu
@node Spazio-dei-nomi globale
@section Lo spazio-dei-nomi globale in @command{awk} standard
@cindex spazio-dei-nomi @subentry definizione
@cindex spazio-dei-nomi @subentry globale @subentry in @command{awk} standard
In @command{awk} standard, esiste un unico @dfn{spazio-dei-nomi} globale.
Ci@`o significa che @emph{tutti} i nomi di funzione e i nomi di variabili
globali devono essere unici.
Per esempio, due differenti file sorgenti di @command{awk},
se usati insieme,
non possono entrambi definire una funzione avente nome
@code{min()}, o definire una variabile con lo stesso nome,
usata come scalare in programma e come vettore in un altro.
Questa situazione pu@`o essere accettabile se i programmi sono
di dimensioni piccole, qualche centinaio di righe, o anche
qualche migliaio, ma impedisce lo sviluppo di librerie riusabili
contenenti funzioni di @command{awk}, e pu@`o far s@`{@dotless{i}} che file di
librerie sviluppate in maniera indipendente fra loro possano
incidentalmente entrare in conflitto con le variabili globali
``private'' proprie di un'altra libreria
(@pxref{Nomi di variabili di libreria}).
@cindex pacchetto @subentry definizione di
@cindex modulo @subentry definizione di
Molti altri linguaggi di programmazione risolvono questo problema rendendo
disponibile qualche tipo di controllo sullo spazio-dei-nomi: un modo per
poter stabilire che ``questa funzione @`e nello spazio-dei-nomi @var{xxx},
mentre quella funzione @`e nello spazio-dei-nomi @var{yyy}''. (Naturalmente,
in realt@`a c'@`e ancora un unico spazio-dei-nomi, quello composto da
tutti gli spazi-dei-nomi, ma si spera che ci siano solo pochi spazi-dei-nomi
in uso da parte di un determinato programma e, quindi, che la probabilit@`a
di conflitti sia molto minore).
Queste funzionalit@`a sono talore indicate col nome di
@dfn{pacchetti} (@dfn{packages}) o @dfn{moduli} (@dfn{modules}).
A partire dalla @value{PVERSION} 5.0, @command{gawk} fornisce un
meccanismo semplice per mettere funzioni e variabili globali in
spazi-dei-nomi separati fra loro.
@node Nomi qualificati
@section Nomi qualificati
@cindex nomi @subentry qualificati (in uno spazio-dei-nomi) @subentry definizione di
@cindex qualificato @subentry nome @subentry definizione di
@cindex spazio-dei-nomi @subentry nomi qualificati
@cindex @code{:} (due punti) @subentry @code{::} @subentry separatore spazio-dei-nomi
@cindex due punti (@code{:}) @subentry @code{::} (separatore spazio-dei-nomi)
@cindex nomi @subentry di componente (in uno spazio-dei-nomi)
@cindex componente @subentry spazio-dei-nomi @subentry nome del
Un @dfn{nome qualificato} @`e un identificativo composto
dal nome di uno spazio-dei-nomi, da un separatore di spazio-dei-nomi
(i due caratteri @code{::}), e dal nome di un @dfn{componente}.
Per esempio, ci potrebbe
essere una funzione di nome @code{posix::getpid()}. Qui, lo spazio-dei-nomi
@`e @code{posix} e il nome della funzione all'interno dello the spazio-dei-nomi
(il componente) @`e @code{getpid()}. Lo spazio-dei-nomi e i nomi di componente
sono separati da due caratteri ":".
In un nome qualificato pu@`o essere presente un unico separatore.
@quotation NOTA
A differenza di come avviene in C++, la notazione @code{::} @emph{non @`e} un
operatore. Non @`e consentito inserire degli spazi di separazione fra il
nome dello spazio-dei-nomi, la notazione @code{::}, e il nome del componente.
@end quotation
@cindex nomi @subentry qualificati (in uno spazio-dei-nomi)
@`E necessario usare nomi qualificati, in uno spazio-dei-nomi, per accedere
a variabili e funzioni in un altro spazio-dei-nomi. Ci@`o @`e particolarmente
importante quando si usano nomi di variabile come indici del vettore
speciale @code{SYMTAB} (@pxref{Variabili auto-assegnate}),
e quando si effettuano chiamate di funzione indirette
(@pxref{Chiamate indirette}).
@node Spazio-dei-nomi di default
@section Lo spazio-dei-nomi di default
@cindex spazio-dei-nomi @subentry default
@cindex spazio-dei-nomi @subentry @code{awk}
@cindex @code{awk} @subentry spazio-dei-nomi
Lo spazio-dei-nomi di default, ovviamente, @`e @code{awk}.
Tutte le variabili predefinite di @command{awk} e di @command{gawk}
sono in questo spazio-dei-nomi, e quindi hanno nomi qualificati come
@code{awk::ARGC}, @code{awk::NF}, e cos@`{@dotless{i}} via.
@cindex nomi @subentry scritti in maiuscolo @subentry sempre nello spazio-dei-nomi @code{awk}
Inoltre, anche se si sta utilizzando uno spazio-dei-nomi differente
nel file sorgente correntemente in uso
(@pxref{Cambiare lo spazio-dei-nomi}), @command{gawk}
assegna tutti gli identificativi senza una qualifica che contengono
solo lettere maiuscole allo spazio-dei-nomi @code{awk}. Ci@`o rende
possibile utilizzare facilmente le variabili globali proprie di
@command{gawk} da spazi-dei-nomi differenti.
Ci@`o rende anche pi@`u scorrevole il codice stesso.
@node Cambiare lo spazio-dei-nomi
@section Come cambiare lo spazio-dei-nomi
@cindex spazio-dei-nomi @subentry cambiare lo
@cindex cambiare @subentry lo spazio-dei-nomi
@cindex @code{@@} (chiocciola) @subentry @code{@@namespace} (direttiva)
@cindex chiocciola (@code{@@}) @subentry @code{@@namespace} (direttiva)
@cindex direttiva @subentry @code{@@namespace}
@cindex @code{@@} (chiocciola) @subentry @code{@@namespace} (direttiva)
Per impostare lo spazio-dei-nomi corrente, si usi una direttiva
@code{@@namespace}
al livello principale del programma interessato:
@example
@@namespace "passwd"
BEGIN @{ @dots{} @}
@dots{}
@end example
Dopo questa direttiva, tutti gli identificati semplici che non siano composti
esclusivamente da lettere maiuscole sono assegnati allo
spazio-dei-nomi @code{passwd}.
@`E possibile cambiare lo spazio-dei-nomi pi@`u volte all'interno di
un singolo file sorgente, sebbene ci@`o possa essere causa di
confusione, se lo si fa troppe volte.
@quotation NOTA
L'assegnamento degli identificativi non qualificati a uno spazio-dei-nomi
avviene nel momento in cui @command{gawk} analizza il programma, @emph{prima}
di cominciare a eseguirlo.
Non c'@`e quindi il concetto di uno spazio-dei-nomi ``corrente'' al momento
dell'esecuzione del programma.
Ci@`o va compreso e messo in conto in anticipo.
@end quotation
@cindex spazio-dei-nomi @subentry implicito
@cindex implicito @subentry spazio-dei-nomi
Ogni file sorgente designato dalle opzioni
@option{-i} e @option{-f} inizia con una direttiva implicita
@samp{@@namespace "awk"}. Analogamente, ogni parte di codice
immesso nella riga di comando, usando l'opzione @option{-e}
ha la stessa implicita direttiva iniziale
(@pxref{Opzioni}).
@cindex spazio-dei-nomi @subentry corrente @subentry cambiare e ripristinare
@cindex cambiare @subentry lo spazio-dei-nomi corrente
@cindex ripristinare @subentry spazio-dei-nomi corrente
@cindex corrente @subentry spazio-dei-nomi @subentry cambiare e ripristinare
I file inclusi con la direttiva @code{@@include} (@pxref{Includere file})
``cambiano'' (@dfn{push}) e ``ripristinano'' (@dfn{pop})
lo spazio-dei-nomi corrente. Ossia, ogni @code{@@include} salva
lo spazio-dei-nomi corrente e inizia con una direttiva implicita
@samp{@@namespace "awk"} che resta attiva finch@'e non si incontra una
direttiva esplicita @code{@@namespace}.
Quando @command{gawk} termina di elaborare il file incluso,
lo spazio-dei-nomi salvato @`e ripristinato e l'elaborazione prosegue
da dove era stata sospesa nel file originale.
@cindex @code{@@} (chiocciola) @subentry @code{@@namespace} (direttiva) @subentry non riguarda @code{BEGIN}, @code{BEGINFILE}, @code{END}, ed @code{ENDFILE}
@cindex chiocciola (@code{@@}) @subentry @code{@@namespace} (direttiva) @subentry non riguarda @code{BEGIN}, @code{BEGINFILE}, @code{END}, ed @code{ENDFILE}
@cindex @code{BEGIN} (regola) @subentry ordine di esecuzione non alterato da @code{@@namespace}
@cindex @code{BEGINFILE} (regola) @subentry ordine di esecuzione non alterato da @code{@@namespace}
@cindex @code{END} (regola) @subentry ordine di esecuzione non alterato da @code{@@namespace}
@cindex @code{ENDFILE} (regola) @subentry ordine di esecuzione non alterato da @code{@@namespace}
@cindex @code{@@} (chiocciola) @subentry @code{@@namespace} (direttiva)
@cindex chiocciola (@code{@@}) @subentry @code{@@namespace} (direttiva)
L'uso di @code{@@namespace} non ha influenza sull'ordine di esecuzione delle
regole @code{BEGIN}, @code{BEGINFILE}, @code{END}, e @code{ENDFILE}.
@node Regole per i nomi
@section Regole per assegnare nomi a uno spazio-dei-nomi e ai suoi componenti
@cindex nomi @subentry regole per assegnarli @subentry agli spazi-dei-nomi e ai loro componenti
@cindex spazio-dei-nomi @subentry regole per assegnare i nomi
@c not "component names" to merge with other index entry
@cindex spazio-dei-nomi @subentry componenti @subentry regole per assegnare i nomi
@cindex componente @subentry spazio-dei-nomi @subentry regole per assegnare i nomi
Alcune regole vanno seguite nell'attribuire i nomi a uno spazio-dei-nomi
e alle sue componenti.
@itemize @bullet
@item
@`E un errore sintattico (@dfn{syntax error})
usare nomi qualificati
come nomi di parametri passati a una funzione.
@item
@`E un errore sintattico (@dfn{syntax error})
usare una quasiasi parola riservata standard di @command{awk} (come
@code{if} o @code{for}), o il nome di una qualsiasi funzione predefinita
(come @code{sin()} o @code{gsub()}) come una qualsiasi delle parti di un nome
nome qualificato.
Quindi, il codice seguente produce un errore sintattico:
@example
@@namespace "example"
function gsub(str, pat, result) @{ @dots{} @}
@end example
@item
Fuori dallo spazio-dei-nomi @code{awk}, i nomi delle ulteriori funzioni
predefinite disponibili in @command{gawk}
(come @code{gensub()} o @code{strftime()}) @emph{possono}
essere usate come nomi di componente.
Lo stesso insieme di nomi pu@`o essere usato come nome di uno
spazio-dei-nomi, sebbene farlo possa ingenerare confusione.
@item
Le ulteriori funzioni predefinite disponibili in @command{gawk} possono
essere chiamate all'esterno dello spazio-dei-nomi @code{awk} utilizzando
nomi qualificati. Per esempio, @code{awk::systime()}.
Ecco un esempio abbastanza banale a dimostrazione di questa regola e
della regola precedente:
@example
BEGIN @{
print "nello spazio-dei-nomi awk, systime() =", systime()
@}
@@namespace "testing"
function systime()
@{
print "nello spazio-dei-nomi testing, systime() =", awk::systime()
@}
BEGIN @{
systime()
@}
@end example
@noindent
Se lo si esegue, l'output prodotto @`e di questo tipo:
@example
$ @kbd{gawk -f systime.awk}
@print{} nello spazio-dei-nomi awk, systime() = 1500488503
@print{} nello spazio-dei-nomi testing, systime() = 1500488503
@end example
@item
I nomi delle variabili predefinite di @command{gawk} possono essere usati:
@code{NF::NR} @`e un nome valido, anche se non sembra una scelta di
nomi molto utile.
@end itemize
@node Gestione interna dei nomi
@section Come i nomi sono gestiti internamente
@cindex nomi @subentry gestione (in uno spazio-dei-nomi)
@cindex @code{awk} @subentry spazio-dei-nomi @subentry memoria che contiene i nomi identificativi
@cindex @code{awk} @subentry spazio-dei-nomi @subentry utilizzo per chiamate indirette di funzione
Per compatibilit@`a all'indietro, tutti gli identificatvi nello spazio-dei-nomi
@code{awk} sono memorizzati internamente come identificativi senza qualifica
(ossia, senza il prefisso @samp{awk::}). Ci@`o ha importanza principalmente
quando tali identificativi sono usati come indici per i vettori
@code{SYMTAB}, @code{FUNCTAB}, e @code{PROCINFO["identifiers"]}
(@pxref{Variabili auto-assegnate}), e quando sono usati per
chiamate indirette di funzioni (@pxref{Chiamate indirette}).
Nella codifica di programmi, per far riferimento a variabili e funzioni
appartenenti allo spazio-dei-nomi @code{awk} da un altro spazio-dei-nomi
@`e tuttavia necessario utilizzare il prefisso @samp{awk::}.
Per esempio:
@example
@@namespace "awk" @ii{Questo @`e lo spazio-dei-nomi di default}
BEGIN @{
Titolo = "Il mio rapporto" @ii{Il nome qualificato @`e} awk::Titolo
@}
@@namespace "rapporto" @ii{Adesso lo spazio-dei-nomi @`e} rapporto
function calcola() @ii{Il nome vero di questa funzione @`e} rapporto::compute()
@{
print awk::Titolo @ii{Per stampare} SYMTAB["Titolo"]
@dots{}
@}
@end example
@node Esempio di spazio-dei-nomi
@section Esempio di codice che usa uno spazio-dei-nomi
@cindex spazio-dei-nomi @subentry esempio di codice
L'esempio seguente @`e una versione riveduta dell'insieme di
script sviluppati in @ref{Funzioni Passwd};
l@`{@dotless{i}} si pu@`o trovare la descrizione del funzionamento del codice.
Questa riformulazione, opera principalmente di Andrew Schorr,
@`e piuttosto elegante.
Tutte le funzioni e le variabili di implementazione
sono nello spazio-dei-nomi @code{passwd}, mentre
le funzioni principali di interfaccia sono
definite nello spazio-dei-nomi @code{awk}.
@example
@c file eg/lib/ns_passwd.awk
# ns_passwd.awk --- accedere alle informazioni del file delle password
@c endfile
@ignore
@c file eg/lib/ns_passwd.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# May 1993
# Revised October 2000
# Revised December 2010
#
# Reworked for namespaces June 2017, with help from
# Andrew J.@: Schorr, aschorr@@telemetry-investments.com
@c endfile
@end ignore
@c file eg/lib/ns_passwd.awk
@@namespace "passwd"
BEGIN @{
# modificare per adattarlo al sistema in uso
Awklib = "/usr/local/libexec/awk/"
@}
function Init( oldfs, oldrs, olddol0, pwcat, using_fw, using_fpat)
@{
if (Inizializzato)
return
oldfs = FS
oldrs = RS
olddol0 = $0
using_fw = (PROCINFO["FS"] == "FIELDWIDTHS")
using_fpat = (PROCINFO["FS"] == "FPAT")
FS = ":"
RS = "\n"
pwcat = Awklib "pwcat"
while ((pwcat | getline) > 0) @{
Byname[$1] = $0
Byuid[$3] = $0
Bycount[++Totale] = $0
@}
close(pwcat)
Contatore = 0
Inizializzato = 1
FS = oldfs
if (using_fw)
FIELDWIDTHS = FIELDWIDTHS
else if (using_fpat)
FPAT = FPAT
RS = oldrs
$0 = olddol0
@}
function awk::getpwnam(nome)
@{
Init()
return Byname[nome]
@}
function awk::getpwuid(uid)
@{
Init()
return Byuid[uid]
@}
function awk::getpwent()
@{
Init()
if (Contatore < Totale)
return Bycount[++Contatore]
return ""
@}
function awk::endpwent()
@{
Contatore = 0
@}
@c endfile
@end example
Come si pu@`o vedere, questa versione segue anche la convenzione menzionata in
@ref{Nomi di variabili di libreria}, secondo la quale i nomi di funzione e
le variabili globali iniziano con la lettera maiuscola.
Quel che segue @`e un semplice programma di test. Poich@'e @`e in un file
separato, gli identificativi non qualificati saranno ricercati
all'interno dello spazio-dei-nomi @code{awk}:
@example
BEGIN @{
while ((p = getpwent()) != "")
print p
@}
@end example
@noindent
Ecco cosa succede quando il programma viene eseguito:
@example
$ @kbd{gawk -f ns_passwd.awk -f testpasswd.awk}
@print{} root:x:0:0:root:/root:/bin/bash
@print{} daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
@print{} bin:x:2:2:bin:/bin:/usr/sbin/nologin
@print{} sys:x:3:3:sys:/dev:/usr/sbin/nologin
@dots{}
@end example
@node Spazio-dei-nomi e funzionalit@`a
@section Lo spazio-dei-nomi e le altre funzionalit@`a di @command{gawk}
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} tratta brevemente di come la funzionalit@`a spazio-dei-nomi
interagisce con altre importanti funzionalit@`a di @command{gawk}.
@cindex spazio-dei-nomi @subentry interazione con la profilazione
@cindex spazio-dei-nomi @subentry interazione con la stampa elegante
@cindex profilazione @subentry interazione con spazio-dei-nomi
@cindex stampa elegante @subentry interazione con spazio-dei-nomi
La profilazione e la stampa elegante (@pxref{Profilare}) sono state
migliorate per trattare gli spazi-dei-nomi e le regole per assegnare nomi in
uno spazio-dei-nomi @ref{Regole per i nomi}.
In particolare, l'output tiene insieme le funzioni che appartengono
allo stesso spazio-dei-nomi, e contiene delle direttive @code{@@namespace}
davanti alle regole, a seconda delle necessit@`a.
In questo modo i nomi dei componenti sono degli
identificativi semplici, senza dover usare dappertutto degli
identificativi qualificati.
@cindex spazio-dei-nomi @subentry interazione con il debugger
@cindex debugger @subentry interazione con lo spazio-dei-nomi
L'interazione con il debugger (@pxref{Debugging}) non @`e cambiata
(almeno fino al momento in cui questo libro @`e stato scritto).
Alcuni campi interni sono stati modificati per tener conto
degli spazi-dei-nomi, e il comando @code{dump} del debugger
@`e stato modificato per lo stesso motivo.
@cindex spazio-dei-nomi @subentry interazione con l'estensione API
@cindex estensione API @subentry interazione con lo spazio-dei-nomi
@cindex API (estensione) @subentry interazione con lo spazio-dei-nomi
L'estensione API (@pxref{Estensioni dinamiche}) ha sempre previsto
di avere funzioni in uno spazio-dei-nomi differente, sebbene ci@`o
non fosse stato ancora implementato. Tuttavia, le routine di
ricerca e di aggiornamento dei simbolo non prevedevano l'utilizzo
di un spazio-dei-nomi. Questo @`e stato corretto
(@pxref{Tabella simboli per nome}).
@xref{Esempio di estensione Inplace}, per un notevole esempio di
un'estensione che sfrutta uno spazio-dei-nomi condiviso fra del
codice scritto in C e del codice @command{awk}, che collaborano
fra loro.
@node Sommario sugli spazi-dei-nomi
@section Sommario
@itemize @value{BULLET}
@item
@command{awk} standard fornisce un unico spazio-dei-nomi per tutti gli
identificativi globali (scalari, vettori e funzioni).
Ci@`o pu@`o essere limitante se si vogliono sviluppare librerie di
funzioni riusabili, o gruppi di funzioni.
@item
@command{gawk} fornisce degli spazi-dei-nomi multipli, attraverso l'uso di
nomi qualificati: nomi che consistono nel nome di uno spazio-dei-nomi,
seguito da un separatore di spazio-dei-nomi (@code{::}), e da un nome di
componente. I nomi degli spazi-dei-nomi potrebbero ancora entrare in
conflitto fra loro, ma questo capita in ogni linguaggio che fornisce
spazi-dei-nomi, moduli, o pacchetti.
@item
Lo spazio-dei-nomi di default @`e @command{awk}. Le regole per gli
spazi-dei-nomi e per i nomi dei loro componenti sono descritte in
@ref{Regole per i nomi}. Le regole sono state progettate
in modo da far s@`{@dotless{i}} che il codice che usa gli spazi-dei-nomi resti
semplice da leggere e funzioni in maniera intuitiva, pur rendendo
disponibile la potenza e la flessibilit@`a necessarie.
@item
Altre parti di @command{gawk} sono state estese come necessario per
integrare gli spazi-dei-nomi nel loro funzionamento.
Questo vale soprattutto per la profilazione / stampa elegante
(@pxref{Profilare}) e per le funzionalit@`a relative alle
estensioni (@pxref{Estensioni dinamiche}).
@cindex spazio-dei-nomi @subentry compatibilit@`a all'indietro
@item
Complessivamente, la funzionalit@`a spazio-dei-nomi @`e stata progettata e
implementata avendo come preoccupazione quella di mantenere la compatibilit@`a
all'indietro. I programmi che non usano degli spazi-dei-nomi
non dovrebbero avere alcuna differenza di comportamento quando sono eseguiti
su una versione di @command{gawk} che abbia la funzionalit@`a spazio-dei-nomi.
@end itemize
@node Calcolo con precisione arbitraria
@chapter Calcolo con precisione arbitraria con @command{gawk}
@cindex precisione @subentry arbitraria
@cindex precisione @subentry multipla
@cindex precisione @subentry infinita
@cindex virgola mobile @subentry numeri in @subentry precisione arbitraria
In questo @value{CHAPTER} si introducono alcuni concetti base su come i
computer
eseguono i calcoli e si definiscono alcuni termini importanti.
Si continua poi descrivendo il calcolo in virgola mobile,
che @`e quello che @command{awk} usa per tutte le sue operazioni aritmetiche,
e si prosegue con
una trattazione del calcolo in virgola mobile con precisione arbitraria,
una funzionalit@`a disponibile solo in @command{gawk}. Si passa poi a
illustrare i numeri interi a precisione arbitraria e si conclude con una
descrizione di alcuni punti sui quali @command{gawk} e lo standard POSIX non
sono esattamente in accordo.
@quotation NOTA
La maggior parte degli utenti di @command{gawk} pu@`o saltare senza patemi
d'animo
questo capitolo. Tuttavia, se si vogliono eseguire calcoli scientifici con
@command{gawk}, questo @`e il luogo adatto per imparare a farlo.
@end quotation
@menu
* Aritmetica del computer:: Una rapida introduzione alla matematica del
computer.
* Definizioni matematiche:: Definizione dei termini usati.
* Funzionalit@`a MPFR:: Funzionalit@`a MPFR in @command{gawk}.
* Cautela col calcolo in VM:: Cose da sapere.
* Interi a precisione arbitraria:: Calcolo con numeri interi a precisione
arbitraria con @command{gawk}.
* Controllare disponibilit@`a MPFR:: Come controllare se MPFR @`e disponibile.
* Problemi virgola mobile POSIX:: Confronto tra standard e uso corrente.
* Sommario virgola mobile:: Sommario della trattazione della
virgola mobile.
@end menu
@node Aritmetica del computer
@section Una descrizione generale dell'aritmetica del computer
Sinora, abbiamo avuto a che fare con dati come numeri o stringhe. Ultimamente,
comunque, i computer rappresentano ogni cosa in termini di @dfn{cifre binarie},
o @dfn{bit}. Una cifra decimale pu@`o assumere uno di 10 valori: da zero a
nove. Una cifra binaria pu@`o assumere uno di due valori: zero o uno. Usando
il sistema binario, i computer (e i programmi per computer) possono
rappresentare e manipolare dati numerici e dati costituiti da caratteri. In
generale, tanti pi@`u bit @`e possibile usare per rappresentare una determinata
cosa, tanto maggiore sar@`a l'intervallo dei possibili valori che essa potr@`a
assumere.
I moderni calcolatori possono eseguire calcoli numerici in almeno due modi, e
spesso anche di pi@`u. Ogni tipo di calcolo usa una diversa rappresentazione
(organizzazione dei bit) dei numeri. Le modalit@`a di calcolo che ci interessano
sono:
@table @asis
@item Calcolo decimale
Questo @`e il tipo di calcolo che s'impara alle scuole elementari, usando
carta e penna (o anche una calcolatrice). In teoria, i numeri possono avere un
numero arbitrario di cifre su ambo i lati del separatore decimale, e il
risultato di un'operazione @`e sempre esatto.
Alcuni sistemi moderni possono eseguire calcoli decimali direttamente,
tramite apposite istruzioni disponibili
nell'hardware dell'elaboratore, ma normalmente si ha necessit@`a di una speciale
libreria software che consenta di effettuare le operazioni desiderate.
Ci sono anche librerie che svolgono i calcoli decimali interamente
per via software.
Anche se alcuni utenti si aspettano che @command{gawk} effettui delle
operazioni usando numeri in base decimale,@footnote{Non sappiamo perch@'e se
lo aspettino, ma @`e cos@`{@dotless{i}}.} non @`e questo quello che succede.
@item La matematica coi numeri interi
A scuola ci hanno insegnato che i valori interi erano quei numeri privi di una
parte frazionaria, come 1, 42, o @minus{}17.
Il vantaggio dei numeri interi @`e che essi rappresentano dei valori in maniera
esatta. Lo svantaggio @`e che i numeri rappresentabili sono limitati.
@cindex senza segno @subentry interi
@cindex segno @subentry interi senza
@cindex interi @subentry senza segno
@cindex numeri @subentry interi @subentry senza segno
Nei calcolatori, i valori interi sono di due tipi: @dfn{con segno} e
@dfn{senza segno}. I valori con segno possono essere negativi o positivi,
mentre i valori senza segno sono sempre maggiori o uguali a zero.
Nei sistemi informatici, il calcolo con valori interi @`e esatto, ma il possibile
campo di variazione dei valori @`e limitato. L'elaborazione con numeri interi @`e
pi@`u veloce di quella con numeri in virgola mobile.
@cindex virgola mobile @subentry numeri in
@cindex numeri @subentry in virgola mobile
@item La matematica coi numeri in virgola mobile
I numeri in virgola mobile rappresentano quelli che a scuola sono chiamati
numeri ``reali'' (cio@`e, quelli che hanno una parte frazionaria, come
3.1415927). Il vantaggio dei numeri in virgola mobile @`e che essi possono
rappresentare uno spettro di valori molto pi@`u ampio di quello rappresentato dai
numeri interi. Lo svantaggio @`e che ci sono numeri che essi non possono
rappresentare in modo esatto.
I computer moderni possono eseguire calcoli su valori in virgola mobile
nell'hardware dell'elaboratore, entro un intervallo di valori limitato.
Ci sono inoltre librerie di programmi che consentono calcoli, usando numeri in
virgola mobile, di precisione arbitraria.
@cindex virgola mobile @subentry numeri in @subentry precisione singola
@cindex virgola mobile @subentry numeri in @subentry precisione doppia
@cindex virgola mobile @subentry numeri in @subentry precisione arbitraria
@cindex precisione @subentry singola
@cindex precisione @subentry doppia
@cindex precisione @subentry arbitraria
@cindex singola @subentry precisione
@cindex doppia precisione
@cindex arbitraria @subentry precisione
POSIX @command{awk} usa numeri in virgola mobile a @dfn{doppia precisione},
che possono gestire pi@`u cifre rispetto ai numeri in virgola mobile a
@dfn{singola precisione}. @command{gawk} ha inoltre funzionalit@`a, descritte
in dettaglio pi@`u sotto, che lo mettono in grado di eseguire
calcoli con i numeri in virgola mobile con precisione arbitraria.
@end table
I calcolatori operano con valori interi e in virgola mobile su diversi
intervalli. I valori interi normalmente hanno una dimensione di 32 bit o 64 bit.
I valori in virgola mobile a singola precisione occupano 32 bit, mentre i
valori in virgola mobile a doppia precisione occupano 64 bit.
(Esistono anche numeri in virgola mobile a precisione quadrupla. Occupano
128 bit, ma non sono disponibili in @command{awk}.)
I valori in virgola mobile sono sempre con segno. I possibili campi di
variazione dei valori sono mostrati in @ref{table-numeric-ranges} e in
@ref{table-floating-point-ranges}.
@float Tabella,table-numeric-ranges
@caption{Intervallo di valori per rappresentazioni di numeri interi}
@multitable @columnfractions .34 .33 .33
@headitem Rappresentazione @tab Valore minimo @tab Valore massimo
@item Interi con segno a 32-bit @tab @minus{}2.147.483.648 @tab 2.147.483.647
@item Interi senza segno a 32-bit @tab 0 @tab 4.294.967.295
@item Interi con segno a 64-bit @tab @minus{}9.223.372.036.854.775.808 @tab 9.223.372.036.854.775.807
@item Interi senza segno a 64-bit @tab 0 @tab 18.446.744.073.709.551.615
@end multitable
@end float
@float Tabella,table-floating-point-ranges
@caption{Intervallo di valori per rappresentazioni di numeri in virgola mobile}
@multitable @columnfractions .34 .22 .22 .22
@iftex
@headitem Rappresentazione @tab @w{Valore positivo} @w{minimo} @w{diverso da zero} @tab @w{Valore finito} @w{minimo} @tab @w{Valore finito} @w{massimo}
@end iftex
@ifnottex
@headitem Rappresentazione @tab Valore positivo minimo diverso da zero @tab Valore finito minimo @tab Valore finito massimo
@end ifnottex
@iftex
@item @w{Virgola mobile, singola precis.} @tab @math{1,175494 @cdot 10^{-38}} @tab @math{-3,402823 @cdot 10^{38}} @tab @math{3,402823 @cdot 10^{38}}
@item @w{Virgola mobile, doppia precis.} @tab @math{2,225074 @cdot 10^{-308}} @tab @math{-1,797693 @cdot 10^{308}} @tab @math{1,797693 @cdot 10^{308}}
@item @w{Virgola mobile, quadrupla prec.} @tab @math{3,362103 @cdot 10^{-4932}} @tab @math{-1,189731 @cdot 10^{4932}} @tab @math{1,189731 @cdot 10^{4932}}
@end iftex
@ifinfo
@item Virgola mobile, singola precis. @tab 1,175494e-38 @tab -3,402823e38 @tab 3,402823e38
@item Virgola mobile, doppia precis. @tab 2,225074e-308 @tab -1,797693e308 @tab 1,797693e308
@item Virgola mobile, quadrupla prec. @tab 3,362103e-4932 @tab -1,189731e4932 @tab 1,189731e4932
@end ifinfo
@ifnottex
@ifnotinfo
@item Virgola mobile, singola precis. @tab 1,175494@sup{-38} @tab -3,402823@sup{38} @tab 3,402823*10@sup{38}
@item Virgola mobile, singola precis. @tab 2,225074@sup{-308} @tab -1,797693@sup{308} @tab 1,797693*10@sup{308}
@item Virgola mobile, quadrupla prec. @tab 3,362103@sup{-4932} @tab -1,189731@sup{4932} @tab 1,189731@sup{4932}
@end ifnotinfo
@end ifnottex
@end multitable
@end float
@node Definizioni matematiche
@section Altre cose da sapere
Il resto di questo @value{CHAPTER} usa un certo numero di termini. Di seguito
vengono date alcune definizioni informali che dovrebbero essere utili
per la lettura di questo documento:
@table @dfn
@item Accuratezza
L'accuratezza del calcolo sui numeri in virgola mobile indica di quanto si
avvicina il calcolo al valore reale (calcolato con carta e penna).
@item Errore
La differenza tra quello che il risultato di un calcolo ``dovrebbe dare''
e quello che effettivamente d@`a. @`E meglio minimizzare l'errore quanto pi@`u
possibile.
@item Esponente
L'ordine di grandezza di un valore;
alcuni bit in un valore in virgola mobile contengono l'esponente.
@item Inf
Un valore speciale che rappresenta l'infinito. Le operazioni tra un qualsiasi
numero e l'infinito danno infinito.
@item Mantissa
Un valore in virgola mobile @`e formato dalla mantissa moltiplicata per 10
alla potenza dell'esponente. Per esempio, in @code{1,2345e67},
la mantissa @`e @code{1,2345}.
@item Modalit@`a di arrotondamento
Come i numeri vanno arrotondati, per eccesso o per difetto, quando necessario.
Maggiori dettagli verranno forniti in seguito.
@item NaN
``Not a number'' (Non un Numero).@footnote{Grazie a Michael
Brennan per questa descrizione, che abbiamo parafrasato, e per gli esempi.} Un
valore speciale che risulta da un calcolo che non ha risposta come numero
reale. In tal caso, i programmi possono o ricevere un'eccezione di virgola
mobile, o restituire @code{NaN} come risultato. Lo standard IEEE 754
consiglia che i sistemi restituiscano @code{NaN}. Alcuni esempi:
@table @code
@item sqrt(-1)
La radice quadrata di @minus{}1 ha senso nell'insieme dei numeri complessi,
ma non nell'insieme dei numeri reali,
per cui il risultato @`e @code{NaN}.
@item log(-8)
Il logaritmo di @minus{}8 @`e fuori dal dominio di @code{log()},
per cui il risultato @`e @code{NaN}.
@end table
@item Normalizzato (formato)
Come la mantissa (vedi oltre in questa lista) @`e usualmente memorizzata. Il
valore viene aggiustato in modo che il primo bit sia sempre uno,
e in questo modo l'uno iniziale @`e supposto presente (per come viene
generato il numero), ma non @`e memorizzato fisicamente.
Questo fornisce un bit di precisione in pi@`u.
@item Precisione
Il numero di bit usati per rappresentare un numero in virgola mobile.
Pi@`u sono i bit, e maggiore @`e l'intervallo di cifre che si possono
rappresentare.
Le precisioni binaria e decimale sono legate in modo approssimativo, secondo
la formula:
@display
@iftex
@math{prec = 3.322 @cdot dps}
@end iftex
@ifnottex
@ifnotdocbook
@var{prec} = 3.322 * @var{dps}
@end ifnotdocbook
@end ifnottex
@docbook
prec = 3.322 ⋅ dps
@end docbook
@end display
@noindent
Qui, @emph{prec} indica la precisione binaria
(misurata in bit) e @emph{dps} (abbreviazione di "decimal places")
indica le cifre decimali.
@item Stabilit@`a
Dal@uref{https://en.wikipedia.org/wiki/Numerical_stability,
l'articolo di Wikipedia sulla stabilit@`a numerica}:
``I calcoli per i quali si pu@`o dimostrare che non amplificano gli errori di
approssimazione sono chiamati @dfn{numericamente stabili}.''
@end table
Si veda @uref{https://en.wikipedia.org/wiki/Accuracy_and_precision,
l'articolo di Wikipedia su accuratezza e precisione} per maggiori informazioni
su questi due termini.
Sui computer moderni, l'unit@`a di calcolo in virgola mobile usa la
rappresentazione e le operazioni definite dallo standard IEEE 754.
Tre dei tipi definiti nello standard IEEE 754 sono:
32-bit singola precisione,
64-bit doppia precisione e
128-bit quadrupla precisione.
Lo standard specifica anche formati a precisione estesa
per consentire una maggiore precisione e campi di variazione degli esponenti
pi@`u ampi. (@command{awk} usa solo il formato a 64-bit doppia precisione.)
@ref{table-ieee-formats} elenca la precisione e i valori di campo
dell'esponente per i principali formati binari IEEE 754.
@float Tabella,table-ieee-formats
@caption{Valori per i principali formati IEEE}
@multitable @columnfractions .20 .20 .20 .20 .20
@headitem Nome @tab Bit totali @tab Precisione @tab Esponente minimo @tab Esponente massimo
@item Singola @tab 32 @tab 24 @tab @minus{}126 @tab +127
@item Doppia @tab 64 @tab 53 @tab @minus{}1022 @tab +1023
@item Quadrupla @tab 128 @tab 113 @tab @minus{}16382 @tab +16383
@end multitable
@end float
@quotation NOTA
I numeri che descrivono la precisione includono la cifra 1 iniziale
implicita, il che equivale ad avere un bit in pi@`u nella mantissa.
@end quotation
@node Funzionalit@`a MPFR
@section Funzionalit@`a per il calcolo a precisione arbitraria in @command{gawk}
Per default, @command{gawk} usa i valori in virgola mobile a doppia precisione
disponibili nell'hardware del sistema su cui viene eseguito.
Tuttavia, se @`e stato compilato in modo da includere questa funzionalit@`a
ed @`e stata specificata
l'opzione da riga di comando @option{-M}, @command{gawk} usa le librerie
@uref{http://www.mpfr.org, GNU MPFR} e @uref{https://gmplib.org, GNU MP} (GMP)
per effettuare calcoli sui numeri con una precisione arbitraria.
Si pu@`o verificare se il supporto a MPFR @`e disponibile in questo modo:
@example
$ @kbd{gawk --version}
@print{} GNU Awk 4.1.2, API: 1.1 (GNU MPFR 3.1.0-p3, GNU MP 5.0.2)
@print{} Copyright (C) 1989, 1991-2015 Free Software Foundation.
@dots{}
@end example
@noindent
(I numeri di versione visualizzati possono essere diversi. Non importa;
l'importante @`e che siano presenti GNU MPFR e GNU MP
nel testo restituito.)
Inoltre, ci sono alcuni elementi disponibili nel vettore @code{PROCINFO}
per fornire informazioni sulle librerie MPFR e GMP
(@pxref{Variabili auto-assegnate}).
La libreria MPFR d@`a un controllo accurato sulle precisioni e sulle modalit@`a di
arrotondamento, e d@`a risultati correttamente arrotondati, riproducibili e
indipendenti dalla piattaforma. Con l'opzione da riga di comando @option{-M},
tutti gli operatori aritmetici e le funzioni in virgola mobile possono
produrre risultati a ogni livello di precisione supportato da MPFR.
Due variabili predefinite, @code{PREC} e @code{ROUNDMODE},
danno il controllo sulla precisione di elaborazione e sulla modalit@`a di
arrotondamento. La precisione e la modalit@`a di arrotondamento sono impostate
a livello globale per ogni operazione da eseguire.
@xref{Impostare la precisione} e
@iftex
la
@end iftex
@ref{Impostare modo di arrotondare}
per maggiori informazioni.
@node Cautela col calcolo in VM
@section Calcolo in virgola mobile: @dfn{Caveat Emptor}!
@quotation
@i{L'ora di matematica @`e ostica!}
@author Teen Talk Barbie, luglio 1992
@end quotation
Questa @value{SECTION} fornisce un quadro dettagliato dei problemi che
si presentano quando si eseguono molti calcoli in virgola
mobile.@footnote{C'@`e un saggio molto bello
@uref{http://www.validlab.com/goldberg/paper.pdf, sul calcolo in
virgola mobile} di David Goldberg, ``What Every Computer Scientist Should Know
About Floating-Point Arithmetic,''
@cite{ACM Computing Surveys} @strong{23}, 1 (1991-03): 5-48. Vale la pena di
leggerlo, se si @`e interessati a scendere nei dettagli, per@`o richiede delle
conoscenze informatiche.}
Le spiegazioni fornite valgono sia per il calcolo in virgola mobile
effettuato direttamente dall'hardware del computer, sia per quello
ottenuto tramite il software per la precisione arbitraria.
@quotation ATTENZIONE
Le informazioni fornite in questa sede sono deliberatamente di tipo generale.
Se si devono eseguire calcoli complessi col computer, si dovrebbero prima
ottenere ulteriori informazioni, e non basarsi solo su quanto qui detto.
@end quotation
@menu
* Inesattezza nei calcoli:: La matematica in virgola mobile non @`e
esatta.
* Ottenere la precisione:: Ottenere pi@`u precisione richiede qualche
sforzo.
* Tentare di arrotondare:: Aggiungere cifre di precisione e arrotondare.
* Impostare la precisione:: Come impostare la precisione.
* Impostare modo di arrotondare:: Impostare le modalit@`a di arrotondamento.
@end menu
@node Inesattezza nei calcoli
@subsection La matematica in virgola mobile non @`e esatta
Le rappresentazioni e i calcoli con numeri in virgola mobile binari sono
inesatti. Semplici valori come 0,1 non possono essere rappresentati in modo
preciso usando numeri in virgola mobile binari, e la limitata precisione dei
numeri in virgola mobile significa che piccoli cambiamenti nell'ordine delle
operazioni o la precisione di memorizzazione di operazioni
intermedie pu@`o cambiare il
risultato. Per rendere la situazione pi@`u difficile, nel calcolo in virgola
mobile con precisione arbitraria, si pu@`o impostare la precisione prima di
eseguire un calcolo, per@`o non si pu@`o sapere con certezza quale sar@`a
il numero di cifre decimali esatte nel risultato finale.
@menu
* Rappresentazioni inesatte:: I numeri non sono rappresentati esattamente.
* Confronti tra valori in VM:: Come confrontare valori in virgola mobile.
* Gli errori si sommano:: Gli errori diventano sempre maggiori.
@end menu
@node Rappresentazioni inesatte
@subsubsection Molti numeri non possono essere rappresentati esattamente
Perci@`o, prima di iniziare a scrivere del codice, si dovrebbe pensare
al risultato che si vuole effettivamente ottenere e a cosa realmente accade.
Si considerino i due numeri nel seguente esempio:
@example
x = 0.875 # 1/2 + 1/4 + 1/8
y = 0.425
@end example
Diversamente dal numero in @code{y}, il numero memorizzato in @code{x}
@`e rappresentabile esattamente nel formato binario, perch@'e pu@`o essere
scritto come somma finita di una o pi@`u frazioni i cui denominatori sono tutti
multipli di due.
Quando @command{gawk} legge un numero in virgola mobile dal sorgente di un
programma, arrotonda automaticamente quel numero alla precisione, quale che
sia, supportata dal computer in uso. Se si tenta di stampare il contenuto
numerico di una variabile usando una stringa di formato in uscita di
@code{"%.17g"}, il valore restituito pu@`o non essere lo stesso numero assegnato
a quella variabile:
@example
$ @kbd{gawk 'BEGIN @{ x = 0.875; y = 0.425}
> @kbd{ printf("%0.17g, %0.17g\n", x, y) @}'}
@print{} 0.875, 0.42499999999999999
@end example
Spesso l'errore @`e talmente piccolo da non essere neppure notato, e se @`e stato
notato, si pu@`o sempre specificare il grado di precisione si vuole nell'output.
In genere questo @`e una stringa di formato come @code{"%.15g"} che, se usata
nell'esempio precedente, d@`a luogo a un output identico all'input.
@node Confronti tra valori in VM
@subsubsection Fare attenzione quando si confrontano valori
Poich@'e la rappresentazione interna del computer
pu@`o discostarsi, sia pur di poco, dal valore
esatto, confrontare dei valori in virgola mobile per vedere se sono esattamente
uguali @`e generalmente una pessima idea. Questo @`e un esempio in cui tale
confronto non funziona come dovrebbe:
@example
$ @kbd{gawk 'BEGIN @{ print (0.1 + 12.2 == 12.3) @}'}
@print{} 0
@end example
Il metodo generalmente seguito per confrontare valori in virgola mobile
consiste nel controllare se la differenza tra loro @`e minore di un certo valore
(chiamato @dfn{delta}, o @dfn{tolleranza}). Quel che si deve decidere @`e qual
@`e il valore minimo di delta
adeguato. Il codice per far ci@`o @`e qualcosa del genere:
@example
@group
delta = 0.00001 # per esempio
differenza = abs(a - b) # sottrazione dei due valori
if (differenza < delta)
# va bene
else
# non va bene
@end group
@end example
@noindent
(Si presuppone che sia stata definita in qualche altra parte del programma
una semplice funzione di nome @code{abs()}.) Se si scrive una funzione
per confrontare dei valori con un valore dato @samp{delta}, si dovrebbe
utilizzare la notazione @samp{differenza < abs(delta)} nel caso che
a @samp{delta} venga assegnato un valore negativo.
@node Gli errori si sommano
@subsubsection Gli errori diventano sempre maggiori
La perdita di accuratezza in un singolo calcolo con numeri in virgola mobile
generalmente non dovrebbe destare preoccupazione. Tuttavia, se si calcola un
valore che @`e una sequenza di operazioni in virgola mobile, l'errore si pu@`o
accumulare e influire sensibilmente sul risultato del calcolo stesso.
Qui sotto vediamo un tentativo di calcolare il valore di @value{PI} usando
una delle sue rappresentazioni
come somma di una serie di numeri:
@example
BEGIN @{
x = 1.0 / sqrt(3.0)
n = 6
for (i = 1; i < 30; i++) @{
n = n * 2.0
x = (sqrt(x * x + 1) - 1) / x
printf("%.15f\n", n * x)
@}
@}
@end example
Quando viene eseguito, gli errori iniziali si propagano nei calcoli
successivi, facendo terminare il ciclo prematuramente dopo un tentativo di
divisione per zero:
@example
$ @kbd{gawk -f pi.awk}
@print{} 3.215390309173475
@print{} 3.159659942097510
@print{} 3.146086215131467
@print{} 3.142714599645573
@dots{}
@print{} 3.224515243534819
@print{} 2.791117213058638
@print{} 0.000000000000000
@error{} gawk: pi.awk:6: fatale: tentativo di dividere per zero
@end example
Ecco un altro esempio in cui l'inaccuratezza nelle rappresentazioni interne
porta a un risultato inatteso:
@example
$ @kbd{gawk 'BEGIN @{}
> @kbd{for (d = 1.1; d <= 1.5; d += 0.1) # esegue il ciclo cinque volte (?)}
> @kbd{i++}
> @kbd{print i}
> @kbd{@}'}
@print{} 4
@end example
@node Ottenere la precisione
@subsection Ottenere la precisione voluta
Pu@`o il calcolo con precisione arbitraria dare risultati esatti? Non ci sono
risposte facili. Le regole standard dell'algebra spesso non valgono
nei calcoli con precisione arbitraria.
Tra le altre cose, le leggi distributiva e associativa non sono rispettate
completamente, e l'ordine dell'operazione pu@`o essere importante per
il calcolo.
Errori di arrotondamento, perdite di precisione che si accumulano, e
valori molto vicini allo zero sono spesso causa di problemi.
Quando @command{gawk} verifica l'eguaglianza delle espressioni
@samp{0.1 + 12.2} e @samp{12.3} usando l'aritmetica a doppia precisione della
macchina, decide che non sono uguali! (@xref{Confronti tra valori in VM}.)
Si pu@`o ottenere il risultato cercato aumentando la precisione; 56 bit in
questo caso sono sufficienti:
@example
$ @kbd{gawk -M -v PREC=56 'BEGIN @{ print (0.1 + 12.2 == 12.3) @}'}
@print{} 1
@end example
Se aggiungere pi@`u bit @`e una buona cosa, aggiungerne ancora di pi@`u
@`e meglio?
Ecco cosa succede se si usa un valore di @code{PREC} ancora pi@`u alto:
@example
$ @kbd{gawk -M -v PREC=201 'BEGIN @{ print (0.1 + 12.2 == 12.3) @}'}
@print{} 0
@end example
Non @`e un bug di @command{gawk} o della libreria MPFR.
@`E facile dimenticare che il numero finito di bit usato per memorizzare il
valore spesso @`e solo un'approssimazione dopo un opportuno arrotondamento. Il
test di uguaglianza riesce se e solo se @emph{tutti} i bit dei due operandi
sono esattamente gli stessi. Poich@'e questo non @`e necessariamente vero dopo un
calcolo in virgola mobile con una determinata precisione e con una modalit@`a di
arrotondamento valida, un test di eguaglianza convenzionale potrebbe non
riuscire. Invece, il test riesce confrontando i due numeri per vedere se la
differenza tra di loro rientra in un delta accettabile.
In applicazioni dove sono sufficienti fino a 15 cifre decimali,
il calcolo in doppia precisione eseguito dall'hardware del computer
pu@`o essere una buona soluzione,
e in genere @`e pi@`u veloce. Per@`o bisogna tener presente che ogni operazione in
virgola mobile pu@`o subire un nuovo errore di arrotondamento con conseguenze
catastrofiche, come si @`e visto nel precedente tentativo di calcolare il valore
di @value{PI}.
In tali casi una precisione supplementare pu@`o aumentare la stabilit@`a e
l'accuratezza del calcolo.
Oltre a ci@`o, bisogna tenere conto del fatto che
addizioni ripetute non sono necessariamente equivalenti a una moltiplicazione
nell'aritmetica in virgola mobile. Nell'esempio visto in
@ref{Gli errori si sommano}:
@example
$ @kbd{gawk 'BEGIN @{}
> @kbd{for (d = 1.1; d <= 1.5; d += 0.1) # ciclo eseguito cinque volte (?)}
> @kbd{i++}
> @kbd{print i}
> @kbd{@}'}
@print{} 4
@end example
@noindent
non @`e detto che, scegliendo per @code{PREC} un valore arbitrariamente alto, si
riesca a ottenere il risultato corretto. La riformulazione del problema in
questione @`e spesso il modo corretto di comportari in tali situazioni.
@node Tentare di arrotondare
@subsection Tentare di aggiungere bit di precisione e arrotondare
Invece dell'aritmetica in virgola mobile con precisione arbitraria,
spesso tutto ci@`o di cui si ha bisogno @`e un aggiustamento della logica
o di un diverso ordine delle operazioni nei calcoli.
La stabilit@`a e l'accuratezza del calcolo di @value{PI}
nel primo esempio possono essere migliorata usando la seguente semplice
trasformazione algebrica:
@example
(sqrt(x * x + 1) - 1) / x @equiv{} x / (sqrt(x * x + 1) + 1)
@end example
@noindent
Dopo aver fatto questo cambiamento, il programma converge verso
@value{PI} in meno di 30 iterazioni:
@example
$ @kbd{gawk -f pi2.awk}
@print{} 3.215390309173473
@print{} 3.159659942097501
@print{} 3.146086215131436
@print{} 3.142714599645370
@print{} 3.141873049979825
@dots{}
@print{} 3.141592653589797
@print{} 3.141592653589797
@end example
@node Impostare la precisione
@subsection Impostare la precisione
@command{gawk} usa una precisione di lavoro a livello globale; non tiene
traccia della precisione e accuratezza dei singoli numeri. Eseguendo
un'operazione aritmetica o chiamando una funzione predefinita, il risultato
viene arrotondato alla precisione di lavoro. La precisione di lavoro di default
@`e di 53 bit, modificabile usando la variabile predefinita @code{PREC}. Si pu@`o
anche impostare il valore a una delle stringhe predefinite (non importa se
scritte in maiuscolo o minuscolo) elencate in
@ref{table-predefined-precision-strings},
per emulare un formato binario che segue lo standard IEEE 754.
@float Tabella,table-predefined-precision-strings
@caption{Stringhe di precisione predefinita per @code{PREC}}
@multitable {@code{"double"}} {12345678901234567890123456789012345}
@headitem @code{PREC} @tab formato binario IEEE 754
@item @code{"half"} @tab 16-bit mezza precisione
@item @code{"single"} @tab 32-bit singole precisione di base
@item @code{"double"} @tab 64-bit doppia precisione di base
@item @code{"quad"} @tab 128-bit quadrupla precisione di base
@item @code{"oct"} @tab 256-bit ottupla precisione
@end multitable
@end float
Il seguente esempio illustra gli effetti del cambiamento di precisione
sulle operazioni aritmetiche:
@example
$ @kbd{gawk -M -v PREC=100 'BEGIN @{ x = 1.0e-400; print x + 0}
> @kbd{PREC = "double"; print x + 0 @}'}
@print{} 1e-400
@print{} 0
@end example
@quotation ATTENZIONE
Diffidare delle costanti in virgola mobile! Quando si legge una costante in
virgola mobile dal codice sorgente di un programma, @command{gawk} usa la
precisione di default (quella del formato @code{double} di C), a meno che non
venga richiesto, tramite la variabile speciale @code{PREC} fornita
sulla riga di comando, di memorizzarla internamente come un numero MPFR.
Cambiare la precisione tramite @code{PREC} nel testo del programma @emph{non}
cambia la precisione di una costante.
Se si deve rappresentare una costante in virgola mobile con una precisione
maggiore di quella di default e non @`e possibile usare un assegnamento a
@code{PREC} da riga di comando, si dovrebbe definire la costante o come
stringa, o come numero razionale, ove possibile. L'esempio seguente illustra le
differenze tra i diversi modi di stampare una costante in virgola mobile:
@example
$ @kbd{gawk -M 'BEGIN @{ PREC = 113; printf("%0.25f\n", 0.1) @}'}
@print{} 0.1000000000000000055511151
$ @kbd{gawk -M -v PREC=113 'BEGIN @{ printf("%0.25f\n", 0.1) @}'}
@print{} 0.1000000000000000000000000
$ @kbd{gawk -M 'BEGIN @{ PREC = 113; printf("%0.25f\n", "0.1") @}'}
@print{} 0.1000000000000000000000000
$ @kbd{gawk -M 'BEGIN @{ PREC = 113; printf("%0.25f\n", 1/10) @}'}
@print{} 0.1000000000000000000000000
@end example
@end quotation
@node Impostare modo di arrotondare
@subsection Impostare la modalit@`a di arrotondamento
@cindex @code{ROUNDMODE} (variabile)
@cindex variabile @subentry @code{ROUNDMODE}
La variabile @code{ROUNDMODE} permette di controllare a livello di programma
la modalit@`a di arrotondamento.
La corrispondenza tra @code{ROUNDMODE} e le modalit@`a di arrotondamento IEEE
@`e mostrata in @ref{table-gawk-rounding-modes}.
@float Tabella,table-gawk-rounding-modes
@caption{Modalit@`a di arrotondamento in @command{gawk} }
@multitable @columnfractions .45 .30 .25
@headitem Modalit@`a di arrotondamento @tab Nome IEEE @tab @code{ROUNDMODE}
@item Arrotonda al pi@`u vicino, o a un numero pari @tab @code{roundTiesToEven} @tab @code{"N"} o @code{"n"}
@item Arrotonda verso infinito @tab @code{roundTowardPositive} @tab @code{"U"} o @code{"u"}
@item Arrotonda verso meno infinito @tab @code{roundTowardNegative} @tab @code{"D"} o @code{"d"}
@item Arrotonda verso zero (troncamento) @tab @code{roundTowardZero} @tab @code{"Z"} o @code{"z"}
@item Arrotonda lontano da zero (per eccesso) @tab @tab @code{"A"} o @code{"a"}
@end multitable
@end float
@code{ROUNDMODE} ha @code{"N"} come valore di default, ovvero si usa la
modalit@`a di arrotondamento IEEE 754 @code{roundTiesToEven}.
In @ref{table-gawk-rounding-modes}, il valore @code{"A"} seleziona
l'arrotondamento lontano da zero (per eccesso).
Questo @`e applicabile solo se la versione in uso
della libreria MPFR lo supporta; altrimenti, l'impostazione di @code{ROUNDMODE}
ad @code{"A"} non ha alcun effetto.
La modalit@`a di default @code{roundTiesToEven} @`e la pi@`u preferita, ma allo
stesso tempo
la meno intuitiva. Questo metodo fa la cosa ovvia per la maggior parte dei
valori, arrotondandoli per eccesso o per difetto alla cifra pi@`u prossima.
Per esempio, arrotondando 1.132 alle due cifre decimali si ottiene 1.13,
e 1.157 viene arrotondato a 1.16.
Tuttavia, se si deve arrotondare un valore posto esattamente a met@`a strada,
le cose non funzionano come probabilmente si insegna a scuola.
In questo caso, il numero @`e arrotondato alla cifra @emph{pari} pi@`u prossima.
Cos@`{@dotless{i}} arrotondando 0.125 alle due cifre si arrotonda per difetto a 0.12,
ma arrotondando 0.6875 alle tre cifre si arrotonda per eccesso a 0.688.
Probabilmente ci si @`e gi@`a imbattuti in questa modalit@`a di arrotondamento
usando @code{printf} per formattare numeri in virgola mobile.
Per esempio:
@example
BEGIN @{
x = -4.5
for (i = 1; i < 10; i++) @{
x += 1.0
printf("%4.1f => %2.0f\n", x, x)
@}
@}
@end example
@noindent
produce il seguente output quando viene eseguito sul sistema
dell'autore:@footnote{@`E possibile che l'output sia completamente diverso, se la
libreria C presente nel sistema in uso non si conforma, per @code{printf},
alla regola IEEE 754
di arrotondamento al valore pari in caso di equidistanza.}
@example
-3.5 => -4
-2.5 => -2
-1.5 => -2
-0.5 => 0
0.5 => 0
1.5 => 2
2.5 => 2
3.5 => 4
4.5 => 4
@end example
La teoria che sta dietro alla regola
@code{roundTiesToEven} @`e che gli arrotondamenti di
valori equidistanti in eccesso e in difetto si distribuiscono pi@`u o meno
uniformemente, con la possibile conseguenza che errori di arrotondamento
ripetuti tendono ad annullarsi a vicenda. Questa @`e la modalit@`a di
arrotondamento di default per funzioni e operatori di calcolo secondo IEEE 754.
@c January 2018. Thanks to nethox@gmail.com for the example.
@sidebar Modalit@`a di arrotondamento e conversioni
@`E importante comprendere che, insieme a @code{CONVFMT} e
@code{OFMT}, la modalit@`a di arrotondamento ha effetto anche sul
modo con cui i numeri sono convertiti in stringhe di caratteri.
Per esempio,si consideri il seguente programma:
@example
BEGIN @{
pi = 3.1416
OFMT = "%.f" # Stampa il valore come numero intero
print pi # ROUNDMODE = "N" per default.
ROUNDMODE = "U" # Ora si cambia ROUNDMODE
print pi
@}
@end example
@noindent
L'esecuzione di questo programma produce il seguente output:
@example
$ @kbd{gawk -M -f roundmode.awk}
@print{} 3
@print{} 4
@end example
@end sidebar
Le altre modalit@`a di arrotondamento sono usate raramente. Gli arrotondamenti
verso l'infinito (@code{roundTowardPositive}) e verso il meno infinito
(@code{roundTowardNegative}) vengono spesso usati per eseguire calcoli su
intervalli, dove si adotta questa modalit@`a di arrotondamento per calcolare
i limiti superiore e inferiore per l'intervallo di valori in uscita.
La modalit@`a
@code{roundTowardZero} pu@`o essere usata per convertire numeri in virgola mobile
in numeri interi. Quando si arrotonda lontano da zero (per eccesso), viene
scelto il numero pi@`u vicino di grandezza maggiore o uguale al valore.
Qualche esperto di analisi numerica dir@`a che la scelta dello stile di
arrotondamento ha un grandissimo impatto sul risultato finale, e consiglier@`a
di attendere sino al risultato finale dopo ogni arrotondamento. Invece,
spesso si possono evitare problemi legati a errori di arrotondamento
impostando all'inizio la precisione a un valore sufficientemente maggiore
della precisione desiderata, in modo che il cumulo degli errori di
arrotondamento non influisca sul
risultato finale. Se si ha il dubbio che i risultati del calcolo contengano
un'accumulazione di errori di arrotondamento, occorre, per accertare la cosa,
controllare se si verifica una differenza significativa nell'output
cambiando la modalit@`a di arrotondamento.
@node Interi a precisione arbitraria
@section Aritmetica dei numeri interi a precisione arbitraria con @command{gawk}
@cindex numeri @subentry interi @subentry a precisione arbitraria
@cindex interi @subentry a precisione arbitraria
@cindex precisione @subentry arbitraria @subentry interi a
Quando viene specificata l'opzione @option{-M},
@command{gawk} esegue tutti i calcoli sui numeri interi usando gli interi a
precisione arbitraria della libreria GMP. Qualsiasi numero che appaia come un
intero in un sorgente o in un @value{DF} @`e memorizzato come intero a precisione
arbitraria. La dimensione del numero intero ha come limite solo la memoria
disponibile. Per esempio, il seguente programma calcola
@iftex
@math{5^{4^{3^{2}}}},
@end iftex
@ifinfo
5^4^3^2,
@end ifinfo
@ifnottex
@ifnotinfo
5@sup{4@sup{3@sup{2}}},
@end ifnotinfo
@end ifnottex
il cui risultato @`e oltre i limiti degli ordinari valori in virgola mobile a
doppia precisione dei processori:
@example
$ @kbd{gawk -M 'BEGIN @{}
> @kbd{x = 5^4^3^2}
> @kbd{print "numero di cifre =", length(x)}
> @kbd{print substr(x, 1, 20), "...", substr(x, length(x) - 19, 20)}
> @kbd{@}'}
@print{} numero di cifre = 183231
@print{} 62060698786608744707 ... 92256259918212890625
@end example
Se invece si dovesse calcolare lo stesso valore usando valori in virgola mobile
con precisione arbitraria, la precisione necessaria per il risultato corretto
(usando
la formula
@iftex
@math{prec = 3.322 @cdot dps})
sarebbe @math{3.322 @cdot 183231},
@end iftex
@ifnottex
@ifnotdocbook
@samp{prec = 3.322 * dps})
sarebbe 3.322 x 183231,
@end ifnotdocbook
@end ifnottex
@docbook
prec = 3.322 ⋅ dps)
would be
prec = 3.322 ⋅ 183231,
@end docbook
o 608693.
Il risultato di un'operazione aritmetica tra un intero e un valore in virgola
mobile @`e un valore in virgola mobile con precisione uguale alla precisione di
lavoro. Il seguente programma calcola l'ottavo termine nella successione di
Sylvester@footnote{Weisstein, Eric W.
@cite{Sylvester's Sequence}. From MathWorld --- A Wolfram Web Resource
@w{(@url{http://mathworld.wolfram.com/SylvestersSequence.html}).}}
usando una ricorrenza:
@example
$ @kbd{gawk -M 'BEGIN @{}
> @kbd{s = 2.0}
> @kbd{for (i = 1; i <= 7; i++)}
> @kbd{s = s * (s - 1) + 1}
> @kbd{print s}
> @kbd{@}'}
@print{} 113423713055421845118910464
@end example
Il risultato mostrato differisce dal numero effettivo,
113.423.713.055.421.844.361.000.443,
perch@'e la precisione di default di 53 bit non @`e suffciente per rappresentare
esattamente il risultato in virgola mobile. Si pu@`o o aumentare la precisione
(in questo caso bastano 100 bit), o sostituire la costante in virgola mobile
@samp{2.0} con un intero, per eseguire tutti i calcoli usando l'aritmetica con
gli interi per ottenere l'output corretto.
A volte @command{gawk} deve convertire implicitamente un intero con precisione
arbitraria in un valore in virgola mobile con precisione arbitraria.
Ci@`o si rende necessario
principalmente perch@'e la libreria MPFR non sempre prevede l'interfaccia
necessaria per elaborare interi a precisione arbitraria o numeri di tipo
eterogeneo come richiesto da un'operazione o funzione. In tal caso, la
precisione viene impostata al minimo valore necessario per una conversione
esatta, e non viene usata la precisione di lavoro. Se
questo non @`e quello di cui si ha bisogno o che si vuole, si pu@`o ricorrere a un
sotterfugio e convertire preventivamente l'intero in un valore in virgola
mobile, come qui di seguito:
@example
gawk -M 'BEGIN @{ n = 13; print (n + 0.0) % 2.0 @}'
@end example
Si pu@`o evitare completamente questo passaggio specificando il numero come
valore in virgola mobile fin dall'inizio:
@example
gawk -M 'BEGIN @{ n = 13.0; print n % 2.0 @}'
@end example
Si noti che, per questo specifico esempio, probabilmente @`e meglio
semplicemente specificare:
@example
gawk -M 'BEGIN @{ n = 13; print n % 2 @}'
@end example
Dividendo due interi a precisione arbitraria con @samp{/} o con @samp{%}, il
risultato @`e tipicamente un valore in virgola mobile con precisione arbitraria
(a meno che il risultato non sia un numero intero esatto).
@ifset INTDIV
Per eseguire divisioni intere o calcolare moduli con interi a precisione
arbitraria, usare la funzione predefinita
@code{intdiv0()} (@pxref{Funzioni numeriche}).
Si pu@`o simulare la funzione @code{intdiv0()} in @command{awk} standard
usando questa funzione definita dall'utente:
@example
@c file eg/lib/intdiv0.awk
# intdiv0 --- fa una divisione intera
@c endfile
@ignore
@c file eg/lib/intdiv0.awk
#
# Arnold Robbins, arnold@@skeeve.com, Public Domain
# July, 2014
#
# Name changed from div() to intdiv()
# April, 2015
#
# Changed to intdiv0()
# April, 2016
@c endfile
@end ignore
@c file eg/lib/intdiv0.awk
function intdiv0(numerator, denominator, result)
@{
split("", result)
numerator = int(numerator)
denominator = int(denominator)
result["quotient"] = int(numerator / denominator)
result["remainder"] = int(numerator % denominator)
return 0.0
@}
@c endfile
@end example
Il seguente programma d'esempio, proposto da Katie Wasserman,
usa @code{intdiv0()} per
calcolare le cifre di @value{PI} al numero di cifre significative
che si @`e scelto di impostare:
@example
@c file eg/prog/pi.awk
@group
# pi.awk --- calcola le cifre di pi
@c endfile
@c endfile
@ignore
@c file eg/prog/pi.awk
#
# Katie Wasserman, katie@@wass.net
# August 2014
@c endfile
@end ignore
@c file eg/prog/pi.awk
BEGIN @{
cifre = 100000
due = 2 * 10 ^ cifre
@end group
pi = due
for (m = cifre * 4; m > 0; --m) @{
d = m * 2 + 1
x = pi * m
intdiv0(x, d, risultato)
pi = risultato["quotient"]
pi = pi + due
@}
print pi
@}
@c endfile
@end example
@ignore
Date: Wed, 20 Aug 2014 10:19:11 -0400
To: arnold@skeeve.com
From: Katherine Wasserman
Subject: Re: computation of digits of pi?
Arnold,
>The program that you sent to compute the digits of pi using div(). Is
>that some standard algorithm that every math student knows? If so,
>what's it called?
It's not that well known but it's not that obscure either
It's Euler's modification to Newton's method for calculating pi.
Take a look at lines (23) - (25) here: http://mathworld.wolfram.com/PiFormulas.htm
The algorithm I wrote simply expands the multiply by 2 and works from
the innermost expression outwards. I used this to program HP calculators
because it's quite easy to modify for tiny memory devices with smallish
word sizes.
http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=899
@end quotation
-Katie
@end ignore
Quando gli fu chiesto dell'algoritmo usato, Katie rispose:
@quotation
Non @`e quello pi@`u noto ma nemmeno quello pi@`u incomprensibile.
@`E la variante di Eulero al metodo di Newton per il calcolo del Pi greco.
Si vedano le righe (23) - (25) nel sito:
@uref{http://mathworld.wolfram.com/PiFormulas.html}.
L'algoritmo che ho scritto semplicemente espande il moltiplicare per 2 e
lavora dall'espressione pi@`u interna verso l'esterno. Ho usato questo per
programmare delle calcolatrici HP perch@'e @`e piuttosto facile da adattare ai
dispositivi di scarsa memoria con dimensioni di parola piuttosto piccole.
Si veda
@uref{http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=899}.
@end quotation
@end ifset
@node Controllare disponibilit@`a MPFR
@section Come controllare se MPFR @`e disponibile
@cindex MPFR @subentry controllare disponibilit@`a
@cindex controllo @subentry disponibilit@`a MPFR
Occasionalmente, potrebbe essere utile controllare se @command{gawk} sia stato
chiamato specificando l'opzione @option{-M}, che consente di effettuare
calcoli aritmetici di precisione arbitraria.
Lo si pu@`o fare con la funzione seguente, messa a disposizione da
Andrew Schorr:
@example
@c file eg/lib/have_mpfr.awk
# precisione_matematica_sufficiente
# --- restituisce "true" [vero]
# se il numero di bit "n" di precisione richiesto
# @`e disponibile per il programma
@c endfile
@ignore
@c file eg/lib/have_mpfr.awk
#
# Andrew Schorr, aschorr@@telemetry-investments.com, Public Domain
# May 2017
@c endfile
@end ignore
@c file eg/lib/have_mpfr.awk
function adequate_math_precision(n)
@{
return (1 != (1+(1/(2^(n-1)))))
@}
@c endfile
@end example
Ecco un frammento di codice che invoca la funzione per controllare
se l'aritmetica a precisione arbitraria @`e disponibile:
@example
BEGIN @{
# Quanti bit di precisione nella mantissa sono necessari
# perch@'e questo programma funzioni correttamente?
fpbits = 123
# Si spera che il programma sia stato invocato con MPFR abilitata.
# Se @`e questo il caso, le istruzioni seguenti dovrebbero configurare
# i calcoli al livello di precisione desiderato.
PREC = fpbits
if (! adequate_math_precision(fpbits)) @{
print("Errore: la precisione di calcolo disponibile non basta.\n" \
"Provare ancora specificando l'argomento -M?") > "/dev/stderr"
# Nota: pu@`o essere necessario impostare un flag a questo punto
# per evitare di eseguire delle eventuali regole END
exit 1
@}
@}
@end example
Occorre tener presente che @code{exit} eseguir@`a le regole @code{END},
eventualmente contenute nel programma (@pxref{Istruzione exit}).
@node Problemi virgola mobile POSIX
@section Confronto tra standard e uso corrente
Per diverso tempo, @command{awk} ha convertito le stringhe dall'aspetto non
numerico nel valore numerico zero, quando richiesto. Per di pi@`u, la
definizione originaria del linguaggio e lo standard POSIX originale prevedevano
che @command{awk} riconoscesse solo i numeri decimali (base 10), e non i numeri
ottali (base 8) o esadecimali (base 16).
Le modifiche nel linguaggio degli standard POSIX 2001 e 2004 possono essere
interpretate nel senso che @command{awk} debba fornire delle funzionalit@`a
aggiuntive. Queste sono:
@itemize @value{BULLET}
@item
Interpretazione del valore dei dati in virgola mobile specificati in notazione
esadecimale (p.es., @code{0xDEADBEEF}). (Da notare: valore dei dati letti,
@emph{non} costanti facenti parte del codice sorgente.)
@item
Supporto per i valori in virgola mobile speciali IEEE 754 ``not a number''
(NaN), pi@`u infinito (``inf'') e meno infinito (``@minus{}inf'').
In particolare, il formato per questi valori @`e quello specificato dallo
standard C ISO 1999, che non distingue maiuscole/minuscole e pu@`o consentire
caratteri aggiuntivi dipendenti dall'implementazione dopo il @samp{nan}, e
consentire o @samp{inf} o @samp{infinity}.
@end itemize
Il primo problema @`e che entrambe le modifiche sono deviazioni evidenti
dalla prassi consolidata:
@itemize @value{BULLET}
@item
Il manutentore di @command{gawk} crede che supportare i valori in virgola mobile
esadecimali, nello specifico, sia sbagliato, e che non sia mai stata intenzione
dell'autore originale di introdurlo nel linguaggio.
@item
Consentire che stringhe completamente alfabetiche abbiano valori numerici
validi @`e anch'essa una deviazione molto marcata dalla prassi consolidata.
@end itemize
Il secondo problema @`e che il manutentore di @command{gawk} crede che questa
interpretazione dello standard, che richiede una certa dimestichezza col
linguaggio giuridico per essere compresa, non sempre @`e stata
colta dai normali sviluppatori. In altre parole, ``Sappiamo come siete
arrivati sin qui, ma non pensiamo che questo sia il posto dove volete essere.''
Recependo queste argomentazioni, e cercando nel contempo di assicurare la
compatibilit@`a con le versioni precedenti dello standard, lo standard POSIX 2008
ha aggiunto delle formulazioni esplicite per consentire l'uso da parte di
@command{awk}, solo a richiesta, dei valori in virgola mobile esadecimali e
dei valori speciali
``@dfn{not a number}'' e infinito.
Sebbene il manutentore di @command{gawk} continui a credere che introdurre
queste funzionalit@`a sia sconsigliabile, ci@`o nonostante, sui sistemi che
supportano i valori in virgola mobile IEEE, sembra giusto fornire
@emph{qualche}
possibilit@`a di usare i valori NaN e infinito. La soluzione implementata
in @command{gawk} @`e questa:
@itemize @value{BULLET}
@item
Se @`e stata specificata l'opzione da riga di comando @option{--posix},
@command{gawk} non
interviene. I valori di stringa sono passati direttamente alla funzione
@code{strtod()} della libreria di sistema, e se quest'ultima restituisce
senza errori un valore numerico,
esso viene usato.@footnote{L'avete voluto, tenetevelo.}
Per definizione, i risultati non sono portabili su diversi sistemi;
e sono anche piuttosto sorprendenti:
@example
$ @kbd{echo nanny | gawk --posix '@{ print $1 + 0 @}'}
@print{} nan
$ @kbd{echo 0xDeadBeef | gawk --posix '@{ print $1 + 0 @}'}
@print{} 3735928559
@end example
@item
Senza l'opzione @option{--posix}, @command{gawk} interpreta i quattro valori di stringa
@samp{+inf},
@samp{-inf},
@samp{+nan}
e
@samp{-nan}
in modo speciale, producendo i corrispondenti valori numerici speciali.
Il segno iniziale serve per segnalare a @command{gawk} (e all'utente)
che il valore @`e realmente numerico. I numeri in virgola mobile esadecimali
non sono consentiti (a meno di non usare anche @option{--non-decimal-data},
che @emph{non} @`e consigliabile). Per esempio:
@example
$ @kbd{echo nanny | gawk '@{ print $1 + 0 @}'}
@print{} 0
$ @kbd{echo +nan | gawk '@{ print $1 + 0 @}'}
@print{} +nan
$ @kbd{echo 0xDeadBeef | gawk '@{ print $1 + 0 @}'}
@print{} 0
@end example
@command{gawk} ignora la distinzione maiuscole/minuscole nei quattro valori
speciali. Cos@`{@dotless{i}}, @samp{+nan} e @samp{+NaN} sono la stessa cosa.
@end itemize
@cindex POSIX @subentry modalit@`a
Oltre a gestire l'input, @command{gawk} deve anche stampare valori
``corretti'' in output, quando un valore sia NaN o infinito.
A partire dalla @value{PVERSION} 4.2.2, per tali valori
@command{gawk} stampa una delle quattro stringhe sopra descritte:
@samp{+inf}, @samp{-inf}, @samp{+nan}, or @samp{-nan}.
Analogamente,se usato in modalit@`a POSIX, @command{gawk} stampa il risultato
della funzione C di sistema @code{printf()} usando la stringa di formato
@code{%g} per il valore, quale che esso sia.
@node Sommario virgola mobile
@section Sommario
@itemize @value{BULLET}
@item
La maggior parte dell'aritmetica al calcolatore @`e fatta usando numeri interi
oppure
valori in virgola mobile. L'@command{awk} standard usa valori in virgola mobile
a doppia precisione.
@item
Nei primi anni '90 Barbie disse erroneamente, ``L'ora di matematica @`e
ostica!'' Sebbene la matematica non sia ostica, l'aritmetica in virgola
mobile non @`e proprio come la
matematica ``carta e penna'', e bisogna prestare attenzione:
@c nested list
@itemize @value{MINUS}
@item
Non tutti i numeri possono essere rappresentati in modo esatto.
@item
Per confrontare dei valori bisognerebbe usare un delta, invece di farlo
direttamente con @samp{==} e @samp{!=}.
@item
Gli errori si accumulano.
@item
Le operazioni non sempre sono esattamente associative o distributive.
@end itemize
@item
Aumentare l'accuratezza pu@`o essere d'aiuto, ma non @`e una panacea.
@item
Spesso, aumentare la precisione e poi arrotondare al numero di cifre
desiderato produce risultati soddisfacenti.
@item
Specificare l'opzione @option{-M} (o @option{--bignum}) per abilitare
il calcolo MPFR.
Usare @code{PREC} per impostare la precisione in bit, e
@code{ROUNDMODE} per impostare la modalit@`a di arrotondamento tra quelle
previste nello standard IEEE 754.
@item
Specificando l'opzione @option{-M}, @command{gawk} esegue calcoli su interi a precisione
arbitraria usando la libreria GMP. In tal modo si ha una maggiore velocit@`a e
una pi@`u efficiente allocazione dello spazio rispetto all'uso di MPFR per
eseguire gli stessi calcoli.
@item
Ci sono diverse aree per quanto attiene ai numeri in virgola mobile in cui
@command{gawk} @`e in disaccordo con lo standard POSIX.
@`E importante averlo ben presente.
@item
In generale, non vi @`e alcun bisogno di essere eccessivamente diffidenti verso i
risultati del calcolo in virgola mobile. La lezione da ricordare @`e che
il calcolo in virgola mobile @`e sempre pi@`u complesso di quello che si fa con
carta e penna. Per trarre vantaggio dalla potenza del calcolo in virgola
mobile, bisogna conoscere i suoi limiti e stare all'interno di essi.
Per la maggior parte degli usi occasionali del calcolo in virgola mobile, si
possono ottenere i risultati attesi semplicemente arrotondando la
visualizzazione dei risultati finali al giusto numero di cifre decimali
significative.
@item
Come consiglio generale, evitare di rappresentare dati numerici in maniera
tale da far sembrare che la precisione sia maggiore di quella effettivamente
necessaria.
@end itemize
@node Estensioni dinamiche
@chapter Scrivere estensioni per @command{gawk}
@cindex estensioni @subentry caricare @subentry dinamicamente
@cindex dinamiche @subentry estensioni
@`E possibile aggiungere nuove funzioni, scritte in C o C++, a @command{gawk}
usando librerie caricate dinamicamente. Questa funzionalit@`a @`e disponibile
su sistemi che supportano le funzioni C @code{dlopen()} e @code{dlsym()}.
Questo @value{CHAPTER} descrive come creare estensioni usando codice scritto
in C o C++.
Chi @`e completamente digiuno di programmazione in C pu@`o tranquillamente
saltare questo @value{CHAPTER}, ma potrebbe valer la pena di dare un'occhiata
alla documentazione sulle estensioni che sono installate insieme a
@command{gawk} (@pxref{Esempi di estensione}),
e alle informazioni sul progetto @code{gawkextlib} (@pxref{gawkextlib}).
Gli esempi di estensione sono automaticamente compilati e installati quando
si installa @command{gawk}.
@quotation NOTA
Se si specifica l'opzione @option{--sandbox}, le estensioni non sono
disponibili
(@pxref{Opzioni}).
@end quotation
@menu
* Introduzione alle estensioni:: Cos'@`e un'estensione.
* Licenza delle estensioni:: Una nota riguardo al tipo di licenza.
* Panoramica sul meccanismo delle estensioni:: Una panoramica sul meccanismo
delle estensioni.
* Descrizione dell'estensione API:: Una descrizione completa dell'API.
* Trovare le estensioni:: Come @command{gawk} trova le estensioni
compilate.
* Esempio di estensione:: Esempio di codice C di un'estensione.
* Esempi di estensione:: Le estensioni di esempio incluse con
@command{gawk}.
* gawkextlib:: Il progetto @code{gawkextlib}.
* Sommario delle estensioni:: Sommario delle estensioni.
* Esercizi sulle estensioni:: Esercizi.
@end menu
@node Introduzione alle estensioni
@section Cos'@`e un'estensione
@cindex plug-in
Un'@dfn{estensione} (talora chiamata @dfn{plug-in}) @`e un frammento di codice
compilato esternamente che @command{gawk} pu@`o caricare in fase di esecuzione
per ottenere funzionalit@`a ulteriori, che vanno ad aggiungersi a quelle di
@command{gawk} descritte nel resto di questo @value{DOCUMENT}.
Le estensioni sono utili perch@'e consentono (ovviamente) di estendere le
funzionalit@`a di @command{gawk}. Per esempio, possono permettere l'uso di
@dfn{chiamate di sistema} (come @code{chdir()} per cambiare directory)
e di altre routine di libreria C potenzialmente utili. Come per la maggior
parte del software, ``il cielo @`e il limite''; se si riesce a immaginare
qualcosa che si vuol fare e che @`e possibile programmare in C o C++,
si pu@`o scrivere un'estensione che lo faccia!
Le estensioni sono scritte in C o C++, usando l'API (@dfn{Application
Programming Interface}) definita per questo scopo dagli sviluppatori di
@command{gawk}. Il resto di questo @value{CHAPTER} descrive
le possibilit@`a offerte dall'API e come usarle,
e illustra una piccola estensione di esempio. Inoltre, sono documentati
gli esempi di estensione inclusi nella distribuzione di @command{gawk}
e viene descritto il progetto @code{gawkextlib}.
@ifclear FOR_PRINT
@xref{Progetto delle estensioni}, per una disamina degli obiettivi e del
progetto del meccanismo delle estensioni.
@end ifclear
@ifset FOR_PRINT
Si veda @uref{https://www.gnu.org/software/gawk/manual/html_node/Extension-Design.html}
per una disamina degli obiettivi e del
progetto del meccanismo delle estensioni.
@end ifset
@node Licenza delle estensioni
@section Tipo di licenza delle estensioni
Ogni estensione dinamica dev'essere distribuita in base a una licenza che sia
compatibile con la licenza GNU GPL (@pxref{Copia}).
Per far sapere a @command{gawk} che la licenza @`e quella corretta,
l'estensione deve definire il simbolo globale
@code{plugin_is_GPL_compatibile}. Se tale simbolo non @`e stato definito,
@command{gawk} termina con un messaggio di errore fatale al momento del
caricamente dell'estensione.
Il tipo dichiarato per il suddetto simbolo dev'essere @code{int}. Esso non
deve tuttavia essere presente in ogni sezione allocata.
Il controllo in essere si limita a constatare che quel simbolo esiste a
livello globale.
Qualcosa del genere pu@`o essere sufficiente:
@example
int plugin_is_GPL_compatible;
@end example
@node Panoramica sul meccanismo delle estensioni
@section Una panoramica sul funzionamento ad alto livello
La comunicazione tra
@command{gawk} e un'estensione @`e bidirezionale. Dapprima, quando
un'estensione @`e caricata, @command{gawk} le passa un puntatore a una struttura
(@code{struct}) i cui campi sono dei puntatori di funzione.
@ifnotdocbook
Questo si pu@`o vedere in @ref{figura-carica-estensione}.
@end ifnotdocbook
@ifdocbook
Questo si pu@`o vedere in @inlineraw{docbook, }.
@end ifdocbook
@ifnotdocbook
@float Figura,figura-carica-estensione
@caption{Caricamento dell'estensione}
@ifclear SMALLPRINT
@center @image{api-figura1, , , Caricamento dell'estensione}
@end ifclear
@ifset SMALLPRINT
@center @image{api-figura1, 11cm, , Caricamento dell'estensione}
@end ifset
@end float
@end ifnotdocbook
@docbook
Caricamento dell'estensione
@end docbook
L'estensione @`e in grado di chiamare funzioni all'interno di @command{gawk}
utilizzando questi puntatori a funzione, in fase di esecuzione, senza aver
bisogno di accedere (in fase di compilazione), ai simboli di @command{gawk}.
Uno di questi puntatori a funzione punta a una funzione che serve per
``registrare'' nuove funzioni.
@ifnotdocbook
Questo @`e mostrato in @ref{figura-registrare-una-nuova-funzione}.
@end ifnotdocbook
@ifdocbook
Questo @`e shown in @inlineraw{docbook, }.
@end ifdocbook
@ifnotdocbook
@float Figura,figura-registrare-una-nuova-funzione
@caption{Registrare una nuova funzione}
@ifclear SMALLPRINT
@center @image{api-figura2, , , Registrare una nuova funzione}
@end ifclear
@ifset SMALLPRINT
@center @image{api-figura2, 11cm , , Registrare una nuova funzione}
@end ifset
@end float
@end ifnotdocbook
@docbook
Registering a new function
@end docbook
Nella direzione opposta, l'estensione registra le sue nuove funzioni
con @command{gawk} passando dei puntatori che puntano alle funzioni che
implementano la nuova funzionalit@`a, (p.es. @code{do_chdir()}). @command{gawk}
associa il puntatore a funzione con un nome ed @`e in grado di chiamarlo in
seguito, usando una convenzione di chiamata predefinita.
@ifnotdocbook
Questo @`e mostrato in @ref{figura-chiamata-nuova-funzione}.
@end ifnotdocbook
@ifdocbook
Questo @`e mostrato in @inlineraw{docbook, }.
@end ifdocbook
@ifnotdocbook
@float Figura,figura-chiamata-nuova-funzione
@caption{Chiamata della nuova funzione}
@ifclear SMALLPRINT
@center @image{api-figura3, , , Chiamata della nuova funzione}
@end ifclear
@ifset SMALLPRINT
@center @image{api-figura3,11cm , , Chiamata della nuova funzione}
@end ifset
@end float
@end ifnotdocbook
@docbook
Chiamata della nuova funzione
@end docbook
La funzione @code{do_@var{xxx}()}, a sua volta, utilizza i puntatori a
funzione nella struttura (@code{struct}) API per svolgere il proprio compito,
come aggiornare variabili o vettori, stampare messaggi, impostare la
variabile @code{ERRNO}, e cos@`{@dotless{i}} via.
Delle macro di servizio rendono la chiamata effettuata utilizzando
i puntatori simile a quella delle funzioni normali, in modo che il codice
sorgente delle estensioni rimanga sufficientemente leggibile e comprensibile.
Sebbene tutto ci@`o possa sembrare piuttosto complesso, il risultato @`e che il
codice sorgente dell'estensione @`e abbastanza intuitivo da scrivere e da
leggere. Lo si pu@`o constatare nell'estensione di esempio
@file{filefuncs.c}
(@pxref{Esempio di estensione}), come pure nel codice @file{testext.c},
che testa l'interfaccia di programmazione (API).
Ecco alcuni ulteriori dettagli:
@itemize @value{BULLET}
@item
L'API fornisce accesso ai valori delle variabili @command{gawk}
@code{do_@var{xxx}}, che memorizzano opzioni della riga di comando come
@code{do_lint}, @code{do_profiling}, e cos@`{@dotless{i}} via (@pxref{Variabili dell'estensione API}).
Questi valori sono solo informativi: un'estensione non pu@`o modificarli
all'interno di @command{gawk}. Oltre a ci@`o, il tentativo di assegnare loro
dei valori produce un errore quando l'estensione viene compilata.
@item
L'API fornisce anche i numeri che identificano la specifica versione di
@command{gawk}, in modo che un'estensione possa controllare se il
comando @command{gawk} che l'ha caricata @`e in grado di supportare le
funzionalit@`a utilizzate nell'estensione. (Discrepanze tra le versioni
``non dovrebbero'' accadere, ma si sa come vanno @emph{queste} cose.)
@xref{Versione dell'estensione} per ulteriori dettagli.
@end itemize
@node Descrizione dell'estensione API
@section Una descrizione completa dell'API
@cindex estensione API
@cindex API (estensione)
Il codice sorgente scritto in C o C++ per un'estensione deve includere il
file di intestazione
@file{gawkapi.h}, che dichiara le funzioni e definisce i tipi di dati
usati per comunicare con @command{gawk}.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
(non breve) @value{SECTION} descrive l'API in dettaglio.
@menu
* Intro funzioni estensione API:: Introduzione alle funzioni dell'API.
* Tipi di dati generali:: I tipi di dati.
* Funzioni di allocazione memoria:: Funzioni per allocare memoria.
* Funzioni di costruzione:: Funzioni per creare valori.
* API e gestione valori MPFR e GMP:: Gestione valori MPFR e GMP.
* Funzioni di registrazione:: Funzioni per registrare cose con
@command{gawk}.
* Stampare messaggi:: Funzioni per stampare messaggi.
* Aggiornare @code{ERRNO}:: Funzioni per aggiornare @code{ERRNO}.
* Richiedere valori:: Come ottenere un valore.
* Accedere ai parametri:: Funzioni per accedere ai parametri.
* Accedere alla tabella simboli:: Funzioni per accedere alle variabili
globali
* Manipolazione di vettori:: Funzioni per lavorare coi vettori.
* Ridirezione API:: Come accedere alla ridirezioni e
modificarle.
* Variabili dell'estensione API:: Variabili fornite dall'API.
* Codice predefinito di un'estensione API:: Codice predefinito di
interfaccia API.
* Modifiche dalla versione API 1:: Modifiche dalla versione 1 dell'API.
@end menu
@node Intro funzioni estensione API
@subsection Introduzione alle funzioni dell'API
L'accesso a funzionalit@`a interne a @command{gawk} @`e effettuato
con una chiamata che usa i puntatori a funzione resi disponibili
all'estensione.
Puntatori a funzioni API sono previsti per i seguenti tipi di operazioni:
@itemize @value{BULLET}
@item
Allocare, riallocare e liberare memoria.
@item
Registrare funzioni. Si possono registrare:
@c nested list
@itemize @value{MINUS}
@item
Funzioni di estensione
@item
Funzioni ausiliarie di pulizia (@dfn{callbacks})
@item
Una stringa di caratteri che identifica la versione
@item
Funzioni per analizzare l'input
@item
Funzioni per modificare l'output
@item
Processori bidirezionali
@end itemize
Tutti questi elementi sono spiegati dettagliatamente nel resto di questo @value{CHAPTER}.
@item
Stampare messaggi fatali, di avvertimento e quelli generati dall'opzione
``lint''.
@item
Modificare @code{ERRNO} o annullarne il valore.
@item
Accedere a parametri, compresa la possibilit@`a di definire come vettore
un parametro ancora indefinito.
@item
Accedere alla "tabella dei simboli": procurarsi il valore di una variabile
globale, crearne una nuova o modificarne una gi@`a esistente.
@item
Creare ed eliminare valori nascosti; ci@`o rende possibile usare un
particolare valore per pi@`u di una variabile, e pu@`o migliorare parecchio
le prestazioni.
@item
Manipolare vettori:
@itemize @value{MINUS}
@item
Ritrovare il valore di elementi del vettore, aggiungerne di nuovi,
cancellare e modificare elementi esistenti.
@item
Ottenere il numero di elementi presenti in un vettore
@item
Creare un nuovo vettore
@item
Cancellare un intero vettore
@item
Appiattire un vettore per poter facilmente eseguire un ciclo, in stile C,
su tutti i suoi indici ed elementi
@end itemize
@item
Accedere a ridirezioni e manipolarle.
@end itemize
Alcune osservazioni riguardo all'uso dell'API:
@itemize @value{BULLET}
@item
I seguenti tipi di variabili, macro e/o funzioni sono resi disponibili
nel file @file{gawkapi.h}. Perch@'e siano utilizzabili, i rispettivi file di
intestazione standard indicati devono essere stati specificati @emph{prima}
di includere @file{gawkapi.h}.
La lista delle macro e dei relativi file di intestazioni @`e contenuta
in @ref{tabella-intestazioni-standard-api}.
@float Tabella,tabella-intestazioni-standard-api
@caption{File di intestazioni standard usati nell'API}
@multitable {@code{memset()}, @code{memcpy()}} {@code{}}
@headitem Elemento C @tab File d'intestazione
@item @code{EOF} @tab @code{}
@item valori di @code{errno} @tab @code{}
@item @code{FILE} @tab @code{}
@item @code{NULL} @tab @code{}
@item @code{memcpy()} @tab @code{}
@item @code{memset()} @tab @code{}
@item @code{size_t} @tab @code{}
@item @code{struct stat} @tab @code{}
@end multitable
@end float
Per ragioni di portabilit@`a, specialmente per sistemi
che non sono interamente aderenti agli standard, occorre assicurarsi di
includere i file corretti nel modo corretto. Questa richiesta mira
a mantenere il file @file{gawkapi.h} ordinato, invece che farlo diventare
un'accozzaglia di problemi di portabilit@`a, quale si pu@`o vedere in alcune
parti del codice sorgente di @command{gawk}.
@item
Se l'estensione usa le funzionalit@`a MPFR, e si desidera ricevere valori
numerici di precisione arbitraria da @command{gawk} e/o passare ad esso
tali valori, si deve includere l'intestazione
@code{} prima di includere @code{}.
@item
Il file @file{gawkapi.h} pu@`o essere incluso pi@`u volte, senza conseguenze
negative. Tuttavia sarebbe meglio evitare di farlo, per uno
stile di programmazione migliore.
@item
Sebbene l'API usi solo funzionalit@`a ISO C 90, c'@`e un'eccezione; le funzione
``costruttrici'' usano la parola chiave @code{inline}. Se il compilatore in
uso non supporta questa parola chiave, si dovrebbe specificare sulla
riga di comando il parametro @samp{-Dinline=''} oppure usare gli strumenti
Autotools GNU e includere un file
@file{config.h} nel codice sorgente delle estensioni.
@item
Tutti i puntatori messi a disposizione da @command{gawk} puntano ad aree
di memoria gestite da @command{gawk} e dovrebbero essere trattati
dall'estensione come in sola lettura.
Le aree di memoria che contengono @emph{tutte} le stringhe passate a
@command{gawk} dall'estensione @emph{devono} provenire da una chiamata a
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()},
e sono gestite da @command{gawk} da quel punto in avanti.
La memoria che contiene valori MPFR/GMP provenienti da @command{gawk}
dovrebbe anche essere trattata come in sola lettura.
Inoltre, a differenza di quel che succede per le stringhe,
la memoria che contiene valori MPFR/GMP allocati da un'estensione
e passati in seguito a @command{gawk} @`e @emph{copiata} da @command{gawk};
@`e quindi l'estensione che dovrebbe liberare quelle aree di memoria,
per evitare perdite di memoria. Ulteriori dettagli a questo
riguardo si possono trovare in @ref{API e gestione valori MPFR e GMP}.
@item
L'API definisce parecchie semplici strutture @code{struct} che mappano dei valori
come sono visti da @command{awk}. Un valore pu@`o essere un numero @code{double}
(in virgola mobile, in doppia precisione), una stringa o un
vettore (come @`e il caso per i vettori multidimensionali o nella creazione di
un nuovo vettore).
I valori di tipo stringa sono costituiti da un puntatore e da una lunghezza,
poich@'e nella stringa possono essere presenti dei caratteri @sc{nul}
(zeri binari, che normalmente marcano la fine di una stringa).
@quotation NOTA
Di proposito, @command{gawk} immagazzina le stringhe usando la codifica
multibyte correntemente in uso (come definita dalle variabili d'ambiente
@env{LC_@var{xxx}}) e non usando dei caratteri larghi (ovvero due byte per
ogni carattere). Ci@`o riflette il modo con cui @command{gawk} memorizza le
stringhe internamente, e anche il modo in cui i caratteri sono
verosimilmente letti dai file in input e scritti nei file in output.
@end quotation
@quotation NOTA
I valori di una stringa passati a un'estensione da @command{gawk} hanno
sempre un carattere @sc{nul} alla fine (come delimitatore). Quindi @`e
possibile usare senza inconvenienti tali valori di stringa per chiamare
funzioni di libreria standard e routine di sistema. Tuttavia, poich@'e
@command{gawk} consente che all'interno di una stringa di dati possano
essere presenti caratteri @sc{nul}, si dovrebbe controllare che la
lunghezza di ogni stringa passata un'estensione coincida con il valore
restituito dalla funzione @code{strlen()} per la stringa stessa.
@end quotation
@item
Per ottenere un valore (p.es. quello di un parametro o quello di una
variabile globale, oppure di un elemento di un vettore), l'estensione chiede
un tipo specifico di variabile (numero, stringa,
scalare, @dfn{value cookie} [si veda pi@`u avanti], vettore o ``undefined'').
Quando la richiesta @`e
``undefined,'' il valore restituito sar@`a quello originale della variabile in
questione.
In ogni caso, se la richiesta e il tipo effettivo della variabile non
corrispondono, la funzione di accesso restituisce ``false'' e fornisce il
tipo proprio della variabile, in modo che l'estensione possa, p.es.,
stampare un messaggio di errore
(del tipo ``ricevuto uno scalare, invece del vettore previsto'').
@c This is documented in the header file and needs some expanding upon.
@c The table there should be presented here
@end itemize
Si possono chiamare le funzioni dell'API usando i puntatori a funzione
direttamente, ma l'interfaccia non @`e molto elegante. Per permettere al
codice sorgente delle estensioni di assomigliare di pi@`u a un codice normale,
il file di intestazione @file{gawkapi.h} definisce parecchie
macro da usare nel codice sorgente dell'estensione.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} presenta le macro come se si trattasse di funzioni.
@node Tipi di dati generali
@subsection I tipi di dati di impiego generale
@cindex Robbins @subentry Arnold
@cindex Ramey, Chet
@quotation
@i{Ho un vero rapporto di amore/odio con le @dfn{unioni}.}
@author Arnold Robbins
@end quotation
@quotation
@i{Questo @`e ci@`o che contraddistingue le @dfn{unioni}: il compilatore @`e
in grado di accomodare le cose in modo da far coesistere amore e odio.}
@author Chet Ramey
@end quotation
L'estensione API definisce un certo numero di semplici tipi di dato e
strutture di uso generale. Ulteriori strutture di dati, pi@`u specializzate,
saranno introdotte
@ifnotinfo
nelle successive
@end ifnotinfo
@ifinfo
nei successivi
@end ifinfo
@value{SECTIONS}, insieme alle funzioni che ne fanno uso.
I tipi di dati e le strutture di uso generale sono le seguenti:
@table @code
@item typedef void *awk_ext_id_t;
Un valore di questo tipo @`e trasmesso da @command{gawk} a un'estensione nel
momento in cui viene caricata. Tale valore dev'essere restituito
a @command{gawk} come primo parametro di ogni funzione API.
@item #define awk_const @dots{}
Questa macro genera delle @samp{costanti} nel momento in cui si compila
un'estensione, e non genera nulla quando si compila il comando @command{gawk}
vero e proprio. Ci@`o rende alcuni
campi nelle strutture dei dati dell'API non alterabili dal codice sorgente
dell'estensione, ma consente al comando @command{gawk} di usarle secondo
necessit@`a.
@item typedef enum awk_bool @{
@itemx @ @ @ @ awk_false = 0,
@itemx @ @ @ @ awk_true
@itemx @} awk_bool_t;
Un semplice tipo di variabile booleana.
@item typedef struct awk_string @{
@itemx @ @ @ @ char *str;@ @ @ @ @ /* dati veri e propri */
@itemx @ @ @ @ size_t len;@ @ @ @ /* lunghezza degli stessi, in caratteri */
@itemx @} awk_string_t;
Questo rappresenta una stringa modificabile. @command{gawk} @`e responsabile
per la gestione della memoria utilizzata, se ha fornito il valore della
stringa. Altrimenti, assume il possesso della memoria in questione.
@emph{Questa memoria dev'essere resa disponibile chiamando una delle funzioni
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}!}
Come gi@`a detto, la rappresentazione delle stringhe in memoria usa la codifica
multibyte corrente.
@item typedef enum @{
@itemx @ @ @ @ AWK_UNDEFINED,
@itemx @ @ @ @ AWK_NUMBER,
@itemx @ @ @ @ AWK_STRING,
@itemx @ @ @ @ AWK_REGEX,
@itemx @ @ @ @ AWK_STRNUM,
@itemx @ @ @ @ AWK_ARRAY,
@itemx @ @ @ @ AWK_SCALAR,@ @ @ @ @ @ @ @ @ /* accesso opaco a una variabile */
@itemx @ @ @ @ AWK_VALUE_COOKIE@ @ @ @ /* per aggiornare un valore
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ gi@`a creato */
@itemx @} awk_valtype_t;
L'elenco @code{enum} indica di che tipo @`e un certo valore.
@`E usato nella seguente struttura @code{struct}.
@item typedef struct awk_value @{
@itemx @ @ @ @ awk_valtype_t val_type;
@itemx @ @ @ @ union @{
@itemx @ @ @ @ @ @ @ @ awk_string_t@ @ @ @ @ @ @ s;
@itemx @ @ @ @ @ @ @ @ awknum_t@ @ @ @ @ @ @ @ @ @ @ n;
@itemx @ @ @ @ @ @ @ @ awk_array_t@ @ @ @ @ @ @ @ a;
@itemx @ @ @ @ @ @ @ @ awk_scalar_t@ @ @ @ @ @ @ scl;
@itemx @ @ @ @ @ @ @ @ awk_value_cookie_t@ vc;
@itemx @ @ @ @ @} u;
@itemx @} awk_value_t;
Un ``valore di @command{awk}''.
Il campo @code{val_type} indica che tipo di valore @code{union} contiene,
e ogni campo @`e del tipo appropriato.
@item #define str_value@ @ @ @ @ @ u.s
@itemx #define strnum_value@ @ @ str_value
@itemx #define regex_value@ @ @ @ str_value
@itemx #define num_value@ @ @ @ @ @ u.n.d
@itemx #define num_type@ @ @ @ @ @ @ u.n.type
@itemx #define num_ptr@ @ @ @ @ @ @ @ u.n.ptr
@itemx #define array_cookie@ @ @ u.a
@itemx #define scalar_cookie@ @ u.scl
@itemx #define value_cookie@ @ @ u.vc
L'uso di queste macro rende pi@`u facile da seguire l'accesso ai campi di
@code{awk_value_t}.
@item enum AWK_NUMBER_TYPE @{
@itemx @ @ @ @ AWK_NUMBER_TYPE_DOUBLE,
@itemx @ @ @ @ AWK_NUMBER_TYPE_MPFR,
@itemx @ @ @ @ AWK_NUMBER_TYPE_MPZ
@itemx @};
La lista @code{enum} @`e usata nella struttura seguente per definire
il tipo di valore numerico con cui si ha a che fare. Va dichiarata al
livello pi@`u alto del file, in modo da poter essere usata sia con il
linguaggio C++ che con il C.
@item typedef struct awk_number @{
@itemx @ @ @ @ double d;
@itemx @ @ @ @ enum AWK_NUMBER_TYPE type;
@itemx @ @ @ @ void *ptr;
@itemx @} awk_number_t;
Questo rappresenta un valore numerico. Internamente, @command{gawk}
memorizza ogni numero o come una variabile C di tipo @code{double},
o come un numero intero GMP, o come un numero MPFR in virgola mobile
di precisione arbitraria. Per consentire alle estensioni di
supportare valori numerici GMP ed MPFR, i valori numerici sono
trasmessi utilizzando questa struttura.
L'elemento in doppia-precisione @code{d} @`e sempre presente nei dati
ricevuti da @command{gawk}. Inoltre, esaminando il membro
@code{type}, un'estensione @`e in grado di determinare se il membro puntato
da @code{ptr} sia un numero intero GMP (tipo @code{mpz_ptr}), o un numero
MPFR in virgola mobile (tipo @code{mpfr_ptr_t}), e trasformarlo a seconda
delle necessit@`a.
@quotation ATTENZIONE
Ogni valore MPFR o MPZ da voi creato e poi passato a @command{gawk}
per essere salvato viene @emph{copiato}. Ci@`o significa che la
responsabilit@`a di liberare la memoria una volta che non serva pi@`u
@`e a carico di chi scrive l'estensione. Vedere il codice
dell'estensione di esempio @code{intdiv} per un esempio di questo
tipo.
@end quotation
@item typedef void *awk_scalar_t;
La variabili scalari possono essere rappresentate da un tipo opaco. Questi
valori sono ottenuti da @command{gawk} e in seguito gli vengono restituiti.
Questo argomento @`e discusso in maniera generale nel testo che segue questa
lista, e pi@`u in dettaglio
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Tabella simboli tramite cookie}.
@item typedef void *awk_value_cookie_t;
Un ``@dfn{value cookie}'' @`e un tipo di variabile opaca, e
rappresenta un valore nascosto.
Anche questo argomento @`e discusso in maniera generale nel testo che segue
questa lista, e pi@`u in dettaglio
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Valori nascosti}.
@end table
I valori di tipo scalare in @command{awk} sono numeri, stringhe, @dfn{strnum}
o @dfn{regexp} fortemente tipizzate.
La struttura @code{awk_value_t} rappresenta valori.
Il campo @code{val_type} indica cosa contiene @code{union}.
Rappresentare numeri @`e facile: l'API usa una variabile C di tipo
@code{double}. Le stringhe richiedono
uno sforzo maggiore. Poich@'e
@command{gawk} consente che le stringhe contengano dei byte @sc{nul}
(a zeri binari) nel valore di una stringa, una stringa dev'essere
rappresentata da una coppia di campi che contengono il puntatore al dato vero
e proprio e la lunghezza della stringa.
@`E questo @`e il tipo @code{awk_string_t}.
Un valore di tipo @dfn{strnum} (stringa numerica) @`e rappresentato come una
stringa e consiste di dati in input forniti dall'utente che appaiono essere
numerici.
Quando una funzione di estensione crea un valore di tipo @dfn{strnum}, il
risultato @`e una stringa che viene marcata come immessa dall'utente. La
successiva analisi da parte di @command{gawk} servir@`a poi a determinare se
la stringa appare essere un numero, e va quindi trattata come @dfn{strnum},
invece che come una normale stringa di caratteri.
Ci@`o @`e utile nei casi un cui una funzione di estensione desideri fare qualcosa
di paragonabile alla funzione @code{split}, la quale imposta l'attributo
di @dfn{strnum} agli elementi di vettore che crea.
Per esempio, un'estensione che implementi la divisione di record CSV
(Comma Separated Values, i cui elementi sono delimitati da virgole)
potrebbe voler usare questa funzionalit@`a. Un'altra situazione in cui ci@`o
@`e utile @`e quello di una funzione che richieda campi-dati ad una banca di
dati. La funzione @code{PQgetvalue()} della banca dati PostgreSQ, per
esempio, restituisce una stringa che pu@`o essere numerica o di tipo carattere,
a seconda del contesto.
I valori di @dfn{regexp} fortemente tipizzate
(@pxref{Costanti @dfn{regexp} forti} non sono molto utili nelle funzioni di
estensione. Le funzioni di estensione possono stabilire di averli ricevuti,
e crearne, attribuendo valori di tipo scalare. In alternativa, @`e possibile
esaminare il testo della @dfn{regexp} utilizzando campi @code{regex_value.str}
e @code{regex_value.len}.
Identificativi (cio@`e, nomi di variabili globali) possono essere
associati sia a valori scalari che a vettori. Inoltre, @command{gawk}
consente veri vettori di vettori, in cui ogni singolo elemento di un vettore
pu@`o a sua volta essere un vettore. La spiegazione dei vettori @`e rinviata
@iftex
alla
@end iftex
@ifnottex
a
@end ifnottex
@ref{Manipolazione di vettori}.
La varie macro sopra elencate facilitano l'uso degli elementi delle
@code{union} come se
fossero campi in una struttura @code{struct}; @`e questa una pratica
comunemente adottata
nella scrittura di programmi in C. Questo tipo di codice @`e pi@`u semplice da
scrivere e da leggere, ma resta una responsabilit@`a @emph{del programmatore}
assicurarsi che il campo @code{val_type} rifletta correttamente il tipo
del valore contenuto nella struttura @code{awk_value_t}.
Dal punti di vista concettuale, i primi tre campi dell'@code{union} (numero,
stringa, e vettore) sono sufficienti per lavorare con i valori @command{awk}.
Tuttavia, poich@'e l'API fornisce routine per ottenere e modificare
il valore di una variabile scalare globale usando solo il nome della
variabile, si ha qui una perdita di efficienza: @command{gawk} deve cercare
la variabile ogni volta che questa @`e utilizzata e modificata. Questo
@`e un probelma reale, non solo un problema teorico.
Per questo motivo, se si sa che una certa estensione passer@`a molto tempo
a leggere e/o modificare il valore di una o pi@`u variabili scalari, si pu@`o
ottenere uno @dfn{scalar cookie}@footnote{Si veda
@uref{http://catb.org/jargon/html/C/cookie.html, la voce ``cookie''
nello Jargon file}
per una definizione di @dfn{cookie}, e
@uref{http://catb.org/jargon/html/M/magic-cookie.html, la voce ``magic cookie''
sempre nello Jargon file} per un bell'esempio.
@ifclear FOR_PRINT
Si veda anche la voce ``Cookie'' nel @ref{Glossario}.
@end ifclear
[@uref{http://jhanc.altervista.org/jargon/Intro.html, @`E disponibile in rete
anche una traduzione italiana dello Jargon file}]
}
per quella variabile, e poi usare
il @dfn{cookie} per ottenere il valore della variabile o per modificarne il
valore.
Il tipo @code{awk_scalar_t} contiene uno @dfn{scalar cookie}, e la macro
@code{scalar_cookie} fornisce accesso al valore di quel tipo
nella struttura @code{awk_value_t}.
Dato uno @dfn{scalar cookie}, @command{gawk} pu@`o trovare o modificare
direttamente il valore, come richiesto, senza bisogno di andarlo
a cercare ogni volta.
Il tipo @code{awk_value_cookie_t} e la macro @code{value_cookie} sono simili.
Se si pensa di dover usare
lo stesso @emph{valore} numerico o la stessa @emph{stringa} per una o pi@`u
variabili, si pu@`o creare il valore una volta per tutte, mettendo da parte un
@dfn{@dfn{value cookie}} per quel valore, e in seguito specificare quel
@dfn{value cookie} quando si desidera impostare il valore di una variabile.
Ci@`o consente di risparmiare spazio in memoria all'interno del processo
di @command{gawk} e riduce il tempo richiesto per creare il valore.
@node Funzioni di allocazione memoria
@subsection Funzioni per allocare memoria e macro di servizio
@cindex allocare memoria per estensioni
@cindex estensioni @subentry allocare memoria per
@cindex memoria @subentry allocare per estensioni
L'API fornisce alcune funzioni per effettuare @dfn{allocazioni di memoria}
che possono essere passate a @command{gawk}, e anche un certo numero di
macro che possono tornare utili.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SUBSECTION} le presenta come prototipi di funzione, nel modo
con cui il codice dell'estensione potrebbe usarle:
@table @code
@item void *gawk_malloc(size_t size);
Chiama la versione corretta di @code{malloc()} per allocare memoria,
che pu@`o in seguito essere messa a disposizione di @command{gawk}.
@item void *gawk_calloc(size_t nmemb, size_t size);
Chiama la versione corretta di @code{calloc()} per allocare memoria che
che pu@`o in seguito essere messa a disposizione di @command{gawk}.
@item void *gawk_realloc(void *ptr, size_t size);
Chiama la versione corretta di @code{realloc()} per allocare memoria
che pu@`o in seguito essere messa a disposizione di @command{gawk}.
@item void gawk_free(void *ptr);
Chiama la versione corretta di @code{free()} per liberare memoria che
era stata allocata con
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}.
@end table
L'API deve fornire queste funzioni perch@'e @`e possibile
che un'estensione sia stata compilata e costruita usando una versione
diversa della libreria C rispetto a quella usata per il programma eseguibile
@command{gawk}.@footnote{Questo succede pi@`u spesso nei sistemi MS-Windows,
ma pu@`o capitare anche in sistemi di tipo Unix.}
Se @command{gawk} usasse la propria versione di @code{free()} per liberare
della memoria acquisita tramite una differente versione di @code{malloc()},
il risultato sarebbe molto probabilmente differente da quello atteso.
Tre macro di utilit@`a possono essere usate per allocare memoria
tramite @code{gawk_malloc()}, @code{gawk_calloc}, e
@code{gawk_realloc()}. Se l'allocazione non riesce, @command{gawk}
termina l'esecuzione con un messaggio di errore fatale.
Queste macro dovrebbero essere usate come se fossero dei richiami a
procedure che non restituiscono un codice di ritorno:
@table @code
@item #define emalloc(pointer, type, size, message) @dots{}
Gli argomenti per questa macro sono i seguenti:
@c nested table
@table @code
@item pointer
La variabile di tipo puntatore che punter@`a alla memoria allocata.
@item type
Il tipo della variabile puntatore. Questo @`e usato per definire il tipo
quando si chiama @code{gawk_malloc()}.
@item size
Il numero totale di byte da allocare.
@item message
Un messaggio da anteporre all'eventuale messaggio di errore fatale.
Questo @`e solitamente il nome della funzione che sta usando la macro.
@end table
@noindent
Per esempio, si potrebbe allocare il valore di una stringa cos@`{@dotless{i}}:
@example
@group
awk_value_t risultato;
char *message;
const char greet[] = "Non v'allarmate!";
emalloc(message, char *, sizeof(greet), "myfunc");
strcpy(message, greet);
make_malloced_string(message, strlen(message), & risultato);
@end group
@end example
@sp 2
@item #define ezalloc(pointer, type, size, message) @dots{}
Questo @`e simile a @code{emalloc()}, ma chiama @code{gawk_calloc()}
invece che @code{gawk_malloc()}.
Gli argomenti sono gli stessi della macro @code{emalloc()}, ma
questa macro garantisce che la memoria allocata sia inizializzata
a zeri binari.
@item #define erealloc(pointer, type, size, message) @dots{}
Questo @`e simile a @code{emalloc()}, ma chiama @code{gawk_realloc()}
invece che @code{gawk_malloc()}.
Gli argomenti sono gli stessi della macro @code{emalloc()}.
@end table
Due ulteriori funzioni allocano oggetti MPFR e GMP per essere usati
da funzioni di estensione che necessitino di creare e di
restituire valori di questo tipo.
@quotation NOTA
Queste funzioni sono obsolete. Funzioni di estensione che intendano
usare valori MPFR e GMP locali dovrebbero semplicemente allocarli
sullo @dfn{stack} e in seguito liberarli come farebbe qualsiasi altro
pezzo di codice.
@end quotation
@noindent
Le funzioni sono:
@table @code
@item void *get_mpfr_ptr();
Alloca e inizializza un oggetto MPFR e restituisce un puntatore allo stesso.
Se l'allocazione non riesce, @command{gawk} termina con un errore fatale
``out of memory'' (memoria esaurita). Se @command{gawk} era stato compilato
senza il supporto MPFR, chiamare questa funzione genera un errore fatale.
@item void *get_mpz_ptr();
Alloca e inizializza un oggetto GMP e restituisce un puntatore allo stesso.
Se l'allocazione non riesce, @command{gawk} termina con un errore fatale
``out of memory'' (memoria esaurita). Se @command{gawk} era stato compilato
senza il supporto MPFR, chiamare questa funzione genera un errore fatale.
@end table
Entrambe queste funzioni restituiscono un codice di ritorno @samp{void *},
poich@'e il file di intestazione @file{gawkapi.h} non dovrebbe avere dipendenze
da @code{} (e @code{},
che @`e incluso da @code{}). I codici di ritorno effettivamente
restituiti sono di tipo @code{mpfr_ptr} e @code{mpz_ptr} rispettivamente,
e si dovrebbero assegnare in maniera appropriata questi codici di ritorno
prima di assegnare i risultati a variabili del tipo corretto.
La memoria allocata da queste funzioni dovrebbe essere liberata a fine
utilizzo, richiamando @code{gawk_free()}.
@node Funzioni di costruzione
@subsection Funzioni per creare valori
L'API fornisce varie funzioni di @dfn{costruzione} per creare
valori di tipo stringa e di tipo numerico, e anche varie macro di utilit@`a.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SUBSECTION} le presenta tutte come prototipi di funzione, nel
modo in cui il codice sorgente di
un'estensione le userebbe:
@table @code
@item static inline awk_value_t *
@itemx make_const_string(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione mette il valore di una stringa nella variabile
@code{awk_value_t} puntata da @code{risultato}. La funzione presuppone che
@code{stringa} sia una costante stringa C
(o altri dati che formano una stringa), e automaticamente crea una
@emph{copia} dei dati che sar@`a immagazzinata in @code{risultato}.
Viene restituito il puntatore @code{risultato}.
@item static inline awk_value_t *
@itemx make_malloced_string(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione mette il valore di una stringa nella variabile
@code{awk_value_t} puntata da @code{risultato}. Si presuppone che
@code{stringa} sia un valore @samp{char *}
che punta a dati ottenuti in precedenza per mezzo di
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}.
L'idea @`e che questi dati siano comunicati direttamente a @command{gawk},
che se ne assume la responsabilit@`a.
Viene restituito il puntatore @code{risultato}.
@item static inline awk_value_t *
@itemx make_null_string(awk_value_t *risultato);
Questa funzione specializzata crea una stringa nulla (il valore ``undefined'')
nella variabile @code{awk_value_t} puntata da @code{risultato}.
Viene restituito il puntatore @code{risultato}.
@item static inline awk_value_t *
@itemx make_number(double num, awk_value_t *risultato);
Questa funzione crea semplicemente un valore numerico nella variabile
@code{awk_value_t}, puntata da @code{risultato}.
@item static inline awk_value_t *
@itemx make_number_mpz(void *mpz, awk_value_t *result);
Questa funzione crea un valore di numero GMP in @code{result}.
@code{mpz} deve provenire da una chiamata a @code{get_mpz_ptr()}
(e quindi essere veramente del corrispondente tipo @code{mpz_ptr}).
@item static inline awk_value_t *
@itemx make_number_mpfr(void *mpfr, awk_value_t *result);
Questa funzione crea un valore di numero MPFR in @code{result}.
@code{mpz} deve provenire da una chiamata a @code{get_mpfr_ptr()}.
@item static inline awk_value_t *
@itemx make_const_user_input(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione @`e identica a @code{make_const_string()}, ma la stringa @`e
marcata come input dell'utente, che dovr@`a essere trattata come @dfn{strnum}
se il contenuto della stringa appare essere numerico.
@item static inline awk_value_t *
@itemx make_malloced_user_input(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione @`e identica a @code{make_malloced_string()}, ma la stringa @`e
marcata come input dell'utente, che dovr@`a essere trattata come @dfn{strnum}
se il contenuto della stringa appare essere numerico.
@item static inline awk_value_t *
@itemx make_const_regex(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione crea un valore di @dfn{regexp} fortemente tipizzata, allocando una
copia della stringa.
@code{stringa} @`e l'espressione regolare, di lunghezza @code{lunghezza}.
@item static inline awk_value_t *
@itemx make_malloced_regex(const char *stringa, size_t lunghezza, awk_value_t *risultato);
Questa funzione crea un valore di @dfn{regexp} fortemente tipizzata.
@code{stringa} @`e l'espressione regolare, di lunghezza @code{lunghezza}.
Si aspetta che @code{stringa} sia un valore di tipo @samp{char *} che punta a
dati ottenuti in precedenza tramite una chiamata a
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}.
@end table
@node API e gestione valori MPFR e GMP
@subsection Gestione valori MPFR e GMP
@cindex MPFR @subentry gestione valori nell'API
@cindex GMP @subentry gestione valori nell'API
@cindex API (estensione) @subentry gestione valori MPFR e GMP
I valori MPFR e GMP sono differenti dai valori di tipo stringa,
nei quali @`e possibile ``prendere possesso'' del valore semplicemente
assegnandogli dei puntatori. Per esempio:
@example
char *p = gawk_malloc(42); p @ii{``possiede'' la memoria}
char *q = p;
p = NULL; @ii{ora} q @ii{la ``possiede''}
@end example
Gli oggetti MPFR e GMP sono certamente allocati sullo @dfn{stack}
oppure dinamicamente, ma le librerie MPFR e GMP trattano questi
oggetti come valori, allo stesso modo in cui si passa normalmente
un valore intero (@code{int}) o uno a virgola mobile a doppia
precisione (@code{double}) per valore. Non c'@`e modo di
``trasferire il possesso'' di oggetti MPFR e GMP.
Per questo motivo, il codice in un'estensione dovrebbe essere
simile a questo:
@example
mpz_t part1, part2, risposta; @ii{dichiarare valori locali}
mpz_set_si(part1, 21); @ii{fare alcuni calcoli}
mpz_set_si(part2, 21);
mpz_add(risposta, part1, part2);
@dots{}
/* si suppone che il risultato sia un parametro */
/* di tipo (awk_value_t *). */
make_number_mpz(risposta, & risultato); @ii{assegnare valore finale GMP}
mpz_clear(part1); @ii{rilasciare valori intermedi}
mpz_clear(part2);
mpz_clear(risposta);
return result;
@end example
@node Funzioni di registrazione
@subsection Funzioni di registrazione
@cindex registrazione di estensione
@cindex estensioni @subentry registrazione di
Questa @value{SECTION} descrive le funzioni dell'API per
registrare parti di un'estensione con @command{gawk}.
@menu
* Funzioni di estensione:: Registrare funzioni di estensione.
* Funzioni di exit callback:: Registrare una exit di callback.
* Stringa di versione Estensioni:: Registrare una stringa di versione.
* Analizzatori di input:: Registrare un analizzatore di input.
* Processori di output:: Registrare un processore di output.
* Processori bidirezionali:: Registrare un processore bidirezionale.
@end menu
@node Funzioni di estensione
@subsubsection Registrare funzioni di estensione
Le funzioni di estensione sono descritte dal seguente tracciato record:
@example
@group
typedef struct awk_ext_func @{
@ @ @ @ const char *nome;
@ @ @ @ awk_value_t *(*const function)(int num_actual_args,
@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato,
@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ struct awk_ext_func *finfo);
@ @ @ @ const size_t max_expected_args;
@ @ @ @ const size_t min_required_args;
@ @ @ @ awk_bool_t suppress_lint;
@ @ @ @ void *data; /* puntatore di tipo opaco
@ @ @ @ a ogni informazione ulteriore */
@} awk_ext_func_t;
@end group
@end example
I campi sono:
@table @code
@item const char *nome;
Il nome della nuova funzione.
Il codice sorgente a livello di @command{awk} richiama la funzione usando
questo nome.
Il nome @`e una normale stringa di caratteri del linguaggio C.
I nomi di funzione devono rispettare le stesse regole che valgono per gli
identificativi @command{awk}.
Cio@`e, devono iniziare o con una lettera dell'alfabeto inglese o con un
trattino basso, che possono essere seguiti da un numero qualsiasi di
lettere, cifre o trattini bassi.
L'uso di maiuscolo/minuscolo @`e significativo.
@item awk_value_t *(*const function)(int num_actual_args,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ struct awk_ext_func *finfo);
Questo @`e un puntatore alla funzione C che fornisce la funzionalit@`a per cui
@`e stata scritta l'estensione.
La funzione deve riempire l'area di memoria puntata da @code{*risultato} con
un numero, con una stringa, oppure con una @dfn{regexp}.
@command{gawk} diventa il proprietario di tutte le stringhe di memoria.
Come gi@`a detto sopra, la stringa di memoria @emph{deve} essere stata ottenuta
usando @code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}.
L'argomento @code{num_actual_args} dice alla funzione scritta in C quanti
parametri sono stati effettivamente passati dal codice chiamante all'interno
di @command{awk}.
La funzione deve restituire il valore di @code{risultato}.
Questo @`e per utilit@`a del codice chiamante all'interno di
@command{gawk}.
@item size_t max_expected_args;
Questo @`e il massimo numero di argomenti che la funzione si aspetta di
ricevere.
Se chiamata con un numero di argomenti maggiore di questo, e se @`e stato
richiesto il controllo @dfn{lint}, @command{gawk} stampa un messaggio di
avvertimento. Per ulteriori informazioni, si veda la descrizione di
@code{suppress_lint}, pi@`u avanti in questa lista.
@item const size_t min_required_args;
Questo @`e il minimo numero di argomenti che la funzione si aspetta di
ricevere.
Se @`e chiamata con un numero inferiore di argomenti, @command{gawk}
stampa un messaggio di errore fatale ed esce.
@item awk_bool_t suppress_lint;
Questo @dfn{flag} dice a @command{gawk} di non stampare un messaggio
@dfn{lint} se @`e stato richiesto un controllo @dfn{lint} e se sono stati
forniti pi@`u argomenti di quelli attesi. Una funzione di estensione pu@`o
stabilire se @command{gawk} ha gi@`a stampato almeno uno di tali messaggi
controllando se @samp{num_actual_args > finfo->max_expected_args}.
In tal caso, se la funzione non desidera la stampa di ulteriori messaggi,
dovrebbe impostare @code{finfo->suppress_lint} a @code{awk_true}.
@item void *data;
Questo @`e un puntatore di tipo opaco a tutti quei dati che una funzione
di estensione desidera avere disponibili al momento della chiamata.
Passando alla funzione di estensione la struttura @code{awk_ext_func_t}
e avendo al suo interno questo puntatore disponibile, rende possibile
scrivere un'unica funzione C o C++ che implementa pi@`u di una funzione
di estensione a livello @command{awk}.
@end table
Una volta preparato un record che descrive l'estensione, la funzione di
estensione va registrata con @command{gawk} usando questa funzione dell'API:
@table @code
@item awk_bool_t add_ext_func(const char *name_space, awk_ext_func_t *func);
Questa funzione restituisce il valore @dfn{true} se ha successo,
oppure @dfn{false} in caso contrario.
Il parametro @code{name_space} indica lo spazio-dei-nomi in cui porre
la funzione (@pxref{Spazi-dei-nomi}).
Si usi una stringa vuota (@code{""}) o @code{"awk"} per porre la funzione
nello spazio-dei-nomi @code{awk}, che @`e quello di default.
Il puntatore @code{func} @`e l'indirizzo di una struttura
@code{struct} che rappresenta la funzione stessa, come descritto sopra.
@command{gawk} non modifica ci@`o che @`e puntato da @code{func}, ma la
funzione di estensione stessa riceve questo puntatore e pu@`o modificarlo
e farlo puntare altrove, quindi il puntatore non @`e stato dichiarato
di tipo costante (@code{const}).
@end table
La combinazione di @code{min_required_args}, @code{max_expected_args},
e @code{suppress_lint} pu@`o ingenerare confusione. Ecco delle linee-guida
sul da farsi.
@table @asis
@item Un numero qualsiasi di argomenti @`e valido
Impostare @code{min_required_args} and @code{max_expected_args} a zero e
impostare @code{suppress_lint} ad @code{awk_true}.
@item Un numero minimo di argomenti @`e richiesto, ma non c'@`e un limite al numero massimo
Impostare @code{min_required_args} al minimo richiesto.
Impostare @code{max_expected_args} a zero e
impostare @code{suppress_lint} ad @code{awk_true}.
@item Un numero minino di argomenti @`e richiesto, ma c'@`e un limite al numero massimo
Impostare @code{min_required_args} al minimo richiesto.
Impostare @code{max_expected_args} al massimo atteso.
Impostare @code{suppress_lint} ad @code{awk_false}.
@item Un numero minino di argomenti @`e richiesto, ma c'@`e un numero massimo non superabile
Impostare @code{min_required_args} al minimo richiesto.
Impostare @code{max_expected_args} al massimo atteso.
Impostare @code{suppress_lint} ad @code{awk_false}.
Nella funzione di estensione, controllare che @code{num_actual_args} non
ecceda @code{f->max_expected_args}. Se il massimo @`e superato, stampare
un messaggio di errore fatale.
@end table
@node Funzioni di exit callback
@subsubsection Registrare una funzione @dfn{exit callback}
Una funzione @dfn{exit callback} @`e una funzione che @command{gawk} invoca
prima di completare l'esecuzione del programma.
Siffatte funzioni sono utili se ci sono dei compiti generali di ``pulizia''
che dovrebbero essere effettuati nell'estensione (come chiudere connessioni a
un @dfn{database} o rilasciare altre risorse).
Si pu@`o registrare una tale
funzione con @command{gawk} per mezzo della seguente funzione:
@table @code
@item void awk_atexit(void (*funcp)(void *data, int exit_status),
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ void *arg0);
I parametri sono:
@c nested table
@table @code
@item funcp
Un puntatore alla funzione da chiamare prima che @command{gawk} completi
l'esecuzione. Il parametro @code{data}
sar@`a il valore originale di @code{arg0}.
Il parametro @code{exit_status} @`e il valore del codice di ritorno che
@command{gawk} intende passare alla chiamata di sistema @code{exit()}
(che termina l'esecuzione del programma).
@item arg0
Un puntatore a un'area dati privata che @command{gawk} mantiene perch@'e
sia poi passata alla funzione puntata da @code{funcp}.
@end table
@end table
Le funzioni @dfn{exit callback} sono chiamate in ordine inverso rispetto
a quello con cui @`e stata fatta la registrazione con @command{gawk}
(LIFO: Last In, First Out).
@node Stringa di versione Estensioni
@subsubsection Registrare una stringa di versione per un'estensione
Si pu@`o registrare una stringa di versione che indica il nome e la versione
di una data estensione a @command{gawk}, come segue:
@table @code
@item void register_ext_version(const char *version);
Registra la stringa puntata da @code{version} con @command{gawk}.
Si noti che @command{gawk} @emph{non} copia la stringa @code{version}, e
quindi questa stringa non dovrebbe essere modificata.
@end table
@command{gawk} stampa tutte le stringhe con le versioni di estensione
registrate, quando viene invocato specificando l'opzione @option{--version}.
@node Analizzatori di input
@subsubsection Analizzatori di input personalizzati
@cindex personalizzato @subentry analizzatore di input
@cindex analizzatore di input personalizzato
@cindex input @subentry analizzatore di @subentry personalizzato
Per default, @command{gawk} legge file di testo come input. Il valore della
variabile @code{RS} @`e usato per determinare la fine di un record, e subito
dopo la variabile @code{FS} (o @code{FIELDWIDTHS} o @code{FPAT}) viene usata
per suddividerlo in campi
@iftex
(@pxrefil{Leggere file}).
@end iftex
@ifnottex
(@pxref{Leggere file}).
@end ifnottex
Viene inoltre impostato il valore di @code{RT}
(@pxref{Variabili predefinite}).
Se lo si desidera, @`e possibile fornire un analizzatore di input
personalizzato. Il compito di un analizzatore di input @`e di restituire un
record al codice di @command{gawk}, che poi lo elaborer@`a, accompagnato,
se necessario, da indicatori del valore e della lunghezza dei dati da usare
per @code{RT}.
Per fornire un analizzatore personalizzato di input, occorre innanzitutto
rendere disponibili due funzioni (dove @var{XXX} @`e un nome che fa da prefisso
all'estensione intera):
@table @code
@item awk_bool_t @var{XXX}_can_take_file(const awk_input_buf_t *iobuf);
Questa funzione esamina l'informazione disponibile in @code{iobuf}
(che vedremo tra poco). Basandosi su tale informazione,
decide se l'analizzatore di input personalizzato andr@`a usato per questo file.
Se questo @`e il caso, dovrebbe restituire @dfn{true}. Altrimenti, restituir@`a
@dfn{false}. Nessuno stato (valori di variabili, etc.) dovrebbe venire
modificato all'interno di @command{gawk}.
@item awk_bool_t @var{XXX}_take_control_of(awk_input_buf_t *iobuf);
Quando @command{gawk} decide di passare il controllo del file a questo
analizzatore di input, richiamer@`a questa funzione.
Questa funzione a sua volta deve assegnare un valore ad alcuni campi
nella struttura @code{awk_input_buf_t} e assicurarsi che
alcune condizioni siano verificate. Dovrebbe poi restituire @dfn{true}.
Se si verifica un errore di qualche tipo, i campi in questione non dovrebbero
venire riempiti, e la funzione dovrebbe restituire @dfn{false}; in questo caso
@command{gawk} non utilizzer@`a pi@`u l'analizzatore personalizzato di input.
I dettagli sono descritti pi@`u avanti.
@end table
L'estensione dovrebbe raccogliere queste funzioni all'interno di una
struttura @code{awk_input_parser_t}, simile a questa:
@example
@group
typedef struct awk_input_parser @{
const char *nome; /* nome dell'analizzatore */
awk_bool_t (*can_take_file)(const awk_input_buf_t *iobuf);
awk_bool_t (*take_control_of)(awk_input_buf_t *iobuf);
awk_const struct awk_input_parser *awk_const next; /* per uso
di gawk */
@} awk_input_parser_t;
@end group
@end example
I campi sono:
@table @code
@item const char *nome;
Il nome dell'analizzatore di input. Questa @`e una normale stringa di caratteri
del linguaggio C.
@item awk_bool_t (*can_take_file)(const awk_input_buf_t *iobuf);
Un puntatore alla funzione @code{@var{XXX}_can_take_file()}.
@item awk_bool_t (*take_control_of)(awk_input_buf_t *iobuf);
Un puntatore alla funzione @code{@var{XXX}_take_control_of()}.
@item awk_const struct input_parser *awk_const next;
Questa struttura @`e per uso di @command{gawk};
per questo motivo @`e marcata @code{awk_const} in modo che l'estensione non
possa modificarla.
@end table
I passi da seguire sono i seguenti:
@enumerate
@item
Creare una variabile @code{static awk_input_parser_t} e inizializzarla
adeguatamente.
@item
Quando l'estensione @`e caricata, registrare l'analizzatore personalizzato di
input con @command{gawk} usando la funzione API @code{register_input_parser()}
(descritta pi@`u sotto).
@end enumerate
La definizione di una struttura @code{awk_input_buf_t} @`e simile a questa:
@example
typedef struct awk_input @{
const char *nome; /* nome file */
int fd; /* descrittore di file */
#define INVALID_HANDLE (-1)
void *opaque; /* area dati privata
per l'analizzatore di input */
int (*get_record)(char **out, struct awk_input *iobuf,
int *errcode, char **rt_start, size_t *rt_len,
const awk_fieldwidth_info_t **field_width);
ssize_t (*read_func)();
void (*close_func)(struct awk_input *iobuf);
struct stat sbuf; /* buffer per stat */
@} awk_input_buf_t;
@end example
I campi si possono dividere in due categorie: quelli che sono usati (almeno
inizialmente) da @code{@var{XXX}_can_take_file()}, e quelli che sono usati da
@code{@var{XXX}_take_control_of()}. Il primo gruppo di campi, e il loro uso,
@`e cos@`{@dotless{i}} definito:
@table @code
@item const char *nome;
Il nome del file.
@item int fd;
Un descrittore di file per il file. Se @command{gawk} riesce ad aprire
il file, il valore di @code{fd} @emph{non} sar@`a uguale a
@code{INVALID_HANDLE} [descrittore non valido]. In caso contrario,
quello sar@`a il valore.
@item struct stat sbuf;
Se il descrittore di file @`e valido, @command{gawk} avr@`a riempito i campi di
questa struttura invocando la chiamata di sistema @code{fstat()}.
@end table
La funzione @code{@var{XXX}_can_take_file()} dovrebbe esaminare i campi di
cui sopra e decidere se l'analizzatore di input vada usato per il file.
La decisione pu@`o dipendere da uno stato di @command{gawk} (il valore
di una variabile definita in precedenza dall'estensione e impostata dal
codice @command{awk}), dal nome del
file, dal fatto che il descrittore di file sia valido o no,
dalle informazioni contenute in @code{struct stat} o da una qualsiasi
combinazione di questi fattori.
Una volta che @code{@var{XXX}_can_take_file()} restituisce @dfn{true}, e
@command{gawk} ha deciso di usare l'analizzatore personalizzato, viene
chiamata la funzione @code{@var{XXX}_take_control_of()}. Tale funzione
si occupa di riempire il campo @code{get_record} oppure il campo
@code{read_func} nella struttura @code{awk_input_buf_t}. La funzione si
assicura inoltre che @code{fd} @emph{not} sia impostato al valore
@code{INVALID_HANDLE}. L'elenco seguente descrive i campi che
possono essere riempiti da @code{@var{XXX}_take_control_of()}:
@table @code
@item void *opaque;
Questo campo @`e usato per contenere qualiasi informazione di stato sia
necessaria per l'analizzatore di input
riguardo a questo file. Il campo @`e ``opaco'' per @command{gawk}.
L'analizzatore di input non @`e obbligato a usare questo puntatore.
@item int@ (*get_record)(char@ **out,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ struct@ awk_input *iobuf,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ int *errcode,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ char **rt_start,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ size_t *rt_len,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const awk_fieldwidth_info_t **field_width);
Questo puntatore a funzione dovrebbe puntare a una funzione che crea i record
in input. Tale funzione @`e il nucleo centrale dell'analizzatore di input.
Il suo modo di operare @`e descritto nel testo che segue questo elenco.
@item ssize_t (*read_func)();
Questo puntatore a funzione dovrebbe puntare a una funzione che ha lo
stesso comportamento della chiamata di sistema standard POSIX @code{read()}.
@`E in alternativa al puntatore a @code{get_record}. Il relativo comportamento
@`e pure descritto nel testo che segue quest'elenco.
@item void (*close_func)(struct awk_input *iobuf);
Questo puntatore a funzione dovrebbe puntare a una funzione che fa
la ``pulizia finale''. Dovrebbe liberare ogni risorsa allocata da
@code{@var{XXX}_take_control_of()}. Pu@`o anche chiudere il file. Se lo fa,
dovrebbe impostare il campo @code{fd} a @code{INVALID_HANDLE}.
Se @code{fd} @`e ancora diverso da @code{INVALID_HANDLE} dopo la chiamata a
questa funzione, @command{gawk} invoca la normale chiamata di sistema
@code{close()}.
Avere una funzione di ``pulizia'' @`e opzionale. Se l'analizzatore di input
non ne ha bisogno, basta non impostare questo campo. In questo caso,
@command{gawk} invoca la normale chiamata di sistema @code{close()} per il
descrittore di file, che, quindi, dovrebbe essere valido.
@end table
La funzione @code{@var{XXX}_get_record()} svolge il lavoro di creazione dei
record in input. I parametri sono i seguenti:
@table @code
@item char **out
Questo @`e un puntatore a una variabile @code{char *} che @`e impostatata in modo
da puntare al record. @command{gawk} usa una sua copia locale dei dati,
quindi l'estensione deve gestire la relativa area di memoria.
@item struct awk_input *iobuf
Questa @`e la struttura @code{awk_input_buf_t} per il file. I campi dovrebbero
essere usati per leggere i dati (@code{fd}) e per gestire lo stato privato
(@code{opaque}), se necessario.
@item int *errcode
Se si verifica un errore, @code{*errcode} dovrebbe essere impostato a un
valore appropriato tra quelli contenuti in @code{}.
@item char **rt_start
@itemx size_t *rt_len
Se il concetto ``fine record'' @`e applicabile,
@code{*rt_start} dovrebbe essere impostato per puntare ai dati da usare come
@code{RT}, e @code{*rt_len} dovrebbe essere impostata alla lunghezza di quel
campo. In caso contrario, @code{*rt_len} dovrebbe essere impostata a zero.
@command{gawk} usa una sua copia di questi dati, quindi l'estensione deve
gestire tale memoria.
@item const awk_fieldwidth_info_t **field_width
Se @code{field_width} non @`e @code{NULL}, @code{*field_width} sar@`a
inizializzato a @code{NULL}, e la funzione pu@`o impostarlo per puntare a una
struttura che fornisca l'informazione sulla lunghezza del campo, che
sar@`a utilizzata al posto di quella determinata dall'analizzatore di default
del campo. Si noti che questa struttura non sar@`a copiata da @command{gawk};
inoltre essa deve rimanere disponibile almeno fino alla successiva chiamata a
@code{get_record} o a @code{close_func}. Si noti inoltre che
@code{field_width} vale @code{NULL} quando @code{getline} sta assegnando
i risultati a una variabile, e quindi un'analisi del campo non @`e necessaria.
Se l'analizzatore imposta @code{*field_width},
allora @command{gawk} usa questa descrizione per analizzare il record in
input, e il valore di @code{PROCINFO["FS"]} sar@`a @code{"API"} finch@'e questo
record rimane corrente come @code{$0}.
La struttura dati @code{awk_fieldwidth_info_t} @`e descritta qui di seguito.
@end table
Il codice di ritorno @`e la lunghezza del buffer puntato da
@code{*out} oppure @code{EOF}, se @`e stata raggiunta la fine del file o se
si @`e verificato un errore.
Poich@'e @code{errcode} @`e sicuramente un puntatore valido, non c'@`e
bisogno di controllare che il valore sia @code{NULL}. @command{gawk}
imposta @code{*errcode} a zero, quindi non c'@`e bisogno di impostarlo, a meno
che non si verifichi un errore.
In presenza di un errore, la funzione dovrebbe restituire @code{EOF} e
impostare @code{*errcode} a un valore maggiore di zero. In questo caso, se
@code{*errcode} non @`e uguale a zero, @command{gawk} automaticamente aggiorna
la variabile @code{ERRNO} usando il valore contenuto in @code{*errcode}.
(In generale, impostare @samp{*errcode = errno} dovrebbe essere la
cosa giusta da fare.)
Invece di fornire una funzione che restituisce un record in input,
@`e possibile fornirne una che semplicemente legge dei byte, e lascia
che sia @command{gawk} ad analizzare i dati per farne dei record. In questo
caso, i dati dovrebbero essere restituiti nella codifica multibyte propria
della localizzazione corrente.
Una siffatta funzione dovrebbe imitare il comportamento della chiamata di
sistema @code{read()}, e riempire il puntatore @code{read_func} con
il proprio indirizzo nella struttura @code{awk_input_buf_t}.
Per default, @command{gawk} imposta il puntatore @code{read_func} in modo che
punti alla chiamata di sistema @code{read()}. In questo modo l'estensione
non deve preoccuparsi di impostare esplicitamente questo campo.
@quotation NOTA
Occorre decidere per l'uno o per l'altro metodo: o una funzione che
restituisce un record o una che restituisce dei dati grezzi. Nel dettaglio,
se si fornisce una funzione che prepara un record, @command{gawk} la
invocher@`a, e non chiamer@`a mai la funzione che fa una lettura grezza.
@end quotation
@command{gawk} viene distribuito con un'estensione di esempio che legge
delle directory, restituendo un record per ogni elemento contenuto nella
directory (@pxref{Esempio di estensione Readdir}. Questo codice sorgente pu@`o
essere usato come modello per scrivere un analizzatore di input
personalizzato.
Quando si scrive un analizzatore di input, si dovrebbe progettare (e
documentare) il modo con cui si suppone che interagisca con il codice
@command{awk}. Si pu@`o scegliere di utilizzarlo per tutte le letture, e
intervenire solo quando @`e necessario, (come fa l'estensione di
esempio @code{readdir}). Oppure lo si pu@`o utilizzare a seconda del
valore preso da una variabile @command{awk}, come fa l'estensione XML
inclusa nel progetto @code{gawkextlib} (@pxref{gawkextlib}).
In quest'ultimo caso, il codice in una regola @code{BEGINFILE}
pu@`o controllare @code{FILENAME} ed @code{ERRNO} per decidere se
attivare un analizzatore di input (@pxref{BEGINFILE/ENDFILE}) oppure no.
Un analizzatore di input va registrato usando la seguente funzione:
@table @code
@item void register_input_parser(awk_input_parser_t *input_parser);
Registra l'analizzatore di input puntato da @code{input_parser} con
@command{gawk}.
@end table
Se si vuole ignorare il meccanismo di default per l'analisi dei campi
per un determinato record, si deve riempire una struttura
@code{awk_fieldwidth_info_t} che ha questo aspetto:
@example
typedef struct @{
awk_bool_t use_chars; /* falso ==> usare byte */
size_t nf; /* numero di campi nel record (NF) */
struct awk_field_info @{
size_t skip; /* da ignorare prima dell'inizio di un campo */
size_t len; /* lunghezza del campo */
@} fields[1]; /* la dimensione effettiva dovrebbe essere nf */
@} awk_fieldwidth_info_t;
@end example
I campi sono:
@table @code
@item awk_bool_t use_chars;
Impostare ad @code{awk_true} se le lunghezze di campo sono specificate in
unit@`a di caratteri potenzialmente multi-byte, oppure impostarlo a
@code{awk_false} se le lunghezze sono espresse in numero di byte.
L'efficienza del programma sar@`a maggiore utilizzando la dimensione in byte.
@item size_t nf;
Impostare al numero di campi nel record in input, cio@`e a @code{NF}.
@item struct awk_field_info fields[nf];
Questo @`e un vettore di lunghezza variabile la cui dimensione effettiva
dovrebbe essere @code{nf}.
Per ogni campo, l'elemento @code{skip} dovrebbe essere impostato al numero
di caratteri o byte, come richiesto dal flag @code{use_chars},
da saltare prima dell'inizio di questo campo. L'elemento @code{len} fornisce
la lunghezza del campo. I valori in @code{fields[0]} forniscono l'informazione
per @code{$1}, e cos@`{@dotless{i}} via, fino all'elemento @code{fields[nf-1]} che contiene
l'informazione per @code{$NF}.
@end table
Una macro di utilit@`a @code{awk_fieldwidth_info_size(numfields)} @`e disponibile
per calcolare la dimensione appropriata della struttura a lunghezza variabile
@code{awk_fieldwidth_info_t} che contiene @code{numfields} campi. Questa
dimensione pu@`o essere usata come argomento per @code{malloc()} o in una
struttura @dfn{union} per allocare spazio staticamente.
Per un esempio si pu@`o vedere l'estensione di esempio @code{readdir_test}.
@node Processori di output
@subsubsection Registrare un processore di output
@cindex personalizzato @subentry processore di output
@cindex processore di output @subentry personalizzato
@cindex output @subentry processore di @subentry personalizzato
@cindex processore di output
@cindex output @subentry processore di
Un @dfn{processore di output} @`e l'immagine riflessa di un
analizzatore di input.
Consente a un'estensione di prendere il controllo dell'output
indirizzato verso un file
che sia stato aperto con gli operatori di ridirezione di I/O
@samp{>} o @samp{>>} (@pxref{Ridirezione}).
Il processore di output @`e molto simile, come struttura,
all'analizzatore di input:
@example
typedef struct awk_output_wrapper @{
const char *nome; /* nome del processore */
awk_bool_t (*can_take_file)(const awk_output_buf_t *outbuf);
awk_bool_t (*take_control_of)(awk_output_buf_t *outbuf);
awk_const struct awk_output_wrapper *awk_const next; /* per gawk */
@} awk_output_wrapper_t;
@end example
I campi sono i seguenti:
@table @code
@item const char *nome;
Questo @`e il nome del processore di output.
@item awk_bool_t (*can_take_file)(const awk_output_buf_t *outbuf);
Questo @`e il puntatore a una funzione che esamina l'informazione contenuta
nella struttura @code{awk_output_buf_t} puntata da @code{outbuf}.
Dovrebbe restituire @dfn{true} se il processore di output vuole elaborare
il file, e @dfn{false} in caso contrario.
Nessuno stato (valori di variabili, etc.) dovrebbe essere modificato
all'interno di @command{gawk}.
@item awk_bool_t (*take_control_of)(awk_output_buf_t *outbuf);
La funzione puntata da questo campo viene chiamata quando @command{gawk}
decide di consentire al processore di output di prendere il controllo del file.
Dovrebbe riempire in maniera appropriata dei campi nella struttura
@code{awk_output_buf_t}, come descritto sotto, e restituire @dfn{true} se
ha successo, @dfn{false} in caso contrario.
@item awk_const struct output_wrapper *awk_const next;
Questa struttura @`e per uso di @command{gawk};
per questo motivo @`e marcata @code{awk_const} in modo che l'estensione non
possa modificarlo.
@end table
La struttura @code{awk_output_buf_t} @`e simile a questa:
@example
typedef struct awk_output_buf @{
const char *nome; /* nome del file in output */
const char *modo; /* argomento @dfn{mode} per fopen */
FILE *fp; /* puntatore stdio file */
awk_bool_t redirected; /* @dfn{true} se un processore @`e attivo */
void *opaque; /* per uso del processore di output */
size_t (*gawk_fwrite)(const void *buf, size_t size, size_t count,
FILE *fp, void *opaque);
int (*gawk_fflush)(FILE *fp, void *opaque);
int (*gawk_ferror)(FILE *fp, void *opaque);
int (*gawk_fclose)(FILE *fp, void *opaque);
@} awk_output_buf_t;
@end example
Anche qui, l'estensione definir@`a le funzioni @code{@var{XXX}_can_take_file()}
e @code{@var{XXX}_take_control_of()} che esaminano e aggiornano
campi dati in @code{awk_output_buf_t}.
I campi dati sono i seguenti:
@table @code
@item const char *nome;
Il nome del file in output.
@item const char *modo;
La stringa @dfn{mode} (come sarebbe usata nel secondo argomento della
chiamata di sistema @code{fopen()})
con cui il file era stato aperto.
@item FILE *fp;
Il puntatore @code{FILE} da @code{}. @command{gawk} apre il file
prima di controllare se esiste un processore di output.
@item awk_bool_t redirected;
Questo campo dev'essere impostato a @dfn{true} dalla funzione
@code{@var{XXX}_take_control_of()}.
@item void *opaque;
Questo puntatore @`e opaco per @command{gawk}. L'estensione dovrebbe usarlo
per contenere un puntatore a qualsiasi dato privato associato al file.
@item size_t (*gawk_fwrite)(const void *buf, size_t size, size_t count,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ FILE *fp, void *opaque);
@itemx int (*gawk_fflush)(FILE *fp, void *opaque);
@itemx int (*gawk_ferror)(FILE *fp, void *opaque);
@itemx int (*gawk_fclose)(FILE *fp, void *opaque);
Questi puntatori dovrebbero essere impostati per puntare a funzioni
la cui azione sia equivalente a quella delle funzioni di @code{},
se questo @`e cio che si desidera.
@command{gawk} usa questi puntatori a funzione per @emph{tutti} gli output.
@command{gawk} inizializza i puntatori per puntare a funzioni interne
``di passaggio'' che si limitano a chiamare le funzioni normali di
@code{}, e quindi un'estensione deve ridefinire solo le funzioni
appropriate per fare il lavoro richiesto.
@end table
La funzione @code{@var{XXX}_can_take_file()} dovrebbe decidere in base ai
campi @code{nome} e @code{modo}, e a ogni altro ulteriore indicatore di stato
(p.es., valori di variabili @command{awk}) adatto allo scopo.
Quando @command{gawk} chiama @code{@var{XXX}_take_control_of()}, la funzione
dovrebbe riempire i rimanenti campi
in modo opportuno, tranne che per @code{fp}, che dovrebbe essere usato
normalmente.
Il processore di output va registrato usando la seguente funzione:
@table @code
@item void register_output_wrapper(awk_output_wrapper_t *output_wrapper);
Registra il processore di output puntato da @code{output_wrapper} con
@command{gawk}.
@end table
@node Processori bidirezionali
@subsubsection Registrare un processore bidirezionale
@cindex personalizzato @subentry processore bidirezionale
@cindex processore bidirezionale personalizzato
@cindex bidirezionale @subentry processore personalizzato
Un @dfn{processore bidirezionale} combina un analizzatore di input e
un processore di output per un I/O
bidirezionale usando l'operatore @samp{|&} (@pxref{Ridirezione}).
Le strutture @code{awk_input_parser_t} e @code{awk_output_buf_t}
sono usate nella maniera gi@`a descritta precedentemente.
Un processore bidirezionale @`e rappresentato dalla struttura seguente:
@example
typedef struct awk_two_way_processor @{
const char *nome; /* nome del processore bidirezionale */
awk_bool_t (*can_take_two_way)(const char *nome);
awk_bool_t (*take_control_of)(const char *nome,
awk_input_buf_t *inbuf,
awk_output_buf_t *outbuf);
awk_const struct awk_two_way_processor *awk_const next; /* per gawk */
@} awk_two_way_processor_t;
@end example
I campi sono i seguenti:
@table @code
@item const char *nome;
Il nome del processore bidirezionale.
@item awk_bool_t (*can_take_two_way)(const char *nome);
La funzione puntata da questo campo dovrebbe restituire @dfn{true} se
vuole gestire l'I/O bidirezionale per questo @value{FN}.
La funzione non dovrebbe modificare alcuno stato (valori di variabili, etc.)
all'interno di @command{gawk}.
@item awk_bool_t (*take_control_of)(const char *nome,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_input_buf_t *inbuf,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_output_buf_t *outbuf);
La funzione puntata da questo campo dovrebbe riempire le strutture
@code{awk_input_buf_t} e @code{awk_output_buf_t} puntate da @code{inbuf} e
@code{outbuf}, rispettivamente. Queste strutture sono gi@`a state descritte
in precedenza.
@item awk_const struct two_way_processor *awk_const next;
Questa struttura @`e per uso di @command{gawk};
per questo motivo @`e marcata @code{awk_const} in modo che l'estensione non
possa modificarla.
@end table
Come per l'analizzatore di input e il processore di output, vanno fornite le
funzione ``s@`{@dotless{i}}, ci penso io'' e ``per questo, fai tu'',
@code{@var{XXX}_can_take_two_way()} e @code{@var{XXX}_take_control_of()}.
Il processore bidirezionale va registrato usando la seguente funzione:
@table @code
@item void register_two_way_processor(awk_two_way_processor_t *two_way_processor);
Registra il processore bidirezionale puntato da @code{two_way_processor} con
@command{gawk}.
@end table
@node Stampare messaggi
@subsection Stampare messaggi dalle estensioni
@cindex stampare @subentry messaggi dalle estensioni
@cindex messaggi @subentry stampare dalle estensioni
@cindex estensioni @subentry stampare messaggi dalle
@`E possibile stampare diversi tipi di messaggi di avvertimento da
un'estensione, come qui spiegato. Si noti che, per queste funzioni,
si deve fornire l'ID di estensione ricevuto da @command{gawk}
al momento in cui l'estensione @`e stata caricata:@footnote{Poich@'e l'API usa solo
funzionalit@`a previste dal
compilatore ISO C 90, non @`e possibile usare le macro di tipo variadico
(che accettano un numero variabile di argomenti) disponibili nel compilatore
ISO C 99, che nasconderebbero quel parametro. Un vero peccato!}
@table @code
@item void fatal(awk_ext_id_t id, const char *format, ...);
Stampa un messaggio e poi @command{gawk} termina immediatamente l'esecuzione.
@item void nonfatal(awk_ext_id_t id, const char *format, ...);
Stampa un messaggio di errore non-fatale.
@item void warning(awk_ext_id_t id, const char *format, ...);
Stampa un messaggio di avvertimento.
@item void lintwarn(awk_ext_id_t id, const char *format, ...);
Stampa un messaggio di avvertimento ``lint''. Normalmente questo equivale a
stampare un messaggio di avvertimento, ma se @command{gawk} era stato
invocato specificando l'opzione @samp{--lint=fatal},
gli avvertimenti di @dfn{lint} diventano messaggi di errore fatali.
@end table
Tutte queste funzioni sono per il resto simili alla famiglia di funzioni
@code{printf()} del linguaggio C, dove il parametro @code{format} @`e una
stringa contenente dei caratteri normali e delle istruzioni di formattazione,
mischiati tra loro.
@node Aggiornare @code{ERRNO}
@subsection Funzioni per aggiornare @code{ERRNO}
Le seguenti funzioni consentono l'aggiornamento della variabile
@code{ERRNO}:
@table @code
@item void update_ERRNO_int(int errno_val);
Imposta @code{ERRNO} alla stringa equivalente del codice di errore
in @code{errno_val}. Il valore dovrebbe essere uno dei codici di errore
definiti in @code{}, e @command{gawk} lo trasforma in una stringa
(qualora possibile, tradotta) usando la funzione C @code{strerror()}.
@item void update_ERRNO_string(const char *string);
Imposta @code{ERRNO} direttamente usando il valore della stringa specificata.
@command{gawk} fa una copia del valore di @code{stringa}.
@item void unset_ERRNO(void);
Annulla il valore di @code{ERRNO}.
@end table
@node Richiedere valori
@subsection Richiedere valori
Tutte le funzioni che restituiscono valori da @command{gawk}
funzionano allo stesso modo. Si fornisce un campo @code{awk_valtype_t}
per indicare il tipo di valore che ci si aspetta. Se il valore disponibile
corrisponde a quello richiesto, la funzione restituisce @dfn{true} e riempie
il campo del risultato @code{awk_value_t}.
Altrimenti, la funzione restituisce @dfn{false}, e il campo @code{val_type}
indica il tipo di valore disponibile.
A quel punto si pu@`o, a seconda di quel che richiede la situazione,
stampare un messaggio di errore oppure ripetere la
richiesta specificando il tipo di valore che risulta disponibile. Questo
comportamento @`e riassunto nella
@ref{table-value-types-returned}.
@float Tabella,table-value-types-returned
@caption{Tipi di valori restituiti dall'API}
@docbook
Tipo di valore reale
Stringa
Strnum
Numero
Regexp
Vettore
Indefinito
Stringa
Stringa
Stringa
Stringa
Stringa
false
false
Strnum
false
Strnum
Strnum
false
false
false
Numero
Numero
Numero
Numero
false
false
false
Tipo
Regexp
false
false
Regexp
false
false
false
Richiesto
Vettore
false
false
false
false
Vettore
false
Scalare
Scalare
Scalare
Scalare
Scalare
false
false
Indefinito
Stringa
Strnum
Numero
Regexp
Vettore
Indefinito
@dfn{Value cookie}
false
false
false
false
false
false
@end docbook
@ifnotplaintext
@ifnotdocbook
@multitable @columnfractions .50 .50
@headitem @tab Tipo di valore reale
@end multitable
@c 10/2014: Thanks to Karl Berry for this bit to reduce the space:
@tex
\vglue-1.1\baselineskip
@end tex
@c @multitable @columnfractions .166 .166 .198 .15 .15 .166
@ifclear SMALLPRINT
@multitable {Richiesto} {Indefinito} {Numero} {Numero} {Scalar} {Regexp} {Vettore} {Indefinito}
@headitem @tab @tab Stringa @tab Strnum @tab Numero @tab Regexp @tab Vettore @tab Indefinito
@item @tab @b{Stringa} @tab Stringa @tab Stringa @tab Stringa @tab Stringa @tab false @tab false
@item @tab @b{Strnum} @tab false @tab Strnum @tab Strnum @tab false @tab false @tab false
@item @tab @b{Numero} @tab Numero @tab Numero @tab Numero @tab false @tab false @tab false
@item @b{Tipo} @tab @b{Regexp} @tab false @tab false @tab false @tab Regexp @tab false @tab false
@item @b{Richiesto} @tab @b{Vettore} @tab false @tab false @tab false @tab false @tab Vettore @tab false
@item @tab @b{Scalar} @tab Scalar @tab Scalar @tab Scalar @tab Scalar @tab false @tab false
@item @tab @b{Indefinito} @tab Stringa @tab Strnum @tab Numero @tab Regexp @tab Vettore @tab Indefinito
@item @tab @b{Value cookie} @tab false @tab false @tab false @tab false @tab false @tab false
@end multitable
@end ifclear
@ifset SMALLPRINT
@smallformat
@multitable {Richiesto} {Value cookie} {Num.} {Num.} {Scal.} {Regexp} {Vett.} {Indef.}
@headitem @tab @tab String @tab Strn. @tab Num. @tab Regexp @tab Vett. @tab Indef.
@item @tab @b{Stringa} @tab String @tab String @tab String @tab String @tab false @tab false
@item @tab @b{Strnum} @tab false @tab Strn. @tab Strn. @tab false @tab false @tab false
@item @tab @b{Numero} @tab Num. @tab Num. @tab Num. @tab false @tab false @tab false
@item @b{Tipo} @tab @b{Regexp} @tab false @tab false @tab false @tab Regexp @tab false @tab false
@item @b{Richiesto} @tab @b{Vettore} @tab false @tab false @tab false @tab false @tab Vett. @tab false
@item @tab @b{Scalar} @tab Scal. @tab Scal. @tab Scal. @tab Scal. @tab false @tab false
@item @tab @b{Indefinito} @tab String @tab Strn. @tab Num. @tab Regexp @tab Vett. @tab Indef.
@item @tab @b{Value cookie} @tab false @tab false @tab false @tab false @tab false @tab false
@end multitable
@end smallformat
@end ifset
@end ifnotdocbook
@end ifnotplaintext
@ifplaintext
@verbatim
+-------------------------------------------------------+
| Tipo di valore reale: |
+--------+--------+--------+--------+-------+-----------+
| Stringa| Strnum | Numero | Regexp |Vettore| Indefinito|
+-----------+-----------+--------+--------+--------+--------+-------+-----------+
| | Stringa | Stringa| Stringa| Stringa| Stringa| false | false |
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Strnum | false | Strnum | Strnum | false | false | false |
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Numero | Numero | Numero | Numero | false | false | false |
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Regexp | false | false | false | Regexp | false | false |
| Tipo +-----------+--------+--------+--------+--------+-------+-----------+
|Richiesto: | Vettore | false | false | false | false |Vettore| false |
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Scalare | Scalare| Scalare| Scalare| Scalare| false | false |
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Indefinito| Stringa| Strnum | Numero | Regexp |Vettore| Indefinito|
| +-----------+--------+--------+--------+--------+-------+-----------+
| | Value- | false | false | false | false | false | false |
| | Cookie | | | | | | |
+-----------+-----------+--------+--------+--------+--------+-------+-----------+
@end verbatim
@end ifplaintext
@end float
@node Accedere ai parametri
@subsection Accedere ai parametri e aggiornarli
Due funzioni consentono di accedere agli argomenti (parametri)
passati all'estensione. Esse sono:
@table @code
@item awk_bool_t get_argument(size_t count,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t wanted,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato);
Riempie la struttura @code{awk_value_t} puntata da @code{risultato}
con l'argomento numero @code{count}. Restituisce @dfn{true} se il tipo
dell'argomento corrisponde
a quello specificato in @code{wanted}, e @dfn{false} in caso contrario.
In quest'ultimo caso,
@code{risultato@w{->}val_type} indica il tipo effettivo dell'argomento
(@pxref{table-value-types-returned}). La numerazione degli argomenti parte
da zero: il primo
argomento @`e il numero zero, il secondo @`e il numero uno, e cos@`{@dotless{i}} via.
@code{wanted} indica il tipo di valore atteso.
@item awk_bool_t set_argument(size_t count, awk_array_t array);
Converte un parametro di tipo indefinito in un vettore; ci@`o permette la
chiamata per riferimento per i vettori. Restituisce @dfn{false} se @code{count} @`e troppo elevato,
o se il tipo di argomento @`e diverso da @dfn{undefined}.
@xref{Manipolazione di vettori}
per ulteriori informazioni riguardo alla creazione di vettori.
@end table
@node Accedere alla tabella simboli
@subsection Accedere alla Tabella dei simboli
@cindex accedere alle variabili globali dalle estensioni
@cindex variabili @subentry globali @subentry accesso dalle estensioni
@cindex estensioni @subentry accesso alle variabili globali
Due insiemi di routine permettono di accedere alle variabili globali,
e un insieme consente di creare e rilasciare dei valori nascosti.
@menu
* Tabella simboli per nome:: Accedere alle variabili per nome.
* Tabella simboli tramite cookie:: Accedere alle variabili per ``cookie''.
* Valori nascosti:: Creare e usare valori nascosti.
@end menu
@node Tabella simboli per nome
@subsubsection Accedere alle variabili per nome e aggiornarle
Le routine che seguono permettono di raggiungere e aggiornare
le variabili globali a livello di @command{awk} per nome. Nel gergo dei
compilatori, gli identificativi di vario tipo sono noti come @dfn{simboli},
da cui il prefisso ``sym'' nei nomi delle routine. La struttura di dati che
contiene informazioni sui simboli @`e chiamata @dfn{Tabella dei simboli}
(@dfn{Symbol table}).
Le funzioni sono le seguenti:
@table @code
@item awk_bool_t sym_lookup(const char *nome,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t wanted,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato);
Riempie la struttura @code{awk_value_t} puntata da @code{risultato}
con il valore della variabile il cui nome @`e nella stringa @code{nome},
che @`e una normale stringa di caratteri C.
@code{wanted} indica il tipo di valore atteso.
La funzione restituisce @dfn{true} se il tipo effettivo della variabile @`e quello
specificato in @code{wanted}, e @dfn{false} in caso contrario.
In quest'ultimo caso, @code{risultato>val_type} indica il tipo effettivo
della variabile
(@pxref{table-value-types-returned}).
@item awk_bool_t sym_lookup_ns(const char *nome,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const char *name_space,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t wanted,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato);
Simile a @code{sym_lookup()}, ma il parametro @code{name_space} consente di
specificare a quale spazio-di-nomi appartiene @code{nome}.
@code{name_space} non pu@`o essere la stringa nulla (@code{NULL}).
Se vale @code{""} o @code{"awk"}, allora @code{nome} @`e cercato nello
spazio-di-nomi di default, ossia @code{awk}.
Si noti che @code{namespace} @`e una parola chiave di C++. Per ragioni di
interoperabilit@`a con C++, si dovrebbe evitare di usare questo identificativo
nel codice C.
@item awk_bool_t sym_update(const char *nome, awk_value_t *valore);
Aggiorna la variabile il cui nome @`e contenuto nella stringa @code{nome},
che @`e una normale stringa di caratteri C.
La variabile @`e aggiunta alla Tabella dei simboli di @command{gawk},
se non @`e gi@`a presente. Restituisce @dfn{true} se tutto @`e andato bene, e
@dfn{false} in caso contrario.
La modifica del tipo (da scalare a vettoriale o viceversa) di una variabile
gi@`a esistente @emph{non} @`e consentito, e questa routine non pu@`o neppure
essere usata per aggiornare un vettore.
Questa routine non pu@`o essere usata per modificare nessuna delle variabili
predefinite (come @code{ARGC} o @code{NF}).
@end table
Un'estensione pu@`o andare a cercare il valore delle variabili speciali di
@command{gawk}.
Tuttavia, con l'eccezione del vettore @code{PROCINFO}, un'estensione
non pu@`o cambiare alcuna di queste variabili.
@node Tabella simboli tramite cookie
@subsubsection Accedere alle variabili per ``cookie'' e aggiornarle
Uno @dfn{scalar cookie} @`e un puntatore nascosto (@dfn{opaque handle}) che
fornisce accesso a una
variabile globale o a un vettore. Si tratta di un'ottimizzazione, per evitare
di ricercare variabili nella Tabella dei simboli di @command{gawk} ogni volta
che un accesso @`e necessario. Questo
argomento @`e gi@`a stato trattato in precedenza, nella
@ref{Tipi di dati generali}.
@need 1500
Le funzioni seguenti servono per gestire gli @dfn{scalar cookie}:
@table @code
@item awk_bool_t sym_lookup_scalar(awk_scalar_t cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t wanted,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato);
Ottiene il valore corrente di uno @dfn{scalar cookie}.
Una volta ottenuto lo @dfn{scalar cookie} usando @code{sym_lookup()}, si
pu@`o usare questa funzione per accedere al valore della variabile in modo
pi@`u efficiente.
Restituisce @dfn{false} se il valore non @`e disponibile.
@item awk_bool_t sym_update_scalar(awk_scalar_t cookie, awk_value_t *valore);
Aggiorna il valore associato con uno @dfn{scalar cookie}.
Restituisce @dfn{false} se il nuovo valore non @`e del tipo
@code{AWK_STRING}, @code{AWK_STRNUM}, @code{AWK_REGEX} o @code{AWK_NUMBER}.
Anche in questo caso, le variabili predefinite non possono essere aggiornate.
@end table
Non @`e immediatamente evidente come si lavora con gli @dfn{scalar cookie} o
quale sia la loro vera @i{ragion d'essere}. In teoria, le routine
@code{sym_lookup()} e @code{sym_update()} sono tutto ci@`o che occorre per
lavorare con le variabili. Per esempio, ci potrebbe essere un codice che
ricerca il valore di una variabile, valuta una condizione, e potrebbe
poi cambiare il valore della variabile a seconda dei risultati della
valutazione in modo simile a questo:
@example
/* do_magic --- fai qualcosa di veramente grande */
static awk_value_t *
do_magic(int nargs, awk_value_t *risultato)
@{
awk_value_t valore;
if ( sym_lookup("MAGIC_VAR", AWK_NUMBER, & valore)
&& qualche_condizione(valore.num_valore)) @{
valore.num_valore += 42;
sym_update("MAGIC_VAR", & valore);
@}
return make_number(0.0, risultato);
@}
@end example
@noindent
Questo codice sembra (ed @`e) semplice e immediato. Qual @`e il problema?
Beh, si consideri cosa succede se un qualche codice a livello di @command{awk}
associato con l'estensione richiama la funzione @code{magic()}
(implementata in linguaggio C da @code{do_magic()}), una volta per ogni
record, mentre si stanno elaborando
file contenenti migliaia o milioni di record.
La variabile @code{MAGIC_VAR} viene ricercata nella Tabella dei simboli una o due
volte per ogni richiamo della funzione!
La ricerca all'interno della Tabella dei simboli @`e in realt@`a una pura perdita
di tempo; @`e molto pi@`u efficiente
ottenere un @dfn{value cookie} che rappresenta la variabile, e usarlo per
ottenere il valore della variabile e aggiornarlo a seconda della
necessit@`a.@footnote{La differenza @`e misurabile e indubbiamente reale.
Fidatevi.}
Quindi, la maniera per usare i valori-cookie @`e la seguente. Per prima
cosa, la variabile di estensione va messa nella Tabella dei simboli di
@command{gawk} usando @code{sym_update()}, come al solito. Poi si deve ottenere
uno @dfn{scalar cookie} per la
variabile usando @code{sym_lookup()}:
@example
@group
static awk_scalar_t magic_var_cookie; /* cookie per MAGIC_VAR */
static void
inizializza_estensione()
@{
awk_value_t valore;
@end group
/* immettere il valore iniziale */
sym_update("MAGIC_VAR", make_number(42.0, & valore));
/* ottenere il @dfn{value cookie} */
sym_lookup("MAGIC_VAR", AWK_SCALAR, & valore);
/* salvarlo per dopo */
magic_var_cookie = valore.scalar_cookie;
@dots{}
@}
@end example
Dopo aver fatto questo, si usino le routine descritte in questa @value{SECTION}
per ottenere e modificare
il valore usando il @dfn{value cookie}. Quindi, @code{do_magic()} diviene ora
qualcosa del tipo:
@example
/* do_magic --- fai qualcosa di veramente grande */
static awk_value_t *
do_magic(int nargs, awk_value_t *risultato)
@{
awk_value_t valore;
if ( sym_lookup_scalar(magic_var_cookie, AWK_NUMBER, & valore)
&& qualche_condizione(valore.num_valore)) @{
valore.num_valore += 42;
sym_update_scalar(magic_var_cookie, & valore);
@}
@dots{}
return make_number(0.0, risultato);
@}
@end example
@quotation NOTA
Il codice appena visto omette il controllo di eventuali errori, per
amor di semplicit@`a. Il codice dell'estensione dovrebbe essere pi@`u complesso
e controllare attentamente i valori
restituiti dalle funzioni dell'API.
@end quotation
@node Valori nascosti
@subsubsection Creare e usare valori nascosti
Le routine in questa @value{SECTION} permettono di creare e rilasciare
valori nascosti. Come gli @dfn{scalar cookie}, in teoria i valori nascosti
non sono necessari. Si possono creare numeri e stringhe usando
le funzioni descritte
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzioni di costruzione}. Si possono poi assegnare
quei valori a delle variabili usando @code{sym_update()}
o @code{sym_update_scalar()}, come si preferisce.
Tuttavia, si pu@`o comprendere l'utilit@`a di avere dei valori nascosti
se si pone mente al fatto che la memoria di @emph{ogni} valore di stringa
@emph{deve} essere ottenuta tramite @code{gawk_malloc()},
@code{gawk_calloc()} o @code{gawk_realloc()}.
Se ci sono 20 variabili, e tutte hanno per valore la stessa stringa,
si devono creare 20 copie identiche della stringa.@footnote{I valori
numerici creano molti meno problemi, in quanto richiedono solo una variabile
C @code{double} (8 byte) per contenerli. Naturalmente, valori di tipo
GMP ed MPFR usano @emph{molta} pi@`u memoria.}
Chiaramente @`e pi@`u efficiente, se possibile, creare il valore una sola volta,
e fare in modo che @command{gawk} utilizzi quell'unico valore per molte
variabili. Questo @`e ci@`o che la routine in
@ifnotinfo
questa
@end ifnotinfo
@ifinfo
questo
@end ifinfo
@value{SECTION} permette
di fare. Le funzioni sono le seguenti:
@table @code
@item awk_bool_t create_value(awk_value_t *valore, awk_value_cookie_t *risultato);
Crea una stringa o un valore numerico nascosti, da @code{valore}, in
vista di un successivo assegnamento di valore. Sono consentiti solo valori di
tipo @code{AWK_NUMBER}, @code{AWK_REGEX} ed @code{AWK_STRING}.
Ogni altro tipo @`e rifiutato.
Il tipo @code{AWK_UNDEFINED} potrebbe essere consentito, ma in questo caso
l'efficienza del programma ne soffrirebbe.
@item awk_bool_t release_value(awk_value_cookie_t vc);
Libera la memoria associata con un @dfn{value cookie} ottenuto mediante
@code{create_value()}.
@end table
Si usano i @dfn{value cookie} in modo dimile a quello con cui si usano gli
@dfn{scalar cookie}.
Nella routine di inizializzazione dell'estensione, si crea il
@dfn{value cookie}:
@example
static awk_value_cookie_t answer_cookie; /* static @dfn{value cookie} */
static void
inizializza_estensione()
@{
awk_value_t value;
char *long_string;
size_t long_string_len;
/* codice precedente */
@dots{}
/* @dots{} riempire long_string e long_string_len @dots{} */
make_malloced_string(long_string, long_string_len, & value);
create_value(& value, & answer_cookie); /* creare cookie */
@dots{}
@}
@end example
Una volta che il valore @`e creato, si pu@`o usare come valore per un numero
qualsiasi di variabili:
@example
static awk_value_t *
do_magic(int nargs, awk_value_t *risultato)
@{
awk_value_t new_value;
@dots{} /* come in precedenza */
value.val_type = AWK_VALUE_COOKIE;
value.value_cookie = answer_cookie;
sym_update("VAR1", & value);
sym_update("VAR2", & value);
@dots{}
sym_update("VAR100", & value);
@dots{}
@}
@end example
@noindent
Usare @dfn{value cookie} in questo modo permette di risparmiare parecchia
memoria, poich@'e tutte le variabili da @code{VAR1} a @code{VAR100} condividono
lo stesso valore.
Ci si potrebbe chiedere, ``Questa condivisione crea problemi?
Cosa succede se il codice @command{awk} assegna un nuovo valore a @code{VAR1};
sono modificate anche tutte le altre variabili?''
Buona domanda! La risposta @`e che no, non @`e un problema.
Internamente, @command{gawk} usa
@dfn{un contatore dei riferimenti alle stringhe}. Questo significa
che molte variabili possono condividere lo stesso valore di tipo stringa,
e @command{gawk} mantiene traccia del loro uso. Quando il valore di
una variabile viene modificato, @command{gawk} semplicemente diminuisce di
uno il contatore dei riferimenti del vecchio valore, e aggiorna la variabile
perch@'e usi il nuovo valore.
Infine, come parte della pulizia al termine del programma
(@pxref{Funzioni di exit callback})
si deve liberare ogni valore nascosto che era stato creato, usando
la funzione @code{release_value()}.
@node Manipolazione di vettori
@subsection Manipolazione di vettori
@cindex vettori @subentry manipolazione nelle estensioni
@cindex estensioni @subentry manipolazione di vettori nelle
La struttura di dati primaria@footnote{D'accordo, l'unica struttura di dati.}
in @command{awk} @`e il vettore associativo
@iftex
(@pxrefil{Vettori}).
@end iftex
@ifnottex
(@pxref{Vettori}).
@end ifnottex
Le estensioni devono essere in grado di manipolare vettori @command{awk}.
L'API fornisce varie strutture di dati per lavorare con vettori,
funzioni per lavorare con singoli elementi di un vettore, e funzioni per
lavorare con interi vettori. @`E prevista anche la possibilit@`a di
``appiattire'' un vettore in modo da rendere facile a un programma scritto in
C la ``visita'' di tutti gli elementi del vettore.
Le strutture dati per i vettori sono facilmente integrabili con le
strutture dati per variabili scalari, per facilitare sia l'elaborazione, sia
la creazione di @dfn{veri} vettori di vettori (@pxref{Tipi di dati generali}).
@menu
* Tipi di dati per i vettori:: Tipi dati per lavorare coi vettori.
* Funzioni per i vettori:: Funzioni per lavorare coi vettori.
* Appiattimento di vettori:: Come appiattire i vettori.
* Creazione di vettori:: Come creare e popolare vettori.
@end menu
@node Tipi di dati per i vettori
@subsubsection Tipi di dati per i vettori
I tipi di dato associati con i vettori sono i seguenti:
@table @code
@item typedef void *awk_array_t;
Se si richiede il valore di una variabile contenuta in un vettore, si ottiene
un valore del tipo @code{awk_array_t}. Questo valore @`e
@dfn{opaco}@footnote{@`E anche un
``cookie,'' ma gli sviluppatori di @command{gawk} hanno preferito non abusare
di questo termine.} per l'estensione; identifica in maniera univoca il
vettore ma pu@`o solo essere usato come parametro di una funzione dell'API,
o essere ricevuto da una funzione dell'API. Questo @`e molto simile al modo
in cui i valori @samp{FILE *} sono usati con le routine di libreria di
@code{}.
@item typedef struct awk_element @{
@itemx @ @ @ @ /* puntatore di servizio
@itemx @ @ @ @ a lista collegata, non usato da gawk */
@itemx @ @ @ @ struct awk_element *next;
@itemx @ @ @ @ enum @{
@itemx @ @ @ @ @ @ @ @ AWK_ELEMENT_DEFAULT = 0,@ @ /* impostato da gawk */
@itemx @ @ @ @ @ @ @ @ AWK_ELEMENT_DELETE = 1@ @ @ @ /* impostato dall'estensione */
@itemx @ @ @ @ @} flags;
@itemx @ @ @ @ awk_value_t index;
@itemx @ @ @ @ awk_value_t value;
@itemx @} awk_element_t;
@code{awk_element_t} @`e un elemento di vettore ``appiattito''.
@command{awk} produce un vettore di questo tipo all'interno della struttura
@code{awk_flat_array_t} (si veda poco pi@`u avanti).
Singoli elementi di vettore possono essere marcati per essere cancellati.
Nuovi elementi del vettore devono essere aggiunti individualmente, uno per
volta, usando una funzione API apposita. I campi sono i seguenti:
@c nested table
@table @code
@item struct awk_element *next;
Questo puntatore @`e presente come ausilio a chi scrive un'estensione.
Permette a un'estensione di creare una lista collegata (@dfn{linked list}) di
nuovi elementi che possono essere aggiunti a un vettore con un
singolo ciclo che percorre tutta la lista.
@item enum @{ @dots{} @} flags;
Un insieme di valori di flag che passano informazione tra l'estensione
e @command{gawk}. Per ora c'@`e solo un flag disponibile:
@code{AWK_ELEMENT_DELETE}.
Se lo si imposta, @command{gawk} elimina l'elemento in questione dal vettore
originale, dopo che il vettore ``appiattito'' @`e stato rilasciato.
@item index
@itemx value
L'indice e il valore di un elemento, rispettivamente.
@emph{Tutta} la memoria puntata da @code{index} e @code{valore} appartiene
a @command{gawk}.
@end table
@item typedef struct awk_flat_array @{
@itemx @ @ @ @ awk_const void *awk_const opaque1;@ @ @ @ /* per uso di gawk */
@itemx @ @ @ @ awk_const void *awk_const opaque2;@ @ @ @ /* per uso di gawk */
@itemx @ @ @ @ awk_const size_t count;@ @ @ @ @ /* quanti elementi nel vettore */
@itemx @ @ @ @ awk_element_t elements[1];@ @ /* saranno ``appiattiti'' */
@itemx @} awk_flat_array_t;
Questo @`e un vettore appiattito. Quando un'estensione ottiene da
@command{gawk} questa struttura, il vettore @code{elements} ha una dimensione
reale di @code{count} elementi.
I puntatori @code{opaque1} e @code{opaque2} sono per uso di @command{gawk};
come tali, sono marcati come @code{awk_const} in modo che l'estensione non
possa modificarli.
@end table
@node Funzioni per i vettori
@subsubsection Funzioni per lavorare coi vettori
Le funzioni seguenti permettono di gestire singoli elementi di un vettore:
@table @code
@item awk_bool_t get_element_count(awk_array_t a_cookie, size_t *count);
Per il vettore rappresentato da @code{a_cookie}, restituisce in @code{*count}
il numero di elementi in esso contenuti. Ogni sottovettore @`e conteggiato come
se fosse un solo elemento.
Restituisce @dfn{false} se si verifica un errore.
@item awk_bool_t get_array_element(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const awk_value_t *const index,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t wanted,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_value_t *risultato);
Per il vettore rappresentato da @code{a_cookie}, restituisce in @code{*risultato}
il valore dell'elemento il cui indice @`e @code{index}.
@code{wanted} specifica il tipo di valore che si vuole ritrovare.
Restituisce @dfn{false} se @code{wanted} non coincide con il tipo di dato o
se @code{index} non @`e nel vettore (@pxref{table-value-types-returned}).
Il valore per @code{index} pu@`o essere numerico, nel qual caso @command{gawk}
lo converte in una stringa. Usare valori non interi @`e possibile, ma
richiede di comprendere il modo con cui tali valori sono convertiti in stringhe
(@pxref{Conversione}); per questo motivo, @`e meglio usare numeri interi.
Come per @emph{tutte} le stringhe passate a @command{gawk} da
un'estensione, la memoria che contiene il valore della stringa con chiave
@code{index} deve essere stata acquisita utilizzando le funzioni
@code{gawk_malloc()}, @code{gawk_calloc()} o @code{gawk_realloc()}, e
@command{gawk} rilascer@`a (al momento opportuno) la relativa memoria.
@item awk_bool_t set_array_element(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const@ awk_value_t *const index,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const@ awk_value_t *const value);
Nel vettore rappresentato da @code{a_cookie}, crea o modifica
l'elemento il cui indice @`e contenuto in @code{index}.
I vettori @code{ARGV} ed @code{ENVIRON} non possono essere modificati,
mentre il vettore @code{PROCINFO} @`e modificabile.
@item awk_bool_t set_array_element_by_elem(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_element_t element);
Come @code{set_array_element()}, ma prende l'indice @code{index} e
il valore @code{value} da @code{element}. Questa @`e una macro di utilit@`a.
@item awk_bool_t del_array_element(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const awk_value_t* const index);
Elimina dal vettore, rappresentato da @code{a_cookie}, l'elemento con
l'indice specificato.
Restituisce @dfn{true} se l'elemento @`e stato rimosso o @dfn{false} se
l'elemento non era presente nel vettore.
@end table
Le seguenti funzioni operano sull'intero vettore:
@table @code
@item awk_array_t create_array(void);
Crea un nuovo vettore a cui si possono aggiungere elementi.
@xref{Creazione di vettori} per una trattazione su come
creare un nuovo vettore e aggiungervi elementi.
@item awk_bool_t clear_array(awk_array_t a_cookie);
Svuota il vettore rappresentato da @code{a_cookie}.
Restituisce @dfn{false} in presenza di qualche tipo di problema, @dfn{true}
in caso contrario. Il vettore non viene eliminato ma, dopo aver chiamato
questa funzione, resta privo di elementi. Questo equivale a usare
l'istruzione @code{delete} (@pxref{Cancellazione}).
@item awk_bool_t flatten_array_typed(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_flat_array_t **data,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t index_type,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_valtype_t value_type);
Per il vettore rappresentato da @code{a_cookie}, crea una struttura
@code{awk_flat_array_t} e la riempie con indici e valori del tipo richiesto.
Imposta il puntatore il cui indirizzo @`e passato in @code{data} per puntare a
questa struttura.
Restituisce @dfn{true} se tutto va bene o @dfn{false} in caso contrario.
@ifset FOR_PRINT
Si veda la prossima @value{SECTION}
@end ifset
@ifclear FOR_PRINT
@xref{Appiattimento di vettori},
@end ifclear
per una trattazione su come appiattire un vettore per poterci lavorare.
@item awk_bool_t flatten_array(awk_array_t a_cookie, awk_flat_array_t **data);
Per il vettore rappresentato da @code{a_cookie}, crea una struttura
@code{awk_flat_array_t} e la riempie con indici di tipo @code{AWK_STRING} e
valori @code{AWK_UNDEFINED}.
Questa funzione @`e resa obsoleta da @code{flatten_array_typed()}.
@`E fornita come macro, e mantenuta per convenienza e per compatibilit@`a a
livello di codice sorgente con la precedente versione dell'API.
@item awk_bool_t release_flattened_array(awk_array_t a_cookie,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ awk_flat_array_t *data);
Quando si @`e finito di lavorare con un vettore appiattito, si liberi la
memoria usando questa funzione. Occorre fornire sia il cookie del vettore
originale, sia l'indirizzo della struttura da liberare,
@code{awk_flat_array_t}.
La funzione restituisce @dfn{true} se tutto va bene, @dfn{false} in caso contrario.
@end table
@node Appiattimento di vettori
@subsubsection Lavorare con tutti gli elementi di un vettore
@dfn{Appiattire} un vettore vuol dire creare una struttura che
rappresenta l'intero vettore in modo da facilitare la visita
dell'intero vettore da parte del codice in C . Parte del codice in
@file{extension/testext.c} fa questo, ed @`e anche un bell'esempio
di come utilizzare l'API.
Questa parte del codice sorgente sar@`a descritta un po' per volta.
Ecco, per iniziare, lo @dfn{script} @command{gawk} che richiama l'estensione di test:
@example
@@load "testext"
BEGIN @{
n = split("blacky rusty sophie raincloud lucky", pets)
printf("pets ha %d elementi\n", length(pets))
ret = dump_array_and_delete("pets", "3")
printf("dump_array_and_delete(pets) ha restituito %d\n", ret)
if ("3" in pets)
printf("dump_array_and_delete() NON ha rimosso l'indice \"3\"!\n")
else
printf("dump_array_and_delete() ha rimosso l'indice \"3\"!\n")
print ""
@}
@end example
@noindent
Questo codice crea un vettore usando la funzione @code{split()}
(@pxref{Funzioni per stringhe})
e poi chiama @code{dump_array_and_delete()}. Questa funzione ricerca
il vettore il cui nome @`e passato come primo argomento, ed
elimina l'elemento il cui indice @`e passato come secondo argomento.
Il codice @command{awk} stampa poi il valore restituito e controlla che
l'elemento sia stato effettivamente cancellato. Ecco il codice C che
costituisce la funzione
@code{dump_array_and_delete()}. @`E stato leggermente modificato per facilitare
l'esposizione.
La prima parte dichiara variabili, imposta il codice di ritorno di default
in @code{risultato}, e controlla che la funzione
sia stata chiamata con il numero corretto di argomenti:
@example
static awk_value_t *
dump_array_and_delete(int nargs, awk_value_t *risultato)
@{
awk_value_t valore, valore2, valore3;
awk_flat_array_t *flat_array;
size_t count;
char *nome;
int i;
assert(risultato != NULL);
make_number(0.0, risultato);
if (nargs != 2) @{
printf("dump_array_and_delete: nargs errato "
"(%d dovrebbe essere 2)\n", nargs);
goto out;
@}
@end example
La funzione poi prosegue un passo per volta, come segue. Il primo passo @`e
ricuperare il nome del vettore, passato come primo argomento, seguito dal
vettore stesso. Se una di queste operazioni non riesce, viene stampato un
messaggio di errore e si ritorna al chiamante:
@example
/* trasforma in un vettore piatto il vettore
passato come argomento e lo stampa */
if (get_argument(0, AWK_STRING, & value)) @{
nome = valore.str_value.str;
if (sym_lookup(nome, AWK_array, & value2))
printf("dump_array_and_delete: sym_lookup di %s effettuato\n",
nome);
else @{
printf("dump_array_and_delete: sym_lookup di %s non riuscito\n",
nome);
goto out;
@}
@} else @{
printf("dump_array_and_delete: get_argument(0) non riuscito\n");
goto out;
@}
@end example
Per controllo, e per assicurarsi che il codice C veda
lo stesso numero di elementi del codice @command{awk},
il secondo passo @`e quello di ottenere il numero di elementi nel vettore
e stamparlo:
@example
if (! get_element_count(valore2.array_cookie, & count)) @{
printf("dump_array_and_delete: get_element_count non riuscito\n");
goto out;
@}
printf("dump_array_and_delete: il vettore in input ha %lu elementi\n",
(unsigned long) count);
@end example
Il terzo passo @`e quello di appiattire il vettore, e quindi
controllare che il numero di elementi nella struttura @code{awk_flat_array_t}
sia uguale a quello appena trovato:
@example
if (! flatten_array_typed(valore2.array_cookie, & flat_array,
AWK_STRING, AWK_UNDEFINED)) @{
printf("dump_array_and_delete: non sono riuscito ad appiattire \
il vettore\n");
goto out;
@}
if (flat_array->count != count) @{
printf("dump_array_and_delete: flat_array->count (%lu)"
" != count (%lu)\n",
(unsigned long) flat_array->count,
(unsigned long) count);
goto out;
@}
@end example
Il quarto passo @`e ritrovare l'indice dell'elemento
da eliminare, che era stato passato come secondo argomento.
Va tenuto presente che i contatori di argomenti passati a @code{get_argument()}
partono da zero, e che quindi il secondo argomento @`e quello numero uno:
@example
if (! get_argument(1, AWK_STRING, & value3)) @{
printf("dump_array_and_delete: get_argument(1) non riuscito\n");
goto out;
@}
@end example
Il quinto passo @`e quello in cui si fa il ``vero lavoro''. La funzione esegue
un ciclo su ogni elemento nel vettore, stampando i valori degli indici e
degli elementi. Inoltre, dopo aver trovato, tramite l'indice, l'elemento
che si vorrebbe eliminare, la funzione imposta il @dfn{bit}
@code{AWK_ELEMENT_DELETE} nel campo @code{flags}
dell'elemento. Quando il vettore @`e stato interamente percorso, @command{gawk}
visita il vettore appiattito, ed elimina ogni elemento in cui il relativo
@dfn{bit} della flag sia impostato:
@example
for (i = 0; i < flat_array->count; i++) @{
printf("\t%s[\"%.*s\"] = %s\n",
nome,
(int) flat_array->elements[i].index.str_value.len,
flat_array->elements[i].index.str_value.str,
valrep2str(& flat_array->elements[i].valore));
if (strcmp(valore3.str_value.str,
flat_array->elements[i].index.str_value.str) == 0) @{
flat_array->elements[i].flags |= AWK_ELEMENT_DELETE;
printf("dump_array_and_delete: ho marcato l'elemento \"%s\" "
"per eliminazione\n",
flat_array->elements[i].index.str_value.str);
@}
@}
@end example
Il sesto passo @`e liberare il vettore appiattito. Questo segnala a
@command{gawk} che l'estensione non sta pi@`u usando il vettore,
e che dovrebbe eliminare gli elementi marcati per l'eliminazione.
@command{gawk} libera anche ogni area di memoria che era stata allocata,
e quindi non si dovrebbe pi@`u usare il puntatore (@code{flat_array} in
questo codice) dopo aver chiamato @code{release_flattened_array()}:
@example
if (! release_flattened_array(valore2.array_cookie, flat_array)) @{
printf("dump_array_and_delete: non riesco a liberare \
il vettore appiattito\n");
goto out;
@}
@end example
Infine, poich@'e tutto @`e andato bene, la funzione imposta il codice di ritorno
a "successo", e lo restituisce quando esce:
@example
@group
make_number(1.0, risultato);
out:
return risultato;
@}
@end group
@end example
Ecco l'output ottenuto eseguendo questa parte del test:
@example
pets ha 5 elementi
dump_array_and_delete: sym_lookup di pets effettuato
dump_array_and_delete: il vettore in input ha 5 elementi
pets["1"] = "blacky"
pets["2"] = "rusty"
pets["3"] = "sophie"
dump_array_and_delete: ho marcato l'elemento "3" per eliminazione
pets["4"] = "raincloud"
pets["5"] = "lucky"
dump_array_and_delete(pets) ha restituito 1
dump_array_and_delete() ha rimosso l'indice "3"!
@end example
@node Creazione di vettori
@subsubsection Come creare e popolare vettori
Oltre a lavorare con vettori creati da codice @command{awk}, si possono
creare vettori a cui aggiungere elementi secondo le esigenze, che poi
il codice @command{awk} pu@`o utilizzare e manipolare.
Ci sono due punti importanti da tener presente quando di creano vettori dal
codice di un'estensione:
@itemize @value{BULLET}
@item
Il vettore appena creato deve essere subito messo nella Tabella dei simboli di
@command{gawk}. Solo dopo aver fatto questo @`e possibile aggiungere elementi
al vettore.
@ignore
Strictly speaking, this is required only
for arrays that will have subarrays as elements; however it is
a good idea to always do this. This restriction may be relaxed
in a subsequent revision of the API.
@end ignore
Analogamente, se si installa un nuovo vettore come sottovettore di
un vettore gi@`a esistente,
occorre prima aggiungere il nuovo vettore al suo "genitore" per poter poi
aggiungere degli elementi allo stesso.
Quindi, il modo giusto per costruire un vettore @`e di lavorare ``dall'alto
verso il basso''. Creare il vettore, e subito aggiungerlo alla Tabella dei
simboli di @command{gawk} usando @code{sym_update()}, o installarlo come
elemento in un vettore gi@`a esistente usando @code{set_array_element()}.
Un esempio di codice @`e fornito pi@`u sotto.
@item
Per come funziona internamente @command{gawk}, dopo aver usato
@code{sym_update()} per definire un vettore
in @command{gawk}, si deve innanzitutto ricuperare il @dfn{cookie}
del vettore dal valore passato a @command{sym_update()}, in questo modo:
@example
awk_value_t val;
awk_array_t new_array;
new_array = create_array();
val.val_type = AWK_ARRAY;
val.array_cookie = new_array;
/* aggiunge il vettore alla Tabella dei simboli */
sym_update("array", & val);
new_array = val.array_cookie; /* QUESTO @`E OBBLIGATORIO */
@end example
Se si sta installando un vettore come sottovettore, occorre anche
ricuperare il @dfn{cookie} del vettore dopo aver chiamato @code{set_element()}.
@end itemize
Il seguente codice C @`e una semplice estensione di test per creare un vettore
con due elementi normali e con un sottovettore. Le direttive iniziali
@code{#include} e le solite dichiarazione di variabili sono state omesse per
amor di brevit@`a
(@pxref{Codice predefinito di un'estensione API}).
Il primo passo @`e creare un nuovo vettore e poi aggiungerlo alla
Tabella dei simboli:
@example
@ignore
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include "gawkapi.h"
static const gawk_api_t *api; /* per far funzionare le macro di utilit@`a */
static awk_ext_id_t ext_id;
static const char *ext_version = "testarray extension: version 1.0";
int plugin_is_GPL_compatible;
@end ignore
/* create_new_array --- creare un vettore denominato */
static void
create_new_array()
@{
awk_array_t a_cookie;
awk_array_t sottovettore;
awk_value_t index, valore;
a_cookie = create_array();
valore.val_type = AWK_array;
valore.array_cookie = a_cookie;
if (! sym_update("new_array", & value))
printf("create_new_array: sym_update(\"nuovo_vettore\") \
non riuscito!\n");
a_cookie = valore.array_cookie;
@end example
@noindent
Si noti come @code{a_cookie} @`e reimpostato dal campo @code{array_cookie}
nella struttura @code{valore}.
Il secondo passo aggiunge due elementi normali a @code{nuovo_vettore}:
@example
(void) make_const_string("salve", 5, & index);
(void) make_const_string("mondo", 5, & value);
if (! set_array_element(a_cookie, & index, & value)) @{
printf("fill_in_array: set_array_element non riuscito\n");
return;
@}
(void) make_const_string("risposta", 8, & index);
(void) make_number(42.0, & value);
if (! set_array_element(a_cookie, & index, & value)) @{
printf("fill_in_array: set_array_element non riuscito\n");
return;
@}
@end example
Il terzo passo @`e creare il sottovettore e aggiungerlo al vettore:
@example
(void) make_const_string("sottovettore", 12, & index);
sottovettore = create_array();
valore.val_type = AWK_array;
valore.array_cookie = subarray;
if (! set_array_element(a_cookie, & index, & value)) @{
printf("fill_in_array: set_array_element non riuscito\n");
return;
@}
sottovettore = valore.array_cookie;
@end example
Il passo finale @`e di aggiungere al sottovettore un suo proprio elemento:
@example
(void) make_const_string("pippo", 5, & index);
(void) make_const_string("pluto", 5, & value);
if (! set_array_element(sottovettore, & index, & value)) @{
printf("fill_in_array: set_array_element non riuscito\n");
return;
@}
@}
@ignore
static awk_ext_func_t func_table[] = @{
@{ NULL, NULL, 0 @}
@};
/* init_testarray --- funzione ulteriore di inizializzazione */
static awk_bool_t init_testarray(void)
@{
create_new_array();
return awk_true;
@}
static awk_bool_t (*init_func)(void) = init_testarray;
dl_load_func(func_table, testarray, "")
@end ignore
@end example
Ecco uno @dfn{script} di esempio che carica l'estensione
e quindi stampa il valore di tutti gli elementi del vettore,
invocando nuovamente se stessa nel caso che un particolare
elemento sia a sua volta un vettore:
@example
@@load "subarray"
function dumparray(nome, vettore, i)
@{
for (i in vettore)
if (isarray(vettore[i]))
dumparray(nome "[\"" i "\"]", vettore[i])
else
printf("%s[\"%s\"] = %s\n", nome, i, vettore[i])
@}
BEGIN @{
dumparray("new_array", new_array);
@}
@end example
Ecco il risultato dell'esecuzione dello @dfn{script}:
@example
$ @kbd{AWKLIBPATH=$PWD gawk -f subarray.awk}
@print{} new_array["sottovettore"]["pippo"] = pluto
@print{} new_array["salve"] = mondo
@print{} new_array["risposta"] = 42
@end example
@noindent
(@xref{Trovare le estensioni} per ulteriori dettagli sulla
variabile d'ambiente @env{AWKLIBPATH}.)
@node Ridirezione API
@subsection Accedere alle ridirezioni e modificarle
La seguente funzione consente alle estensioni di accedere e di manipolare
delle ridirezioni.
@table @code
@item awk_bool_t get_file(const char *nome,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ size_t name_len,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const char *tipofile,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ int fd,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const awk_input_buf_t **ibufp,
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ const awk_output_buf_t **obufp);
Ricerca il file @code{nome} nella tabella interna di ridirezione di
@command{gawk}.
Se @code{nome} @`e @code{NULL} o @code{name_len} @`e zero, restituisce
i dati del file in input correntemente aperto il cui nome @`e memorizzato in
@code{FILENAME}.
(Questa chiamata non usa l'argomento @code{filetype}, che, quindi, pu@`o essere
lasciato indefinito).
Se il file non @`e gi@`a aperto, tenta di aprirlo.
L'argomento @code{filetype} deve terminare con uno zero binario, e dovrebbe
dovrebbe avere uno di questi valori:
@table @code
@item ">"
Un file aperto in output.
@item ">>"
Un file aperto in output, record aggiunti a fine file,
dopo quelli gi@`a esistenti [@dfn{append}].
@item "<"
Un file aperto in input.
@item "|>"
Una @dfn{pipe} aperta in output.
@item "|<"
Una @dfn{pipe} aperta in input.
@item "|&"
Un coprocesso bidirezionale.
@end table
In caso di errore, restituisce il valore @code{awk_false}.
Altrimenti, restituisce
@code{awk_true}, insieme a ulteriori informazioni sulla ridirezione
nei puntatori @code{ibufp} e @code{obufp}.
Per ridirezioni di input il valore @code{*ibufp} non dovrebbe essere
@code{NULL}, mentre @code{*obufp} dovrebbe essere @code{NULL}.
Per ridirezioni di input,
il valore di @code{*ibufp} dovrebbe essere non-@code{NULL}, e @code{*obufp}
dovrebbe essere @code{NULL}.
Per ridirezioni di output,
il valore di @code{*obufp} dovrebbe essere non-@code{NULL}, e @code{*ibufp}
dovrebbe essere @code{NULL}.
Per coprocessi bidirezionali, ognuno dei due
valori dovrebbe essere non-@code{NULL}.
Normalmente, l'estensione @`e interessata a @code{(*ibufp)->fd}
e/o @code{fileno((*obufp)->fp)}. Se il file non @`e gi@`a
aperto, e l'argomento @code{fd} non @`e negativo, @command{gawk}
user@`a quel descrittore di file invece di aprire il file nella
maniera solita. Se l'@code{fd} non @`e negativo, ma il file esiste gi@`a,
@command{gawk} ignora l'@code{fd} e restituisce il file esistente. @`E
responsabilit@`a del chiamante notare che n@'e l'@code{fd} nella struttura
restituita @code{awk_input_buf_t}, n@'e l'@code{fd} nella struttura restituita
@code{awk_output_buf_t} contiene il valore richiesto.
Si noti che fornire un descrittore di file @emph{non} @`e al momento supportato
per le @dfn{pipe}. Tuttavia, l'utilizzo di un descrittore di file
dovrebbe essere possibile per @dfn{socket} in input, output,
aggiunta-a-fine-file (append), e bidirezionale (coprocessi).
Se @code{filetype} @`e bidirezionale, @command{gawk} presuppone che sia un
@dfn{socket}! Si noti che nel caso
bidirezionale i descrittori di file in input e output possono essere
differenti.
Per essere sicuri che tutto sia andato bene, si deve controllare che uno dei due
corrisponda alla richiesta.
@end table
Si prevede che questa funzione API verr@`a usata per parallelizzare l'I/O
e rendere disponibile una libreria per i @dfn{socket}.
@node Variabili dell'estensione API
@subsection Variabili fornite dall'API
L'API fornisce due insiemi di variabili. Il primo insieme contiene
informazioni sulla versione dell'API (sia la versione dell'estensione
compilata, che quella di @command{gawk}). Il secondo
insieme contiene informazioni su come @command{gawk} @`e stato invocato.
@menu
* Versione dell'estensione:: Informazioni sulla versione API.
* Versione estensione GMP/MPFR:: Informazioni sulla versione disponibile
di GMP ed MPFR.
* Variabili informative di estens. API:: Variabili che forniscono informationi
sull'invocazione di @command{gawk}.
@end menu
@node Versione dell'estensione
@subsubsection Costanti e variabili della versione dell'API
@cindex API (estensione) @subentry versione
@cindex versione @subentry dell'estensione API @command{gawk}
@cindex estensione API @subentry @command{gawk}, versione API
L'API fornisce sia un numero di versione ``principale'' che uno ``secondario''.
Le versioni dell'API sono disponibili al momento della compilazione, come
definizioni per il preprocessore C, a supporto della compilazione
condizionale, e come elencazione di costanti per facilitare il debug:
@float Tabella,gawk-api-version
@caption{Costanti delle versioni API gawk}
@multitable {@b{API Version}} {@code{gawk_api_major_version}} {@code{GAWK_API_MAJOR_VERSION}}
@headitem versione API @tab Definiz. Preprocessore C @tab Costante di elenco
@item Major @tab @code{gawk_api_major_version} @tab @code{GAWK_API_MAJOR_VERSION}
@item Minor @tab @code{gawk_api_minor_version} @tab @code{GAWK_API_MINOR_VERSION}
@end multitable
@end float
La versione secondaria aumenta quando nuove funzioni sono aggiunte all'API.
Tali nuove funzioni sono sempre aggiunte alla fine della struttura
@code{struct} dell'API.
La versione principale aumenta (e la versione secondaria torna a zero) se
qualche tipo di dati cambia dimensione o si modifica l'ordine dei campi, o se
qualcuna delle funzioni esistenti cambia il livello di versione.
Pu@`o capitare che un'estensione sia stata compilata con una versione
dell'API ma caricata da una versione di @command{gawk} che ne usa una
differente. Per questo motivo, la versione principale e quella secondaria
dell'API della versione in uso di @command{gawk} sono incluse nella
struttura @code{struct} dell'API come costanti intere in sola lettura:
@table @code
@item api->major_version
La versione principale di @command{gawk} in esecuzione.
@item api->minor_version
La versione secondaria di @command{gawk} in esecuzione.
@end table
Dipende dall'estensione decidere se ci sono incompatibilit@`a con l'API.
Tipicamente, basta un controllo di questo tipo:
@example
if ( api->major_version != GAWK_API_MAJOR_VERSION
|| api->minor_version < GAWK_API_MINOR_VERSION) @{
fprintf(stderr, "estensione_pippo: discordanza di versione \
con gawk!\n");
fprintf(stderr, "\tLa mia versione (%d, %d), versione gawk \
(%d, %d)\n",
GAWK_API_MAJOR_VERSION, GAWK_API_MINOR_VERSION,
api->major_version, api->minor_version);
exit(1);
@}
@end example
Questo codice @`e incluso nella macro generica @code{dl_load_func()}
presente in @file{gawkapi.h} (trattata
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Codice predefinito di un'estensione API}).
@node Versione estensione GMP/MPFR
@subsubsection Informazioni sulla versione disponibile di GMP ed MPFR
L'API include anche informazioni sulle versioni di GMP ed MPFR con cui
il comando @command{gawk} in esecuzione @`e stato compilato (se disponibile).
Queste sono incluse nella struttura @code{struct} dell'API come costanti intere
in sola lettura:
@table @code
@item api->gmp_major_version
La versione principale della libreria GMP usata per compilare @command{gawk}.
@item api->gmp_minor_version
La versione secondaria della libreria GMP usata per compilare @command{gawk}.
@item api->mpfr_major_version
La versione principale della libreria MPFR usata per compilare @command{gawk}.
@item api->mpfr_minor_version
La versione secondaria della libreria MPFR usata per compilare @command{gawk}.
@end table
Questi campi hanno un valore di zero se @command{gawk} @`e stato compilato
senza supporto MPFR.
Si pu@`o controllare se le versioni di MPFR e GMP dell'utente corrispondono
a quelle contenute in @command{gawk} con le seguenti macro:
@table @code
@item check_mpfr_version(extension)
La @code{extension} @`e l'ID dell'estensione, passato a tutte le altre macro
e funzioni definite in @file{gawkapi.h}. Se il file di intestazione
@code{} non @`e stato incluso, questa macro verr@`a definita in
modo da non fare nulla.
Se invece il predetto file @`e stato incluso, questa macro confronta
le versioni principale e secondaria di MPFR e GMP con quelle delle
librerie in uso da parte dell'utente. Se queste ultime sono pi@`u
recenti di quelle di @command{gawk}, stampa un messaggio di
errore fatale ed esce.
La macro @code{dl_load_func()} (trattata
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Codice predefinito di un'estensione API})
chiama @code{check_mpfr_version()}.
@end table
@node Variabili informative di estens. API
@subsubsection Variabili informative
@cindex API (estensione) @subentry variabili informative
@cindex variabili @subentry informative dell'API
@cindex estensione API @subentry variabili informative
L'API fornisce accesso a parecchie variabili che descrivono
se le opzioni della riga di comando corrispondenti sono state specificate
quando @command{gawk} @`e stato chiamato. Le variabili sono:
@table @code
@item do_debug
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--debug}.
@item do_lint
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--lint}.
@item do_mpfr
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--bignum}.
@item do_profile
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--profile}.
@item do_sandbox
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--sandbox}.
@item do_traditional
Questa variabile @`e @dfn{true} se @command{gawk} @`e stato invocato con l'opzione @option{--traditional}.
@end table
Il valore di @code{do_lint} pu@`o cambiare se il codice @command{awk}
modifica la variabile predefinita @code{LINT} (@pxref{Variabili predefinite}).
Gli altri valori non dovrebbero cambiare durante l'esecuzione.
@node Codice predefinito di un'estensione API
@subsection Codice predefinito di interfaccia API
Come gi@`a detto (@pxref{Panoramica sul meccanismo delle estensioni}),
le definizioni di funzioni qui presentate sono in realt@`a delle macro.
Per usare queste macro, l'estensione deve fornire una piccola quantit@`a di
codice predefinito (variabili e
funzioni) nella parte iniziale del file sorgente, usando dei nomi
standard, come descritto qui sotto. Il codice predefinito in questione @`e
anche descritto nel file di intestazione @file{gawkapi.h}:
@example
@group
/* Codice predefinito: */
int plugin_is_GPL_compatible;
static gawk_api_t *const api;
@end group
static awk_ext_id_t ext_id;
static const char *ext_version = NULL; /* o @dots{} = "qualche stringa" */
static awk_ext_func_t func_table[] = @{
@{ "name", do_name, 1, 0, awk_false, NULL @},
/* @dots{} */
@};
/* O: */
static awk_bool_t (*init_func)(void) = NULL;
/* OPPURE: */
static awk_bool_t
init_mia_estensione(void)
@{
@dots{}
@}
static awk_bool_t (*init_func)(void) = init_mia_estensione;
dl_load_func(func_table, qualche_nome, "name_space_in_quotes")
@end example
Queste variabili e funzioni sono:
@table @code
@item int plugin_is_GPL_compatible;
Qui si dichiara che l'estensione @`e compatibile con
@ifclear FOR_PRINT
la licenza GNU GPL (@pxref{Copia}).
@end ifclear
@ifset FOR_PRINT
la licenza GNU GPL.
@end ifset
Se l'estensione non ha questa variabile, non verr@`a caricata da @command{gawk}
(@pxref{Licenza delle estensioni}).
@item static gawk_api_t *const api;
Questa variabile globale @code{static} dovrebbe essere impostata per
puntare al puntatore
@code{gawk_api_t} che @command{gawk} passa alla funzione (dell'estensione)
@code{dl_load()}. Questa variabile @`e usata da tutte le macro.
@item static awk_ext_id_t ext_id;
Questa variabile globale @code{static} dovrebbe essere impostata al valore
@code{awk_ext_id_t} che @command{gawk} passa alla funzione @code{dl_load()}.
Questa variabile @`e usata da tutte le macro.
@item static const char *ext_version = NULL; /* o @dots{} = "qualche stringa" */
Questa variabile globale @code{static} dovrebbe essere impostata
a @code{NULL} oppure puntare a una stringa che contiene il nome e la
versione dell'estensione.
@item static awk_ext_func_t func_table[] = @{ @dots{} @};
Questo @`e un vettore di una o pi@`u strutture @code{awk_ext_func_t},
come descritto in precedenza (@pxref{Funzioni di estensione}).
Pu@`o essere usato in seguito per pi@`u chiamate a
@code{add_ext_func()}.
@c Use @var{OR} for docbook
@item static awk_bool_t (*init_func)(void) = NULL;
@itemx @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @var{OR}
@itemx static awk_bool_t init_mia_estensione(void) @{ @dots{} @}
@itemx static awk_bool_t (*init_func)(void) = init_mia_estensione;
Se qualche lavoro di inizializzazione @`e necessario, si dovrebbe definire una
funzione all'uopo (crea variabili, apre file, etc.)
e poi definire il puntatore @code{init_func} che punti alla funzione
stessa.
La funzione dovrebbe restituire @code{awk_@dfn{false}} se non va a buon fine
o @code{awktrue} se tutto va bene.
Se un'inizializzazione non @`e necessaria, si definisca il puntatore e
lo si inizializzi a @code{NULL}.
@item dl_load_func(func_table, qualche_nome, "nome_spazio_tra_doppi_apici")
Questa macro genera una funzione @code{dl_load()} che far@`a
tutte le inizializzazioni necessarie.
@end table
Lo scopo di tutte le variabili e dei vettori @`e di far s@`{@dotless{i}} che la
funzione @code{dl_load()} (richiamata dalla macro @code{dl_load_func()})
faccia tutto il lavoro standard necessario, qui descritto:
@enumerate 1
@item
Controlla le versioni dell'API. Se la versione principale dell'estensione
non corrisponde a quella di @command{gawk} o se la versione secondaria
dell'estensione @`e maggiore di quella di @command{gawk}, stampa un messaggio
di errore fatale ed esce.
@item
Controlla le versioni di MPFR e GMP. Se non sono allo stesso livello con
quelle in uso localmente, stampa un messaggio
di errore fatale ed esce.
@item
Carica le funzioni definite in @code{func_table}.
Se qualche caricamento non riesce, stampa un messaggio di
avvertimento ma continua l'esecuzione.
@item
Se il puntatore @code{init_func} non @`e @code{NULL}, chiama la
funzione da esso puntata. Se questa restituisce @code{awk_false}, stampa un
messaggio di avvertimento.
@item
Se @code{ext_version} non @`e @code{NULL}, registra la
stringa di versione con @command{gawk}.
@end enumerate
@node Modifiche dalla versione API 1
@subsection Modifiche dalla versione 1 dell'API
La versione API corrente @emph{non} @`e compatibile a livello binario con la
versione 1 dell'API.
Le funzioni di estensione vanno ricompilate per poterle usare con la versione
corrente di @command{gawk}.
Fortunatamente, fatti salvi alcuni possibili avvertimenti a livello di
compilazione, l'API rimane compatibile a livello di codice sorgente con la
precedente versione API. Le differenze pi@`u rilevanti sono gli ulteriori
campi nella struttura @code{awk_ext_func_t}, e l'aggiunta del terzo argomento
nella funzione di implementazione in linguaggio C.
(@pxref{Funzioni di estensione}).
Quella che segue @`e una lista di singole funzionalit@`a che sono
state modificate nella versione 2 rispetto alla versione 1 dell'API:
@itemize @bullet
@item
I valori numerici possono ora essere anche di tipo MPFR/MPZ
(@pxref{Tipi di dati generali}).
@item
Ci sono nuovi tipi di stringa: @code{AWK_REGEX} e @code{AWK_STRNUM}
(@pxref{Tipi di dati generali}).
@item
@`E disponibile la nuova macro @code{ezalloc()}
(@pxref{Funzioni di allocazione memoria}).
@item
La struttura @code{awk_ext_func_t} @`e stata modificata. Invece del
parametro @code{num_expected_args}, ha ora i due parametri
@code{max_expected} e @code{min_required}
(@pxref{Funzioni di estensione}).
@item
In @code{get_record()}, un analizzatore di input pu@`o ora specificare
l'ampiezza dei campi
(@pxref{Analizzatori di input}).
@item
Le estensioni possono ora inviare messaggi di errore non fatali
(@pxref{Stampare messaggi}).
@item
Quando di appiattisce un vettore, si pu@`o ora specificare il tipo
dell'indice e quello dei valori
(@pxref{Funzioni per i vettori}).
@item
C'@`e una nuova API, @code{get_file()}
(@pxref{Ridirezione API}).
@end itemize
@node Trovare le estensioni
@section Come @command{gawk} trova le estensioni compilate
@cindex estensioni @subentry percorso di ricerca per
@cindex estensioni @subentry come trovarle
@cindex trovare @subentry estensioni
@cindex percorso di ricerca @subentry per estensioni
Le estensioni compilate vanno installate in una directory dove
@command{gawk} possa trovarle. Se @command{gawk} @`e configurato e
installato nella maniera di default, la directory dove trovare le
estensioni @`e @file{/usr/local/lib/gawk}. Si pu@`o anche specificare un
percorso di ricerca contenente una lista di directory da esaminare per la
ricerca di estensioni compilate.
@xref{AWKLIBPATH (Variabile)} per ulteriori dettagli.
@node Esempio di estensione
@section Esempio: alcune funzioni per i file
@cindex estensione @subentry esempio
@cindex esempio @subentry di estensione
@quotation
@i{In qualunque posto vai, l@`a tu sei.}
@author Buckaroo Banzai
@end quotation
@c It's enough to show chdir and stat, no need for fts
Due utili funzioni che non sono in @command{awk} sono @code{chdir()} (per
permettere a un programma @command{awk} di cambiare directory di lavoro) e
@code{stat()}
(per far s@`{@dotless{i}} che un programma @command{awk} possa raccogliere informazioni
su un dato file).
Per illustrare l'azione dell'API, questa @value{SECTION} fornisce
queste funzioni a @command{gawk} in un'estensione.
@menu
* Descrizione interna file:: Quello che le nuove funzioni faranno
* Operazioni interne file:: Codice per gestire file all'interno
* Usare operazioni interne file:: Come usare un'estensione esterna
@end menu
@node Descrizione interna file
@subsection Usare @code{chdir()} e @code{stat()}
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} mostra come usare le nuove funzioni a
livello di @command{awk} una volta che siano state integrate nell'interprete
del programma @command{gawk} in esecuzione. Usare @code{chdir()} @`e molto
semplice. Richiede un solo argomento, la nuova directory su cui
posizionarsi:
@example
@@load "filefuncs"
@dots{}
newdir = "/home/arnold/funstuff"
ret = chdir(newdir)
if (ret < 0) @{
printf("non riesco a passare a %s: %s\n", newdir, ERRNO) > "/dev/stderr"
exit 1
@}
@dots{}
@end example
Il valore restituito @`e negativo se la chiamata a @code{chdir()} non @`e riuscita,
ed @code{ERRNO} (@pxref{Variabili predefinite}) @`e impostato a una stringa
che descrive l'errore.
Usare @code{stat()} @`e un po' pi@`u complicato. La funzione scritta in C
@code{stat()} riempie una struttura che ha una certa quantit@`a di informazioni.
La maniera corretta per immagazzinarle in @command{awk} @`e quella di riempire
un vettore associativo con le informazioni appropriate:
@c broke printf for page breaking
@example
file = "/home/arnold/.profile"
ret = stat(file, fdata)
if (ret < 0) @{
printf("non @`e stato possibile eseguire @command{stat} per %s: %s\n",
file, ERRNO) > "/dev/stderr"
exit 1
@}
printf("dimensione di %s @`e %d byte\n", file, fdata["size"])
@end example
La funzione @code{stat()} svuota sempre il vettore che contiene i dati,
anche nel caso che la chiamata a @code{stat()} non riesca. I seguenti
elementi vengono restituiti dalla funzione:
@table @code
@item "name"
Il nome del file oggetto della chiamata a @code{stat()}.
@item "dev"
@itemx "ino"
I numeri di @dfn{device} e di @dfn{inode}, rispettivamente.
@item "mode"
Il modo del file, in formato numerico. Questo include sia il tipo di file che
i suoi permessi di accesso.
@item "nlink"
Il numero di collegamenti fisici del file (stesso file con diversi nomi).
@item "uid"
@itemx "gid"
Gli identificativi di utente e di gruppo del possessore del file.
@item "size"
La dimensione in byte del file.
@item "blocks"
Il numero di blocchi su disco realmente occupati dal file. Questo pu@`o non
essere
proporzionale alla dimensione del file se il file ha delle lacune
[ossia se solo alcune parti del file esistono veramente, il resto
non @`e ancora stato riempito].
@item "atime"
@itemx "mtime"
@itemx "ctime"
La data e ora dell'ultimo accesso, modifica, e aggiornamento dell'@dfn{inode},
rispettivamente. Questi sono delle marcature temporali numeriche
(misurate in secondi dal
01 gennaio 1970), che possono essere formattate dalla funzione
@code{strftime()}
(@pxref{Funzioni di tempo}).
@item "pmode"
La modalit@`a stampabile (``printable mode'') del file.
Questo @`e una stringa che rappresenta
il tipo del file e i permessi di accesso, come sono visualizzati da
@samp{ls -l}---per esempio, @code{"drwxr-xr-x"}.
@item "type"
Una stringa stampabile che descrive il tipo di file. Il valore @`e uno dei
seguenti:
@table @code
@item "blockdev"
@itemx "chardev"
Il file @`e un dispositico a blocchi o a caratteri (``file speciale'').
@ignore
@item "door"
The file is a Solaris ``door'' (special file used for
interprocess communications).
@end ignore
@item "directory"
Il file @`e una directory.
@item "fifo"
Il file @`e una @dfn{pipe} denominata (nota anche come FIFO [First In First
Out]).
@item "file"
Il file @`e un file normale.
@item "@dfn{socket}"
Il file @`e un @dfn{socket} @code{AF_UNIX} (``Unix domain'') nel
filesystem.
@item "symlink"
Il file @`e un collegamento simbolico.
@end table
@c 5/2013: Thanks to Corinna Vinschen for this information.
@item "devbsize"
La dimensione di un blocco per l'elemento indicizzato da @code{"blocks"}.
Questa informazione @`e derivata dalla costante @code{DEV_BSIZE}
definita in @code{} nella maggior parte dei sistemi,
o dalla costante @code{S_BLKSIZE} in @code{} nei sistemi BSD.
Per alcuni altri sistemi il valore si basa su una conoscenza @dfn{a priori}
delle caratteristiche di un particolare sistema.
Se non si riesce a determinare il valore, viene
restituito quello di default, che @`e 512.
@end table
Possono essere presenti diversi altri elementi, a seconda del
sistema operativo e del tipo di file.
Si pu@`o controllarne la presenza dal programma @command{awk} per mezzo
dell'operatore @code{in}
(@pxref{Visitare elementi}):
@table @code
@item "blksize"
La dimensione preferita di un blocco per effettuare operazioni di I/O sul file.
Questo campo non @`e presente nella struttura C @code{stat} di tutti i sistemi
che rispettano lo standard POSIX.
@item "linkval"
Se il file @`e un collegamento simbolico, questo elemento @`e il nome del
file puntato dal collegamento simbolico (cio@`e, il valore del collegamento).
@item "rdev"
@itemx "major"
@itemx "minor"
Se il file @`e un dispositivo a blocchi o a caratteri, questi valori
rappresentano il numero del dispositivo e, rispettivamente, le componenti
principale e secondaria di quel numero.
@end table
@node Operazioni interne file
@subsection Codice C per eseguire @code{chdir()} e @code{stat()}
Questo @`e il codice C per queste estensioni.@footnote{La versione qui
presentata @`e
lievemente modificata per amor di semplicit@`a. Si veda @file{extension/filefuncs.c}
nella distribuzione @command{gawk} per la versione completa.}
Il file include alcuni file di intestazione standard, e poi il file di
intestazione @file{gawkapi.h}, che fornisce le definizioni dell'API.
A queste seguono le dichiarazioni di variabili, necessarie
per usare le macro dell'API e il codice predefinito
(@pxref{Codice predefinito di un'estensione API}):
@example
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include "gawkapi.h"
#include "gettext.h"
#define _(msgid) gettext(msgid)
#define N_(msgid) msgid
#include "gawkfts.h"
#include "stack.h"
static const gawk_api_t *api; /* per consentire il funzionamento
delle macro di utilit@`a */
static awk_ext_id_t ext_id;
static awk_bool_t init_filefuncs(void);
static awk_bool_t (*init_func)(void) = init_filefuncs;
static const char *ext_version = "filefuncs extension: version 1.0";
int plugin_is_GPL_compatible;
@end example
@cindex programmazione @subentry convenzioni di @subentry estensioni @command{gawk}
@cindex estensioni @subentry @command{gawk}, convenzioni di programmazione
Per convenzione, per una funzione @command{awk} di nome @code{pippo()},
la funzione C che la implementa @`e chiamata @code{do_pippo()}. La funzione
dovrebbe avere due argomenti. Il primo @`e un numero @code{int}, chiamato
@code{nargs}, che rappresenta il numero di argomenti passato alla funzione.
Il secondo @`e un puntatore a una struttura @code{awk_value_t}, normalmente
chiamata @code{risultato}:
@example
@group
/* do_chdir --- fornisce funzione chdir()
caricata dinamicamente per gawk */
static awk_value_t *
do_chdir(int nargs, awk_value_t *risultato, struct awk_ext_func *non_usata)
@end group
@{
awk_value_t newdir;
int ret = -1;
assert(risultato != NULL);
@end example
La variabile @code{newdir}
rappresenta la nuova directory nella quale cambiare, che @`e ottenuta
tramite la funzione @code{get_argument()}. Si noti che il primo argomento @`e
quello numero zero.
Se l'argomento @`e stato trovato con successo, la funzione invoca la chiamata di
sistema @code{chdir()}. In caso contrario, se la @code{chdir()} non riesce,
viene aggiornata la variabile @code{ERRNO}:
@example
if (get_argument(0, AWK_STRING, & newdir)) @{
ret = chdir(newdir.str_value.str);
if (ret < 0)
update_ERRNO_int(errno);
@}
@end example
Infine, la funzione restituisce il codice di ritorno da @code{chdir} a
livello di @command{awk}:
@example
return make_number(ret, risultato);
@}
@end example
L'estensione @code{stat()} @`e pi@`u impegnativa. Dapprima abbiamo
una funzione che trasforma la stringa di autorizzazione numerica
(@dfn{mode}) in una rappresentazione stampabile
(p.es., il codice ottale @code{0644} diviene @samp{-rw-r--r--}). Questa
parte @`e qui omessa per brevit@`a.
@example
/* format_mode --- trasforma il campo @dfn{mode} di @dfn{stat}
in qualcosa di leggibile */
static char *
format_mode(unsigned long fmode)
@{
@dots{}
@}
@end example
Viene poi una funzione per leggere dei collegamenti simbolici, anche questa
omessa per brevit@`a:
@example
/* read_symlink --- legge un collegamento simbolico in un buffer
allocato.
@dots{} */
static char *
read_symlink(const char *fname, size_t bufsize, ssize_t *linksize)
@{
@dots{}
@}
@end example
Due funzioni ausiliarie semplificano l'immissione di valori nel
vettore che conterr@`a il risultato della chiamata a @code{stat()}:
@example
/* array_set --- imposta un elemento di un vettore */
static void
array_set(awk_array_t vettore, const char *sub, awk_value_t *valore)
@{
awk_value_t index;
set_array_element(vettore,
make_const_string(sub, strlen(sub), & index),
valore);
@}
/* array_set_numeric --- imposta un elemento di un vettore con un
numero */
static void
array_set_numeric(awk_array_t vettore, const char *sub, double num)
@{
awk_value_t tmp;
array_set(vettore, sub, make_number(num, & tmp));
@}
@end example
La seguente funzione fa il grosso del lavoro per riempire il vettore dei
risultati @code{awk_array_t} con valori ottenuti
da una @code{struct stat} valida. Questo lavoro @`e fatto in una funzione
separata per supportare sia la funzione
@code{stat()} per @command{gawk}, che l'estensione @code{fts()},
che @`e inclusa nello stesso file, ma non
@`e mostrata qui
(@pxref{Esempio di estensione funzioni file}).
La prima parte della funzione @`e la dichiarazione delle variabili,
compresa una tabella per tradurre i tipi di file in stringhe:
@example
/* fill_stat_array --- fa il lavoro di riempire un
vettore con informazioni da stat */
static int
fill_stat_array(const char *nome, awk_array_t vettore, struct stat *sbuf)
@{
char *pmode; /* @dfn{mode} stampabile */
const char *type = "unknown";
awk_value_t tmp;
static struct ftype_map @{
unsigned int mask;
const char *type;
@} ftype_map[] = @{
@{ S_IFREG, "file" @},
@{ S_IFBLK, "blockdev" @},
@{ S_IFCHR, "chardev" @},
@{ S_IFDIR, "directory" @},
#ifdef S_IFSOCK
@{ S_IFSOCK, "socket" @},
#endif
#ifdef S_IFIFO
@{ S_IFIFO, "fifo" @},
#endif
#ifdef S_IFLNK
@{ S_IFLNK, "symlink" @},
#endif
#ifdef S_IFDOOR /* Stranezza Solaris */
@{ S_IFDOOR, "door" @},
#endif
@};
int j, k;
@end example
Il vettore di destinazione @`e svuotato di elementi, e poi il codice riempie
i vari elementi prendendoli dai valori presenti in @code{struct stat}:
@example
/* svuota il vettore */
clear_array(vettore);
/* riempie il vettore */
array_set(vettore, "name", make_const_string(nome, strlen(nome),
& tmp));
array_set_numeric(vettore, "dev", sbuf->st_dev);
array_set_numeric(vettore, "ino", sbuf->st_ino);
array_set_numeric(vettore, "mode", sbuf->st_mode);
array_set_numeric(vettore, "nlink", sbuf->st_nlink);
array_set_numeric(vettore, "uid", sbuf->st_uid);
array_set_numeric(vettore, "gid", sbuf->st_gid);
array_set_numeric(vettore, "size", sbuf->st_size);
array_set_numeric(vettore, "blocks", sbuf->st_blocks);
array_set_numeric(vettore, "atime", sbuf->st_atime);
array_set_numeric(vettore, "mtime", sbuf->st_mtime);
array_set_numeric(vettore, "ctime", sbuf->st_ctime);
/* per dispositivi a blocchi o carattere, aggiunge rdev,
e il numero principale e secondario */
if (S_ISBLK(sbuf->st_mode) || S_ISCHR(sbuf->st_mode)) @{
array_set_numeric(vettore, "rdev", sbuf->st_rdev);
array_set_numeric(vettore, "major", major(sbuf->st_rdev));
array_set_numeric(vettore, "minor", minor(sbuf->st_rdev));
@}
@end example
@noindent
L'ultima parte della funzione fa alcune aggiunte selettive
al vettore di destinazione, a seconda che siano disponibili o no
certi campi e/o il tipo del file. Viene poi restituito zero, per indicare che
tutto @`e andato bene:
@example
@group
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
array_set_numeric(vettore, "blksize", sbuf->st_blksize);
#endif
@end group
pmode = format_mode(sbuf->st_mode);
array_set(vettore, "pmode", make_const_string(pmode, strlen(pmode),
& tmp));
/* per collegamenti simbolici, si aggiunge un campo linkval */
if (S_ISLNK(sbuf->st_mode)) @{
char *buf;
ssize_t linksize;
if ((buf = read_symlink(nome, sbuf->st_size,
& linksize)) != NULL)
array_set(vettore, "linkval",
make_malloced_string(buf, linksize, & tmp));
else
warning(ext_id, _("stat: non riesco a leggere il \
collegamento simbolico `%s'"),
nome);
@}
/* aggiunge il tipo di campo */
type = "unknown"; /* non dovrebbe succedere */
for (j = 0, k = sizeof(ftype_map)/sizeof(ftype_map[0]); j < k; j++) @{
if ((sbuf->st_mode & S_IFMT) == ftype_map[j].mask) @{
type = ftype_map[j].type;
break;
@}
@}
array_set(vettore, "type", make_const_string(type, strlen(type), & tmp));
return 0;
@}
@end example
Del terzo argomento passato a @code{stat()} non si era ancora parlato.
Questo argomento @`e opzionale. Se presente, dice a @code{do_stat()} di
usare la chiamata di sistema @code{stat()} invece della chiamata di sistema
@code{lstat()}. Questo avviene attraverso un puntatore a funzione:
@code{statfunc}.
@code{statfunc} @`e inizializzato per puntare a @code{lstat()} (invece che a
@code{stat()}) per ottenere le informazioni relative al file, nel caso che
il file in questione sia un
collegamento simbolico. Tuttavia, se il terzo argomento @`e specificato,
@code{statfunc} viene modificato in modo da puntare a @code{stat()}.
Ecco la funzione @code{do_stat()}, che inizia con la dichiarazione delle
variabili e un controllo degli argomenti passati dal chiamante:
@example
/* do_stat --- fornisce una funzione stat() per gawk */
static awk_value_t *
do_stat(int nargs, awk_value_t *risultato, struct awk_ext_func *non_usata)
@{
awk_value_t file_param, array_param;
char *nome;
awk_array_t vettore;
int ret;
struct stat sbuf;
/* per default si usa lstat() */
int (*statfunc)(const char *path, struct stat *sbuf) = lstat;
assert(risultato != NULL);
@end example
A questo punto inizia l'elaborazione vera e propria. Per prima cosa, la
funzione esamina gli argomenti.
Poi, ottiene le informazioni relative al file. Se la funzione chiamata
(@code{lstat()} o @code{stat()}) restituisce un errore, il codice imposta
@code{ERRNO} e torna al chiamante:
@example
/* file @`e il primo argomento,
il vettore per contenere i risultati @`e il secondo */
if ( ! get_argument(0, AWK_STRING, & file_param)
|| ! get_argument(1, AWK_ARRAY, & array_param)) @{
warning(ext_id, _("stat: parametri errati"));
return make_number(-1, risultato);
@}
if (nargs == 3) @{
statfunc = stat;
@}
nome = file_param.str_value.str;
vettore = array_param.array_cookie;
/* svuota sempre il vettore all'inizio */
clear_array(vettore);
/* chiama stat per il file;
in caso di errore,
imposta ERRNO e ritorna */
ret = statfunc(nome, & sbuf);
@group
if (ret < 0) @{
update_ERRNO_int(errno);
return make_number(ret, risultato);
@}
@end group
@end example
Il lavoro noioso @`e svolto da @code{fill_stat_array()}, visto in
precedenza. Alla fine, la funzione restituisce il codice di ritorno
impostato da @code{fill_stat_array()}:
@example
@group
ret = fill_stat_array(nome, vettore, & sbuf);
return make_number(ret, risultato);
@}
@end group
@end example
Infine, @`e necessario fornire la ``colla'' che aggrega
le nuove funzioni a @command{gawk}.
L'estensione @code{filefuncs} comprende anche una funzione
@code{fts()}, qui omessa
(@pxref{Esempio di estensione funzioni file}).
@`E anche prevista una funzione di
inizializzazione:
@example
/* init_filefuncs --- routine di initializazione */
static awk_bool_t
init_filefuncs(void)
@{
@dots{}
@}
@end example
Siamo quasi alla fine. Serve un vettore di strutture @code{awk_ext_func_t}
per caricare ogni funzione in @command{gawk}:
@example
static awk_ext_func_t func_table[] = @{
@{ "chdir", do_chdir, 1, 1, awk_false, NULL @},
@{ "stat", do_stat, 3, 2, awk_false, NULL @},
@dots{}
@};
@end example
Ogni estensione deve avere una routine di nome @code{dl_load()} per caricare
tutto ci@`o che occorre caricare. La cosa pi@`u semplice @`e di usare la macro
@code{dl_load_func()} in @code{gawkapi.h}:
@example
/* definizione della funzione dl_load()
usando la macro standard */
dl_load_func(func_table, filefuncs, "")
@end example
Abbiamo finito!
@node Usare operazioni interne file
@subsection Integrare le estensioni
@cindex @command{gawk} @subentry aggiungere funzionalit@`a a
@cindex funzionalit@`a @subentry aggiungere a @command{gawk}
@cindex aggiungere @subentry funzionalit@`a a @command{gawk}
Dopo aver scritto il codice, dev'essere possibile aggiungerlo in fase
di esecuzione all'interprete @command{gawk}. Per prima cosa, il codice
va compilato. Supponendo che le funzioni siano in
un file di nome @file{filefuncs.c}, e che @var{idir} sia la posizione
del file di intestazione @file{gawkapi.h},
i seguenti passi@footnote{In pratica, si potrebbe decidere di usare
i comandi GNU Autotools (Automake, Autoconf, Libtool, e @command{gettext})
per configurare e costruire le librerie necessarie. L'esposizione di come
ci@`o pu@`o essere fatto esula dal tema di questo @value{DOCUMENT}.
@xref{gawkextlib} per i puntatori a siti Internet che permettono di accedere
a questi strumenti.} creano una libreria condivisa GNU/Linux:
@example
$ @kbd{gcc -fPIC -shared -DHAVE_CONFIG_H -c -O -g -I@var{idir} filefuncs.c}
$ @kbd{gcc -o filefuncs.so -shared filefuncs.o}
@end example
Una volta creata la libreria, questa viene caricata usando la parola
chiave @code{@@load}:
@example
# file testff.awk
@@load "filefuncs"
BEGIN @{
"pwd" | getline curdir # salva la directory corrente
close("pwd")
chdir("/tmp")
system("pwd") # verifica l'avvenuto cambio di directory
chdir(curdir) # torna indietro
print "Info per testff.awk"
ret = stat("testff.awk", data)
print "ret =", ret
for (i in data)
printf "data[\"%s\"] = %s\n", i, data[i]
print "testff.awk modified:",
strftime("%m %d %Y %H:%M:%S", data["mtime"])
print "\nInfo per JUNK"
ret = stat("JUNK", data)
print "ret =", ret
for (i in data)
printf "data[\"%s\"] = %s\n", i, data[i]
print "JUNK modified:", strftime("%m %d %Y %H:%M:%S", data["mtime"])
@}
@end example
La variabile d'ambiente @env{AWKLIBPATH} dice a
@command{gawk} dove @`e possibile trovare le estensioni (@pxref{Trovare le estensioni}).
La variabile viene impostata alla directory corrente, e quindi viene eseguito
il programma:
@example
$ @kbd{AWKLIBPATH=$PWD gawk -f testff.awk}
@print{} /tmp
@print{} Info per testff.awk
@print{} ret = 0
@print{} data["blksize"] = 4096
@print{} data["devbsize"] = 512
@print{} data["mtime"] = 1412004710
@print{} data["mode"] = 33204
@print{} data["type"] = file
@print{} data["dev"] = 2053
@print{} data["gid"] = 1000
@print{} data["ino"] = 10358899
@print{} data["ctime"] = 1412004710
@print{} data["blocks"] = 8
@print{} data["nlink"] = 1
@print{} data["name"] = testff.awk
@print{} data["atime"] = 1412004716
@print{} data["pmode"] = -rw-rw-r--
@print{} data["size"] = 666
@print{} data["uid"] = 1000
@print{} testff.awk modified: 09 29 2014 18:31:50
@print{}
@print{} Info per JUNK
@print{} ret = -1
@print{} JUNK modified: 01 01 1970 02:00:00
@end example
@node Esempi di estensione
@section Le estensioni di esempio incluse nella distribuzione @command{gawk}
@cindex estensioni @subentry distribuite con @command{gawk}
Questa @value{SECTION} fornisce una breve panoramica degli esempi di
estensione inclusi nella distribuzione di @command{gawk}. Alcune di esse
sono destinate per l'uso in produzione (p.es., le estensioni
@code{filefuncs}, @code{readdir}, e
@code{inplace}). Altre sono state scritte principalmente per mostrare come
si usa l'estensione API.
@menu
* Esempio di estensione funzioni file:: L'esempio che usa funzioni file.
* Esempio di estensione Fnmatch:: Un'interfaccia a @code{fnmatch()}.
* Esempio di estensione Fork:: Un'interfaccia a @code{fork()} e
altre funzioni di processo.
* Esempio di estensione Inplace:: Consentire modifica diretta dei file.
* Esempio di estensione Ord:: Conversioni a valore e a stringa di
caratteri.
* Esempio di estensione Readdir:: Un'interfaccia a @code{readdir()}.
* Esempio di estensione Revout:: Semplice post-processore per
invertire la stringa in output.
* Esempio di estensione Rev2way:: Processore bidirezionale per
invertire la stringa in output.
* Esempio di estensione Rwarray:: Serializzare il vettore in un
file.
* Esempio di estensione Readfile:: Leggere un intero file in una stringa.
* Esempio di estensione Time:: Un'interfaccia a @code{gettimeofday()}
e @code{sleep()}.
* Esempio di estensione API Test:: Test per l'API.
@end menu
@node Esempio di estensione funzioni file
@subsection Funzioni relative ai file
L'estensione @code{filefuncs} include tre funzioni diverse, come descritto sotto.
L'uso @`e il seguente:
@table @asis
@item @code{@@load "filefuncs"}
Questo @`e il modo per caricare l'estensione.
@cindex @code{chdir()} (estensione)
@cindex estensione @subentry @code{chdir()}
@item @code{risultato = chdir("/qualche/directory")}
La funzione @code{chdir()} invoca a sua volta la chiamata di sistema
@code{chdir()} per cambiare la directory corrente. Restituisce zero
se tutto va bene o un valore minore di zero in caso di errore.
In quest'ultimo caso, viene aggiornata la variabile @code{ERRNO}.
@cindex @code{stat()} (estensione)
@cindex estensione @subentry @code{stat()}
@item @code{risultato = stat("/qualche/percorso", statdata} [@code{, follow}]@code{)}
La funzione @code{stat()} invoca a sua volta la chiamata di sistema
@code{stat()}.
Restituisce zero se tutto va bene o un valore minore di zero in caso di
errore.
In quest'ultimo caso, viene aggiornata la variabile @code{ERRNO}.
Per default, viene usata la chiamata di sistema @code{lstat()}.
Tuttavia, se alla funzione viene passato un terzo argomento, questa invoca
invece @code{stat()}.
In tutti i casi, il vettore @code{statdata} viene preventivamente svuotato.
Quando la chiamata a @code{stat()} riesce, viene riempito il vettore
@code{statdata} con le informazioni ottenute dal fileystem, come segue:
@multitable @columnfractions .15 .50 .20
@headitem Indice @tab Campo in @code{struct stat} @tab Tipo file
@item @code{"name"} @tab Il @value{FN} @tab Tutti
@item @code{"dev"} @tab @code{st_dev} @tab Tutti
@item @code{"ino"} @tab @code{st_ino} @tab Tutti
@item @code{"mode"} @tab @code{st_mode} @tab Tutti
@item @code{"nlink"} @tab @code{st_nlink} @tab Tutti
@item @code{"uid"} @tab @code{st_uid} @tab Tutti
@item @code{"gid"} @tab @code{st_gid} @tab Tutti
@item @code{"size"} @tab @code{st_size} @tab Tutti
@item @code{"atime"} @tab @code{st_atime} @tab Tutti
@item @code{"mtime"} @tab @code{st_mtime} @tab Tutti
@item @code{"ctime"} @tab @code{st_ctime} @tab Tutti
@item @code{"rdev"} @tab @code{st_rdev} @tab Dispositivi
@item @code{"major"} @tab @code{st_major} @tab Dispositivi
@item @code{"minor"} @tab @code{st_minor} @tab Dispositivi
@item @code{"blksize"} @tab @code{st_blksize} @tab Tutti
@item @code{"pmode"} @tab Una versione leggibile del valore dell'autorizzazione,
come quello stampato dal comando
@command{ls} (per esempio, @code{"-rwxr-xr-x"}) @tab Tutti
@item @code{"linkval"} @tab Il valore del collegamento simbolico @tab
Collegamenti simbolici
@item @code{"type"} @tab Il tipo del file in formato stringa --- pu@`o essere
@code{"file"},
@code{"blockdev"},
@code{"chardev"},
@code{"directory"},
@code{"socket"},
@code{"fifo"},
@code{"symlink"},
@code{"door"}
o
@code{"unknown"}
(non tutti i sistemi supportano tutti i tipi file) @tab Tutti
@end multitable
@cindex @code{fts()} (estensione)
@cindex estensione @subentry @code{fts()}
@item @code{flags = or(FTS_PHYSICAL, ...)}
@itemx @code{risultato = fts(pathlist, flags, filedata)}
Percorre gli alberi di file elencati in @code{pathlist} e riempie il vettore
@code{filedata}, come descritto qui di seguito. @code{flags} @`e l'operazione
@dfn{OR} @dfn{bit} a @dfn{bit} di parecchi valori predefiniti, pure descritti
pi@`u sotto.
Restituisce zero in assenza di errori, in caso contrario restituisce @minus{}1.
@end table
La funzione @code{fts()} invoca a sua volta la routine di libreria C
@code{fts()} per percorrere gerarchie di file. Invece di restituire i dati
relativi ai file uno per volta in sequenza,
riempie un vettore multidimensionale con i dati di ogni file e directory
che risiedono nelle gerarchie richieste.
Gli argomenti sono i seguenti:
@table @code
@item pathlist
Un vettore di @value{FNS}. Sono usati i valori dei singoli elementi;
gli indici che puntano a tali valori vengono ignorati.
@item flags
Questo dovrebbe essere l'@dfn{OR} @dfn{bit} a @dfn{bit} di uno o pi@`u dei
seguenti valori dei flag costanti predefiniti.
Almeno uno dei due flag @code{FTS_LOGICAL}
o @code{FTS_PHYSICAL} dev'essere impostato; in caso contrario
@code{fts()} restituisce una segnalazione di errore e imposta @code{ERRNO}.
I flag sono:
@c nested table
@table @code
@item FTS_LOGICAL
Passa in rassegna i file in modo ``logico'', e quindi l'informazione restituita
per un collegamento simbolico @`e quella relativa al file puntato, e non al
collegamento simbolico stesso. Questo flag @`e mutuamente esclusivo con
@code{FTS_PHYSICAL}.
@item FTS_PHYSICAL
Passa in rassegna i file in modo ``fisico'', e quindi l'informazione restituita
per un collegamento simbolico @`e quella relativa al collegamento simbolico
stesso. Questo flag @`e mutuamente esclusivo con @code{FTS_LOGICAL}.
@item FTS_NOCHDIR
Per migliorare le prestazioni, la routine di libreria C @code{fts()}
cambia directory mentre percorre una gerarchia di file. Questo flag
disabilita quell'ottimizzazione.
@item FTS_COMFOLLOW
Si accede al file puntato da un collegamento simbolico esistente in @code{pathlist},
anche se @code{FTS_LOGICAL} non @`e stato impostato.
@item FTS_SEEDOT
Per default, la routine di libreria C @code{fts()} non restituisce
informazioni per i file
@file{"."} (punto) e @file{".."} (punto-punto). Quest'opzione richiede
l'informazione anche per @file{".."}. (L'estensione ritorna sempre
l'informazione per @file{"."}; maggiori dettagli pi@`u sotto.)
@item FTS_XDEV
Mentre si percorre un filesystem, non passare mai a un filesystem montato
diverso da quello in cui si opera.
@c Pu@`o succedere nel caso di collegamenti simbolici, che contengono un nome di file
@c che si trova da tutt'altra parte
@c lrwxrwxrwx 1 root root 6 ago 6 2015 /aca -> /d/aca
@c /d/aca:
@c /dev/sda6 115234344 15648380 93709280 15% /d
@c / (e il collegamento simbolico /aca)
@c /dev/sda1 37308224 13573368 21816644 39% /
@end table
@item filedata
Il vettore @code{filedata} contiene i risultati.
La funzione @code{fts()} lo svuota all'inizio. In seguito viene creato
un elemento in @code{filedata} per ogni elemento in @code{pathlist}.
L'indice @`e il nome della directory o del file specificato in @code{pathlist}.
L'elemento puntato da questo indice @`e a sua volta un vettore. Ci sono due
casi:
@c nested table
@table @emph
@item Il percorso @`e un file
In questo caso, il vettore contiene due o tre elementi:
@c doubly nested table
@table @code
@item "path"
Il percorso completo di questo file, a partire dalla directory radice (``root'')
indicata nel vettore @code{pathlist}.
@item "stat"
Questo elemento @`e esso stesso un vettore, contenente le stesse informazioni
fornite dalla funzione @code{stat()} vista in precedenza a proposito del suo
argomento
@code{statdata}. L'elemento pu@`o non essere presente se la chiamata
di sistema @code{stat()} per il file non @`e riuscita.
@item "error"
Se qualche tipo di errore si verifica durante l'elaborazione, il vettore
conterr@`a anche un elemento con chiave @code{"error"}, che @`e una stringa
che descrive l'errore.
@end table
@item Il percorso @`e una directory
In questo caso, nel vettore viene creato un elemento per ogni elemento
contenuto nella directory. Se un elemento della directory @`e un
file, l'azione del programma @`e la stessa descritta sopra per un file.
Se invece la directory contiene delle sottodirectory, l'elemento creato
nel vettore @`e (ricorsivamente) a sua volta un vettore che descrive la
sottodirectory. Se fra i flag @`e stato
specificato il flag @code{FTS_SEEDOT},
ci sar@`a anche un elemento di nome
@code{".."}. Questo elemento sar@`a un vettore contenente i dati restituiti
da un'invocazione di @code{stat()}.
Inoltre, ci sar@`a un elemento il cui indice @`e @code{"."}.
Questo elemento @`e un vettore contenente gli stessi due o tre elementi che
sono messi a disposizione per un file: @code{"path"}, @code{"stat"},
ed @code{"error"}.
@end table
@end table
La funzione @code{fts()} restituisce zero in assenza di errori.
in caso contrario, restituisce @minus{}1.
@quotation NOTA
L'estensione @code{fts()} non imita esattamente l'interfaccia fornita dalla
routine di libreria C @code{fts()}, ma sceglie di fornire un'interfaccia
basata sui vettori associativi, che @`e pi@`u adeguata per l'uso da parte di un
programma @command{awk}. Questo
implica la mancanza di una funzione di
confronto, poich@'e @command{gawk} gi@`a
prevede la possibilit@`a di mettere facilmente nell'ordine desiderato gli
elementi di un vettore.
Anche se un'interfaccia modellata su @code{fts_read()} avrebbe potuto essere
fornita, @`e sembrato pi@`u naturale mettere a disposizione un vettore
multidimensionale, che rappresenta la gerarchia dei file e le informazioni
relative a ognuno di essi.
@end quotation
Si veda il file @file{test/fts.awk} nella distribuzione di @command{gawk}
per un esempio di uso dell'estensione @code{fts()}.
@node Esempio di estensione Fnmatch
@subsection Un'interfaccia a @code{fnmatch()}
Quest'estensione fornisce un'interfaccia per utilizzare la funzione di
libreria C @code{fnmatch()}. Si usa cos@`{@dotless{i}}:
@table @code
@item @@load "fnmatch"
@`E questo il modo per caricare l'estensione.
@cindex @code{fnmatch()} (estensione)
@cindex estensione @subentry @code{fnmatch()}
@item risultato = fnmatch(pattern, stringa, flags)
Il valore restituito @`e zero se tutto va bene, oppure @code{FNM_NOMATCH}
se la funzione non ha trovato alcuna corrispondenza, o
un valore differente, diverso da zero, se si @`e verificato un errore.
@end table
Oltre a rendere disponibile la funzione @code{fnmatch()}, l'estensione
di @code{fnmatch} definisce una costante (@code{FNM_NOMATCH}), e un vettore
con dei valori di flag, di nome @code{FNM}.
Gli argomenti per @code{fnmatch()} sono:
@table @code
@item pattern
L'espressione regolare con cui confrontare @value{FN}
@item stringa
La stringa @value{FN}
@item flags
Pu@`o valere zero o essere l'@dfn{OR} @dfn{bit} a @dfn{bit} di uno o pi@`u flag
nel vettore @code{FNM}
@end table
I flag sono i seguenti:
@multitable @columnfractions .40 .60
@headitem Elemento del vettore @tab Flag corrispondente definito da @code{fnmatch()}
@item @code{FNM["CASEFOLD"]} @tab @code{FNM_CASEFOLD}
@item @code{FNM["FILE_NAME"]} @tab @code{FNM_FILE_NAME}
@item @code{FNM["LEADING_DIR"]} @tab @code{FNM_LEADING_DIR}
@item @code{FNM["NOESCAPE"]} @tab @code{FNM_NOESCAPE}
@item @code{FNM["PATHNAME"]} @tab @code{FNM_PATHNAME}
@item @code{FNM["PERIOD"]} @tab @code{FNM_PERIOD}
@end multitable
Ecco un esempio:
@example
@@load "fnmatch"
@dots{}
flags = or(FNM["PERIOD"], FNM["NOESCAPE"])
if (fnmatch("*.a", "pippo.c", flags) == FNM_NOMATCH)
print "nessuna corrispondenza"
@end example
@node Esempio di estensione Fork
@subsection Un'interfaccia a @code{fork()}, @code{wait()}, e @code{waitpid()}
L'estensione @code{fork} mette a disposizione tre funzioni, come segue:
@table @code
@item @@load "fork"
Questo @`e il modo per caricare l'estensione.
@cindex @code{fork()} (estensione)
@cindex estensione @subentry @code{fork()}
@item pid = fork()
Questa funzione crea un nuovo processo. Il valore restituito @`e zero nel
processo ``figlio'' e il numero che identifica il nuovo processo
(@dfn{pid}) nel processo ``padre'', o @minus{}1
in caso di errore. In quest'ultimo caso, @code{ERRNO} indica il problema.
Nel processo figlio, gli elementi @code{PROCINFO["pid"]} e
@code{PROCINFO["ppid"]} vengono aggiornati per riflettere i valori corretti.
@cindex @code{waitpid()} (estensione)
@cindex estensione @subentry @code{waitpid()}
@item ret = waitpid(pid)
Questa funzione ha un unico argomento numerico, l'identificativo del processo
di cui aspettare l'esito. Il codice di ritorno @`e quello restituito dalla
chiamata di sistema @code{waitpid()}.
@cindex @code{wait()} (estensione)
@cindex estensione @subentry @code{wait()}
@item ret = wait()
Questa funzione attende che il primo processo ``figlio'' termini.
Il valore restituito @`e quello della chiamata di sistema @code{wait()}.
@end table
Non c'@`e una funzione corrispondente alla chiamata di sistema @code{exec()}.
Ecco un esempio:
@example
@@load "fork"
@dots{}
if ((pid = fork()) == 0)
print "salve dal processo figlio"
else
print "salve dal processo padre"
@end example
@node Esempio di estensione Inplace
@subsection Consentire la modifica in loco dei file
@cindex @code{inplace} (estensione)
@cindex estensione @subentry @code{inplace()}
L'estensione @code{inplace} svolge un lavoro simile a quello
dell'opzione @option{-i} nel programma di utilit@`a GNU @command{sed},
che svolge delle funzioni di modifica ``al volo'' su ogni file in input.
Viene usato il file @file{inplace.awk}, caricato dinamicamente, per richiamare
l'estensione in maniera corretta:
@example
@c file eg/lib/inplace.awk
@group
# inplace --- carica e richiama l'estensione inplace.
@c endfile
@ignore
@c file eg/lib/inplace.awk
#
# Copyright (C) 2013, 2017, 2019 the Free Software Foundation, Inc.
#
# This file is part of GAWK, the GNU implementation of the
# AWK Programming Language.
#
# GAWK is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# GAWK is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
# Andrew J. Schorr, aschorr@@telemetry-investments.com
# January 2013
#
# Revised for namespaces
# Arnold Robbins, arnold@@skeeve.com
# July 2017
# June 2019, add backwards compatibility
@c endfile
@end ignore
@c file eg/lib/inplace.awk
@@load "inplace"
# @`E buona cosa impostare inplace::suffix in modo da fare
# una copia di backup.
# Per esempio, si potrebbe impostare inplace::suffix a .bak
# sulla riga di comando, o in una regola BEGIN.
# Prima che fossero introdotti gli spazi di nomi in gawk, quest'estensione
# usava INPLACE_SUFFIX come variabile per fare delle copie di backup.
# Questo @`e ancora possibile, in modo che ogni codice che usava la
# precedente versione di questo @dfn{script} possa continuare a funzionare.
# Per default, ogni file specificato sulla riga di comando
# verr@`a modificato sovrascrivendo il file originale.
# Ma @`e possibile evitarlo specificando l'argomento inplace::enable=0
# davanti al nome del file che non si desidera elaborare in questo modo.
# Si pu@`o poi abilitare di nuovo l'aggiornamento diretto del file
# sulla riga di comando, specificando inplace::enable=1 prima dei file
# che si vogliono modificare direttamente.
# N.B. La funzione inplace::end() @`e invocata nelle regole
# BEGINFILE ed END, in modo che ogni eventuale azione
# in una regola ENDFILE sar@`a ridiretta come previsto.
@@namespace "inplace"
@end group
@group
BEGIN @{
enable = 1 # abilitato per default
@}
@end group
@group
BEGINFILE @{
sfx = (suffix ? suffix : awk::INPLACE_SUFFIX)
if (filename != "")
end(filename, sfx)
if (enable)
begin(filename = FILENAME, sfx)
else
filename = ""
@}
@end group
@group
END @{
if (filename != "")
end(filename, (suffix ? suffix : awk::INPLACE_SUFFIX))
@}
@end group
@c endfile
@end example
Per ogni file elaborato, l'estensione ridirige lo
standard output verso un file temporaneo definito in modo da avere lo stesso
proprietario e le stesse autorizzazioni del file originale. Dopo che il file
@`e stato elaborato, l'estensione riporta lo standard output alla sua
destinazione originale.
Se @code{INPLACE_SUFFIX} non @`e una stringa vuota, il file originale @`e
collegato a un @value{FN} di backup, creato aggiungendo il
suffisso al nome originale.
Infine, il file temporaneo @`e rinominato in modo da essere lo stesso del
@value{FN} originario.
Si noti che l'uso di questa funzionalit@`a pu@`o essere controllato
specificando @samp{inplace::enable=0} sulla riga di comando, prima del nome
del file che non dovrebbe essere elaborato come appena descritto.
Si pu@`o richiedere ancora l'aggiornamento diretto di un file, specificando
l'argomento @samp{inplace::enable=1} davanti al nome del file da elaborare
in maniera diretta.
La variabile @code{inplace::filename} serve per tener traccia del nome del
file corrente, in modo da non eseguire la funzione @code{inplace::end()} prima
di aver elaborato il primo file.
Se si verifica un errore, l'estensione emette un messaggio di errore fatale
per terminare l'elaborazione immediatamente, senza danneggiare il
file originale.
Ecco alcuni semplici esempi:
@example
$ @kbd{gawk -i inplace '@{ gsub(/pippo/, "pluto") @}; @{ print @}' file1 file2 file3}
@end example
Per mantenere una copia di backup del file originale, si provi a fare cos@`{@dotless{i}}:
@example
$ @kbd{gawk -i inplace -v INPLACE_SUFFIX=.bak '@{ gsub(/pippo/, "pluto") @}}
> @kbd{@{ print @}' file1 file2 file3}
@end example
Si noti che, anche se l'estensione tenta di mantenere il proprietario e i
permessi di accesso del file originario, non viene tentata la copia degli
ulteriori permessi di accesso
(@dfn{ACL - Access Control Lists}) del file originale.
Se il programma termina prima del previsto, come potrebbe succedere se riceve
dal sistema un segnale non gestito, pu@`o lasciare come residuo un file
temporaneo.
@node Esempio di estensione Ord
@subsection Caratteri e valori numerici: @code{ord()} e @code{chr()}
L'estensione @code{ordchr} aggiunge due funzioni, di nome
@code{ord()} e @code{chr()}, come segue:
@table @code
@item @@load "ordchr"
Questo @`e il modo per caricare l'estensione.
@cindex @code{ord()} (estensione)
@cindex estensione @subentry @code{ord()}
@item numero = ord(stringa)
Restituisce il valore numerico del primo carattere in @code{stringa}.
@cindex @code{Chr} (estensione)
@cindex estensione @subentry @code{chr()}
@item char = chr(number)
Restituisce una stringa il cui primo carattere @`e quello rappresentato
da @code{number}.
@end table
Queste funzioni sono ispirate alle funzioni del linguaggio Pascal
dallo stesso nome. Ecco un esempio:
@example
@@load "ordchr"
@dots{}
printf("Il valore numerico di 'A' @`e %d\n", ord("A"))
printf("Il valore come stringa di 65 @`e %s\n", chr(65))
@end example
@node Esempio di estensione Readdir
@subsection Leggere directory
L'estensione @code{readdir} aggiunge un analizzatore di input
per esaminare directory.
L'uso @`e il seguente:
@cindex @code{readdir} (estensione)
@cindex estensione @subentry @code{readdir()}
@example
@@load "readdir"
@end example
Quando quest'estensione @`e in uso, invece che saltare le
directory presenti sulla riga di comando, (o accedute tramite @code{getline}),
queste sono lette, e ogni elemento della directory @`e restituito come
un record.
Il record consiste di tre campi. I primi due sono il numero di @dfn{inode} e
il @value{FN}, separati fra loro da una barra.
Nei sistemi in cui l'elemento di directory contiene il tipo del file,
il record ha un terzo campo (pure separato da una barra), composto da una
sola lettera, che indica il tipo del file. Le lettere e i tipi di file a cui
corrispondono sono mostrate in @ref{table-readdir-file-types}.
@float Tabella,table-readdir-file-types
@caption{Tipi file restituiti dall'estensione @code{readdir}}
@multitable @columnfractions .1 .9
@headitem Lettera @tab Tipo di file
@item @code{b} @tab Dispositivo a blocchi
@item @code{c} @tab Dispositivo a caratteri
@item @code{d} @tab Directory
@item @code{f} @tab File normale
@item @code{l} @tab Collegamento simbolico
@item @code{p} @tab @dfn{pipe} con nome (FIFO)
@item @code{s} @tab @dfn{socket}
@item @code{u} @tab Tutto il resto (sconosciuto)
@end multitable
@end float
Nei sistemi che non contengono l'informazione sul tipo del file, il terzo
campo @`e sempre @samp{u}.
@quotation NOTA
Nei sistemi GNU/Linux, ci sono fileystem che non supportano il campo
@code{d_type} (si veda la pagina di manuale @i{readdir}(3)), e in questo caso
il tipo di file @`e sempre @samp{u}. Si pu@`o usare l'estensione
@code{filefuncs} per chiamare @code{stat()} e ottenere l'informazione
corretta sul tipo di file.
@end quotation
Per default, se non @`e possibile aprire una directory (p.es. per problemi
di autorizzazione), @command{gawk} termina l'esecuzione.
Come per i file normali, questa situazione pu@`o
essere gestita usando una regola @code{BEGINFILE} che controlli il
contenuto della variabile @code{ERRNO} e stampi un messaggio di
errore oppure gestisca il problema in qualche altro modo.
Ecco un esempio:
@example
@@load "readdir"
@dots{}
BEGIN @{ FS = "/" @}
@{ print "@value{FN} @`e", $2 @}
@end example
@node Esempio di estensione Revout
@subsection Invertire la stringa in output
L'estensione @code{revoutput} aggiunge un semplice processore
di output che inverte i caratteri di ogni riga in output. Serve a dimostrare
come @`e possibile scrivere un processore di output, anche se pu@`o essere
a prima vista vagamente divertente.
Ecco un esempio:
@cindex @code{revoutput} (estensione)
@cindex estensione @subentry @code{revoutput()}
@example
@@load "revoutput"
BEGIN @{
REVOUT = 1
print "non v'allarmate" > "/dev/stdout"
@}
@end example
L'output di questo programma @`e @samp{etamralla'v non}.
@node Esempio di estensione Rev2way
@subsection Esempio di I/O bidirezionale
L'estensione @code{revtwoway} aggiunge un semplice processore
bidirezionale che inverte i caratteri di ogni riga che riceve, per farla
poi rileggere dal programma @command{awk}. Il motivo per cui @`e stata scritta
@`e quello di mostrare come si scrive un processore bidirezionale, anche se pu@`o
sembrare un programma vagamente divertente.
Il seguente esempio mostra come usarlo:
@cindex @code{revtwoway} (estensione)
@cindex estensione @subentry @code{revtwoway()}
@example
@@load "revtwoway"
BEGIN @{
cmd = "/specchio/magico"
print "non v'allarmate" |& cmd
cmd |& getline risultato
print risultato
close(cmd)
@}
@end example
L'output di questo programma
@ifnotinfo
anche in questo caso @`e:
@end ifnotinfo
@ifinfo
@`e:
@end ifinfo
@samp{etamralla'v non}.
@node Esempio di estensione Rwarray
@subsection Scaricare e ricaricare un vettore
L'estensione @code{rwarray} aggiunge due funzioni,
di nome @code{writea()} e @code{reada()}, come segue:
@table @code
@item @@load "rwarray"
Questo @`e il modo per caricare l'estensione.
@cindex @code{writea()} (estensione)
@cindex estensione @subentry @code{writea()}
@item ret = writea(file, vettore)
Questa funzione ha come argomento una stringa, che @`e il nome del file
sul quale scaricare il vettore, e il vettore stesso @`e il secondo argomento.
@code{writea()} @`e in grado di gestire vettori di vettori. Restituisce il
valore uno se completa il lavoro o zero se non va a buon fine.
@cindex @code{reada()} (estensione)
@cindex estensione @subentry @code{reada()}
@item ret = reada(file, vettore)
@code{reada()} @`e la funzione inversa di @code{writea()};
legge il file il cui nome @`e fornito come primo argomento, riempiendo il
vettore il cui nome @`e il secondo argomento. Il vettore viene preventivamente
svuotato.
Anche in questo caso, il valore restituito @`e uno se tutto va bene o zero se
la funzione non va a buon fine.
@end table
Il vettore creato da @code{reada()} @`e identico a quello scritto da
@code{writea()} nel senso che i contenuti sono gli stessi. Tuttavia,
per come @`e strutturata la funzione, l'ordine di attraversamento del vettore
ricreato @`e quasi certamente differente da quello del vettore originale.
Poich@'e l'ordine di attraversamento di un vettore @`e, per default, indefinito
in @command{awk}, questo non @`e (tecnicamente) un problema. Se serve che
l'attraversamento del vettore avvenga in un ordine preciso, si possono usare
le funzionalit@`a di ordinamento di un vettore disponibili in @command{gawk}
(@pxref{Ordinamento di vettori}).
Il file contiene dati in formato binario. Tutti i valori interi sono scritti
in @dfn{network byte order}@footnote{Cio@`e, nella maniera con cui sarebbero
normalmente scritti in un testo, con le cifre pi@`u significative del
numero contenute nella parte sinistra, e quelle meno significative
nella parte destra della rappresentazione binaria del numero.}.
Tuttavia, i valori in virgola mobile a doppia precisione sono scritti come
dati binari nativi. Quindi, vettori che contengono solo dati in formato
stringa possono essere scaricati da un sistema con un certo ordine di byte
e ripristinati su un sistema con un ordine di byte differente, anche se
un test al riguardo non @`e mai stato fatto.
Ecco un esempio:
@example
@@load "rwarray"
@dots{}
ret = writea("scaricato.bin", vettore)
@dots{}
ret = reada("scaricato.bin", vettore)
@end example
@node Esempio di estensione Readfile
@subsection Leggere un intero file in una stringa
L'estensione @code{readfile} aggiunge una sola funzione
di nome @code{readfile()}, e un analizzatore di input:
@table @code
@item @@load "readfile"
Questo @`e il modo per caricare l'estensione.
@cindex @code{readfile()} (estensione)
@cindex estensione @subentry @code{readfile()}
@item risultato = readfile("/qualche/percorso")
L'argomento @`e il nome del file da leggere. Il valore restituito @`e una
stringa contenente l'intero contenuto del file richiesto. In caso di errore,
la funzione restituisce la stringa vuota e imposta @code{ERRNO}.
@item BEGIN @{ PROCINFO["readfile"] = 1 @}
Inoltre, l'estensione aggiunge un analizzatore di input che @`e attivato se
l'elemento @code{PROCINFO["readfile"]} esiste.
Quando l'analizzatore @`e attivato, ogni file in input @`e restituito interamente
come @code{$0}.
La variabile @code{RT} @`e impostata alla stringa nulla.
@end table
Ecco un esempio:
@example
@@load "readfile"
@dots{}
contents = readfile("/percorso/del/file");
if (contents == "" && ERRNO != "") @{
print("problema in lettura file", ERRNO) > "/dev/stderr"
...
@}
@end example
@node Esempio di estensione Time
@subsection Funzioni dell'estensione time
@quotation ATTENZIONE
A partire da @command{gawk} @value{PVERSION} 5.1.0, quest'estensione @`e
da considerarsi obsoleta. @`E sostituita dall'estensione
@code{timex} in @code{gawkextlib} (@pxref{gawkextlib}).
Nella @value{PVERSION} 5.1, non viene emesso alcun messaggio di avviso
se si usa quest'estensione.
A partire dalla prossima versione principale, verr@`a emesso un messaggio
di avviso. Nella versione successiva a quella, quest'estensione sar@`a
rimossa dalla distribuzione.
@end quotation
L'estensione @code{time} aggiunge due funzioni, di nome
@code{gettimeofday()} e @code{sleep()}, come segue:
@table @code
@item @@load "time"
Questo @`e il modo per caricare l'estensione.
@cindex @code{gettimeofday()} (estensione)
@cindex estensione @subentry @code{gettimeofday()}
@item ora_corrente = gettimeofday()
Restituisce il numero di secondi trascorsi dalle ore 00:00 del giorno
01/01/1970 UTC come valore in virgola mobile.
Se questa informazione non @`e disponibile nella piattaforma in uso,
restituisce @minus{}1 e imposta @code{ERRNO}. Il valore fornito dovrebbe
avere la precisione di una frazione di
secondo, ma la precisione effettiva pu@`o variare a seconda della
piattaforma.
Se la chiamata di sistema standard C @code{gettimeofday()} @`e disponibile
nella piattaforma in uso, questo @`e il valore restituito. In caso contrario,
se si sta lavorando con MS-Windows, la chiamata di sistema @`e fatta a
@code{GetSystemTimeAsFileTime()}.
@cindex @code{sleep()} (estensione)
@cindex estensione @subentry @code{sleep()}
@item risultato = sleep(@var{secondi})
Il programma @command{gawk} resta inattivo (dorme) per i @var{secondi}
specificati. Se @var{secondi} ha un valore negativo,
o la chiamata di sistema non riesce, restituisce @minus{}1 e imposta @code{ERRNO}.
In caso contrario, restituisce zero dopo aver lasciato trascorrere
la quantit@`a di tempo indicata.
Si noti che @var{secondi} pu@`o essere un numero in virgola mobile (non solo un
numero intero).
Dettagli di implementazione: a seconda della disponibilit@`a nel sistema in uso,
questa funzione tenta di usare @code{nanosleep()} o @code{select()} per
ottenere il tempo di attesa richiesto.
@end table
@node Esempio di estensione API Test
@subsection Test per l'API
@cindex @code{testext} (estensione)
@cindex estensione @subentry @code{testext()}
L'estensione @code{testext} controlla la funzionalit@`a di
parti dell'estensione API che non sono utilizzate negli altri esempi.
Il file @file{extension/testext.c}
contiene sia il codice C per l'estensione che il codice @command{awk}
(tra i commenti del codice C) per eseguire i test. L'ambiente di test
estrae il codice sorgente @command{awk} ed esegue i test. Si veda il file
sorgente per maggiori informazioni.
@node gawkextlib
@section Il progetto @code{gawkextlib}
@cindex estensioni @subentry caricabili @subentry Progetto @code{gawkextlib}
@cindex @code{gawkextlib} (Progetto)
@cindex progetto @subentry @code{gawkextlib}
Il progetto @uref{https://sourceforge.net/projects/gawkextlib/, @code{gawkextlib}}
fornisce varie estensioni per @command{gawk}, compresa una per
l'elaborazione dei file XML. Questa @`e un'evoluzione del progetto noto come
@command{xgawk} (XML @command{gawk}).
Le estensioni sono parecchie. Alcune delle pi@`u interessanti sono:
@itemize @value{BULLET}
@item
Estensione @code{abort}. Consente di uscire immediatamente dal programma
@command{awk} senza eseguire le regole @code{END}.
@item
Estensione @code{json}.
Permette di serializzare un vettore multidimensionale trasformandolo in
una stringa in formato JSON (JavaScript Object Notation), di effettuare
l'operazione inversa, de-serializzando una stringa JSON, generando
un vettore @command{gawk}.
@item
Estensione libreria MPFR.
Fornisce accesso a varie funzioni MPFR non previste dal supporto nativo
di MPFR disponibile in @command{gawk}
@item
Estensione Select. Fornisce delle funzionalit@`a, appoggiandosi sulla
chiamata di sistema @code{select()}.
@item
Estensione analizzatore XML, usando la libreria di analisi XML
@uref{https://expat.sourceforge.net, Expat}
@end itemize
@cindex @command{git} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{git}
Si pu@`o scaricare il codice del progetto @code{gawkextlib}
usando il codice sorgente mantenuto tramite
@uref{https://git-scm.com, Git}.
Il comando per farlo @`e il seguente:
@example
git clone git://git.code.sf.net/p/gawkextlib/code gawkextlib-code
@end example
@cindex RapidJson @subentry libreria per analizzare JSON
@cindex JSON @subentry RapidJson @subentry libreria per analizzare
Occorre che sia installata la libreria di analisi JSON
per poter generare e usare l'estensione @code{json}.
@cindex Expat @subentry libreria per analizzare XML
@cindex XML @subentry Expat @subentry libreria per analizzare
Per poter compilare e usare l'estensione XML, @`e necessario installare
la libreria di analisi XML @uref{https://expat.sourceforge.net, Expat}.
Inoltre, @`e necessario installare gli strumenti GNU Autotools
(@uref{https://www.gnu.org/software/autoconf, Autoconf},
@uref{https://www.gnu.org/software/automake, Automake},
@uref{https://www.gnu.org/software/libtool, Libtool}
e
@uref{https://www.gnu.org/software/gettext, GNU @command{gettext}}).
La semplice procedura per compilare e testare @code{gawkextlib} @`e la seguente.
Dapprima, occorre compilare e installare @command{gawk}:
@example
cd .../percorso/del/sorgente/gawk
./configure --prefix=/tmp/newgawk @ii{Installa in /tmp/newgawk per ora}
make && make check @ii{Compila e controlla che tutto sia a posto}
make install @ii{Installa gawk}
@end example
Poi, dal sito @url{https://sourceforge.net/projects/gawkextlib/files} si deve
scaricare @code{gawkextlib} e le estensioni che si vogliono installare.
Il file @file{README} del sito spiega come compilare il codice. Se si @`e
installato @command{gawk} in una posizione non-standard, occorre
specificare @code{./configure --with-gawk=@var{/percorso/del/programma/gawk}}
per far s@`{@dotless{i}} che venga trovato.
Pu@`o essere necessario usare il programma di utilit@`a @command{sudo}
per installare sia @command{gawk} che @code{gawkextlib}, a seconda di come
funziona il sistema su cui si lavora.
Chi scrive un'estensione e desidera condividerla con altri utenti
@command{gawk}, pu@`o prendere in considerazione l'idea di farlo attraverso
il progetto @code{gawkextlib}.
Si veda il sito web del progetto per maggiori informazioni.
@node Sommario delle estensioni
@section Sommario
@itemize @value{BULLET}
@item
Si possono scrivere estensioni (dette anche @dfn{plug-in})
per @command{gawk}
nel linguaggio C o C++ usando l'interfaccia di programmazione applicativa
(API) definita dagli sviluppatori di
@command{gawk}.
@item
Le estensioni devono avere una licenza compatibile con la
GNU General Public License (GPL), e devono dichiararlo definendo un'apposita
variabile di nome
@code{plugin_is_GPL_compatibile}.
@item
La comunicazione tra @command{gawk} e un'estensione @`e bidirezionale.
@command{gawk} passa all'estensione una struttura (@code{struct}) che contiene
vari campi di dati e puntatori a funzione. L'estensione pu@`o poi chiamare
funzioni all'interno di @command{gawk} tramite dei puntatori a funzioni
per svolgere alcuni compiti.
@item
Uno di questi compiti @`e di ``registrare'' il nome e l'implementazione di
nuove funzioni a livello di @command{awk} con @command{gawk}.
L'implementazione ha la forma di un puntatore del linguaggio C,
cui @`e associato un dato livello di versione.
Per convenzione, le funzioni di implementazione hanno nome
@code{do_@var{XXXX}()} per una funzione a livello di @command{awk} di nome
@code{@var{XXXX}()}.
@item
L'API @`e definita in un file di intestazione di nome @file{gawkapi.h}.
Occorre includere alcuni file di intestazione standard @emph{prima} di
includere tale intestazione nel codice sorgente.
@item
Vengono forniti dei puntatori a funzioni dell'API per i seguenti tipi di
operazioni:
@itemize @value{BULLET}
@item
Allocare, riallocare, e liberare memoria
@item
Registrare funzioni (si possono registrare
funzioni di estensione,
funzioni ausiliarie di pulizia (@dfn{callbacks}),
una stringa di versione,
degli analizzatori di input,
dei processori di output,
e dei processori bidirezionali)
@item
Stampare messaggi fatali, non fatali, di avvertimento, e avvertimenti ``lint''
@item
Aggiornare @code{ERRNO} o annullarlo
@item
Accedere a parametri, come pure convertire un parametro di tipo non definito
in un vettore
@item
Accedere alla tabella dei simboli (ricuperare il valore di una
variabile globale, crearne una nuova o modificarne una esistente)
@item
Creare e rilasciare valori nascosti; questo consente di usare in modo
efficiente lo stesso valore per pi@`u variabili e pu@`o migliorare di molto le
prestazioni del programma
@item
Manipolare vettori
(ricuperare, aggiungere, cancellare e modificare elementi;
ottenere il numero di elementi in un vettore;
creare un nuovo vettore;
svuotare un vettore;
e
appiattire un vettore per poterlo percorrere facilmente con un ciclo in
stile C, visitando tutti i suoi indici ed elementi)
@end itemize
@item
L'API definisce diversi tipi di dati standard per rappresentare
valori di variabili, elementi di vettore e vettori presenti in @command{awk}.
@item
L'API fornisce funzioni di servizio per definire dei valori.
Sono anche disponibili funzioni di gestione della memoria, per assicurare
la compatibilit@`a fra memoria allocata da @command{gawk} e memoria allocata da
un'estensione.
@item
@emph{Tutta} la memoria passata da @command{gawk} a un'estensione dev'essere
considerata come in sola lettura dall'estensione.
@item
@emph{Tutta} la memoria passata da un'estensione a @command{gawk} deve
essere ottenuta dalle funzioni di allocazione della memoria previste
dall'API. @command{gawk} @`e responsabile per la gestione di quella memoria e
la libera quando @`e il momento per farlo.
@item
L'API fornisce informazioni sulla versione di @command{gawk} in
esecuzione, in modo che un'estensione possa verificare la propria compatibilit@`a
con la versione di @command{gawk} da cui @`e stata caricata.
@item
@`E pi@`u facile iniziare a programmare una nuova estensione usando il
codice predefinito descritto in questo @value{CHAPTER}. Alcune macro nel
file di intestazione @file{gawkapi.h} rendono la cosa pi@`u agevole.
@item
La distribuzione di @command{gawk} comprende un numero di piccoli ma utili
esempi di estensione. Il progetto @code{gawkextlib} include diverse altre
estensioni, di maggiori dimensioni.
Per chi desideri scrivere un'estensione e metterla a disposizione della
comunit@`a degli utenti di @command{gawk}, il progetto @code{gawkextlib}
@`e il posto adatto per farlo.
@end itemize
@c EXCLUDE START
@node Esercizi sulle estensioni
@section Esercizi
@enumerate
@item
Aggiungere funzioni per rendere disponibili chiamate di sistema come
@code{chown()}, @code{chmod()} e @code{umask()} nelle estensioni che
operano con i file viste
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Operazioni interne file}.
@c Idea from comp.lang.awk, February 2015
@item
Scrivere un analizzatore di input che stampi un prompt se l'input proviene
da un dispositivo che sia un ``terminale''. Si pu@`o usare la funzione
@code{isatty()} per sapere se il file in input @`e un terminale.
(Suggerimento: questa funzione
normalmente usa parecchie risorse quando @`e richiamata; si tenti di chiamarla
una volta sola.)
Il contenuto del prompt dovrebbe provenire da una variabile che sia possibile
impostare a livello di codice @command{awk}.
Si pu@`o inviare il prompt allo standard error. Tuttavia,
per ottenere risultati migliori, @`e meglio aprire un nuovo descrittore di file
(o puntatore a un file)
sul file @file{/dev/tty} e stampare il prompt su quel file, nel caso
in cui lo standard error sia stato ridiretto.
Perch@'e lo standard error @`e una scelta migliore dello
standard output per scrivere il prompt?
Quale meccanismo di lettura andrebbe sostituito, quello che legge un record
o quello che legge dei semplici byte?
@item
(Difficile.)
Come si potrebbero gestire degli insiemi di nomi (@dfn{spazi-dei-nomi})
in @command{gawk}, in modo
che i nomi di funzione presenti in estensioni differenti non siano in conflitto
tra loro?
Chi riesce a trovare uno schema di buona qualit@`a @`e pregato di contattare il
manutentore di @command{gawk}, per metterlo al corrente.
@item
Si scriva uno @dfn{script} di shell che funga da interfaccia per
l'estensione ``inplace'', vista
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Esempio di estensione Inplace},
in modo che il comportamento sia simile a quello del comando @samp{sed -i}.
@end enumerate
@c EXCLUDE END
@ifnotinfo
@part @value{PART4}Appendici
@end ifnotinfo
@ifdocbook
@ifclear FOR_PRINT
La Parte IV contiene le appendici (come pure le due licenze che proteggono
il codice sorgente di @command{gawk} e questo @value{DOCUMENT},
rispettivamente) e inoltre il Glossario:
@end ifclear
@ifset FOR_PRINT
La Parte IV contiene tre appendici, l'ultima delle quali @`e la licenza
che protegge il codice sorgente di @command{gawk}:
@end ifset
@itemize @value{BULLET}
@item
@ref{Storia del linguaggio}
@item
@ref{Installazione}
@ifclear FOR_PRINT
@item
@ref{Note}
@item
@ref{Concetti fondamentali}
@item
@ref{Glossario}
@end ifclear
@item
@ref{Copia}
@ifclear FOR_PRINT
@item
@ref{Licenza per Documentazione Libera GNU (FDL)}
@end ifclear
@end itemize
@end ifdocbook
@node Storia del linguaggio
@appendix L'evoluzione del linguaggio @command{awk}
Questo @value{DOCUMENT} descrive l'implementazione GNU di @command{awk}
conforme alle specifiche POSIX. Molti degli utenti di lunga data di
@command{awk} hanno imparato a programmare in @command{awk} usando
l'implementazione originale di @command{awk} presente nella versione 7 di
Unix. (Questa versione @`e servita da base per la versione Berkeley Unix di
@command{awk}, attraverso la versione 4.3BSD-Reno. Successive versioni di
Berkeley Unix e, per un certo periodo, alcuni sistemi derivati da
4.4BSD-Lite, hanno usato varie versioni di @command{gawk} come loro
@command{awk}.) Questo @value{CHAPTER} descrive in breve l'evoluzione
del linguaggio @command{awk}, facendo riferimento ad altre parti del
@value{DOCUMENT} dove si possono trovare ulteriori informazioni.
@ifset FOR_PRINT
Per amor di brevit@`a, sono state omesse in questa edizione informazioni
sulla storia delle funzionalit@`a di @command{gawk}. Si possono trovare nella
@uref{https://www.gnu.org/software/gawk/manual/html_node/Feature-History.html,
documentazione online}.
@end ifset
@menu
* V7/SVR3.1:: Le principali differenze tra V7 e System V
Release 3.1.
* SVR4:: Differenze minori tra System V
Release 3.1 e 4.
* POSIX:: Nuove funzionalit@`a per lo standard POSIX.
* BTL:: Nuove funzionalit@`a dalla versione
di @command{awk} di Brian Kernighan.
* POSIX/GNU:: Le estensioni in @command{gawk} non
previste in @command{awk} POSIX.
* Storia delle funzionalit@`a:: La storia delle funzionalit@`a di
@command{gawk}.
* Estensioni comuni:: Sommario Estensioni comuni.
* Intervalli e localizzazione:: Come le localizzazioni influiscono sugli
intervalli delle espressioni regolari.
* Contributori:: I maggiori contributori a @command{gawk}.
* Sommario della storia:: Sommario della storia.
@end menu
@node V7/SVR3.1
@appendixsec Differenze importanti tra V7 e System V Release 3.1
@cindex @command{awk} @subentry versioni di
@cindex @command{awk} @subentry versioni di @subentry differenze tra V7 e SVR3.1
Il liguaggio @command{awk} si @`e evoluto considerevolmente tra Unix versione
7 (1978) e la nuova implementazione disponibile a partire da Unix System V
Release 3.1 (1987). Questa @value{SECTION} riassume le differenze e indica
dove @`e possibile trovare ulteriori dettagli:
@itemize @value{BULLET}
@item
La necessit@`a di inserire @samp{;} per separare pi@`u regole su una riga
(@pxref{Istruzioni/Righe})
@item
Funzioni definite dall'utente e istruzione @code{return}
(@pxref{Funzioni definite dall'utente})
@item
L'istruzione @code{delete} (@pxref{Cancellazione})
@item
L'istruzione @code{do}-@code{while}
(@pxref{Istruzione do})
@item
Le funzioni predefinite @code{atan2()}, @code{cos()}, @code{sin()}, @code{rand()} e
@code{srand()} (@pxref{Funzioni numeriche})
@item
Le funzioni predefinite @code{gsub()}, @code{sub()} e @code{match()}
(@pxref{Funzioni per stringhe})
@item
Le funzioni predefinite @code{close()} e @code{system()}
(@pxref{Funzioni di I/O})
@item
Le variabili predefinite @code{ARGC}, @code{ARGV}, @code{FNR}, @code{RLENGTH},
@code{RSTART} e @code{SUBSEP} (@pxref{Variabili predefinite})
@item
Possibilit@`a di modificare @code{$0} (@pxref{Cambiare i campi})
@item
L'espressione condizionale che fa uso dell'operatore ternario @samp{?:}
(@pxref{Espressioni condizionali})
@item
L'espressione @samp{@var{indice} in @var{vettore}} esterna alle istruzioni
@code{for} (@pxref{Visitare elementi})
@item
L'operatore esponenziale @samp{^}
(@pxref{Operatori aritmetici}) e il relativo operatore di assegnamento
@samp{^=} (@pxref{Operatori di assegnamento})
@item
Precedenze tra operatori compatibili con quelle del linguaggio C, che
rendono non funzionanti alcuni vecchi programmi @command{awk} (@pxref{Precedenza})
@item
La possibilit@`a di usare @dfn{regexp} come valori di @code{FS}
(@pxref{Separatori di campo}) e come
terzo argomento per la funzione @code{split()}
(@pxref{Funzioni per stringhe}), invece di usare solo il primo carattere
di @code{FS}
@item
@dfn{Regexp} dinamiche come operandi degli operatori @samp{~} e @samp{!~}
(@pxref{Espressioni regolari calcolate})
@item
Le sequenze di protezione @samp{\b}, @samp{\f} e @samp{\r}
(@pxref{Sequenze di protezione})
@item
La ridirezione dell'input per la funzione @code{getline}
(@pxref{Getline})
@item
La possibilit@`a di avere pi@`u regole @code{BEGIN} ed @code{END}
(@pxref{BEGIN/END})
@item
Vettori multidimensionali
(@pxref{Vettori multidimensionali})
@end itemize
@node SVR4
@appendixsec Differenze tra le versioni System V Release 3.1 e SVR4
@cindex @command{awk} @subentry versioni di @subentry differenze tra SVR3.1 e SVR4
La versione per Unix System V Release 4 (1989) di @command{awk} ha aggiunto
queste funzionalit@`a (alcune delle quali introdotte da @command{gawk}):
@itemize @value{BULLET}
@item
Il vettore @code{ENVIRON} (@pxref{Variabili predefinite})
@c gawk and MKS awk
@item
La possibilit@`a di specificare pi@`u opzioni @option{-f} sulla riga di comando
(@pxref{Opzioni})
@c MKS awk
@c Mortice Kern Systems, ditta produttrice di una versione commerciale di awk
@item
L'opzione @option{-v} per assegnare variabili prima di iniziare
l'esecuzione del programma
(@pxref{Opzioni})
@c GNU, Bell Laboratories & MKS together
@item
La notazione @option{--} per indicare la fine delle opzioni sulla riga di
comando
@item
Le sequenze di protezione @samp{\a}, @samp{\v} e @samp{\x}
(@pxref{Sequenze di protezione})
@c GNU, for ANSI C compat
@item
Un codice di ritorno definito per la funzione predefinita @code{srand()}
(@pxref{Funzioni numeriche})
@item
Le funzioni predefinite per stringhe @code{toupper()} e @code{tolower()}
per la conversione maiuscolo/minuscolo
(@pxref{Funzioni per stringhe})
@item
Una specificazione pi@`u accurata per la lettera @samp{%c} di controllo del
formato nella funzione @code{printf}
(@pxref{Lettere di controllo})
@item
La capacit@`a di decidere dinamicamente la larghezza di un campo e la
precisione da usare (@code{"%*.*d"}) nella lista degli argomenti passati a
@code{printf} e @code{sprintf()}
(@pxref{Lettere di controllo})
@item
L'uso di costanti @dfn{regexp}, p.es. @code{/pippo/}, come espressioni,
che equivalgono a usare l'operatore di ricerca di una
corrispondenza, p.es. @samp{$0 ~ /pippo/}
(@pxref{Usare le costanti @dfn{regexp}})
@item
Gestione di sequenze di protezione nell'assegnamento di variabili
effettuato tramite la riga di comando
(@pxref{Opzioni di assegnamento})
@end itemize
@node POSIX
@appendixsec Differenze tra versione SVR4 e POSIX di @command{awk}
@cindex @command{awk} @subentry versioni di @subentry differenze tra SVR4 e POSIX @command{awk}
@cindex POSIX @command{awk} @subentry differenze tra versioni @command{awk}
Lo standard POSIX Command Language and Utilities per @command{awk} (1992)
ha introdotto le seguenti modifiche al linguaggio:
@itemize @value{BULLET}
@item
L'uso dell'opzione @option{-W} per opzioni specifiche a una data
implementazione
(@pxref{Opzioni})
@item
L'uso di @code{CONVFMT} per controllare la conversione di numeri
in stringhe (@pxref{Conversione})
@item
Il concetto di stringa numerica e regole di confronto pi@`u precise da seguire
al riguardo (@pxref{Tipi di variabile e confronti})
@item
L'uso di variabili predefinite come nomi di parametri delle funzioni @`e vietato
(@pxref{Sintassi delle definizioni})
@item
Una documentazione pi@`u completa di molte tra le funzionalit@`a del linguaggio
precedentemente non documentate
@end itemize
Nel 2012, un certo numero di estensioni che erano gi@`a comunemente
disponibili da parecchi anni sono state finalmente aggiunte allo standard
POSIX. Ecco l'elenco:
@itemize @value{BULLET}
@item
La funzione predefinita @code{fflush()} per forzare la scrittura dei buffer
in output
(@pxref{Funzioni di I/O})
@item
L'istruzione @code{nextfile}
(@pxref{Istruzione nextfile})
@item
La possibilit@`a di eliminare completamente un vettore con l'istruzione
@samp{delete @var{vettore}}
(@pxref{Cancellazione})
@end itemize
@xref{Estensioni comuni} per una lista delle estensioni comuni
non previste nello standard POSIX.
Lo standard POSIX 2018 @`e reperibile online a:
@url{https://pubs.opengroup.org/onlinepubs/9699919799/}.
@node BTL
@appendixsec Estensioni nell'@command{awk} di Brian Kernighan
@cindex @command{awk} @subentry versioni di @seealso{Brian Kernighan, @command{awk} di}
@cindex estensioni @subentry Brian Kernighan @command{awk}
@cindex Brian Kernighan @subentry @command{awk} di @subentry estensioni
@cindex Kernighan, Brian
Brian Kernighan
ha reso disponibile la sua versione nel suo sito.
(@pxref{Altre versioni}).
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive estensioni comuni disponibili per la
prima volta nella sua versione di @command{awk}:
@itemize @value{BULLET}
@item
Gli operatori @samp{**} e @samp{**=}
(@pxref{Operatori aritmetici}
e
@ref{Operatori di assegnamento})
@item
L'uso di @code{func} come abbreviazione di @code{function}
(@pxref{Sintassi delle definizioni})
@item
La funzione predefinita @code{fflush()} per forzare la scrittura dei buffer
in output
(@pxref{Funzioni di I/O})
@ignore
@item
The @code{SYMTAB} array, that allows access to @command{awk}'s internal symbol
table. This feature was never documented for his @command{awk}, largely because
it is somewhat shakily implemented. For instance, you cannot access arrays
or array elements through it
@end ignore
@end itemize
@xref{Estensioni comuni} per una lista completa delle estensioni
disponibile nel suo @command{awk}.
@node POSIX/GNU
@appendixsec Estensioni di @command{gawk} non in POSIX @command{awk}
@cindex modalit@`a compatibile di (@command{gawk}) @subentry estensioni nella
@cindex estensioni @subentry nella modalit@`a compatibile di (@command{gawk})
@cindex estensioni @subentry in @command{gawk}, non in POSIX @command{awk}
@cindex POSIX @subentry estensioni @command{gawk} non incluse in
L'implementazione GNU di @command{gawk} aggiunge molte funzionalit@`a.
Queste possono essere disabilitate completamente sia con l'opzione
@option{--traditional} che con l'opzione
@option{--posix}
(@pxref{Opzioni}).
Alcune funzionalit@`a sono state introdotte e successivamente tolte
con il passare del tempo.
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION}
sintetizza le ulteriori funzionalit@`a rispetto a POSIX @command{awk} che sono
presenti nella versione corrente di @command{gawk}.
@itemize @value{BULLET}
@item
Ulteriori variabili predefinite:
@itemize @value{MINUS}
@item
Le variabili
@code{ARGIND},
@code{BINMODE},
@code{ERRNO},
@code{FIELDWIDTHS},
@code{FPAT},
@code{IGNORECASE},
@code{LINT},
@code{PROCINFO},
@code{RT}
e
@code{TEXTDOMAIN}
(@pxref{Variabili predefinite})
@end itemize
@item
File speciali verso cui ridirigere l'I/O:
@itemize @value{MINUS}
@item
I file @file{/dev/stdin}, @file{/dev/stdout}, @file{/dev/stderr} e i
@value{FNS} speciali @file{/dev/fd/@var{N}}
(@pxref{File speciali})
@item
I file speciali @file{/inet}, @file{/inet4} e @file{/inet6} per
interagire con la rete TCP/IP usando @samp{|&} per specificare quale
versione usare del protocollo IP
(@pxref{Reti TCP/IP})
@end itemize
@item
Differenze e/o aggiunte al linguaggio:
@itemize @value{MINUS}
@item
La sequenza di protezione @samp{\x}
(@pxref{Sequenze di protezione})
@item
Supporto completo per @dfn{regexp} sia POSIX che GNU
@iftex
(@pxrefil{Espressioni regolari})
@end iftex
@ifnottex
(@pxref{Espressioni regolari})
@end ifnottex
@item
La possibilit@`a che @code{FS} e il terzo
argomento di @code{split()} siano la stringa nulla
(@pxref{Campi di un solo carattere})
@item
La possibilit@`a che @code{RS} sia una @dfn{regexp}
(@pxref{Record})
@item
La possibilit@`a di usare costanti ottali ed esadecimali nei programmi
scritti in @command{awk}
(@pxref{Numeri non-decimali})
@item
L'operatore @samp{|&} per poter effettuare I/O bidirezionale verso un
coprocesso
(@pxref{I/O bidirezionale})
@item
Chiamate indirette di funzione
(@pxref{Chiamate indirette})
@item
La possibilit@`a di ignorare directory specificate sulla riga di comando,
emettendo un messaggio di avvertimento
(@pxref{Directory su riga di comando})
@item
Errori in output usando @code{print} e @code{printf} non provocano
necessariamente la fine del programma
(@pxref{Continuazione dopo errori})
@end itemize
@item
Nuove parole chiave:
@itemize @value{MINUS}
@item
I criteri di ricerca speciali @code{BEGINFILE} ed @code{ENDFILE}
(@pxref{BEGINFILE/ENDFILE})
@item
L'istruzione @code{switch}
(@pxref{Istruzione switch})
@end itemize
@item
Differenze in funzioni standard di @command{awk}:
@itemize @value{MINUS}
@item
Il secondo argomento opzionale di @code{close()} che consente di chiudere
un solo lato dell'I/O di una @dfn{pipe} bidirezionale aperta verso un
coprocesso (@pxref{I/O bidirezionale})
@item
Aderenza allo standard POSIX per le funzioni @code{gsub()} e @code{sub()}
se @`e stata specificata l'opzione @option{--posix}
@item
La funzione @code{length()} accetta come argomento il nome di un vettore
e restituisce il numero di elementi nel vettore
(@pxref{Funzioni per stringhe})
@item
Il terzo argomento opzionale della funzione @code{match()}
per contenere eventuali sottoespressioni individuate all'interno di una
@dfn{regexp}
(@pxref{Funzioni per stringhe})
@item
Specificatori di posizione nei formati di @code{printf} per facilitare
le traduzioni di messaggi
(@pxref{Ordinamento di printf})
@item
L'aggiunta di un quarto argomento opzionale alla funzione @code{split()},
per designare un vettore che contenga il testo dei separatori di campo
(@pxref{Funzioni per stringhe})
@end itemize
@item
Ulteriori funzioni presenti solo in @command{gawk}:
@itemize @value{MINUS}
@item
Le funzioni @code{gensub()}, @code{patsplit()} e @code{strtonum()}
per una gestione di testi pi@`u potente
(@pxref{Funzioni per stringhe})
@item
Le funzioni @code{asort()} e @code{asorti()} per l'ordinamento di vettori
(@pxref{Ordinamento di vettori})
@item
Le funzioni @code{mktime()}, @code{systime()} e @code{strftime()}
per lavorare con date e ore
(@pxref{Funzioni di tempo})
@item
Le funzioni
@code{and()},
@code{compl()},
@code{lshift()},
@code{or()},
@code{rshift()}
e
@code{xor()}
per la manipolazione a livello di bit
(@pxref{Funzioni a livello di bit})
@c In 4.1, and(), or() and xor() grew the ability to take > 2 arguments
@item
La funzione @code{isarray()} per controllare se una variabile @`e un vettore
oppure no
(@pxref{Funzioni per i tipi})
@item
Le funzioni @code{bindtextdomain()}, @code{dcgettext()}
e @code{dcngettext()} per l'internazionalizzazione
(@pxref{I18N per programmatore})
@ifset INTDIV
@item
La funzione @code{intdiv0()} per effettuare divisioni a numeri interi e
ottenere il resto della divisione
(@pxref{Funzioni numeriche})
@end ifset
@end itemize
@item
Modifiche e/o aggiunte alle opzioni della riga di comando:
@itemize @value{MINUS}
@item
La variabile d'ambiente @env{AWKPATH} per specificare un percorso di ricerca
per l'opzione @option{-f} della riga di comando
(@pxref{Opzioni})
@item
La variabile d'ambiente @env{AWKLIBPATH} per specificare un percorso di ricerca
per l'opzione @option{-l} della riga di comando
(@pxref{Opzioni})
@item
Le opzioni brevi
@option{-b},
@option{-c},
@option{-C},
@option{-d},
@option{-D},
@option{-e},
@option{-E},
@option{-g},
@option{-h},
@option{-i},
@option{-l},
@option{-L},
@option{-M},
@option{-n},
@option{-N},
@option{-o},
@option{-O},
@option{-p},
@option{-P},
@option{-r},
@option{-s},
@option{-S},
@option{-t}
e
@option{-V}
. Inoltre, la
possibilit@`a di usare opzioni in formato lungo (stile GNU) che iniziano
con @option{--}
e le opzioni lunghe
@option{--assign},
@option{--bignum},
@option{--characters-as-bytes},
@option{--copyright},
@option{--debug},
@option{--dump-variables},
@option{--exec},
@option{--field-separator},
@option{--file},
@option{--gen-pot},
@option{--help},
@option{--include},
@option{--lint},
@option{--lint-old},
@option{--load},
@option{--non-decimal-data},
@option{--optimize},
@option{--no-optimize},
@option{--posix},
@option{--pretty-print},
@option{--profile},
@option{--re-interval},
@option{--sandbox},
@option{--source},
@option{--traditional},
@option{--use-lc-numeric},
and
@option{--version}
(@pxref{Opzioni}).
@end itemize
@c new ports
@item
Il supporto per i seguenti sistemi obsoleti @`e stato rimosso dal codice
sorgente e dalla documentazione di @command{gawk} @value{PVERSION} 4.0:
@c nested table
@itemize @value{MINUS}
@item
Amiga
@item
Atari
@item
BeOS
@item
Cray
@item
MIPS RiscOS
@item
MS-DOS con il compilatore Microsoft
@item
MS-Windows con il compilatore Microsoft
@item
NeXT
@item
SunOS 3.x, Sun 386 (Road Runner)
@item
Tandem (non-POSIX)
@item
Compilatore pre-standard VAX C per VAX/VMS
@item
GCC per VAX e Alpha non @`e stato verificato da parecchio tempo.
@end itemize
@item
Il supporto per i seguenti sistemi obsoleti @`e stato rimosso dal codice
di @command{gawk} @value{PVERSION} 4.1:
@c nested table
@itemize @value{MINUS}
@item
Ultrix
@end itemize
@item
Il supporto per i seguenti sistemi obsoleti @`e stato rimosso dal codice
sorgente e dalla documentazione di
@command{gawk} @value{PVERSION} 4.2:
@c nested table
@itemize @value{MINUS}
@item
MirBSD
@item
GNU/Linux su Alpha
@end itemize
@end itemize
@c XXX ADD MORE STUFF HERE
@c This does not need to be in the formal book.
@ifclear FOR_PRINT
@node Storia delle funzionalit@`a
@appendixsec Storia delle funzionalit@`a di @command{gawk}
@ignore
See the thread:
https://groups.google.com/forum/#!topic/comp.lang.awk/SAUiRuff30c
This motivated me to add this section.
@end ignore
@ignore
I've tried to follow this general order, esp.@: for the 3.0 and 3.1 sections:
variables
special files
language changes (e.g., hex constants)
differences in standard awk functions
new gawk functions
new keywords
new command-line options
behavioral changes
extension API changes
new / deprecated / removed ports
installation time stuff
Within each category, be alphabetical.
@end ignore
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive le funzionalit@`a in @command{gawk}
in aggiunta a quelle di POSIX @command{awk},
nell'ordine in cui sono state rese disponibili in @command{gawk}.
La versione 2.10 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
La variabile d'ambiente @env{AWKPATH} per specificare un percorso di ricerca
per l'opzione @option{-f} della riga di comando
(@pxref{Opzioni})
@item
La variabile @code{IGNORECASE} e i suoi effetti
(@pxref{Maiuscolo-Minuscolo}).
@item
I file @file{/dev/stdin}, @file{/dev/stdout}, @file{/dev/stderr} e i
@value{FNS} speciali @file{/dev/fd/@var{N}}
(@pxref{File speciali})
@end itemize
La versione 2.13 di @command{gawk} ha ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
La variabile @code{FIELDWIDTHS} e i suoi effetti
(@pxref{Dimensione costante}).
@item
Le funzioni predefinite @code{systime()} e @code{strftime()} per ottenere
e stampare data e ora
(@pxref{Funzioni di tempo}).
@item
Ulteriori opzioni dalla riga di comando
(@pxref{Opzioni}):
@itemize @value{MINUS}
@item
L'opzione @option{-W lint} per fornire controlli su possibili errori e per
la portabilit@`a, sia a livello di codice sorgente che in fase di esecuzione.
@item
L'opzione @option{-W compat} per inibire le estensioni GNU.
@item
L'opzione @option{-W posix} per richiedere una stretta aderenza allo
standard POSIX.
@end itemize
@end itemize
La versione 2.14 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
L'istruzione @code{next file} per passare immediatamente al successivo
@value{DF} (@pxref{Istruzione nextfile}).
@end itemize
La versione 2.15 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
Nuove variabili (@pxref{Variabili predefinite}):
@itemize @value{MINUS}
@item
@code{ARGIND}, che permette di controllare la posizione di @code{FILENAME}
nel vettore @code{ARGV}.
@item
@code{ERRNO}, che contiene il messaggio di errore del sistema quando
@code{getline} restituisce @minus{}1 o @code{close()} non termina con successo.
@end itemize
@item
I @value{FNS} speciali @file{/dev/pid}, @file{/dev/ppid}, @file{/dev/pgrpid}
e @file{/dev/user}. Questo supporto @`e stato rimosso in seguito.
@item
La possibilit@`a di cancellare un intero vettore in una sola istruzione
con @samp{delete @var{vettore}}
(@pxref{Cancellazione}).
@item
Modifiche nelle opzioni della riga di comando
(@pxref{Opzioni}):
@itemize @value{MINUS}
@item
La possibilit@`a di usare opzioni in formato lungo (in stile GNU) che iniziano
con @option{--}.
@item
L'opzione @option{--source} per combinare codice sorgente immesso nella riga
di comando e codice sorgente proveniente da file di libreria.
@end itemize
@end itemize
La versione 3.0 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
Variabili nuove o modificate:
@itemize @value{MINUS}
@item
@code{IGNORECASE} modificato, diventa applicabile al confronto tra stringhe,
come pure alle operazioni su @dfn{regexp}
(@pxref{Maiuscolo-Minuscolo}).
@item
@code{RT}, che contiene il testo in input che @`e stato individuato da @code{RS}
(@pxref{Record}).
@end itemize
@item
Supporto completo sia per le @dfn{regexp} POSIX sia per quelle GNU
@iftex
(@pxrefil{Espressioni regolari}).
@end iftex
@ifnottex
(@pxref{Espressioni regolari}).
@end ifnottex
@item
La funzione @code{gensub()} per migliorare la manipolazione di testi
(@pxref{Funzioni per stringhe}).
@item
La funzione @code{strftime()} prevede un formato di data e ora di default,
in modo da poter essere chiamata senza alcun argomento.
(@pxref{Funzioni di tempo}).
@item
La possibilit@`a che @code{FS} e il terzo argomento della funzione
@code{split()} siano delle stringhe nulle
(@pxref{Campi di un solo carattere}).
@item
La possibilit@`a che @code{RS} sia una @dfn{regexp}
(@pxref{Record}).
@item
L'istruzione @code{next file} @`e diventata @code{nextfile}
(@pxref{Istruzione nextfile}).
@item
La funzione @code{fflush()} di
BWK @command{awk}
(BWK allora lavorava ai Bell Laboratories;
@pxref{Funzioni di I/O}).
@item
Nuove opzioni della riga di comando:
@itemize @value{MINUS}
@item
L'opzione @option{--lint-old} per
ottenere messaggi relativi a costrutti non disponibili
nell'implementazione di @command{awk} per Unix Version 7
(@pxref{V7/SVR3.1}).
@item
L'opzione @option{-m} da BWK @command{awk}. (Brian lavorava
ancora ai Bell Laboratories all'epoca.) Quest'opzione @`e stata in seguito
rimossa, sia dal suo @command{awk} che da @command{gawk}.
@item
L'opzione @option{--re-interval} per consentire di specificare
espressioni di intervallo nelle @dfn{regexp}
(@pxref{Operatori di espressioni regolari}).
@item
L'opzione @option{--traditional} aggiunta come maniera pi@`u intuitiva
per richiedere l'opzione
@option{--compat} (@pxref{Opzioni}).
@end itemize
@item
L'uso di GNU Autoconf per controllare il processo di configurazione
(@pxref{Installazione veloce}).
@item
Supporto per Amiga.
Questo supporto @`e stato rimosso in seguito.
@end itemize
La versione 3.1 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
Nuove variabili
(@pxref{Variabili predefinite}):
@itemize @value{MINUS}
@item
@code{BINMODE}, per sistemi non aderenti allo standard POSIX,
che consente I/O binario per file in input e/o output
(@pxref{Uso su PC}).
@item
@code{LINT}, che controlla dinamicamente gli avvertimenti emessi da @dfn{lint}.
@item
@code{PROCINFO}, un vettore che fornisce informazioni correlate con il
processo in esecuzione.
@item
@code{TEXTDOMAIN}, per impostare il dominio testuale in cui internazionalizzare
un'applicazione (@pxref{Internazionalizzazione}).
@end itemize
@item
La possibilit@`a di usare costanti ottali ed esadecimali nel codice
sorgente di programmi @command{awk}.
(@pxref{Numeri non-decimali}).
@item
L'operatore @samp{|&} per effettuare I/O bidirezionale verso un
coprocesso
(@pxref{I/O bidirezionale}).
@item
I file speciali @file{/inet} per interagire con reti TCP/IP usando @samp{|&}
(@pxref{Reti TCP/IP}).
@item
Il secondo argomento opzionale della funzione @code{close()} per permettere di
chiudere uno dei lati di una @dfn{pipe} bidirezionale aperta con un coprocesso
(@pxref{I/O bidirezionale}).
@item
Il terzo argomento opzionale della funzione @code{match()} per
avere a disposizione le diverse sottoespressioni individuate all'interno
di una @dfn{regexp}
(@pxref{Funzioni per stringhe}).
@item
Specificatori di posizione nelle stringhe di formato di @code{printf} per
facilitare la traduzione di messaggi
(@pxref{Ordinamento di printf}).
@item
Alcune nuove funzioni predefinite:
@itemize @value{MINUS}
@item
Le funzioni @code{asort()} e @code{asorti()} per l'ordinamento di vettori
(@pxref{Ordinamento di vettori}).
@item
Le funzioni @code{bindtextdomain()}, @code{dcgettext()} e @code{dcngettext()}
per l'internationalizzazione
(@pxref{I18N per programmatore}).
@item
La funzione @code{extension()} e la possibilit@`a di aggiungere
nuove funzioni predefinite dinamicamente
@iftex
(@pxrefil{Estensioni dinamiche}).
@end iftex
@ifnottex
(@pxref{Estensioni dinamiche}).
@end ifnottex
@item
La funzione @code{mktime()} per generare date e ore
(@pxref{Funzioni di tempo}).
@item
Le funzioni @code{and()}, @code{or()}, @code{xor()}, @code{compl()},
@code{lshift()}, @code{rshift()} e @code{strtonum()}
(@pxref{Funzioni a livello di bit}).
@end itemize
@item
@cindex @code{next file} (istruzione obsoleta)
Il supporto per @samp{next file} scritto come due parole @`e stato rimosso
completamente
(@pxref{Istruzione nextfile}).
@item
Ulteriori opzioni sulla riga di comando
(@pxref{Opzioni}):
@itemize @value{MINUS}
@item
L'opzione @option{--dump-variables} per stampare una lista di tutte le
variabili globali.
@item
L'opzione @option{--exec}, da usare in @dfn{script} CGI [Common Gateway Interface].
@item
L'opzione della riga di comando @option{--gen-po} e l'uso di un trattino
basso a inizio stringa, per segnalare stringhe che dovrebbero essere tradotte
(@pxref{Estrazione di stringhe}).
@item
L'opzione @option{--non-decimal-data} per consentire di avere dati in input
di tipo non decimale
(@pxref{Dati non decimali}).
@item
L'opzione @option{--profile} e @command{pgawk}, la
versione profilatrice di @command{gawk}, per produrre profili di esecuzione
di programmi @command{awk}
(@pxref{Profilare}).
@item
L'opzione @option{--use-lc-numeric} per richiedere a @command{gawk}
di usare il carattere di separazione decimale proprio della localizzazione
nell'elaborazione dei dati in input
(@pxref{Conversione}).
@end itemize
@item
L'uso di GNU Automake a supporto della standardizzazione del processo
di configurazione
(@pxref{Installazione veloce}).
@item
L'uso di GNU @command{gettext} per i messaggi emessi da @command{gawk}
(@pxref{Gawk internazionalizzato}).
@item
Supporto per BeOS. Rimosso in seguito.
@item
Supporto per Tandem. Rimosso in seguito.
@item
La versione per Atari ufficialmente non @`e pi@`u supportata e in seguito
@`e stata completamente rimossa.
@item
Modifiche al codice sorgente per usare definizioni di funzione secondo lo
stile di codifica dello standard ISO C.
@item
Aderenza alla specifica POSIX per le funzioni @code{sub()} e @code{gsub()}
(@pxref{Dettagli ostici}).
@item
La funzione @code{length()} @`e stata estesa per accettare un vettore come
argomento, e restituire in tal caso il numero di elementi nel vettore
(@pxref{Funzioni per stringhe}).
@item
La funzione @code{strftime()} accetta un terzo argomento per
dare la possibilit@`a di stampare data e ora nel formato UTC
(@pxref{Funzioni di tempo}).
@end itemize
La versione 4.0 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
Aggiunta di variabili:
@itemize @value{MINUS}
@item
@code{FPAT}, che permette di specificare una @dfn{regexp} che individua
i campi, invece che individuare il separatore tra i campi
(@pxref{Separazione in base al contenuto}).
@item
Se esiste l'elemento di vettore @code{PROCINFO["sorted_in"]}, il ciclo
@samp{for(indice in pippo)} ordina
gli indici, prima di iniziare il ciclo. Il valore di questo elemento
permette di controllare l'ordinamento degli indici prima di iniziare il
ciclo che li visita tutti
(@pxref{Controllare visita}).
@item
@code{PROCINFO["strftime"]}, che contiene la stringa di formato
di default per @code{strftime()}
(@pxref{Funzioni di tempo}).
@end itemize
@item
I file speciali @file{/dev/pid}, @file{/dev/ppid}, @file{/dev/pgrpid}
e @file{/dev/user} sono stati rimossi.
@item
Il supporto per IPv6 @`e stato aggiunto attraverso il file speciale
@file{/inet6}.
Il file speciale @file{/inet4} consente di operare con IPv4 e @file{/inet}
opera con il default di sistema, che probabilmente @`e IPv4
(@pxref{Reti TCP/IP}).
@item
L'uso delle sequenze di protezione @samp{\s} e @samp{\S} nelle espressioni
regolari
(@pxref{Operatori di @dfn{regexp} GNU}).
@item
Le espressioni di intervallo sono consentite per default nelle espressioni
regolari
(@pxref{Operatori di espressioni regolari}).
@item
La classi di caratteri POSIX sono consentite anche se si @`e specificata
l'opzione @option{--traditional}
(@pxref{Operatori di espressioni regolari}).
@item
@code{break} e @code{continue} non sono pi@`u consentiti fuori da un ciclo,
anche se si @`e specificata l'opzione @option{--traditional}
(@pxref{Istruzione break} e anche la
@ref{Istruzione continue}).
@item
@code{fflush()}, @code{nextfile} e @samp{delete @var{array}}
sono consentite anche se @`e stata specificata l'opzione @option{--posix} o
@option{--traditional}, poich@'e questi costrutti sono ora inclusi
nello standard POSIX.
@item
Un terzo argomento opzionale per le funzioni @code{asort()} e @code{asorti()}
permette di specificare il tipo di ordinamento desiderato
(@pxref{Funzioni per stringhe}).
@item
Il comportamento di @code{fflush()} @`e stato modificato per corrispondere
a quello di BWK @command{awk}
e per lo standard POSIX; ora sia @samp{fflush()} che @samp{fflush("")}
forzano la scrittura di tutte le ridirezioni in output aperte
(@pxref{Funzioni di I/O}).
@item
La funzione @code{isarray()}
determina se un elemento @`e un vettore oppure no
per rendere possibile la visita di vettori di vettori
(@pxref{Funzioni per i tipi}).
@item
La funzione @code{patsplit()} che
fornisce le stesse funzionalit@`a di @code{FPAT}, per suddividere delle stringhe
(@pxref{Funzioni per stringhe}).
@item
Un quarto argomento opzionale per la funzione @code{split()},
che indica un vettore destinato a contenere i valori dei separatori
(@pxref{Funzioni per stringhe}).
@item
Vettori di vettori
(@pxref{Vettori di vettori}).
@item
I criteri di ricerca speciali @code{BEGINFILE} ed @code{ENDFILE}
(@pxref{BEGINFILE/ENDFILE}).
@item
Chiamate indirette di funzioni
(@pxref{Chiamate indirette}).
@item
Le istruzioni @code{switch} / @code{case} sono disponibili per default
(@pxref{Istruzione switch}).
@item
Modifiche nelle opzioni della riga di comando
(@pxref{Opzioni}):
@itemize @value{MINUS}
@item
Le opzioni @option{-b} e @option{--characters-as-bytes},
che impediscono che @command{gawk} tratti l'input come composto da una
stringa di caratteri multibyte.
@item
Rimozione delle opzioni ridondanti (in notazione lunga) @option{--compat},
@option{--copyleft} e @option{--usage}.
@item
L'opzione @option{--gen-po} @`e stata finalmente rinominata
@option{--gen-pot} per correttezza.
@item
L'opzione @option{--sandbox} che disabilita alcune funzionalit@`a [per operare
in un ambiente "protetto"].
@item
Tutte le opzioni in notazione lunga hanno acquisito opzioni corrispondenti
in notazione breve, per poter essere usate negli @dfn{script} di shell @samp{#!}.
@end itemize
@item
I nomi di directory che appaiono sulla riga di comando generano adesso
un messaggio di errore, ma non interrompono l'elaborazione, a meno che non
siano state specificate le opzioni @option{--posix} o @option{--traditional}
(@pxref{Directory su riga di comando}).
@item
Il codice interno di @command{gawk} @`e stato riscritto, aggiungendo la
versione per il debug @command{dgawk},
con un possibile miglioramento nei tempi di esecuzione
@iftex
(@pxrefil{Debugger}).
@end iftex
@ifnottex
(@pxref{Debugger}).
@end ifnottex
@item
@cindex POSIX @subentry modalit@`a
In aderenza agli standard di codifica GNU, le estensioni dinamiche devono
definire un simbolo globale che indica che sono compatibili con la
licenza GPL
(@pxref{Licenza delle estensioni}).
@item
@cindex POSIX @subentry modalit@`a
In modalit@`a POSIX, i confronti tra stringhe usano le funzioni di
libreria @code{strcoll()} / @code{wcscoll()}
(@pxref{Confronto POSIX di stringhe}).
@item
L'opzione per usare @dfn{socket} in maniera @dfn{raw} (nativa) @`e stata
rimossa, perch@'e non era mai stata implementata
(@pxref{Reti TCP/IP}).
@item
Intervalli nella forma @samp{[d-h]} sono elaborati come se fossero scritti
nella localizzazione C, a prescindere da che tipo di @dfn{regexp} @`e usata,
anche se era stata specificata l'opzione
@option{--posix}
(@pxref{Intervalli e localizzazione}).
@item
@`E stato rimosso il supporto per i seguenti sistemi:
@itemize @value{MINUS}
@item
Atari
@item
Amiga
@item
BeOS
@item
Cray
@item
MIPS RiscOS
@item
MS-DOS col Compilatore Microsoft
@item
MS-Windows col Compilatore Microsoft
@item
NeXT
@item
SunOS 3.x, Sun 386 (Road Runner)
@item
Tandem (non-POSIX)
@item
Compilatore pre-standard VAX C per VAX/VMS
@end itemize
@end itemize
La versione 4.1 di @command{gawk} ha introdotto le seguenti funzionalit@`a:
@itemize @value{BULLET}
@item
Tre nuovi vettori:
@code{SYMTAB}, @code{FUNCTAB} e @code{PROCINFO["identifiers"]}
(@pxref{Variabili auto-assegnate}).
@item
I tre comandi eseguibili @command{gawk}, @command{pgawk} e @command{dgawk},
sono diventati uno solo, con il solo nome @command{gawk}. Di conseguenza
le opzioni sulla riga di comando sono state modificate.
@item
Modifiche delle opzioni da riga di comando
(@pxref{Opzioni}):
@itemize @value{MINUS}
@item
L'opzione @option{-D} attiva il debugger.
@item
Le opzioni @option{-i} e @option{--include}
caricano dei file di libreria @command{awk}.
@item
Le opzioni @option{-l} e @option{--load} caricano estensioni dinamiche
compilate.
@item
Le opzioni @option{-M} e @option{--bignum} abilitano la libreria MPFR per
il calcolo con un numero arbitrario di cifre significative.
@item
L'opzione @option{-o} serve solo a ottenere in output una stampa formattata
elegantemente del programma da eseguire.
@item
L'opzione @option{-p} @`e usata per "profilare" l'esecuzione del programma.
@item
L'opzione @option{-R} @`e stata rimossa.
@end itemize
@item
Supporto per il calcolo ad alta precisione con MPFR
(@pxref{Calcolo con precisione arbitraria}).
@item
Le funzioni @code{and()}, @code{or()} e @code{xor()} sono state modificate
per ammettere un numero qualsiasi di argomenti, con un minimo di due
(@pxref{Funzioni a livello di bit}).
@item
L'interfaccia che rende possibile l'estensione dinamica @`e stata rifatta
completamente
@iftex
(@pxrefil{Estensioni dinamiche}).
@end iftex
@ifnottex
(@pxref{Estensioni dinamiche}).
@end ifnottex
@item
La funzione @code{getline} ridiretta @`e stata resa possibile all'interno di
@code{BEGINFILE} ed @code{ENDFILE}
(@pxref{BEGINFILE/ENDFILE}).
@item
Il comando @code{where} @`e stato aggiunto al debugger
(@pxref{@dfn{Stack} di esecuzione}).
@item
Il supporto per Ultrix @`e stato rimosso.
@end itemize
La versione 4.2 di @command{gawk} ha introdotto le seguenti modifiche:
@itemize @bullet
@item
Differenze apportate alle variabili d'ambiente (@code{ENVIRON}) sono
riflesse in quelle rese disponibili a @command{gawk} e in quelle di
programmi che siano da esso richiamati.
@xref{Variabili auto-assegnate}.
@item
@code{FIELDWIDTHS} @`e stato migliorato per consentire di saltare dei
caratteri prima di assegnare il valore di un campo
(@pxref{Separazione in base al contenuto}).
@item
Il vettore @code{PROCINFO["argv"]}.
@xref{Variabili auto-assegnate}.
@item
Il numero massimo di cifre esadecimali consentito nelle sequenze di
protezione @samp{\x} @`e ora limitato a due.
@xref{Sequenze di protezione}.
@item
Costanti @dfn{regexp} forti nella forma @samp{@@/@dots{}/}
(@pxref{Costanti @dfn{regexp} forti}).
@item
Le funzioni a livello di bit sono state modificate. Se si
forniscono argomenti negativi, viene generato un errore fatale.
(@pxref{Funzioni a livello di bit}).
@ifset INTDIV
@item
La funzione @code{intdiv0()}.
@xref{Funzioni numeriche}.
@end ifset
@item
La funzione @code{mktime()} ora accetta un secondo argomento opzionale
(@pxref{Funzioni di tempo}).
@item
La funzione @code{typeof()} (@pxref{Funzioni per i tipi}).
@item
Le ottimizzazioni sono abilitate per default. Si usi @option{-s} /
@option{--no-optimize} per non effettuare ottimizzazioni.
@item
Per molti anni, lo standard POSIX richiedeva che la separazione dei campi
di un record fosse fatta per default
quando si incontrano spazi e TAB, e questo @`e il comportamento di
@command{gawk} se si specifica l'opzione @option{--posix}. Dal 2013
il comportamento originario @`e stato ripristinato, e ora
il default per separare i campi con l'opzione @option{--posix} ammette
anche il ritorno a capo come separatore di campi.
@item
Continuazione dopo errori [non fatali] con @code{print} e @code{printf}.
@xref{Continuazione dopo errori}.
@item
Possibilit@`a di tentare di nuovo l'I/O in input
attraverso @code{PROCINFO[@var{input-file}, "RETRY"]};
(@pxref{Proseguire dopo errore in input}).
@item
Modifiche all'opzione @option{--pretty-print}
(@pxref{Profilare}):
@c nested table
@itemize @value{MINUS}
@item
L'opzione @option{--pretty-print} non esegue pi@`u il programma @command{awk}
come in precedenza.
@item
I commenti nel programma sorgente sono conservati e inseriti nel file
in output.
@item
Parentesi esplicite [anche se non strettamente necessarie] nelle espressioni
in input sono mantenute nell'output generato.
@end itemize
@item
Miglioramenti all'API per l'estensione
(@pxref{Estensioni dinamiche}):
@c nested
@itemize @value{MINUS}
@item
La funzione @code{get_file()} @`e in grado di accedere
a ridirezioni in fase di @dfn{open}.
@item
La funzione @code{nonfatal()} per generare messaggi di errore non fatali
(che non provocano la fine del programma).
@item
Supporto per i numeri scritti per essere usati tramite GMP ed MPFR.
@item
Gli analizzatori di input possono ora prevalere sul meccanismo di
analisi dei campi, specificando delle posizioni precise.
@end itemize
@item
Dei file per iniziare una sessione sono inclusi nella distribuzione
e installati da @samp{make install}
(@pxref{File da usare a inizio sessione}).
@item
Il programma @command{igawk} e la relativa pagina di manuale non
sono pi@`u installati quando si compila @command{gawk} [il programma
non @`e pi@`u necessario].
@xref{Programma igawk}.
@item
Il supporto per MirBSD @`e stato rimosso.
@item
Il supporto per GNU/Linux sull'architettura Alpha @`e stato rimosso.
@end itemize
La @value{PVERSION} 5.0 ha aggiunto le seguenti funzionalit@`a:
@itemize
@item
L'elemento di vettore @code{PROCINFO["platform"]}, che permette di
scrivere del codice che tiene conto di piattaforma / sistema operativo.
@end itemize
La @value{PVERSION} 5.1 @`e stata creata per distribuire @command{gawk} con
un nuovo numero di versione maggiore per l'API. Sfortunatamente questo
dettaglio era stato dimenticato al momento in cui era stata preparata la
@value{PVERSION} 5.0. Sono state aggiunte le seguenti funzionalit@`a:
@itemize
@item
L'indice analitico di questo manuale @`e stato completamente rimaneggiato.
@item
@`E stato aggiunto il supporto per MSYS2.
@end itemize
@c XXX ADD MORE STUFF HERE
@end ifclear
@node Estensioni comuni
@appendixsec Sommario Estensioni Comuni
@cindex estensioni @subentry Brian Kernighan @command{awk}
@cindex estensioni @subentry @command{mawk}
La tabella seguente dettaglia le estensioni comuni supportate
da @command{gawk}, da Brian Kernighan @command{awk} e da @command{mawk},
le tre versioni liberamente disponibili pi@`u usate di @command{awk}
(@pxref{Altre versioni}).
@multitable {File speciale @file{/dev/stderr}} {BWK @command{awk} } {@command{mawk}} {@command{gawk}} {Standard attuale}
@headitem Funzionalit@`a @tab BWK @command{awk} @tab @command{mawk} @tab @command{gawk} @tab Standard attuale
@item Sequenza di protezione @samp{\x} @tab X @tab X @tab X @tab
@item Stringa nulla come @code{FS} @tab X @tab X @tab X @tab
@item File speciale @file{/dev/stdin} @tab X @tab X @tab X @tab
@item File speciale @file{/dev/stdout} @tab X @tab X @tab X @tab
@item File speciale @file{/dev/stderr} @tab X @tab X @tab X @tab
@item @code{delete} senza indici @tab X @tab X @tab X @tab X
@item Funzione @code{fflush()} @tab X @tab X @tab X @tab X
@item @code{length()} di un vettore @tab X @tab X @tab X @tab
@item Istruzione @code{nextfile} @tab X @tab X @tab X @tab X
@item Operatori @code{**} e @code{**=} @tab X @tab @tab X @tab
@item Parola chiave @code{func} @tab X @tab @tab X @tab
@item Variabile @code{BINMODE} @tab @tab X @tab X @tab
@item @code{RS} come @dfn{regexp} @tab X @tab X @tab X @tab
@item Funzioni gestione data/ora @tab @tab X @tab X @tab
@end multitable
@node Intervalli e localizzazione
@appendixsec Intervalli @dfn{regexp} e localizzazione: una lunga e triste storia
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} descrive la storia confusionaria degli intervalli
all'interno di espressioni regolari, le loro relazioni con la localizzazione,
e l'effetto da ci@`o determinato su diverse versioni di @command{gawk}.
@cindex ASCII
@cindex EBCDIC
Gli strumenti originali Unix aventi a che fare con espressioni regolari
stabilivano che intervalli di caratteri (come @samp{[a-z]}) individuavano
un carattere qualsiasi tra il primo carattere dell'intervallo e l'ultimo
carattere dello stesso, entrambi inclusi. L'ordinamento era basato sul
valore numerico di ogni carattere come era rappresentato all'interno
del computer, nell'insieme di caratteri proprio di ogni macchina.
Quindi, su sistemi che adottano la codifica ASCII, @samp{[a-z]} individua
tutte le lettere minuscole, e solo
quelle, in quanto i valori numerici che rappresentano le lettere dalla
@samp{a} fino alla @samp{z} sono contigui. (In un sistema che adotta la
codifica EBCDIC, l'intervallo @samp{[a-z]} comprende anche ulteriori
caratteri non alfabetici.)
Quasi tutti i testi di introduzione allo Unix spiegavano che le espressioni
di intervallo funzionavano in questo modo, e in particolare insegnavano che
la maniera ``corretta'' per individuare le lettere minuscole era con
@samp{[a-z]} e che @samp{[A-Z]} era il modo ``corretto'' per individuare le
lettere maiuscole.
E, in effetti, era proprio cos@`{@dotless{i}}.@footnote{E la vita era semplice.}
Lo standard POSIX 1992 introduceva l'idea di localizzazione
(@pxref{Localizzazioni}).
Poich@'e molte localizzazioni comprendono altre lettere, oltre alle 26
lettere dell'alfabeto inglese, lo standard POSIX introduceva le classi
di carattere (@pxref{Espressioni tra parentesi quadre}) per permettere
l'individuazione di differenti insiemi di caratteri, in aggiunta a quelli
tradizionali presenti nell'insieme di caratteri ASCII.
Tuttavia, lo standard @emph{ha modificato} l'interpretazione delle
espressioni di intervallo.
Nelle localizzazioni @code{"C"} e @code{"POSIX"},
un'espressione di intervallo come
@samp{[a-dx-z]} @`e ancora equivalente a @samp{[abcdxyz]}, secondo l'ordine
della codifica ASCII.
Ma in tutte le altre localizzazioni l'ordinamento @`e basato su quel che
si chiama @dfn{ordine di collazione}.
Cosa vuol dire?
In molte localizzazioni, le lettere @samp{A} e @samp{a} vengono entrambe
prima di @samp{B}.
In altre parole, queste localizzazioni ordinano i caratteri nel modo in cui
sono ordinati in un dizionario,
e @samp{[a-dx-z]} non @`e detto che equivalga a @samp{[abcdxyz]};
invece, potrebbe essere equivalente a @samp{[ABCXYabcdxyz]}, per fare un
esempio.
Su questo punto @`e opportuno insistere: molta documentazione afferma che
si dovrebbe usare @samp{[a-z]} per identificare un carattere minuscolo.
Ma su sistemi con localizzazioni
non-ASCII, un tale intervallo potrebbe includere tutti i caratteri maiuscoli
tranne @samp{A} o @samp{Z}! Questo ha continuato a essere una fonte di
equivoci perfino nel ventunesimo secolo.
Per dare un'idea del tipo di problemi, l'esempio seguente usa la funzione
@code{sub()}, che effettua una sostituzione di testo all'interno di una
stringa (@pxref{Funzioni per stringhe}). Qui, l'idea @`e quella di rimuovere
i caratteri maiuscoli a fine stringa:
@example
$ @kbd{echo qualcosa1234abc | gawk-3.1.8 '@{ sub("[A-Z]*$", ""); print @}'}
@print{} qualcosa1234a
@end example
@noindent
Questo non @`e l'output che ci si aspettava, perch@'e, il @samp{bc} alla fine di
@samp{qualcosa1234abc} non dovrebbe essere individuato da @samp{[A-Z]*}.
Un tale risultato dipende dalle impostazioni di localizzazione (e quindi
potrebbe non succedere sul sistema che si sta usando).
@cindex Unicode
@cindex ASCII
Considerazioni simili valgono per altri intervalli. Per esempio, @samp{["-/]}
@`e perfettamente valido in ASCII, ma non @`e valido in molte localizzazioni
Unicode, p.es. in @code{en_US.UTF-8}.
Il codice delle prime versioni di @command{gawk} per individuare le
@dfn{regexp} non teneva conto della localizzazione, e quindi gli
intervalli potevano essere interpretati in maniera tradizionale.
Quando @command{gawk} ha iniziato a usare metodi di ricerca di @dfn{regexp}
che tengono conto della localizzazione, sono iniziati i problemi;
a maggior ragione in quanto sia GNU/Linux che i venditori di versioni
commerciali di Unix
avevano iniziato a implementare localizzazioni non-ASCII,
@emph{adottandole per default}. La domanda che forse si udiva pi@`u spesso
era del tipo: ``Perch@'e @samp{[A-Z]} individua lettere minuscole?!?''
@cindex Berry, Karl
Questa situazione @`e in essere da circa 10 anni, se non di pi@`u, e
il manutentore di @command{gawk} si @`e stufato di continuare a spiegare che
@command{gawk} stava semplicemente implementando quelli che sono gli
standard, e che il problema stava nella localizzazione dell'utente. Nella
fase di sviluppo della @value{PVERSION} 4.0, @command{gawk} @`e stato modificato
in modo da trattare sempre gli
intervalli "come si faceva prima di POSIX", a meno che non si specifichi
l'opzione @option{--posix} (@pxref{Opzioni}).@footnote{Ed
@`e cos@`{@dotless{i}} che @`e nata la Campagna per l'Interpretazione Razionale degli
Intervalli (in inglese, RRI [@dfn{Rational Range Interpretation}]).
Un certo
numero di strumenti GNU hanno gi@`a implementato questa modifica, o
lo faranno presto. Grazie a Karl Berry per aver coniato la frase
``Rational Range Interpretation''.}
Fortunatamente, un po' prima del rilascio definitivo della versione 4.0 di
@command{gawk}, il manutentore ha appreso che lo standard 2008 aveva
modificato la definizione di intervallo, e che, al di fuori delle
localizzazioni @code{"C"} e @code{"POSIX"}, il significato di espressione
di intervallo era ora
@emph{indefinito}.@footnote{Si veda
@uref{https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05, lo standard}
e
@uref{https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap09.html#tag_21_09_03_05, le motivazioni}.}
Adottando questo simpatico termine tecnico, lo standard permette agli
implementatori di implementare gli intervalli nella maniera che preferiscono.
Il manutentore di @command{gawk} ha deciso di implementare la regola pre-POSIX
sia per l'individuazione di default delle @dfn{regexp} sia quando si
specificano le opzioni @option{--traditional} o @option{--posix}.
In ogni caso @command{gawk} aderisce allo standard POSIX.
@node Contributori
@appendixsec I principali contributori a @command{gawk}
@cindex @command{gawk} @subentry lista di contributori a
@quotation
@i{Riconoscere sempre il merito, se un merito va riconosciuto.}
@author Anonimo
@end quotation
Questa @value{SECTION} elenca le persone che hanno maggiormente contribuito
allo sviluppo di @command{gawk} e/o alla stesura di questo @value{DOCUMENT},
in ordine approssimativamente cronologico:
@itemize @value{BULLET}
@item
@cindex Aho, Alfred
@cindex Weinberger, Peter
@cindex Kernighan, Brian
Il Dr.@: Alfred V.@: Aho,
il Dr.@: Peter J.@: Weinberger, e
il Dr.@: Brian W.@: Kernighan, tutti dei Bell Laboratories,
hanno progettato e implementato @command{awk} per Unix,
da cui @command{gawk} trae la maggioranza delle sue funzionalit@`a.
@item
@cindex Rubin, Paul
Paul Rubin,
autore del progetto e dell'implementazione iniziale del 1986, ha
scritto la prima bozza (di circa 40 pagine) di questo @value{DOCUMENT}.
@item
@cindex Fenlason, Jay
Jay Fenlason
ha completato l'implementazione iniziale.
@item
@cindex Close, Diane
Diane Close
ha rivisto la prima bozza di questo @value{DOCUMENT}, portandolo alla
lunghezza di circa 90 pagine.
@item
@cindex Stallman, Richard
Richard Stallman
ha aiutato a completare l'implementazione e la bozza iniziale di questo
@value{DOCUMENT}.
@`E anche il fondatore della FSF e del progetto GNU.
@item
@cindex Woods, John
John Woods
ha scritto porzioni di codice (volti principalmente alla correzione di
errori) nella versione iniziale di @command{gawk}.
@item
@cindex Trueman, David
Nel 1988,
David Trueman
si @`e fatto carico della manutenzione principale di @command{gawk},
rendendolo compatibile col ``nuovo'' @command{awk} e
migliorandone parecchio la velocit@`a di esecuzione.
@item
@cindex Kwok, Conrad
@cindex Garfinkle, Scott
@cindex Williams, Kent
Conrad Kwok,
Scott Garfinkle
e
Kent Williams
hanno per primi portato il programma all'ambiente MS-DOS, usando varie
versioni del compilatore MSC.
@item
@cindex Rankin, Pat
Pat Rankin
ha portato il programma all'ambiente VMS, preparando anche la relativa
documentazione.
@item
@cindex Peterson, Hal
Hal Peterson
@`e stato di aiuto nel portare @command{gawk} nei sistemy Cray.
(L'ambiente Cray non @`e pi@`u supportato.)
@item
@cindex Rommel, Kai Uwe
Kai Uwe Rommel
ha portato per primo il programma all'ambiente OS/2, preparando anche
la relativa documentazione.
@item
@cindex Jaegermann, Michal
Michal Jaegermann
ha portato il programma all'ambiente Atari, preparando anche la relativa
documentazione.
(L'ambiente Atari non @`e pi@`u supportato.)
Michal continua a effettuare controlli di portabilit@`a,
e ha molto contribuito a consentire a @command{gawk}
di funzionare su sistemi diversi da quelli a 32 bit.
@item
@cindex Fish, Fred
Fred Fish
ha portato il programma all'ambiente Amiga, preparando anche la relativa
documentazione.
(Purtroppo Fred non @`e pi@`u tra noi, e questo ambiente non @`e pi@`u supportato.)
@item
@cindex Deifik, Scott
Scott Deifik
si @`e occupato in passato della manutenzione per MS-DOS usando
il compilatore DJGPP.
@item
@cindex Zaretskii, Eli
Eli Zaretskii
si occupa della manutenzione della versione per MS-Windows, nell'ambiente
MinGW.
@item
@cindex Grigera, Juan
Juan Grigera
@`e autore di una versione di @command{gawk} per sistemi Windows32.
(Questa versione non @`e pi@`u supportata.)
@item
@cindex Hankerson, Darrel
Per molti anni, il
Dr.@: Darrel Hankerson
ha fatto da coordinatore per le varie versioni che giravano su diverse
piattaforme PC e ha creato distribuzioni binarie per vari sistemi operativi
che girano sui PC.
Il suo aiuto @`e stato importante per mantenere aggiornata la documentazione
per le diverse piattaforme PC.
@item
@cindex Zoulas, Christos
Christos Zoulas
ha scritto la funzione predefinita @code{extension()} per aggiungere
dinamicamente nuove funzioni.
(Questa funzionalit@`a @`e divenuta obsoleta a partire da @command{gawk} 4.1.)
@item
@cindex Kahrs, J@"urgen
J@"urgen Kahrs
ha scritto la prima versione del codice per interagire con la rete
TCP/IP, con la relativa documentazione, e fornito le ragioni per l'aggiunta
dell'operatore @samp{|&}.
@item
@cindex Davies, Stephen
Stephen Davies
ha portato per la prima volta il programma all'ambiente Tandem, preparando
anche la relativa documentazione.
(Tuttavia, questa versione non @`e pi@`u supportata.)
Stephen @`e anche stato determinante nel lavoro iniziale per integrare il codice
interno di gestione dei byte nel
complesso del codice di @command{gawk}.
Inoltre, ha svolto molto del lavoro necessario per far s@`{@dotless{i}} che usando
l'opzione @option{--pretty-print} i commenti venissero conservati e
stampati nell'output.
@item
@cindex Woehlke, Matthew
Matthew Woehlke
ha migliorato l'aderenza allo standard POSIX nei sistemi Tandem che
implementano lo standard.
@item
@cindex Brown, Martin
Martin Brown
ha portato il programma all'ambiente BeOS, preparando anche la relativa
documentazione.
(L'ambiente BeOS non @`e pi@`u supportato.)
@item
@cindex Peters, Arno
Arno Peters
ha fatto il lavoro iniziale necessario per consentire alla configurazione
di @command{gawk} di usare GNU Automake e GNU @command{gettext}.
@item
@cindex Broder, Alan J.@:
Alan J.@: Broder
ha scritto la prima versione della funzione @code{asort()} e anche
il codice per gestire il terzo argomento opzionale della funzione
@code{match()}.
@item
@cindex Buening, Andreas
Andreas Buening
ha aggiornato la versione di @command{gawk} per OS/2.
@item
@cindex Hasegawa, Isamu
Isamu Hasegawa,
dell'IBM in Giappone, ha contribuito con il supporto per i caratteri multibyte.
@item
@cindex Benzinger, Michael
Michael Benzinger ha sviluppato il codice iniziale per l'istruzione
@code{switch}.
@item
@cindex McPhee, Patrick
Patrick T.J.@: McPhee ha sviluppato il codice per il caricamento
dinamico negli ambienti Windows32.
(Questa funzionalit@`a non @`e pi@`u supportata.)
@item
@cindex Wallin, Anders
Anders Wallin ha aiutato a continuare il supporto della versione VMS
di @command{gawk} per parecchi anni.
@item
@cindex Gordon, Assaf
Assaf Gordon ha contribuito il codice iniziale per implementare
l'opzione @option{--sandbox}.
@item
@cindex Haque, John
John Haque @`e autore dei seguenti contributi:
@itemize @value{MINUS}
@item
Le modifiche per convertire @command{gawk}
in un interprete di codice a livello di byte, compreso il debugger
@item
L'aggiunta di veri vettori di vettori
@item
Le modifiche ulteriori per il supporto del calcolo a precisione
arbitraria
@item
Il testo iniziale di
@ref{Calcolo con precisione arbitraria}
@item
Il lavoro per unificare le tre varianti del programma @command{gawk},
in vista della versione 4.1
@item
I miglioramenti alla gestione interna dei vettori per i vettori i cui
indici sono dei numeri interi
@item
A John, insieme a Pat Rankin, si devono i miglioramenti alla funzionalit@`a
di ordinamento dei vettori.
@end itemize
@cindex Papadopoulos, Panos
@item
Panos Papadopoulos ha scritto il testo originale per
@ref{Includere file}.
@item
@cindex Yawitz, Efraim
Efraim Yawitz ha scritto il testo originale per il @ref{Debugger}.
@item
@cindex Schorr, Andrew
Lo sviluppo dell'estensione API rilasciata per la prima volta con
@command{gawk} 4.1 @`e stata principalmente guidata da
Arnold Robbins e Andrew Schorr, con notevoli contributi dal
resto del team di sviluppo.
@cindex Malmberg, John
@item
John Malmberg ha apportato miglioramenti significativi alla versione
OpenVMS e alla relativa documentazione.
@item
@cindex Colombo, Antonio
Antonio Giovanni Colombo ha riscritto diversi esempi, che non erano pi@`u
attuali, contenuti nei primi capitoli, e gliene sono estremamente grato.
Ha inoltre preparato con Marco Curreli e mantiene la traduzione in
italiano di questo libro.
@item
@cindex Curreli, Marco
Marco Curreli, insieme con Antonio Colombo, ha tradotto questo
@value{DOCUMENT} in italiano. @`E ora incluso nella distribuzione
di @command{gawk}.
@item
@cindex Guerrero, Juan Manuel
Juan Manuel Guerrero ha preso in carico la manutenzione della
versione DJGPP di @command{gawk}.
@item
@cindex Jannick
``Jannick'' ha fornito il supporto per l'ambiente MSYS2.
@item
@cindex Robbins @subentry Arnold
Arnold Robbins
ha lavorato su @command{gawk} dal 1988, dapprima
aiutando David Trueman e in seguito, dal 1994 circa, come
manutentore principale.
@end itemize
@node Sommario della storia
@appendixsec Sommario
@itemize @value{BULLET}
@item
Il linguaggio @command{awk} si @`e evoluto col passare degli anni. La prima
versione risale a Unix V7, circa 1978. Nel 1987, per la versione Unix
System V Release 3.1, sono state fatte al linguaggio delle modifiche
importanti, inclusa la possibilit@`a di avere funzioni definite dall'utente.
Ulteriori modifiche sono state fatte per la versione System V Release 4, nel
1989.
Dopo di allora, sono state apportate ulteriori modifiche minori,
per implementare lo standard POSIX.
@item
L'@command{awk} di Brian Kernighan prevede un piccolo numero di estensioni
implementate di comune accordo con altre versioni di @command{awk}.
@item
@command{gawk} prevede un elevato numero di estensioni rispetto
a POSIX @command{awk}.
Queste estensioni possono essere disabilitate specificando l'opzione
@option{--traditional} o @option{--posix}.
@item
@cindex ASCII
@cindex EBCDIC
L'interazione tra localizzazioni POSIX e individuazione di @dfn{regexp}
in @command{gawk} @`e stata causa di malintesi nel corso degli anni. Oggi
@command{gawk} implementa l'Interpretazione Razionale degli Intervalli
(@dfn{Rational Range Interpretation}), dove
intervalli nella forma @samp{[a-z]} individuano @emph{solo} i caratteri
numericamente compresi tra
@samp{a} e @samp{z} nella rappresentazione nativa dei caratteri in quella
particolare macchina. Normalmente quella in uso @`e quella ASCII,
ma pu@`o essere EBCDIC sui sistemi IBM S/390.
@item
Molte persone hanno contribuito allo sviluppo di @command{gawk} nel corso
degli anni. Spero che l'elenco fornito in questo @value{CHAPTER} sia
esauriente e attribuisca il giusto riconoscimento quando questo @`e dovuto.
@end itemize
@node Installazione
@appendix Installare @command{gawk}
@c last two commas are part of see also
@cindex sistemi operativi
@cindex sistemi operativi @seealso{GNU/Linux}
@cindex sistemi operativi @seealso{Linux}
@cindex @command{gawk} @subentry installare
@cindex installare @command{gawk}
Quest'appendice contiene istruzioni per installare @command{gawk} sulle
varie piattaforme supportate dagli sviluppatori. Lo sviluppatore
principale supporta GNU/Linux (e Unix), mentre le altre piattaforme sono
sono curate da altri sviluppatori.
@xref{Bug}
per gli indirizzi di posta elettronica di chi effettua la manutenzione
della versione specifica di una particolare piattaforma.
@menu
* Distribuzione di Gawk:: Contenuto della distribuzione di @command{gawk}.
* Installazione Unix:: Installare @command{gawk} su varie versioni
di Unix.
* Installazione non-Unix:: Installazioni su altri Sistemi Operativi.
* Bug:: Notificare problemi e bug.
* Altre versioni:: Altre implementazioni di @command{awk}
liberamente disponibili.
* Sommario dell'installazione:: Sommario dell'installazione.
@end menu
@node Distribuzione di Gawk
@appendixsec La distribuzione di @command{gawk}
@cindex codice sorgente @subentry @command{gawk}
@cindex sorgente @subentry codice @subentry @command{gawk}
Questa @value{SECTION} spiega come ottenere la distribuzione
di @command{gawk}, come scompattarla, e cosa @`e contenuto nei vari file
e nelle sottodirectory risultanti.
@menu
* Scaricare:: Come ottenere la distribuzione.
* Scompattazione:: Come estrarre la distribuzione.
* Contenuti della distribuzione:: Cosa c'@`e nella distribuzione.
@end menu
@node Scaricare
@appendixsubsec Ottenere la distribuzione di @command{gawk}
@cindex @command{gawk} @subentry codice sorgente @subentry ottenere il
@cindex codice sorgente @subentry @command{gawk} @subentry ottenere il
Ci sono due modi per ottenere del software GNU:
@itemize @value{BULLET}
@item
Copiarlo da qualcuno che ce l'abbia gi@`a.
@cindex FSF (Free Software Foundation)
@cindex Free Software Foundation (FSF)
@item
Ottenere @command{gawk}
dal sito Internet
@code{ftp.gnu.org}, nella directory @file{/gnu/gawk}.
@`E possibile accedere al sito sia via @command{ftp} anonimo che via @code{http}.
Se si dispone del programma @command{wget}, si pu@`o utilizzarlo digitando un
comando simile a questo:
@example
wget https://ftp.gnu.org/gnu/gawk/gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz
@end example
@end itemize
L'archivio che contiene il software GNU @`e disponibile in vari cloni
(@dfn{mirror}) in tutto il mondo.
La lista aggiornata dei siti clone @`e disponibile nel
@uref{https://www.gnu.org/order/ftp.html, sito web principale della FSF}.
Si tenti di usare uno dei siti-clone; dovrebbero essere meno trafficati, ed @`e
possibile che ce ne sia uno pi@`u vicino.
Si pu@`o anche scaricare la distribuzione del sorgente di @command{gawk}
dal deposito Git ufficiale; per maggiori informazioni, si veda
@ref{Accedere ai sorgenti}.
@node Scompattazione
@appendixsubsec Scompattare la distribuzione
@command{gawk} @`e distribuito sotto forma di parecchi file @code{tar}
compressi con differenti programmi di compressione: @command{gzip},
@command{bzip2}
e @command{xz}. Per amor di semplicit@`a, il resto di queste istruzioni
presuppone che si stia usando quella compressa col programma GNU Gzip
(@command{gzip}).
Una volta che si ha a disposizione la distribuzione (p.es.,
@file{gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz}),
va usato @code{gzip} per scompattare il file e quindi @code{tar} per estrarne i
file. Si pu@`o usare la seguente @dfn{pipe} per produrre la distribuzione
@command{gawk}:
@example
gzip -d -c gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz | tar -xvpf -
@end example
In un sistema che abbia la versione GNU di @command{tar}, si
pu@`o far effettuare la scompattazione direttamente a @command{tar}:
@example
tar -xvpzf gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz
@end example
@noindent
L'estrazione dei file dall'archivio
crea una directory di nome @file{gawk-@value{VERSION}.@value{PATCHLEVEL}}
nella directory corrente.
Il @value{FN} della distribuzione @`e nella forma
@file{gawk-@var{V}.@var{R}.@var{P}.tar.gz}.
La @var{V} rappresenta la versione maggiore di @command{gawk},
la @var{R} rappresenta il rilascio corrente della versione @var{V}, e
la @var{P} rappresenta un @dfn{patch level}, che sta a indicare che
correzioni a errori minori sono state incluse nel rilascio.
Il @dfn{patch level} corrente @`e @value{PATCHLEVEL}, ma quando ci si procura
una distribuzione, andr@`a ottenuta quella con il livello pi@`u alto di
versione, rilascio e @dfn{patch}.
(Si noti, comunque, che livelli di @dfn{patch} maggiori o uguali a 60
denotano versioni ``beta'', ossia versioni non destinate a essere usate
in produzione; non si dovrebbero utilizzare tali versioni, se non si @`e
disposti a sperimentare.)
Se non si sta usando un sistema Unix o GNU/Linux, i modi per ottenere
e scompattare la distribuzione di @command{gawk} sono differenti.
Si dovrebbe sentire un esperto di quel sistema.
@node Contenuti della distribuzione
@appendixsubsec Contenuti della distribuzione @command{gawk}
@cindex @command{gawk} @subentry distribuzione di
@cindex distribuzione di @command{gawk}
La distribuzione di @command{gawk} contiene un certo numero di file
sorgente in C, di file di documentazione, di sottodirectory, e di file
utilizzati durante il processo di configurazione
(@pxref{Installazione Unix}),
come pure parecchie sottodirectory relative a diversi sistemi operativi
non-Unix:
@table @asis
@item Vari file @samp{.c}, @samp{.y} e @samp{.h}
Questi file contengono il codice sorgente vero e proprio di @command{gawk}.
@end table
@table @file
@item support/*
Intestazioni C e file sorgente per routine che @command{gawk}
usa, ma che non sono parte della sua funzionalit@`a
fondamentale. Per esempio, analisi di argomenti, controlli
di corrispondenze di espressioni regolari, e routine per
generare numeri casuali sono tutti mantenuti qui.
@item ABOUT-NLS
Un file contenente informazioni sul comando GNU @command{gettext} e
sulle traduzioni.
@item AUTHORS
Un file con alcune informazioni su chi ha scritto @command{gawk}.
Esiste solo per placare i pedanti della Free Software Foundation.
@item README
@itemx README_d/README.*
File descrittivi: vari @file{README} ("leggimi") per @command{gawk} sotto Unix e per
tutte le varie altre combinazioni hardware e software.
@item INSTALL
Un file che fornisce una panoramica sul processo di configurazione e installazione.
@item ChangeLog
Una lista dettagliata delle modifiche apportate al codice sorgente,
ai problemi risolti e ai miglioramenti introdotti.
@item ChangeLog.0
Una lista meno recente di modifiche al codice sorgente.
@item NEWS
Una lista di modifiche a @command{gawk} a partire dall'ultimo rilascio
o @dfn{patch}.
@item NEWS.0
Una lista meno recente di modifiche a @command{gawk}.
@item COPYING
La @dfn{GNU General Public License}.
@item POSIX.STD
Una descrizione di comportamenti nello standard POSIX per @command{awk} che
sono lasciati indefiniti, o ai quali @command{gawk} non pu@`o conformarsi
pienamente, come pure una lista di specifiche che lo standard POSIX dovrebbe
contenere, ma che non sono presenti.
@cindex intelligenza artificiale @subentry @command{gawk} e
@cindex @command{gawk} @subentry e l'intelligenza artificiale
@item doc/awkforai.txt
Puntatori alla bozza originale di un breve articolo
che spiega perch@'e @command{gawk} @`e un linguaggio adatto alla
programmazione nel campo dell'intelligenza artificiale (AI).
@item doc/bc_notes
Una breve descrizione della struttura interna a livello di byte di
@command{gawk} [``byte code''].
@item doc/README.card
@itemx doc/ad.block
@itemx doc/awkcard.in
@itemx doc/cardfonts
@itemx doc/colors
@itemx doc/macros
@itemx doc/no.colors
@itemx doc/setter.outline
Il sorgente @command{troff} per una scheda di riferimento a cinque colori
di @command{awk}.
Per ottenere la versione a colori @`e richiesta una versione recente di
@command{troff}, come la versione GNU di @command{troff} (@command{groff}).
Si veda il file @file{README.card} per istruzioni su come comportarsi se @`e
disponibile solo una versione pi@`u vecchia di @command{troff}.
@item doc/gawk.1
Il sorgente @command{troff} di una pagina di manuale [@dfn{man}]
che descrive @command{gawk}.
Questa pagina @`e distribuita a beneficio degli utenti Unix.
@cindex Texinfo
@item doc/gawktexi.in
@itemx doc/sidebar.awk
Il file sorgente Texinfo di questo @value{DOCUMENT}.
Dovrebbe venire elaborato da @file{doc/sidebar.awk}
prima di essere elaborato con @command{texi2dvi} o @command{texi2pdf}
per produrre un documento stampato, o
con @command{makeinfo} per produrre un file Info o HTML.
Il @file{Makefile} si occupa di questa elaborazione e produce
la versione stampabile tramite i comandi
@command{texi2dvi} o @command{texi2pdf}.
@item doc/gawk.texi
Il file prodotto elaborando @file{gawktexi.in}
tramite @file{sidebar.awk}.
@item doc/gawk.info
Il file Info generato per questo @value{DOCUMENT}.
@item doc/gawkinet.texi
Il file sorgente Texinfo per
@ifinfo
@inforef{Top, , Introduzione generale, gawkinet, @value{GAWKINETTITLE}}.
@end ifinfo
@ifnotinfo
@cite{@value{GAWKINETTITLE}}.
@end ifnotinfo
Dovrebbe venire elaborato con @TeX{}
(tramite @command{texi2dvi} o @command{texi2pdf})
per produrre un documento stampato o
con @command{makeinfo} per produrre un file Info o HTML.
@item doc/gawkinet.info
Il file Info generato per
@cite{@value{GAWKINETTITLE}}.
@item doc/igawk.1
Il sorgente @command{troff} per una pagina di manuale relativa al
programma @command{igawk} descritto
@ifnottex
in
@end ifnottex
@iftex
nella
@end iftex
@ref{Programma igawk}.
(Poich@'e @command{gawk} prevede ora internamente l'uso della direttiva
@code{@@include},
n@'e @command{igawk} n@'e @file{igawk.1} sono effettivamente installati.)
@item doc/it/*
File per la traduzione italiana di questo @value{DOCUMENT}, preparata e
contribuita da Antonio Colombo e Marco Curreli.
@item doc/Makefile.in
Il file in input usato durante la procedura di configurazione per
generare l'effettivo @file{Makefile} da usare per creare la documentazione.
@item Makefile.am
@itemx */Makefile.am
File usati dal software GNU Automake per generare
il file @file{Makefile.in} usato da Autoconf e dallo @dfn{script}
@command{configure}.
@item Makefile.in
@itemx aclocal.m4
@itemx bisonfix.awk
@itemx config.guess
@itemx configh.in
@itemx configure.ac
@itemx configure
@itemx custom.h
@itemx depcomp
@itemx install-sh
@itemx missing_d/*
@itemx mkinstalldirs
@itemx m4/*
Questi file e sottodirectory sono usati per configurare e compilare
@command{gawk} per vari sistemi Unix. L'uso di molti tra questi file @`e spiegato
@iftex
nella
@end iftex
@ifnottex
in
@end ifnottex
@ref{Installazione Unix}. I rimanenti hanno una funzione di supporto
per l'infrastruttura.
@item po/*
La directory @file{po} contiene la traduzione in varie lingue
dei messaggi emessi da @command{gawk}.
@item awklib/extract.awk
@itemx awklib/Makefile.am
@itemx awklib/Makefile.in
@itemx awklib/eg/*
La directory @file{awklib} contiene una copia di @file{extract.awk}
(@pxref{Programma extract}),
che pu@`o essere usato per estrarre i programmi di esempio dal file sorgente
Texinfo di questo @value{DOCUMENT}. Contiene anche un file
@file{Makefile.in}, che
@command{configure} usa per generare un @file{Makefile}.
@file{Makefile.am} @`e usato da GNU Automake per creare @file{Makefile.in}.
Le funzioni di libreria descritte
@iftex
nel
@end iftex
@ifnottex
in
@end ifnottex
@ref{Funzioni di libreria},
sono incluse come file pronti per l'uso nella distribuzione @command{gawk}.
Essi sono installati come parte della procedura di installazione.
I rimanenti programmi contenuti in questo @value{DOCUMENT} sono disponibili
nelle appropriate sottodirectory di @file{awklib/eg}.
@item extension/*
Il codice sorgente, le pagine di manuale, e i file di infrastruttura per
gli esempi di estensione incluse con @command{gawk}.
@xref{Estensioni dinamiche}, per ulteriori dettagli.
@item extras/*
Ulteriori file, non-essenziali. Al momento, questa directory contiene
alcuni file da eseguire al momento di iniziare una sessione,
da installare nella directory @file{/etc/profile.d}
per essere di aiuto nella gestione delle variabili d'ambiente
@env{AWKPATH} e @env{AWKLIBPATH}.
@xref{File da usare a inizio sessione}, per ulteriori informazioni.
@item posix/*
File necessari per compilare @command{gawk} su sistemi conformi allo
standard POSIX.
@item pc/*
File necessari per compilare @command{gawk} sotto MS-Windows
(@pxref{Installazione su PC} per i dettagli).
@item vms/*
File necessari per compilare @command{gawk} sotto Vax/VMS e OpenVMS
(@pxref{Installazione su VMS} per i dettagli).
@item test/*
Una serie di test per
@command{gawk}. Si pu@`o usare @samp{make check} dalla directory principale
di @command{gawk} per provare se la serie di test funziona con la
versione in uso di @command{gawk}.
Se @command{gawk} supera senza errori @samp{make check}, si pu@`o essere
sicuri che sia stato installato e configurato correttamente su un dato
sistema.
@end table
@node Installazione Unix
@appendixsec Compilare e installare @command{gawk} su sistemi di tipo Unix
Normalmente, si pu@`o compilare e installare @command{gawk} immettendo
solo un paio di comandi. Comunque, se si ci si trova in un sistema
insolito, pu@`o essere necessario
dover configurare @command{gawk} per quel dato sistema.
@menu
* Installazione veloce:: Compilare @command{gawk} sotto Unix.
* File da usare a inizio sessione:: Funzioni di personalizzazione della
shell.
* Ulteriori opzioni di configurazione:: Altre opzioni utilizzabili in fase di
compilazione.
* Filosofia della configurazione:: Come si suppone che tutto funzioni.
@end menu
@node Installazione veloce
@appendixsubsec Compilare @command{gawk} per sistemi di tipo Unix
Questi normali passi di installazione dovrebbero essere sufficienti in
tutti i moderni sistemi in commercio derivati da Unix, ossia
GNU/Linux, sistemi basati su BSD, e l'ambiente Cygwin sotto MS-Windows.
Dopo aver estratto la distribuzione di @command{gawk}, posizionarsi con
@command{cd} nella directory
@file{gawk-@value{VERSION}.@value{PATCHLEVEL}}. Come per la maggior parte dei
programmi GNU, occorre configurare @command{gawk} per il sistema in uso,
eseguendo il programma @command{configure}. Questo programma @`e
uno @dfn{script} della shell Bourne, che @`e stato generato automaticamente
usando il comando GNU Autoconf.
@ifnotinfo
(Il software Autoconf @`e
descritto in dettaglio in
@cite{Autoconf --- Generating Automatic Configuration Scripts},
che pu@`o essere trovato in rete sul sito
@uref{https://www.gnu.org/software/autoconf/manual/index.html,
della Free Software Foundation}.)
@end ifnotinfo
@ifinfo
(Il software Autoconf @`e descritto in dettaglio a partire da
@inforef{Top, , Autoconf, autoconf,Autoconf --- Generating Automatic Configuration Scripts}.)
@end ifinfo
Per configurare @command{gawk} basta eseguire @command{configure}:
@example
sh ./configure
@end example
Questo produce i file @file{Makefile} e @file{config.h} adatti al sistema
in uso.
Il file @file{config.h} descrive varie situazioni relative al sistema in uso.
@`E possibile modificare il @file{Makefile} per
cambiare la variabile @code{CFLAGS}, che controlla
le opzioni di riga di comando da passare al compilatore C (come i livelli
di ottimizzazione o la richiesta di generare informazioni per il @dfn{debug}).
In alternativa, si possono specificare dei valori a piacere per
molte delle variabili di @command{make} sulla riga di comando,
come @code{CC} e @code{CFLAGS}, quando
si chiama il programma
@command{configure}:
@example
CC=cc CFLAGS=-g sh ./configure
@end example
@noindent
Si veda il file @file{INSTALL} nella distribuzione di @command{gawk} per
tutti i dettagli.
Dopo aver eseguito @command{configure} ed eventualmente modificato
@file{Makefile},
va dato il comando:
@example
make
@end example
@noindent
Poco dopo, si dovrebbe avere a disposizione una versione eseguibile
di @command{gawk}.
Questo @`e tutto!
Per verificare se @command{gawk} funziona correttamente,
va dato il comando @samp{make check}. Tutti i test dovrebbero terminare con
successo.
Se questi passi non producono il risultato desiderato, o se qualche
test fallisce, controllare i file nella directory @file{README_d}
per determinare se quello che @`e capitato @`e un problema noto.
Se il problema capitato non @`e descritto l@`{@dotless{i}},
inviare una segnalazione di @dfn{bug} (@pxref{Bug}).
Naturalmente, dopo aver compilato @command{gawk}, verosimilmente
andr@`a installato. Per fare ci@`o, occorre eseguire il comando
@samp{make install}, disponendo delle autorizzazioni necessarie.
Come acquisirle varia da sistema a sistema, ma su molti sistemi si pu@`o
usare il comando @command{sudo} per ottenerle. Il comando da immettere
diventa in questo caso @samp{sudo make install}. @`E probabile che sia
necessario fornire una password, ed essere stati messi nella lista degli
utenti che possono utilizzare il comando @command{sudo}.
@node File da usare a inizio sessione
@appendixsubsec File di inizializzazione della shell
La distribuzione contiene i file da usare a inizio sessione
@file{gawk.sh} e
@file{gawk.csh}, che contengono funzioni che possono essere di aiuto
nel gestire le variabili d'ambiente
@env{AWKPATH} e @env{AWKLIBPATH}.
Su un sistema Fedora GNU/Linux, questi file dovrebbero essere installati
nella directory @file{/etc/profile.d};
su altre piattaforme, la posizione corretta pu@`o essere differente.
@table @command
@cindex @command{gawkpath_default} (funzione della shell)
@cindex funzione della shell @subentry @command{gawkpath_default}
@item gawkpath_default
Ripristina la variabile d'ambiente @env{AWKPATH} al suo valore di default.
@cindex @command{gawkpath_prepend} (funzione della shell)
@cindex funzione della shell @subentry @command{gawkpath_prepend}
@item gawkpath_prepend
Aggiunge l'argomento all'inizio della variabile d'ambiente @env{AWKPATH}.
@cindex @command{gawkpath_append} (funzione della shell)
@cindex funzione della shell @subentry @command{gawkpath_append}
@item gawkpath_append
Aggiunge l'argomento alla fine della variabile d'ambiente @env{AWKPATH}.
@cindex @command{gawklibpath_default} (funzione della shell)
@cindex funzione della shell @subentry @command{gawklibpath_default}
@item gawklibpath_default
Reimposta la variabile d'ambiente @env{AWKLIBPATH} al suo valore di default.
@cindex @command{gawklibpath_prepend} (funzione della shell)
@cindex funzione della shell @subentry @command{gawklibpath_prepend}
@item gawklibpath_prepend
Aggiunge l'argomento all'inizio della variabile d'ambiente
@env{AWKLIBPATH}.
@cindex @command{gawklibpath_append} (funzione della shell)
@cindex funzione della shell @subentry @command{gawklibpath_append}
@item gawklibpath_append
Aggiunge l'argomento alla fine della variabile d'ambiente
@env{AWKLIBPATH}.
@end table
@node Ulteriori opzioni di configurazione
@appendixsubsec Ulteriori opzioni di configurazione
@cindex @command{gawk} @subentry configurazione @subentry opzioni di
@cindex configurazione di @command{gawk} @subentry opzioni di
@cindex opzioni di configurazione @subentry di @command{gawk}
Ci sono parecchie altre opzioni che si possono utilizzare sulla riga
di comando di @command{configure}
quando si compila @command{gawk} a partire dai sorgenti, tra cui:
@table @code
@cindex @option{--disable-extensions} (opzione di configurazione)
@cindex opzioni di configurazione @subentry @option{--disable-extensions}
@item --disable-extensions
Disabilita il meccanismo delle estensioni all'interno di
@command{gawk}. Specificando quest'opzione non @`e possibile
utilizzare estensioni dinamiche. Inoltre si disabilita la
configurazione e la generazione delle estensioni di esempio nella
directory @file{extension}.
Questo @`e utile quando si genera @command{gawk} per essere eseguito
su un'altra piattaforma.
L'azione di default @`e di controllare dinamicamente se le estensioni
possono essere configurate e compilate.
@cindex @option{--disable-lint} (opzione di configurazione)
@cindex opzioni di configurazione @subentry @code{--disable-lint}
@item --disable-lint
Disabilitare i controlli @dfn{lint} all'interno di @command{gawk}. Le opzioni
@option{--lint} e @option{--lint-old}
(@pxref{Opzioni})
sono accettate, ma non fanno nulla, e non emettono alcun messaggio di
avvertimento.
Analogamente, se si imposta la variabile @code{LINT}
(@pxref{Variabili modificabili dall'utente})
questa non ha alcun effetto sul programma @command{awk} in esecuzione.
Se si specifica l'opzione del compilatore GNU Compiler Collection (GCC) che
elimina il codice non eseguito, quest'opzione riduce di quasi
23K byte la dimensione del programma eseguibile @command{gawk}
su sistemi GNU/Linux x86_64. I risultati su altri sistemi e con
altri compilatori sono probabilmente diversi.
L'uso di questa opzione pu@`o apportare qualche piccolo miglioramento nei
tempi di esecuzione di un programma.
@quotation ATTENZIONE
Se si usa quest'opzione alcuni dei test di funzionalit@`a non avranno successo.
Quest'opzione potr@`a essere rimossa in futuro.
@end quotation
@cindex @option{--disable-mpfr} (opzione di configurazione)
@cindex opzioni di configurazione @subentry @code{--disable-mpfr}
@item --disable-mpfr
Non effettuare il controllo delle librerie MPFR e GMP.
Ci@`o pu@`o essere utile principalmente per gli sviluppatori,
per assicurarsi che tutto funzioni regolarmente nel caso in cui
il supporto MPFR non sia disponibile.
@cindex @option{--disable-nls} (opzione di configurazione)
@cindex opzioni di configurazione @subentry @code{--disable-nls}
@item --disable-nls
Non attivare la traduzione automatica dei messaggi.
Ci@`o normalmente non @`e consigliabile, ma pu@`o apportare qualche lieve
miglioramento nei tempi di esecuzione di un programma.
@cindex @option{--enable-versioned-extension-dir} (opzione di configurazione)
@cindex opzioni di configurazione @subentry @code{--enable-versioned-extension-dir}
@item --enable-versioned-extension-dir
Usare una directory con l'indicazione della versione per le estensioni.
Il nome della directory conterr@`a la versione principale e quella
secondaria dell'API. Ci@`o consente la presenza, nello stesso sistema,
di pi@`u di una versione dell'API, senza che fra di esse sorgano dei
conflitti legati all'una o all'altra versione.
@end table
Si usi il comando @samp{./configure --help} per ottenere la lista completa
delle opzioni disponibili in @command{configure}.
@node Filosofia della configurazione
@appendixsubsec Il processo di configurazione
@cindex @command{gawk} @subentry configurazione di
@cindex configurazione di @command{gawk}
Questa @value{SECTION} interessa solo a chi abbia un minimo di familiarit@`a con
il linguaggio C e con i sistemi operativi di tipo Unix.
Il codice sorgente di @command{gawk}, in generale, cerca di aderire, nei limiti
del possibile, a degli standard formali. Ci@`o significa che @command{gawk} usa
routine di libreria che sono specificate nello standard ISO C e nello standard
POSIX per le interfacce dei sistemi operativi. Il codice sorgente di
@command{gawk} richiede l'uso di un compilatore ISO C (standard 1990).
Molti sistemi Unix non aderiscono completamente n@'e allo standard ISO n@'e a
quello POSIX. La sottodirectory @file{missing_d} nella distribuzione di
@command{gawk} contiene delle versioni sostitutive per quelle funzioni che pi@`u
frequentemente risultano essere non disponibili.
Il file @file{config.h} creato da @command{configure} contiene definizioni che
elencano funzionalit@`a del particolare sistema operativo nel quale si tenta di
compilare @command{gawk}. Le tre cose descritte da questo file sono: quali
file di intestazione sono disponibili, in modo da poterli includere correttamente,
quali funzioni (presumibilmente) standard sono realmente disponibili nelle
librerie C, e varie informazioni assortite riguardo al sistema operativo
corrente. Per esempio, pu@`o non esserci l'elemento @code{st_blksize} nella
struttura @code{stat}. In questo caso, @samp{HAVE_STRUCT_STAT_ST_BLKSIZE} @`e
indefinito.
@cindex @code{custom.h} (file)
@`E possible che il compilatore C del sistema in uso "tragga in inganno"
@command{configure}. Pu@`o succedere nel caso in cui non viene restituito
un errore se una funzione di libreria non @`e disponibile. Per superare questo
problema, si pu@`o modificare il file @file{custom.h}. Basta usare una direttiva
@samp{#ifdef} appropriata per il sistema corrente, e definire, tramite
@code{#define}, tutte le costanti che @command{configure} avrebbe dovuto
definire, ma non @`e riuscito a farlo, oppure, usando @code{#undef} annullare le
costanti che @command{configure} ha definito, ma non avrebbe dovuto farlo. Il
file @file{custom.h} @`e automaticamente incluso dal file @file{config.h}.
@`E anche possibile che il programma @command{configure} generato da Autoconf non
funzioni in un dato sistema per una ragione differente. Se c'@`e un problema, si
tenga presente che il file @file{configure.ac} @`e quello preso in input da
Autoconf. @`E possibile modificare questo file e generare una nuova versione di
@command{configure} che funzioni sul sistema corrente (@pxref{Bug} per
informazioni su come segnalare problemi nella configurazione di
@command{gawk}). Lo stesso meccanismo si pu@`o usare per inviare aggiornamenti
al file @file{configure.ac} e/o a @file{custom.h}.
@node Installazione non-Unix
@appendixsec Installazione su altri Sistemi Operativi
Questa @value{SECTION} descrive come installare @command{gawk} su
vari sistemi non-Unix.
@menu
* Installazione su PC:: Installare e compilare @command{gawk}
su Microsoft Windows.
* Installazione su VMS:: Installare @command{gawk} su VMS.
@end menu
@node Installazione su PC
@appendixsubsec Installazione su MS-Windows
@cindex PC @subentry @command{gawk} su sistemi operativi
@cindex sistemi operativi @subentry per PC @subentry @command{gawk} su
@cindex installare @command{gawk} @subentry su sistemi operativi per PC
Questa @value{SECTION} tratta dell'installazione e uso di @command{gawk}
su macchine con architettura Intel che eseguono qualsiasi versione di
MS-Windows.
In questa @value{SECTION}, il termine ``Windows32''
si riferisce a una qualsiasi versione di Microsoft Windows
95/98/ME/NT/2000/XP/Vista/7/8/10.
Si veda anche il file @file{README_d/README.pc} nella distribuzione.
@menu
* Installazione binaria su PC:: Installare una distribuzione pronta
all'uso.
* Compilazione su PC:: Compilare @command{gawk} per Windows32.
* Uso su PC:: Eseguire @command{gawk} su Windows32.
* Cygwin:: Compilare ed eseguire @command{gawk}
per Cygwin.
* MSYS:: Usare @command{gawk} nell'ambiente MSYS.
@end menu
@node Installazione binaria su PC
@appendixsubsubsec Installare una distribuzione predisposta per sistemi MS-Windows
@cindex installare @command{gawk} @subentry su MS-Windows
La sola distribuzione binaria predisposta supportata per i sistem MS-Windows
@`e quella messa a disposizione da Eli Zaretskii
@uref{https://sourceforge.net/projects/ezwinports/, progetto ``ezwinports''}.
Si parta da l@`{@dotless{i}} per installare il comando @command{gawk} precompilato.
@node Compilazione su PC
@appendixsubsubsec Compilare @command{gawk} per sistemi operativi di PC
@command{gawk} pu@`o essere compilato per Windows32, usando MinGW
(per Windows32).
Il file @file{README_d/README.pc} nella distribuzione @command{gawk}
contiene ulteriori annotazioni, e il file @file{pc/Makefile} contiene
informazioni importanti sulle opzioni di compilazione.
@cindex compilare @command{gawk} @subentry per MS-Windows
Per compilare @command{gawk} per Windows32, occorre copiare i file
dalla directory @file{pc} (@emph{tranne} il file @file{ChangeLog}) alla
directory che contiene il resto dei sorgenti di @command{gawk}, e quindi
chiamare @command{make}, specificando il nome appropriato di obiettivo come
argomento, per generare @command{gawk}. Il @file{Makefile} copiato dalla
directory @file{pc} contiene una sezione di configurazione con commenti, e pu@`o
essere necessario modificarlo perch@'e funzioni con il programma di utilit@`a
@command{make} corrente.
Il @file{Makefile} contiene un certo numero di alternative, che permettono di
generare @command{gawk} per diverse
versioni MS-DOS e Windows32. Se il comando @command{make} @`e richiamato senza
specificare alcun argomento viene stampata una lista delle alternative
disponibili. Per esempio,
per generare un codice binario di @command{gawk} nativo per MS-Windows
usando gli strumenti MinGW, scrivere @samp{make mingw32}.
@node Uso su PC
@appendixsubsubsec Usare @command{gawk} su sistemi operativi PC
@cindex PC @subentry @command{gawk} su sistemi operativi per
@cindex sistemi operativi @subentry per PC @subentry @command{gawk} su
Sotto MS-Windows, l'ambiente MinGW consente di usare
sia l'operatore @samp{|&} che le operazioni su rete TCP/IP
(@pxref{Reti TCP/IP}).
L'ambiente DJGPP non consente di usare @samp{|&}.
@cindex percorso di ricerca
@cindex percorso di ricerca @subentry per file sorgente
@cindex @command{gawk} @subentry versione MS-Windows di
@cindex @code{;} (punto e virgola) @subentry @env{AWKPATH} variabile e
@cindex punto e virgola (@code{;}) @subentry @env{AWKPATH} variabile e
@cindex @env{AWKPATH} (variabile d'ambiente)
@cindex variabili d'ambiente @subentry @env{AWKPATH}
Le versioni MS-Windows di @command{gawk} ricercano i file di
programma come descritto in @ref{AWKPATH (Variabile)}. Comunque, gli elementi
della variabile @env{AWKPATH} sono separati tra di loro da un punto e virgola
(anzich@'e da due punti (@code{:})).
Se @env{AWKPATH} @`e non impostata o ha per valore la stringa nulla, il percorso
di ricerca di default @`e @samp{@w{.;c:/lib/awk;c:/gnu/lib/awk}}.
@cindex estensioni comuni @subentry variabile @code{BINMODE}
@cindex differenze tra @command{awk} e @command{gawk} @subentry variabile @code{BINMODE}
@cindex @code{BINMODE} (variabile)
@cindex variabile @subentry @code{BINMODE}
Sotto MS-Windows,
@command{gawk} (come molti altri programmi di trattamento testi) converte
automaticamente la stringa di fine riga @samp{\r\n} in @samp{\n} leggendo dall'input
e @samp{\n} in @samp{\r\n} scrivendo sull'output.
La variabile speciale @code{BINMODE} @value{COMMONEXT} permette di controllare
come avvengono queste conversioni, ed @`e interpretata come segue:
@itemize @value{BULLET}
@item
Se @code{BINMODE} @`e @code{"r"} o uno,
la modalit@`a binaria @`e impostata
in lettura (cio@`e, nessuna conversione in lettura).
@item
Se @code{BINMODE} @`e @code{"w"} o due,
la modalit@`a binaria @`e impostata
in scrittura (cio@`e, nessuna conversione in scrittura).
@item
Se @code{BINMODE} @`e @code{"rw"} o @code{"wr"} o tre,
la modalit@`a binaria @`e impostata sia in lettura che in scrittura.
@item
@code{BINMODE=@var{stringa-non-nulla}} equivale a specificare
@samp{BINMODE=3} (cio@`e, nessuna conversione in
lettura e scrittura). Tuttavia, @command{gawk} emette un messaggio di
avviso se la stringa non @`e @code{"rw"} o @code{"wr"}.
@end itemize
@noindent
La modalit@`a di trattamento dello standard input e standard output sono
impostate una volta sola
(dopo aver letto la riga di comando, ma prima di iniziare a elaborare
qualsiasi programma @command{awk}).
L'impostazione di @code{BINMODE} per standard input o
standard output va fatta usando
un'appropriata opzione @samp{-v BINMODE=@var{N}} sulla riga di comando.
@code{BINMODE} @`e impostato nel momento in cui un file o @dfn{pipe} @`e aperto
e non pu@`o essere cambiato in corso di elaborazione.
Su sistemi compatibili con POSIX, il valore di queta variabile non ha
alcun effetto. Pertanto, se si pensa che un dato programma sar@`a eseguito
su parecchi sistemi differenti, e che sia necessario usare
@code{BINMODE}, @`e possibile impostarlo semplicemente (nel programma
o sulla riga di comando) incondizionatamente, senza preoccuparsi del
sistema operativo sotto il quale il programma viene eseguito.
Il nome @code{BINMODE} @`e stato scelto in analogia con @command{mawk}
(@pxref{Altre versioni}).
@command{mawk} e @command{gawk} gestiscono @code{BINMODE} in maniera simile;
tuttavia, @command{mawk} prevede un'opzione @samp{-W BINMODE=@var{N}} e una
variabile d'ambiente che pu@`o impostare @code{BINMODE}, @code{RS}, e @code{ORS}.
I file @file{binmode[1-3].awk} (nella directory @file{gnu/lib/awk} in alcune
delle distribuzioni binarie gi@`a predisposte) sono stati inclusi per rendere
disponibile l'opzione di @command{mawk} @samp{-W BINMODE=@var{N}}. Questi
possono essere modificati o ignorati; in particolare, quale sia l'impostazione
di @code{RS} che d@`a meno ``sorprese'' rimane una questione aperta.
@command{mawk} usa @samp{RS = "\r\n"} se si imposta la modalit@`a binaria in
lettura, il che @`e appropriato per file che abbiano i caratteri di fine riga in
stile MS-DOS.
Per chiarire, gli esempi seguenti impostano la modalit@`a binaria in
scrittura per lo standard output e altri file, e impostano @code{ORS} in modo
da ottenere la fine riga ``normale'' in stile MS-DOS:
@example
gawk -v BINMODE=2 -v ORS="\r\n" @dots{}
@end example
@noindent
o:
@example
gawk -v BINMODE=w -f binmode2.awk @dots{}
@end example
@noindent
Questi comandi danno lo stesso risultato dell'opzione
@samp{-W BINMODE=2} in @command{mawk}.
Quanto segue modifica il separatore di record a @code{"\r\n"} e imposta
la modalit@`a binaria in lettura, senza modificare le letture da standard input:
@example
gawk -v RS="\r\n" -e "BEGIN @{ BINMODE = 1 @}" @dots{}
@end example
@noindent
o:
@example
gawk -f binmode1.awk @dots{}
@end example
@noindent
Usando i caratteri di protezione appropriati, nel primo
esempio l'impostazione di @code{RS} pu@`o essere spostata in una regola
@code{BEGIN}.
@node Cygwin
@appendixsubsubsec Usare @command{gawk} in ambiente Cygwin
@cindex compilare @command{gawk} @subentry per Cygwin
@cindex Cygwin @subentry compilare @command{gawk} per
@command{gawk} pu@`o essere compilato e usato ``cos@`{@dotless{i}} com'@`e'' sotto MS-Windows se
si opera all'interno dell'ambiente @uref{http://www.cygwin.com, Cygwin}.
Questo ambiente consente un'eccellente simulazione di GNU/Linux, con l'uso di
Bash, GCC, GNU Make, e altri programmi GNU. La compilazione e l'installazione
per Cygwin @`e la stessa usata nei sistemi di tipo Unix:
@example
tar -xvpzf gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz
cd gawk-@value{VERSION}.@value{PATCHLEVEL}
./configure
make && make check
@end example
In confronto a un sistema GNU/Linux sulla stessa macchina, l'esecuzione
del passo di @samp{configure} sotto Cygwin richiede molto pi@`u tempo.
Tuttavia si conclude regolarmente, e poi @samp{make} procede come ci si
aspetta.
@cindex installare @command{gawk} @subentry su Cygwin
Si pu@`o anche installare @command{gawk} con la procedura di installazione
normalmente usata per tutto il software Cygwin.
In generale, Cygwin fornisce l'ultima versione rilasciata di @command{gawk}.
Le versioni pi@`u recenti di Cygwin aprono tutti i file in modalit@`a binaria.
Ci@`o implica che si dovrebbe usare @samp{RS = "\r?\n"} per riuscire a
gestire file di testo MS-Windows in formato standard, in cui ogni riga
termina con i due caratteri di ritorno a capo e avanzamento riga.
L'ambiente Cygwin consente l'utilizzo sia dell'operatore @samp{|&}
che di reti TCP/IP (@pxref{Reti TCP/IP}).
@node MSYS
@appendixsubsubsec Usare @command{gawk} in ambiente MSYS
Nell'ambiente MSYS sotto MS-Windows, @command{gawk} automaticamente usa la
modalit@`a binaria per leggere e scrivere file. Non @`e quindi necessario usare la
variabile @code{BINMODE}.
Questo pu@`o causare problemi con altri componenti di tipo Unix che sono stati
resi disponibile in MS-Windows, che si aspettano che @command{gawk} faccia
automaticamente la conversione di @code{"\r\n"}, mentre cos@`{@dotless{i}} non @`e.
In ambiente MSYS2, la compilazione usando i comandi classici
@samp{./configure && make} funziona senza necessitare di alcuna modifica.
@node Installazione su VMS
@appendixsubsec Compilare e installare @command{gawk} su Vax/VMS e OpenVMS
@c based on material from Pat Rankin
@c now rankin@pactechdata.com
@c now r.pat.rankin@gmail.com
@cindex @command{gawk} @subentry versione VMS di
@cindex installare @command{gawk} @subentry su VMS
@cindex VMS @subentry installare @command{gawk} su
Questa @value{SUBSECTION} descrive come compilare e installare @command{gawk}
sotto VMS. Il termine classico ``VMS'' @`e usato qui anche per designare
OpenVMS.
@menu
* Compilazione su VMS:: Come compilare @command{gawk} su VMS.
* Estensioni dinamiche su VMS:: Compilare estensioni dinamiche
di @command{gawk} su VMS.
* Dettagli installazione su VMS:: Come installare @command{gawk} su VMS.
* Esecuzione su VMS:: Come eseguire @command{gawk} su VMS.
* GNV su VMS:: Il progetto VMS GNV.
* Vecchio Gawk su VMS:: Una versione non aggiornata arriva
con alcune versioni di VMS.
@end menu
@node Compilazione su VMS
@appendixsubsubsec Compilare @command{gawk} su VMS
@cindex compilare @command{gawk} @subentry per VMS
@cindex VMS @subentry compilare @command{gawk} per
Per compilare @command{gawk} sotto VMS, esiste una procedura di comandi
@code{DCL} che esegue tutti i comandi @code{CC} e @code{LINK} necessari. C'@`e
anche un @file{Makefile} da usare con i programmi di utilit@`a @code{MMS} e
@code{MMK}. A partire della directory che contiene i file sorgente, si usi:
@example
$ @kbd{@@[.vms]vmsbuild.com}
@end example
@noindent
o:
@example
$ @kbd{MMS/DESCRIPTION=[.vms]descrip.mms gawk}
@end example
@noindent
o:
@example
$ @kbd{MMK/DESCRIPTION=[.vms]descrip.mms gawk}
@end example
Il comando @command{MMK} @`e un quasi-clone, a codice aperto e gratuito, di
@command{MMS}, che gestisce in maniera migliore i volumi ODS-5 con @value{FNS}
a caratteri maiuscoli e minuscoli. @command{MMK} @`e disponibile da
@uref{https://github.com/endlesssoftware/mmk}.
Avendo a che fare con volumi ODS-5 e con l'analisi sintattica estesa abilitata,
il nome del parametro che specifica l'obiettivo pu@`o dover essere scritto
digitando esattamente le lettere maiuscole e minuscole.
@command{gawk} @`e stato testato sotto VAX/VMS 7.3 e Alpha/VMS 7.3-1 usando il
compilatore Compaq C V6.4, e sotto Alpha/VMS 7.3, Alpha/VMS 7.3-2, e IA64/VMS
8.3. Le compilazioni pi@`u recenti hanno usato il compilatore HP C V7.3 su Alpha
VMS 8.3 e su VMS 8.4, sia Alpha che IA64, hanno usato il compilatore HP C
7.3.@footnote{L'architettura IA64 @`e anche nota come ``Itanium''.}
@xref{GNV su VMS} per informazioni su come compilare
@command{gawk} come un kit PCSI compatible con il prodotto GNV.
@node Estensioni dinamiche su VMS
@appendixsubsubsec Compilare estensioni dinamiche di @command{gawk} in VMS
Le estensioni che sono state rese disponibile su VMS possono essere
costruite dando uno dei comandi seguenti:
@example
$ @kbd{MMS/DESCRIPTION=[.vms]descrip.mms extensions}
@end example
@noindent
o:
@example
$ @kbd{MMK/DESCRIPTION=[.vms]descrip.mms extensions}
@end example
@command{gawk} usa @code{AWKLIBPATH} come una variabile d'ambiente
oppure come un nome logico per trovare le estensioni dinamiche.
Le estensioni dinamiche devono essere compilate con le stesse opzioni del
compilatore usate per compilare @command{gawk} riguardanti numeri in virgola
mobile, dimensione dei puntatori e trattamento dei nomi simbolici. I computer
con architettura Alpha e Itanium dovrebbero usare i numeri in virgola mobile
col formato IEEE. La dimensione dei puntatori @`e 32 bit, e il trattamento dei nomi
simbolici dovrebbe richiedere il rispetto esatto di maiuscole/minuscole, con le
abbreviazioni CRC per simboli pi@`u lunghi di 32 bit.
Per Alpha e Itanium:
@example
/nome=(as_is,short)
/float=ieee/ieee_mode=denorm_results
@end example
Per VAX:
@example
/nome=(as_is,short)
@end example
Le macro da usare al momento della compilazione devono essere definite prima di
includere il primo file di intestazione proveniente da VMS, come segue:
@example
#if (__CRTL_VER >= 70200000) && !defined (__VAX)
#define _LARGEFILE 1
#endif
#ifndef __VAX
#ifdef __CRTL_VER
#if __CRTL_VER >= 80200000
#define _USE_STD_STAT 1
#endif
#endif
#endif
@end example
Se si scrivono delle estensioni utente da eseguire su VMS, vanno fornite anche
queste definizioni. Il file @file{config.h} creato quando si compila
@command{gawk} su VMS lo fa gi@`a; se invece si usa qualche altro file simile,
occorre ricordarsi di includerlo prima di qualsiasi file di intestazione
proveniente da VMS.
@node Dettagli installazione su VMS
@appendixsubsubsec Installare @command{gawk} su VMS
Per usare @command{gawk}, tutto ci@`o che serve @`e un comando ``esterno'', che @`e
un simbolo @code{DCL} il cui valore inizia col segno del dollaro.
Per esempio:
@example
$ @kbd{GAWK :== $disk1:[gnubin]gawk}
@end example
@noindent
Si sostituisca la posizione corrente di @command{gawk.exe} a
@samp{$disk1:[gnubin]}. Il simbolo dovrebbe essere posto nel file
@file{login.com} di ogni utente che desideri eseguire @command{gawk},
in modo che sia definito ogni volta che l'utente inizia una sessione.
Alternativamente, il simbolo pu@`o essere messo nella procedura di sistema
@file{sylogin.com},
in modo da permettere a tutti gli utenti di eseguire @command{gawk}.
Se @command{gawk} @`e stato installato da un kit PCSI nell'albero di
directory @file{GNV$GNU:}, il programma avr@`a come nome
@file{GNV$GNU:[bin]gnv$gawk.exe}, e il file di aiuto sar@`a chiamato
@file{GNV$GNU:[vms_help]gawk.hlp}.
Il kit PCSI installa anche un file @file{GNV$GNU:[vms_bin]gawk_verb.cld}
che pu@`o essere usato per aggiungere @command{gawk} e @command{awk}
alla lista dei comandi DCL.
Per farlo solo nella sessione corrente si pu@`o usare:
@example
$ @kbd{set command gnv$gnu:[vms_bin]gawk_verb.cld}
@end example
Oppure il sistemista VMS pu@`o usare @file{GNV$GNU:[vms_bin]gawk_verb.cld} per
aggiungere @command{gawk} e @command{awk} alla tabella @samp{DCLTABLES}
valida per tutto il sistema.
La sintassi DCL @`e documentata nel file @file{gawk.hlp}.
In alternativa, l'elemento @file{gawk.hlp} pu@`o essere caricato in una
libreria di aiuto VMS:
@example
$ @kbd{LIBRARY/HELP sys$help:helplib [.vms]gawk.hlp}
@end example
@noindent
(Una libreria specifica dell'installazione potrebbe venir usata invece
della libreria standard VMS library @samp{HELPLIB}.) Dopo aver installato
il testo di aiuto, il comando:
@example
$ @kbd{HELP GAWK}
@end example
@noindent
fornisce informazioni sia sull'implementazione di @command{gawk}
sia sul linguaggio di programmazione @command{awk}.
Il nome logico @samp{AWK_LIBRARY} pu@`o designare una posizione di default per i
file di programma @command{awk}. Riguardo all'opzione @option{-f}, se il
@value{FN} specificato non contiene un dispositivo o un percorso di directory,
@command{gawk} cerca dapprima nella directory corrente, poi nella directory
specificata dalla traduzione di @samp{AWK_LIBRARY} se il file non @`e stato
trovato. Se, dopo aver cercato in entrambe queste directory, il file non @`e
ancora stato trovato, @command{gawk} appone il suffisso @samp{.awk} al
@value{FN} e ritenta la ricerca del file. Se @samp{AWK_LIBRARY} non @`e
definita, si usa per essa il valore di default @samp{SYS$LIBRARY:}.
@node Esecuzione su VMS
@appendixsubsubsec Eseguire @command{gawk} su VMS
L'elaborazione della riga di comando e le convenzioni per proteggere i
caratteri sono significativamente differenti in VMS, e quindi gli esempi
presenti in questo @value{DOCUMENT} o provenienti da altre fonti necessitano
piccole modifiche. Le modifiche, tuttavia, @emph{sono} veramente piccole, e
tutti i programmi @command{awk} dovrebbero funzionare correttamente.
Ecco un paio di semplici test:
@example
$ @kbd{gawk -- "BEGIN @{print ""Hello, World!""@}"}
$ @kbd{gawk -"W" version}
! ma anche -"W version" o "-W version"
@end example
@noindent
Si noti che il testo con caratteri maiuscoli e misti maiuscoli/minuscoli
dev'essere incluso tra doppi apici.
La versione VMS di @command{gawk} comprende un'interfaccia in stile @code{DCL},
oltre a quella originale, di tipo shell (si veda il file di aiuto per ulteriori
dettagli). Un effetto indesiderato della duplice analisi della riga
di comando @`e che se c'@`e solo un unico parametro (come nel programma con le
righe contenenti doppi apici), il comando diviene ambiguo. Per evitare questo
inconveniente, il flag, normalmente non necessario, @option{--} @`e necessario
per forzare un esame dei parametri in stile Unix, piuttosto che nella modalit@`a
@code{DCL}. Se qualsiasi altra opzione preceduta dal segno @option{-} (o pi@`u
parametri, per esempio, pi@`u @value{DF} in input) @`e presente, non c'@`e ambiguit@`a,
e l'opzione @option{--} pu@`o essere omessa.
@cindex codice di ritorno @subentry di @command{gawk} @subentry in VMS
@cindex @code{exit} (istruzione) @subentry codice di ritorno di @command{gawk}, in VMS
Il valore di @code{exit} @`e un valore in stile Unix e viene trasformato in
un codice di ritorno VMS all'uscita del programma.
I bit di severit@`a di VMS saranno impostati a partire dal valore dell'istruzione
@code{exit}. Un errore grave @`e indicato da 1, e VMS imposta la condizione
@code{ERROR}. Un errore fatale @`e indicato da 2, e VMS imposta la condizione
@code{FATAL}. Ogni altro valore imposta la condizione @code{SUCCESS}. Il
valore d'uscita @`e codificato per aderire agli standard di codifica VMS e avr@`a
un @code{C_FACILITY_NO} di @code{0x350000} con il codice costante @code{0xA000}
aggiunto al numero spostato a sinistra di 3 bit per far posto al codice di
severit@`a.
Per estrarre il codice reale di ritorno dell'istruzione @code{exit}
di @command{gawk} dalla condizione impostata da VMS, si usi:
@example
unix_status = (vms_status .and. %x7f8) / 8
@end example
@noindent
Un programma C che usa @code{exec()} per chiamare @command{gawk}
ricever@`a il valore originale della exit in stile Unix.
Precedenti versioni di @command{gawk} per VMS consideravano un
codice di ritorno a Unix di 0 come 1, un errore come 2,
un errore fatale come 4, e tutti
gli altri valori erano restituiti immodificati. Questa era una violazione
rispetto alle specifiche di codifica delle condizioni di uscita di VMS.
@cindex numeri @subentry in virgola mobile @subentry VAX/VMS
@cindex VAX/VMS @subentry numeri in virgola mobile,
L'aritmetica in virgola mobile VAX/VMS usa un arrotondamento statistico.
@xref{Funzione round}.
VMS restituisce data e ora in formato GMT, a meno che non siano stati impostati
i nomi logici @code{SYS$TIMEZONE_RULE} o @code{TZ}. Precedenti versioni di
VMS, come VAX/VMS 7.3, non impostano questi nomi logici.
@c @cindex directory search
@c @cindex path, search
@cindex percorso di ricerca @subentry per file sorgente
Il percorso di ricerca di default, nella ricerca dei file di programma per
@command{awk} specificati dall'opzione @option{-f}, @`e
@code{"SYS$DISK:[],AWK_LIBRARY:"}. Il nome logico @env{AWKPATH} pu@`o essere
usato per sostituire questo di default. Il formato di @env{AWKPATH} @`e una lista
di directory, separate da virgola. Nel definirla, il valore dovrebbe essere
incluso tra doppi apici, in modo che consenta una sola traduzione, e non una
lista di ricerca multitraduzione @code{RMS}.
@cindex ridirezione in VMS
Questa restrizione vale anche se si esegue @command{gawk} sotto GNV,
in quanto la ridirezione @`e sempre verso un comando DCL.
Se si ridirigono dati verso un comando o un programma di utilit@`a VMS,
l'implementazione corrente richiede la creazione di un comando VMS esterno che
esegua un file di comandi, prima di invocare @command{gawk}.
(Questa restrizione potrebbe essere rimossa in una futura versione di
@command{gawk} per VMS.)
Senza un tale file di comandi, i dati in input saranno presenti anche
in output, prima dei dati di output veri e propri.
Ci@`o consente la simulazione di comandi POSIX non disponibili in VMS
o l'uso di programmi di utilit@`a GNV.
L'esempio seguente mostra come ridirigere dati da @command{gawk} verso il
comando VMS @command{sort}.
@example
$ sort = "@@device:[dir]vms_gawk_sort.com"
@end example
Il file di comandi deve avere il formato dell'esempio seguente.
La prima riga serve a evitare che i dati in input siano presenti anche
nell'output. Dev'essere nel formato mostrato nell'esempio.
La riga seguente crea un comando esterno che prevale sul comando esterno
superiore, che serve a prevenire una ricorsione infinita di file di comandi.
Il penultimo comando ridirige @code{sys$input} su @code{sys$command},
per poter ottenere i dati che sono ridiretti verso il comando.
L'ultima riga esegue il comando vero e proprio. Dev'essere l'ultimo
comando, perch@'e i dati ridiretti da @command{gawk} saranno letti
quando il file di comandi finisce di essere eseguito.
@example
$!'f$verify(0,0)'
$ sort := sort
$ define/user sys$input sys$command:
$ sort sys$input: sys$output:
@end example
@node GNV su VMS
@appendixsubsubsec Il progetto VMS GNV
Il pacchetto VMS GNV fornisce un ambiente di sviluppo simile
a POSIX tramite una collezione di strumenti @dfn{open source}.
Il @command{gawk} presente nel pacchetto base GNV @`e una vecchia versione.
Attualmente, il progetto GNV @`e in fase di riorganizzazione, con l'obiettivo
di offrire pacchetti PCSI separati per ogni componente.
Si veda @w{@uref{https://sourceforge.net/p/gnv/wiki/InstallingGNVPackages/}.}
La procedura normale per compilare @command{gawk} produce un programma
adatto a essere usato con GNV.
Il file @file{vms/gawk_build_steps.txt} nella distribuzione documenta
la procedura per compilare un pacchetto PCSI compatible con GNV.
@ignore
@c The VMS POSIX product, also known as POSIX for OpenVMS, is long defunct
@c and building gawk for it has not been tested in many years, but these
@c old instructions might still work if anyone is still using it.
@node VMS POSIX
@appendixsubsubsec Compilare e usare @command{gawk} su VMS POSIX
Le istruzioni appena viste vanno ignorate, sebbene @file{vms/gawk.hlp}
dovrebbe ancora essere reso disponibile in una libreria di aiuto.
L'albero del codice sorgente dovrebbe essere scompattato in un sottosistema
contenitore di file, e non nel normale @dfn{filesystem} VMS.
Occorre accertarsi che i due @dfn{script}, @file{configure} e
@file{vms/posix-cc.sh}, siano eseguibile; si usi @samp{chmod +x} per farlo,
se necessario. Poi vanno eseguiti i seguenti due comandi:
@example
psx> @kbd{CC=vms/posix-cc.sh configure}
psx> @kbd{make CC=c89 gawk}
@end example
@noindent
Il primo comando costruisce i file @file{config.h} e @file{Makefile},
a partire da dei modelli, usando uno @dfn{script} per fare s@`{@dotless{i}} che il
compilatore C soddisfi le aspettative di @command{configure}. Il secondo
comando compila e collega @command{gawk} chiamando direttamente il
compilatore C; gli eventuali messaggi di @command{make} che dicono di non
riuscire a ridefinire @code{CC} vanno ignorati. @command{configure}
impiega molto tempo a completarsi, ma in compenso continua a fornire
messaggi che permettono di seguirne l'avanzamento.
Questo @`e stato testato con VAX/VMS V6.2, VMS POSIX V2.0, e DEC C V5.2.
Una volta installato, @command{gawk} funziona come ogni altro programma
di utilit@`a della shell. A differenza della normale versione VMS di
@command{gawk}, neesuna manipolazione speciale della riga di comando @`e
necessaria nell'ambiente VMS POSIX.
@end ignore
@node Vecchio Gawk su VMS
@appendixsubsubsec Vecchia versione di @command{gawk} su sistemi VMS
@c Thanks to "gerard labadie"
Alcune versioni di VMS includono una vecchia versione di @command{gawk}.
Per utilizzarla, occorre definire un simbolo, come segue:
@example
$ @kbd{gawk :== $sys$common:[syshlp.examples.tcpip.snmp]gawk.exe}
@end example
La versione appare essere la @value{PVERSION} 2.15.6, che @`e molto vecchia.
Si raccomanda di compilare e usare la versione corrente.
@node Bug
@appendixsec Segnalazione di problemi e bug
@cindex archeologi
@quotation
@i{Non c'@`e niente di pi@`u pericoloso di un archeologo annoiato.}
@author Douglas Adams, @cite{Guida galattica per autostoppisti}
@end quotation
@c the radio show, not the book. :-)
@cindex debug @subentry @command{gawk} @subentry segnalare bug
@cindex risoluzione di problemi @subentry @command{gawk} @subentry segnalare bug
Se si incontrano problemi con @command{gawk} o se si ritiene di aver trovato un
bug, si raccomanda di segnalarlo agli sviluppatori;
non c'@`e un impegno preciso a intervenire, ma c'@`e una buona possibilit@`a che ci
si sforzi di risolverlo.
@menu
* Indirizzo Bug:: Dove inviare le segnalazioni.
* Usenet:: Dove non inviare le segnalazioni.
* Manutentori:: Manutentori di version non-*nix.
@end menu
@node Indirizzo Bug
@appendixsubsec Segnalare Bug
Prima di segnalare un bug, occorre assicurarsi che sia davvero un bug.
Per prima cosa, si deve verificare se si sta usando l'ultima versione di
@command{gawk}.
Molti bug (di solito difficili da scoprire) sono corretti in ogni nuova
versione, e se la versione in uso @`e piuttosto datata, il problema pu@`o
essere stato risolto nel frattempo.
In secondo luogo, si dovrebbe controllare se, con l'impostare la variabile
@env{LC_ALL} come @code{LC_ALL=C} produce il funzionamento atteso da parte
del programma. Se @`e questo il caso, il problema dipende dalla
localizzazione, e pu@`o non essere veramente un bug.
In terzo luogo, va riletta attentamente la documentazione,
per controllare se dice che @`e possibile
fare quel che si sta tentando di fare. Se non @`e chiaro se sia possibile
fare quella particolare cosa o no, occorre segnalarlo; in questo caso si tratta
di un bug nella documentazione!
Infine, prima
di segnalare un bug o di tentare di risolverlo personalmente, si tenti
di isolarlo preparando un programma @command{awk} il pi@`u piccolo possibile, con
un @value{DF} in input che possa riprodurre il problema. Dopo averlo fatto, si
spedisca il programma e il @value{DF}, insieme a informazioni sul tipo di
sistema Unix in uso, il compilatore usato per compilare @command{gawk}, e i
risultati esatti che @command{gawk} ha prodotto. Inoltre andrebbe specificato
cosa ci si aspettava che il programma facesse; questo @`e di aiuto per decidere
se il problema @`e un problema di documentazione.
@`E importante includere il numero di versione di @command{gawk} in uso.
Questa informazione si pu@`o ottenere con il comando @samp{gawk --version}.
@cindex @code{bug-gawk@@gnu.org} indirizzo per la segnalazione dei bug
@cindex email @subentry indirizzo per segnalare bug @subentry @code{bug-gawk@@gnu.org}
@cindex indirizzo email per segnalare bug @subentry @code{bug-gawk@@gnu.org}
@cindex bug @subentry segnalare @subentry indirizzo email, @code{bug-gawk@@gnu.org}
@cindex segnalare bug @subentry indirizzo email @subentry @code{bug-gawk@@gnu.org}
Una volta pronta la descrizione precisa del problema, si spedisca un messaggio
di posta elettronica a @EMAIL{bug-gawk@@gnu.org,bug-gawk at gnu dot org}.
I manutentori di @command{gawk} sono i destinatari, e riceveranno la
segnalazione di errore. Sebbene sia possibile spedire messaggi direttamente ai
manutentori, @`e preferibile usare l'indirizzo sopra fornito perch@'e quella
mailing list rimane in archivio presso il Progetto GNU. @emph{Tutti i messaggi
devono essere in inglese. @`E questo il solo linguaggio che tutti i manutentori
conoscono.} Inoltre, occorre accertarsi di spedire tutti i messaggi in formato
@emph{testo}, e non (o non soltanto) in formato HTML.
@quotation NOTA
Molte distribuzioni di GNU/Linux e i vari sistemi operativi basati su
BSD hanno un loro proprio canale per segnalare i bug. Se si segnala un
bug usando il canale della distribuzione, una copia del messaggio andrebbe
inviata anche a @EMAIL{bug-gawk@@gnu.org,bug-gawk at gnu dot org}.
Questo per due ragioni. La prima @`e che, sebbene alcune distribuzioni inoltrino
i messaggi sui problemi ``verso l'alto'' alla mailing list GNU, molte non lo
fanno, e quindi c'@`e una buona probabilit@`a che i manutentori di @command{gawk}
non vedano affatto il messaggio relativo al bug! La seconda ragione @`e che la
posta diretta alla mailing list GNU @`e archiviata, e il poter disporre di ogni
cosa all'interno del progetto GNU consente di avere a disposizione tutte le
informazioni rilevanti senza dover dipendere da altre organizzazioni.
@end quotation
Suggerimenti non correlati a bug sono pure sempre benvenuti. Se si hanno
domande riguardo a qualcosa di non chiaro nella documentazione o a proposito
di funzionalit@`a oscure, si scriva alla mailing list dei bug; si prover@`a
a essere di aiuto nei limiti del possibile.
Si tenga presente: Si chiede di seguire le
@uref{https://gnu.org/philosophy/kind-communication.html,
@dfn{GNU Kind Communication Guidelines}
-- Linee guida GNU per una comunicazione gentile}
nella corrispondenza con la lista
(e anche in quella fuori dalla lista).
@node Usenet
@appendixsubsec Non segnalare bug a USENET!
@quotation
@c Date: Sun, 17 May 2015 19:50:14 -0400
@c From: Chet Ramey
@c Reply-To: chet.ramey@case.edu
@c Organization: ITS, Case Western Reserve University
@c To: Aharon Robbins
@c CC: chet.ramey@case.edu
Ho iniziato a ignorare Usenet un paio di anni fa, e non me ne sono mai
pentito. @`E come quando si parla di sport alla radio --- ci si sente
pi@`u intelligenti per aver lasciato perdere.
@author Chet Ramey
@end quotation
@cindex @code{comp.lang.awk} gruppo di discussione
@cindex newsgroup @code{comp.lang.awk}
@cindex gruppo di discussione @code{comp.lang.awk}
Siete pregati di @emph{non} provare a notificare bug di @command{gawk}
scrivendo al gruppo di discussione Usenet/Internet @code{comp.lang.awk}.
Sebbene alcuni degli sviluppatori di @command{gawk} leggano talora i
messaggi di questo gruppo di discussione, il manutentore principale di
@command{gawk} non lo fa pi@`u. Quindi @`e praticamente certo che un
messaggio inviato l@`a @emph{non} sia da lui letto.
Analogamente, segnalando bug o ponendo domande in @dfn{forum} online
come @uref{https://stackoverflow.com/, Stack Overflow}) si pu@`o
ottenere una risposta, ma non dai manutentori di @command{gawk},
che non dedicano tempo ai @dfn{forum} online. La procedura qui
descritta @`e la sola maniera ufficialmente riconosciuta
per notificare problemi. Davvero!
@ignore
And another one:
Date: Thu, 11 Jun 2015 09:00:56 -0400
From: Chet Ramey
My memory was imperfect. Back in June 2009, I wrote:
"That's the nice thing about open source, right? You can take your ball
and run to another section of the playground. Then, if you like mixing
metaphors, you can throw rocks from there."
@end ignore
@node Manutentori
@appendixsubsec Notificare problemi per versioni non-Unix
Se si riscontrano bug in una delle versioni non-Unix di @command{gawk}, una
copia del messaggio inviato alla mailing list dei bug andrebbe spedita alla
persona che si occupa di quella versione. I manutentori sono elencati nella
lista seguente, come pure nel file @file{README} nella distribuzione
@command{gawk}. Le informazioni nel file @file{README} dovrebbero essere
considerate come le pi@`u aggiornate, se risultano in conflitto con questo
@value{DOCUMENT}.
Le persone che si occupano delle varie versioni di @command{gawk} sono:
@c put the index entries outside the table, for docbook
@cindex Buening, Andreas
@cindex Malmberg, John
@cindex G., Daniel Richard
@cindex Robbins @subentry Arnold
@cindex Zaretskii, Eli
@cindex Guerrero, Juan Manuel
@ifset SMALLPRINT
@multitable {MS-Windows} {123456789012345678901234567890123456789001234567890}
@end ifset
@ifclear SMALLPRINT
@multitable {MS-Windows con MinGW} {123456789012345678901234567890123456789001234567890}
@end ifclear
@item Unix e sistemi POSIX @tab Arnold Robbins, @EMAIL{arnold@@skeeve.com,arnold at skeeve dot com}
@item MS-DOS with DJGPP @tab Juan Manuel Guerrero, @EMAIL{juan.guerrero@@gmx.de, juan dot guerrero at gmx dot de}
@item MS-Windows con MinGW @tab Eli Zaretskii, @EMAIL{eliz@@gnu.org,eliz at gnu dot org}
@c Leave this in the document on purpose.
@c OS/2 is not mentioned anywhere else though.
@item OS/2 @tab Andreas Buening, @EMAIL{andreas.buening@@nexgo.de,andreas dot buening at nexgo dot de}
@item VMS @tab John Malmberg, @EMAIL{wb8tyw@@qsl.net,wb8tyw at qsl.net}
@item z/OS (OS/390) @tab Daniel Richard G.@: @EMAIL{skunk@@iSKUNK.ORG,skunk at iSKUNK.ORG}
@end multitable
Se il problema riscontrato @`e riproducibile anche sotto Unix,
si dovrebbe spedire una copia del messaggio anche alla mailing list
@EMAIL{bug-gawk@@gnu.org,bug-gawk at gnu dot org}.
La versione generata usando gli strumenti DJGPP non @`e pi@`u supportata;
il codice relativo rester@`a nella distribuzione ancora per qualche tempo,
nel caso che qualche volontario desideri prenderla in carico.
Se questo non dovesse succedere, la parte di codice relativa questa
versione sar@`a rimossa dalla distribuzione.
@node Altre versioni
@appendixsec Altre implementazioni di @command{awk} liberamente disponibili
@cindex @command{awk} @subentry implementazioni di
@cindex implementazione @subentry di @command{awk}
@ignore
From: emory!amc.com!brennan (Michael Brennan)
Subject: C++ comments in awk programs
To: arnold@gnu.ai.mit.edu (Arnold Robbins)
Date: Wed, 4 Sep 1996 08:11:48 -0700 (PDT)
@end ignore
@cindex Brennan, Michael
@ifnotdocbook
@quotation
@i{@`E piuttosto divertente mettere commenti simili nel vostro codice awk:}@*
@ @ @ @ @ @ @code{// Funzionano i commenti in stile C++? Risposta: s@`{@dotless{i}}! certo}
@author Michael Brennan
@end quotation
@end ifnotdocbook
@docbook
Michael Brennan
@`E piuttosto divertente mettere commenti simili nel vostro codice awk.
// Funzionano i commenti in stile C++? Risposta: s@`{@dotless{i}}! certo
@end docbook
Ci sono alcune altre implementazioni di @command{awk} disponibili
gratuitamente.
Questa @value{SECTION} descrive in breve dove @`e possibile trovarle:
@table @asis
@cindex Kernighan, Brian
@cindex sorgente @subentry codice @subentry Brian Kernighan @command{awk}
@cindex codice sorgente @subentry Brian Kernighan @command{awk}
@cindex @command{awk} @subentry versioni di @seealso{Brian Kernighan, @command{awk} di}
@cindex Brian Kernighan @subentry @command{awk} di @subentry codice sorgente
@item Unix @command{awk}
Brian Kernighan, uno degli sviluppatori originali di Unix @command{awk},
ha reso disponibile liberamente la sua implementazione di @command{awk}.
Pu@`o essere scaricata da GitHub:
@example
git clone git://github.com/onetrueawk/awk bwkawk
@end example
@noindent
Questo comando crea una copia del deposito @uref{https://git-scm.com, Git}
in una directory chiamata @file{bwkawk}. Se si omette l'ultimo argomento
della riga di comando @command{git}, la copia del deposito @`e creata in una
directory di nome @file{awk}.
Questa versione richiede un compilatore ISO C (standard 1990); il compilatore
C contenuto in GCC (la collezione di compilatori GNU) @`e pi@`u che sufficiente.
Per eseguire la compilazione, si rivedano le impostazioni nel file
@file{makefile}, e quindi si richiami semplicemente @command{make}.
Si noti che il risultato della compilazione ha come nome
@command{a.out}; questo file va rinominato in maniera adeguata.
@xref{Estensioni comuni}
per una lista di estensioni in questo @command{awk} che non sono in
POSIX @command{awk}.
Incidentalmente, Dan Bornstein ha creato un deposito Git che contiene tutte le
versioni di BWK @command{awk} che @`e riuscito a trovare. @`E disponibile in
@uref{git://github.com/danfuzz/one-true-awk}.
@cindex Brennan, Michael
@cindex @command{mawk} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{mawk}
@cindex codice sorgente @subentry @command{mawk}
@item @command{mawk}
Michael Brennan ha scritto un'implementazione indipendente di @command{awk},
di nome @command{mawk}. @`E disponibile sotto la licenza
@ifclear FOR_PRINT
GPL (@pxref{Copia}),
@end ifclear
@ifset FOR_PRINT
GPL,
@end ifset
proprio come @command{gawk}.
Il sito di distribuzione originale di @command{mawk} non contiene pi@`u
il codice sorgente. Una copia @`e disponibile in
@uref{http://www.skeeve.com/gawk/mawk1.3.3.tar.gz}.
Dal 2009 @`e Thomas Dickey a occuparsi della manutenzione di @command{mawk}.
Le informazioni di base sono disponibili nella
@uref{http://www.invisible-island.net/mawk, pagine web del progetto}.
Il puntatore URL da cui scaricare @`e
@url{http://invisible-island.net/datafiles/release/mawk.tar.gz}.
Una volta scaricato,
per scompattare questo file pu@`o essere usato @command{gunzip}.
L'installazione @`e simile a quella di @command{gawk}
(@pxref{Installazione Unix}).
@xref{Estensioni comuni}
per una lista di estensioni in @command{mawk} che non sono in POSIX @command{awk}.
@item @command{mawk} 2.0
Nel 2016, Michael Brennan ha iniziato nuovamente lo sviluppo di @command{mawk}.
Le sue versioni di sviluppo sono disponibili tramite Git dalla pagina GitHub
@uref{https://github.com/mikebrennan000/mawk-2, del progetto}.
@cindex Sumner, Andrew
@cindex @command{awka} @subentry compilatore per @command{awk}
@cindex compilatore per @command{awk} @subentry @command{awka}
@cindex sorgente @subentry codice @subentry @command{awka}
@cindex codice sorgente @subentry @command{awka}
@item @command{awka}
Scritto da Andrew Sumner,
@command{awka} traduce i programmi @command{awk} in C, li compila,
e prepara il codice eseguibile usando una libreria di funzioni che
implementano le funzionalit@`a di base di @command{awk}.
Comprende anche un certo numero di estensioni.
Il traduttore di @command{awk} @`e rilasciato sotto la licenza GPL, e la
relativa libreria sotto la licenza LGPL.
Per ottenere @command{awka}, si visiti
il sito @url{https://sourceforge.net/projects/awka}.
@c You can reach Andrew Sumner at @email{andrew@@zbcom.net}.
@c andrewsumner@@yahoo.net
Il progetto sembra essere stato congelato; non ci sono state modifiche nel
codice sorgente dal 2001 circa.
@cindex Beebe, Nelson H.F.@:
@cindex @command{pawk} (versione con profilazione di Brian Kernighan @command{awk})
@cindex codice sorgente @subentry @command{pawk}
@cindex sorgente @subentry codice @subentry @command{pawk}
@item @command{pawk}
Nelson H.F.@: Beebe all'Universit@`a dello Utah ha modificato
BWK @command{awk} per fornire informazioni di temporizzazione e profilazione.
Questo @`e differente dall'usare @command{gawk} con l'opzione @option{--profile}
(@pxref{Profilare})
nel senso che fornisce un profilo basato sul consumo di CPU, non sul
numero di esecuzioni di una data riga di codice.
Sia pu@`o trovare sia in
@uref{ftp://ftp.math.utah.edu/pub/pawk/pawk-20030606.tar.gz}
che in
@uref{http://www.math.utah.edu/pub/pawk/pawk-20030606.tar.gz}.
@item BusyBox @command{awk}
@cindex BusyBox Awk
@cindex codice sorgente @subentry BusyBox Awk
@cindex sorgente @subentry codice @subentry BusyBox Awk
BusyBox @`e un programma distribuito con licenza GPL che fornisce versioni
ridotte di parecchie piccole applicazioni, all'interno di un singolo modulo
eseguibile. @`E stato ideato per sistemi
integrati.
Include un'implementazione completa di POSIX @command{awk}. Quando lo si
compila occorre prestare attenzione a non eseguire @samp{make install}, perch@'e
in questo modo si andrebbero a sostituire copie di altre applicazioni nella
directory @file{/usr/local/bin} del sistema corrente. Per ulteriori
informazioni, si veda @uref{https://busybox.net, la pagina principale del progetto}.
@cindex OpenSolaris
@cindex Solaris @subentry versione POSIX @command{awk}
@cindex codice sorgente @subentry Solaris @command{awk}
@cindex sorgente @subentry codice @subentry Solaris @command{awk}
@item POSIX @command{awk} per OpenSolaris
Le versioni di @command{awk} in @file{/usr/xpg4/bin} e @file{/usr/xpg6/bin} su
Solaris sono @dfn{grosso modo} conformi allo standard POSIX. Sono basate sul
comando @command{awk} preparato per i PC dalla ditta Mortice Kern. @`E stato
possibile compilare e far funzionare questo codice sotto GNU/Linux dopo 1--2
ore di lavoro. Rendere questo codice pi@`u generalmente portabile (usando gli
strumenti GNU Autoconf e/o Automake) richiederebbe ulteriore lavoro, che non @`e
stato fin qui compiuto, almeno per quel che risulta a chi scrive.
@cindex Illumos @subentry @command{awk} conforme a POSIX e
@cindex codice sorgente @subentry Illumos @command{awk}
@cindex sorgente @subentry codice @subentry Illumos @command{awk}
Il codice sorgente era un tempo disponibile dal sito web OpenSolaris.
Tuttavia, il progetto @`e terminato, e il sito web chiuso. Fortunatamente,
il progetto
@uref{https://wiki.illumos.org/display/illumos/illumos+Home, Illumos}
mette a disposizione questa implementazione. Si possono vedere i singoli file in
@uref{https://github.com/joyent/illumos-joyent/blob/master/usr/src/cmd/awk_xpg4}.
@cindex @command{goawk}
@cindex Go @subentry implementazione di @command{awk}
@cindex sorgente @subentry @command{goawk}
@cindex @command{goawk} @subentry sorgente di
@cindex linguaggi di programmazione @subentry Go
@cindex Go @subentry linguaggio di programmazione
@item @command{goawk}
Questo @`e un interpretatore di @command{awk} scritto nel
@uref{https://golang.org/, Linguaggio di programmazion Go}.
Implementa POSIX @command{awk}, con alcune estensioni minori.
Il codice sorgente @`e disponibile in @uref{https://github.com/benhoyt/goawk}.
L'autore ha scritto un buon
@uref{https://benhoyt.com/writings/goawk/, articolo}
che descrive l'implementazione.
@cindex @command{jawk}
@cindex Java @subentry implementazione di @command{awk}
@cindex implementazione @subentry di @command{awk} in Java
@cindex codice sorgente @subentry @command{jawk}
@cindex sorgente @subentry codice @subentry @command{jawk}
@item @command{jawk}
Questo @`e un interprete per @command{awk} scritto in Java. Dichiara di
essere un interprete completo, anche se, poich@'e usa funzionalit@`a di Java
per l'I/O e per la ricerca di @dfn{regexp}, il linguaggio che supporta
@`e differente da @command{awk} POSIX.
Ulteriori informazioni sono disponibili sulla
@uref{https://jawk.sourceforge.net, pagina principale del progetto}.
@item Libmawk
@cindex @command{libmawk} (interpretatore)
@cindex codice sorgente @subentry @command{libmawk} (interpretatore)
@cindex sorgente @subentry codice @subentry @command{libmawk} (interpretatore)
Questo @`e un interprete @command{awk} incorporabile, derivato da
@command{mawk}. Per ulteriori informazioni, si veda
@uref{http://repo.hu/projects/libmawk/}.
@cindex codice sorgente @subentry interpretatore @command{awk} incorporabile
@cindex interpretatore @command{awk} incorporabile @subentry codice sorgente
@cindex Neacsu, Mircea
@item @command{awk} incorporabile di Mircea Neacsu
@item incorporabile, @command{awk}, di Mircea Neacsu
Mircea Neacsu ha creato un interpretatore @command{awk}
incorporabile, basato su BWK @command{awk}. @`E disponibile
nel sito @uref{https://github.com/neacsum/awk}.
@item @code{pawk}
@cindex codice sorgente @subentry @command{pawk} (versione Python)
@cindex sorgente @subentry codice @subentry @command{pawk} (versione Python)
@cindex @code{pawk} @subentry implementazione simile ad @command{awk} per Python
Questo @`e un modulo Python che intende introdurre funzionalit@`a di tipo
@command{awk} in Python. Si veda @uref{https://github.com/alecthomas/pawk} per
ulteriori informazioni. (Questo programma non @`e correlato con la versione
modificata da Nelson Beebe di BWK @command{awk}, descritta prima.)
@item @w{QSE @command{awk}}
@cindex QSE @command{awk}
@cindex codice sorgente @subentry QSE @command{awk}
@cindex sorgente @subentry codice @subentry QSE @command{awk}
Questo @`e un interprete di @command{awk} incorporabile. Per ulteriori
informazioni, si veda
@uref{https://code.google.com/p/qse/}. @c e @uref{http://awk.info/?tools/qse}.
@item @command{QTawk}
@cindex QuikTrim Awk
@cindex codice sorgente @subentry QuikTrim Awk
@cindex sorgente @subentry codice @subentry QuikTrim Awk
Questa @`e un'implementazione indipendente di @command{awk} distribuita con la
licenza GPL. Ha un gran numero di estensioni rispetto ad @command{awk}
standard, e pu@`o non essere sintatticamente compatibile al 100% con esso. Si
veda @uref{http://www.quiktrim.org/QTawk.html} per ulteriori informazioni,
compreso il manuale. Il puntatore per scaricare QuikTrim non punta all'ultima
versione: si veda @uref{http://www.quiktrim.org/#AdditionalResources} per un
puntatore alla versione corrente.
Il progetto sembra essere fermo; non ci sono nuove versioni del codice
a partire dal 2014 circa.
@item Altre versioni
Si veda anche [in inglese] la sezione ``Versions and implementations''
della voce di
@uref{https://en.wikipedia.org/wiki/Awk_language#Versions_and_implementations,
Wikipedia} su @command{awk} per informazioni su ulteriori versioni.
@end table
@node Sommario dell'installazione
@appendixsec Sommario
@itemize @value{BULLET}
@item
La distribuzione di @command{gawk} @`e disponibile dal sito principale
di distribuzione del Progetto GNU
@code{ftp.gnu.org}. La maniera canonica per scaricarlo e installarlo @`e:
@example
wget https://ftp.gnu.org/gnu/gawk/gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz
tar -xvpzf gawk-@value{VERSION}.@value{PATCHLEVEL}.tar.gz
cd gawk-@value{VERSION}.@value{PATCHLEVEL}
./configure && make && make check
@end example
@quotation NOTA
A causa degli URL di tipo @samp{https://}, pu@`o essere necessario
specificare l'opzione @option{--no-check-certificate} a @command{wget}
per poter scaricare il file.
@end quotation
@item
@command{gawk} pu@`o essere installato anche su sistemi non-POSIX. I sistemi
correntemente supportati sono MS-Windows, usando
MSYS, MSYS2, DJGPP, MinGW e Cygwin,
@c OS/2,
e sia Vax/VMS che OpenVMS. Le istruzioni per ognuno di questi sistemi sono
incluse in questa @value{APPENDIX}.
@item
Le segnalazioni di errori (bug) dovrebbero essere spedite tramite email a
@email{bug-gawk@@gnu.org}. Le segnalazioni di errore dovrebbero essere scritte
in inglese e dovrebbero specificare la versione di @command{gawk} in uso, come
@`e stata compilata, un breve programma e un @value{DF} che permettono di
riprodurre il problema.
@item
Ci sono alcune altre implementazioni di @command{awk} disponibili
gratuitamente. Molte rispettano lo standard POSIX; altre un po' meno.
@end itemize
@ifclear FOR_PRINT
@node Note
@appendix Note di implementazione
@cindex @command{gawk} @subentry problemi di implementazione
@cindex problemi di implementazione @subentry @command{gawk}
Quest'appendice contiene informazioni che interessano soprattutto le persone
che aggiornano e mantengono @command{gawk}. L'intero contenuto si applica
specificatamente a @command{gawk} e non ad altre implementazioni.
@menu
* Modalit@`a di compatibilit@`a:: Come inibire alcune estensioni di
@command{gawk}.
* Aggiunte:: Fare aggiunte a @command{gawk}.
* Future estensioni:: Nuove funzionalit@`a che potranno
essere implementate in futuro.
* Limitazioni dell'implementazione:: Alcune limitazioni
dell'implementazione.
* Progetto delle estensioni:: Note di progetto sull'estensione API.
* Sommario delle note:: Sommario delle note di
implementazione.
@end menu
@node Modalit@`a di compatibilit@`a
@appendixsec Compatibilit@`a all'indietro e debug
@cindex @command{gawk} @subentry problemi di implementazione @subentry compatibilit@`a all'indietro
@cindex @command{gawk} @subentry problemi di implementazione @subentry debug
@cindex risoluzione di problemi @subentry @command{gawk}
@cindex problemi @subentry risoluzione di @subentry @command{gawk}
@cindex problemi di implementazione @subentry @command{gawk} @subentry debug
@xref{POSIX/GNU},
per un compendio delle estensioni GNU per il linguaggio e il programma
@command{awk}. Tutte queste funzionalit@`a possono essere inibite invocando
@command{gawk} con l'opzione @option{--traditional} o con l'opzione
@option{--posix}.
Se @command{gawk} @`e stato compilato per il debug con @samp{-DDEBUG}, @`e
possibile specificare un'ulteriore opzione sulla riga di comando:
@table @code
@item -Y
@itemx --parsedebug
Stampa l'informazione contenuta nella pila di analisi, durante la fase di
analisi iniziale del programma.
@end table
Quest'opzione @`e utile solo a chi sviluppa @command{gawk} e non all'utente
occasionale. @`E probabile che non sia neppure disponibile nella versione di
@command{gawk} che si sta usando, perch@'e rallenta l'esecuzione del programma.
@node Aggiunte
@appendixsec Fare aggiunte a @command{gawk}
Se si desidera migliorare @command{gawk} in maniera significativa, c'@`e la
massima libert@`a di farlo. @`E questo lo scopo del software libero; il codice
sorgente @`e disponibile, ed @`e possibile modificarlo a piacere
(@pxref{Copia}).
@ifnotinfo
Questa
@end ifnotinfo
@ifinfo
Questo
@end ifinfo
@value{SECTION} tratta di come @`e possibile modificare @command{gawk},
ed espone alcune considerazioni che si dovrebbero tenere presenti.
@menu
* Accedere ai sorgenti:: Accedere al deposito dei sorgenti Git.
* Aggiungere codice:: Aggiungere codice al programma
principale @command{gawk}.
* Nuovi sistemi:: Portare @command{gawk} su un nuovo sistema
operativo.
* File derivati:: Perch@'e i file derivati sono tenuti
nel deposito @command{git}.
@end menu
@node Accedere ai sorgenti
@appendixsubsec Accedere al deposito dei sorgenti Git di @command{gawk}
Poich@'e @command{gawk} @`e Software Libero, il codice sorgente @`e sempre
disponibile.
@iftex
La
@end iftex
@ref{Distribuzione di Gawk} descrive come scaricare e installare
le versioni ufficiali rilasciate di @command{gawk}.
@cindex @command{git} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{git}
Peraltro, se si intende modificare @command{gawk} e mettere a disposizione le
modifiche, @`e preferibile lavorare sulla versione in via di sviluppo. Per far
ci@`o @`e necessario accedere al deposito del codice sorgente di @command{gawk}.
Il codice @`e mantenuto usando il @uref{https://git-scm.com, sistema distribuito
di controllo delle versioni Git}. Sar@`a necessario installarlo se non @`e gi@`a
presente nel sistema. Quando @command{git} @`e disponibile, va usato il comando:
@example
git clone https://git.savannah.gnu.org/gawk.git
@end example
@noindent
Questo comando scarica in locale una copia esatta del deposito dei
sorgenti di @command{gawk}. Se si sta usando un @dfn{firewall}
che non consente l'uso del protocollo nativo di Git, @`e possibile accedere
ugualmente al deposito usando il comando:
@example
git clone http://git.savannah.gnu.org/r/gawk.git
@end example
Una volta modificato il sorgente, @`e posibile usare @samp{git diff} per
produrre una @dfn{patch}, e spedirla al manutentore di @command{gawk}; si veda
@ref{Bug}, per come farlo.
In passato era disponibile un'interfaccia Git--CVS
utilizzabile da persone che non avevano a disposizione Git. Purtroppo,
quest'interfaccia non funziona pi@`u, ma si potrebbe avere maggior fortuna usando
un sistema di controllo versioni pi@`u moderno, come Bazaar, che @`e dotato di
un'estensione Git per lavorare con depositi di sorgenti Git.
@node Aggiungere codice
@appendixsubsec Aggiungere nuove funzionalit@`a
@cindex @command{gawk} @subentry aggiungere funzionalit@`a a
@cindex funzionalit@`a @subentry aggiungere a @command{gawk}
@cindex aggiungere @subentry funzionalit@`a a @command{gawk}
Ognuno @`e libero di aggiungere tutte le nuove funzionalit@`a che vuole a
@command{gawk}. Comunque, se si desidera che tali modifiche siano incorporate
nella distribuzione di @command{gawk}, ci sono parecchi passi da fare per
rendere possibile la loro inclusione:
@enumerate 1
@item
Prima di inserire la nuova funzionalit@`a all'interno di @command{gawk},
prendere in considerazione la possibilit@`a di scriverla sotto forma di
estensione (@pxref{Estensioni dinamiche}).
Se ci@`o non @`e possibile, continuare con i passi rimanenti descritti in questa
lista.
@item
Essere disposti a firmare un documento liberatorio appropriato.
Se l'FSF deve poter distribuire le modifiche, queste vanno dichiarate
di pubblico dominio, tramite la firma di un documento apposito, oppure
attribuendo il copyright delle modifiche all'FSF.
Entrambe queste azioni sono semplici da fare, e @emph{molte} persone gi@`a
l'hanno fatto. Se ci sono domande da fare, mettersi in contatto con me
(@pxref{Bug}),
oppure @EMAIL{assign@@gnu.org,assign chiocciola gnu punto org}.
@item
Utilizzare l'ultima versione.
@`E molto pi@`u semplice per me integrare modifiche se sono basate sull'ultima
versione disponibile di @command{gawk} o, meglio ancora, sull'ultimo codice
sorgente presente nel deposito Git. Se la versione di @command{gawk} @`e molto
vecchia, potrei non essere affatto in grado di integrare le modifiche.
(@xref{Scaricare},
per informazioni su come ottenere l'ultima versione di @command{gawk}.)
@item
@ifnotinfo
Seguire gli @cite{Standard di codifica GNU}.
@end ifnotinfo
@ifinfo
Si veda @inforef{Top, , Version, standards, Standard di Codifica GNU}.
@end ifinfo
Questo documento descrive come dovrebbe essere scritto il software GNU.
Se non lo si @`e letto, @`e bene farlo, preferibilmente @emph{prima}
di iniziare a modificare @command{gawk}.
(Gli @cite{Standard di codifica GNU} sono disponibili nel sito web del
@uref{https://www.gnu.org/prep/standards/, Progetto GNU}.
Sono disponibili anche versioni in formato Texinfo, Info, e DVI.)
@cindex @command{gawk} @subentry stile di codifica in
@item
Usare lo stile di codifica @command{gawk}.
Il codice sorgente in C di @command{gawk} segue le istruzioni dello
@cite{Standard di codifica GNU}, con qualche piccola eccezione. Il codice @`e
formattato usando lo stile tradizionale ``K&R'', in particolare per ci@`o che
riguarda il posizionamento delle parentesi graffe e l'uso del carattere TAB.
In breve, le regole di codifica per @command{gawk}
sono le seguenti:
@itemize @value{BULLET}
@item
Usare intestazioni di funzione (prototipi) in stile ANSI/ISO quando
si definiscono delle funzioni.
@item
Mettere il nome della funzione all'inizio della riga in cui la si sta definendo.
@item
Usare @samp{#elif} invece di nidificare istruzioni @samp{#if} all'interno
di un'istruzione @samp{#else}.
@item
Mettere il tipo di codice di ritorno della funzione, anche se @`e @code{int},
sulla riga immediatamente sopra quella che contiene il nome e gli argomenti
della funzione.
@item
Mettere degli spazi attorno alle parentesi usate nelle strutture di controllo
(@code{if}, @code{while}, @code{for}, @code{do}, @code{switch}
e @code{return}).
@item
Non mettere spazi davanti alle parentesi usate nelle chiamate di funzione.
@item
Mettere spazi attorno a tutti gli operatori C e dopo le virgole,
nelle chiamate di funzione.
@item
Non usare l'operatore @dfn{virgola} per produrre degli effetti collaterali
multipli, tranne che nelle parti di inizializzazione e incremento dei cicli
@code{for}, e nel corpo delle macro.
@item
Usare dei caratteri TAB per l'indentazione, e non dei semplici spazi.
@item
Usare lo stile ``K&R'' per formattare le parti di programma incluse fra
parentesi graffe.
@item
Usare confronti con @code{NULL} e @code{'\0'} per le condizioni
contenute nelle istruzioni @code{if}, @code{while} e @code{for}, e anche
nelle varie clausole @code{case} delle istruzioni @code{switch}, invece
del semplice puntatore o il semplice valore del carattere.
@item
Usare i valori @code{true} e @code{false} per le variabili @code{booleane},
la costante simbolica @code{NULL} per i valori dei puntatori,
e la costante carattere @code{'\0'} quando @`e il caso, invece dei valori @code{1}
e @code{0}.
@item
Fornire un commento descrittivo di una riga per ogni funzione.
@item
Non usare la funzione @code{alloca()} per allocare memoria dallo @dfn{stack}.
Il farlo genera dei problemi di portabilit@`a che non giustificano il vantaggio
secondario di non doversi preoccupare di liberare la memoria. Usare invece
@code{malloc()} e @code{free()}.
@item
Non usare confronti nella forma @samp{! strcmp(a, b)} o simili.
Come disse una volta Henry Spencer, ``@code{strcmp()} non @`e una funzione
booleana!'' Usare invece @samp{strcmp(a, b) == 0}.
@item
Per aggiungere nuovi valori a @dfn{flag} binari, usare costanti esadecimali
esplicite (@code{0x001}, @code{0x002}, @code{0x004}, etc.) invece che
spostare di un bit a sinistra in incrementi successivi
(@samp{(1<<0)}, @samp{(1<<1)}, etc.).
@end itemize
@quotation NOTA
Qualora fossi costretto a riformattare completamente il codice per
farlo aderire allo stile di codifica usato in @command{gawk}, potrei anche
decidere di ignorare del tutto le modifiche proposte.
@end quotation
@cindex Texinfo
@item
Aggiornare la documentazione.
Insieme col nuovo codice, fornire nuove sezioni e/o capitoli per questo
@value{DOCUMENT}. Per quanto possibile, usare il formato Texinfo, invece
di fornire soltanto del testo ASCII non formattato (sebbene un semplice testo
sia gi@`a meglio che nessuna documentazione). Le convenzioni da seguire in
@cite{@value{TITLE}} sono elencate dopo la parole chiave @samp{@@bye} alla fine
del file sorgente Texinfo. Se possibile, aggiornare anche la pagina di manuale
in formato @command{man}.
Si dovr@`a anche firmare un documento liberatorio relativo alle
modifiche apportate alla documentazione.
@cindex @command{git} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{git}
@item
Inviare le modifiche come file di differenze nel formato contestuale unificato.
Usare @samp{diff -u -r -N} per confrontare i sorgenti originali dell'albero
di sorgenti @command{gawk} con la versione proposta.
Si raccomanda di usare la versione GNU di @command{diff} o, ancora meglio,
@samp{git diff} o @samp{git format-patch}.
Per inviare le modifiche proposte spedire l'output prodotto da @command{diff}.
(@xref{Bug}, per l'indirizzo di posta elettronica.)
L'uso di questo formato rende semplice per me l'applicazione delle modifiche
alla versione principale del sorgente di @command{gawk} (usando il programma di
utilit@`a @code{patch}). Se invece tocca a me applicare le modifiche a mano,
con un editor di testo, potrei decidere di non farlo, specialmente
se le modifiche sono molte.
@item
Includere una descrizione da aggiungere al file @file{ChangeLog} riguardo alla
modifica da voi proposta. Questo serve a minimizzare l'attivit@`a a me
richiesta, rendendo pi@`u facile per me l'accettazione delle modifiche, che
diventa pi@`u semplice se si include anche questa parte nel file di differenze
(nel formato @dfn{diff}).
@end enumerate
Sebbene questa possa sembrare una richiesta molto esigente, si tenga presente
che, anche se il nuovo codice non @`e opera mia, tocca poi a me manutenerlo e
correggere eventuali errori. Se non @`e possibile per me farlo senza perderci
troppo tempo, potrei anche lasciar perdere la modifica.
@node Nuovi sistemi
@appendixsubsec Portare @command{gawk} su un nuovo Sistema Operativo
@cindex portabilit@`a @subentry @command{gawk}
@cindex sistemi operativi @subentry portare @command{gawk} su altri
@cindex portare @command{gawk}
Se si vuol portare @command{gawk} su di un nuovo sistema operativo, sono
necessari parecchi passi:
@enumerate 1
@item
Seguire le linee-guida contenute
@ifinfo
in @ref{Aggiungere codice},
@end ifinfo
@ifnotinfo
nella precedente @value{SECTION}
@end ifnotinfo
relative allo stile di codifica, all'invio delle differenze proposte, etc.
@item
Essere disposti a firmare un documento liberatorio appropriato.
Se l'FSF deve poter distribuire le modifiche, queste vanno dichiarate
di pubblico dominio, tramite la firma di un documento apposito, oppure
attribuendo il copyright delle modifiche all'FSF.
Entrambe queste azioni sono semplici da fare, e @emph{molte} persone gi@`a
l'hanno fatto. Se ci sono domande da fare, scrivere a me
oppure all'indirizzo @email{gnu@@gnu.org}.
@item
Nel realizzare un @dfn{port}, tener presente che il codice
deve coesistere pacificamente con il resto di @command{gawk} e con le
versioni per altri sistemi operativi.
Evitare modifiche non necessarie alla parte di codice che @`e indipendente
dal sistema operativo. Se possibile, evitare di disseminare @samp{#ifdef},
utili solo per il proprio @dfn{port}, all'interno del codice sorgente.
Se le modifiche necessarie per un particolare sistema coinvolgono una parte
troppo rilevante del codice, @`e probabile che io non le accetti.
In questo caso si possono, naturalmente, distribuire le modifiche per
proprio conto, basta che si rispettino i vincoli della GPL
(@pxref{Copia}).
@item
Un certo numero di file che fanno parte della distribuzione di @command{gawk}
sono mantenuti da terze persone e non dagli sviluppatori di @command{gawk}.
Quindi, non si dovrebbero cambiare, se non per ragioni molto
valide; vale a dire, modifiche a questi file non sono impossibili, ma
le modifiche a questi file saranno controllate con estrema attenzione.
Questi file sono tutti quelli contenuti nella directory @file{support}
presente nella distribuzione di @command{gawk}. Vedere direttamente l@`a.
@item
Un certo numero di altri file sono prodotti dagli Autotool [comandi di
configurazione] di GNU (Autoconf, Automake, e GNU @command{gettext}).
Neppure questi file dovrebbero essere modificati, se non per ragioni molto
valide. I file sono
@file{ABOUT-NLS},
@file{config.guess},
@file{config.rpath},
@file{config.sub},
@file{depcomp},
@file{INSTALL},
@file{install-sh},
@file{missing},
@file{mkinstalldirs},
e
@file{ylwrap}.
@item
Essere disponibili a continuare a manutenere il @dfn{port}.
I sistemi operativi non-Unix sono supportati da volontari che tengono
aggiornato il codice necessario per compilare ed eseguire @command{gawk}
nei loro sistemi. Se nessuno @`e disponibile a tener aggiornato un @dfn{port},
questo diventa non pi@`u supportato, e pu@`o essere necessario rimuoverlo dalla
distribuzione.
@item
Fornire un appropriato file @file{gawkmisc.???}.
Ogni @dfn{port} ha il proprio @file{gawkmisc.???} che implementa alcune
funzioni specifiche per quel sistema operativo. Questa @`e una soluzione pi@`u
pulita, rispetto a una quantit@`a di @samp{#ifdef} sparsi nel codice. Il file
@file{gawkmisc.c} nella directory principale dei sorgenti include gli
appropriati file @file{gawkmisc.???} da ogni sottodirectory. Anche
quest'ultimo file va aggiornato.
Ogni file @file{gawkmisc.???} del @dfn{port} ha un suffisso esplicativo
del tipo di macchina o del sistema operativo in questione --- per esempio,
@file{pc/gawkmisc.pc} e @file{vms/gawkmisc.vms}. L'uso di suffissi distinti
invece di un semplice @file{gawkmisc.c}, rende possibile spostare file da
una sottodirectory propria del @dfn{port} nella sottodirectory principale,
senza cancellare incidentalmente il file @file{gawkmisc.c} vero e proprio.
(Al momento, questo rappresenta un problema solo per i @dfn{port} ai
sistemi operativi dei PC.)
@item
Fornire un @file{Makefile} e ogni altro file sorgente o di intestazione in C
che sia necessario per il proprio sistema operativo. Tutto il codice dovrebbe
stare in una sottodirectory a parte, il cui nome sia lo stesso, o
sia indicativo, del proprio sistema operativo o del tipo di computer.
Se possibile, tentare di strutturare il codice in modo che non sia necessario
spostare file dalla propria sottodirectory nella directory principale del
codice sorgente. Se ci@`o non @`e possibile, evitare nel modo pi@`u assoluto di
usare nomi per i file che siano duplicati di nomi di file presenti nella
directory principale del codice sorgente.
@item
Aggiornare la documentazione.
Scrivere una sezione (o pi@`u sezioni) per questo @value{DOCUMENT}
che descriva i passi di installazione e compilazione necessari per compilare
e/o installare @command{gawk} per il sistema desiderato.
@end enumerate
Seguire queste indicazioni facilita molto l'integrazione delle
modifiche in @command{gawk} e la loro felice coesistenza con il codice di
altri sistemi operativi gi@`a presenti.
Nel codice che viene fornito e tenuto aggiornato, si possono
tranquillamente usare uno stile di codifica e una disposizione delle
parentesi graffe di proprio gradimento.
@node File derivati
@appendixsubsec Perch@'e i file generati sono tenuti in Git
@cindex Git @subentry uso per il codice sorgente di @command{gawk}
@c From emails written March 22, 2012, to the gawk developers list.
Se si esaminano i sorgenti di @command{gawk} nel deposito Git
si noter@`a che sono inclusi file generati automaticamente dagli strumenti
dell'infrastruttura GNU, come @file{Makefile.in} generato da Automake e
anche @file{configure} proveniente da Autoconf.
Questo comportamento @`e differente da quello di molti progetti di
Libero Software che non memorizzano i file derivati, per mantenere pi@`u
sgombro il deposito Git, rendendo cos@`{@dotless{i}} pi@`u facile comprendere quali sono le
modifiche sostanziali confrontando differenti versioni, nel tentativo di
capire cosa @`e cambiato tra una modifica e la precedente.
Tuttavia, ci sono parecchie ragioni per le quali il manutentore di
@command{gawk} preferisce mantenere ogni cosa nel deposito Git.
Innanzitutto, perch@'e in questo modo @`e facile generare completamente ogni
data versione, senza doversi preoccupare di avere a disposizione altri
strumenti (pi@`u vecchi, probabilmente obsoleti, e in qualche caso
perfino impossibili da trovare).
Come esempio estremo, se solo si pensa di tentare di compilare, diciamo, la
versione Unix V7 di @command{awk}, ci si accorge che non solo @`e necessario
scaricare e ricompilare la versione V7 del comando @command{yacc} per farlo, ma
anche che serve la versione V7 del comando @command{lex}. E quest'ultima @`e
praticamente impossibile farla funzionare in un sistema GNU/Linux dei giorni
nostri.@footnote{Ci abbiamo provato. @`E stata un'esperienza dolorosa.}
(Oppure, diciamo che la versione 1.2 di @command{gawk} richiede il comando
@command{bison} come funzionava nel 1989, e non @`e presente il file
@file{awkgram.c} [generato tramite @command{bison}] nel deposito Git. Che cosa
ci garantisce di riuscire a trovare quella versione di @command{bison}? O che
@emph{quella} riesca a generarlo?)
Se il deposito Git comprende tutti i file derivati,
@`e facile, dopo averli scaricati, ricostruire il programma. (Oppure @`e @emph{pi@`u
facile}, a seconda di quanto si vuole risalire indietro nel tempo).
E qui arriviamo alla seconda (e pi@`u valida) ragione per cui tutti i file
devono essere proprio nel deposito Git. Domandiamoci a chi ci si rivolge:
agli sviluppatori di @command{gawk}, oppure a un utilizzatore che intende
solo scaricare una data versione e provarla?
Il manutentore di @command{gawk} desidera che per tutti gli utenti
@command{awk} interessati sia possibile limitarsi a clonare il deposito sul
proprio computer, selezionare la variante che lo interessa e costruirla. Senza
doversi preoccupare di avere a disposizione le versioni corrette degli Autotool
GNU.@footnote{Ecco un programma GNU che (secondo noi) @`e estremamente difficile
da estrarre dal deposito Git e compilare. Per esempio, in un vecchio (ma
ancora funzionante) PowerPC Macintosh, con il sistema operativo Mac Os X 10.5,
@`e stato necessario scaricare e compilare una tonnellata di software,
incominciando dallo stesso programma Git, per riuscire a lavorare con l'ultima
versione del codice. Non @`e un'esperienza piacevole e, specie sui vecchi
sistemi, @`e una notevole perdita di tempo.
Neppure partire dall'ultimo archivio @command{tar} compresso @`e stata una
passeggiata: i manutentori avevano eliminato i file compressi in formato
@file{.gz} e @file{.bz2} sostituendoli con file di tipo @file{.tar.xz}.
Bisognava quindi per prima cosa scaricare e compilare @command{xz}}.
A questo serve il file @file{bootstrap.sh}. Va a "toccare"
[tramite il comando @command{touch}] vari altri file nell'ordine richiesto
in modo che
@example
# La formula canonica per compilare il software GNU:
./bootstrap.sh && ./configure && make
@end example
@noindent
tutto @emph{funzioni senza problemi}.
Questo @`e estremamente importante per i rami
@code{master} e @code{gawk-@var{X}.@var{Y}-stable}.
Inoltre, il manutentore di @command{gawk} potrebbe sostenere che
ci@`o @`e importante anche per gli sviluppatori di @command{gawk}. Tentando di
scaricare il ramo @code{xgawk}@footnote{Un ramo (non pi@`u presente) creato da
uno degli altri sviluppatori, e che non includeva i file generati.} per
compilarlo, non ci riusc@`{@dotless{i}}. (Mancava il file @file{ltmain.sh}, ed egli non
aveva idea di come crearlo, e c'erano anche ulteriori problemi.)
La cosa lo lasci@`o in uno stato di frustrazione @emph{estrema}. Riguardo a quel
ramo, il manutentore @`e in una posizione non differente da quella di un utente
generico che voglia tentare di compilare @code{gawk-4.1-stable} o @code{master}
dal deposito Git.
Quindi, il manutentore ritiene che sia non solo importante, ma cruciale, che
per ogni dato ramo la formula canonica evocata prima
@emph{funzioni senza problemi}.
@c Added 9/2014:
Una terza ragione per avere tutti i file @`e che senza di essi, usare @samp{git
bisect} per tentare di trovare quale modifica ha introdotto un errore diventa
estremamente difficile. Il manutentore ha tentato di farlo su un altro
progetto che richiede di eseguire @dfn{script} di inizializzazione allo scopo
di creare lo @dfn{script} @command{configure} e cos@`{@dotless{i}} via; @`e stata un'esperienza
veramente dolorosa. Se invece il deposito Git contiene tutto il necessario,
usare @command{git bisect} al suo interno @`e molto facile.
@c So - that's my reasoning and philosophy.
Quali sono, quindi, alcune delle conseguenze e/o delle cose da fare?
@enumerate 1
@item
Non importa se ci sono file differenti nei diversi rami
prodotti da versioni differenti degli Autotool.
@enumerate A
@item
Spetta al manutentore integrarli tra loro, e se ne occuper@`a lui.
@item
@`E facile per lui eseguire @samp{git diff x y > /tmp/diff1 ; gvim /tmp/diff1}
per rimuovere le differenze che non sono rilevanti ai fini della revisione
del codice sorgente.
@end enumerate
@item
Sarebbe sicuramente d'aiuto se tutti usassero le stesse versioni degli Autotool
GNU che lui usa, che in generale sono le ultime versioni rilasciate di
Automake,
Autoconf,
@command{bison},
GNU @command{gettext}
e
Libtool.
@ignore
If it would help if I sent out an ``I just upgraded to version x.y
of tool Z'' kind of message to this list, I can do that. Up until
now it hasn't been a real issue since I'm the only one who's been
dorking with the configuration machinery.
@end ignore
@c @enumerate A
@c @item
Installare a partire dal sorgente @`e abbastanza facile. @`E il modo con cui il
manutentore ha lavorato per anni (e ancora lavora).
Egli aveva @file{/usr/local/bin} all'inizio del suo @env{PATH} e dava i
seguenti comandi:
@example
wget https://ftp.gnu.org/gnu/@var{package}/@var{package}-@var{x}.@var{y}.@var{z}.tar.gz
tar -xpzvf @var{package}-@var{x}.@var{y}.@var{z}.tar.gz
cd @var{package}-@var{x}.@var{y}.@var{z}
./configure && make && make check
make install # come utente root
@end example
@quotation NOTA
A causa degli URL di tipo @samp{https://}, pu@`o essere necessario
specificare l'opzione @option{--no-check-certificate} a @command{wget}
per poter scaricare il file.
@end quotation
@c @item
@ignore
These days the maintainer uses Ubuntu 12.04 which is medium current, but
he is already doing the above for Automake, Autoconf, and @command{bison}.
@end ignore
@ignore
(C. Rant: Recent Linux versions with GNOME 3 really suck. What
are all those people thinking? Fedora 15 was such a bust it drove
me to Ubuntu, but Ubuntu 11.04 and 11.10 are totally unusable from
a UI perspective. Bleah.)
@end ignore
@c @end enumerate
@ignore
@item
If someone still feels really strongly about all this, then perhaps they
can have two branches, one for their development with just the clean
changes, and one that is buildable (xgawk and xgawk-buildable, maybe).
Or, as I suggested in another mail, make commits in pairs, the first with
the "real" changes and the second with "everything else needed for
building".
@end ignore
@end enumerate
La maggior parte del testo precedente fa parte di messaggi scritti
originalmente dal manutentore agli altri sviluppatori @command{gawk}.
Da uno degli sviluppatori @`e stata avanzata l'obiezione
``@dots{} che chi scarica il sorgente da Git
non @`e un utente finale''.
Tuttavia, questo non @`e esatto. Ci sono ``utenti avanzati di @command{awk}''
che possono installare @command{gawk} (usando la formula canonica vista sopra)
ma che non conoscono il linguaggio C. Quindi, i rami pi@`u rilevanti
dovrebbero essere sempre compilabili.
@`E stato proposto poi di lanciare ogni notte uno @dfn{script} tramite il
programma di utilit@`a @command{cron} per creare archivi in formato @command{tar}
contenenti tutto ``il codice sorgente.'' Il problema in questo caso @`e che
ci sono differenti alberi di sorgenti, che corrispondono ai vari rami!
Quindi gli archivi notturni in questione non sono una risposta valida, anche
per il fatto che il deposito Git pu@`o rimanere senza alcuna modifica
significativa per settimane intere.
Fortunatamente, il server Git pu@`o rispondere a questa esigenza. Per ogni
dato ramo chiamato @var{nome-ramo}, basta usare:
@example
wget https://git.savannah.gnu.org/cgit/gawk.git/snapshot/gawk-@var{nome-ramo}.tar.gz
@end example
@noindent
per ottenere una copia utilizzabile del ramo in questione.
@node Future estensioni
@appendixsec Probabili estensioni future
@ignore
From emory!scalpel.netlabs.com!lwall Tue Oct 31 12:43:17 1995
Return-Path:
Message-Id: <9510311732.AA28472@scalpel.netlabs.com>
To: arnold@skeeve.atl.ga.us (Arnold D. Robbins)
Subject: Re: May I quote you?
In-Reply-To: Your message of "Tue, 31 Oct 95 09:11:00 EST."
Date: Tue, 31 Oct 95 09:32:46 -0800
From: Larry Wall
: Greetings. I am working on the release of gawk 3.0. Part of it will be a
: thoroughly updated manual. One of the sections deals with planned future
: extensions and enhancements. I have the following at the beginning
: of it:
:
: @cindex PERL
: @cindex Wall, Larry
: @display
: @i{AWK is a language similar to PERL, only considerably more elegant.} @*
: Arnold Robbins
: @sp 1
: @i{Hey!} @*
: Larry Wall
: @end display
:
: Before I actually release this for publication, I wanted to get your
: permission to quote you. (Hopefully, in the spirit of much of GNU, the
: implied humor is visible... :-)
I think that would be fine.
Larry
@end ignore
@cindex Perl
@cindex Wall, Larry
@cindex Robbins @subentry Arnold
@quotation
@i{AWK @`e un linguaggio simile a PERL, solo che @`e notevolmente pi@`u elegante.}
@author Arnold Robbins
@end quotation
@quotation
@i{Hey!}
@author Larry Wall
@end quotation
Il file @file{TODO} nel ramo @code{master} del deposito Git di @command{gawk}
contiene un elenco di possibili futuri miglioramenti. Alcuni di questi
riguardano il codice sorgente, e altri possibili nuove funzionalit@`a.
Consultare quel file per esaminare la lista.
@xref{Aggiunte},
se si @`e interessati a intraprendere qualcuno dei progetti col@`a elencati.
@node Limitazioni dell'implementazione
@appendixsec Alcune limitazioni dell'implementazione
La tabella seguente specifica i limiti di @command{gawk} in un sistema di
tipo Unix (sebbene anche tra questi ci potrebbero essere variazioni). Altri
sistemi operativi possono avere limiti differenti.
@multitable @columnfractions .40 .60
@headitem Caratteristica @tab Limiti
@item Caratteri in una classe di caratteri @tab 2^(numero di bit per byte)
@item Lunghezza di un record in input @tab @code{ULONG_MAX}
@item Lunghezza di un record in output @tab Illimitata
@item Lunghezza di una riga di codice sorgente @tab Illimitata
@item Numero di campi in un record @tab @code{ULONG_MAX}
@item Numero di ridirezioni di file @tab Illimitata
@item Numero di record in input in un singolo file @tab @code{MAX_LONG}
@item Numero totale di record in input @tab @code{MAX_LONG}
@item Numero di ridirezioni via @dfn{pipe} @tab min(numero processi per utente, numero di file aperti)
@item Valori numerici @tab Numeri in virgola mobile in doppia precisione (se non si usa la funzionalit@`a MPFR)
@item Dimensione di un campo @tab @code{ULONG_MAX}
@item Dimensione di una stringa letterale @tab @code{ULONG_MAX}
@item Dimensione di una stringa di @dfn{printf} @tab @code{ULONG_MAX}
@end multitable
@node Progetto delle estensioni
@appendixsec Note di progetto dell'estensione API
Questa @value{SECTION} documenta l'architettura dell'estensione API,
inclusa una trattazione sommaria della progettazione e dei problemi che
andavano risolti.
La prima versione delle estensioni per @command{gawk} @`e stata sviluppata
a met@`a degli anni '90, e distribuita con la versione 3.1 di @command{gawk},
verso la fine degli anni '90.
Il meccanismo e l'architettura sono rimasti gli stessi per quasi 15 anni,
fino al 2012.
Il vecchio meccanismo delle estensioni usava tipi di dati e funzioni dello
stesso @command{gawk}, con un ``abile trucco'' per installare le funzioni
di estensione.
La distribuzione @command{gawk} conteneva alcuni esempi di estensioni, solo
poche delle quali erano realmente utili. Tuttavia era chiaro fin da
principio che il meccanismo di estensione era un'aggiunta improvvisata, e
non era realmente ben concepito.
@menu
* Problemi con le vecchie estensioni:: Problemi col vecchio meccanismo.
* Obiettivi delle estensioni:: Obiettivi del nuovo meccanismo.
* Altre scelte progettuali per le estensioni:: Qualche altra scelta progettuale.
* Futuri sviluppi delle estensioni:: Possibilit@`a di crescita futura.
@end menu
@node Problemi con le vecchie estensioni
@appendixsubsec Problemi con le vecchie estensioni
Il vecchio meccanismo delle estensioni presentava parecchi problemi:
@itemize @value{BULLET}
@item
Dipendeva eccessivamente dalla struttura interna di @command{gawk}. Ogni volta
che la struttura @code{NODE}@footnote{Una struttura di dati fondamentale
all'interno di @command{gawk}.} veniva modificata, ogni estensione doveva
essere ricompilata. Inoltre, la scrittura di estensioni richiedeva una
certa familiarit@`a con le funzioni interne di @command{gawk}. Esisteva
un po' di documentazione in questo @value{DOCUMENT}, ma era ridotta al minimo.
@item
Per poter utilizzare servizi di @command{gawk} da un'estensione era necessario
disporre di funzionalit@`a del @dfn{linker}
normalmente disponibili in ambiente di tipo Unix, ma non implementate
nei sistemi MS-Windows; chi voleva utilizzare estensioni in
MS-Windows doveva aggiungerle al modulo eseguibile di @command{gawk},
anche se MS-Windows supporta il caricamento dinamico di oggetti condivisi.
@item
L'API di tanto in tanto veniva modificata, in parallelo ai cambiamenti di
@command{gawk}; nessuna compatibilit@`a tra le versioni @`e stata mai prevista o
resa disponibile.
@end itemize
Nonostante questi inconvenienti, gli sviluppatori del progetto @command{xgawk}
si basarono su @command{gawk} per sviluppare parecchie estensioni
significative. Inoltre, migliorarono le capacit@`a, in @command{gawk}, di
includere file e di accedere a oggetti condivisi.
Una nuova API @`e rimasta un desiderio per lungo tempo, ma solo nel 2012
il manutentore di @command{gawk} e gli sviluppatori di @command{xgawk}
iniziarono finalmente a lavorare insieme. Ulteriori informazioni riguardanti
il progetto @command{xgawk} sono forniti nella @ref{gawkextlib}.
@node Obiettivi delle estensioni
@appendixsubsec Obiettivi per un nuovo meccanismo
Alcuni obiettivi per la nuova API sono:
@itemize @value{BULLET}
@item
L'API dovrebbe essere indipendente dalla struttura interna di @command{gawk}.
Le modifiche alla struttura interna di @command{gawk} dovrebbero essere
irrilevanti per chi scrive una funzione di estensione.
@item
L'API dovrebbe consentire una compatibilit@`a @emph{binaria} [ossia a livello
di codice eseguibile, e non solo a livello di codice sorgente] tra diverse
versioni di @command{gawk}, se la stessa API rimane invariata.
@item
L'API dovrebbe consentire che le estensioni scritte in C o C++ abbiano
all'incirca la stessa ``struttura'', per il codice awk,
di quella che hanno le funzioni di @command{awk}. Questo vuol dire che le
estensioni dovrebbero avere:
@itemize @value{MINUS}
@item
La capacit@`a di accedere ai parametri delle funzioni.
@item
La capacit@`a di trasformare un parametro indefinito in un vettore
(chiamata per riferimento [@dfn{by reference}]).
@item
La capacit@`a di creare, leggere e aggiornare variabili globali.
@item
Un accesso facile a tutti gli elementi di un vettore simultaneamente
(``appiattimento del vettore'') in modo da poter visitare tutti gli elementi
del vettore in una maniera semplice per un programma scritto in C.
@item
La capacit@`a di creare vettori (compresi i veri "vettori di vettori" di
@command{gawk}).
@end itemize
@end itemize
Alcuni ulteriori obiettivi rilevanti sono:
@itemize @value{BULLET}
@item
L'API dovrebbe usare solo funzionalit@`a disponibili nella specifica ISO C 90, in
modo da consentire estensioni scritte con una vasta gamma di compilatori C e
C++. L'intestazione dovrebbe includere le appropriate direttive
@samp{#ifdef __cplusplus} e @samp{extern "C"}, in modo da poter utilizzare un
compilatore C++. (Se si usa C++, il sistema operativo in uso dev'essere in
grado di invocare dei costruttori e dei distruttori, poich@'e @command{gawk} @`e un
programma scritto in C. Al momento in cui queste note sono scritte, la cosa
non @`e stata verificata).
@item
Il meccanismo API non dovrebbe aver bisogno di accedere ai simboli di
@command{gawk}@footnote{I @dfn{simboli} sono le variabili e le funzioni
definite all'interno di @command{gawk}. Accedere a questi simboli da parte
di codice esterno a @command{gawk} caricato dinamicamente al momento
dell'esecuzione @`e problematico in ambiente MS-Windows.} da parte del
@dfn{linker} statico, usato in fase di compilazione, o di quello dinamico,
in modo da rendere possibile la creazione di estensioni che funzionino anche
in ambiente MS-Windows.
@end itemize
In fase di sviluppo, @`e apparso evidente che dovevano essere disponibili alle
estensioni anche altre funzionalit@`a, che sono state
successivamente implementate:
@itemize @value{BULLET}
@item
Le estensioni dovrebbero essere in grado di agganciarsi al meccanismo di
ridirezione dell'I/O di @command{gawk}. In particolare, gli sviluppatori di
@command{xgawk} hanno programmato un cosiddetto ``gancio aperto'' (@dfn{open
hook}) per gestire autonomamente la lettura dei record. In fase di sviluppo,
questo meccanismo @`e stato generalizzato, per consentire alle estensioni di
agganciarsi sia all'elaborazione dell'input, che a quella dell'output, nonch@'e
all'I/O bidirezionale.
@item
Un'estensione dovrebbe poter rendere disponibile una funzione di ``call back''
(richiamo) per effettuare operazioni di pulizia all'uscita di @command{gawk}.
@item
Un'estensione dovrebbe poter rendere disponibile una stringa di versione
cos@`{@dotless{i}} che l'opzione @option{--version}
di @command{gawk} possa informare anche sulle versioni delle estensioni.
@end itemize
Il vincolo di evitare di accedere ai simboli di @command{gawk} pu@`o parere a
prima vista piuttosto difficile da rispettare.
Un tipo di architettura, apparentemente usato da Perl e Ruby e forse da altri
programmi, potrebbe consistere nel mettere il codice principale di
@command{gawk} in una libreria, limitando il programma di utilit@`a
@command{gawk} a una piccola funzione @code{main()} in C che richiamerebbe
dinamicamente la libreria.
Questo inverte i ruoli del programma principale e della sua estensione, e
complica sia la compilazione che l'installazione, trasformando la semplice
copia del programma eseguibile @command{gawk} da un sistema all'altro (o da una
posizione all'altra all'interno dello stesso sistema) in un'operazione ad alto
rischio.
Pat Rankin ha suggerito la soluzione che @`e stata adottata.
@xref{Panoramica sul meccanismo delle estensioni}, per maggiori dettagli.
@node Altre scelte progettuali per le estensioni
@appendixsubsec Altre scelte progettuali
Per una scelta progettuale arbitraria, le estensioni possono accedere ai valori
delle variabili e dei vettori predefiniti (come @code{ARGV} e @code{FS}), ma
non possono modificarli, con la sola eccezione di @code{PROCINFO}.
Il motivo di questa scelta @`e di impedire a una funzione di estensione di
alterare il flusso di un programma @command{awk} togliendogli il controllo.
Mentre una vera funzione di @command{awk} pu@`o fare quel che vuole, a
discrezione del programmatore, una funzione di estensione dovrebbe fornire un
servizio, o rendere disponibile un'API C da utilizzare all'interno di
@command{awk}, senza interferire con le variabili @code{FS} o @code{ARGC} e
@code{ARGV}.
Inoltre, diverrebbe facile avviarsi su un sentiero scivoloso. Quante
funzionalit@`a di @command{gawk} dovrebbero essere disponibili alle estensioni?
Devono poter usare @code{getline}? Oppure richiamare @code{gsub()} o compilare
espressioni regolari? Oppure richiamare funzioni interne di @command{awk}?
(@emph{Questo} potrebbe creare molta confusione.)
Per evitare questi problemi, gli sviluppatori di @command{gawk} hanno scelto di
iniziare con le funzionalit@`a pi@`u semplici e di base, che sono comunque
veramente utili.
Sebbene @command{gawk} consenta cose interessanti come l'MPFR,
e vettori indicizzati internamente con numeri interi,
un'altra decisione @`e stata quella di non rendere disponibili all'API queste
funzionalit@`a, per amor di semplicit@`a e per restare fedeli alla tradizionale
semantica di @command{awk}. (In effetti, i vettori indicizzati internamente
con numeri interi sono talmente trasparenti che non sono neppure documentati!)
In pi@`u, tutte le funzioni nell'API controllano che i puntatori ai parametri
passati loro in input non siano @code{NULL}. Se lo sono, viene emesso un
messaggio di errore. (@`E bene che il codice di estensione verifichi
che i puntatori ricevuti da @command{gawk} non siano @code{NULL}. Ci@`o non
dovrebbe succedere, ma gli sviluppatori di @command{gawk} sono solo degli
esseri umani, e capita anche a loro di commettere degli errori, di tanto in
tanto.)
Col tempo, l'API si svilupper@`a certamente; gli sviluppatori di @command{gawk}
si aspettano che questo avvenga in base alle necessit@`a degli utenti. Per ora,
l'API disponbile sembra fornire un insieme di funzionalit@`a minimo, eppure
potente, per creare estensioni.
@node Futuri sviluppi delle estensioni
@appendixsubsec Possibilit@`a di sviluppo futuro
L'API pu@`o ancora essere ampliata, come minimo nei modi seguenti:
@itemize @value{BULLET}
@item
@command{gawk} passa un ``identificativo di estensione'' all'estensione in fase
di caricamente dell'estensione. L'estensione a sua volta restituisce questo
identificativo a @command{gawk} a ogni chiamata di funzione. Questo meccanismo
consente a @command{gawk} di identificare l'estensione che lo chiama, se la
cosa dovesse risultare necessaria.
@end itemize
Naturalmente, al momento in cui queste righe sono state scritte, nessuna
decisione @`e stata presa riguardo a quanto descritto sopra.
@node Sommario delle note
@appendixsec Sommario
@itemize @value{BULLET}
@item
Le estensioni di @command{gawk} possono essere disabilitata sia con
l'opzione @option{--traditional} che con l'opzione @option{--posix}.
L'opzione @option{--parsedebug} @`e disponibile se @command{gawk} @`e stato
compilato con @samp{-DDEBUG}.
@item
Il codice sorgente di @command{gawk} @`e conservato in un deposito Git
pubblicamente accessibile. Tutti possono scaricarlo e visualizzare il
codice sorgente.
@item
I contributi a @command{gawk} sono benvenuti. Seguire le istruzioni
delineate in questo @value{CHAPTER} render@`a pi@`u agevole integrare
i contributi degli utenti nel codice principale.
Questo vale sia per il contributo di nuove funzionalit@`a che per il
@dfn{porting} a ulteriori sistemi operativi.
@item
@command{gawk} ha alcuni limiti: generalmente quelli imposti
dall'architettura hardware della macchina.
@item
La progettazione dell'estensione API @`e volta a risolvere alcuni problemi
riscontrati nel precedente meccanismo di estensione, ad abilitare
funzionalit@`a richieste dal progetto @code{xgawk}, e a fornire una
compatibilit@`a binaria in futuro.
@item
Il precedente meccanismo di estensione non @`e pi@`u supportato
ed @`e stato rimosso dal codice sorgente nella
@value{PVERSION} 4.2.
@end itemize
@node Concetti fondamentali
@appendix Concetti fondamentali di programmazione
@cindex programmazione @subentry concetti di
@cindex programmazione @subentry concetti di
Quest'@value{APPENDIX} si propone di definire alcuni dei concetti
e termini fondamentali usati nel resto di questo @value{DOCUMENT}.
Poich@'e questo @value{DOCUMENT} @`e dedicato ad @command{awk},
e non riguarda la programmazione al computer in generale, la trattazione
@`e necessariamente piuttosto generica e semplificata.
(Se serve qualcosa di pi@`u approfondito, ci sono molti
altri testi introduttivi che si possono consultare.)
@menu
* Fondamenti ad alto livello:: Una visione dall'alto.
* Fondamenti sui tipi di dati:: Una velocissima introduzione ai tipi di dati.
@end menu
@node Fondamenti ad alto livello
@appendixsec Quel che fa un programma
@cindex elaborazione dati
Al livello pi@`u fondamentale, il compito di un programma @`e di elaborare
alcuni dati in input e produrre dei risultati.
@ifnotdocbook
Si veda la @ref{figura-generica-flusso}.
@end ifnotdocbook
@ifdocbook
Si veda la @inlineraw{docbook, }.
@end ifdocbook
@ifnotdocbook
@float Figura,figura-generica-flusso
@caption{Flusso generico di un programma}
@ifclear SMALLPRINT
@center @image{programma-generico, , , Flusso generico di un programma}
@end ifclear
@ifset SMALLPRINT
@center @image{programma-generico, 11cm, , Flusso generico di un programma}
@end ifset
@end float
@end ifnotdocbook
@docbook
Flusso generico di un programma
@end docbook
@cindex programmi compilati
@cindex programmi interpretati
Il ``programma'' nella figura pu@`o essere sia un programma
compilato@footnote{I programmi compilati sono normalmente scritti
in linguaggi di programmazione di livello pi@`u basso, come C, C++, o Ada,
e quindi tradotti, o @dfn{compilati}, in una forma che
il computer pu@`o eseguire direttamente.}
(come @command{ls}),
sia un programma @dfn{interpretato}. In quest'ultimo caso, un programma
direttamente eseguibile dal computer, come @command{awk}, legge il
programma, e quindi usa le istruzioni in esso contenute per elaborare i dati.
@cindex programmazione @subentry passi fondamentali
Quando si scrive un programma, esso @`e composto normalmente
dai seguenti insiemi di istruzioni di base,
@ifnotdocbook
come si vede nella @ref{figura-flusso-elaborazione}:
@end ifnotdocbook
@ifdocbook
come si vede nella @inlineraw{docbook, }:
@end ifdocbook
@ifnotdocbook
@float Figura,figura-flusso-elaborazione
@caption{Fasi di un programma generico}
@ifclear SMALLPRINT
@center @image{flusso-elaborazione, , , Fasi di un programma generico}
@end ifclear
@ifset SMALLPRINT
@center @image{flusso-elaborazione, 11cm , , Fasi di un programma generico}
@end ifset
@end float
@end ifnotdocbook
@docbook
Fasi di un programma generico
@end docbook
@table @asis
@item Inizializzazione
Queste sono le cose da fare prima di iniziare la reale elaborazione dei
dati, per esempio controllare gli argomenti con cui @`e stato invocato il
programma, inizializzare dei dati di cui si potr@`a aver bisogno per la
successiva elaborazione, e cos@`{@dotless{i}} via.
Questa fase corrisponde alla regola @code{BEGIN} di @command{awk}
(@pxref{BEGIN/END}).
Nella preparazione di una torta, questa fase corrisponde a quella di
tirar fuori tutti i contenitori in cui mischiare gli ingredienti, e la
teglia in cui cuocerla, e nell'assicurarsi di avere a disposizione tutti gli
ingredienti necessari.
@item Elaborazione
Questa fase @`e quella in cui si svolge il lavoro vero e proprio. Il programma
legge i dati, raggruppati in ``pezzi logici'', e li elabora secondo necessit@`a.
In quasi tutti i linguaggi di programmazione, la lettura dei dati va gestita
manualmente, controllando dopo ogni lettura se @`e
rimasto ancora qualcosa d'altro da leggere. Il paradigma @dfn{criterio di
ricerca--azione} di @command{awk}
@iftex
(@pxrefil{Per iniziare})
@end iftex
@ifnottex
(@pxref{Per iniziare})
@end ifnottex
gestisce automaticamente la parte di lettura dati.
Nella preparazione di una torta, l'elaborazione corrisponde all'attivit@`a
vera e propria: rompere le uova, mescolare la farina, l'acqua e gli altri
ingredienti, e quindi mettere la torta a cuocere nel forno.
@item Pulizia
Una volta elaborati tutti i dati, ci sono attivit@`a da svolgere prima di aver
finito. Questa fase corrisponde alla regola @code{END} di @command{awk}.
(@pxref{BEGIN/END}).
Dopo che la torta @`e stata tirata fuori dal forno, va fatta raffreddare e
avvolta in una pellicola trasparente per evitare che qualcuno la assaggi,
e inoltre vanno lavati i contenitori e le posate.
@end table
@cindex algoritmi
Un @dfn{algoritmo} @`e la descrizione dettagliata della procedura necessaria per
svolgere un compito o per elaborare dati. Lo si pu@`o paragonare alla ricetta
per preparare una torta. I programmi sono il modo con cui un
algoritmo viene eseguito da un computer.
Spesso @`e compito del programmatore sia sviluppare un algoritmo, sia
programmarlo.
@cindex record
@cindex campi
I ``pezzi logici'' nominati precedentemente sono chiamati @dfn{record}
(registrazioni), in analogia con le registrazioni del personale di una ditta,
degli studenti di una scuola, o dei pazienti di un dottore.
Ogni record @`e composto di molte parti, per esempio nome, cognome, data di
nascita, indirizzo, e cos@`{@dotless{i}} via. Le parti di cui @`e composto un record sono
chiamate @dfn{campi} del record.
L'atto di leggere i dati @`e noto come @dfn{input}, e quello di generare
risultati @`e, come facilmente prevedibile, chiamato @dfn{output}. Spesso i due
sono riuniti sotto il nome di ``input/output'' e, ancor pi@`u spesso, con
l'abbreviazione ``I/O''. (In inglese ``input'' e ``output'' sono spesso usati
come verbi, nel gergo informatico, al posto di leggere e scrivere.)
@cindex guidati-dai-dati @subentry linguaggi di programmazione
@cindex linguaggi di programmazione @subentry guidati dai dati
@command{awk} gestisce la lettura dei dati, come anche la divisione in
record e campi. Lo scopo del programma dell'utente @`e di dire ad @command{awk}
cosa fare con i dati. Questo vien fatto descrivendo @dfn{modelli} da
ricercare nei dati e @dfn{azioni} da eseguire qualora si siano trovati questi
modelli. Questa caratteristica dei programmi @command{awk}, di essere
@dfn{guidati-dai-dati}, di solito li rende pi@`u facili sia da scrivere che da
leggere.
@node Fondamenti sui tipi di dati
@appendixsec Valore dei dati in un computer
@cindex variabili
In un programma si tiene traccia di informazioni e valori in contenitori
chiamati @dfn{variabili}. Una variabile @`e solo un nome per designare un certo
valore, come @code{nome}, @code{cognome}, @code{indirizzo}, e cos@`{@dotless{i}} via.
@command{awk} ha molte variabili predefinite, e ha dei nomi speciali per
designare il record in input corrente e i campi che compongono il record
stesso. Si possono inoltre raggruppare molti valori associati tra di loro
sotto un unico nome, utilizzando un vettore.
@cindex valori @subentry numerici
@cindex valori @subentry di tipo stringa
@cindex valori @subentry scalari
@cindex scalari @subentry valori
I dati, in particolare in @command{awk}, possono avere valori numerici, come 42
o 3.1415927, o avere come valore delle stringhe. Un valore di tipo stringa @`e
essenzialmente qualsiasi cosa che non sia un numero, per esempio un nome. Le
stringhe sono talora chiamate @dfn{dati di tipo carattere}, poich@'e memorizzano
i singoli caratteri che le formano. Le singole variabili, come pure le
variabili numeriche e di tipo stringa, sono definite come valori
@dfn{scalari}. Raggruppamenti di valori, come i vettori, non sono scalari.
@iftex
La
@end iftex
@ref{Aritmetica del computer}, ha fornito un'introduzione di base ai tipi
numerici (interi e in virgola mobile) e a come questi sono usati in un computer.
Si consiglia di rileggere quelle informazioni, comprese le numerose avvertente
l@`a esposte.
@cindex stringa nulla
Mentre @`e probabile che ci si sia abituati all'idea di un numero senza un valore
(cio@`e, allo zero), richiede un po' pi@`u di riflessione abituarsi all'idea di
dati di tipo carattere a lunghezza zero. Nonostante ci@`o, questo tipo di dato
esiste. @`E chiamato @dfn{stringa nulla}. La stringa nulla @`e un dato di tipo
carattere che non ha un valore. In altre parole, @`e vuoto. Si scrive cos@`{@dotless{i}} nei
programmi @command{awk}: @code{""}.
Gli esseri umani sono abituati a usare il sistema decimale, cio@`e a base 10.
In base 10, i numeri vanno da 0 a 9, e poi ``vengono riportati'' nella
colonna
@iftex
colonna successiva.
(Chi si ricorda la scuola elementare? @math{42 = 4 volte 10 + 2}.)
@end iftex
@ifnottex
colonna successiva.
(Chi si ricorda la scuola elementare? 42 = 4 x 10 + 2.)
@end ifnottex
Ma esistono anche altre basi per i numeri. I computer normalmente usano
la base 2 o @dfn{binaria}, la base 8 o @dfn{ottale}, e la base 16 o
@dfn{esadecimale}. Nella numerazione binaria, ogni colonna rappresenta il
doppio del valore della colonna alla sua destra. Ogni colonna pu@`o contenere
solo uno 0 o un 1.
@iftex
Quindi, il numero binario 1010 rappresenta @math{(1 volta 8) + (0 volte 4)
+ (1 volta 2) + (0 volte 1)}, ossia il numero decimale 10.
@end iftex
@ifnottex
Quindi, il numero binario 1010 rappresenta (1 x 8) + (0 x 4)
+ (1 x 2) + (0 x 1), ossia il numero decimale 10.
@end ifnottex
Le numerazioni ottale ed
esadecimale sono trattate pi@`u ampiamente
@ifnottex
in
@end ifnottex
@iftex
nella
@end iftex
@ref{Numeri non-decimali}.
Al livello pi@`u basso possibile, i computer memorizzano i valori come gruppi di
cifre binarie, o @dfn{bit}. I computer moderni raggruppano i bit in gruppi di
otto, detti @dfn{byte}. Applicazioni avanzate talora hanno necessit@`a di
manipolare i bit direttamente, e @command{gawk} @`e dotato di apposite funzioni.
I programmi sono scritti nei linguaggi di programmazione. Esistono centinaia,
se non migliaia, di linguaggi di programmazione. Uno dei pi@`u diffusi @`e il
linguaggio di programmazione C. Il linguaggio C ha esercitato un'influsso
molto forte nella progettazione del linguaggio @command{awk}.
@cindex Kernighan, Brian
@cindex Ritchie, Dennis
Ci sono state parecchie versioni di C. La prima @`e spesso designata come
``K&R'' C, dalle iniziali di Brian Kernighan e Dennis Ritchie,
gli autori del primo libro sul C. (Dennis Ritchie ha creato il linguaggio,
e Brian Kernighan @`e stato uno dei creatori di @command{awk}.)
A met@`a degli anni '80 @`e iniziato uno sforzo rivolto a produrre uno
standard internazionale per il C. Questo lavoro ha raggiunto un punto di
arrivo nel 1989 con la produzione dello standard ANSI per il C.
Questo standard @`e diventato uno standard ISO nel 1990.
Nel 1999, uno standard ISO C revisionato @`e stato approvato e pubblicato.
Dove @`e opportuno, POSIX @command{awk} @`e compatible con lo standard
ISO C del 1999.
@node Glossario
@unnumbered Glossario
@table @asis
@item Abbraccio mortale
La situazione in cui due processi che comunicano tra loro sono entrambi bloccati, in
attesa che l'altro processo faccia qualcosa.
@cindex Ada @subentry linguaggio di programmazione
@cindex linguaggi di programmazione @subentry Ada
@item Ada
Un linguaggio di programmazione originalmente definito dal Department of
Defense U.S.A.@: per la programmazione integrata. @`E stato progettato per
favorire dei buoni metodi da seguire nell'ingegneria del software.
@item Ambiente
Si veda ``Variabili d'ambiente''.
@item @`Ancora
I metacaratteri @dfn{regexp} @samp{^} e @samp{$}, che richiedono che la
corrispondenza che si sta cercando si trovi all'inizio o alla fine di una
stringa, rispettivamente.
@cindex angolo buio
@item Angolo buio
Un'area del linguaggio le cui specifiche spesso non erano (o ancora non
sono) chiare, col risultato di ottenere un comportamente inatteso o non
desiderabile.
Tali aree sono segnalate in questo @value{DOCUMENT} con
@iftex
il disegno di una torcia a margine
@end iftex
@ifnottex
``(a.b.)'' nel testo
@end ifnottex
e sono riportate nell'indice analitico sotto la voce ``angolo buio''.
@cindex ANSI
@item ANSI
L'American National Standards Institute. Questo ente produce
parecchi standard, e tra questi gli standard per i linguaggi di
programmazione C e C++.
Questi standard spesso diventano anche internazionali. Si veda anche
``ISO''.
@item Argomento
Un argomento pu@`o essere due cose differenti. Pu@`o essere un'opzione o un
@value{FN} passato a un comando mentre lo si invoca dalla riga dei comandi,
oppure pu@`o essere qualcosa passato a una @dfn{funzione} all'interno di un
programma, per esempio all'interno di @command{awk}.
In quest'ultimo caso, un argomento pu@`o essere passato a una funzione in
due modi. Nel primo modo @`e passato come valore alla funzione chiamata,
ossia una copia del valore della variabile @`e reso disponibile alla funzione
chiamata, ma la variabile originale non pu@`o essere modificata dalla
funzione stessa. Nel secondo modo l'argomento @`e passato per riferimento,
ossia un puntatore alla variabile in questione @`e passato alla funzione, che
pu@`o quindi modificarla direttamente. In @command{awk} le variabili scalari
sono passate per valore, e i vettori sono passati per riferimento.
Si veda ``Passaggio per valore/riferimento''.
@item Arrotondamento
Arrotondare il risultato di un'operazione aritmetica pu@`o essere difficile.
C'@`e pi@`u di un modo di arrotondare, e in @command{gawk} @`e possibile scegliere
quale metodo dovrebbe essere usato all'interno di un programma.
@xref{Impostare modo di arrotondare}.
@item Assegnamento
Un'espressione @command{awk} che cambia il valore di qualche variabile o
dato oggetto di @command{awk}. Un oggetto a cui si pu@`o assegnare un valore
@`e detto un @dfn{lvalue}. I valori
assegnati sono chiamati @dfn{rvalue}.
@xref{Operatori di assegnamento}.
@cindex Spencer, Henry
@cindex @command{sed} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{sed}
@cindex amazing @command{awk} assembler (programma @command{aaa})
@cindex programma @subentry @command{aaa} (amazing @command{awk} assembler)
@item Assembler incredibilmente scritto in @command{awk}
Henry Spencer dell'Universit@`a di Toronto ha scritto un assembler adatto a
molti diversi hardware, usando solo @dfn{script} @command{sed} e
@command{awk}. @`E lungo migliaia di righe, e include
la descrizione dell'hardware di
numerosi micro-computer a 8 bit. @`E un
buon esempio di programma per cui sarebbe stato
meglio utilizzare un altro linguaggio.
@c Si pu@`o scaricare da @uref{http://awk.info/?awk100/aaa}.
@item Asserzione
Un'istruzione in un programma che afferma che una condizione @`e verificata in
un dato punto di un programma.
Utile per ragionare su come si suppone funzioni un programma.
@item Azione
Una serie di istruzioni @command{awk} associate a una regola. Se
l'espressione di ricerca della regola individua un record in input,
@command{awk} esegue su quel record l'azione relativa. Le azioni sono
sempre racchiuse tra parentesi graffe.
(@xref{Panoramica sulle azioni}).
@item Bash
La versione GNU della shell standard
@ifnotinfo
(il @b{B}ourne-@b{A}gain @b{SH}ell).
@end ifnotinfo
@ifinfo
(il Bourne-Again SHell).
@end ifinfo
Si veda anche ``Bourne Shell''.
@item Binario
Notazione a base due, che usa le cifre @code{0}--@code{1}. Poich@'e
i circuiti elettronici funzionano ``naturalmente'' in base 2
(basta pensare a Off/On), ogni cosa all'interno di un computer @`e
calcolata usando la base 2. Ciascuna cifra rappresenta la presenza
(o l'assenza) di una potenza di 2 ed @`e chiamata un @dfn{bit}.
Cos@`{@dotless{i}}, per esempio, il numero in base due @code{10101} rappresenta il
numero in base decimale 21,
@iftex
(@math{(1 volta 16) + (1 volta 4) + (1 volta 1)}).
@end iftex
@ifnottex
((1 x 16) + (1 x 4) + (1 x 1)).
@end ifnottex
Poich@'e i numeri in base due diventano rapidamente molto lunghi
sia da leggere che da scrivere, normalmente li si unisce a gruppi di tre
(ossia, sono visti come numeri ottali) o a gruppi di quattro (ossia, sono
visti come numeri esadecimali). Non c'@`e un modo diretto per inserire
numeri a base due in un programma C. Se necessario, tali numeri vengono
solitamente inseriti come numeri ottali o esadecimali.
Il numero di cifre in base due contenuto nei registri usati per
rappresentare i numeri interi all'interno dei computer @`e un'indicazione
approssimativa della potenza di calcolo del computer stesso. La maggior
parte dei computer oggi usa 64 bit per rappresentare i numeri interi nei
registri di calcolo, ma registri a 32 bit, 16 bit e 8 bit sono stati
largamente in uso in passato.
@xref{Numeri non-decimali}.
@cindex McIlroy, Doug
@cindex biscotto della fortuna
@item Biscotto della fortuna
Una particolare perla di saggezza, segno, detto o ricordo
prodotto da (o presentato a) un programma. (Con vivi ringraziamenti al Prof.
Doug McIlroy).
@ignore
From: Doug McIlroy
Date: Sat, 13 Oct 2012 19:55:25 -0400
To: arnold@skeeve.com
Subject: Re: origin of the term "cookie"?
I believe the term "cookie", for a more or less inscrutable
saying or crumb of information, was injected into Unix
jargon by Bob Morris, who used the word quite frequently.
It had no fixed meaning as it now does in browsers.
The word had been around long before it was recognized in
the 8th edition glossary (earlier editions had no glossary):
cookie a peculiar goodie, token, saying or remembrance
returned by or presented to a program. [I would say that
"returned by" would better read "produced by", and assume
responsibility for the inexactitude.]
Doug McIlroy
From: Doug McIlroy
Date: Sun, 14 Oct 2012 10:08:43 -0400
To: arnold@skeeve.com
Subject: Re: origin of the term "cookie"?
> Can I forward your email to Eric Raymond, for possible addition to the
> Jargon File?
Sure. I might add that I don't know how "cookie" entered Morris's
vocabulary. Certainly "values of beta give rise to dom!" (see google)
was an early, if not the earliest Unix cookie. The fact that it was
found lying around on a model 37 teletype (which had Greek beta in
its type box) suggests that maybe it was seen to be like milk and
cookies laid out for Santa Claus. Morris was wont to make such
connections.
Doug
@end ignore
@item Bit
Abbreviazione di ``Binary Digit'' [cifra binaria].
Tutti i valori nella memoria di un computer sono rappresentati nella forma di
cifre binarie: valori che sono zero o uno.
Gruppi di bit possono essere interpretati differentemente --- come numeri
interi, numeri in virgola mobile, dati di tipo carattere, indirizzi di altri
oggetti contenuti in memoria, o altri dati ancora.
@command{awk} permette di lavorare con numeri in virgola mobile e stringhe.
@command{gawk} permette di manipolare bit con le funzioni predefinite
descritte
@ifnottex
in
@end ifnottex
@iftex
nella
@end iftex
@ref{Funzioni a livello di bit}.
I computer sono spesso definiti dal numero di bit che usano per rappresentare
valori interi. Molti sistemi sono a 32-bit, ma i sistemi a 64-bit sono sempre
pi@`u numerosi, mentre i sistemi a 16-bit [e quelli a 8-bit] sono praticamente
scomparsi.
@item Bourne Shell
La shell standard (@file{/bin/sh}) in Unix e nei sistemi derivati da Unix,
Originariamente scritto da Steven R.@: Bourne dei Bell Laboratories.
Molte shell (Bash, @command{ksh}, @command{pdksh}, @command{zsh}) sono
generalmente compatibili con la Bourne shell, anche quando offrono ulteriori
funzionalit@`a.
@item C
Il linguaggio di programmazione di sistema con cui @`e scritta la maggior parte
del software GNU. Il linguaggio di programmazione @command{awk} ha una
sintassi simile a quella del C, e
questo @value{DOCUMENT} puntualizza, quando serve, le somiglianze esistenti
fra @command{awk} e C.
In generale, @command{gawk} tenta di essere ragionevolmente simile alla
versione 1990 del C ISO.
@item C Shell
La C Shell (@command{csh} o la sua versione migliorata @command{tcsh}) @`e una
shell Unix creata da Bill Joy verso la fine degli anni '70. La C shell si
differenzia dalla altre shell per le sue funzionalit@`a interattive, e per lo
stile complessivo, che @`e abbastanza simile a quello del linguaggio C.
La C shell non @`e compatibile all'indietro con la Bourne Shell, e per questo
motivo un'attenzione speciale @`e necessaria se si convertono alla C shell
degli @dfn{script} scritti per altre shell Unix, in particolare per ci@`o che
concerne la gestione delle variabili di shell.
Si veda anche ``Bourne Shell''.
@item C++
Un linguaggio di programmazione molto diffuso, orientato agli oggetti,
derivato dal C.
@item Campo
Quando @command{awk} legge un record in input, suddivide il record in parti
separate da spazi vuoti (o da una @dfn{regexp} che individua il separatore,
modificabile reimpostando la variabile predefinita @code{FS}). Tali parti
sono dette campi. Se le parti sono di lunghezza fissa, si pu@`o usare la
variabile predefinita @code{FIELDWIDTHS} per descriverne le lunghezze.
Se si desidera specificare i contenuti dei campi, piuttosto che il separatore
fra i campi, si pu@`o usare la variabile predefinita @code{FPAT} per farlo.
(@xref{Separatori di campo},
@iftex
la
@end iftex
@ref{Dimensione costante},
e
@iftex
la
@end iftex
@ref{Separazione in base al contenuto}).
@cindex ASCII
@cindex ISO @subentry 8859-1 (codifica caratteri)
@cindex ISO @subentry Latin-1 (codifica caratteri)
@cindex caratteri @subentry (codifiche macchina di caratteri)
@cindex insiemi di caratteri (codifiche macchina di caratteri)
@cindex Unicode
@item Caratteri
L'insieme di codici numerici usati da un computer per rappresentare i
caratteri (lettere, numeri, segni d'interpunzione, etc.) di un particolare
paese o localit@`a. L'insieme di caratteri pi@`u comunemente in uso oggi @`e
l'ASCII (American Standard Code for Information Interchange). Molti paesi
europei usano un'estensione dell'ASCII
nota come ISO-8859-1 (ISO Latin-1).
L'insieme di caratteri @uref{http://www.unicode.org, Unicode} sta guadagnando
popolarit@`a e affermandosi come standard, e il suo uso @`e particolarmente esteso
nei sistemi GNU/Linux.
@cindex Kernighan, Brian
@cindex Bentley, Jon
@cindex @command{chem} (programma di utilit@`a)
@cindex programma di utilit@`a @subentry @command{chem}
@item CHEM
Un preprocessore per @command{pic} che legge descrizioni di molecole
e produce l'input a @command{pic} che serve a disegnarle.
@`E stato scritto in @command{awk}
da Brian Kernighan e Jon Bentley, ed @`e disponibile in
@uref{http://netlib.org/typesetting/chem}.
@item Classe di caratteri
Si veda ``Espressione tra parentesi quadre''.
@cindex programmi compilati
@item Compilatore
Un programma che traduce codici sorgente scritti in qualche linguaggio
in codici eseguibili su un particolare computer. Il codice oggetto risultante
pu@`o quindi essere eseguito direttamente dal computer.
Si veda anche ``Interprete''.
@item Concatenazione
Concatenare due stringhe significa unirle, producendo una nuova stringa.
Per esempio, la stringa @samp{pippo} concatenata con
la stringa @samp{pluto} produce la stringa @samp{pippopluto}.
(@xref{Concatenazione}).
@item Contatore di riferimenti
Un meccanismo interno di @command{gawk} per minimizzare la quantit@`a di
memoria necessaria per contenere il valore delle variabili di tipo
stringa. Se il valore assunto da una variabile @`e usato in pi@`u di un
posto nel programma, solo una copia del valore stesso @`e tenuta in
memoria, e il contatore di riferimenti ad esso associato @`e aumentato di
uno quando lo stesso valore @`e usato da un'ulteriore variabile, e diminuito
di uno quando la variabile relativa non @`e pi@`u utilizzata. Quando il
contatore di riferimenti va a zero, la parte di memoria utilizzata per
contenere il valore della variuabile @`e liberato.
@item Coprocesso
Un programma subordinato con il quale @`e possibile una comunicazione
bidirezionale dal programma principale.
@item Dati oggetto
Sono costituiti da numeri e stringhe di caratteri. I numeri sono convertiti
in stringhe e viceversa, a seconda delle necessit@`a.
(@xref{Conversione}).
@item Debugger
Un programma che serve agli sviluppatori per rimuovere ``bug'' (de-bug) dai
loro programmi.
@item Dominio di testo
Un nome unico che identifica un'applicazione.
Usato per raggruppare messaggi che sono tradotti in fase di esecuzione
nel linguaggio locale.
@item Doppia precisione
Una rappresentazione di numeri all'interno del computer che ha una parte
espressa sotto forma di frazione. I numeri a doppia precisione hanno pi@`u
cifre decimali che quelli a singola precisione, ma le operazioni che la
usano consumano pi@`u risorse di quelle
eseguite in singola precisione. La doppia precisione @`e il formato con cui
@command{awk} memorizza i valori numerici. Nel linguaggio C @`e il tipo di
dati detto @code{double}.
@item Editore di flusso
Un programma che legge record da un flusso in input e li elabora uno o
pi@`u alla volta. Questo @`e diverso da quel che farebbe un programma batch
il quale potrebbe leggere completamente i file in input, prima di
iniziare a fare alcunch@'e, ed @`e diverso anche da un programma interattivo, che
richiede input dall'utente [tipicamente, una riga alla volta].
@item Effetto collaterale
Un effetto collaterale ha luogo quando un'espressione ha un effetto ulteriore,
invece di produrre solo un valore. Espressioni di assegnamento,
incremento e decremento, e invocazioni di funzioni hanno effetti collaterali.
(@xref{Operatori di assegnamento}).
@cindex epoch @subentry definizione di
@item Epoca [Inizio del tempo in Unix]
la data usata come ``inizio del tempo'' per i campi che contengono date.
I valori del tempo nella maggior parte dei dei sistemi sono rappresentati
in numero di secondi trascorsi dall'Epoca, con funzioni di libreria
che consentono di convertire tali valori nei formati normali di data e ora.
L'Epoca nei sistemi Unix e POSIX parte dal primo gennaio 1970 alle ore
00:00:00 UTC.
Si veda anche ``GMT'' e ``UTC''.
@item Esadecimale
@cindex ASCII
Notazione per l'aritmetica in base 16, che usa le cifre @code{0}--@code{9} e
le lettere @code{A}--@code{F}, con @samp{A}
che rappresenta 10, @samp{B} che rappresenta 11, e cos@`{@dotless{i}} via, fino a
@samp{F} per 15.
I numeri esadecimali sono scritti in C prefissandoli con @samp{0x},
per indicarne la base.
@iftex
Quindi, @code{0x12} @`e 18 (@math{(1 volta 16) + 2}).
@end iftex
@ifnottex
Quindi, @code{0x12} @`e 18 ((1 x 16) + 2).
@end ifnottex
@xref{Numeri non-decimali}.
@item Espressione booleana
Cos@`{@dotless{i}} detta dal nome del matematico inglese George Boole.
Si veda anche ``Espressione logica''.
@item Espressione condizionale
Un'espressione che usa l'operatore ternario @samp{?:}, come p.es.
@samp{@var{expr1} ? @var{expr2} : @var{expr3}}. Dell'espressione
@var{expr1} viene calcolato il valore; se risulta verificata, il valore
dell'intera espressione diviene quello di @var{expr2}; altrimenti il valore @`e
quello di @var{expr3}. In ogni caso, solo una delle due espressioni
@var{expr2} e @var{expr3}
viene calcolata. (@xref{Espressioni condizionali}).
@item Espressione di confronto
Una relazione che @`e vera o falsa, del tipo di @samp{a < b}.
Espressioni di confronto sono usate nelle istruzioni
@code{if}, @code{while}, @code{do}, @code{for}
e nelle espressioni di ricerca per scegliere quale record in input elaborare.
(@xref{Tipi di variabile e confronti}).
@item Espressione di intervallo
Una parte di un'espressione regolare che permette di specificare
corrispondenze multiple di qualche parte della @dfn{regexp}. Le espressioni di
intervallo non erano originariamente ammesse nei programmi @command{awk}.
@item Espressione di ricerca [@dfn{pattern}]
@itemx (detta anche "criterio di ricerca" o "modello di ricerca")
Le espressioni di ricerca individuano per @command{awk} a quali record in
input sono applicabili determinate
regole.
Un'espressione di ricerca [pattern] @`e un'espressione condizionale specifica
che viene confrontata con ogni record
in input. Se la corrispondenza esiste, si dice che il modello @dfn{individua}
il record in input. Una tipica espressione di ricerca potrebbe confrontare
il record in input con un'espressione regolare.
(@xref{Panoramica sui criteri di ricerca}).
@item Espressione logica
Un'espressione che usa gli operatori logici AND, OR e NOT,
scritti come @samp{&&}, @samp{||}, e @samp{!} in @command{awk}.
Spesso chiamate espressioni booleane, dal nome del matematico che per primo
ha sistematizzato questo tipo di logica matematica.
@item Espressione regolare
un'espressione regolare (abbreviabile come ``@dfn{regexp}'') @`e un modello che
descrive un assieme di stringhe, potenzialmente illimitato. Per esempio
l'espressione regolare
@samp{R.*xp} corrisponde a qualsiasi stringa che inizia con la lettera
@samp{R} e termina con le lettere @samp{xp}. In @command{awk}, le espressioni
regolari sono usate nei modelli [pattern] e nelle espressioni condizionali.
Le espressioni regolari possono contenere sequenze di protezione.
@iftex
(@xrefil{Espressioni regolari}).
@end iftex
@ifnottex
(@xref{Espressioni regolari}).
@end ifnottex
@item Espressione regolare calcolata
Si veda ``Espressioni regolari dinamiche''.
@item Espressione regolare costante
Un'espressione regolare costante @`e un'espressione regolare scritta tra barre,
come @code{/pippo/}. A una tale espressione viene assegnato un valore quando
si scrive un programma @command{awk} e non pu@`o essere modificata in fase di
esecuzione del programma. (@xref{Uso di @dfn{regexp}}.)
@item Espressione regolare dinamica
Un'espressione regolare dinamica @`e un'espressione regolare scritta come
un'espressione normale. Potrebbe essere una costante stringa, come
@code{"pippo"}, ma potrebbe anche essere un'espressione il cui valore @`e variabile
(@xref{Espressioni regolari calcolate}).
@item Espressione tra parentesi quadre
All'interno di una @dfn{espressione regolare}, un'espressione racchiusa
fra parentesi quadre sta a indicare che un singolo carattere appartiene
a una specifica classe di caratteri. Un'espressione tra parentesi quadre
pu@`o contenere una lista di uno o pi@`u caratteri, come @samp{[abc]}, un
intervallo di caratteri, come @samp{[A-Z]}, o un nome, delimitato da
@samp{:}, che designa un insieme di caratteri conosciuto, come
@samp{[:digit:]}. La forma di espressione tra parentesi quadre
racchiusa tra @samp{:} @`e indipendente dalla rappresentazione binaria dei
caratteri stessi, che potrebbe utilizzare le codifiche ASCII, EBCDIC, o
Unicode, a seconda dell'architettura del computer, e della localizzazione.
Si veda anche ``Espressioni regolari''.
@item Espressione tra parentesi quadre complementata
La negazione di una @dfn{espressione tra parentesi quadre}. Tutto ci@`o che
@emph{non} @`e descritto da una data espressione tra parentesi quadre.
Il simbolo @samp{^} precede l'espressione tra parentesi quadre che viene
negata. Per esempio: @samp{[^[:digit:]]}
designa qualsiasi carattere che non sia una cifra. @samp{[^bad]}
designa qualsiasi carattere che non sia una delle lettere @samp{b}, @samp{a},
o @samp{d}.
Si veda ``Espressione tra parentesi quadre''.
@item Estensione
Una funzionalit@`a aggiunta o una modifica a un linguaggio di programmazione
o a un programma di utilit@`a, non definita dallo standard di quel linguaggio
o di quel programma di utilit@`a.
@command{gawk} ha molte estensioni rispetto al POSIX @command{awk} (fin
troppe).
@item FDL
Free Documentation License. Si veda ``Licenza Documentazione Libera''.
@item File speciale
Un @value{FN} interpretato internamente da @command{gawk}, invece che
gestito direttamente dal sistema operativo in cui viene eseguito
@command{gawk} --- per esempio, @file{/dev/stderr}.
(@xref{File speciali}).
@item Flag [Indicatore]
Una variabile [di tipo booleano] che, se verificata, indica la presenza o
l'assenza di qualche condizione.
@item Formato
Le stringhe di formato controllano il modo in cui le funzioni
@code{strftime()}, @code{sprintf()} e l'istruzione @code{printf} visualizzano
l'output che producono. Inoltre, le conversioni da numeri a stringhe sono
controllate dalle stringhe di formato contenute nelle variabili predefinite
@code{CONVFMT} e @code{OFMT}. (@xref{Lettere di controllo}).
@cindex formattatore incredibilmente duttile (@command{awf})
@cindex programma @subentry @command{awf} (formattatore incredibilmente duttile)
@item Formattatore incredibilmente duttile (@command{awf})
Henry Spencer all'Universit@`a di Toronto ha scritto un formattatore che
accetta un ampio sottoassieme dei comandi di formattazione @samp{nroff -ms}
e @samp{nroff -man} usando
@command{awk} e @command{sh}.
@c Si pu@`o scaricare da @uref{http://awk.info/?tools/awf}.
@item Fortran
Abbreviazione di FORmula TRANslator (traduttore di formule), @`e uno dei primi
linguaggi di programmazione, pensato per il calcolo scientifico.
@`E stato ideato da John Backus ed @`e disponibile a partire dal 1957. @`E ancora
in uso ai giorni nostri.
@cindex FSF (Free Software Foundation)
@cindex Free Software Foundation (FSF)
@cindex Stallman, Richard
@item Free Software Foundation
Un'organizzazione senza fini di lucro dedicata alla
produzione e distribuzione di software liberamente distribuibile.
@`E stata fondata da Richard M.@: Stallman, l'autore dell'originale editor
Emacs. GNU Emacs @`e la versione di Emacs maggiormente usata oggigiorno.
@item FSF
Si veda ``Free Software Foundation''.
@item Funzione
Una parte di un programma @command{awk} che si pu@`o chiamare da qualsiasi
punto del programma, per eseguire un compito. @command{awk} ha parecchie
funzioni predefinite.
Gli utenti possono definire essi stessi delle funzioni in qualsiasi parte
del programma. Le funzioni possono essere ricorsive, ossia possono
chiamare se stesse.
@iftex
@xrefil{Funzioni}.
@end iftex
@ifnottex
@xref{Funzioni}.
@end ifnottex
In @command{gawk} @`e anche possibile avere funzioni condivise tra diversi
programmi, incluse secondo necessit@`a usando la direttiva
@code{@@include}
(@pxref{Includere file}).
In @command{gawk} il nome della funzione da chiamare pu@`o essere generato
in fase di esecuzione, ossia in maniera dinamica.
L'estensione API di @command{gawk} fornisce funzioni di costruzione
(@pxref{Funzioni di costruzione}).
@item Funzioni predefinite
Il linguaggio @command{awk} fornisce funzioni predefinite, che compiono
calcoli vari, di tipo numerico, di input/output e di tipo carattere. Esempi
sono @code{sqrt()} ([square root], la radice quadrata di un numero) e
@code{substr()} (che estrae una sottostringa da una stringa).
@command{gawk} fornisce funzioni per la gestione di data e ora,
le operazioni a livello di bit, l'ordinamento di
vettori, il controllo di tipo [di variabile] e la traduzione di stringhe
in fase di esecuzione di programma.
(@xref{Funzioni predefinite}).
@item @command{gawk}
L'implementazione GNU di @command{awk}.
@cindex GPL (General Public License)
@cindex GNU @subentry General Public License
@item General Public License
Un documento che descrive le condizioni alle quali @command{gawk} e i suoi
file sorgenti possono essere distribuiti. (@xref{Copia}).
@item GMT
``Greenwich Mean Time''.
Il termine tradizionalmente usato per UTC.
@`E la datazione usata internamente dai sistemi Unix e POSIX.
Si veda anche ``Epoca'' e ``UTC''.
@cindex FSF (Free Software Foundation)
@cindex Free Software Foundation (FSF)
@cindex progetto @subentry GNU
@item GNU
``GNU's not Unix'' (GNU non @`e Unix).
Un progetto della Free Software Foundation, ancora in corso, che mira a creare
un ambiente di calcolo completo, liberamente distribuibile, aderente allo
standard POSIX.
@item GNU/Linux
Una variante del sistema GNU che usa il kernel Linux,
invece del kernel proprio della Free Software Foundation, noto come Hurd.
Il kernel Linux @`e un clone di Unix stabile, efficiente, completo di tutte le
funzionalit@`a, ed @`e stato portato su varie architetture hardware.
@`E molto diffuso su sistemi del tipo dei Personal Computer, ma funziona bene
anche in parecchi altri computer.
Il codice sorgente del kernel Linux @`e disponibile nei termini della GNU General
Public License, la qual cosa @`e forse il suo aspetto pi@`u rilevante.
@item GPL
Si veda ``General Public License''.
@item Graffe
I caratteri @samp{@{} e @samp{@}}. Le parentesi graffe sono usate in
@command{awk} per delimitare azioni, istruzioni composte, e il codice che
costituisce le funzioni.
@item Guidato dai dati
Una descrizione dei programmi @command{awk}, nei quali si specifica quali sono
i dati che si vogliono elaborare, e cosa fare quando si trovano tali dati.
@item I/O
Abbreviazione per ``Input/Output,'' ovvero il trasferimento di dati da e verso
un programma in esecuzione.
@item Individuazione
L'azione che consiste nel confrontare una stringa con un'espressione regolare.
Se la @dfn{regexp} descrive qualcosa che @`e contenuto nella stringa, si dice che
la @dfn{individua}.
@item Internazionalizzazione
La procedura con cui si scrive o si modifica un programma
in modo che possa inviare messaggi in lingue differenti, senza richiedere
ulteriori modifiche al codice sorgente.
@item Intero
Un numero intero, cio@`e un numero che non ha una parte frazionaria.
@cindex programmi interpretati
@item Interprete
Un programma che accetta come input del codice sorgente, e usa le
istruzione contenute nello stesso per elaborare dati e fornire risultati.
@command{awk} @`e tipicamente (ma non sempre) implementato come un interprete.
Si veda anche ``Compilatore''.
@item Intervallo (nelle righe di input)
Una sequenza di righe consecutive nel/nei file in input. Un'espressione di
ricerca pu@`o specificare intervalli di righe di input da far elaborare ad
@command{awk} oppure pu@`o specificare singole righe.
(@xref{Panoramica sui criteri di ricerca}).
@cindex ISO
@item ISO
Acronimo di International Organization for Standardization.
Questo ente elabora degli standard internazionali in vari settori, inclusi i
linguaggi di programmazione, come il C e il C++.
In ambito informatico, standard importanti come quelli per il C, C++, e POSIX
sono allo stesso tempo standard nazionali americani e standard internazionali
ISO.
In questo @value{DOCUMENT} lo Standard C @`e chiamato ``ISO C''.
Si veda @uref{https://www.iso.org/iso/home/about.htm, il sito web ISO} per
ulteriori informazioni sul nome dell'ente e sul suo acronimo di tre lettere,
che rimane lo stesso in tutte le lingue.
@item Istruzione
Un'espressione all'interno di un programma @command{awk} nella parte
"azione" di una regola @dfn{criterio di ricerca--azione}, o all'interno
di una funzione @command{awk}. Un'espressione pu@`o essere un assegnamento
di variabile, un'operazione su un vettore, un ciclo, etc.
@item Istruzione composta
Una serie di istruzioni @command{awk}, racchiuse tra parentesi graffe.
Le istruzioni composte possono essere nidificate [possono esserci pi@`u livelli
di parentesi graffe].
(@xref{Istruzioni}).
@item Istruzione di controllo
Un'istruzione di controllo @`e un'istruzione per eseguire una data operazione
o un insieme di operazioni all'interno di un programma @command{awk},
se una determinata condizione @`e verificata.
Istruzioni di controllo sono: @code{if}, @code{for}, @code{while}, e @code{do}
(@pxref{Istruzioni}).
@cindex Java @subentry linguaggio di programmazione
@cindex linguaggi di programmazione @subentry Java
@item Java
Un moderno linguaggio di programmazione originalmente sviluppato da Sun
Microsystems (ora Oracle) che prevede la programmazione orientata agli
oggetti. Sebbene normalmente sia implementato compilando le istruzioni
per una macchina virtuale standard (la JVM --- Java Virtual Machine) il
linguaggio pu@`o essere compilato per essere eseguito in maniera nativa.
@item Korn Shell
La Korn Shell (@command{ksh}) @`e una shell Unix sviluppata da David Korn,
presso i Bell Laboratories, nei primi anni '80. La Korn shell @`e
compatibile all'indietro con la Bourne shell e comprende molte funzionalit@`a
presenti nella C Shell.
Si veda anche ``Bourne Shell''.
@item LDL
Si veda ``Licenza Documentazione Libera''.
@cindex LGPL (Lesser General Public License)
@cindex Lesser General Public License (LGPL)
@cindex GNU @subentry Lesser General Public License
@item Lesser General Public License
Questo documento descrive i termini nei quali possono essere distribuiti
degli archivi contenenti librerie in formato eseguibile o oggetti condivisi,
e il relativo codice sorgente.
@item LGPL
Si veda ``Lesser General Public License''.
@item Licenza Documentazione Libera
Questo documento descrive i termini in base ai quali questo @value{DOCUMENT}
@`e pubblicato e pu@`o essere copiato.
(@xref{Licenza per Documentazione Libera GNU (FDL)}).
@item Linguaggio @command{awk}
Il linguaggio in cui i programmi @command{awk} sono scritti.
@item Linux
Si veda ``GNU/Linux''.
@item Lista di caratteri
Si veda ``Espressione tra parentesi quadre''.
@item Localizzazioni
La funzionalit@`a che fornisce i dati necessari perch@'e un programma
internazionalizzato interagisca con l'utente in un particolare linguaggio.
@item @dfn{Lvalue}
[left-value, ossia valore a sinistra] Un'espressione che pu@`o stare alla
sinistra di un operatore di assegnamento.
Nella maggior parte dei linguaggi, gli @dfn{lvalue} possono essere variabili o
elementi di un vettore. In @command{awk}, un designatore di campo pu@`o anche
essere usato come un @dfn{lvalue}.
@item Marcatura temporale
Un valore nel formato ``secondi a partire dall'epoch'' usato dai sistemi Unix
e POSIX. Usato per le funzioni @command{gawk}
@code{mktime()}, @code{strftime()}, e @code{systime()}.
Si veda anche ``Epoca,'' ``GMT,'' e ``UTC''.
@item Metacaratteri
Caratteri usati all'interno di una @dfn{regexp} e che non rappresentano se
stessi.
Servono invece per rappresentare operazioni con espressioni regolari, come
per esempio delle ripetizioni, dei raggruppamenti, o delle alternanze.
@item Nidificazione
Una nidificazione si riscontra dove l'informazione @`e organizzata a strati,
o dove degli oggetti contengono altri oggetti simili.
In @command{gawk} la direttiva @code{@@include}
pu@`o essere nidificata. La nidificazione ``naturale'' delle operazioni
aritmetiche e logiche pu@`o essere modificato attraverso l'uso di parentesi.
(@pxref{Precedenza}).
@item No-op
Un'operazione che non fa nulla.
@item Numero
Un dato oggetto il cui valore @`e numerico. Le implementazioni di @command{awk}
usano numeri in virgola mobile in doppia precisione per rappresentare i numeri.
Le primissime implementazioni di @command{awk} usavano numeri in virgola mobile
in singola precisione.
@item Numero in virgola mobile
Spesso descritto, in termini matematici, come un numero ``razionale'' o reale,
@`e soltanto un numero che pu@`o avere una parte frazionaria.
Si veda anche ``Doppia precisione'' e ``Singola precisione''.
@item Operatori di espressioni regolari
Si veda ``Metacaratteri''.
@item Ottale
Notazione avente come base 8, nella quale le cifre sono @code{0}--@code{7}.
I numeri ottali in C sono scritti premettendo uno @samp{0},
per indicare la base.
@iftex
Quindi, @code{013} @`e 11 (@math{(1 volta 8) + 3}).
@end iftex
@ifnottex
Quindi, @code{013} @`e 11 ((1 x 8) + 3).
@end ifnottex
@xref{Numeri non-decimali}.
@item Parentesi Graffe
Si veda ``Graffe''.
@item Parola chiave
nel linguaggio @command{awk}, una parola chiave (keyword) @`e una parola
che ha un significato speciale. Queste parole sono riservate e non possono
essere usate come nomi di variabili.
Le parole chiave di @command{gawk} sono:
@code{BEGIN},
@code{BEGINFILE},
@code{END},
@code{ENDFILE},
@code{break},
@code{case},
@code{continue},
@code{default},
@code{delete},
@code{do@dots{}while},
@code{else},
@code{exit},
@code{for@dots{}in},
@code{for},
@code{function},
@code{func},
@code{if},
@code{next},
@code{nextfile},
@code{switch},
e
@code{while}.
@item PEBKAC
Un acronimo inglese che descrive qual @`e probabilmente la causa pi@`u frequente
di problemi nell'uso di un computer. (@dfn{Problem Exists Between Keyboard and
Chair} [il problema si trova tra la tastiera e la sedia].)
@item Percorso di ricerca
In @command{gawk}, una lista di directory in cui cercare file contenenti del
codice sorgente per @command{awk}.
Nella shell, una lista di directory in cui ricercare un programma eseguibile.
@item Plug-in
Si veda ``Estensione''.
@item POSIX
Il nome di una serie di standard che specificano l'interfaccia di un Sistema
Operativo Portabile (Portable Operating System). La ``IX'' specifica
che questi standard sono stati originati dallo Unix.
Lo standard pi@`u rilevante per gli utenti @command{awk} @`e lo
@cite{IEEE Standard for Information Technology, Standard 1003.1@sup{TM}-2017
(Revisione dello Standard IEEE 1003.1-2008)}.
Lo standard POSIX 2018 pu@`o essere trovato in rete all'indirizzo:
@w{@url{https://pubs.opengroup.org/onlinepubs/9699919799/}}.
@item Precedenza
L'ordine in cui le operazioni sono eseguite quando si usano degli operatori
se non si stabiliscono precedenze per mezzo di parentesi.
@item Private
Variabili e/o funzioni che sono riservate all'uso esclusivo di funzioni di
libreria, e non per il programma principale @command{awk}. Un'attenzione
particolare va prestata quando si desigano tali variabili e funzioni.
(@xref{Nomi di variabili di libreria}).
@item Programma @command{awk}
Un programma @command{awk} consiste in una serie di @dfn{espressioni di
ricerca} e @dfn{azioni}, che formano delle @dfn{regole}. Per ogni record in
input a un progranna, le regole del programma sono elaborate nell'ordine in
cui sono scritte. I programmi
@command{awk} possono anche contenere definizioni di funzioni.
@item Record
Si veda ``Record in input'' e ``Record in output''.
@item Record in input
Una singola parte di dati letta da @command{awk}. Solitamente, un
record in input di @command{awk} consiste in una riga di testo.
(@xref{Record}).
@item Record in output
Un singolo pezzo di dati scritto da @command{awk}. Solitamente, un
record in output di @command{awk} consiste di una o pi@`u righe di testo.
@xref{Record}.
@item Ricorsione
Quando una funzione chiama se stessa, direttamente o indirettamente.
Se questo @`e chiaro, si pu@`o passare a leggere la definizione successiva.
Altrimenti, si veda la voce ``Ricorsione''.
@item @dfn{regexp}
Si veda ``Espressione regolare''.
@item Regola
Un segmento di un programma @command{awk} che specifica come trattare singoli
record in input. Una regola consiste in una @dfn{espressione di ricerca} e in
una @dfn{azione}.
@command{awk} legge un record in input; poi, per ogni regola, se il record in
input soddisfa l'espressione di ricerca della regola, @command{awk} esegue
l'azione specificata dalla regola.
Altrimenti, la regola non ha alcun effetto su quel record in input.
@item Ridirezione
Ridirezione significa ricevere input da quaclosa che non sia il flusso dello
standard input, o dirigere output a qualcosa di diverso dal flusso dello
standard output.
Si pu@`o ridirigere input all'istruzione @code{getline} usando gli operatori
@samp{<}, @samp{|}, e @samp{|&}.
Si pu@`o ridirigere l'output delle istruzioni @code{print} e @code{printf} verso
un file o un comando di sistema, usando gli operatori @samp{>}, @samp{>>},
@samp{|}, e @samp{|&}.
(@xref{Getline},
e @ref{Ridirezione}).
@item @dfn{Rvalue}
[right-value, ossia valore a destra] Un valore che pu@`o apparire alla destra
di un operatore di assegnazione.
In @command{awk}, essenzialmente ogni espressione ha un valore.
Ognuno di questi valori @`e un @dfn{rvalue}.
@item Scalare
Un valore singolo, sia numerico che di tipo stringa.
Le variabili normali sono scalari; i vettori e le funzioni non lo sono.
@item Scorciatoia
La natura degli operatori logici @command{awk} @samp{&&} e @samp{||}.
Se il valore dell'intera espressione in cui sono contenuti @`e determinabile
valutando solo una parte iniziale dell'espressione, la parte seguente non @`e
presa in considerazione.
(@xref{Operatori booleani}).
@item @dfn{Script} @command{awk}
Un altro nome per designare un programma @command{awk}.
@item @command{sed}
Si veda ``Editore di flusso''.
@item Seme
Il valore iniziale, o il punto di partenza, di una sequenza di numeri casuali.
@item Sequenze di protezione
Una speciale sequenza di caratteri usata per descrivere caratteri non
stampabili, come @samp{\n} (ritorno a capo) o @samp{\033} per il carattere
ASCII ESC (Escape). (@xref{Sequenze di protezione}).
@item Shell
Il programma che interpreta i comandi nei sistemi Unix e in quelli che
rispettano lo standard POSIX.
La shell funziona sia interattivamente che come un linguaggio di
programmazione, che elabora file sequenziali, detti @dfn{script} di shell.
@item Singola precisione
Una rappresentazione di numeri all'interno del computer che ha una parte
espressa sotto forma di frazione. I numeri a singola precisione hanno meno
cifre significative di quelli a doppia precisione, ma le operazioni relative
richiedono talora meno risorse elaborative da parte del computer.
Questo tipo di numero @`e quello usato da alcune tra le prime versioni di
@command{awk} per memorizzare valori numerici. Nel linguaggio C, sono numeri
di tipo @code{float}.
@item Spazio
Il carattere generato premendo la barra spaziatrice sulla tastiera.
@item Spazio vuoto
Una sequenza di spazi, TAB, o caratteri di ritorno a capo presenti in un
record in input o in una stringa.
@item Stringa
Un dato che consiste in una sequenza di caratteri, come @samp{Io sono una
stringa}. Le costanti stringa sono scritte tra doppi apici nel linguaggio
@command{awk} e possono contenere sequenze di protezione
(@xref{Sequenze di protezione}).
@item Stringa nulla
Una stringa che non contiene alcun carattere. @`E rappresentabile
esplicitamente nei programmi @command{awk} mettendo due caratteri di
doppio apice uno dietro all'altro (@code{""}). La si pu@`o inserire nei dati
in input mettendo due separatori di campo uno dietro all'altro.
@item Stringa vuota
Si veda ``Stringa nulla''.
@item Tab
Il carattere generato premendo il tasto @kbd{TAB} sulla tastiera.
Normalmente pu@`o generare sino a otto spazi in output.
@cindex GNU/Linux
@cindex Unix
@cindex sistemi operativi @subentry basati su BSD
@cindex NetBSD
@cindex FreeBSD
@cindex OpenBSD
@item Unix
Un sistema operativo per computer originalmente sviluppato nei primi anni '70
presso gli AT&T Bell Laboratories. Inizialmente si diffuse nelle universit@`a
di tutto il mondo e in seguito si estese agli ambienti del mondo del lavoro
come un sistema per lo sviluppo del software e come server di rete.
Ci sono parecchie versioni di Unix a pagamento, come pure parecchi sistemi
operativi modellati su Unix e il cui codice sorgente @`e liberamente
disponibile. (come GNU/Linux, @uref{http://www.netbsd.org, NetBSD},
@uref{https://www.freebsd.org, FreeBSD}, e
@uref{http://www.openbsd.org, OpenBSD}).
@item UTC
L'abbreviazione comune per ``Universal Coordinated Time'' (tempo coordinato
universale). Questa @`e l'ora standard di Greenwich, (UK), usata come tempo
di riferimento per i calcoli relativi a marcature temporali.
Si veda anche ``Epoca'' e ``GMT''.
@item Variabile
Un nome per designare un valore. In @command{awk}, le variabili possono
essere degli scalari o dei vettori.
@item Variabili d'ambiente
Una collezione di stringhe, in formato @samp{@var{nome}=@var{valore}}, che
ogni programma ha a disposizione. Gli utenti in generale assegnano valori
alle variabili d'ambiente per fornire informazioni a vari programmi.
Esempi tipici sono le variabili d'ambiente @env{HOME} e @env{PATH}.
@item Variabili predefinite
@code{ARGC},
@code{ARGV},
@code{CONVFMT},
@code{ENVIRON},
@code{FILENAME},
@code{FNR},
@code{FS},
@code{NF},
@code{NR},
@code{OFMT},
@code{OFS},
@code{ORS},
@code{RLENGTH},
@code{RSTART},
@code{RS},
e
@code{SUBSEP}
sono le variabili con un significato speciale in @command{awk}.
In pi@`u,
@code{ARGIND},
@code{BINMODE},
@code{ERRNO},
@code{FIELDWIDTHS},
@code{FPAT},
@code{IGNORECASE},
@code{LINT},
@code{PROCINFO},
@code{RT},
e
@code{TEXTDOMAIN}
sono le variabili con un significato speciale in @command{gawk}.
Se i loro valori sono modificati, il contesto di esecuzione di @command{awk}
cambia.
(@xref{Variabili predefinite}).
@item Vettore
Un raggruppamento di molti valori con uno stesso nome.
La maggior parte dei linguaggi fornisce solo vettori sequenziali.
@command{awk} fornisce vettori associativi.
@item Vettore associativo
Un vettore i cui indici possono essere numeri o stringhe, e non solamente
interi sequenziali compresi in un intervallo prestabilito.
@end table
@end ifclear
@c The GNU General Public License.
@node Copia
@unnumbered Licenza Pubblica Generale GNU (GPL)
@ifnotdocbook
@center Versione 3, 29 Giugno 2007
@end ifnotdocbook
@docbook
Versione 3, 29 Giugno 2007
@end docbook
@c This file is intended to be included within another document,
@c hence no sectioning command or @node.
@display
Copyright @copyright{} 2007 Free Software Foundation, Inc. @url{https://fsf.org/}
This is an unofficial translation of the GNU General Public License into
Italian. It was not published by the Free Software Foundation, and does not
legally state the distribution terms for software that uses the GNU GPL --- only
the original English text of the GNU GPL does that. However, we hope that this
translation will help Italian speakers understand the GNU GPL better.
Questa @`e una traduzione non ufficiale in italiano della GNU General Public
License. Questa traduzione non @`e stata pubblicata dalla Free Software
Foundation, e non stabilisce i termini legali di distribuzione del software
che usa la GNU GPL. Soltanto la versione originale in inglese della GNU GPL
fa ci@`o. Ciononostante, speriamo che questa traduzione possa aiutare gli utenti
di lingua italiana a comprendere un po' meglio la GNU GPL.
A chiunque @`e permesso copiare e ridistribuire copie esatte di questo documento
di licenza, ma non @`e in alcun modo consentito apportarvi modifiche.
@end display
@c fakenode --- for prepinfo
@heading Preambolo
La GNU General Public License @`e una licenza libera e basata su copyleft per
software e altri tipi di opere.
Le licenze della maggior parte del software e di altre opere materiali sono
pensate per togliere la libert@`a di condividere e modificare tali opere. Al
contrario, la GNU General Public License ha l'obiettivo di garantire la
libert@`a di condividere e modificare tutte le versioni di un programma e di
fare in modo che esso rimanga software libero per tutti gli utenti. Noi, Free
Software Foundation, usiamo la GNU General Public License per la maggior parte
del nostro software; essa viene applicata anche a qualunque altro software
rilasciato dall'autore sotto questa licenza. Chiunque pu@`o utilizzare questa
licenza per i suoi programmi.
Quando parliamo di software libero (free software), ci riferiamo al concetto
di libert@`a, non al prezzo. Le nostre General Public License sono progettate
per garantire che chiunque abbia la libert@`a di distribuire copie di software
libero (anche dietro pagamento di un prezzo, se lo desidera), che chiunque
riceva o possa ricevere il codice sorgente se lo vuole, che chiunque possa
apportare modifiche al software o utilizzarne delle porzioni in altri software
liberi, e che chiunque sappia che ha il diritto di fare tutte queste cose col
software libero.
Per proteggere i vostri diritti, abbiamo la necessit@`a di impedire che altri vi
neghino questi diritti o vi obblighino a rinunciarvi. Pertanto, chiunque
distribuisce o modifica software rilasciato con questa licenza assume dei
precisi doveri: il dovere di rispettare la libert@`a degli altri.
Per esempio, chi distribuisce copie di un programma rilasciato sotto questa
licenza, sia gratis che dietro pagamento di un prezzo, e' obbligato a
riconoscere a chi riceve il software esattamente gli stessi diritti che ha
ricevuto. Deve garantire che chi riceva il software abbia o possa avere
accesso al codice sorgente. E deve chiaramente far conoscere ai destinatari
del software queste condizioni, cos@`{@dotless{i}} che essi conoscano quali sono i loro
diritti.
Gli sviluppatori che usano la GNU GPL proteggono i vostri diritti in due modi:
(1) Rivendicando il copyright sul software, e (2) offrendovi questa licenza
che vi garantisce il diritto legale di copiarlo e/o di modificarlo.
Al fine di proteggere gli sviluppatori e gli autori, la GPL spiega chiaramente
che non c'@`e nessuna garanzia per questo software libero. Nell'interesse degli
utenti e degli autori, la GPL impone che le versioni modificate del software
vengano esplicitamente marcate come ``modificate'', in maniera tale che
eventuali problemi non vengano erroneamente attribuiti agli autori delle
versioni precedenti.
Alcuni dispositivi sono progettati per negare agli utenti l'installazione o
l'esecuzione di versioni modificate del software che gira sugli stessi, anche
se il costruttore si riserva la possibilit@`a di farlo. Ci@`o @`e fondamentalmente
incompatibile con l'obiettivo di garantire la libert@`a degli utenti di
modificare il software. Una ripetizione sistematica di tali abusi avviene nel
campo dei dispositivi per usi individuali, e ci@`o rende questi abusi ancora pi@`u
inaccettabili. Pertanto, abbiamo realizzato questa versione della GPL al fine
di proibire queste pratiche. Se problemi simili dovessero sorgere in altri
ambiti, saremo pronti ad estendere queste misure a questi nuovi ambiti in
versioni future della GPL, nella maniera che si render@`a necessaria per
difendere la libert@`a degli utenti.
In conclusione, tutti i programmi sono costantemente minacciati dai brevetti
sul software. Gli Stati non dovrebbero permettere ai brevetti sul software di
limitare lo sviluppo e l'utilizzo di software per computer, ma nei Paesi in
cui ci@`o avviene noi vogliamo evitare in particolare il pericolo che i brevetti
sul software applicati ad un programma libero possano renderlo, a tutti gli
effetti, proprietario. Per impedire ci@`o, la GPL assicura che non @`e possibile
utilizzare i brevetti sul software per rendere un programma non libero.
I termini e le condizioni esatte per la copia, la distribuzione e la modifica
del software sono riportate di seguito.
@c fakenode --- for prepinfo
@heading TERMINI E CONDIZIONI
@enumerate 0
@item Definizioni
``Questa Licenza'' si riferisce alla versione 3 della GNU General Public
License.
``Copyright'' indica anche leggi simili al copyright che riguardano altri tipi
di opere, come le maschere per la produzione di semiconduttori.
``Il Programma'' indica qualunque opera che sia soggetta a copyright e che sia
rilasciata sotto questa Licenza. I detentori della licenza sono indicati come
``tu'' o ``voi''. Licenziatari e destinatari possono essere individui o
organizzazioni.
``Modificare'' un'opera significa copiare o adattare tutta o parte dell'opera in
una maniera che richieda un permesso di copyright, e non indica la semplice
azione di fare una esatta copia dell'opera. L'opera risultante viene chiamata
``versione modificata'' dell'opera precedente, oppure viene detta opera ``basata
sulla'' opera precedente.
Una ``opera coperta da questa licenza'' indica il Programma originale non
modificato oppure un'opera basata sul Programma.
``Propagare'' un'opera significa fare qualunque cosa con essa che, in mancanza
di un esplicito permesso, ti renda direttamente o indirettamente perseguibile
per violazione secondo le vigenti normative sul copyright, ad eccezione della
semplice esecuzione del Programma su un computer o della modifica di una copia
privata. La Propagazione include la copia, la distribuzione (con o senza
modifiche), la messa a disposizione al pubblico e, in alcuni stati, altre
attivit@`a simili e connesse.
``Distribuire'' un'opera indica qualunque forma di propagazione che permetta a
terze parti di effettuare o ricevere delle copie. La mera interazione con un
utente attraverso una rete di computer, senza che ci sia alcun trasferimento
di una copia, non @`e considerata ``Distribuzione''.
Una interfaccia utente interattiva fornisce delle ``Adeguate Informazioni
Legali'' soltanto nel caso in cui include una apposita funzionalit@`a, resa
adeguatamente visibile, che (1) visualizzi un'adeguata informazione di
copyright, e (2) informi l'utente che non c'@`e alcuna garanzia sull'opera
(eccetto nel caso in cui delle garanzie sono espressamente fornite), dica che
il licenziatario pu@`o distribuire l'opera utilizzando questa Licenza, indichi
come @`e possibile prendere visione di una copia di questa Licenza. Se
l'interfaccia presenta una lista di comandi o di opzioni, come per esempio un
men@`u, una delle opzioni fornite nella lista deve rispettare questa condizione.
@item Codice Sorgente
Il ``codice sorgente'' di un'opera indica la forma pi@`u indicata dell'opera per
effettuare modifiche su di essa. Il ``codice oggetto'' indica qualunque forma
dell'opera che non sia codice sorgente.
Una ``Interfaccia Standard'' @`e una interfaccia che risponde ad uno standard
ufficiale definito da un ente di standardizzazione riconosciuto o, nel caso di
interfacce specifiche per un particolare linguaggio di programmazione, una
interfaccia che @`e largamente utilizzata dagli sviluppatori per sviluppare in
tale linguaggio.
Le ``Librerie di Sistema'' di un eseguibile includono qualsiasi cosa, eccetto
l'opera nel suo insieme, che (a) sia inclusa nella normale forma di
pacchettizzazione di un ``Componente Principale'', ma che non @`e parte di quel
Componente Principale, e (b) che serva solo a consentire l'uso dell'opera con
quel Componente Principale, o per implementare una Interfaccia Standard per la
quale esista una implementazione disponibile al pubblico in forma sorgente. Un
``Componente Principale'', in questo contesto, @`e un componente essenziale
(kernel, gestore di finestre eccetera) dello specifico sistema operativo
(ammesso che ce ne sia uno) sul quale l'eseguibile esegue, o un compilatore
utilizzato per produrre il programma, o un interprete di codice oggetto
utilizzato per eseguire il programma.
Il ``Sorgente Corrispondente'' per un'opera in forma di codice oggetto @`e il
codice sorgente necessario per generare, installare e (per un programma
eseguibile) eseguire il codice oggetto e per modificare l'opera, inclusi gli
script per controllare le suddette attivit@`a di generazione, installazione ed
esecuzione. Non sono incluse le Librerie di Sistema usate dal programma, o gli
strumenti di utilit@`a generica o i programmi liberamente accessibili che sono
utilizzati, senza modifiche, per portare a termine le suddette attivit@`a ma che
non fanno parte dell'opera. Per esempio, il sorgente corrispondente include i
file con le definizioni delle interfacce associati ai file sorgente
dell'opera, e il codice sorgente delle librerie condivise e sottoprogrammi
collegati dinamicamente specificatamente necessari per il programma, ad
esempio a causa di stretta comunicazione dati o di controllo di flusso tra
questi sottoprogrammi e altre parti del programma.
Il Sorgente Corrispondente non include qualunque cosa che l'utente possa
rigenerare automaticamente da altre parti del Sorgente Corrispondente stesso.
Il Sorgente Corrispondente di un'opera in forma di codice sorgente @`e l'opera
stessa.
@item Principali Diritti
Tutti i diritti garantiti da questa Licenza sono garantiti per la durata del
copyright sul Programma, e sono irrevocabili ammesso che le suddette
condizioni siano rispettate. Questa Licenza afferma esplicitamente il tuo
permesso illimitato di eseguire il Programma non modificato. Il risultato
dell'esecuzione di un programma coperto da questa Licenza @`e a sua volta
coperto da questa Licenza solo se il risultato stesso, a causa del suo
contenuto, @`e un'opera coperta da questa Licenza. Questa Licenza riconosce il
tuo diritto all'uso legittimo o altri diritti equivalenti, come stabilito
dalla legislazione sul copyright.
Puoi creare, eseguire e propagare programmi coperti da questa Licenza che tu
non distribuisci, senza alcuna condizione fino a quando la tua Licenza rimane
valida. Puoi distribuire opere coperte da questa Licenza ad altri al solo
scopo di ottenere che essi facciano delle modifiche al programma
esclusivamente per te, o che ti forniscano dei servizi per l'esecuzione di
queste opere, ammesso che tu rispetti i termini di questa Licenza nel
distribuire tutto il materiale per il quale non detieni il copyright. Coloro i
quali creano o eseguono per conto tuo un programma coperto da questa Licenza
lo fanno esclusivamente in tua vece, sotto la tua direzione e il tuo
controllo, in maniera tale che sia proibito a costoro effettuare copie di
materiale di cui detieni il copyright al di fuori della relazione che
intrattengono nei tuoi confronti.
Distribuire opere coperte da licenza in qualunque altra circostanza @`e
consentito soltanto alle condizioni espresse in seguito. Non @`e consentito
sottolicenziare le opere: la sezione 10 lo rende non necessario.
@item Protezione dei diritti legali degli utenti dalle leggi anti-elusione
Nessun programma protetto da questa Licenza pu@`o essere considerato parte di
una misura tecnologica di restrizione che sottosta ad alcuna delle leggi che
soddisfano l'articolo 11 del ``WIPO copyright treaty'' adottato il 20 Dicembre
1996, o a simili leggi che proibiscono o limitano l'elusione di tali misure
tecnologiche di restrizione.
Quando distribuisci un programma coperto da questa Licenza, rifiuti tutti i
poteri legali atti a proibire l'elusione di misure tecnologiche di restrizione
ammesso che tale elusione sia effettuata nell'esercizio dei diritti garantiti
da questa Licenza riguardo al programma coperto da questa Licenza, e rinunci
all'intenzione di limitare l'operativit@`a o la modifica del programma per far
valere, contro i diritti degli utenti del programma, diritti legali tuoi o di
terze parti che impediscano l'elusione di misure tecnologiche di restrizione.
@item Distribuzione di Copie Esatte
Ti @`e permesso distribuire copie esatte del codice sorgente del Programma come
lo hai ricevuto, con qualunque mezzo, ammesso che tu aggiunga in maniera
appropriata su ciascuna copia una appropriata nota di copyright; che tu lasci
intatti tutti gli avvisi che affermano che questa Licenza e tutte le clausole
non-permissive aggiunte in accordo con la sezione 7 sono valide per il codice
che distribuisci; che tu lasci intatti tutti gli avvisi circa l'assenza di
garanzia; che tu fornisca a tutti i destinatari una copia di questa Licenza
assieme al Programma.
Puoi richiedere il pagamento di un prezzo o di nessun prezzo per ciascuna
copia che distribuisci, e puoi offrire supporto o garanzia a pagamento.
@item Distribuzione di Versioni modificate del sorgente
Puoi distribuire un'opera basata sul Programma, o le modifiche per produrla a
partire dal Programma, nella forma di codice sorgente secondo i termini della
sezione 4, ammesso che tu rispetti anche tutte le seguenti condizioni:
@enumerate a
@item
L'opera deve recare con s@`e delle informazioni adeguate che affermino che tu
l'hai modificata, indicando la data di modifica.
@item
L'opera deve recare informazioni adeguate che affermino che essa @`e rilasciata
sotto questa Licenza e sotto le condizioni aggiuntive secondo quanto indicato
dalla Sezione 7. Questa condizione modifica la condizione espressa alla
sezione 4 di ``lasciare intatti tutti gli avvisi''.
@item
Devi rilasciare l'intera opera, nel suo complesso, sotto questa Licenza a
chiunque venga in possesso di una copia di essa. Questa Licenza sar@`a pertanto
applicata, assieme ad eventuali clausole aggiunte in osservanza della Sezione
7, all'opera nel suo complesso, a tutte le sue parti, indipendentemente da
come esse siano pacchettizzate. Questa Licenza nega il permesso di licenziare
l'opera in qualunque altro modo, ma non rende nullo un tale permesso ammesso
che tu lo abbia ricevuto separatamente.
@item
Se l'opera ha delle interfacce utente interattive, ciascuna deve mostrare
delle Adeguate Informazioni Legali; altrimenti, se il Programma ha delle
interfacce interattive che non visualizzano delle Adeguate Informazioni
Legali, il tuo programma non @`e obbligato a visualizzarle.
@end enumerate
La giustapposizione di un'opera coperta da questa Licenza assieme ad altre
opere separate e indipendenti, che non sono per loro natura estensioni del
Programma, e che non sono combinate con esso a formare un altro programma pi@`u
grande, dentro o in uno stesso supporto di memorizzazione a lungo termine o di
distribuzione, @`e semplicemente detto ``aggregato'' se la raccolta e il suo
copyright non sono utilizzati per limitare l'accesso o i diritti legali degli
utenti della raccolta stessa oltre ci@`o che ciascun singolo programma consente.
L'inclusione di un programma coperto da questa Licenza in un aggregato non
comporta l'applicazione di questa Licenza alle altre parti dell'aggregato.
@item Distribuzione in formato non-sorgente
Puoi distribuire un programma coperto da questa Licenza in formato di codice
oggetto secondo i termini delle sezioni 4 e 5, ammesso che tu fornisca anche
il Sorgente Corrispondente in formato comprensibile da un computer sotto i
termini di questa stessa Licenza, in uno dei seguenti modi:
@enumerate a
@item
Distribuendo il codice oggetto in, o contenuto in, un prodotto fisico (inclusi
i mezzi fisici di distribuzione), accompagnato dal Sorgente Corrispondente su
un supporto fisico duraturo comunemente utilizzato per lo scambio di software.
@item
Distribuendo il codice oggetto in, o contenuto in, un prodotto fisico (inclusi
i mezzi fisici di distribuzione), accompagnato da un'offerta scritta, valida
per almeno tre anni e valida per tutto il tempo durante il quale tu offri
ricambi o supporto per quel modello di prodotto, di fornire a chiunque
possieda il codice oggetto (1) una copia del Sorgente Corrispondente di tutto
il software contenuto nel prodotto che @`e coperto da questa Licenza, su un
supporto fisico duraturo comunemente utilizzato per lo scambio di software, ad
un prezzo non superiore al costo ragionevole per effettuare fisicamente tale
distribuzione del sorgente, oppure (2) accesso alla copia del Sorgente
Corrispondente attraverso un server di rete senza alcun costo aggiuntivo.
@item
Distribuendo copie singole del codice oggetto assieme ad una copia
dell'offerta scritta di fornire il Sorgente Corrispondente. Questa possibilit@`a
@`e permessa soltanto occasionalmente e per fini non commerciali, e solo se tu
hai ricevuto il codice oggetto assieme ad una tale offerta, in accordo alla
sezione 6b.
@item
Distribuendo il codice oggetto mediante accesso da un luogo designato (gratis
o dietro pagamento di un prezzo), e offrendo un accesso equivalente al
Sorgente Corrispondente alla stessa maniera a partire dallo stesso luogo senza
costi aggiuntivi. Non devi obbligare i destinatari a copiare il Sorgente
Corrispondente assieme al codice oggetto. Se il luogo dal quale copiare il
codice oggetto @`e un server di rete, il Sorgente Corrispondente pu@`o trovarsi su
un server differente (gestito da te o da terze parti) che fornisca
funzionalit@`a equivalenti per la copia, a patto che tu fornisca delle
indicazioni chiare accanto al codice oggetto che indichino dove trovare il
Sorgente Corrispondente. Indipendentemente da quale server ospiti il Sorgente
Corrispondente, tu rimani obbligato ad assicurare che esso rimanga disponibile
per tutto il tempo necessario a soddisfare queste condizioni.
@item
Distribuendo il codice oggetto mediante trasmissione peer-to-peer, a patto che
tu informi gli altri peer circa il luogo in cui il codice oggetto e il
Sorgente Corrispondente sono gratuitamente offerti al pubblico secondo i
termini della sezione 6d.
@end enumerate
Una porzione separabile del codice oggetto, il cui sorgente @`e escluso dal
Sorgente Corrispondente e trattato come Libreria di Sistema, non deve essere
obbligatoriamente inclusa nella distribuzione del codice oggetto del
programma.
Un ``Prodotto Utente'' @`e un (1) ``prodotto consumer'', cio@`e qualunque propriet@`a
personale tangibile che @`e normalmente utilizzata per scopi personali,
familiari o domestici, oppure (2) qualunque cosa progettata o venduta per
essere utilizzata in ambiente domestico. Nella classificazione di un prodotto
come ``prodotto consumer'', i casi dubbi andranno risolti in favore dell'ambito
di applicazione. Per un dato prodotto ricevuto da un dato utente, ``normalmente
utilizzato'' si riferisce ad un uso tipico o comune di quella classe di
prodotti, indipendentemente dallo stato dell'utente specifico o dal modo in
cui l'utente specifico utilizza, o si aspetta o ci si aspetta che utilizzi, il
prodotto. Un prodotto @`e un ``prodotto consumer'' indipendentemente dal fatto che
abbia usi commerciali, industriali o diversi da quelli ``consumer'', a meno che
questi usi non rappresentino il solo modo utile di utilizzare il prodotto in
questione.
Le ``Informazioni di Installazione'' per un Prodotto Utente sono i metodi, le
procedure, le chiavi di autorizzazioni o altre informazioni necessarie per
installare ed eseguire versioni modificate di un programma coperto da questa
Licenza all'interno di un Prodotto Utente, a partire da versioni modificate
dei suoi Sorgenti Corrispondenti. Tali informazioni devono essere sufficienti
ad assicurare che il funzionamento del codice oggetto modificato non sia in
nessun caso proibito o ostacolato per il solo fatto che sono state apportate
delle modifiche.
Se distribuisci un codice oggetto secondo le condizioni di questa sezione in,
o assieme, o specificatamente per l'uso in o con un Prodotto Utente, e la
distribuzione avviene come parte di una transazione nella quale il diritto di
possesso e di uso del Prodotto Utente viene trasferito al destinatario per
sempre o per un periodo prefissato (indipendentemente da come la transazione
sia caratterizzata), il Sorgente Corrispondente distribuito secondo le
condizioni di questa sezione deve essere accompagnato dalle Informazioni di
Installazione. Questa condizione non @`e richiesta se n@`e tu n@`e una terza parte
ha la possibilit@`a di installare versioni modificate del codice oggetto sul
Prodotto Utente (per esempio, se il programma @`e installato su una ROM)
La condizione che richiede di fornire delle Informazioni di Installazione non
implica che venga fornito supporto, garanzia o aggiornamenti per un programma
che @`e stato modificato o installato dal destinatario, o per il Prodotto Utente
in cui esso @`e stato modificato o installato. L'accesso ad una rete pu@`o essere
negato se le modifiche apportate impattano materialmente sull'operativit@`a
della rete o se violano le regole e i protocolli di comunicazione attraverso
la rete.
Il Sorgente Corrispondente distribuito, e le Informazioni di Installazione
fornite, in accordo con questa sezione, devono essere in un formato che sia
pubblicamente documentato (e con una implementazione pubblicamente disponibile
in formato di codice sorgente), e non devono richiedere speciali password o
chiavi per essere spacchettate, lette o copiate.
@item Condizioni Aggiuntive
Le ``Condizioni Aggiuntive'' sono condizioni che completano le condizioni di
questa Licenza permettendo delle eccezioni a una o pi@`u delle condizioni sopra
elencate. Le condizioni aggiuntive che sono applicabili all'intero Programma
devono essere considerate come se fossero incluse in questa Licenza, a patto
che esse siano valide secondo le normative vigenti. Se alcune condizioni
aggiuntive fanno riferimento soltanto ad alcune parti del Programma, quelle
parti possono essere utilizzate separatamente sotto le stesse condizioni, ma
l'intero Programma rimane sottoposto a questa Licenza senza riferimento ad
alcuna condizione aggiuntiva.
Quando distribuisci una copia di un programma coperto da questa Licenza, puoi,
a tua discrezione, eliminare qualunque condizione aggiuntiva dalla copia, o da
parte di essa. (Le Condizioni Aggiuntive possono essere scritte in maniera
tale da richiedere la loro rimozione in certi casi di modifica del Programma).
Puoi aggiungere Condizioni Aggiuntive su materiale, aggiunto da te ad un'opera
coperta da questa Licenza, per il quale hai o puoi garantire un'adeguata
licenza di copyright.
Indipendentemente da qualunque altra condizione di questa Licenza, e per il
materiale che aggiungi ad un'opera coperta da questa Licenza, puoi (se
autorizzato dai legittimi detentori del copyright per il suddetto materiale)
aggiungere alle condizioni di questa Licenza delle condizioni che:
@enumerate a
@item
Negano la garanzia o limitano la responsabilit@`a del Programma in maniera
differente da quanto riportato nelle sezioni 15 e 16 di questa Licenza; oppure
@item
Richiedono il mantenimento di specifiche e circostanziate informative legali o
di note di attribuzione ad autori nel materiale o assieme alle Adeguate
Informazioni Legali mostrate dal Programma che lo contiene; oppure
@item
Proibiscono di fornire informazioni errate o ingannevoli sull'origine e la
provenienza del materiale in oggetto, o richiedono che versioni modificate di
tale materiale siano appositamente marcate in maniera differente rispetto alla
versione originale; oppure
@item
Limitano l'utilizzo per scopi pubblicitari del nome dei detentori del
copyright o degli autori del materiale; oppure
@item
Rifiutano di garantire diritti secondo le leggi sulla propriet@`a intellettuale
circa l'uso di nomi, marchi di fabbrica o similari; oppure
@item
Richiedono l'indennizzo dei detentori del copyright o degli autori del
materiale in oggetto da parte di chi distribuisce il materiale (o versioni
modificate dello stesso) con impegni contrattuali circa la responsabilit@`a nei
confronti del destinatario, per qualunque responsabilit@`a che questi impegni
contrattuali dovessero imporre direttamente ai suddetti detentori del
copyright e autori.
@end enumerate
Tutte le altre condizioni addizionali non-permissive sono considerate
``ulteriori restrizioni'', secondo il significato specificato alla sezione 10.
Se il Programma o parti di esso contengono, all'atto della ricezione dello
stesso, informative che specificano che esso @`e soggetto a questa Licenza
assieme ad una condizione che @`e una ``ulteriore restrizione'', puoi rimuovere
quest'ultima condizione. Se un documento di licenza contiene ulteriori
restrizioni ma permette di rilicenziare o distribuire il Programma con questa
Licenza, puoi aggiungere al Programma del materiale coperto dalle condizioni
di quel documento di licenza, a patto che le ulteriori restrizioni non
compaiano nelle versioni rilicenziate o ridistribuite.
Se aggiungi ad un Programma coperto da questa Licenza delle condizioni
aggiuntive in accordo con questa sezione, devi aggiungere anche, nei file
sorgenti corrispondenti, un avviso che riassuma le condizioni aggiuntive
applicate a quei file, ovvero un avviso che specifichi dove @`e possibile
trovare copia delle condizioni aggiunte.
Tutte le Condizioni aggiuntive, permissive o non-permissive, devono essere
espresse nella forma di una licenza scritta e separata, o espresse
esplicitamente come eccezioni; in entrambi i casi valgono le condizioni
succitate.
@item Cessazione di Licenza
Non puoi propagare o modificare un programma coperto da questa Licenza in
maniera diversa da quanto espressamente consentito da questa Licenza.
Qualunque tentativo di propagare o modificare altrimenti il Programma @`e nullo,
e provoca l'immediata cessazione dei diritti garantiti da questa Licenza
(compresi tutte le eventuali licenze di brevetto garantite ai sensi del terzo
paragrafo della sezione 11).
In ogni caso, se cessano tutte le violazioni di questa Licenza, allora la tua
licenza da parte di un dato detentore del copyright viene ripristinata (a) in
via cautelativa, a meno che e fino a quando il detentore del copyright non
cessa esplicitamente e definitivamente la tua licenza, e (b) in via permanente
se il detentore del copyright non ti notifica in alcun modo la violazione
entro 60 giorni dalla cessazione della licenza.
Inoltre, la tua licenza da parte di un dato detentore del copyright viene
ripristinata in maniera permanente se il detentore del copyright ti notifica
la violazione in maniera adeguata, se questa @`e la prima volta che ricevi una
notifica di violazione di questa Licenza (per qualunque Programma) dallo
stesso detentore di copyright, e se rimedi alla violazione entro 30 giorni
dalla data di ricezione della notifica di violazione.
La cessazione dei tuoi diritti come specificato in questa sezione non provoca
la cessazione delle licenze di terze parti che abbiano ricevuto copie o
diritti da te secondo questa Licenza. Se i tuoi diritti cessano e non sono
ristabiliti in via permanente, non hai diritto di ricevere nuove licenze per
lo stesso materiale, secondo quanto stabilito nella sezione 10.
@item L'ottenimento di copie non richiede l'accettazione della Licenza
Non sei obbligato ad accettare i termini di questa Licenza al solo fine di
ottenere o eseguire una copia del Programma. Similmente, propagazioni
collaterali di un Programma coperto da questa Licenza che occorrono come
semplice conseguenza dell'utilizzo di trasmissioni peer-to-peer per la
ricezione di una copia non richiedono l'accettazione della Licenza. In ogni
caso, solo e soltanto questa Licenza ti garantiscono il permesso di propagare
e modificare qualunque programma coperto da questa Licenza. Queste azioni
violano le leggi sul copyright nel caso in cui tu non accetti questa Licenza.
Pertanto, modificando o propagando un programma coperto da questa Licenza,
indichi implicitamente la tua accettazione della Licenza.
@item Licenza Automatica per i successivi destinatari
Ogni qual volta distribuisci un programma coperto da questa Licenza, il
destinatario riceve automaticamente una licenza, dal detentore originario del
copyright, di eseguire, modificare e propagare il programma, nel rispetto di
questa Licenza. Non sei ritenuto responsabile del rispetto di questa Licenza
da parte di terze parti.
Una ``transazione d'entit@`a'' @`e una transazione che trasferisce il controllo di
una organizzazione, o sostanzialmente di tutti i suoi beni, che suddivide una
organizzazione o che fonde pi@`u organizzazioni. Se la propagazione di un
programma coperto da questa Licenza @`e conseguente ad una transazione di
entit@`a, ciascuna parte che ha ruolo nella transazione e che riceve una copia
del programma riceve allo stesso tempo qualsiasi licenza sul programma che i
predecessori della parte possedevano o potevano rilasciare nel rispetto del
paragrafo precedente, e in pi@`u il diritto di possesso del Sorgente
Corrispondente del programma dal predecessore in interesse, se il predecessore
lo possiede o se pu@`o ottenerlo senza troppe difficolt@`a.
Non puoi imporre nessuna ulteriore restrizione sull'esercizio dei diritti
garantiti o affermati da questa Licenza. Per esempio, non puoi imporre un
prezzo di licenza, una royalty, o altri costi per l'esercizio dei diritti
garantiti da questa Licenza, a non puoi dar corso ad una controversia (ivi
incluse le controversie incrociate o la difesa in cause legali) affermando che
siano stati violati dei brevetti a causa della produzione, dell'uso, della
vendita, della messa in vendita o dell'importazione del Programma o di sue
parti.
@item Brevetti
Un ``contribuente'' @`e un detentore di copyright che autorizza l'uso secondo
questa Licenza di un Programma o di un'opera basata sul Programma. L'opera
cos@`{@dotless{i}} licenziata viene chiamata ``versione del contribuente''.
I ``diritti essenziali di brevetto'' da parte di un contribuente sono tutti i
diritti di brevetto che appartengono o che sono controllati dal contribuente,
che siano gi@`a acquisiti o che saranno acquisiti in futuro, che possano essere
violati in qualche maniera, consentita da questa Licenza, generando,
modificando o vendendo la versione del contribuente, ma non includono i
diritti che possano essere violati soltanto come conseguenza di ulteriori
modifiche alla versione del contribuente. In relazione a questa definizione,
il termine ``controllo'' include il diritto di garantire sottolicenze di
brevetto in maniera consistente con le condizioni di questa Licenza.
Ciascun contribuente ti garantisce la licenza di brevetto sui diritti
essenziali di brevetto del contribuente stesso non-esclusiva, valida in tutto
il mondo, esente da royalty, di creare, usare, vendere, offrire in vendita,
importare e altrimenti eseguire, modificare e propagare i contenuti della
versione del contribuente.
Nei tre paragrafi successivi, con ``licenza di brevetto'' si intende qualunque
accordo o contratto, comunque denominato, di non rivendicazione di un brevetto
(come per esempio un permesso esplicito di utilizzare un brevetto o un accordo
di rinuncia alla persecuzione per violazione di brevetto). ``Garantire'' una
tale licenza di brevetto ad una parte significa portare a termine un tale
accordo o contratto di non rivendicazione di brevetto contro la parte.
Se distribuisci un programma coperto da questa Licenza, confidando
consapevolmente su una licenza di brevetto, e il Sorgente Corrispondente per
il programma non @`e reso disponibile per la copia, senza alcun onere aggiuntivo
e comunque nel rispetto delle condizioni di questa Licenza, attraverso un
server di rete pubblicamente accessibile o tramite altri mezzi facilmente
accessibili, allora devi (1) fare in modo che il Sorgente Corrispondente sia
reso disponibile come sopra, oppure (2) fare in modo di rinunciare ai benefici
della licenza di brevetto per quel particolare programma, oppure (3)
adoperarti, in maniera consistente con le condizioni di questa Licenza, per
estendere la licenza di brevetto a tutti i destinatari successivi. ``Confidare
consapevolmente'' significa che tu sei attualmente cosciente che, eccettuata la
licenza di brevetto, la distribuzione da parte tua di un programma protetto da
questa Licenza in un paese, o l'utilizzo in un paese del programma coperto da
questa Licenza da parte di un destinatario, pu@`o violare uno o pi@`u brevetti in
quel paese che tu hai ragione di ritenere validi.
Se, come conseguenza o in connessione con una singola transazione o con un
dato accordo, distribuisci, o fai in modo di distribuire, un programma coperto
da questa Licenza, e garantisci una licenza di brevetto per alcune delle parti
che ricevono il Programma autorizzandole ad utilizzare, propagare, modificare
o distribuire una specifica copia del Programma, allora la licenza di brevetto
che fornisci @`e automaticamente estesa a tutti i destinatari del Programma
coperto da questa Licenza e delle opere basate sul Programma.
Una licenza di brevetto @`e ``discriminatoria'' se non include nell'ambito della
sua copertura, proibisce l'esercizio, o @`e vincolata al non-esercizio di uno o
pi@`u dei diritti che sono specificatamente garantiti da questa Licenza. Non
puoi distribuire un Programma coperto da questa Licenza se sei parte di un
accordo con una terza parte la cui attivit@`a comprende la distribuzione di
software, secondo il quale tu sei costretto ad un pagamento alla parte terza
in funzione della tua attivit@`a di distribuzione del Programma, e in
conseguenza del quale la parte terza garantisce, a qualunque delle parti che
riceveranno il Programma da te, una licenza di brevetto discriminatoria (a)
assieme a copie del Programma coperto da questa Licenza distribuite da te (o
ad altre copie fatte da codeste copie), oppure (b) principalmente per e in
connessione con specifici prodotti o raccolte di prodotti che contengono il
Programma, a meno che l'accordo non sia stato stipulato, o le licenze di
brevetto non siano state rilasciate, prima del 28 Marzo 2007.
Nessuna parte di questa Licenza pu@`o essere interpretata come atta ad escludere
o limitare gli effetti di qualunque altra licenza o altri meccanismi di difesa
dalla violazione che possano altrimenti essere resi disponibili dalla
normativa vigente in materia di brevetti.
@item Nessuna resa di libert@`a altrui
Se ti vengono imposte delle condizioni (da un ordine giudiziario, da un
accordo o da qualunque altra eventualit@`a) che contraddicono le condizioni di
questa Licenza, non sei in nessun modo esonerato dal rispetto delle condizioni
di questa Licenza. Se non puoi distribuire un Programma coperto da questa
Licenza per sottostare simultaneamente agli obblighi derivanti da questa
Licenza e ad altri obblighi pertinenti, allora non puoi distribuire il
Programma per nessun motivo. Per esempio, se accetti delle condizioni che ti
obbligano a richiedere il pagamento di una royalty per le distribuzioni
successivamente effettuate da coloro ai quali hai distribuito il Programma,
l'unico modo per soddisfare sia queste condizioni che questa Licenza @`e evitare
del tutto la distribuzione del Programma.
@item Utilizzo con la GNU Affero General Public License
Indipendentemente da qualunque altra condizione espressa da questa Licenza,
hai il permesso di collegare o combinare qualunque Programma coperto da questa
Licenza con un'opera rilasciata sotto la versione 3 della licenza GNU Affero
General Public License, ottenendo un singolo Programma derivato, e di
distribuire il Programma risultante. Le condizioni di questa Licenza
continuano a valere per le parti riguardanti il Programma che sono coperte da
questa Licenza, mentre le condizioni speciali della GNU Affero General Public
License, sezione 13, riguardanti l'interazione mediante rete, saranno
applicate al Programma cos@`{@dotless{i}} risultante.
@item Versioni rivedute di questa Licenza
La Free Software Foundation pu@`o pubblicare delle versioni rivedute e/o delle
nuove versioni della GNU General Public License di tanto in tanto. Tali
versioni saranno simili, nello spirito, alla presente versione, ma potranno
differire nei dettagli al fine di affrontare nuovi problemi e nuove
situazioni.
A ciascuna versione viene assegnato un numero identificativo di versione. Se
il Programma specifica che si applica a s@`e stesso una certa versione della GNU
General Public License, ``o qualunque altra versione successiva'', hai la
possibilit@`a di sottostare alle condizioni di quella specifica versione o di
qualunque altra versione successiva pubblicata dalla Free Software Foundation.
Se il Programma non specifica un numero di versione della GNU General Public
License, puoi scegliere qualunque versione della GNU General Public License
pubblicata dalla Free Software Foundation.
Se il Programma specifica che un sostituto o un procuratore pu@`o decidere quali
versioni future della GNU General Public License posso essere utilizzate,
allora tale scelta di accettazione di una data versione ti autorizza, in
maniera permanente, ad utilizzare quella versione della Licenza per il
Programma.
Versioni successive della Licenza possono garantire diritti aggiuntivi o
leggermente differenti. Ad ogni modo, nessun obbligo aggiuntivo viene imposto
agli autori o ai detentori di copyright come conseguenza della tua scelta di
adottare una versione successiva della Licenza.
@item Rinuncia alla Garanzia
NON C'@`E NESSUNA GARANZIA PER IL PROGRAMMA, PER QUANTO CONSENTITO DALLE
VIGENTI NORMATIVE. ECCETTO QUANDO ALTRIMENTI STABILITO PER ISCRITTO, I
DETENTORI DEL COPYRIGHT E/O LE ALTRE PARTI FORNISCONO IL PROGRAMMA ``COS@`I COME
@`E'' SENZA GARANZIA DI ALCUN TIPO, N@'E ESPRESSA N@'E IMPLICITA, INCLUSE, MA NON
LIMITATE A, LE GARANZIE DI COMMERCIABILIT@`A O DI UTILIZZABILIT@`A PER UN
PARTICOLARE SCOPO. L'INTERO RISCHIO CONCERNENTE LA QUALIT@`A E LE PRESTAZIONI
DEL PROGRAMMA @`E DEL LICENZIATARIO. SE IL PROGRAMMA DOVESSE RISULTARE
DIFETTOSO, IL LICENZIATARIO SI ASSUME I COSTI DI MANUTENZIONE, RIPARAZIONE O
CORREZIONE.
@item Limitazione di Responsabilit@`a
IN NESSUN CASO, A MENO CHE NON SIA RICHIESTO DALLA NORMATIVA VIGENTE O
CONCORDATO PER ISCRITTO, I DETENTORI DEL COPYRIGHT, O QUALUNQUE ALTRA PARTE
CHE MODIFICA E/O DISTRIBUISCE IL PROGRAMMA SECONDO LE CONDIZIONI PRECEDENTI,
POSSONO ESSERE RITENUTI RESPONSABILI NEI CONFRONTI DEL LICENZIATARIO PER
DANNI, INCLUSO QUALUNQUE DANNEGGIAMENTO GENERICO, SPECIALE, INCIDENTALE O
CONSEQUENZIALE DOVUTO ALL'USO O ALL'IMPOSSIBILIT@`A D'USO DEL PROGRAMMA
(INCLUSI, MA NON LIMITATI A, LE PERDITE DI DATI, LA CORRUZIONE DI DATI, LE
PERDITE SOSTENUTE DAL LICENZIATARIO O DA TERZE PARTI O L'IMPOSSIBILIT@`A DEL
PROGRAMMA A FUNZIONARE ASSIEME AD ALTRI PROGRAMMI), ANCHE NEL CASO IN CUI IL
DETENTORE O LE ALTRE PARTI SIANO STATI AVVISATI CIRCA LA POSSIBILIT@`A DI TALI
DANNEGGIAMENTI.
@item Interpretazione delle Sezioni 15 e 16
Se la dichiarazione di garanzia e la limitazione di responsabilit@`a fornite
precedentemente non hanno effetto legale in un paese a causa delle loro
condizioni, le corti di giustizia devono applicare la norma locale che pi@`u si
avvicini al rifiuto assoluto di qualsivoglia responsabilit@`a civile relativa al
Programma, a meno che una garanzia o una assunzione di responsabilit@`a scritta
non accompagni una copia del programma ottenuta dietro pagamento.
@end enumerate
@c fakenode --- for prepinfo
@heading FINE DEI TERMINI E DELLE CONDIZIONI
@c fakenode --- for prepinfo
@heading Come applicare queste condizioni di Licenza ai vostri programmi
Se sviluppi un nuovo programma, e vuoi che esso sia della massima utilit@`a, il
modo migliore @`e renderlo software libero in modo che chiunque possa
ridistribuirlo e modificarlo secondo i termini di questa Licenza.
Per fare ci@`o, allega le seguenti note informative al programma. Il modo
migliore @`e inserirle all'inizio di ciascun file sorgente, al fine di rimarcare
adeguatamente la mancanza di garanzia; ciascun file dovrebbe inoltre contenere
la dichiarazione di copyright e un riferimento al posto in cui @`e possibile
ottenere la versione completa delle note informative.
@smallexample
@var{}
Copyright (C) @var{} @var{}
Questo software @`e libero; lo puoi distribuire e/o modificare alle condizioni
stabilite nella 'GNU General Public License' pubblicata dalla Free Software
Foundation; fai riferimento alla versione 3 della Licenza, o (a tua scelta)
a una qualsiasi versione successiva.
Questo programma @`e distribuito con la speranza che sia utile, ma SENZA
ALCUNA GARANZIA; senza neppure la garanzia implicita di COMMERCIABILIT@`A o
IDONEIT@`A AD UN PARTICOLARE SCOPO. Si veda la 'GNU General Public License' per
ulteriori dettagli.
Dovresti aver ricevuto una copia della GNU General Public License assieme a
questo programma; se non @`e cos@`{@dotless{i}}, vedere
@url{https://www.gnu.org/licenses/}.
@end smallexample
Inoltre, aggiungi le informazioni necessarie a contattarti via posta ordinaria
o via posta elettronica.
Se il programma interagisce mediante terminale, fai in modo che visualizzi,
quando viene avviato in modalit@`a interattiva, un breve messaggio come quello
che segue:
@smallexample
@var{} Copyright (C) @var{} @var{}
Questo programma non ha ALCUNA GARANZIA; per dettagli usare il comando
@samp{show w}.
Questo @`e software libero, e ognuno @`e libero di ridistribuirlo
sotto certe condizioni; usare il comando @samp{show c} per i dettagli.
@end smallexample
Gli ipotetici comandi @samp{show w} e @samp{show c} devono visualizzare le parti
corrispondenti della GNU General Public License. Naturalmente i comandi del
tuo programma potrebbero essere differenti; per una interfaccia di tipo GUI,
dovresti usare un bottone ``About'' o ``Info''.
Devi inoltre fare in modo che il tuo datore di lavoro (se lavori come
programmatore presso terzi) o la tua scuola, eventualmente, firmino una
``rinuncia al copyright'' sul programma, se necessario. Per maggiori
informazioni su questo punto, e su come applicare e rispettare la GNU GPL,
consultare la pagina @url{https://www.gnu.org/licenses/}.
La GNU General Public License non consente di incorporare il programma
all'interno di software proprietario. Se il tuo programma @`e una libreria di
funzioni, potresti ritenere pi@`u opportuno consentire il collegamento tra
software proprietario e la tua libreria. Se @`e questo ci@`o che vuoi, allora
utilizza la GNU Lesser General Public License anzich@'e questa Licenza, ma prima
leggi @url{https://www.gnu.org/philosophy/why-not-lgpl.html}.
@ifclear FOR_PRINT
@c The GNU Free Documentation License.
@node Licenza per Documentazione Libera GNU (FDL)
@unnumbered Licenza per Documentazione Libera GNU (FDL)
@ifnotdocbook
@center Versione 1.3, 3 Novembre 2008
@end ifnotdocbook
@docbook
Versione 1.3, 3 Novembre 2008
@end docbook
@cindex FDL (Free Documentation License)
@cindex Free Documentation License (FDL)
@cindex GNU @subentry Free Documentation License
@c This file is intended to be included within another document,
@c hence no sectioning command or @node.
@display
Copyright @copyright{} 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
@uref{https://fsf.org}
This is an unofficial translation of the GNU Free Documentation License into
Italian. It was not published by the Free Software Foundation, and does not
legally state the distribution terms for software that uses the GNU FDL --- only
the original English text of the GNU FDL does that. However, we hope that this
translation will help Italian speakers understand the GNU FDL better.
Questa @`e una traduzione non ufficiale della GNU Free Documentation License
in italiano. Non @`e una pubblicazione della Free Software Foundation, e non
ha validit@`a legale per i termini di distribuzione della documentazione che
usa la GNU FDL; solo il testo originale inglese della GNU FDL ha tale
validit@`a. Comunque, speriamo che questa traduzione aiuti chi parla
italiano a comprendere meglio la GNU FDL.
A chiunque @`e permesso copiare e ridistribuire copie esatte di questo documento
di licenza, ma non @`e in alcun modo consentito apportarvi modifiche.
@end display
@enumerate 0
@item
PREAMBOLO
Lo scopo di questa licenza @`e di rendere @dfn{liberi} un manuale, un testo o
altri documenti funzionali e utili, nel senso di assicurare a tutti la
libert@`a effettiva di copiarli e ridistribuirli, con o senza modifiche, con
o senza fini di lucro. In secondo luogo questa licenza prevede per autori
ed editori il modo per ottenere il giusto riconoscimento del proprio
lavoro, preservandoli dall'essere considerati responsabili per modifiche
apportate da altri.
Questa licenza garantisce il ``copyleft'': questo significa che i lavori che
derivano dal documento originale devono essere ugualmente liberi. @`E il
complemento alla Licenza Pubblica Generale GNU, che @`e una licenza di tipo
``copyleft'' pensata per il software libero.
Questa licenza @`e stata progettata appositamente per l'uso con manuali di
software libero, perch@'e il software libero ha bisogno di documentazione
libera: un programma libero dovrebbe accompagnarsi a manuali che
forniscano le stesse libert@`a del software. Questa licenza non @`e limitata
alla manualistica del software; pu@`o essere utilizzata per ogni testo che
tratti un qualsiasi argomento e al di l@`a dell'avvenuta pubblicazione
cartacea. Si raccomanda l'uso di questa licenza principalmente per opere
che abbiano fini didattici o per manuali.
@item
APPLICABILIT@`A E DEFINIZIONI
Questa licenza si applica a qualsiasi manuale o altra opera, su ogni tipo
di supporto, che contenga la nota, posta dal detentore del copyright, che
attesti la possibilit@`a di distribuzione secondo i termini di questa
licenza. Tale nota permette universalmente, senza pagamento di diritti e
senza limiti di durata di utilizzare il lavoro secondo le condizioni qui
specificate. Con ``documento'', nel seguito ci si riferisce a qualsiasi
manuale o opera. Ogni fruitore @`e un destinatario della licenza ed @`e ad
esso che si fa riferimento. Si conviene che la licenza viene accettata se
si copia, modifica o distribuisce il lavoro in una maniera tale da
richiedere il permesso secondo le leggi sul copyright.
Una ``versione modificata'' del documento @`e ogni opera contenente il
documento stesso o parte di esso, sia riprodotto alla lettera che con
modifiche, oppure traduzioni in un'altra lingua.
Una ``sezione secondaria'' @`e un'appendice cui si fa riferimento o una
premessa del documento e riguarda esclusivamente il rapporto dell'editore
o dell'autore del documento con l'argomento generale del documento stesso
(o argomenti affini) e non contiene nulla che possa essere compreso
nell'argomento principale. (Perci@`o, se il documento @`e in parte un manuale
di matematica, una sezione secondaria non pu@`o contenere spiegazioni di
matematica). Il rapporto con l'argomento pu@`o essere un tema collegato
storicamente con il soggetto principale o con soggetti affini, o essere
costituito da argomentazioni legali, commerciali, filosofiche, etiche o
politiche pertinenti.
Le ``sezioni non modificabili'' sono alcune sezioni secondarie i cui titoli
sono esplicitamente elencati come titoli delle sezioni non modificabili
nella nota che indica che il documento @`e realizzato sotto questa licenza.
Se una sezione non rientra nella precedente definizione di sezione
secondaria, allora non @`e permesso che venga definita come non
modificabile. Il documento pu@`o anche non contenere sezioni non
modificabili. Se nel documento non vengono indicate sezioni non
modificabili, allora significa che non ve ne sono.
I ``testi di copertina'' sono dei brevi brani di testo che sono elencati,
nella prima o quarta pagina di copertina, nella nota che indica che il
documento @`e rilasciato sotto questa licenza. Il testo sulla prima di
copertina pu@`o essere composto al massimo di 5 parole mentre quello sulla
quarta di copertina pu@`o essere al massimo di 25 parole.
Una copia ``trasparente'' indica una copia leggibile da un calcolatore,
codificata in un formato le cui specifiche sono disponibili pubblicamente,
tale che il suo contenuto possa essere modificato in modo semplice con
generici editor di testi o (per immagini composte da pixel) con generici
editor di immagini o (per i disegni) con qualche editor di disegni
ampiamente diffuso; la copia deve essere adatta al trattamento per la
formattazione o per la conversione in una variet@`a di formati atti alla
successiva formattazione. Una copia fatta in un formato di file, per il
resto trasparente, i cui marcatori o assenza di tali sono stati progettati
per intralciare o scoraggiare modifiche future da parte dei lettori non @`e
trasparente. Un formato immagine non @`e trasparente se viene usato per
rappresentare una notevole quantit@`a di testo. Una copia non ``trasparente''
viene detta ``opaca''.
Esempi di formati adatti per copie trasparenti sono l'@sc{ASCII} puro senza
marcatori, il formato di ingresso per Texinfo, il formato di ingresso per
La@TeX{}, @acronym{SGML} o @acronym{XML} accoppiati ad una @acronym{DTD}
pubblica e disponibile, e i formati conformi agli standard @acronym{HTML}
semplice, Postscript e @acronym{PDF} progettati per essere modificati
manualmente. Esempio di formati immagine trasparenti includono il
@acronym{PNG}, @acronym{XCF} e @acronym{JPG}. I formati opachi includono i
formati proprietari che possono essere letti e modificati solo con word
processor proprietari, @acronym{SGML} o @acronym{XML} per cui non @`e in
genere disponibile la @acronym{DTD} o gli strumenti per il trattamento, e i
formati @acronym{HTML}, Postscript e @acronym{PDF} generati automaticamente
da qualche word processor esclusivamente come output.
La ``pagina del titolo'' di un libro stampato indica la pagina del titolo
stessa, pi@`u qualche pagina seguente per quanto necessario a contenere in
modo leggibile, il materiale che la licenza prevede che compaia nella
pagina del titolo. Per opere in formati in cui non sia contemplata
esplicitamente la pagina del titolo, con ``pagina del titolo'' si intende il
testo prossimo al titolo dell'opera, precedente l'inizio del corpo del
testo.
Il termine ``editore'' indica qualunque persona o entit@`a che distribuisce al
pubblico copie del documento.
Una sezione ``Intitolata XYZ'' significa una sottosezione con nome del
documento il cui titolo sia precisamente XYZ o che contenga XYZ in
parentesi dopo il testo che traduce XYZ in un'altra lingua (in questo caso
XYZ sta per uno specifico nome di sezione menzionato sotto, come per i
``Riconoscimenti'', ``Dediche'', ``Approvazioni'', o ``Storia''). Secondo questa
definizione, ``preservare il titolo'' di tale sezione quando si modifica il
documento, significa che essa rimane una sezione ``Intitolata XYZ''.
Il Documento pu@`o includere dei limiti alla garanzia accanto alla nota
affermante l'applicazione di questa licenza al documento. Questi limiti
alla garanzia sono da considerare da includere come riferimento a questa
licenza, ma solo per quanto riguarda le limitazioni alla garanzia: ogni
altra implicazione che questi limiti alla garanzia possono avere @`e da
considerarsi nulla e non ha effetto sul significato di questa licenza.
@item
COPIE LETTERALI
Si pu@`o copiare e distribuire il documento con qualsiasi mezzo, con o senza
fini di lucro, purch@'e tutte le copie contengano questa licenza, le note di
copyright e l'avviso che questa licenza si applica al documento, e che non
si aggiungano altre condizioni al di fuori di quelle della licenza stessa.
Non si possono usare misure tecniche per impedire o controllare la lettura
o la produzione di copie successive alle copie che si producono o
distribuiscono. Si possono comunque accettare compensi per la copiatura.
Se si distribuiscono un numero sufficiente di copie si devono seguire
anche le condizioni della sezione 3.
Alle stesse condizioni sopra menzionate si possono prestare copie e
mostrarle pubblicamente.
@item
COPIARE IN NOTEVOLI QUANTIT@`A
Se si pubblicano a mezzo stampa (o in formati che tipicamente posseggono
copertine) pi@`u di 100 copie del documento, e la nota della licenza
richiede uno o pi@`u testi di copertina, si devono includere nelle copie, in
modo chiaro e leggibile, tutti i testi di copertina indicati: il testo
della prima di copertina in prima di copertina e il testo di quarta di
copertina in quarta di copertina. Ambedue devono identificare l'editore
che pubblica il documento. La prima di copertina deve presentare il titolo
completo con tutte le parole che lo compongono egualmente visibili ed
evidenti. Si pu@`o aggiungere altro materiale alle copertine. Il copiare con
modifiche limitate alle sole copertine, purch@'e si preservino il titolo e
le altre condizioni viste in precedenza, @`e considerato alla stregua di
copiare alla lettera.
Se il testo richiesto per le copertine @`e troppo voluminoso per essere
riprodotto in modo leggibile, se ne pu@`o mettere una prima parte (per
quanto ragionevolmente pu@`o stare) in copertina, e continuare il resto
nelle pagine immediatamente seguenti.
Se si pubblicano o distribuiscono copie opache del documento in numero
superiore a 100, si deve anche includere una copia trasparente leggibile
da un calcolatore in ogni copia oppure menzionare in ogni copia opaca un
indirizzo di rete di calcolatori pubblicamente accessibile che utilizzi un
protocollo di rete standard pubblico, da cui si possa scaricare
liberamente una copia trasparente completa del documento, senza materiale
aggiuntivo. Se si adotta quest'ultima opzione, si deve prestare la giusta
attenzione, nel momento in cui si inizia la distribuzione in quantit@`a
elevata di copie opache, ad assicurarsi che la copia trasparente rimanga
accessibile all'indirizzo stabilito fino ad almeno un anno dopo l'ultima
distribuzione (direttamente o attraverso distributori o rivenditori) di
quell'edizione al pubblico.
@`E caldamente consigliato, bench@'e non obbligatorio, contattare l'autore del
documento prima di distribuirne un numero considerevole di copie, per
metterlo in grado di fornire una versione aggiornata del documento.
@item
MODIFICHE
Si possono copiare e distribuire versioni modificate del documento
rispettando le condizioni delle precedenti sezioni 2 e 3, purch@'e la
versione modificata sia realizzata seguendo questa stessa licenza, con la
versione modificata che svolga il ruolo del ``documento'', cos@`{@dotless{i}} da estendere
la licenza sulla distribuzione e la modifica a chiunque ne possieda una
copia. Inoltre nelle versioni modificate si deve:
@enumerate A
@item
Usare nella pagina del titolo (e nelle copertine se ce ne sono) un titolo
diverso da quello del documento, e da quelli di versioni precedenti (che
devono essere elencati nella sezione storia del documento ove presenti).
Si pu@`o usare lo stesso titolo di una versione precedente se l'editore di
quella versione originale ne ha dato il permesso.
@item
Elencare nella pagina del titolo, come autori, una o pi@`u persone o gruppi
responsabili in qualit@`a di autori delle modifiche nella versione
modificata, insieme ad almeno cinque tra i principali autori del documento
(tutti gli autori principali se sono meno di cinque), a meno che questi
non abbiano acconsentito a liberarvi da quest'obbligo.
@item
Dichiarare nella pagina del titolo il nome dell'editore della versione
modificata in qualit@`a di editore.
@item
Conservare tutte le note di copyright
del documento originale.
@item
Aggiungere un'appropriata nota di copyright per
le modifiche di seguito alle altre note di copyright.
@item
Includere, immediatamente dopo la nota di copyright, una nota di licenza
che dia pubblicamente il permesso di usare la versione modificata nei
termini di questa licenza, nella forma mostrata nell'Addendum alla fine di
questo testo.
@item
Preservare in tale nota di licenza l'elenco completo di sezioni non
modificabili e testi di copertina richiesti come previsto dalla licenza
del documento.
@item
Includere una copia non modificata di questa licenza.
@item
Conservare la sezione intitolata ``Storia'', e il suo titolo, e aggiungere
a questa un elemento che riporti almeno il titolo, l'anno, i nuovi autori,
e gli editori della versione modificata come figurano nella pagina del
titolo. Se non ci sono sezioni intitolate ``Storia'' nel documento,
crearne una che riporti il titolo, gli autori, gli editori del documento
come figurano nella pagina del titolo, quindi aggiungere un elemento che
descriva la versione modificata come detto in precedenza.
@item
Conservare l'indirizzo in rete riportato nel documento, se c'@`e, al fine
del pubblico accesso ad una copia trasparente, e possibilmente l'indirizzo
in rete per le precedenti versioni su cui ci si @`e basati. Questi possono
essere collocati nella sezione ``Storia''. Si pu@`o omettere un indirizzo di
rete per un'opera pubblicata almeno quattro anni prima del documento
stesso, o se l'originario editore della versione cui ci si riferisce ne d@`a
il permesso.
@item
In ogni sezione di ``Ringraziamenti'' o ``Dediche'', si conservi il titolo
della sezione, e all'interno della sezione tutta la sostanza e il tono di
ognuno dei ringraziamenti ai contributori e/o le dediche ivi contenute.
@item
Si conservino inalterate le sezioni non modificabili del documento, nei
propri testi e nei propri titoli. I numeri della sezione o equivalenti non
sono considerati parte del titolo della sezione.
@item
Si cancelli ogni sezione intitolata ``Approvazioni''. Tale sezione non pu@`o
essere inclusa nella versione modificata.
@item
Non si cambi il titolo di sezioni esistenti in ``Approvazioni'' o in modo
tale che si possa creare confusione con i titoli di sezioni non
modificabili.
@item
Si conservino tutti i limiti alla garanzia.
@end enumerate
Se la versione modificata comprende nuove sezioni di primaria
importanza o appendici che ricadono in ``sezioni secondarie'', e non
contengono materiale copiato dal documento, si ha facolt@`a di rendere non
modificabili quante sezioni si voglia. Per fare ci@`o si aggiunga il loro
titolo alla lista delle sezioni non modificabili nella nota di licenza
della versione modificata. Questi titoli devono essere distinti dai titoli
di ogni altra sezione.
Si pu@`o aggiungere una sezione intitolata ``Approvazioni'', a patto che non
contenga altro che le approvazioni alla versione modificata prodotte da
vari soggetti--per esempio, affermazioni di revisione o che il testo @`e
stato approvato da una organizzazione come la definizione normativa di uno
standard.
Si pu@`o aggiungere un brano fino a cinque parole come testo di prima di
copertina e un brano fino a 25 parole come testo di quarta di copertina,
alla fine dell'elenco dei testi di copertina nella versione modificata.
Solamente un brano del testo di prima di copertina e uno del testo di
quarta di copertina possono essere aggiunti (anche con adattamenti) da
ciascuna persona o organizzazione. Se il documento include gi@`a un testo di
copertina per la stessa copertina, precedentemente aggiunto o adattato da
qualunque fruitore o dalla stessa organizzazione nel nome della quale si
agisce, non se ne pu@`o aggiungere un altro, ma si pu@`o rimpiazzare il
vecchio ottenendo l'esplicita autorizzazione dall'editore precedente che
aveva aggiunto il testo di copertina.
L'autore/i e l'editore/i del documento non danno, tramite questa licenza,
il permesso di usare i loro nomi per pubblicizzare o asserire, anche
implicitamente, la loro approvazione di ogni versione modificata.
@item
COMBINAZIONE DI DOCUMENTI
Si pu@`o combinare il documento con altri pubblicati con questa licenza,
seguendo i termini definiti nella precedente sezione 4 per le versioni
modificate, a patto che si includa l'insieme di tutte le sezioni non
modificabili di tutti i documenti originali, senza modifiche, e si
elenchino tutte come sezioni non modificabili della combinazione di
documenti nella licenza della stessa, mantenendo tutti i limiti alla
garanzia.
Nella combinazione @`e necessaria una sola copia di questa licenza, e pi@`u
sezioni non modificabili possono essere rimpiazzate da una singola copia
se identiche. Se ci sono pi@`u sezioni non modificabili con lo stesso nome
ma contenuti differenti, si renda unico il titolo di ciascuna sezione
aggiungendovi, alla fine e tra parentesi, il nome dell'autore o editore
della sezione, se noti, o altrimenti un numero distintivo. Si facciano gli
stessi aggiustamenti ai titoli delle sezioni nell'elenco delle sezioni non
modificabili nella nota di copyright della combinazione.
Nella combinazione si devono unire le varie sezioni intitolate ``Storia''
nei vari documenti originali di partenza per formare una unica sezione
intitolata ``Storia''; allo stesso modo si unisca ogni sezione intitolata
``Ringraziamenti'', e ogni sezione intitolata ``Dediche''. Si devono eliminare
tutte le sezioni intitolate ``Approvazioni''.
@item
RACCOLTE DI DOCUMENTI
Si pu@`o produrre una raccolta che consista del documento e di altri
documenti rilasciati sotto questa licenza, e rimpiazzare le singole copie
di questa licenza nei vari documenti con una sola inclusa nella raccolta,
solamente se si seguono le regole fissate da questa licenza per le copie
alla lettera come se si applicassero a ciascun documento.
Si pu@`o estrarre un singolo documento da tale raccolta e distribuirlo
separatamente sotto questa licenza, solo se si inserisce una copia di
questa licenza nel documento estratto e se si seguono tutte le altre
regole fissate da questa licenza per le copie alla lettera del documento.
@item
AGGREGAZIONE A LAVORI INDIPENDENTI
Un'unione del documento o sue derivazioni con altri documenti o lavori
separati o indipendenti, all'interno di, o a formare un, archivio o un
supporto, per la memorizzazione o la distribuzione, viene chiamato un
``aggregato'' se il copyright risultante dall'unione non viene usato per
limitare i diritti legali degli utilizzatori oltre a ci@`o che viene
permesso dai singoli lavori. Quando il documento viene incluso in un
aggregato, questa licenza non si applica ad altri lavori nell'aggregato
che non siano essi stessi dei lavori derivati dal documento.
Se le esigenze del testo di copertina della sezione 3 sono applicabili a
queste copie del documento allora, se il documento @`e inferiore alla met@`a
dell'intero aggregato i testi di copertina del documento possono essere
piazzati in copertine che delimitano il documento all'interno
dell'aggregato, o dell'equivalente elettronico delle copertine se il
documento @`e in un formato elettronico. Altrimenti devono apparire nella
copertina dell'intero aggregato.
@item
TRADUZIONE
La traduzione @`e considerata un tipo di modifica, di conseguenza si possono
distribuire traduzioni del documento nei termini della sezione 4.
Rimpiazzare sezioni non modificabili con traduzioni richiede un
particolare permesso da parte dei detentori del copyright, ma @`e possibile
includere la traduzione di parti o di tutte le sezioni non modificabili in
aggiunta alle versioni originali di queste sezioni. @`E possibile includere
una traduzione di questa licenza, di tutte le avvertenze del documento e
di tutti i limiti di garanzia, a condizione che si includa anche la
versione originale in inglese della licenza completa, comprese le
avvertenze e limitazioni di garanzia. In caso di discordanza tra la
traduzione e la versione originale inglese di questa licenza o avvertenza
o limitazione di garanzia, prevale sempre la versione originale inglese.
Se una sezione del documento viene titolata ``Riconoscimenti'', ``Dediche'', o
``Storia'', il requisito (sezione 4) di preservare il titolo (sezione 1)
richieder@`a tipicamente il cambiamento del titolo.
@item
CESSAZIONE DELLA LICENZA
Non si pu@`o sublicenziare il documento, copiarlo, modificarlo, o
distribuirlo al di fuori dei termini espressamente previsti da questa
licenza. Ogni altro tentativo di applicare una licenza al documento,
copiarlo, modificarlo, o distribuirlo @`e nullo e pone fine automaticamente
ai diritti previsti da questa licenza.
In ogni caso, se cessano tutte le violazioni di questa Licenza, allora la
specifica licenza di un particolare detentore del copyright viene
ripristinata (a) in via provvisoria, a meno che e fino a quando il
detentore del copyright non faccia estinguere esplicitamente e
definitivamente la licenza, e (b) in via permanente se il detentore del
copyright non notifica in alcun modo la violazione entro 60 giorni dalla
cessazione della licenza.
Inoltre, la licenza di un dato detentore del copyright viene ripristinata
in maniera permanente se quest'ultimo notifica la violazione in maniera
adeguata, se si tratta della prima volta che si riceve una notifica di
violazione della licenza (per qualsiasi opera) dallo stesso detentore di
copyright, e se la violazione viene corretta entro 30 giorni dalla data di
ricezione della notifica di violazione.
La cessazione dei diritti come specificato in questa sezione non provoca
la cessazione delle licenze di terze parti che abbiano ricevuto copie o
diritti secondo questa licenza. Se i diritti sono cessati e non sono stati
ristabiliti in via permanente, la ricezione di una copia dello stesso
materiale, in tutto o in parte, non d@`a alcun diritto ad utilizzarlo.
@item
REVISIONI FUTURE DI QUESTA LICENZA
La Free Software Foundation pu@`o occasionalmente pubblicare versioni nuove
o rivedute della Licenza per Documentazione Libera GNU. Le nuove versioni
saranno simili nello spirito alla versione attuale ma potrebbero
differirne in qualche dettaglio per affrontare nuovi problemi e concetti.
Si veda @uref{https://www.gnu.org/copyleft/}.
Ad ogni versione della licenza viene dato un numero che la distingue. Se
il documento specifica che si riferisce ad una versione particolare della
licenza ``o ogni versione successiva'', si ha la possibilit@`a di seguire
termini e condizioni sia della versione specificata che di ogni versione
successiva pubblicata (non come bozza) dalla Free Software Foundation. Se
il documento non specifica un numero di versione particolare di questa
licenza, si pu@`o scegliere ogni versione pubblicata (non come bozza) dalla
Free Software Foundation. Se il documento specifica che un delegato pu@`o
decidere quale futura versione di questa licenza pu@`o essere utilizzata,
allora la dichiarazione pubblica di accettazione della versione, da parte
del delegato, autorizza in maniera permanente a scegliere tale versione
per il documento.
@item
CAMBIO DI LICENZA
Il termine ``sito per la collaborazione massiva multiautore'' (o ``sito
MMC'')
indica qualsiasi server web che pubblica opere sottoponibili a copyright e
fornisce a chiunque appositi strumenti per modificare tali opere. Un wiki
pubblico modificabile da chiunque @`e un esempio di server in questione. Una
``collaborazione massiva multiautore'' (o ``MMC'') contenuta nel sito indica
un qualunque insieme di opere sottoponibili a copyright pubblicate sul
sito MMC.
Il termine ``CC-BY-SA'' indica la licenza Creative Commons Attribution-Share
Alike 3.0 pubblicata dalla Creative Commons Corporation, un'organizzazione
senza fini di lucro con sede principale a San Francisco, California, come
anche le future versioni di tale licenza pubblicate dalla stessa
organizzazione.
``Incorporare'' significa pubblicare o ripubblicare un documento in tutto o
in parte, come parte di un altro documento.
Una MMC @`e ``qualificata a cambiare questa licenza'' se ha adottato questa
licenza e se tutte le opere precedentemente pubblicate con questa licenza
altrove rispetto alla MMC e successivamente incorporate del tutto o in
parte nella MMC (1) non hanno testo di copertina o sezioni invarianti e
(2) sono state incorporate prima del 1@sup{o} novembre 2008.
L'operatore di un sito MMC pu@`o ripubblicare un MMC contenuto nel sito con
una CC-BY-SA nello stesso sito in qualsiasi momento prima del 1@sup{o} agosto
2009, da parte di una MMC qualificata a cambiare questa licenza.
@end enumerate
@c fakenode --- for prepinfo
@unnumberedsec ADDENDUM: Come usare questa licenza per i vostri documenti
Per applicare questa licenza ad un documento che si @`e scritto, si includa
una copia della licenza nel documento e si inserisca la seguente nota di
copyright appena dopo la pagina del titolo:
@smallexample
@group
Copyright (C) @var{} @var{}
@`E permesso copiare, distribuire e/o modificare questo documento
seguendo i termini della ``Licenza per documentazione libera GNU'', versione 1.3
o ogni versione successiva pubblicata dalla Free Software Foundation;
senza sezioni non modificabili, senza testi di prima di copertina e di quarta di copertina.
Una copia della licenza @`e inclusa nella sezione intitolata
``Licenza per la documentazione libera GNU''.
@end group
@end smallexample
Se ci sono sezioni non modificabili, testi di prima di copertina e di
quarta di copertina, scrivere nella parte ``with@dots{} di copertina'' il testo seguente:
@smallexample
@group
con le seguenti sezioni non modificabili @var{lista dei loro titoli},
con i seguenti testi di prima di copertina @var{elenco},
e con i seguenti testi di quarta di copertina @var{elenco},
@end group
@end smallexample
Se esistono delle sezioni non modificabili ma non i testi di copertina, o
qualche altra combinazione dei tre elementi sopra riportati, fondere
assieme le due alternative in modo da conformarsi alla situazione descritta.
Se il vostro documento contiene esempi non banali di programma in codice
sorgente si raccomanda di rilasciare gli esempi contemporaneamente
applicandovi anche una licenza di software libero di vostra scelta, come
per esempio la Licenza Pubblica Generica GNU, al fine di permetterne l'uso
come software libero.
@end ifclear
@ifnotdocbook
@node Indice analitico
@unnumbered Indice analitico
@end ifnotdocbook
@printindex cp
@bye
Unresolved Issues:
------------------
1. From ADR.
Robert J. Chassell points out that awk programs should have some indication
of how to use them. It would be useful to perhaps have a "programming
style" section of the manual that would include this and other tips.
Consistency issues:
/.../ regexps are in @code, not @samp
".." strings are in @code, not @samp
no @print before @dots
values of expressions in the text (@code{x} has the value 15),
should be in roman, not @code
Use TAB and not tab
Use ESC and not ESCAPE
Use space and not blank to describe the space bar's character
The term "blank" is thus basically reserved for "blank lines" etc.
To make dark corners work, the @value{DARKCORNER} has to be outside
closing `.' of a sentence and after (pxref{...}).
Make sure that each @value{DARKCORNER} has an index entry, and
also that each `@cindex dark corner' has an @value{DARKCORNER}.
" " should have an @w{} around it
Use "non-" only with language names or acronyms, or the words bug and option and null
Use @command{ftp} when talking about anonymous ftp
Use uppercase and lowercase, not "upper-case" and "lower-case"
or "upper case" and "lower case"
Use "single precision" and "double precision", not "single-precision" or "double-precision"
Use alphanumeric, not alpha-numeric
Use POSIX-compliant, not POSIX compliant
Use --foo, not -Wfoo when describing long options
Use "Bell Laboratories", but not "Bell Labs".
Use "behavior" instead of "behaviour".
Use "coprocess" instead of "co-process".
Use "zeros" instead of "zeroes".
Use "nonzero" not "non-zero".
Use "runtime" not "run time" or "run-time".
Use "command-line" as an adjective and "command line" as a noun.
Use "online" not "on-line".
Use "whitespace" not "white space".
Use "Input/Output", not "input/output". Also "I/O", not "i/o".
Use "lefthand"/"righthand", not "left-hand"/"right-hand".
Use "workaround", not "work-around".
Use "startup"/"cleanup", not "start-up"/"clean-up"
Use "filesystem", not "file system"
Use @code{do}, and not @code{do}-@code{while}, except where
actually discussing the do-while.
Use "versus" in text and "vs." in index entries
Use @code{"C"} for the C locale, not ``C'' or @samp{C}.
The words "a", "and", "as", "between", "for", "from", "in", "of",
"on", "that", "the", "to", "with", and "without",
should not be capitalized in @chapter, @section etc.
"Into" and "How" should.
Search for @dfn; make sure important items are also indexed.
"e.g." should always be followed by a comma.
"i.e." should always be followed by a comma.
The numbers zero through ten should be spelled out, except when
talking about file descriptor numbers. > 10 and < 0, it's
ok to use numbers.
For most cases, do NOT put a comma before "and", "or" or "but".
But exercise taste with this rule.
Don't show the awk command with a program in quotes when it's
just the program. I.e.
{
....
}
not
awk '{
...
}'
Do show it when showing command-line arguments, data files, etc, even
if there is no output shown.
Use numbered lists only to show a sequential series of steps.
Use @code{xxx} for the xxx operator in indexing statements, not @samp.
Use MS-Windows not MS Windows
Use MS-DOS not MS DOS
Use an empty set of parentheses after built-in and awk function names.
Use "multiFOO" without a hyphen.
Use "time zone" as two words, not "timezone".
Date: Wed, 13 Apr 94 15:20:52 -0400
From: rms@gnu.org (Richard Stallman)
To: gnu-prog@gnu.org
Subject: A reminder: no pathnames in GNU
It's a GNU convention to use the term "file name" for the name of a
file, never "pathname". We use the term "path" for search paths,
which are lists of file names. Using it for a single file name as
well is potentially confusing to users.
So please check any documentation you maintain, if you think you might
have used "pathname".
Note that "file name" should be two words when it appears as ordinary
text. It's ok as one word when it's a metasyntactic variable, though.
------------------------
ORA uses filename, thus the macro.
Suggestions:
------------
Better sidebars can almost sort of be done with:
@ifdocbook
@macro @sidebar{title, content}
@inlinefmt{docbook, }
\title\
@inlinefmt{docbook, }
\content\
@inlinefmt{docbook, }
@end macro
@end ifdocbook
@ifnotdocbook
@macro @sidebar{title, content}
@cartouche
@center @b{\title\}
\content\
@end cartouche
@end macro
@end ifnotdocbook
But to use it you have to say
@sidebar{Title Here,
@include file-with-content
}
which sorta sucks.
TODO: