Quest'opzione imposta
il compatibility mode, con le seguenti restrizioni aggiuntive : ·Non sono
riconosciute le sequenze \x. ·Quando a FS è assegnato un sigolo spazio, solo
spazi e TAB fungono da separatori di campo, il carattere "newline" invece
no. ·Non è riconosciuto il sinonimo func della parola chiave function. ·Non
si possono usare gli operatori ** e **= al posto di ^ and ^=. ·La funzione
fflush() non è disponibile.
- -W re-interval
- --re-interval
- Permette l'indicazione
di espressioni intervallari (interval expression) nella valutazione di
espressioni formali (che chiameremo d'ora in poi regular expression; sono
descritte in dettaglio in un apposito capitolo, più avanti). Le espressioni
intervallari non erano tradizionalmente disponibili nel linguaggio AWK.
Lo standard POSIX le ha aggiunte per rendere awk ed egrep coerenti tra
loro. Con questa prestazione, tuttavia, i vecchi programmi AWK probabilmente
non funzionano più. Per questo gawk riconosce le espressioni intervallari
solo se espressamente richieste specificando questa opzione oppure --posix.
- -W source testo-del-programma
- --source testo-del-programma
- Usa testo-del-programma
come codice sorgente del programma AWK. Quest'opzione permette di aggiungere
in modo semplice funzioni di libreria (raccolte in file indicati dalle
opzioni -f e --file) con codice sorgente dato nella linea di comando. È stata
pensata per programmi di media e grande dimensione usati all'interno di
procedure di shell ("shell script").
- -W version
- --version
- Scrive su "standard
output" la versione di questa particolare copia di gawk. È utile principalmente
per sapere se la copia di gawk installata correntemente è aggiornata rispetto
a ciò che Free Software Foundation sta distribuendo. In linea con le convenzioni
di codifica GNU (GNU Coding Standards), queste opzioni provocano un'uscita
immediata e senza segnalazione di errore.
- --
- Indica la fine delle opzioni.
Permette di passare al programma AWK stesso argomenti che comincino con
"-", e quindi conformi alla convenzione di passaggio dei parametri della
maggior parte delle applicazioni .
In modalità compatibile, tutte le altre
opzioni sono segnalate come illegali, e per il resto ignorate. Nell'uso
normale le opzioni sconosciute sono passate al programma nel vettore ARGV
per l'elaborazione, purché il testo del programma sia dato in qualche modo.
Ciò è utile in particolare nel lancio del programma AWK tramite il meccanismo
di esecuzione automatica dell'interprete, realizzato dalla sequenza "#!"
all'inizio del file eseguibile.
Un programma
AWK consiste in una sequenza di istruzioni ("statement") del tipo "pattern-azione"
ed, opzionalmente, definizioni di funzioni.
pattern { azione istruzioni
}
function nome(lista di parametri) { istruzioni }
Gawk legge prima
di tutto il programma sorgente da file-di-programma se specificato, dagli
argomenti di --source, o dal primo argomento non di tipo opzione della linea
di comando. Le opzioni -f e --source possono essere usate più volte nella
linea di comando. Gawk leggerà il testo del programma come se tutti i file-di-programma
e il testo sorgente della linea di comando fossero concatenati. Questo
permette di realizzare librerie di funzioni AWK senza bisogno di includerle
in ogni nuovo programma che le usi; inoltre si possono unire funzioni
di libreria a programmi provenienti dalla linea di comando.
La variabile
di ambiente AWKPATH specifica il percorso lungo il quale cercare i file
sorgenti indicati dall'opzione -f. Se questa variabile non esiste, è utilizzato
il percorso ".:/usr/local/share/awk" (ma questo percorso può variare a
seconda di come gawk sia stato compilato ed installato). Se un nome di
file dato all'opzione -f contiene il carattere "/", non è eseguita alcuna
ricerca tramite percorso.
Gawk esegue i programmi nell'ordine seguente. Per
prima cosa, realizza tutti gli assegnamenti indicati dall'opzione -v. Successivamente,
converte i programmi in un formato interno. A questo punto esegue il codice
dei blocchi BEGIN, se presenti, infine legge ciascun file indicato nel
vettore ARGV. Se non ne è indicato alcuno, gawk legge da "standard input".
Se un nome di file nella linea di comando ha la forma var=val, è trattato
come un assegnamento di variabile. Alla variabile var sarà assegnato il
valore val. Quest'azione, che ha luogo dopo che tutti i blocchi BEGIN sono
stati eseguiti, è utilissima per agire dinamicamente sulle variabili che
AWK usa per decidere come isolare i campi ed i record in ingresso. È utile
inoltre per controllare variabili di stato quando siano necessari più
passi di elaborazione su un singolo file di dati.
Se il valore di un particolare
elemento di ARGV è la stringa vuota ("" ), gawk lo salta.
Per ogni record
in ingresso, gawk controlla se soddisfi qualcuna delle configurazioni
("pattern "), specificate nel programma AWK. Per ogni pattern compatibile
col record, è eseguita la corrispondente azione. I pattern sono controllati
nell'ordine in cui appaiono nel programma.
Infine, dopo che sono esauriti
i dati in ingresso, gawk esegue il codice negli eventuali blocchi END.
Le variabili di AWK sono dinamiche; iniziano
ad esistere la prima volta che le si usa. I loro valori sono numeri in
virgola mobile, o stringhe, o entrambe le cose, a seconda di come sono
usati. Inoltre AWK dispone di vettori monodimensionali; i vettori multidimensionali
possono essere simulati. Al lancio del programma sono impostate parecchie
variabili predefinite; saranno descritte di volta in volta quando sarà
necessario, ed elencate più avanti.
Normalmente i record sono separati
dal carattere "newline". Si può controllare il modo in cui i record sono
separati grazie alla variabile predefinita RS. Se RS contiene un qualsiasi
carattere singolo, tale carattere separerà i record. Altrimenti, RS può
essere un'espressione formale (regular expression): i record saranno separati
della parte di testo in ingresso compatibile con l'espressione. Tuttavia,
nella modalità compatibile (compatibility mode) è preso in considerazione
solo il primo carattere della stringa come separatore. Se RS contiene la
stringa nulla, i record sono separati da righe vuote. Quando RS contiene
la stringa nulla, il carattere "newline" ha sempre la funzione di separatore
di campo in aggiunta a quello indicato dalla variabile FS, qualunque sia.
Ogni volta che gawk legge un record lo spezza in campi, usando
il valore della variabile FS come separatore di campo. Se FS è un singolo
carattere, i campi sono separati da quel carattere. Se FS è la stringa
nulla, ogni singolo carattere del record diventa un diverso campo. Diversamente,
si presume che FS sia un'espressione formale ("regular expression ") completa.
Nel caso particolare in cui FS è un singolo spazio, i campi sono separati
da sequenze di spazi, "tab" o "newline" (ma si veda più avanti la discussione
dell'opzione --posix). Si noti che il valore di IGNORECASE (vedi) influenza
anche il modo in cui i campi sono spezzati quando FS è una regular expression,
e come i record vengano separati quando RS è una regular expression.
Se
alla variabile FIELDWIDTHS è assegnata una lista di numeri separati da
spazi, ogni campo è considerato di lunghezza fissa, e gawk spezza il record
secondo le ampiezze specificate. Il valore di FS è ignorato. Assegnando
un nuovo valore a FS, si annulla l'effetto di FIELDWIDTHS, e si ripristina
il comportamento ordinario.
Ogni campo nel record in ingresso può essere
individuato dalla sua posizione : $1, $2, e così via. $0 è l'intero record.
Nello stesso modo, si può anche assegnare un valore ad un campo. Non è
necessario che i campi siano indicati da costanti:
n = 5
print $n
stampa
il quinto campo del record d'ingresso. La variabile NF contiene il numero
di campi nel record corrente.
Riferimenti a campi inesistenti (cioè campi
oltre $NF) producono la stringa vuota. Tuttavia, l'assegnamento ad un campo
inesistente (per esempio $(NF+2) = 5) provoca l'incremento del valore di
NF, crea tutti i campi intermedi assegnando loro la stringa nulla, e fa
sì che il valore di $0 sia ricalcolato utilizzando OFS per separare i
campi. Riferimenti a campi con indice negativo producono un errore fatale.
Il decremento di NF provoca la perdita dei campi di indice superiore al
valore impostato, ed il ricalcolo di $0, utilizzando OFS per separare
i campi.
Le variabili predefinite di gawk sono:
- ARGC
- Il numero di argomenti della linea di comando (escluse le opzioni
proprie di gawk ed il programma sorgente).
- ARGIND
- L'indice in ARGV del
file correntemente elabolato.
- ARGV
- Vettore degli argomenti della linea
di comando. Il suo indice va da 0 ad ARGC - 1. La modifica del contenuto
di ARGV permette di variare dinamicamente i file dei dati.
- CONVFMT
- Il
formato di conversione dei numeri, d'ufficio vale "%.6g" .
- ENVIRON
- Un vettore
contenente i valori dell'ambiente ("environment") corrente. Gli indici del
vettore sono i nomi delle variabili d'ambiente, e gli elementi contengono
i valori corrispondenti (per esempio, ENVIRON["HOME"] potrebbe valere
qualcosa come /home/arnold). La modifica di questo vettore non si riflette
sull'environment ereditato dai programmi che gawk lancia per redirezione
o con la funzione system(). (Ciò potrebbe cambiare in una futura versione
di gawk.)
- ERRNO
- Se ha luogo un errore di sistema in un redirezione o una
lettura fatte con getline, oppure in una close(), ERRNO conterrà una stringa
descrivente l'errore.
- FIELDWIDTHS
- Una lista di ampiezze di campo separate
da spazi. Se impostato, gawk analizza l'ingresso secondo campi di lunghezza
fissa, anziché usare il valore della variabile FS come separatore di
campo. Questa prestazione è ancora nella fase sperimentale; la sua semantica
potrebbe cambiare con l'evolvere di gawk.
- FILENAME
- Il nome del file di
ingresso corrente. Se non sono specificati file nella linea di comando,
il valore di FILENAME è "-". Tuttavia, FILENAME è indefinito all'interno
del blocco BEGIN.
- FNR
- L'indice del record nel file di ingresso corrente.
- FS
- Il separatore di campo, normalmente uno spazio. Si veda Campi, sopra.
- IGNORECASE
- Controlla la sensibilità alla distinzione tra maiuscole e
minuscole ("case-sensitivity") nella valutazione di tutte le regular expression
e nelle operazioni coinvolgenti stringhe. Se IGNORECASE ha un valore diverso
da zero, allora il confronto di pattern nelle regole, il confronto di
stringhe, la separazione di campi tramite FS, la separazione di record
tramite RS, gli operatori ~ e !~, e le funzioni predefinte gensub(),
gsub(), index(), match(), split(), e sub() ignoreranno tutti la differenza
tra maiuscole e minuscole nelle operazioni coinvolgenti regular expression.
Così, se IGNORECASE è diverso da zero, /aB/ si accorda con tutte queste
stringhe : "ab" , "aB" , "Ab" , e "AB" . Come per tutte le variabili di
AWK, il valore iniziale di IGNORECASE è zero, cosicché tutte le operazioni
su regular expression e su stringhe normalmente distinguono tra maiuscole
e minuscole. Su Unix, è utilizzato l'intero insieme di caratteri ISO 8852-1
Latin-1 quando è ignorata la distinzione tra maiuscole e minuscole. NOTA:
Nelle versioni di gawk precedenti la 3.0, IGNORECASE influenzava solo le
operazioni riguardanti regular expression. Ora ha effetto anche sul confronto
fra stringhe.
- NF
- Il numero di campi nel record corrente.
- NR
- Il numero
totale di record incontrati finora.
- OFMT
- Il formato d'uscita per i numeri,
d'ufficio vale "%.6g" .
- OFS
- Il separatore di campi in uscita, normalmente
è uno spazio.
- ORS
- Il separatore di record in uscita, normalmente la sequenza
di fine linea ("newline ").
- RS
- Il separatore di record in ingresso, normalmente
"newline".
- RT
- Il terminatore di record. gwak pone RT uguale al testo in
ingresso che corrisponde al carattere o alla regular expression indicati
in RS.
- RSTART
- L'indice del primo carattere trovato conforme da match(),
oppure 0 se non ci sono corrispondenze.
- RLENGTH
- la lunghezza della stringa
trovata conforme da match(); oppure -1 se non ci sono corrispondenze.
- SUBSEP
- Il carattere usato per separare indici multipli negli elementi di un
vettore, d'ufficio è "\034" .
I vettori sono indicizzati da un'espressione
tra parentesi quadre ([ e ]). Se l'espressione è formata da una lista di
espressioni (expr, expr ...) l'indice del vettore è una stringa ottenuta concatenando
i valori (stringa) di ogni espressione, sepati dal valore della variabile
SUBSEP. Questa prestazione è sfruttata per simulare vettori multidimensionali.
Per esempio:
i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"
assegna la stringa "hello, world\n" all'elemento del vettore x il cui
indice è la stringa "A\034B\034C" . In AWK, tutti i vettori sono associativi,
cioè indicizzati da valori di tipo stringa.
L'operatore in può essere usato
in istruzioni if o while per sapere se un vettore preveda un certo valore
come indice.
if (val in array)
print array[val]
Se il vettore ha indici
multipli, si usi (i, j) in array.
Il costrutto in può anche essere usato
in un ciclo for per iterare su tutti gli elementi di un vettore.
Un elemento
di un vettore può essere cancellato con l'istruzione delete. delete può
anche essere usato per cancellare l'intero contenuto di un vettore, basta
specificare il nome del vettore stesso senza indici.
Le variabili e i campi possono essere numeri in virgola
mobile, stringhe, o entrambe le cose. Come sia interpretato il valore di
una variabile dipende dal contesto. In un'espressione numerica, sarà trattato
come numero; usato come stringa, sarà trattato come tale.
Per fare in modo
che una variabile sia trattata come numero, le si sommi 0; per ottenere
il trattamento come stringa, le si concateni la stringa nulla.
Quando una
stringa deve essere convertita a numero, la conversione è compiuta con
atof(3)
. I numeri sono convertiti a stringhe usando sprintf(3)
col valore
di CONVFMT come stringa di formato ed il valore numerico della variabile
come argomento. Tuttavia, anche se tutti i numeri in AWK sono in virgola
mobile ("float"), i valori privi di decimali sono sempre convertiti come
interi. Così, dati
CONVFMT = "%2.2f"
a = 12
b = a ""
la variabile b
ha un valore di tipo stringa di "12" e non "12.00" .
Gawk esegue i confronti
nel modo seguente: Se due variabili sono numeriche, sono confrontate numericamente.
Se una è numerica e l'altra è una stringa interpretabile come numero, sono
pure confrontate numericamente. Negli altri casi, gli eventuali valori
numerici sono convertiti in stringhe, ed è eseguito un confronto tra stringhe.
Secondo lo standard , il confronto numerico dovrebbe aversi anche quando
entrambe le variabili fossero stringhe convertibili a numeri. Tuttavia,
questo è chiaramente sbagliato, e gawk non lo fa.
Si noti che le costanti
stringa, come "57" , non sono stringhe numeriche, ma solo costanti stringa.
L'idea di "stringa numerica" si applica solo ai campi, all'ingresso di getline,
a FILENAME, agli elementi di ARGV e di ENVIRON, ed agli elmenti di un
vettore creato da split() che abbiano le caratteristiche di una stringa
numerica. L'idea fondamentale è che debbano essere trattati in questo modo
solo i dati forniti dall'utente (user input), e non altri.
Le variabili
non inizializzate hanno come valore numerico 0, e come valore di stringa
"" (cioè la stringa vuota, o stringa nulla).
AWK è un
linguaggio orientato alla linea. Il pattern va all'inizio, l'azione a seguire.
Le istruzioni dell'azione sono chiuse tra { e }. Sia il pattern che l'azione
possono mancare ma, naturalmente, non entrabi. Se manca il pattern, l'azione
è eseguita per ogni record in ingresso. Omettere invece l'azione equivale
a specificare
{ print }
che stampa l'intero record.
I commenti cominciano
col carattere "#", e continuano fino a fine riga. Si possono separare le
istruzioni con righe vuote. Un'istruzione finisce normalmente con la fine
della riga, a meno che non termini in ",", {, ?, :, &&, o ||. Le istruzioni
in righe terminanti con do o else continuano automaticamente alla riga
successiva. Negli altri casi, una riga terminante con un "\" continua alla
successiva, e "newline" è ignorato.
Si possono scrivere più istruzioni
sulla stessa linea separandole con ";". Questo si applica sia alle istruzioni
all'interno di un'azione (il caso più comune), sia ai gruppi pattern-azione
stessi.
I pattern di AWK possono assume le forme seguenti:
BEGIN
END /regular expression/ espressione di relazione pattern && pattern pattern
|| pattern pattern ? pattern : pattern (pattern) ! pattern pattern1, pattern2
BEGIN e END sono due tipi speciali di pattern, che non dipendono dai
dati in ingresso. Le azioni di tutti i pattern BEGIN sono unite insieme,
come se tutte le istruzioni fossero scritte in un unico blocco BEGIN,
e sono eseguite prima che sia letto alcunché dall'igresso. Allo stesso modo,
tutti i blocchi END sono fusi insieme, ed eseguiti dopo che tutti i dati
in ingresso sono terminati o si è incontrata l'istruzione exit. BEGIN e
END non possono essere combinati con altri pattern in espressioni, inoltre
l'azione associata ad essi è obbligatoria.
Per i pattern nella forma /regular
expression/ l'azione associata è eseguita per ogni record in ingresso che
sia conforme alla regular expression. Le "regular expression" hanno la
stessa forma di quelle di egrep(1)
, e sono descritte più avanti.
In un'espressione
relazionale si può usare qualsiasi operatore definito nella sezione sulla
azioni, più avanti. Generalmente l'espressione relazionale è utilizzata
per verificare se certi campi si accordino con determinate regular expression.
Gli operatori &&, ||, e ! sono rispettivamnete l'AND logico, l'OR logico, ed
il NOT logico. Come i loro equivalenti del linguaggio C, valutano solo
il numero di operandi strettamente necessario a decidere il risultato,
a partire da quello più a sinistra ("short-circuit evaluation"). Sono usati
per combinare espressioni di pattern più semplici. Come nella maggior parte
dei linguaggi, si possono usare parentesi per cambiare l'ordine di valutazione.
L'operatore ?: è simile allo stesso operatore del C: se il primo pattern
è vero, allora il pattern utilizzato per il test è il secondo, altrimenti
è il terzo. Dei pattern secondo e terzo, ne è valutato sempre solo uno.
Un'espressione nella forma pattern1, pattern2 è detta range pattern. Essa
considera compatibili tutti i record a partire da uno conforme a pattern1,
fino ad uno conforme a pattern2, compreso. Non può essere combinata con
alcun'altra espressione.
Le
regular expression sono del tipo esteso che si trova in egrep. Sono composte
da caratteri secondo le regole seguenti:
- c
- accetta il carattere (non
speciale) c.
- \c
- accetta il carattere c considerato letteralmente.
- .
- accetta
qualsiasi carattere, compreso "newline".
- ^
- accetta l'inizio di una stringa.
- $
- accetta la fine di una stringa.
- [abc...]
- lista di caratteri, accetta uno
qualsiasi dei caratteri abc....
- [^abc...]
- lista di caratteri negata, accetta
qualsiasi carattere eccetto abc....
- r1|r2
- alternativa: accetta r1 oppure r2.
- r1r2
- concatenazione: accetta r1, e poi r2.
- r+
- accetta uno o più r.
- r*
- accetta zero o più r.
- r?
- accetta un r o nessuno.
- (r)
- raggruppamento:
accetta r.
- r{n}
- r{n,}
- r{n,m}
- Uno o due numeri racchiusi tra graffe
indicano un'"espressione intervallare" (interval expression). Se c'è un numero
tra graffe, la regular expression precedente r è ripetuta n volte. Se tra
graffe ci sono due numeri separati da virgola, r è ripetuta da n ad m
volte. Se c'è un numero seguito da una virgola, r è ripetuta almeno n volte.
Le espresioni intervallari sono ammesse solo se nella linea di comando
è specificata l'opzione --posix oppure --re-interval.
- \y
- accetta la stringa vuota
all'inizio o alla fine di una parola.
- \B
- accetta la stringa vuota all'interno
di una parola.
- \<
- accetta la stringa vuota all'inizio di una parola.
- \>
- accetta
la stringa vuota alla fine di una parola.
- \w
- accetta un qualsiasi carattere
che possa far parte di una parola, cioè lettere, numeri o "_" ("underscore").
- \W
- accetta un qualsiasi carattere che non possa far parte di una parola.
- è
- accetta la stringa vuota all'inizio di una stringa.
- \'
- accetta la stringa
vuota alla fine di una stringa.
Le sequenze "\x" ("escape sequence") valide
all'interno delle stringhe (vedere oltre) sono ammesse anche nelle regular
expression.
Le classi di caratteri sono una nuova prestazione introdotta
nello standard POSIX. Una classe di caratteri è una speciale notazione
per indicare liste di caratteri accomunati da uno specifico attributo,
i costituenti delle quali possono variare a seconda della nazionalità
e dell'insieme di caratteri di sistema (detto comunenmente character set
o charset per brevità) correntemente attivi. Per esempio, la nozione di
"carattere alfabetico" valida negli Stati Uniti è diversa da quella valida
in Francia.
Una classe di caratteri è ammessa solo all'interno delle parentesi
quadre di una lista di caratteri di una regular expression. Le classi di
caratteri si rappresentano con [:, una parola chiave indicante la classe,
e :]. Queste sono le classi di caratteri definite dallo standard POSIX:
- [:alnum:]
- Caratteri alfanumerici.
- [:alpha:]
- Caratteri alfabetici.
- [:blank:]
- Caratteri "spazio" e "tab".
- [:cntrl:]
- Caratteri di controllo.
- [:digit:]
- Caratteri numerici.
- [:graph:]
- Caratteri che siano sia stampabili che
visibili (uno spazio è stampabile ma non visibile, mentre a è entrambe
le cose).
- [:lower:]
- Caratteri alfabetici minuscoli.
- [:print:]
- Caratteri
stampabili (cioè caratteri che non siano di controllo).
- [:punct:]
- Caratteri
di punteggiatura (cioè caratteri che non siano né lettere, né cifre, né
caratteri di controllo, né caratteri di spaziatura).
- [:space:]
- Caratteri
di spaziatura (come lo spazio, "tab", "formfeed", per citarne solo alcuni).
- [:upper:]
- Caratteri alfabetici maiuscoli.
- [:xdigit:]
- Cifre esadecimali.
Per fare un esempio, prima dell'introduzione dello standard POSIX si sarebbe
dovuto scrivere /[A-Za-z0-9]/ per individuare caratteri alfanumerici. Qualora
il "character set" vigente avesse compreso altri caratteri alfanumerici,
l'espressione non li avrebbe riconosciuti. Con le classi di caratteri POSIX,
si può scrivere /[[:alnum:]]/, che troverà corrispondenza con tutti i
caratteri alfabetici e numerici previsti dal charset correntemente in
uso.
Nelle liste di caratteri possono comparire due sequenze speciali aggiuntive.
Esse si applicano ai charset non ASCII, i quali possono comprendere sia
simboli singoli, chiamati "elementi di confronto testuale" (collating
elements) rappresentati da più di un carattere, sia gruppi di caratteri
tra loro equivalenti ai fini del confronto testuale (collating) o dell'ordinamento.
Per esempio, in francese una "e" semplice ed una con l'accento grave sono
equivalenti.
- Simboli di Confronto Testuale ("Collating Symbols ")
- Un simbolo
di confronto testuale è un elemento di confronto di più di un carettere
chiuso tra [. e .]. Per esempio, se ch è un elemento di confronto testuale,
allora [[.ch.]] è la regular expression che lo individua, mentre [ch] è
una regular expression che individua o il carattere c, o il carattere
h.
- Classi di Equivalenza ("Equivalence Classes ")
- Una classe di equivalenza
è un nome, dipendente dalla località, associato ad una lista di caratteri
tra loro equivalenti. Il nome è racchiuso tra [= e =]. Per esempio, il nome
e potrebbe essere usato per rappresentare globalmente i caratteri e, è
ed é. In questo caso, [[=e]] è una regular expression compatibile con uno
qualsiasi dei caratteri e, é, ed è.
Queste funzionalità sono molto apprezzabili
quando la lingua corrente non è l'inglese. Le funzioni di libreria che gawk
usa nella valutazione di regular exopression riconoscono attualmente solo
le classi di caratteri POSIX, non i simboli di confronto testuale né le
classi di equivalenza.
Gli operatori \y, \B, \<, \>, \w, \W, è, ed \' sono specificità
di gawk; queste estensioni sono possibili grazie alle facilitazioni derivanti
dall'uso della libreria "regexp" di GNU.
Quelle che seguono sono le opzioni
della linea di comando che controllano come gawk interpreti i caratteri
nella regular expression.
- Nessuna opzione
- In assenza di indicazioni, gawk
mette a disposizione tutte le facilitazioni caratteristiche delle regular
expression POSIX e degli operatori GNU descritti prima. Tuttavia, le espressioni
intervallari non funzionano.
- --posix
- Sono riconosciute solo le regular expression
POSIX, non gli operatori GNU (per esempio, \w individua il carattere w).
Sono ammesse le espressioni intervallari.
- --traditional
- Le regular expression
sono valutate secondo le regole del tradizionale awk per Unix. Nè gli operatori
GNU, né le espressioni intervallari, né le classi di caratteri POSIX ([[:alnum:]]
e simili) funzionano. I caratteri descritti da sequenze ottali o esadecimali
sono trattati letteralmente, anche se rappresentano metacaratteri di regular
expression.
- --re-interval
- Sono permesse le espressioni intervallari, anche
se è stato specificato --traditional.
Le istruzioni di azione sono
rinchiuse tra graffe, { e }. Le istruzioni del costrutto di azione possono
essere assegnamenti o istruzioni condizionali o iterative come si trovano
nella maggior parte dei linguaggi. Gli operatori, le strutture di controllo
e le istruzioni di input/output ricalcano le corrispondenti del linguaggio
C.
Gli operatori di AWK, in ordine decrescente di precedenza,
sono
- (...)
- Raggruppamento
- $
- Riferimento a campi.
- ++ --
- Incremento e decremento,
sia prefisso che postfisso.
- ^
- Elevamento a potenza (si può anche usare
** al suo posto, e **= nell'assegnamento con operatore).
- + - !
- Più e meno
unari, e negazione logica.
- * / %
- Moltiplicazione, divisione e resto.
- +
-
- Addizione e sottrazione.
- spazio
- Concatenazione di stringhe.
- < >
- <= >=
- != ==
- I ben noti operatori di relazione.
- ~ !~
- Controllo di conformità
("match") tra regular expression, e controllo di non conformità. NOTA:
Non usare una regular expression costante (/foo/) come operando di sinistra
di ~ o !~. Si indichi sempre la regular expression come operando di destra.
L'espressione /foo/ ~ exp ha lo stesso significato di (($0 ~ /foo/) ~ exp)
. Non è questo, in genere, che ci si aspetta.
- in
- Controllo di appartenenza
ad un vettore.
- &&
- AND logico.
- ||
- OR logico.
- ?:
- L'espressione condizionale in
stile C. Ha la forma expr1 ? expr2 : expr3. Se expr1 è vera, il valore dell'espressione
è expr2, altrimenti è expr3. È valutata solo una delle due espressioni
expr2 ed expr3.
- = += -=
- *= /= %= ^=
- Assegnamento. Sono riconosciuti sia
l'assegnamento assoluto (var = value) sia quello con operatore (le altre
forme).
Le istruzioni di controllo di AWK sono:
if (condizione) istruzione [ else istruzione ]
while (condizione)
istruzione
do istruzione while (condizione)
for (expr1; expr2; expr3)
istruzione
for (var in vettore) istruzione
break
continue
delete
vettore[indice]
delete vettore
exit [ espressione ]
{ istruzione
}
Le istruzioni di input/output sono le seguenti:
- close(file)
- Chiude un file (o una pipe, come si vedrà più avanti).
- getline
- Copia in $0 la prossima linea d'ingresso, e ricalcola NF, NR, FNR.
- getline
<file
- Copia in $0 la prossima linea di file, e ricalcola NF.
- getline var
- Copia in var la prossima linea d'ingresso, e ricalcola NR ed FNR.
- getline
var <file
- Copia in var la prossima linea di file.
- next
- Cessa l'elaborazione
della linea d'ingresso corrente. È letta la successiva, e l'elaborazione
ricomincia dal primo pattern del programma AWK. Se non ci sono più righe
in ingresso, sono eseguiti i blocchi END, se presenti.
- nextfile
- Cessa
l'eleborazione del file di ingresso corrente. La prossima linea sarà letta
dal file di ingresso successivo. Sono aggiornati FILENAME ed ARGIND, FNR
è riportato ad 1, e l'elaborazione riprende dal primo pattern del programma
AWK. Se non ci sono più dati in ingresso, sono eseguiti gli eventuali blocchi
END. NOTA: Nelle precedenti versioni di gawk si usavano le due distinte
parole next file. Quest'ultima forma è ancora riconosciuta, ma potrebbe
non esserlo in futuro; per il momento essa provoca l'emissione di un messaggio
di avvertimento.
- print
- Stampa il record corrente, seguito dal valore della
variabile ORS.
- print expr-list
- Stampa le espressioni indicate, separate
dal valore della variabile OFS. La linea prodotta termina col valore della
variabile ORS.
- print expr-list >file
- Stampa su file le espressioni indicate,
separandole col valore della variabile OFS. La linea prodotta termina col
valore della variabile ORS.
- printf fmt, expr-list
- Stampa secondo formato.
- printf fmt, expr-list >file
- Stampa secondo formato su file.
- system(cmd-line)
- Esegue il comando cmd-line, e ne restituisce il valore d'uscita. (Può non
essere disponibile sui sistemi non-.).
- fflush( [file ])
- Scarica il contenuto
di tutti i buffer associati al file o alla pipe aperti in scrittura file.
Se file non è specificato, è assunto lo standard output. Se file è la stringa
vuota, l'operazione è eseguita su tutti i file e le pipe aperti in scrittura.
Sono permessi anche altri tipi di redirezione. Per print e printf, >>file
accoda i caratteri prodotti a file, metre | command scrive su una pipe.
Allo stesso modo, command | getline legge da una pipe l'uscita di "command".
L'istruzione getline restituirà 0 in caso di fine file, e -1 in caso di
errore.
Le versioni di AWK dell'istruzione printf e
della funzione sprintf() (vedi più avanti) accettano i seguenti formati
di conversione:
- %c
- Un carattere ASCII
. Se l'argomento usato per %c è numerico,
è trattato come un carattere e stampato. Altrimenti l'argomento è di tipo
stringa, e ne è stampato solo il primo carattere.
- %d
- %i
- Un numero decimale
(parte intera).
- %e
- %E
- Un numero in virgola mobile nella forma [-]d.dddddde[+-]dd.
Con %E si ottiene E anziché e.
- %f
- Un numero in virgola mobile nella forma
[-]ddd.dddddd.
- %g
- %G
- Usa il più corto tra i formati e ed f (o E ed f,
nel caso di %G) e sopprime gli zeri non significativi.
- %o
- Un numero ottale
senza segno (di nuovo, un intero).
- %s
- Una stringa di caratteri.
- %x
- %X
- Un numero esadecimale senza segno (intero). %x usa i caratteri abcdef,
mentre %X usa ABCDEF.
- %%
- Un singolo carattere %; nessun argomento è convertito.
Tra % e la lettera di controllo possono comparire alcuni parametri opzionali:
- -
- L'espressione dovrebbe essere giustificata a sinistra all'interno del
proprio campo.
- spazio
- Nelle conversioni numeriche, fa precedere ai valori
positivi uno spazio, ed ai valori negativi il segno "meno".
- +
- Il segno
"più" prima del modificatore di ampiezza (descritto più avanti) indica
che nelle conversioni numeriche il segno deve essere sempre prodotto,
anche se il valore del dato è positivo. + annulla l'effetto dello spazio.
- #
- Usa una "forma alternativa" con certe lettere di controllo. Con %o è
aggiunto uno zero iniziale; con %x e %X sono aggiunti rispettivamente
0x e 0X in caso di valore diverso da zero; con %e, %E, e %f, il risultato
conterrà sempre il punto decimale; con %g, e %G, gli zeri in coda non
sono rimossi.
- Uno 0 (zero) iniziale indica che la stringa risultante deve
essere completata da zeri anziché spazi. Questo vale anche per i formati
non numerici. Questo indicatore ha effetto solo quando la larghezza del
campo è maggiore di quella necessaria a contenere il valore da stampare.
- ampiezza
- Un numero indicante l'ampiezza che il campo dovrebbe avere. Normalmente
il carattere di riempimento è uno spazio, ma se si è usato l'indicatore
0, il carattere di riempimento è lo zero.
- .prec
- Un numero indicante la
precisione da utilizzare nella stampa. Con i formati %e, %E, e %f, specifica
il numero di cifre che dovranno comparire a destra del punto decimale.
Con i formati %g, e %G, specifica il massimo numero di cifre significative.
Con i formati %d, %o, %i, %u, %x, e %X, specifica il numero minimo di
cifre da stampare. Con le stringhe, specifica il massimo numero di caratteri
della stringa che potranno essere stampati.
È permessa la definizione dinamica
di ampiezza e prec prevista dalla funzione printf() dell' C. Un * al posto
di ampiezza o prec farà sì che i loro valori siano presi dalla lista degli
argomenti di printf o sprintf().
Nelle redirezioni
di print o printf in un file, o di getline da un file, gawk riconosce
internamente certi nomi di file speciali, che permettono di accedere a
file descriptor ereditati dal processo genitore di gawk (la shell, in
genere), oppure ad informazioni riguardanti il processo gawk corrente.
I nomi speciali sono:
- /dev/pid
- La lettura di questo file fornisce il
PID del processo corrente, in forma decimale e terminante con "newline".
- /dev/ppid
- La lettura di questo file fornisce il PID del genitore del
processo corrente, in forma decimale e terminante con "newline".
- /dev/pgrpid
- La lettura di questo file fornisce il "process group ID" del processo
corrente, in forma decimale e terminante con "newline".
- /dev/user
- La lettura
di questo file fornisce una linea terminante con "newline", i cui campi
sono separati da spazi. $1 è il valore della system call getuid(2)
, $2
è il valore di geteuid(2)
, $3 è il valore di getgid(2)
, e $4 è il valore
di getegid(2)
. Se ci sono campi addizionali, sono i "group ID" dati da
getgroups(2)
. I gruppi multipli possono non essere realizzati su tutti
i sistemi.
- /dev/stdin
- Lo "standard input".
- /dev/stdout
- Lo "standard output".
- /dev/stderr
- Lo "standard error".
- /dev/fd/n
- Il file associato al file
descriptor aperto n.
Questi ultimi sono utili in particolare nell'emissione
di messaggi. Per esempio, si può scrivere:
print "Che sf...ortuna!" > "/dev/stderr"
laddove, per ottenere lo stesso effetto, si sarebbe stati costretti a
scrivere
print "Che sf...ortuna!" | "cat 1>&2"
Questi nomi di file possono
essere anche dati nella linea di comando come nomi di file di dati.
AWK ha le seguenti funzioni aritmetiche predefinite:
- atan2(y,
x)
- l'arcotangente di y/x in radianti.
- cos(expr)
- coseno di expr (si aspetta
radianti).
- exp(expr)
- esponenziale.
- int(expr)
- troncamento ad intero.
- log(expr)
- logaritmo naturale.
- rand()
- fornisce un numero casuale tra 0 ed 1.
- sin(expr)
- seno di expr (si aspetta radianti).
- sqrt(expr)
- radice quadrata.
- srand(
[expr ])
- usa expr come nuovo seme per il generatore di numeri casuali.
Se expr non è indicata, sarà utilizzata la data corrente. Il valore di
ritorno è il valore precedente del seme.
Gawk offre
le seguenti funzioni di stringa predefinite:
- gensub(r, s, h [, t ])
- cerca nella stringa obiettivo t corrispondenze con la regular expression
r. Se h è una stringa che inizia con g o G, tutte le corrispondenze con
r sono sostituite con s; altrimenti, h è un numero che indica la particolare
corrispondenza con r che si vuole sostituire. Se t non è specificata, è
usato $0 al suo posto. All'interno del testo di rimpiazzo s si può utilizzare
la sequenza \n , dove n è una cifra tra 1 e 9, per indicare la parte di
testo che corrisponde all'n-esima sottoespressione tra parentesi. La sequenza
\0 rappresenta il testo ricoperto dall'intera espressione, e così pure il
carattere &. A differenza di sub() e gsub(), la stringa modificata è data
come risulatato della funzione; l'originale resta inalterata.
- gsub(r, s
[, t ])
- per ogni sottostringa conforme alla regular expression r nella
stringa t, sostituisce la stringa s, e restituisce il numero di sostituzioni.
Se t non è specificata, usa $0. Una & nel testo di rimpiazzo è sostituita
dal testo trovato conforme con la regular expression. Si usi \& per indicare
il carattere & inteso letteralmente. Si veda AWK Language Programming per
una più ampia discussione circa le regole che riguardano & e i "backslash"
nel testo di rimpiazzo di sub(), gsub(), e gensub().
- index(s, t)
- trova
l'indice posizionale della stringa t nella stringa s, o 0 se t non è presente.
- length( [s ])
- la lunghezza della stringa s, oppure la lunghezza di $0
se s non è specificata.
- match(s, r)
- trova la posizione in s del tratto
che si conforma alla regular expression r, oppure 0 se non ci sono conformtà.
I valori di RSTART ed RLENGTH sono modificati di conseguenza.
- split(s,
a [, r ])
- spezza la stringa s nel vettore a utilizzando il metodo di
separazione descritto dalla regular expression r, e restituisce il numero
di campi. Se r è omessa, il separatore utilizzato è FS. Il precedente contenuto
del vettore a è cancellato. La divisione di una stringa in parti e l'isolamento
dei campi nei record, descritto prima, sono compiuti esattamente allo
stesso modo.
- sprintf(fmt, expr-list)
- stampa (in modo fittizio) expr-list
secondo il formato fmt, e restituisce la stringa risultante.
- sub(r, s
[, t ])
- come gsub(), ma è sostituita solo la prima sottostringa trovata.
- substr(s, i [, n ])
- restituisce la sottostringa di s di n caratteri
alpiù che inizia nella posizione i. Se n è omesso, è usato il resto di
s.
- tolower(str)
- restituisce una copia della stringa str, con tutti i caratteri
maiuscoli tradotti nei minuscoli corrispondenti. I caratteri non alfabetici
restano invariati.
- toupper(str)
- restituisce una copia della stringa str,
con tutti i caratteri minuscoli tradotti nei maiuscoli corrispondenti.
I caratteri non alfabetici restano invariati.
Poiché
uno dei principali campi di applicazione dei programmi AWK è l'elaborazione
di file di traccia ("log files") contenenti informazioni di tipo marcatempo
("time stamp"), gawk mette a disposizione le seguenti due funzioni per
ottenere marcatori di tempo e per manipolarli.
- systime()
- restituisce la
data e l'ora correnti, espresse come numero di secondi trascorsi da una
certa data convenzionale (Mezzanotte del 1/1/1970 sui sistemi ).
- strftime(
[format [, timestamp ]])
- Applica il formato format a timestamp. timestamp
dovrebbe essere nella forma utilizzata da systime(). Se timestamp è omesso,
sono utilizzate la data e l'ora correnti. Se format è omesso, è assunto
un formato equivalente a quello utilizzato dal comando date(1)
. Per sapere
quali formati di conversione siano disponibili, si faccia riferimento
alle specifiche della funzione strftime() del C . Una versione di pubblico
dominio di strftime(3)
e le relative pagine di manuale sono distribuite
con gawk; se gawk è stato compilato utilizzando tale versione di strftime,
potrà eseguire tutte le conversioni descritte nel manuale associato.
Le costanti di tipo stringa in AWK sono sequenze di caratteri
chiuse tra doppi apici (" ). All'interno delle stringhe, sono riconosciute
certe sequenze di escape (escape sequences), come nel linguaggio C :
- \\
- Un carattere "\" singolo.
- \a
- Il carattere "alert"; di solito si tratta
del carattere ASCII
BEL
(^G).
- \b
- backspace : ASCII
BS
(^H).
- \f
- form-feed :
ASCII
FF
(^L).
- \n
- newline (^J).
- \r
- carriage return (^M).
- \t
- horizontal tab (^I).
- \v
- vertical tab (^V).
- \xhex digits
- Il carattere rappresentato dalla stringa
di cifre esadecimali che segue \x. Come nel C , tutte le cifre esadecimali
seguenti sono considerate parte della sequenza (questa prestazione la
dice lunga su come il comitato abbia redatto le specifiche del linguaggio).
Per esempio, "\x1B" è il carattere ASCII
ESC
(escape).
- \ddd
- Il carattere
rappresentato dalla sequenza di una, due o tre cifre ottali. Esempio: "\033"
è il carattere ASCII
ESC
(escape).
- \c
- Il carattere c , così com'è.
Le sequenze
di escape possono anche essere utilizzate all'interno di regular expression
(per esempio, /[ \t\f\n\r\v]/ descrive i caratteri di spaziatura).
In modalità
compatibile i caratteri rappresentati da sequenze ottali ed esadecimali
sono trattati letteralmente quando usati in costanti contenenti regular
expression. Così, /a\52b/ equivale a /a\*b/.
Le funzioni in AWK
sono definite in questo modo:
function nome(lista-di-parametri) { istruzioni
}
Le funzioni sono eseguite in seguito a chiamate dall'interno di espressioni,
che possono comparire sia all'interno di pattern, sia all'interno di azioni.
I parametri attuali dati al momento della chiamata istanziano i parametri
formali dichiarati nella funzione. I vettori sono passati per riferimento,
le altre variabili per valore.
Poiché le funzioni non erano in origine
previste nel linguaggio AWK, la gestione delle variabili locali è piuttosto
goffa: sono dichiarate semplicemente come parametri in più nella lista
dei parametri formali. Per convenzione, si usa separare le variabili locali
dai veri parametri con qualche spazio in più nella lista. Per esempio:
function f(p, q, a, b) # "a" e "b" sono locali
{
.....
}
/abc/
{ ... ; f(1, 2) ; ... }
La parentesi di sinistra di una chiamata deve seguire
immediatamente il nome della funzione, senza spazi in mezzo; questo per
evitare l'ambiguità sintattica con l'operatore di concatenazione. Questa
restrizione non si applica alle funzioni predefinite elencate prima.
Le
funzioni possono chiamare a loro volta altre funzioni, e possono essere
ricorsive. I parametri utilizzati come variabili locali sono inizializzati
alla stringa nulla ed al numero zero al momento dell'invocazione.
Se è stata
data l'opzione --lint, gawk avvertirà in caso di chiamate a funzioni indefinite
al momento della valutazione sintattica del programma anziché durante
l'esecuzione. La chiamata di una funzione indefinita in fase di esecuzione
è un errore fatale.
Si può usare la parola func al posto di function.
Stampa ed ordina i nomi di login di tutti gli utenti:
BEGIN { FS =
":" }
{ print $1 | "sort" }
Conta le righe di un file:
{ nlines++
}
END { print nlines }
Aggiunge il numero di linea alle righe di
un file:
{ print FNR, $0 }
Variazione sul tema:
{ print NR, $0 }
egrep(1)
, getpid(2)
, getppid(2)
, getpgrp(2)
, getuid(2)
,
geteuid(2)
, getgid(2)
, getegid(2)
, getgroups(2)
The AWK Programming Language,
Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 1988.
ISBN 0-201-07981-X.
AWK Language Programming, Edition 1.0, pubblicata da Free
Software Foundation, 1995.
Un obiettivo di primaria
importanza per gawk è la compatibilità con lo standard , così come con
la più recente versione di awk per . A tal fine, gawk incorpora le seguenti
prestazioni non descritte nel manuale del linguaggio, ma facenti parte
della versione dei Bell Labs di awk, e previste dallo standard .
L'opzione
-v per l'assegnamento di variabili prima dell'esecuzione del programma è
una novità. Secondo il libro, l'assegnamento di variabili da linea di comando
ha luogo nel momento in cui awk utilizza l'argomento come eventuale nome
di file da aprire in lettura, la qual cosa avviene dopo che sono stati
eseguiti tutti i blocchi BEGIN. Tuttavia, nelle versioni più recenti, gli
assegnamenti avvengono prima dell'esecuzione di BEGIN, a patto che precedano
tutti i nomi di file nella linea di comando. Le applicazioni hanno finito
col dipendere da questa "prestazione". Quando awk fu modificato per allinearlo
con la sua documentazione, fu aggiunta quest'opzione per venire incontro
alle applicazioni che confidavano nel vecchio comportamento. (Questa funzionalità
è stata accolta sia dagli sviluppatori di AT&T, sia da quelli di GNU.)
L'opzione
-W per l'attivazione di prestazioni specifiche della versione proviene dallo
standard .
Nell'esame degli argomenti, gawk interpreta l'opzione speciale
"-- " come marcatore della fine della lista. In modalità compatibile segnala,
ma per il resto ignora, le opzioni indefinite. Nella modalità ordinaria,
tali argomenti sono passati al programma AWK perché possa elaborarli.
Il
manuale di AWK non definisce il valore di ritorno di srand(). Lo standard
prevede che la funzione restituisca il seme corrente, per poter controllare
la sequenza di generazione dei numeri casuali. Perciò, anche srand() di
gawk restituisce il seme corrente.
Nuove prestazioni sono anche le seguenti:
l'uso di più di un'opzione -f (da MKS awk); il vettore ENVIRON; le escape
sequence \a, e \v (originali di gawk ma aggiunte in seguito anche da AT&T);
le funzioni predefinite tolower() e toupper() (da AT&T); e le specifiche
di conversione del C per printf (da AT&T).
Gawk aggiunge
alcune estensioni a awk, descritte in questa sezione. Tutte le estensioni
qui documentate possono essere disabilitate con l'opzione --traditional.
Le
seguenti funzionalità di gawk non sono disponibili in awk.
·- L'escape sequence
\x. (Disabilitata con --posix.)
·- La funzione fllush(). (Disabilitata con --posix.)
·- Le funzioni systime(), strftime() e gensub().
·- I nomi di file speciali per
la redirezione dell'I/O.
·- Le variabili ARGIND, ERRNO ed RT.
·- La variabile IGNORECASE,
con i suoi effetti collaterali.
·- La variabile FIELDWIDTHS e la possibilità
di isolare campi di lunghezza fissa.
·- L'uso di RS come regular expression.
·- La possibilità di isolare i singoli caratteri assegnando la strimga vuota
ad FS ed al terzo argomento di split().
·- La ricerca tramite percorso predefinito
per i file indicati con l'opzione -f, e la variabile AWKPATH.
·- Il costrutto
nextfile per abbandonare l'elaborazione del file corrente.
·- Il costrutto
delete array per cancellare l'intero contenuto di un vettore.
Il manuale
di AWK non definisce il valore di ritorno di close(). Per Gawk, close()
restituisce il valore di fclose(3)
, per la chiusura di file ordinari,
o pclose(3)
, per la chiusura di pipe.
Quando gawk è lanciato con l'opzione
--traditional, e l'argomento fs dell'opzione -F è "t", ad FS è assegnato il
carattere "tab". Si noti che se si digita gawk -F\t ... si ottiene solo di forzare
la shell a considerare "t" alla lettera, e non di passare "\t" all'opzione
-F. Poiché si tratta di un caso particolare abbastanza brutto, questo comportamento
non ha luogo nella modalità ordinaria, e neppure quando si specifichi
--posix. Il modo migliore per definire davvero un carattere "tab" come separatore
di campo è usare gli apici: gawk -F'\t' ....
Gawk supporta
due prestazioni caratteristiche delle prime realizzazioni di AWK. La prima
è la possibilità di chiamare la funzione predefinita length() non solo
senza argomenti, ma anche senza parentesi ! Così
a = length # Il sacro
Algol 60, Batman!
equivale a
a = length()
a = length($0)
Questa prestazione
è segnalata come "deprecabile" nello standard , e gawk emette un messaggio
di avvertimento riguardo il suo uso se è specificata l'opzione --lint.
La
seconda prestazione "storica" è l'uso delle istruzioni continue e break
fuori dal corpo di cicli while, for, o do. Le versioni tradizionali di
AWK consideravano tali costrutti equivalenti all'istruzione next. Gawk permette
questa sintassi se è specificato --traditional.
Se esiste
la variabile d'ambiente POSIXLY_CORRECT, gawk si comporterà esattamente
come se fosse stato specificato --posix nella linea di comando. Se è specificato
--lint, gawk emetterà un messaggio di avvertimento consono.
Si può utilizzare
la variabile di ambiente AWKPATH per indicare una lista di directory dove
gawk cercherà i file indicati dalle opzioni -f e --file.
L'opzione -F
non è necessaria, dato che è possibile l'assegnamento a variabili qualsiasi
da linea di comando; rimane solo per compatibilità all'indietro.
Se il sistema
operativo fornisce un supporto per /dev/fd ed i file associati /dev/stdin,
/dev/stdout, e /dev/stderr, gawk può produrre dati in uscita diversi da
quelli che si avrebbero su sistemi privi di tale supporto. Quando gawk
interpreta quei file internamente, sincronizza la scrittura sullo standard
output con la scrittura su /dev/stdout, mentre su di un sistema che riconosca
quei file, la scrittura è attualmente diretta verso file descriptor diversi.
"Caveat emptor".
I programmi contenenti singoli caratteri sintatticamente
errati tendono a riempire lo stack dell'analizzatore grammaticale, generando
un messaggio di scarsa utilità. Programmi di questo genere sono sorprendentemente
difficili da diagnosticare nel caso generale, e lo sforzo per farlo non
vale davvero il risultato.
Questo manuale
documenta gawk, versione 3.02.
La versione originale di awk per
è stata progettata e realizzata da Alfred Aho, Peter Weinberger, e Brian
Kernighan degli AT&T Bell Labs. Brian Kernighan ne continua la manutenzione
ed il miglioramento.
Paul Rubin e Jay Fenlason, della Free Software Foundation,
hanno scritto gawk facendo riferimeto per compatibilità alla versione
originale di awk distribuita con Seventh Edition . John Woods ha contribuito
correggendo un buon numero di errori. David Trueman, col contributo di
Arnold Robbins, ha reso gawk compatibile con la nuova versione di awk.
Arnold Robbins è l'attuale manutentore.
Il trasporto su DOS è stato fatto
inizialmente da Conrad Kwok e Scott Garfinkle. Scott Deifik è l'attuale
responsabile della versione per DOS. Pat Rankin ha curato il trasporto
su VMS, e Michal Jaegermann quello su Atari ST. Il trasporto su OS/2 è
stato realizzato da Kai Uwe Rommel, con l'aiuto di Darrel Hankerson. Fred
Fish ha prodotto la versione per Amiga.
Documentazione tradotta da Giuseppe
Guerrini (giusguerrini@racine.ra.it ).
Chi trovasse
bachi in gawk, può segnalarli per posta elettronica a bug-gnu-util@prep.ai.mit.edu,
con "carbon copy" a arnold@gnu.ai.mit.edu. Si prega di specificare il tipo
e la versione del proprio sistema operativo, la versione di gawk, il compilatore
utilizzato per compilarlo, ed un programma di prova completo di dati,
il più corto possibile, che evidenzi il problema.
Prima di inviare una
segnalazione di baco, bisogna fare due cose. Innanzi tutto, verificare
se si sta usando la versione più recente di gawk: ogni nuova distribuzione
corregge molti bachi, in genere i più subdoli; se quella in uso non è
aggiornata, è probabile che il problema sia già stato risolto. La seconda
cosa da fare è leggere attentamente queste pagine ed il manuale di riferimento,
per essere sicuri che ciò che si pensa un errore non sia piuttosto un
cavillo del linguaggio.
Si prega di NON inviare segnalazioni di bachi a
comp.lang.awk. Benché gli sviluppatori di gawk frequentino occasionalmente
questo newsgroup, inviare lì le segnalazioni di bachi non è affidabile.
Invitiamo invece tutti ad utilizzare gli indirizzi di posta elettronica
dati sopra.
Ringraziamo Brian Kernighan dei Bell Labs,
che ha dato consideravole assistenza durante le fasi di test e debug.
NOTA DEL TRADUTTORE:
Il testo seguente è lasciato nella sua forma originale perché manca l'approvazione
ufficiale della sua traduzione da parte di Free Software Foundation. In
coda all'originale abbiamo aggiunto una versione in italiano, che però
è da considerare informale e legalmente non valida. Il solo testo la cui
presenza renda ridistribuibile il documento, e la cui assenza configuri
una violazione della licenza, è quello in lingua inglese.
Copyright © 1996
Free Software Foundation, Inc.
Permission is granted to make and distribute
verbatim copies of this manual page provided the copyright notice and
this permission notice are preserved on all copies.
Permission is granted
to copy and distribute modified versions of this manual page under the
conditions for verbatim copying, provided that the entire resulting derived
work is distributed under the terms of a permission notice identical to
this one.
Permission is granted to copy and distribute translations of
this manual page into another language, under the above conditions for
modified versions, except that this permission notice may be stated in
a translation approved by the Foundation.
Copyright © 1996 Free Software Foundation, Inc. Proprietà
letteraria della Free Software Foundation, 1996.
È permesso stampare e
distribure copie letterali di questa pagina del manuale, a patto che la
nota di proprietà letteraria e questa parte sui permessi di ristampa siano
preservate in tutte le copie.
È permesso copiare e distribuire versioni
modificate di questa pagina del manuale, sotto le condizioni poste per
la copia letterale, a patto che l'intero lavoro derivato sia distribuito
secondo permessi di ristampa identici a questi.
È permesso copiare e distribuire
traduzioni di questa pagina del manuale in un'altra lingua, sotto le condizioni
poste sopra per le versioni modificate, salvo che quest'informazione sui
permessi di copia e ristampa deve essere espressa in una traduzione approvata
dalla Free Software Foundation.
Table of Contents
