GAWK(1)

NOME
gawk - linguaggio di ricerca ed elaborazione di configurazioni di testo (o "pattern", come diremo d'ora in poi).

SINTASSI
gawk [ opzioni in stile POSIX o GNU ] -f file-di-programma [ -- ] file ...
gawk [ opzioni in stile POSIX o GNU ] [ -- ] testo-del-programma file ...

DESCRIZIONE
Gawk è la realizzazione dell'interprete del linguaggio AWK dello GNU Project. È conforme alla definizione del linguaggio prevista dallo standard "POSIX 1003.2 Command Language And Utilities". In particolare, questa versione è basata sulla descrizione contenuta in The AWK Programming Language, di Aho, Kernighan e Weinberger, con le prestazioni aggiuntive che si trovano nella versione di awk di UNIX System V Release 4. Gawk mette a disposizione inoltre le estensioni del più recente awk dei Bell Labs ed alcune funzionalità specifiche di GNU.

La linea di comando consiste in opzioni di gawk stesso, il testo del programma AWK (a meno che non sia contenuto in un file indicato con l'opzione -f o --file), e valori che saranno resi disponibili al programma nelle variabili predefinite ARGC e ARGV.

FORMATO DELLE OPZIONI

Le opzioni di Gawk possono essere sia nella tradizionale forma a una lettera di POSIX, sia nella forma estesa tipica di GNU. Le opzioni POSIX cominciano con un "-" singolo, quelle in forma lunga cominciano con "--". Sono disponibili opzioni in forma lunga sia per le prestazioni specifiche di GNU, sia per quelle previste da POSIX.

Conformemente allo standard POSIX, le opzioni specifiche di gawk sono indicate come argomenti dell'opzione -W. Si possono indicare più opzioni -W. Ogni opzione -W ha un equivalente in forma lunga, come è spiegato più avanti. Gli argomenti delle opzioni in forma lunga possono essere uniti ad esse da un =, senza spazi, oppure sono indicati nel successivo campo della linea di comando.

Gawk riconosce le seguenti opzioni.

-F fs
--field-separator fs
    Usa fs come separatore dei campi in ingresso ("input field separator"). È il valore della variabile predefinita FS.

-v var=val
--assign var=val
    Assegna il valore val alla variabile var prima di iniziare l'esecuzione del programma. I valori dati in questo modo alle variabili sono quindi disponibili già nel blocco BEGIN dei programmi AWK.

-f file-di-programma
--file file-di-programma
    Legge il programma AWK dal file file-di-programma anziché dal primo argomento della linea di comando. Si possono dare più opzioni -f (o --file).

-mf NNN
-mr NNN
    Fissa al valore NNN certi limiti di memoria. f decide il massimo numero di campi, ed r la massima dimensione di una linea (o, più propriamente, di un record). Questi due indicatori ("flag"), e l'opzione -m, sono ereditati della versione di awk per UNIX dei Bell Labs. gawk li ignora, dato che non ha limiti predefiniti.
-W traditional
-W compat
--traditional
--compat
    Con quest'opzione gawk funziona in modo compatibile ("compatibility mode"), cioè si comporta esattamente come UNIX awk. Non sarà riconosciuta alcuna estensione specifica di GNU. La forma --traditional è preferibile alle altre. Per ulteriori informazioni, si consulti il paragrafo ESTENSIONI GNU.

-W copyleft
-W copyright
--copyleft
--copyright
    Scrive su "standard output" la versione concisa del messaggio di copyright di GNU e termina con successo.

-W help
-W usage
--help
--usage
    Scrive su "standard output" un sommario relativamente breve delle opzioni disponibili. In linea con le convenzioni di codifica GNU, ("GNU Coding Standards"), queste opzioni provocano un'uscita immediata e senza segnalazione di errore.

-W lint
--lint
    Sono prodotti messaggi d'avvertimento ("warning") relativi a costrutti dubbi o non trasportabili su altre versioni di AWK.

-W lint-old
--lint-old
    Sono prodotti messaggi d'avvertimento ("warning") relativi a costrutti non trasportabili sulla versione originale di awk per Unix.

-W posix
--posix
    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 UNIX.

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.

ESECUZIONE DEL PROGRAMMA AWK

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.

VARIABILI, RECORD E CAMPI
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.

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

  Campi

Ogni volta che gawk legge un record lo spezza in campi, usando il valore della variabile FS come separatore di campo. Se FS è un 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.

  Variabili predefinite

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

  Vettori

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.

  Tipi Di Variabili E Conversioni

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

PATTERN ED AZIONI
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.

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

  Regular Expressions ("Espressioni Formali")
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.

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

  Operatori

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

  Istruzioni di controllo

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 }

  Istruzioni di I/O

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

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.

  L'istruzione printf

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.

0   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'ANSI C. Un * al posto di ampiezza o prec farà sì che i loro valori siano presi dalla lista degli argomenti di printf o sprintf().

  Nomi di file speciali

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.

  Funzioni Numeriche

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.

  Funzioni su Stringhe

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.

  Funzioni di Tempo

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 (la mezzanotte del 1/1/1970 sui sistemi POSIX).

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

  Constanti di tipo Stringa

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 ANSI, 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/.

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

ESEMPI
Stampa ed ordina i nomi di login di tutti gli utenti:
	BEGIN   { FS = ":" }
		{ print $1 | "sort" }
Conta le righe di un file:
		{ nlines++ }
	END     { print nlines }
Aggiunge il numero di linea alle righe di un file:
	{ print FNR, $0 }
Variazione sul tema:
	{ print NR, $0 }

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

COMPATIBILITÀ POSIX
Un obiettivo di primaria importanza per gawk è la compatibilità con lo standard POSIX, così come con la più recente versione di awk per UNIX. 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 POSIX.

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

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 POSIX 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 ANSI per printf (da AT&T).

ESTENSIONI GNU
Gawk aggiunge alcune estensioni a POSIX 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 POSIX 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' ....

PRESTAZIONI STORICHE
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 POSIX, 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.

VARIABILI D'AMBIENTE
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.

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

INFORMAZIONI SULLA VERSIONE
Questo manuale documenta gawk, versione 3.02.

AUTORI
La versione originale di awk per UNIX è 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 UNIX. 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 UNIX 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).

SEGNALAZIONE DEI BACHI
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.

RINGRAZIAMENTI
Ringraziamo Brian Kernighan dei Bell Labs, che ha dato consideravole assistenza durante le fasi di test e debug.

COPYING PERMISSIONS (PERMESSI DI COPIA/RISTAMPA)

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.

PERMESSI DI COPIA/RISTAMPA [Traduzione non ufficiale, N.d.T.]
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.