| Voce dell’indice | | Sezione |
|---|
|
| ! | | |
|---|
| ! (punto esclamativo), operatore !~: | | Uso di regexp |
| ! (punto esclamativo), operatore !~: | | Espressioni regolari calcolate |
| ! (punto esclamativo), operatore !~: | | Maiuscolo-Minuscolo |
| ! (punto esclamativo), operatore !~: | | Costanti come espressioni regolari |
| ! (punto esclamativo), operatore !=: | | Operatori di confronto |
| ! (punto esclamativo), operatore !~: | | Operatori di confronto |
| ! (punto esclamativo), operatore !~: | | Operatori di confronto |
| ! (punto esclamativo), operatore !: | | Operatori booleani |
| ! (punto esclamativo), operatore !: | | Precedenza |
| ! (punto esclamativo), operatore !=: | | Precedenza |
| ! (punto esclamativo), operatore !~: | | Precedenza |
| ! (punto esclamativo), operatore !~: | | Espressioni come criteri di ricerca |
| ! (punto esclamativo), operatore !: | | Intervalli |
| ! (punto esclamativo), operatore !: | | Programma egrep |
|
| " | | |
|---|
| " (doppio apice), nei comandi shell: | | Protezione |
| " (doppio apice), in costanti regexp: | | Espressioni regolari calcolate |
|
| # | | |
|---|
| # (cancelletto), #! (script eseguibili): | | Script eseguibili |
| # (cancelletto), commentare: | | Commenti |
|
| $ | | |
|---|
| $ (dollaro), operatore regexp: | | Dettagli sugli operatori di regexp |
| $ (dollaro), operatore di campo $: | | Campi |
| $ (dollaro), incrementare campi e vettori: | | Operatori di incremento |
| $ (dollaro), operatore di campo $: | | Precedenza |
|
| % | | |
|---|
| % (percento), operatore %=: | | Operatori di assegnamento |
| % (percento), operatore %: | | Precedenza |
| % (percento), operatore %=: | | Precedenza |
|
| & | | |
|---|
| & (e commerciale), operatore &&: | | Operatori booleani |
| & (e commerciale), operatore &&: | | Precedenza |
| & (e commerciale), funzioni gsub()/gensub()/sub() e: | | Dettagli ostici |
|
| ' | | |
|---|
| ' (apice singolo): | | Monouso |
| ' (apice singolo), nella riga di comando di gawk: | | Lunghi |
| ' (apice singolo), vs. apostrofo: | | Commenti |
| ' (apice singolo), nei comandi di shell: | | Protezione |
| ' (apice singolo), con doppio apice: | | Protezione |
|
| ( | | |
|---|
| () (parentesi), operatore regexp: | | Dettagli sugli operatori di regexp |
| () (parentesi), in un profilo: | | Profilare |
|
| * | | |
|---|
| * (asterisco), operatore *, come operatore regexp: | | Dettagli sugli operatori di regexp |
| * (asterisco), operatore **: | | Operatori aritmetici |
| * (asterisco), operatore *=: | | Operatori di assegnamento |
| * (asterisco), operatore **=: | | Operatori di assegnamento |
| * (asterisco), operatore **: | | Precedenza |
| * (asterisco), operatore *, come operatore di moltiplicazione: | | Precedenza |
| * (asterisco), operatore *=: | | Precedenza |
| * (asterisco), operatore **=: | | Precedenza |
| * (asterisco), operatore *, individuare la stringa nulla: | | Funzioni per stringhe |
|
| + | | |
|---|
| + (più), operatore regexp: | | Dettagli sugli operatori di regexp |
| + (più), operatore +=: | | Operatori di assegnamento |
| + (più), operatore ++: | | Operatori di incremento |
| + (più), operatore ++: | | Operatori di incremento |
| + (più), operatore ++: | | Precedenza |
| + (più), operatore +: | | Precedenza |
| + (più), operatore +: | | Precedenza |
| + (più), operatore +=: | | Precedenza |
|
| , | | |
|---|
| , (virgola), negli intervalli di ricerca: | | Intervalli |
|
| - | | |
|---|
| - (meno), nomi di file che iniziano con: | | Opzioni |
| - (meno), -- marcatore della fine delle opzioni: | | Opzioni |
| - (meno), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| - (meno), operatore -=: | | Operatori di assegnamento |
| - (meno), operatore --: | | Operatori di incremento |
| - (meno), operatore --: | | Precedenza |
| - (meno), operatore -: | | Precedenza |
| - (meno), operatore -: | | Precedenza |
| - (meno), operatore -=: | | Precedenza |
| --assign (opzione): | | Opzioni |
| --bignum (opzione): | | Opzioni |
| --characters-as-bytes (opzione): | | Opzioni |
| --copyright (opzione): | | Opzioni |
| --debug (opzione): | | Opzioni |
| --disable-extensions (opzione di configurazione): | | Ulteriori opzioni di configurazione |
| --disable-lint (opzione di configurazione): | | Ulteriori opzioni di configurazione |
| --disable-mpfr (opzione di configurazione): | | Ulteriori opzioni di configurazione |
| --disable-nls (opzione di configurazione): | | Ulteriori opzioni di configurazione |
| --dump-variables (opzione): | | Opzioni |
| --dump-variables (opzione), uso per funzioni di libreria: | | Nomi di variabili di libreria |
| --enable-versioned-extension-dir (opzione di configurazione): | | Ulteriori opzioni di configurazione |
| --exec (opzione): | | Opzioni |
| --field-separator (opzione): | | Opzioni |
| --file (opzione): | | Opzioni |
| --gen-pot (opzione): | | Opzioni |
| --gen-pot (opzione): | | Estrazione di stringhe |
| --gen-pot (opzione): | | Estrazione di stringhe |
| --help (opzione): | | Opzioni |
| --include (opzione): | | Opzioni |
| --lint (opzione): | | Riga di comando |
| --lint (opzione): | | Opzioni |
| --lint-old (opzione): | | Opzioni |
| --load (opzione): | | Opzioni |
| --no-optimize (opzione): | | Opzioni |
| --non-decimal-data (opzione): | | Opzioni |
| --non-decimal-data (opzione): | | Dati non decimali |
| --non-decimal-data (opzione), funzione strtonum() e: | | Dati non decimali |
| --optimize (opzione): | | Opzioni |
| --posix (opzione): | | Opzioni |
| --posix (opzione), e opzione --traditional: | | Opzioni |
| --pretty-print (opzione): | | Opzioni |
| --profile (opzione): | | Opzioni |
| --profile (opzione): | | Profilare |
| --re-interval (opzione): | | Opzioni |
| --sandbox (opzione): | | Opzioni |
| --sandbox (opzione), ridirezione dell’input con getline: | | Getline |
| --sandbox (opzione), ridirezione dell’output con print, printf: | | Ridirezione |
| --sandbox (opzione), disabilitare la funzione system(): | | Funzioni di I/O |
| --source (opzione): | | Opzioni |
| --traditional (opzione): | | Opzioni |
| --traditional (opzione), e opzione --posix: | | Opzioni |
| --use-lc-numeric (opzione): | | Opzioni |
| --version (opzione): | | Opzioni |
| -b (opzione): | | Opzioni |
| -c (opzione): | | Opzioni |
| -C (opzione): | | Opzioni |
| -d (opzione): | | Opzioni |
| -D (opzione): | | Opzioni |
| -e (opzione): | | Opzioni |
| -E (opzione): | | Opzioni |
| -e (opzione): | | Opzioni |
| -f (opzione): | | Lunghi |
| -F (opzione): | | Opzioni |
| -f (opzione): | | Opzioni |
| -F (opzione), -Ft imposta FS a TAB: | | Opzioni |
| -f (opzione), usi multipli: | | Opzioni |
| -F (opzione) sulla riga di comando: | | Separatori campo da riga di comando |
| -g (opzione): | | Opzioni |
| -h (opzione): | | Opzioni |
| -i (opzione): | | Opzioni |
| -l (opzione): | | Opzioni |
| -L (opzione): | | Opzioni |
| -M (opzione): | | Opzioni |
| -n (opzione): | | Opzioni |
| -N (opzione): | | Opzioni |
| -o (opzione): | | Opzioni |
| -O (opzione): | | Opzioni |
| -p (opzione): | | Opzioni |
| -P (opzione): | | Opzioni |
| -r (opzione): | | Opzioni |
| -s (opzione): | | Opzioni |
| -S (opzione): | | Opzioni |
| -t (opzione): | | Opzioni |
| -v (opzione): | | Opzioni |
| -V (opzione): | | Opzioni |
| -v (opzione): | | Opzioni di assegnamento |
| -W (opzione): | | Opzioni |
|
| . | | |
|---|
| . (punto), operatore regexp: | | Dettagli sugli operatori di regexp |
| .gmo (file): | | Utilizzare gettext |
| .gmo (file), specificare la directory di: | | Utilizzare gettext |
| .gmo (file), specificare la directory di: | | I18N per programmatore |
| .mo (file), conversione da .po: | | Esempio I18N |
| .po (file): | | Utilizzare gettext |
| .po (file): | | I18N per traduttore |
| .po (file), conversione in .mo: | | Esempio I18N |
| .pot (file): | | Utilizzare gettext |
|
| / | | |
|---|
| / (barra), per delimitare le espressioni regolari: | | Espressioni regolari |
| / (barra), operatore /=: | | Operatori di assegnamento |
| / (barra), operatore /=, vs. costante regexp /=…/: | | Operatori di assegnamento |
| / (barra), operatore /: | | Precedenza |
| / (barra), operatore /=: | | Precedenza |
| / (barra), criteri di ricerca e: | | Espressioni come criteri di ricerca |
| /dev/…, file speciali: | | FD speciali |
| /dev/fd/N, file speciali (in gawk): | | FD speciali |
| /inet/…, file speciali (in gawk): | | Reti TCP/IP |
| /inet4/…, file speciali (in gawk): | | Reti TCP/IP |
| /inet6/…, file speciali (in gawk): | | Reti TCP/IP |
|
| : | | |
|---|
| : (due punti), operatore ?:: | | Precedenza |
| : (due punti), ::, separatore spazio-dei-nomi: | | Nomi qualificati |
|
| ; | | |
|---|
| ; (punto e virgola), separare istruzioni nelle azioni: | | Istruzioni/Righe |
| ; (punto e virgola), separare regole: | | Istruzioni/Righe |
| ; (punto e virgola), separare istruzioni nelle azioni: | | Panoramica sulle azioni |
| ; (punto e virgola), separare istruzioni nelle azioni: | | Istruzioni |
| ; (punto e virgola), AWKPATH variabile e: | | Uso su PC |
|
| < | | |
|---|
| < (parentesi acuta sinistra), operatore < (I/O): | | Getline file |
| < (parentesi acuta sinistra), operatore <: | | Operatori di confronto |
| < (parentesi acuta sinistra), operatore <=: | | Operatori di confronto |
| < (parentesi acuta sinistra), operatore <: | | Precedenza |
| < (parentesi acuta sinistra), operatore <=: | | Precedenza |
|
| = | | |
|---|
| = (uguale), operatore =: | | Operatori di assegnamento |
| = (uguale), operatore ==: | | Operatori di confronto |
| = (uguale), operatore ==: | | Precedenza |
|
| > | | |
|---|
| > (parentesi acuta destra), operatore > (I/O): | | Ridirezione |
| > (parentesi acuta destra), operatore >> (I/O): | | Ridirezione |
| > (parentesi acuta destra), operatore >=: | | Operatori di confronto |
| > (parentesi acuta destra), operatore >: | | Operatori di confronto |
| > (parentesi acuta destra), operatore >=: | | Precedenza |
| > (parentesi acuta destra), operatore >: | | Precedenza |
| > (parentesi acuta destra), operatore >> (I/O): | | Precedenza |
|
| ? | | |
|---|
| ? (punto interrogativo), operatore regexp: | | Dettagli sugli operatori di regexp |
| ? (punto interrogativo), operatore regexp: | | Operatori di regexp GNU |
| ? (punto interrogativo), operatore ?:: | | Precedenza |
|
| @ | | |
|---|
| @ (chiocciola), @include (direttiva): | | Includere file |
| @ (chiocciola), @load (direttiva): | | Caricare librerie condivise |
| @ (chiocciola), @-notazione per la chiamata indiretta di funzioni: | | Chiamate indirette |
| @ (chiocciola), @namespace (direttiva): | | Cambiare lo spazio-dei-nomi |
| @ (chiocciola), @namespace (direttiva): | | Cambiare lo spazio-dei-nomi |
| @ (chiocciola), @namespace (direttiva), non riguarda BEGIN, BEGINFILE, END, ed ENDFILE: | | Cambiare lo spazio-dei-nomi |
| @ (chiocciola), @namespace (direttiva): | | Cambiare lo spazio-dei-nomi |
|
| [ | | |
|---|
| [] (parentesi quadre), operatore regexp: | | Dettagli sugli operatori di regexp |
|
| \ | | |
|---|
| \ (barra inversa): | | Commenti |
| \ (barra inversa), nei comandi di shell: | | Protezione |
| \ (barra inversa), continuazione di riga e: | | Istruzioni/Righe |
| \ (barra inversa), continuazione di riga e, in csh: | | Istruzioni/Righe |
| \ (barra inversa), continuazione di riga e, commenti: | | Istruzioni/Righe |
| \ (barra inversa), in sequenze di protezione: | | Sequenze di protezione |
| \ (barra inversa), \a (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \b (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \f (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \n (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \r (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \t (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \v (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \nnn (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \x (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \/ (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), \" (sequenza di protezione): | | Sequenze di protezione |
| \ (barra inversa), in sequenze di protezione: | | Sequenze di protezione |
| \ (barra inversa), in sequenze di protezione, POSIX e: | | Sequenze di protezione |
| \ (barra inversa), operatore regexp: | | Dettagli sugli operatori di regexp |
| \ (barra inversa), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| \ (barra inversa), in costanti regexp: | | Espressioni regolari calcolate |
| \ (barra inversa), \s (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \S (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \w (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \W (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \< (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \> (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \y (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \B (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \` (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), \' (operatore gawk): | | Operatori di regexp GNU |
| \ (barra inversa), come separatore di campo: | | Separatori campo da riga di comando |
| \ (barra inversa), gsub()/gensub()/sub() funzioni e: | | Dettagli ostici |
|
| ^ | | |
|---|
| ^ (circonflesso), operatore regexp: | | Dettagli sugli operatori di regexp |
| ^ (circonflesso), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| ^ (circonflesso), operatore regexp: | | Operatori di regexp GNU |
| ^ (circonflesso), in FS: | | Separare campi con regexp |
| ^ (circonflesso), operatore ^=: | | Operatori di assegnamento |
| ^ (circonflesso), operatore ^: | | Precedenza |
| ^ (circonflesso), operatore ^=: | | Precedenza |
|
| _ | | |
|---|
| _ (trattino basso), nei nomi di variabili private: | | Nomi di variabili di libreria |
| _ (trattino basso), macro C: | | Utilizzare gettext |
| _ (trattino basso), stringa traducibile: | | I18N per programmatore |
| _gr_init(), funzione definita dall’utente: | | Funzioni Group |
| _ord_init(), funzione definita dall’utente: | | Funzioni ordinali |
| _pw_init(), funzione definita dall’utente: | | Funzioni Passwd |
|
| { | | |
|---|
| {} (parentesi graffe), operatore regexp: | | Dettagli sugli operatori di regexp |
| {} (parentesi graffe), azioni e: | | Panoramica sulle azioni |
| {} (parentesi graffe), istruzioni, raggruppare: | | Istruzioni |
| {} (parentesi graffe): | | Profilare |
|
| | | | |
|---|
| | (barra verticale): | | Dettagli sugli operatori di regexp |
| | (barra verticale), operatore | (I/O): | | Getline pipe |
| | (barra verticale), operatore |& (I/O): | | Getline coprocesso |
| | (barra verticale), operatore | (I/O): | | Ridirezione |
| | (barra verticale), operatore |& (I/O): | | Ridirezione |
| | (barra verticale), operatore |& (I/O), pipe, chiusura: | | Chiusura file e pipe |
| | (barra verticale), operatore ||: | | Operatori booleani |
| | (barra verticale), operatore | (I/O): | | Precedenza |
| | (barra verticale), operatore |& (I/O): | | Precedenza |
| | (barra verticale), operatore ||: | | Precedenza |
| | (barra verticale), operatore |& (I/O): | | I/O bidirezionale |
|
| ~ | | |
|---|
| ~ (tilde), operatore ~: | | Uso di regexp |
| ~ (tilde), operatore ~: | | Espressioni regolari calcolate |
| ~ (tilde), operatore ~: | | Maiuscolo-Minuscolo |
| ~ (tilde), operatore ~: | | Costanti come espressioni regolari |
| ~ (tilde), operatore ~: | | Operatori di confronto |
| ~ (tilde), operatore ~: | | Operatori di confronto |
| ~ (tilde), operatore ~: | | Precedenza |
| ~ (tilde), operatore ~: | | Espressioni come criteri di ricerca |
|
| A | | |
|---|
| abbracci mortali: | | I/O bidirezionale |
| abilitare un punto d’interruzione: | | Controllo dei breakpoint |
| accedere alle variabili globali dalle estensioni: | | Accedere alla tabella simboli |
| accesso ai campi: | | Campi |
| account, informazioni sugli: | | Funzioni Passwd |
| account, informazioni sugli: | | Funzioni Group |
| Ada, linguaggio di programmazione: | | Glossario |
| aggiungere, campi: | | Cambiare i campi |
| aggiungere, funzionalità a gawk: | | Usare operazioni interne file |
| aggiungere, funzionalità a gawk: | | Aggiungere codice |
| Aho, Alfred: | | Storia |
| Aho, Alfred: | | Contributori |
| alarm.awk (programma): | | Programma alarm |
| algoritmi: | | Fondamenti ad alto livello |
| allocare memoria per estensioni: | | Funzioni di allocazione memoria |
| amazing awk assembler (programma aaa): | | Glossario |
| ambiguità sintattica: operatore /= vs. costante regexp /=…/: | | Operatori di assegnamento |
| anagram.awk (programma): | | Programma anagram |
| anagrammi, trovare: | | Programma anagram |
| analizzatore di input personalizzato: | | Analizzatori di input |
| and (operatore logico-booleano): | | Operatori booleani |
| AND (operazione sui bit): | | Funzioni a livello di bit |
| AND (operazione sui bit): | | Funzioni a livello di bit |
| and() (funzione gawk): | | Funzioni a livello di bit |
| angolo buio: | | Convenzioni |
| angolo buio, ARGV, valore della variabile: | | Script eseguibili |
| angolo buio, variabile, ARGV, valore: | | Script eseguibili |
| angolo buio, invocare awk: | | Riga di comando |
| angolo buio, programmi vuoti: | | Riga di comando |
| angolo buio, sequenze di protezione: | | Altri argomenti |
| angolo buio, sequenze di protezione, per metacaratteri: | | Sequenze di protezione |
| angolo buio, file in input: | | awk divisione record |
| angolo buio, stringhe, memorizzazine di: | | gawk divisione record |
| angolo buio, variabile, NF, decremento: | | Cambiare i campi |
| angolo buio, ^, in FS: | | Separare campi con regexp |
| angolo buio, FS come stringa nulla: | | Campi di un solo carattere |
| angolo buio, separatore di campo: | | Campo intera riga |
| angolo buio, record multiriga: | | Righe multiple |
| angolo buio, variabile, FILENAME: | | Note su getline |
| angolo buio, variabile, OFMT: | | OFMT |
| angolo buio, caratteri di controllo del formato: | | Lettere di controllo |
| angolo buio, caratteri di controllo del formato: | | Lettere di controllo |
| angolo buio, funzione, close(): | | Chiusura file e pipe |
| angolo buio, stringhe, continuazione su più righe: | | Costanti scalari |
| angolo buio, costanti regexp: | | Costanti regexp normali |
| angolo buio, costanti regexp, come argomenti a funzioni definite dall’utente: | | Costanti regexp normali |
| angolo buio, argomenti da riga di comando: | | Opzioni di assegnamento |
| angolo buio, variabile, CONVFMT: | | Stringhe e numeri |
| angolo buio, carattere di separazione dei decimali nelle localizzazioni: | | Localizzazione e conversioni |
| angolo buio, costanti regexp, operatore /= e: | | Operatori di assegnamento |
| angolo buio, operatore /= vs. costante regexp /=…/: | | Operatori di assegnamento |
| angolo buio, "0" è effettivamente vero: | | Valori di verità |
| angolo buio, intervalli di ricerca, continuazione di riga e: | | Intervalli |
| angolo buio, istruzione, break: | | Istruzione break |
| angolo buio, istruzione, continue: | | Istruzione continue |
| angolo buio, istruzione, exit: | | Istruzione exit |
| angolo buio, valore di ARGV[0]: | | Variabili auto-assegnate |
| angolo buio, variabile, FILENAME: | | Variabili auto-assegnate |
| angolo buio, variabile, FNR/NR: | | Variabili auto-assegnate |
| angolo buio, indici di vettori: | | Indici non inizializzati |
| angolo buio, regexp come secondo argomento di index(): | | Funzioni per stringhe |
| angolo buio, funzione, length(): | | Funzioni per stringhe |
| angolo buio, funzione, split(): | | Funzioni per stringhe |
| angolo buio: | | Glossario |
| ANSI: | | Glossario |
| API, versione dell’estensione: | | Versione dell'estensione |
| API, variabili informative dell’estensione: | | Variabili informative di estens. API |
| API (estensione), interazione con lo spazio-dei-nomi: | | Spazio-dei-nomi e funzionalità |
| API (estensione): | | Descrizione dell'estensione API |
| apice singolo ('): | | Monouso |
| apice singolo ('), nella riga di comando di gawk: | | Lunghi |
| apice singolo ('), vs. apostrofo: | | Commenti |
| apice singolo ('), nei comandi di shell: | | Protezione |
| apice singolo ('), con doppio apice: | | Protezione |
| arbitraria, precisione: | | Aritmetica del computer |
| archeologi: | | Bug |
| arcotangente: | | Funzioni numeriche |
| ARGC/ARGV (variabili), argomenti da riga di comando: | | Altri argomenti |
| ARGC/ARGV (variabili): | | Variabili auto-assegnate |
| ARGC/ARGV (variabili), come usarle: | | ARGC e ARGV |
| ARGIND (variabile), argomenti da riga di comando: | | Altri argomenti |
| ARGIND (variabile): | | Variabili auto-assegnate |
| argomenti, riga di comando, eseguire awk: | | Riga di comando |
| argomenti, riga di comando: | | Altri argomenti |
| argomenti, nelle chiamate di funzione: | | Chiamate di funzione |
| argomenti, riga di comando: | | Variabili auto-assegnate |
| argomenti, riga di comando: | | Variabili auto-assegnate |
| argomenti, riga di comando: | | ARGC e ARGV |
| argomenti, elaborazione di: | | Funzione getopt |
| ARGV (vettore): | | Opzioni |
| ARGV (vettore), indicizzare all’interno di: | | Altri argomenti |
| aritmetici, operatori: | | Operatori aritmetici |
| arrotondare, all’intero più vicino: | | Funzioni numeriche |
| arrotondare, numeri: | | Funzione round |
| ASCII: | | Sequenze di protezione |
| ASCII: | | Espressioni tra parentesi quadre |
| ASCII: | | Costanti scalari |
| ASCII: | | Funzioni ordinali |
| ASCII: | | Programma alarm |
| ASCII: | | I/O bidirezionale |
| ASCII: | | Intervalli e localizzazione |
| ASCII: | | Intervalli e localizzazione |
| ASCII: | | Sommario della storia |
| ASCII: | | Glossario |
| ASCII: | | Glossario |
| asort() (funzione gawk): | | Funzioni per stringhe |
| asort() (funzione gawk): | | Funzioni di ordinamento di vettori |
| asort() (funzione gawk), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| asort() (funzione gawk), effetti collaterali: | | Funzioni di ordinamento di vettori |
| asorti() (funzione gawk): | | Funzioni per stringhe |
| asorti() (funzione gawk): | | Funzioni di ordinamento di vettori |
| asorti() (funzione gawk), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| asorti() (funzione gawk), effetti collaterali: | | Funzioni di ordinamento di vettori |
| assegnamento, di variabile e file in input: | | Altri argomenti |
| assegnamento, operatori di: | | Operatori di assegnamento |
| assegnamento, operatori di, lvalue/rvalue: | | Operatori di assegnamento |
| assegnamento, operatori di, ordine di valutazione: | | Operatori di assegnamento |
| assegnamento, di variabile, visti come nomi di file: | | Ignorare assegnamenti di variabili |
| assegnamento, di valori a variabili, nel debugger: | | Vedere e modificare dati |
| assert(), funzione di libreria C: | | Funzione assert |
| assert(), funzione definita dall’utente: | | Funzione assert |
| asserzioni: | | Funzione assert |
| associativi, vettori: | | Introduzione ai vettori |
| asterisco (*), operatore *, come operatore regexp: | | Dettagli sugli operatori di regexp |
| asterisco (*), operatore **: | | Operatori aritmetici |
| asterisco (*), operatore *=: | | Operatori di assegnamento |
| asterisco (*), operatore **=: | | Operatori di assegnamento |
| asterisco (*), operatore **: | | Precedenza |
| asterisco (*), operatore *, come operatore di moltiplicazione: | | Precedenza |
| asterisco (*), operatore *=: | | Precedenza |
| asterisco (*), operatore **=: | | Precedenza |
| asterisco (*), operatore *, individuare la stringa nulla: | | Funzioni per stringhe |
| atan2() (funzione): | | Funzioni numeriche |
| avanzate, funzionalità, di gawk: | | Funzionalità avanzate |
| avanzate, funzionalità, programmazione di rete: | | Reti TCP/IP |
| avvertimenti, emissione di: | | Opzioni |
| avviare il debugger: | | Invocazione del debugger |
| awk: | | Prefazione |
| awk, POSIX e: | | Prefazione |
| awk, POSIX e: | | Prefazione |
| awk, gawk e: | | Prefazione |
| awk, uso di: | | Prefazione |
| awk, storia di: | | Storia |
| awk, nuovo e vecchio: | | Nomi |
| awk, descrizione dei termini: | | Questo manuale |
| awk, gawk e: | | Questo manuale |
| awk, utilizzo di: | | Per iniziare |
| awk, uso di: | | Per iniziare |
| awk, uso di: | | Quando |
| awk, eseguire: | | Riga di comando |
| awk, debug, abilitare: | | Opzioni |
| awk, profilazione, abilitare la: | | Opzioni |
| awk, implementazioni di, limiti delle: | | Note su getline |
| awk, problemi di implementazione, pipe: | | Ridirezione |
| awk, nuovo vs. vecchio, variabile OFMT: | | Stringhe e numeri |
| awk, linguaggio, versione POSIX: | | Operatori di assegnamento |
| awk, costanti regexp e: | | Operatori di confronto |
| awk, spazio-dei-nomi: | | Spazio-dei-nomi di default |
| awk, spazio-dei-nomi, memoria che contiene i nomi identificativi: | | Gestione interna dei nomi |
| awk, spazio-dei-nomi, utilizzo per chiamate indirette di funzione: | | Gestione interna dei nomi |
| awk, versioni di: | | V7/SVR3.1 |
| awk, versioni di, differenze tra V7 e SVR3.1: | | V7/SVR3.1 |
| awk, versioni di, differenze tra SVR3.1 e SVR4: | | SVR4 |
| awk, versioni di, differenze tra SVR4 e POSIX awk: | | POSIX |
| awk, versioni di: | | BTL |
| awk, implementazioni di: | | Altre versioni |
| awk, versioni di: | | Altre versioni |
| awka, compilatore per awk: | | Altre versioni |
| awk: | | Prefazione |
| AWKLIBPATH (variabile d’ambiente): | | AWKLIBPATH (Variabile) |
| AWKPATH (variabile d’ambiente): | | AWKPATH (Variabile) |
| AWKPATH (variabile d’ambiente): | | Uso su PC |
| awkprof.out, file: | | Profilare |
| awksed.awk (programma): | | Programma sed semplice |
| awkvars.out, file: | | Opzioni |
| azioni, default: | | Molto semplice |
| azioni, omesse: | | Molto semplice |
| azioni: | | Panoramica sulle azioni |
| azioni, istruzioni di controllo in: | | Istruzioni |
| a_fine_file(), funzione definita dall’utente: | | Funzione filetrans |
| a_inizio_file(), funzione definita dall’utente: | | Funzione filetrans |
|
| B | | |
|---|
| b (comando del debugger): | | Trovare il bug |
| b (comando del debugger), (alias per break): | | Controllo dei breakpoint |
| backtrace (comando del debugger): | | Trovare il bug |
| backtrace (comando del debugger): | | Stack di esecuzione |
| barra (/), per delimitare le espressioni regolari: | | Espressioni regolari |
| barra (/), operatore /=: | | Operatori di assegnamento |
| barra (/), operatore /=, vs. costante regexp /=…/: | | Operatori di assegnamento |
| barra (/), operatore /: | | Precedenza |
| barra (/), operatore /=: | | Precedenza |
| barra (/), criteri di ricerca e: | | Espressioni come criteri di ricerca |
| barra inversa (\): | | Commenti |
| barra inversa (\), nei comandi di shell: | | Protezione |
| barra inversa (\), continuazione di riga e: | | Istruzioni/Righe |
| barra inversa (\), continuazione di riga e, in csh: | | Istruzioni/Righe |
| barra inversa (\), continuazione di riga e, commenti: | | Istruzioni/Righe |
| barra inversa (\), in sequenze di protezione: | | Sequenze di protezione |
| barra inversa (\), \a (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \b (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \f (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \n (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \r (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \t (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \v (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \nnn (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \x (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \/ (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), \" (sequenza di protezione): | | Sequenze di protezione |
| barra inversa (\), in sequenze di protezione: | | Sequenze di protezione |
| barra inversa (\), in sequenze di protezione, POSIX e: | | Sequenze di protezione |
| barra inversa (\), operatore regexp: | | Dettagli sugli operatori di regexp |
| barra inversa (\), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| barra inversa (\), in costanti regexp: | | Espressioni regolari calcolate |
| barra inversa (\), \s (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \S (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \w (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \W (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \< (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \> (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \y (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \B (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \` (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), \' (operatore gawk): | | Operatori di regexp GNU |
| barra inversa (\), come separatore di campo: | | Separatori campo da riga di comando |
| barra inversa (\), gsub()/gensub()/sub() funzioni e: | | Dettagli ostici |
| barra verticale (|): | | Dettagli sugli operatori di regexp |
| barra verticale (|), operatore | (I/O): | | Getline pipe |
| barra verticale (|), operatore |& (I/O): | | Getline coprocesso |
| barra verticale (|), operatore ||: | | Operatori booleani |
| barra verticale (|), operatore | (I/O): | | Precedenza |
| barra verticale (|), operatore |& (I/O): | | Precedenza |
| barra verticale (|), operatore ||: | | Precedenza |
| barra verticale (|), operatore |& (I/O): | | I/O bidirezionale |
| Beebe, Nelson H.F.: | | Ringraziamenti |
| Beebe, Nelson H.F.: | | Funzioni numeriche |
| Beebe, Nelson H.F.: | | Altre versioni |
| BEGIN (regola): | | Separatori di campo |
| BEGIN (regola), getline e: | | Note su getline |
| BEGIN (regola), intestazioni, aggiungere: | | Esempi su print |
| BEGIN (regola), variabili OFS/ORS, assegnare valori a: | | Separatori di output |
| BEGIN (regola), criteri di ricerca booleani e: | | Espressioni come criteri di ricerca |
| BEGIN (regola): | | BEGIN/END |
| BEGIN (regola): | | Usare BEGIN/END |
| BEGIN (regola), operatori e: | | Usare BEGIN/END |
| BEGIN (regola), istruzione print e: | | I/O e BEGIN/END |
| BEGIN (regola), istruzioni next/nextfile e: | | I/O e BEGIN/END |
| BEGIN (regola), istruzioni next/nextfile e: | | Istruzione next |
| BEGIN (regola), istruzione exit e: | | Istruzione exit |
| BEGIN (regola), funzione definita dall’utente assert() e: | | Funzione assert |
| BEGIN (regola), programma pwcat: | | Funzioni Passwd |
| BEGIN (regola), eseguire programmi awk e: | | Programma cut |
| BEGIN (regola), profilazione e: | | Profilare |
| BEGIN (regola), variabile TEXTDOMAIN e: | | I18N per programmatore |
| BEGIN (regola), ordine di esecuzione non alterato da @namespace: | | Cambiare lo spazio-dei-nomi |
| BEGINFILE (regola), criteri di ricerca booleani e: | | Espressioni come criteri di ricerca |
| BEGINFILE (regola): | | BEGINFILE/ENDFILE |
| BEGINFILE (regola), ordine di esecuzione non alterato da @namespace: | | Cambiare lo spazio-dei-nomi |
| Bentley, Jon: | | Glossario |
| Benzinger, Michael: | | Contributori |
| Berry, Karl: | | Ringraziamenti |
| Berry, Karl: | | Ringraziamenti |
| Berry, Karl: | | Intervalli e localizzazione |
| bidirezionale, processore personalizzato: | | Processori bidirezionali |
| binario, input/output: | | Variabili modificabili dall'utente |
| bindtextdomain(), funzione di libreria C: | | Utilizzare gettext |
| bindtextdomain() (funzione gawk): | | Funzioni di internazionalizzazione |
| bindtextdomain() (funzione gawk): | | I18N per programmatore |
| bindtextdomain() (funzione gawk), portabilità e: | | Portabilità nell'I18N |
| BINMODE (variabile): | | Variabili modificabili dall'utente |
| BINMODE (variabile): | | Uso su PC |
| biscotto della fortuna: | | Glossario |
| bit, funzioni per la manipolazione di: | | Funzioni a livello di bit |
| bit, operazioni sui: | | Funzioni a livello di bit |
| bit, complemento a livello di: | | Funzioni a livello di bit |
| bit, spostamento di: | | Funzioni a livello di bit |
| bit, di parità (in ASCII): | | Funzioni ordinali |
| bits2str(), funzione definita dall’utente: | | Funzioni a livello di bit |
| booleane, espressioni: | | Operatori booleani |
| booleani, operatori: | | Operatori booleani |
| Bourne shell, protezione, regole per la: | | Protezione |
| break (comando del debugger): | | Trovare il bug |
| break (comando del debugger): | | Controllo dei breakpoint |
| break (istruzione): | | Istruzione break |
| breakpoint (comando del debugger): | | Terminologia nel debug |
| breakpoint (comando del debugger): | | Trovare il bug |
| breakpoint (comando del debugger), impostare: | | Controllo dei breakpoint |
| breakpoint (comando del debugger), in una determinata posizione, cancellare: | | Controllo dei breakpoint |
| breakpoint (comando del debugger), cancellare per numero: | | Controllo dei breakpoint |
| Brennan, Michael: | | Introduzione3 |
| Brennan, Michael: | | Introduzione4 |
| Brennan, Michael: | | Ringraziamenti |
| Brennan, Michael: | | Cancellazione |
| Brennan, Michael: | | Programma sed semplice |
| Brennan, Michael: | | Altre versioni |
| Brennan, Michael: | | Altre versioni |
| Brian Kernighan, awk di: | | Quando |
| Brian Kernighan, awk di: | | Sequenze di protezione |
| Brian Kernighan, awk di: | | Operatori di regexp GNU |
| Brian Kernighan, awk di: | | gawk divisione record |
| Brian Kernighan, awk di: | | Separare campi con regexp |
| Brian Kernighan, awk di: | | Getline pipe |
| Brian Kernighan, awk di: | | Concatenazione |
| Brian Kernighan, awk di: | | I/O e BEGIN/END |
| Brian Kernighan, awk di: | | Istruzione break |
| Brian Kernighan, awk di: | | Istruzione continue |
| Brian Kernighan, awk di: | | Istruzione nextfile |
| Brian Kernighan, awk di: | | Cancellazione |
| Brian Kernighan, awk di: | | Funzioni per stringhe |
| Brian Kernighan, awk di: | | Dettagli ostici |
| Brian Kernighan, awk di: | | Funzioni di I/O |
| Brian Kernighan, awk di, estensioni: | | BTL |
| Brian Kernighan, awk di, codice sorgente: | | Altre versioni |
| Brini, Davide: | | Programma signature |
| Brink, Jeroen: | | Doppi apici in DOS |
| Broder, Alan J.: | | Contributori |
| Brown, Martin: | | Contributori |
| bt (comando del debugger), (alias per backtrace): | | Trovare il bug |
| bt (comando del debugger), (alias per backtrace): | | Stack di esecuzione |
| Buening, Andreas: | | Ringraziamenti |
| Buening, Andreas: | | Contributori |
| Buening, Andreas: | | Manutentori |
| buffer, operatori per: | | Operatori di regexp GNU |
| buffer, scrivere su disco un: | | Funzioni di I/O |
| buffer, scrivere su disco un: | | Funzioni di I/O |
| bufferizzazione, interattiva vs. non interattiva: | | Funzioni di I/O |
| bufferizzazione, dell’input/output: | | Funzioni di I/O |
| bufferizzazione, dell’output: | | Funzioni di I/O |
| bufferizzazione, dell’input/output: | | I/O bidirezionale |
| bug, segnalare, indirizzo email, bug-gawk@gnu.org: | | Indirizzo Bug |
| bug-gawk@gnu.org indirizzo per la segnalazione dei bug: | | Indirizzo Bug |
| BusyBox Awk: | | Altre versioni |
|
| C | | |
|---|
| cambiare, il separatore di record: | | awk divisione record |
| cambiare, il contenuto dei campi: | | Cambiare i campi |
| cambiare, il valore di FS (variabile): | | Separatori di campo |
| cambiare, lo spazio-dei-nomi: | | Cambiare lo spazio-dei-nomi |
| cambiare, lo spazio-dei-nomi corrente: | | Cambiare lo spazio-dei-nomi |
| campi: | | Leggere file |
| campi: | | Campi |
| campi, esame dei: | | Campi |
| campi, numero dei: | | Campi |
| campi, numero dei: | | Campi non costanti |
| campi, cambiare il contenuto dei: | | Cambiare i campi |
| campi, aggiungere: | | Cambiare i campi |
| campi, separatore di: | | Cambiare i campi |
| campi, separare: | | Separatori di campo |
| campi, separatore di: | | Separatori di campo |
| campi, di un solo carattere: | | Campi di un solo carattere |
| campi, di larghezza costante: | | Dimensione costante |
| campi, stampare: | | Esempi su print |
| campi, separatore di, variabile FIELDWIDTHS e: | | Variabili modificabili dall'utente |
| campi, separatore di, variabile FPAT e: | | Variabili modificabili dall'utente |
| campi, separatore di: | | Variabili modificabili dall'utente |
| campi, separatore di: | | Variabili modificabili dall'utente |
| campi, ritagliare: | | Programma cut |
| campi: | | Fondamenti ad alto livello |
| cancellare punto d’interruzione, in una determinata posizione: | | Controllo dei breakpoint |
| cancellare punto d’interruzione, per numero: | | Controllo dei breakpoint |
| cancellare punto d’osservazione: | | Vedere e modificare dati |
| cancelletto (#), #! (script eseguibili): | | Script eseguibili |
| cancelletto (#), commentare: | | Commenti |
| caratteri, elenchi di, in espressioni regolari: | | Espressioni tra parentesi quadre |
| caratteri, valore come numero: | | Funzioni ordinali |
| caratteri, contare i: | | Programma wc |
| caratteri, rimpiazzare: | | Programma translate |
| caratteri, (codifiche macchina di caratteri): | | Glossario |
| caricare estensioni: | | Opzioni |
| caricare estensioni, @load (direttiva): | | Includere file |
| caricare estensioni, direttiva @load: | | Caricare librerie condivise |
| case, parola chiave: | | Istruzione switch |
| case, : | | Istruzione switch |
| casuali, numeri, generatore Cliff di: | | Funzione random Cliff |
| categoria di localizzazione: | | Utilizzare gettext |
| categoria di localizzazione, LC_MESSAGES (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_COLLATE (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_CTYPE (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_MONETARY (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_NUMERIC (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_TIME (variabile d’ambiente): | | Utilizzare gettext |
| categoria di localizzazione, LC_ALL (variabile d’ambiente): | | Utilizzare gettext |
| cavalieri jedi: | | Non documentato |
| cercare e rimpiazzare in stringhe: | | Funzioni per stringhe |
| CGI, awk script per: | | Opzioni |
| Chassell, Robert J.: | | Ringraziamenti |
| chdir() (estensione): | | Esempio di estensione funzioni file |
| chem (programma di utilità): | | Glossario |
| chiamare, funzione: | | Chiamate di funzione |
| chiamare, comando di shell: | | Funzioni di I/O |
| chiamare, funzione definita dall’utente: | | Chiamata di una funzione |
| chiamare, funzione, per valore: | | Parametri per valore/riferimento |
| chiamare, funzione, per riferimento: | | Parametri per valore/riferimento |
| chiamare, funzione, indirettamente: | | Chiamate indirette |
| chiamare, funzione, indirettamente, notazione @: | | Chiamate indirette |
| chiocciola (@), @include (direttiva): | | Includere file |
| chiocciola (@), @load (direttiva): | | Caricare librerie condivise |
| chiocciola (@), @-notazione per la chiamata indiretta di funzioni: | | Chiamate indirette |
| chiocciola (@), @namespace (direttiva): | | Cambiare lo spazio-dei-nomi |
| chiocciola (@), @namespace (direttiva), non riguarda BEGIN, BEGINFILE, END, ed ENDFILE: | | Cambiare lo spazio-dei-nomi |
| chiocciola (@), @namespace (direttiva): | | Cambiare lo spazio-dei-nomi |
| chiudere un file o un coprocesso: | | Funzioni di I/O |
| Chr (estensione): | | Esempio di estensione Ord |
| chr(), funzione definita dall’utente: | | Funzioni ordinali |
| cicli: | | Istruzione while |
| cicli, while: | | Istruzione while |
| cicli, do-while: | | Istruzione do |
| cicli, for, iterativi: | | Istruzione for |
| cicli, istruzione continue e: | | Istruzione for |
| cicli, uscita: | | Istruzione break |
| cicli, istruzione break e: | | Istruzione break |
| cicli, for, visita di un vettore: | | Visitare un intero vettore |
| cicli, conteggi per l’intestazione, in un profilo: | | Profilare |
| cicli: | | Istruzione while |
| circonflesso (^), operatore regexp: | | Dettagli sugli operatori di regexp |
| circonflesso (^), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| circonflesso (^), operatore regexp: | | Operatori di regexp GNU |
| circonflesso (^), operatore ^=: | | Operatori di assegnamento |
| circonflesso (^), operatore ^: | | Precedenza |
| circonflesso (^), operatore ^=: | | Precedenza |
| clear (comando del debugger): | | Controllo dei breakpoint |
| Cliff, generatore di numeri casuali: | | Funzione random Cliff |
| cliff_rand(), funzione definita dall’utente: | | Funzione random Cliff |
| close() (funzione): | | Chiusura file e pipe |
| close() (funzione), portabilità: | | Chiusura file e pipe |
| close() (funzione), codice di ritorno: | | Chiusura file e pipe |
| close() (funzione): | | Funzioni di I/O |
| close() (funzione), pipe bidirezionali e: | | I/O bidirezionale |
| Close, Diane: | | Storia del manuale |
| Close, Diane: | | Contributori |
| codice di ritorno, di gawk: | | Codice di ritorno |
| codice di ritorno, funzione close(): | | Chiusura file e pipe |
| codice di ritorno, di gawk, in VMS: | | Esecuzione su VMS |
| codice sorgente, combinare: | | Opzioni |
| codice sorgente, gawk: | | Distribuzione di Gawk |
| codice sorgente, gawk, ottenere il: | | Scaricare |
| codice sorgente, Brian Kernighan awk: | | Altre versioni |
| codice sorgente, mawk: | | Altre versioni |
| codice sorgente, awka: | | Altre versioni |
| codice sorgente, pawk: | | Altre versioni |
| codice sorgente, BusyBox Awk: | | Altre versioni |
| codice sorgente, Solaris awk: | | Altre versioni |
| codice sorgente, Illumos awk: | | Altre versioni |
| codice sorgente, jawk: | | Altre versioni |
| codice sorgente, libmawk (interpretatore): | | Altre versioni |
| codice sorgente, interpretatore awk incorporabile: | | Altre versioni |
| codice sorgente, pawk (versione Python): | | Altre versioni |
| codice sorgente, QSE awk: | | Altre versioni |
| codice sorgente, QuikTrim Awk: | | Altre versioni |
| Collado, Manuel: | | Ringraziamenti |
| Collado, Manuel: | | File CSV |
| Colombo, Antonio: | | Ringraziamenti |
| Colombo, Antonio: | | Contributori |
| colonne, allineamento: | | Esempi su print |
| colonne, ritagliare: | | Programma cut |
| comandi da eseguire al punto d’interruzione: | | Controllo esecuzione debugger |
| comando, ls: | | Maggiore sofisticazione |
| comando, csh: | | Istruzioni/Righe |
| comando, getline, risoluzione di problemi: | | Controllo di file |
| comando, getline, funzione definita dall’utente, _pw_init(): | | Funzioni Passwd |
| comando, getline, funzione definita dall’utente, _gr_init(): | | Funzioni Group |
| comando, csh, operatore |&, confronto con: | | I/O bidirezionale |
| comando, kill, profilazione dinamica e: | | Profilare |
| comando del debugger, breakpoint: | | Trovare il bug |
| comando del debugger, break: | | Trovare il bug |
| comando del debugger, b (alias per break): | | Trovare il bug |
| comando del debugger, run: | | Trovare il bug |
| comando del debugger, bt (alias per backtrace): | | Trovare il bug |
| comando del debugger, backtrace: | | Trovare il bug |
| comando del debugger, print: | | Trovare il bug |
| comando del debugger, p (alias per print): | | Trovare il bug |
| comando del debugger, n (alias per next): | | Trovare il bug |
| comando del debugger, next: | | Trovare il bug |
| comando del debugger, b (alias per break): | | Controllo dei breakpoint |
| comando del debugger, break: | | Controllo dei breakpoint |
| comando del debugger, clear: | | Controllo dei breakpoint |
| comando del debugger, condition: | | Controllo dei breakpoint |
| comando del debugger, d (alias per delete): | | Controllo dei breakpoint |
| comando del debugger, delete: | | Controllo dei breakpoint |
| comando del debugger, disable: | | Controllo dei breakpoint |
| comando del debugger, e (alias per enable): | | Controllo dei breakpoint |
| comando del debugger, enable: | | Controllo dei breakpoint |
| comando del debugger, ignore: | | Controllo dei breakpoint |
| comando del debugger, t (alias per tbreak): | | Controllo dei breakpoint |
| comando del debugger, tbreak: | | Controllo dei breakpoint |
| comando del debugger, commands: | | Controllo esecuzione debugger |
| comando del debugger, silent: | | Controllo esecuzione debugger |
| comando del debugger, end: | | Controllo esecuzione debugger |
| comando del debugger, c (alias per continue): | | Controllo esecuzione debugger |
| comando del debugger, continue: | | Controllo esecuzione debugger |
| comando del debugger, finish: | | Controllo esecuzione debugger |
| comando del debugger, n (alias per next): | | Controllo esecuzione debugger |
| comando del debugger, next: | | Controllo esecuzione debugger |
| comando del debugger, ni (alias per nexti): | | Controllo esecuzione debugger |
| comando del debugger, nexti: | | Controllo esecuzione debugger |
| comando del debugger, return: | | Controllo esecuzione debugger |
| comando del debugger, r (alias per run): | | Controllo esecuzione debugger |
| comando del debugger, run: | | Controllo esecuzione debugger |
| comando del debugger, s (alias per step): | | Controllo esecuzione debugger |
| comando del debugger, step: | | Controllo esecuzione debugger |
| comando del debugger, si (alias per stepi): | | Controllo esecuzione debugger |
| comando del debugger, stepi: | | Controllo esecuzione debugger |
| comando del debugger, u (alias per until): | | Controllo esecuzione debugger |
| comando del debugger, until: | | Controllo esecuzione debugger |
| comando del debugger, display: | | Vedere e modificare dati |
| comando del debugger, eval: | | Vedere e modificare dati |
| comando del debugger, p (alias per print): | | Vedere e modificare dati |
| comando del debugger, print: | | Vedere e modificare dati |
| comando del debugger, printf: | | Vedere e modificare dati |
| comando del debugger, set: | | Vedere e modificare dati |
| comando del debugger, w (alias per watch): | | Vedere e modificare dati |
| comando del debugger, watch: | | Vedere e modificare dati |
| comando del debugger, undisplay: | | Vedere e modificare dati |
| comando del debugger, unwatch: | | Vedere e modificare dati |
| comando del debugger, bt (alias per backtrace): | | Stack di esecuzione |
| comando del debugger, backtrace: | | Stack di esecuzione |
| comando del debugger, where (alias per backtrace): | | Stack di esecuzione |
| comando del debugger, down: | | Stack di esecuzione |
| comando del debugger, f (alias per frame): | | Stack di esecuzione |
| comando del debugger, frame: | | Stack di esecuzione |
| comando del debugger, up: | | Stack di esecuzione |
| comando del debugger, i (alias per info): | | Informazioni sul debugger |
| comando del debugger, info: | | Informazioni sul debugger |
| comando del debugger, o (alias per option): | | Informazioni sul debugger |
| comando del debugger, option: | | Informazioni sul debugger |
| comando del debugger, dump: | | Comandi vari del debugger |
| comando del debugger, exit: | | Comandi vari del debugger |
| comando del debugger, h (alias per help): | | Comandi vari del debugger |
| comando del debugger, help: | | Comandi vari del debugger |
| comando del debugger, l (alias per list): | | Comandi vari del debugger |
| comando del debugger, list: | | Comandi vari del debugger |
| comando del debugger, q (alias per quit): | | Comandi vari del debugger |
| comando del debugger, quit: | | Comandi vari del debugger |
| comando del debugger, trace: | | Comandi vari del debugger |
| commands (comando del debugger): | | Controllo esecuzione debugger |
| commenti: | | Commenti |
| commenti, continuazione di riga con barra inversa e: | | Istruzioni/Righe |
| comp.lang.awk gruppo di discussione: | | Usenet |
| compatibile, modalità (gawk), numeri ottali: | | Numeri non-decimali |
| compatibile, modalità (gawk), numeri esadecimali: | | Numeri non-decimali |
| compilare gawk, per MS-Windows: | | Compilazione su PC |
| compilare gawk, per Cygwin: | | Cygwin |
| compilare gawk, per VMS: | | Compilazione su VMS |
| compilatore per awk, awka: | | Altre versioni |
| compl() (funzione gawk): | | Funzioni a livello di bit |
| complemento sui bit: | | Funzioni a livello di bit |
| complemento sui bit: | | Funzioni a livello di bit |
| completamento dei comandi, nel debugger: | | Supporto per Readline |
| componente, spazio-dei-nomi, nome del: | | Nomi qualificati |
| componente, spazio-dei-nomi, regole per assegnare i nomi: | | Regole per i nomi |
| composte, istruzioni, istruzioni di controllo e: | | Istruzioni |
| comuni, estensioni, \x, sequenza di protezione: | | Sequenze di protezione |
| comuni, estensioni, RS come espressione regolare: | | gawk divisione record |
| comuni, estensioni, campi di un solo carattere: | | Campi di un solo carattere |
| comuni, estensioni, delete per eliminare interi vettori: | | Cancellazione |
| comuni, estensioni, length() applicato a un vettore: | | Funzioni per stringhe |
| concatenare: | | Concatenazione |
| conchiglie, mare: | | Non documentato |
| condition (comando del debugger): | | Controllo dei breakpoint |
| condizionali, espressioni: | | Espressioni condizionali |
| condizione dei punti d’interruzione: | | Controllo dei breakpoint |
| configurazione di gawk, opzioni di: | | Ulteriori opzioni di configurazione |
| configurazione di gawk: | | Filosofia della configurazione |
| confronto, espressioni di: | | Tipi di variabile e confronti |
| contare: | | Programma wc |
| conteggio riferimenti, ordinamento vettori: | | Funzioni di ordinamento di vettori |
| continuare esecuzione programma, nel debugger: | | Controllo esecuzione debugger |
| continuazione di riga, nella C shell: | | Maggiore sofisticazione |
| continuazione di riga, in istruzione print: | | Esempi su print |
| continuazione di riga: | | Operatori booleani |
| continuazione di riga, gawk: | | Espressioni condizionali |
| continue (comando del debugger): | | Controllo esecuzione debugger |
| continue (istruzione): | | Istruzione continue |
| controllo, lint, con programma vuoto: | | Riga di comando |
| controllo, lint, POSIXLY_CORRECT (variabile d’ambiente): | | Opzioni |
| controllo, tramite istruzioni, in azioni: | | Istruzioni |
| controllo, lint: | | Variabili modificabili dall'utente |
| controllo, ordine di visita dei vettori: | | Controllare visita |
| controllo, lint, indici di vettori: | | Indici non inizializzati |
| controllo, lint, elementi di vettori: | | Cancellazione |
| controllo, lint, per funzione indefinita: | | Precisazioni sulle funzioni |
| controllo, disponibilità MPFR: | | Controllare disponibilità MPFR |
| convenzioni di programmazione, istruzione exit: | | Istruzione exit |
| convenzioni di programmazione, ARGC/ARGV (variabili): | | Variabili auto-assegnate |
| convenzioni di programmazione, nelle chiamate di funzione: | | Chiamare funzioni predefinite |
| convenzioni di programmazione, nella scrittura di funzioni: | | Sintassi delle definizioni |
| convenzioni di programmazione, parametri di funzione: | | Istruzione return |
| convenzioni di programmazione, nomi di variabili private: | | Nomi di variabili di libreria |
| conversione, da stringa a numero: | | Stringhe e numeri |
| conversione, da numero a stringa: | | Stringhe e numeri |
| conversione, di tipo di variabile: | | Stringhe e numeri |
| conversione, di numeri interi che sono indici di vettore: | | Indici numerici di vettore |
| conversione, da stringa a numero: | | Funzioni per stringhe |
| conversione, di stringa in minuscolo: | | Funzioni per stringhe |
| conversione, di stringa in maiuscolo: | | Funzioni per stringhe |
| conversione, di date in marcature temporali: | | Funzioni di tempo |
| conversione, da stringa a numero: | | Funzioni a livello di bit |
| conversione, da numero a stringa: | | Funzioni a livello di bit |
| CONVFMT (variabile): | | Stringhe e numeri |
| CONVFMT (variabile): | | Variabili modificabili dall'utente |
| CONVFMT (variabile), indici di vettore e: | | Indici numerici di vettore |
| coprocessi, getline da: | | Getline coprocesso |
| coprocessi: | | Ridirezione |
| coprocessi, chiusura: | | Chiusura file e pipe |
| coprocessi: | | I/O bidirezionale |
| corpo, nelle azioni: | | Istruzioni |
| corpo, nei cicli: | | Istruzione while |
| corrente, spazio-dei-nomi, cambiare e ripristinare: | | Cambiare lo spazio-dei-nomi |
| cortocircuito, operatori: | | Operatori booleani |
| cos() (funzione): | | Funzioni numeriche |
| coseno: | | Funzioni numeriche |
| costanti, regexp: | | Uso di regexp |
| costanti, regexp, barre vs. doppi apici: | | Espressioni regolari calcolate |
| costanti, regexp, vs. costanti stringa: | | Espressioni regolari calcolate |
| costanti, stringa, vs. costanti regexp: | | Espressioni regolari calcolate |
| costanti, tipi di: | | Costanti |
| costanti, numeriche: | | Costanti scalari |
| costanti, stringa: | | Costanti scalari |
| costanti, regexp: | | Costanti come espressioni regolari |
| costanti, regexp, in gawk: | | Costanti regexp normali |
| costanti, regexp: | | Operatori di confronto |
| costanti, non decimali: | | Dati non decimali |
| creare un vettore da una stringa: | | Funzioni per stringhe |
| criteri di ricerca, default: | | Molto semplice |
| criteri di ricerca, espressioni regolari come: | | Uso di regexp |
| criteri di ricerca: | | Criteri di ricerca e azioni |
| criteri di ricerca, tipi di: | | Panoramica sui criteri di ricerca |
| criteri di ricerca, espressioni regolari come: | | regexp come criteri di ricerca |
| criteri di ricerca, espressioni regolari come: | | Espressioni come criteri di ricerca |
| criteri di ricerca, espressioni di confronto come: | | Espressioni come criteri di ricerca |
| criteri di ricerca, costanti regexp come: | | Espressioni come criteri di ricerca |
| criteri di ricerca, espressioni booleane come: | | Espressioni come criteri di ricerca |
| criteri di ricerca, intervalli nei: | | Intervalli |
| criteri di ricerca, vuoti: | | Vuoto |
| criteri di ricerca, conteggi in un profilo: | | Profilare |
| csh (comando di utilità), variabile d’ambiente POSIXLY_CORRECT: | | Opzioni |
| csh (comando di utilità), operatore |&, confronto con: | | I/O bidirezionale |
| ctime(), funzione definita dall’utente: | | Esempio di funzione |
| Curreli, Marco: | | Contributori |
| custom.h (file): | | Filosofia della configurazione |
| cut (programma di utilità): | | Programma cut |
| cut.awk (programma): | | Programma cut |
| Cygwin, compilare gawk per: | | Cygwin |
|
| D | | |
|---|
| d (comando del debugger), (alias per delete): | | Controllo dei breakpoint |
| D-o: | | Ringraziamenti |
| data e ora, : | | Funzioni di tempo |
| data e ora, formato stringa: | | Funzioni di tempo |
| data e ora, : | | Funzioni di tempo |
| data e ora, corrente del sistema: | | Funzioni di tempo |
| data e ora, formattazione: | | Funzione getlocaltime |
| date, conversione in marcature temporali: | | Funzioni di tempo |
| date, informazioni relative alla localizzazione: | | Utilizzare gettext |
| date (programma di utilità GNU): | | Funzioni di tempo |
| date (programma di utilità POSIX): | | Funzioni di tempo |
| Davies, Stephen: | | Ringraziamenti |
| Davies, Stephen: | | Contributori |
| Day, Robert P.J.: | | Ringraziamenti |
| dcgettext() (funzione gawk): | | Funzioni di internazionalizzazione |
| dcgettext() (funzione gawk): | | I18N per programmatore |
| dcgettext() (funzione gawk), portabilità e: | | Portabilità nell'I18N |
| dcngettext() (funzione gawk): | | Funzioni di internazionalizzazione |
| dcngettext() (funzione gawk): | | I18N per programmatore |
| dcngettext() (funzione gawk), portabilità e: | | Portabilità nell'I18N |
| deadlocks, vedi stalli: | | I/O bidirezionale |
| debug, istruzione print, omissione virgole: | | Esempi su print |
| debug, errori fatali, printf, stringhe di formato: | | Modificatori di formato |
| debug, stampare: | | Ridirezione |
| debug, doppio apice con nomi di file: | | FD speciali |
| debug, dei programmi awk: | | Debugger |
| debug, esempio di sessione: | | Esempio di sessione di debug |
| debug, gawk, segnalare bug: | | Bug |
| debugger, funzionalità del: | | Nozioni sul debug |
| debugger, terminologia: | | Terminologia nel debug |
| debugger, stack di chiamata: | | Terminologia nel debug |
| debugger, pila di chiamata: | | Terminologia nel debug |
| debugger, stack frame: | | Terminologia nel debug |
| debugger, breakpoint: | | Terminologia nel debug |
| debugger, punto d’interruzione: | | Terminologia nel debug |
| debugger, watchpoint: | | Terminologia nel debug |
| debugger, punto d’osservazione: | | Terminologia nel debug |
| debugger, come avviarlo: | | Invocazione del debugger |
| debugger, comandi del: | | Invocazione del debugger |
| debugger, prompt: | | Invocazione del debugger |
| debugger, impostare un punto d’interruzione: | | Trovare il bug |
| debugger, eseguire il programma: | | Trovare il bug |
| debugger, elementi pila, visualizzazione: | | Trovare il bug |
| debugger, stampare singoli elementi di un vettore: | | Trovare il bug |
| debugger, stampare tutti gli elementi di un vettore: | | Trovare il bug |
| debugger, ripetere dei comandi: | | Lista dei comandi di debug |
| debugger, continuare esecuzione programma: | | Controllo esecuzione debugger |
| debugger, mostrare argomenti delle funzioni: | | Informazioni sul debugger |
| debugger, mostrare punti d’interruzione: | | Informazioni sul debugger |
| debugger, visualizzazioni automatiche: | | Informazioni sul debugger |
| debugger, descrizione degli stack frame delle chiamate: | | Informazioni sul debugger |
| debugger, elencare definizioni delle funzioni: | | Informazioni sul debugger |
| debugger, mostrare variabili locali: | | Informazioni sul debugger |
| debugger, mostrare il nome del file sorgente corrente: | | Informazioni sul debugger |
| debugger, mostrare il nome di tutti i file sorgente: | | Informazioni sul debugger |
| debugger, elencare tutte le variabili locali: | | Informazioni sul debugger |
| debugger, mostrare i punti d’osservazione: | | Informazioni sul debugger |
| debugger, opzioni del: | | Informazioni sul debugger |
| debugger, dimensione della cronologia: | | Informazioni sul debugger |
| debugger, numero di righe nella lista di default: | | Informazioni sul debugger |
| debugger, ridirezionare l’output di gawk: | | Informazioni sul debugger |
| debugger, prompt: | | Informazioni sul debugger |
| debugger, file della cronologia: | | Informazioni sul debugger |
| debugger, salvataggio opzioni: | | Informazioni sul debugger |
| debugger, tener traccia delle istruzioni: | | Informazioni sul debugger |
| debugger, salvare dei comandi su un file: | | Informazioni sul debugger |
| debugger, leggere comandi da un file: | | Informazioni sul debugger |
| debugger, uscire dal: | | Comandi vari del debugger |
| debugger, uscire dal: | | Comandi vari del debugger |
| debugger, completamento dei comandi nel: | | Supporto per Readline |
| debugger, espansione della cronologia: | | Supporto per Readline |
| debugger, limitazioni: | | Limitazioni |
| debugger, interazione con lo spazio-dei-nomi: | | Spazio-dei-nomi e funzionalità |
| decremento, operatori di: | | Operatori di incremento |
| default, parola chiave: | | Istruzione switch |
| default, : | | Istruzione switch |
| definite dall’utente, Si veda variabili definite dall’utente: | | Variabili |
| definite dall’utente, Si veda funzioni definite dall’utente: | | Funzioni definite dall'utente |
| definizione di funzioni: | | Sintassi delle definizioni |
| Deifik, Scott: | | Ringraziamenti |
| Deifik, Scott: | | Contributori |
| delete (comando del debugger): | | Controllo dei breakpoint |
| delete (istruzione): | | Cancellazione |
| delete (istruzione), eliminare un elemento di un vettore: | | Cancellazione |
| Demaille, Akim: | | Ringraziamenti |
| descrittori di file: | | FD speciali |
| descrizione di, stack, pila delle, nel debugger: | | Stack di esecuzione |
| descrizione di, stack frame delle chiamate, nel debugger: | | Informazioni sul debugger |
| differenze tra awk e gawk, AWKPATH (variabile d’ambiente): | | AWKPATH (Variabile) |
| differenze tra awk e gawk, AWKLIBPATH (variabile d’ambiente): | | AWKLIBPATH (Variabile) |
| differenze tra awk e gawk, espressioni regolari: | | Maiuscolo-Minuscolo |
| differenze tra awk e gawk, separatore di record: | | awk divisione record |
| differenze tra awk e gawk, variabili RS/RT: | | awk divisione record |
| differenze tra awk e gawk, variabili RS/RT: | | gawk divisione record |
| differenze tra awk e gawk, memorizzazione di stringhe: | | gawk divisione record |
| differenze tra awk e gawk, campi di un solo carattere: | | Campi di un solo carattere |
| differenze tra awk e gawk, variabili RS/RT: | | Righe multiple |
| differenze tra awk e gawk, comando getline: | | Getline |
| differenze tra awk e gawk, operatori di input/output: | | Getline coprocesso |
| differenze tra awk e gawk, limitazioni di implementazione: | | Note su getline |
| differenze tra awk e gawk, tempo limite per lettura: | | Timeout in lettura |
| differenze tra awk e gawk, proseguire dopo errore in input: | | Proseguire dopo errore in input |
| differenze tra awk e gawk, directory sulla riga di comando: | | Directory su riga di comando |
| differenze tra awk e gawk, tra istruzioni print e printf: | | Modificatori di formato |
| differenze tra awk e gawk, operatori di input/output: | | Ridirezione |
| differenze tra awk e gawk, limitazioni di implementazione: | | Ridirezione |
| differenze tra awk e gawk, messaggi di errore: | | FD speciali |
| differenze tra awk e gawk, funzione close(): | | Chiusura file e pipe |
| differenze tra awk e gawk, funzione close(): | | Chiusura file e pipe |
| differenze tra awk e gawk, stringhe: | | Costanti scalari |
| differenze tra awk e gawk, stringhe: | | Costanti scalari |
| differenze tra awk e gawk, costanti regexp: | | Costanti regexp normali |
| differenze tra awk e gawk, operazione di modulo-troncamento: | | Operatori aritmetici |
| differenze tra awk e gawk, continuazione di riga: | | Espressioni condizionali |
| differenze tra awk e gawk, criteri di ricerca BEGIN/END: | | I/O e BEGIN/END |
| differenze tra awk e gawk, criteri di ricerca BEGINFILE/ENDFILE: | | BEGINFILE/ENDFILE |
| differenze tra awk e gawk, variabile BINMODE: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile FIELDWIDTHS: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile FPAT: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile IGNORECASE: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile LINT: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile TEXTDOMAIN: | | Variabili modificabili dall'utente |
| differenze tra awk e gawk, variabile ARGIND: | | Variabili auto-assegnate |
| differenze tra awk e gawk, variabile ERRNO: | | Variabili auto-assegnate |
| differenze tra awk e gawk, variabile FUNCTAB: | | Variabili auto-assegnate |
| differenze tra awk e gawk, vettore PROCINFO: | | Variabili auto-assegnate |
| differenze tra awk e gawk, variabili RS/RT: | | Variabili auto-assegnate |
| differenze tra awk e gawk, vettore SYMTAB: | | Variabili auto-assegnate |
| differenze tra awk e gawk, variabili ARGC/ARGV: | | ARGC e ARGV |
| differenze tra awk e gawk, elementi dei vettori, eliminazione: | | Cancellazione |
| differenze tra awk e gawk, argomenti di funzione (gawk): | | Chiamare funzioni predefinite |
| differenze tra awk e gawk, funzione length(): | | Funzioni per stringhe |
| differenze tra awk e gawk, funzione match(): | | Funzioni per stringhe |
| differenze tra awk e gawk, funzione split(): | | Funzioni per stringhe |
| differenze tra awk e gawk, chiamata indiretta di funzione: | | Chiamate indirette |
| differenze tra awk e gawk, variabile BINMODE: | | Uso su PC |
| dinamiche, estensioni: | | Estensioni dinamiche |
| directory, ricerca di file sorgente: | | AWKPATH (Variabile) |
| directory, ricerca di estensioni caricabili: | | AWKLIBPATH (Variabile) |
| directory, riga di comando: | | Directory su riga di comando |
| directory, ricerca: | | Esercizi sui programmi |
| direttiva, @include: | | Includere file |
| direttiva, @namespace: | | Cambiare lo spazio-dei-nomi |
| disabilitare punto d’interruzione: | | Controllo dei breakpoint |
| disable (comando del debugger): | | Controllo dei breakpoint |
| display (comando del debugger): | | Vedere e modificare dati |
| distinzione maiuscolo/minuscolo, gawk: | | Maiuscolo-Minuscolo |
| distinzione maiuscolo/minuscolo, programmi di esempio: | | Funzioni di libreria |
| distribuzione di gawk: | | Contenuti della distribuzione |
| dividere in un vettore una stringa: | | Funzioni per stringhe |
| divisione: | | Operatori aritmetici |
| do-while (istruzione), uso di espressioni regolari in: | | Uso di regexp |
| do-while (istruzione): | | Istruzione do |
| documentazione, online: | | Storia del manuale |
| documenti, ricerca in: | | Programma dupword |
| dollaro ($), operatore regexp: | | Dettagli sugli operatori di regexp |
| dollaro ($), operatore di campo $: | | Campi |
| dollaro ($), incrementare campi e vettori: | | Operatori di incremento |
| dollaro ($), operatore di campo $: | | Precedenza |
| doppia precisione: | | Aritmetica del computer |
| doppio apice ("), nei comandi shell: | | Protezione |
| doppio apice ("), in costanti regexp: | | Espressioni regolari calcolate |
| down (comando del debugger): | | Stack di esecuzione |
| Drepper, Ulrich: | | Ringraziamenti |
| due punti (:), operatore ?:: | | Precedenza |
| due punti (:), :: (separatore spazio-dei-nomi): | | Nomi qualificati |
| Duman, Patrice: | | Ringraziamenti |
| dump (comando del debugger): | | Comandi vari del debugger |
| dupword.awk (programma): | | Programma dupword |
|
| E | | |
|---|
| e (comando del debugger), (alias per enable): | | Controllo dei breakpoint |
| e commerciale (&), operatore &&: | | Operatori booleani |
| e commerciale (&), operatore &&: | | Precedenza |
| e commerciale (&), funzioni gsub()/gensub()/sub() e: | | Dettagli ostici |
| EBCDIC: | | Funzioni ordinali |
| EBCDIC: | | Intervalli e localizzazione |
| EBCDIC: | | Sommario della storia |
| editori di flusso: | | Campo intera riga |
| editori di flusso: | | Programma sed semplice |
| effetti collaterali, variabile FILENAME: | | Note su getline |
| effetti collaterali: | | Concatenazione |
| effetti collaterali, espressioni di assegnamento: | | Operatori di assegnamento |
| effetti collaterali: | | Operatori di incremento |
| effetti collaterali, operatori di decremento/incremento: | | Operatori di incremento |
| effetti collaterali: | | Operatori di incremento |
| effetti collaterali, operatori booleani: | | Operatori booleani |
| effetti collaterali, espressioni condizionali: | | Espressioni condizionali |
| effetti collaterali, chiamate di funzione: | | Chiamate di funzione |
| effetti collaterali, delle istruzioni: | | Panoramica sulle azioni |
| effetti collaterali, indicizzazione di vettori: | | Visitare elementi |
| effetti collaterali, funzione, match(): | | Funzioni per stringhe |
| effetti collaterali, funzione, asort(): | | Funzioni di ordinamento di vettori |
| effetti collaterali, funzione, asorti(): | | Funzioni di ordinamento di vettori |
| effettivo, ID di gruppo dell’utente di gawk: | | Variabili auto-assegnate |
| egrep (programma di utilità): | | Espressioni tra parentesi quadre |
| egrep (programma di utilità): | | Programma egrep |
| egrep.awk (programma): | | Programma egrep |
| elaborazione dati: | | Fondamenti ad alto livello |
| elementi, di collazione: | | Espressioni tra parentesi quadre |
| elementi, di collazione: | | Espressioni tra parentesi quadre |
| elementi, di vettore: | | Visitare elementi |
| elementi, di vettore, non assegnati: | | Visitare elementi |
| elementi, di vettore, vuoti: | | Visitare elementi |
| elementi, di vettore, inesistenti: | | Visitare elementi |
| elementi, di vettore, assegnare valori a: | | Impostare elementi |
| elementi, di vettore, visitare: | | Visitare un intero vettore |
| elementi, di vettore, ordine di accesso da parte dell’operatore in: | | Visitare un intero vettore |
| elementi, di vettore, eliminazione di: | | Cancellazione |
| elementi, di vettore, controlli lint per: | | Cancellazione |
| elencare, definizioni delle funzioni, nel debugger: | | Informazioni sul debugger |
| elencare, tutte le variabili locali, nel debugger: | | Informazioni sul debugger |
| elenchi di caratteri in espressioni regolari: | | Espressioni tra parentesi quadre |
| eliminare, elementi di vettori: | | Cancellazione |
| eliminare, interi vettori: | | Cancellazione |
| email, indirizzo per segnalare bug, bug-gawk@gnu.org: | | Indirizzo Bug |
| EMRED (codice di errore di fantasia): | | Reti TCP/IP |
| enable (comando del debugger): | | Controllo dei breakpoint |
| end (comando del debugger): | | Controllo esecuzione debugger |
| END (regola), criteri di ricerca booleani e: | | Espressioni come criteri di ricerca |
| END (regola): | | BEGIN/END |
| END (regola): | | Usare BEGIN/END |
| END (regola), operatori e: | | Usare BEGIN/END |
| END (regola), istruzione print e: | | I/O e BEGIN/END |
| END (regola), istruzioni next/nextfile e: | | I/O e BEGIN/END |
| END (regola), istruzioni next/nextfile e: | | Istruzione next |
| END (regola), istruzione exit e: | | Istruzione exit |
| END (regola), funzione definita dall’utente assert() e: | | Funzione assert |
| END (regola), profilazione e: | | Profilare |
| END (regola), ordine di esecuzione non alterato da @namespace: | | Cambiare lo spazio-dei-nomi |
| ENDFILE (regola), criteri di ricerca booleani e: | | Espressioni come criteri di ricerca |
| ENDFILE (regola): | | BEGINFILE/ENDFILE |
| ENDFILE (regola), ordine di esecuzione non alterato da @namespace: | | Cambiare lo spazio-dei-nomi |
| endgrent(), funzione di libreria C: | | Funzioni Group |
| endgrent(), funzione definita dall’utente: | | Funzioni Group |
| endpwent(), funzione di libreria C: | | Funzioni Passwd |
| endpwent(), funzione definita dall’utente: | | Funzioni Passwd |
| English, Steve: | | Funzionalità avanzate |
| ENVIRON (vettore): | | Variabili auto-assegnate |
| epoch, definizione di: | | Glossario |
| ERE (espressioni regolari estese): | | Espressioni tra parentesi quadre |
| ERRNO (variabile), con comando getline: | | Getline |
| ERRNO (variabile), con funzione close(): | | Chiusura file e pipe |
| ERRNO (variabile), con criterio di ricerca BEGINFILE: | | BEGINFILE/ENDFILE |
| ERRNO (variabile): | | Variabili auto-assegnate |
| ERRNO (variabile): | | Reti TCP/IP |
| errore, in input, possibilità di proseguire: | | Proseguire dopo errore in input |
| errore, in output: | | FD speciali |
| errori, gestione degli: | | FD speciali |
| esadecimali, numeri, abilitare l’interpretazione di: | | Opzioni |
| esadecimali, numeri: | | Numeri non-decimali |
| esaminare i campi: | | Campi |
| esecuzione di un solo passo, nel debugger: | | Controllo esecuzione debugger |
| esempio, di definizione di funzione: | | Esempio di funzione |
| esempio, di programma awk: | | Programmi di esempio |
| esempio, di sessione di debug: | | Esempio di sessione di debug |
| esempio, di estensione: | | Esempio di estensione |
| espansione della cronologia, nel debugger: | | Supporto per Readline |
| esponenziale: | | Funzioni numeriche |
| espressioni, tra parentesi quadre: | | Dettagli sugli operatori di regexp |
| espressioni, tra parentesi quadre, complementate: | | Dettagli sugli operatori di regexp |
| espressioni, di intervallo, (regexp): | | Dettagli sugli operatori di regexp |
| espressioni, tra parentesi quadre: | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, espressioni di intervallo: | | Espressioni tra parentesi quadre |
| espressioni, di intervallo, (regexp): | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, classi di caratteri: | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, elementi di collazione: | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, non-ASCII: | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, elementi di collazione: | | Espressioni tra parentesi quadre |
| espressioni, tra parentesi quadre, classi di equivalenza: | | Espressioni tra parentesi quadre |
| espressioni: | | Espressioni |
| espressioni, di assegnamento: | | Operatori di assegnamento |
| espressioni, di confronto: | | Tipi di variabile e confronti |
| espressioni, ricerca di corrispondenze: | | Tipi di variabile e confronti |
| espressioni, di confronto, stringa vs. regexp: | | Operatori di confronto |
| espressioni, booleane: | | Operatori booleani |
| espressioni, condizionali: | | Espressioni condizionali |
| espressioni, selezionare: | | Espressioni condizionali |
| espressioni, di ricerca: | | Criteri di ricerca e azioni |
| espressioni, di confronto, come criteri di ricerca: | | Espressioni come criteri di ricerca |
| espressioni, booleane, come criteri di ricerca: | | Espressioni come criteri di ricerca |
| espressioni regolari, espressioni di intervallo e: | | Opzioni |
| espressioni regolari: | | Espressioni regolari |
| espressioni regolari, come criteri di ricerca: | | Uso di regexp |
| espressioni regolari, operatori: | | Uso di regexp |
| espressioni regolari, costanti: | | Uso di regexp |
| espressioni regolari, operatori: | | Operatori di espressioni regolari |
| espressioni regolari, àncore nelle: | | Dettagli sugli operatori di regexp |
| espressioni regolari, operatori, precedenza degli: | | Dettagli sugli operatori di regexp |
| espressioni regolari, elenchi di caratteri in: | | Espressioni tra parentesi quadre |
| espressioni regolari, estese (ERE): | | Espressioni tra parentesi quadre |
| espressioni regolari, corrispondenza più a sinistra: | | Più lungo da sinistra |
| espressioni regolari, calcolate: | | Espressioni regolari calcolate |
| espressioni regolari, dinamiche: | | Espressioni regolari calcolate |
| espressioni regolari, dinamiche, contenenti dei ritorni a capo: | | Espressioni regolari calcolate |
| espressioni regolari, operatori, gawk: | | Operatori di regexp GNU |
| espressioni regolari, operatori, per parole: | | Operatori di regexp GNU |
| espressioni regolari, operatori, per buffer: | | Operatori di regexp GNU |
| espressioni regolari, gawk, opzioni sulla riga di comando: | | Operatori di regexp GNU |
| espressioni regolari, maiuscolo/minuscolo: | | Maiuscolo-Minuscolo |
| espressioni regolari, come separatore di record: | | awk divisione record |
| espressioni regolari, come separatore di campo: | | Separatori di campo |
| espressioni regolari, come separatore di campo: | | Separare campi con regexp |
| espressioni regolari, come criteri di ricerca: | | regexp come criteri di ricerca |
| espressioni regolari, come criteri di ricerca: | | Espressioni come criteri di ricerca |
| espressioni regolari, maiuscolo/minuscolo: | | Variabili modificabili dall'utente |
| espressioni regolari, ricerca di: | | Programma egrep |
| estensione, esempio: | | Esempio di estensione |
| estensione, chdir(): | | Esempio di estensione funzioni file |
| estensione, stat(): | | Esempio di estensione funzioni file |
| estensione, fts(): | | Esempio di estensione funzioni file |
| estensione, fnmatch(): | | Esempio di estensione Fnmatch |
| estensione, fork(): | | Esempio di estensione Fork |
| estensione, waitpid(): | | Esempio di estensione Fork |
| estensione, wait(): | | Esempio di estensione Fork |
| estensione, inplace(): | | Esempio di estensione Inplace |
| estensione, ord(): | | Esempio di estensione Ord |
| estensione, chr(): | | Esempio di estensione Ord |
| estensione, readdir(): | | Esempio di estensione Readdir |
| estensione, revoutput(): | | Esempio di estensione Revout |
| estensione, revtwoway(): | | Esempio di estensione Rev2way |
| estensione, writea(): | | Esempio di estensione Rwarray |
| estensione, reada(): | | Esempio di estensione Rwarray |
| estensione, readfile(): | | Esempio di estensione Readfile |
| estensione, gettimeofday(): | | Esempio di estensione Time |
| estensione, sleep(): | | Esempio di estensione Time |
| estensione, testext(): | | Esempio di estensione API Test |
| estensione API, numero di versione: | | Variabili auto-assegnate |
| estensione API, interazione con lo spazio-dei-nomi: | | Spazio-dei-nomi e funzionalità |
| estensione API: | | Descrizione dell'estensione API |
| estensione API, gawk, versione API: | | Versione dell'estensione |
| estensione API, variabili informative: | | Variabili informative di estens. API |
| estensioni, caricare: | | Opzioni |
| estensioni, caricare, @load (direttiva): | | Includere file |
| estensioni, caricare, direttiva @load: | | Caricare librerie condivise |
| estensioni, caricare, dinamicamente: | | Estensioni dinamiche |
| estensioni, allocare memoria per: | | Funzioni di allocazione memoria |
| estensioni, registrazione di: | | Funzioni di registrazione |
| estensioni, stampare messaggi dalle: | | Stampare messaggi |
| estensioni, accesso alle variabili globali: | | Accedere alla tabella simboli |
| estensioni, manipolazione di vettori nelle: | | Manipolazione di vettori |
| estensioni, percorso di ricerca per: | | Trovare le estensioni |
| estensioni, come trovarle: | | Trovare le estensioni |
| estensioni, gawk, convenzioni di programmazione: | | Operazioni interne file |
| estensioni, distribuite con gawk: | | Esempi di estensione |
| estensioni, caricabili, Progetto gawkextlib: | | gawkextlib |
| estensioni, Brian Kernighan awk: | | BTL |
| estensioni, nella modalità compatibile di (gawk): | | POSIX/GNU |
| estensioni, in gawk, non in POSIX awk: | | POSIX/GNU |
| estensioni, Brian Kernighan awk: | | Estensioni comuni |
| estensioni, mawk: | | Estensioni comuni |
| estensioni comuni, \x (sequenza di protezione): | | Sequenze di protezione |
| estensioni comuni, RS come espressione regolare: | | gawk divisione record |
| estensioni comuni, campi di un solo carattere: | | Campi di un solo carattere |
| estensioni comuni, file speciale /dev/stdin: | | FD speciali |
| estensioni comuni, file speciale /dev/stdout: | | FD speciali |
| estensioni comuni, file speciale /dev/stderr: | | FD speciali |
| estensioni comuni, operatore **: | | Operatori aritmetici |
| estensioni comuni, operatore **=: | | Operatori di assegnamento |
| estensioni comuni, operatore **=: | | Operatori di assegnamento |
| estensioni comuni, delete per eliminare interi vettori: | | Cancellazione |
| estensioni comuni, length() applicato a un vettore: | | Funzioni per stringhe |
| estensioni comuni, funzione fflush(): | | Funzioni di I/O |
| estensioni comuni, parola chiave func: | | Sintassi delle definizioni |
| estensioni comuni, variabile BINMODE: | | Uso su PC |
| estese, opzioni: | | Riga di comando |
| estrarre programma da file sorgente Texinfo: | | Programma extract |
| estrazione di stringhe marcate (internazionalizzazione): | | Estrazione di stringhe |
| etichette per lettera, stampare: | | Programma labels |
| eval (comando del debugger): | | Vedere e modificare dati |
| exit (comando del debugger): | | Comandi vari del debugger |
| exit (istruzione): | | Istruzione exit |
| exit (istruzione), codice di ritorno di gawk, in VMS: | | Esecuzione su VMS |
| exp() (funzione): | | Funzioni numeriche |
| expand (programma): | | Molto semplice |
| Expat, libreria per analizzare XML: | | gawkextlib |
| extract.awk (programma): | | Programma extract |
|
| F | | |
|---|
| f (comando del debugger), (alias per frame): | | Stack di esecuzione |
| falso, valore logico (zero o stringa nulla): | | Valori di verità |
| FDL (Free Documentation License): | | Licenza per Documentazione Libera GNU (FDL) |
| Fenlason, Jay: | | Storia |
| Fenlason, Jay: | | Contributori |
| fflush() (funzione): | | Funzioni di I/O |
| FIELDWIDTHS (variabile): | | Dati di lunghezza fissa |
| FIELDWIDTHS (variabile): | | Variabili modificabili dall'utente |
| file, programmi awk in: | | Lunghi |
| file, mail-list: | | File dati di esempio |
| file, inventory-shipped: | | File dati di esempio |
| file, awkvars.out: | | Opzioni |
| file, oggetto portabili, generare: | | Opzioni |
| file, passaggi multipli su: | | Altri argomenti |
| file, includere, direttiva @include: | | Includere file |
| file, trattato come un solo record: | | gawk divisione record |
| file, lettura dei record multiriga: | | Righe multiple |
| file, descrittori: | | FD speciali |
| file, speciali, /dev/…: | | FD speciali |
| file, in output, chiusura di: | | Chiusura file e pipe |
| file, elaborazione di, variabile ARGIND e: | | Variabili auto-assegnate |
| file, chiusura di: | | Funzioni di I/O |
| file, di registro (log), marcature temporali nei: | | Funzioni di tempo |
| file, gestione di: | | Gestione File Dati |
| file, gestione di, limiti dei file-dati: | | Funzione filetrans |
| file, inizializzazione e pulizia: | | Funzione filetrans |
| file, rileggere: | | Funzione rewind |
| file, non elaborare: | | Controllo di file |
| file, nomi di, assegnamenti di variabile visti come: | | Ignorare assegnamenti di variabili |
| file, delle password: | | Funzioni Passwd |
| file, dei gruppi: | | Funzioni Group |
| file, ricercare espressioni regolari nei: | | Programma egrep |
| file, suddividere: | | Programma split |
| file, multipli, duplicare l’output su: | | Programma tee |
| file, Texinfo, estrarre programma da: | | Programma extract |
| file, sorgente, percorso di ricerca per: | | Esercizi sui programmi |
| file, speciali, /inet/… (in gawk): | | Reti TCP/IP |
| file, speciali, /inet4/… (in gawk): | | Reti TCP/IP |
| file, speciali, /inet6/… (in gawk): | | Reti TCP/IP |
| file, awkprof.out: | | Profilare |
| file, .pot: | | Utilizzare gettext |
| file, portable object template (.pot): | | Utilizzare gettext |
| file, .po: | | Utilizzare gettext |
| file, portable object (.po): | | Utilizzare gettext |
| file, .gmo: | | Utilizzare gettext |
| file, message object (.mo): | | Utilizzare gettext |
| file, .gmo, specificare la directory di: | | Utilizzare gettext |
| file, message object (.mo), specificare la directory di: | | Utilizzare gettext |
| file, .gmo, specificare la directory di: | | I18N per programmatore |
| file, message object (.mo), specificare la directory di: | | I18N per programmatore |
| file, .po: | | I18N per traduttore |
| file, portable object (.po): | | I18N per traduttore |
| file, .po, conversione in .mo: | | Esempio I18N |
| file, .mo, conversione da .po: | | Esempio I18N |
| file, portable object (.po), conversione in message object file: | | Esempio I18N |
| file, message object (.mo), conversione da portable object file: | | Esempio I18N |
| file, sorgente corrente, mostrare nel debugger: | | Informazioni sul debugger |
| FILENAME (variabile): | | Leggere file |
| FILENAME (variabile), impostare con getline: | | Note su getline |
| FILENAME (variabile): | | Variabili auto-assegnate |
| finish (comando del debugger): | | Controllo esecuzione debugger |
| Fish, Fred: | | Contributori |
| flag (indicatore), variabili di tipo: | | Operatori booleani |
| flag (indicatore), variabili di tipo: | | Programma tee |
| flusso, editori di: | | Programma sed semplice |
| fnmatch() (estensione): | | Esempio di estensione Fnmatch |
| FNR (variabile): | | Record |
| FNR (variabile): | | Variabili auto-assegnate |
| FNR (variabile), modifica di: | | Variabili auto-assegnate |
| for (istruzione): | | Istruzione for |
| for (istruzione), esecuzione di cicli su un vettore: | | Visitare un intero vettore |
| fork() (estensione): | | Esempio di estensione Fork |
| formato, numerico di output: | | OFMT |
| formato, stringa, marcature temporali: | | Funzioni di tempo |
| formato, stringa, data e ora: | | Funzioni di tempo |
| formato, specificatori di, funzione strftime() di gawk: | | Funzioni di tempo |
| formato, specificatori di posizione, frammisti a specificatori non standard: | | Ordinamento di printf |
| formattare, output: | | Printf |
| formattare, stringhe: | | Funzioni per stringhe |
| formattatore incredibilmente duttile (awf): | | Glossario |
| fornire una lista di tutte le variabili del programma: | | Opzioni |
| FPAT (variabile): | | Separazione in base al contenuto |
| FPAT (variabile): | | Variabili modificabili dall'utente |
| frame (comando del debugger): | | Stack di esecuzione |
| Free Documentation License (FDL): | | Licenza per Documentazione Libera GNU (FDL) |
| Free Software Foundation (FSF): | | Storia del manuale |
| Free Software Foundation (FSF): | | Scaricare |
| Free Software Foundation (FSF): | | Glossario |
| Free Software Foundation (FSF): | | Glossario |
| FreeBSD: | | Glossario |
| FS (variabile), l’opzione --field-separator e: | | Opzioni |
| FS (variabile), carattere TAB come: | | Opzioni |
| FS (variabile): | | Separatori di campo |
| FS (variabile), cambiare il valore della: | | Separatori di campo |
| FS (variabile), come separatore di campo: | | Separatori di campo di default |
| FS (variabile), contenente ^: | | Separare campi con regexp |
| FS (variabile), come stringa nulla: | | Campi di un solo carattere |
| FS (variabile), impostare da riga di comando: | | Separatori campo da riga di comando |
| FS (variabile), nei record multiriga: | | Righe multiple |
| FS (variabile): | | Variabili modificabili dall'utente |
| FS (variabile), eseguire programmi awk e: | | Programma cut |
| FSF (Free Software Foundation): | | Storia del manuale |
| FSF (Free Software Foundation): | | Scaricare |
| FSF (Free Software Foundation): | | Glossario |
| FSF (Free Software Foundation): | | Glossario |
| fts() (estensione): | | Esempio di estensione funzioni file |
| FUNCTAB (vettore): | | Variabili auto-assegnate |
| funzionalità, deprecate: | | Parti obsolete |
| funzionalità, non documentate: | | Non documentato |
| funzionalità, avanzate, campi di larghezza costante: | | Dimensione costante |
| funzionalità, avanzate, specificare il contenuto dei campi: | | Separazione in base al contenuto |
| funzionalità, avanzate, processi, comunicare con: | | I/O bidirezionale |
| funzionalità, avanzate, programmazione di rete: | | Reti TCP/IP |
| funzionalità, aggiungere a gawk: | | Usare operazioni interne file |
| funzionalità, aggiungere a gawk: | | Aggiungere codice |
| funzione, close(), portabilità: | | Chiusura file e pipe |
| funzione, close(), codice di ritorno: | | Chiusura file e pipe |
| funzione, sprintf() (variabile) OFMT e: | | Variabili modificabili dall'utente |
| funzione, split(), eliminazione di elementi di vettori: | | Cancellazione |
| funzione, predefinita: | | Funzioni |
| funzione, match(), variabili RSTART/RLENGTH: | | Funzioni per stringhe |
| funzione, match(), effetti collaterali: | | Funzioni per stringhe |
| funzione, sub(), argomenti di: | | Funzioni per stringhe |
| funzione, gsub(), argomenti di: | | Funzioni per stringhe |
| funzione, sub(), protezione caratteri: | | Dettagli ostici |
| funzione, gsub(), protezione caratteri: | | Dettagli ostici |
| funzione, gensub() (gawk), protezione caratteri: | | Dettagli ostici |
| funzione, esempio di definizione di: | | Esempio di funzione |
| funzione, indefinita, controlli lint per: | | Precisazioni sulle funzioni |
| funzione, puntatori a: | | Chiamate indirette |
| funzione, sprintf(), istruzioni print/printf e: | | Funzione round |
| funzione, asort() (gawk), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| funzione, asort() (gawk), effetti collaterali: | | Funzioni di ordinamento di vettori |
| funzione, asorti() (gawk), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| funzione, asorti() (gawk), effetti collaterali: | | Funzioni di ordinamento di vettori |
| funzione, sort(), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| funzione, asort(), effetti collaterali: | | Funzioni di ordinamento di vettori |
| funzione, asorti(), effetti collaterali: | | Funzioni di ordinamento di vettori |
| funzione, close(), pipe bidirezionali e: | | I/O bidirezionale |
| funzione, bindtextdomain() (gawk), portabilità e: | | Portabilità nell'I18N |
| funzione, dcgettext() (gawk), portabilità e: | | Portabilità nell'I18N |
| funzione, dcngettext() (gawk), portabilità e: | | Portabilità nell'I18N |
| funzione definita dall’utente, istruzioni next/nextfile e: | | Istruzione next |
| funzione definita dall’utente, istruzioni next/nextfile e: | | Istruzione nextfile |
| funzione definita dall’utente, bits2str(): | | Funzioni a livello di bit |
| funzione definita dall’utente: | | Funzioni definite dall'utente |
| funzione definita dall’utente, rev(): | | Esempio di funzione |
| funzione definita dall’utente, ctime(): | | Esempio di funzione |
| funzione definita dall’utente, chiamare: | | Chiamata di una funzione |
| funzione definita dall’utente, libreria di: | | Funzioni di libreria |
| funzione definita dall’utente, assert(): | | Funzione assert |
| funzione definita dall’utente, round(): | | Funzione round |
| funzione definita dall’utente, cliff_rand(): | | Funzione random Cliff |
| funzione definita dall’utente, ord(): | | Funzioni ordinali |
| funzione definita dall’utente, chr(): | | Funzioni ordinali |
| funzione definita dall’utente, _ord_init(): | | Funzioni ordinali |
| funzione definita dall’utente, join(): | | Funzione join |
| funzione definita dall’utente, getlocaltime(): | | Funzione getlocaltime |
| funzione definita dall’utente, readfile(): | | Funzione readfile |
| funzione definita dall’utente, a_inizio_file(): | | Funzione filetrans |
| funzione definita dall’utente, a_fine_file(): | | Funzione filetrans |
| funzione definita dall’utente, rewind(): | | Funzione rewind |
| funzione definita dall’utente, getopt(): | | Funzione getopt |
| funzione definita dall’utente, getopt(): | | Funzione getopt |
| funzione definita dall’utente, getpwent(): | | Funzioni Passwd |
| funzione definita dall’utente, _pw_init(): | | Funzioni Passwd |
| funzione definita dall’utente, getpwnam(): | | Funzioni Passwd |
| funzione definita dall’utente, getpwuid(): | | Funzioni Passwd |
| funzione definita dall’utente, getpwent(): | | Funzioni Passwd |
| funzione definita dall’utente, endpwent(): | | Funzioni Passwd |
| funzione definita dall’utente, getgrent(): | | Funzioni Group |
| funzione definita dall’utente, _gr_init(): | | Funzioni Group |
| funzione definita dall’utente, getgrnam(): | | Funzioni Group |
| funzione definita dall’utente, getgrgid(): | | Funzioni Group |
| funzione definita dall’utente, getgruser(): | | Funzioni Group |
| funzione definita dall’utente, getgrent(): | | Funzioni Group |
| funzione definita dall’utente, endgrent(): | | Funzioni Group |
| funzione definita dall’utente, walk_array(): | | Visitare vettori |
| funzione definita dall’utente, conteggi, in un profilo: | | Profilare |
| funzione della shell, gawkpath_default: | | File da usare a inizio sessione |
| funzione della shell, gawkpath_prepend: | | File da usare a inizio sessione |
| funzione della shell, gawkpath_append: | | File da usare a inizio sessione |
| funzione della shell, gawklibpath_default: | | File da usare a inizio sessione |
| funzione della shell, gawklibpath_prepend: | | File da usare a inizio sessione |
| funzione della shell, gawklibpath_append: | | File da usare a inizio sessione |
| funzione di libreria C, assert(): | | Funzione assert |
| funzione di libreria C, getopt(): | | Funzione getopt |
| funzione di libreria C, getpwent(): | | Funzioni Passwd |
| funzione di libreria C, getpwnam(): | | Funzioni Passwd |
| funzione di libreria C, getpwuid(): | | Funzioni Passwd |
| funzione di libreria C, getpwent(): | | Funzioni Passwd |
| funzione di libreria C, endpwent(): | | Funzioni Passwd |
| funzione di libreria C, getgrent(): | | Funzioni Group |
| funzione di libreria C, getgrnam(): | | Funzioni Group |
| funzione di libreria C, getgrgid(): | | Funzioni Group |
| funzione di libreria C, getgruser(): | | Funzioni Group |
| funzione di libreria C, getgrent(): | | Funzioni Group |
| funzione di libreria C, endgrent(): | | Funzioni Group |
| funzione di libreria C, getaddrinfo(): | | Reti TCP/IP |
| funzione di libreria C, textdomain(): | | Utilizzare gettext |
| funzione di libreria C, bindtextdomain(): | | Utilizzare gettext |
| funzione di libreria C, gettext(): | | Utilizzare gettext |
| funzioni, predefinite: | | Chiamate di funzione |
| funzioni, predefinite, ordine di valutazione: | | Chiamare funzioni predefinite |
| funzioni, numeriche: | | Funzioni numeriche |
| funzioni, di manipolazione di stringhe: | | Funzioni per stringhe |
| funzioni, di input/output: | | Funzioni di I/O |
| funzioni, di tempo: | | Funzioni di tempo |
| funzioni, per la manipolazione di bit: | | Funzioni a livello di bit |
| funzioni, di traduzione di stringhe: | | Funzioni di internazionalizzazione |
| funzioni, definizione di: | | Sintassi delle definizioni |
| funzioni, nomi di: | | Sintassi delle definizioni |
| funzioni, convenzioni di programmazione, nella scrittura di: | | Sintassi delle definizioni |
| funzioni, ricorsive: | | Sintassi delle definizioni |
| funzioni, vettori come parametri di: | | Parametri per valore/riferimento |
| funzioni, indefinite: | | Precisazioni sulle funzioni |
| funzioni, di libreria: | | Funzioni di libreria |
| funzioni, libreria di, vettori associativi e: | | Nomi di variabili di libreria |
| funzioni, libreria di, asserzioni: | | Funzione assert |
| funzioni, libreria di, arrotondamento di numeri: | | Funzione round |
| funzioni, libreria di, numeri casuali Cliff: | | Funzione random Cliff |
| funzioni, libreria di, valori di carattere come numeri: | | Funzioni ordinali |
| funzioni, libreria di, trasformare vettori in stringhe: | | Funzione join |
| funzioni, libreria di, gestione delle ore del giorno: | | Funzione getlocaltime |
| funzioni, libreria di, gestire file di dati: | | Gestione File Dati |
| funzioni, libreria di, opzioni sulla riga di comando: | | Funzione getopt |
| funzioni, di libreria C: | | Funzione getopt |
| funzioni, libreria di, leggere la lista degli utenti: | | Funzioni Passwd |
| funzioni, libreria di, leggere la lista dei gruppi: | | Funzioni Group |
| funzioni, libreria di, programma di esempio per usare una: | | Programma igawk |
|
| G | | |
|---|
| G., Daniel Richard: | | Ringraziamenti |
| G., Daniel Richard: | | Manutentori |
| Garfinkle, Scott: | | Contributori |
| gawk: | | Prefazione |
| gawk, awk e: | | Prefazione |
| gawk, uso di: | | Prefazione |
| gawk, awk e: | | Questo manuale |
| gawk, ritorno a capo: | | Istruzioni/Righe |
| gawk, estensioni, disabilitare: | | Opzioni |
| gawk, versione di, stampa informazioni su: | | Opzioni |
| gawk, ARGIND (variabile) in: | | Altri argomenti |
| gawk, PROCINFO (vettore) vettori in: | | Altri argomenti |
| gawk, sequenze di protezione: | | Sequenze di protezione |
| gawk, sequenze di protezione: | | Sequenze di protezione |
| gawk, espressioni regolari, precedenza: | | Dettagli sugli operatori di regexp |
| gawk, espressioni di intervallo e: | | Espressioni di intervallo |
| gawk, classi di caratteri e: | | Espressioni tra parentesi quadre |
| gawk, espressioni regolari, operatori: | | Operatori di regexp GNU |
| gawk, operatore limite-di-parola: | | Operatori di regexp GNU |
| gawk, opzioni sulla riga di comando, ed espressioni regolari: | | Operatori di regexp GNU |
| gawk, espressioni regolari, distinzione maiuscolo/minuscolo: | | Maiuscolo-Minuscolo |
| gawk, variabile, IGNORECASE in: | | Maiuscolo-Minuscolo |
| gawk, variabile, RT in: | | awk divisione record |
| gawk, variabile, RT in: | | gawk divisione record |
| gawk, variabile, FIELDWIDTHS in: | | Dati di lunghezza fissa |
| gawk, variabile, FPAT in: | | Separazione in base al contenuto |
| gawk, separazione in campi e: | | Controllare la creazione di campi |
| gawk, variabile, RT in: | | Righe multiple |
| gawk, variabile, ERRNO in: | | Getline |
| gawk, problemi di implementazione, limiti: | | Note su getline |
| gawk, caratteri di controllo del formato: | | Lettere di controllo |
| gawk, caratteri di controllo del formato: | | Lettere di controllo |
| gawk, problemi di implementazione, pipe: | | Ridirezione |
| gawk, nomi di file in: | | File speciali |
| gawk, variabile, ERRNO in: | | Chiusura file e pipe |
| gawk, numeri ottali e: | | Numeri non-decimali |
| gawk, numeri esadecimali e: | | Numeri non-decimali |
| gawk, costanti regexp e: | | Costanti regexp normali |
| gawk, continuazione di riga in: | | Espressioni condizionali |
| gawk, variabile, ERRNO in: | | BEGINFILE/ENDFILE |
| gawk, break (istruzione) in: | | Istruzione break |
| gawk, continue (istruzione) in: | | Istruzione continue |
| gawk, variabili predefinite e: | | Variabili predefinite |
| gawk, variabile, FIELDWIDTHS in: | | Variabili modificabili dall'utente |
| gawk, variabile, FPAT in: | | Variabili modificabili dall'utente |
| gawk, separatore di campo e: | | Variabili modificabili dall'utente |
| gawk, variabile, IGNORECASE in: | | Variabili modificabili dall'utente |
| gawk, variabile, LINT in: | | Variabili modificabili dall'utente |
| gawk, variabile, TEXTDOMAIN in: | | Variabili modificabili dall'utente |
| gawk, variabile, ERRNO in: | | Variabili auto-assegnate |
| gawk, vettore, FUNCTAB in: | | Variabili auto-assegnate |
| gawk, vettore, PROCINFO in: | | Variabili auto-assegnate |
| gawk, versione di: | | Variabili auto-assegnate |
| gawk, variabile, RT in: | | Variabili auto-assegnate |
| gawk, vettore, SYMTAB in: | | Variabili auto-assegnate |
| gawk, variabile, IGNORECASE in: | | Introduzione ai vettori |
| gawk, argomenti di funzione e: | | Chiamare funzioni predefinite |
| gawk, variabile, IGNORECASE in: | | Funzioni per stringhe |
| gawk, data e ora (marcature temporali): | | Funzioni di tempo |
| gawk, vettore, PROCINFO in: | | Funzioni di tempo |
| gawk, operazioni sui bit in: | | Funzioni a livello di bit |
| gawk, funzioni di traduzione di stringhe: | | Funzioni di internazionalizzazione |
| gawk, funzionalità avanzate: | | Funzionalità avanzate |
| gawk, variabile, IGNORECASE in: | | Funzioni di ordinamento di vettori |
| gawk, vettore, PROCINFO in: | | I/O bidirezionale |
| gawk, variabile, ERRNO in: | | Reti TCP/IP |
| gawk, programma, profilazione dinamica: | | Profilare |
| gawk, profilare programmi: | | Profilare |
| gawk, internazionalizzazione e: | | Internazionalizzazione |
| gawk, aggiungere funzionalità a: | | Usare operazioni interne file |
| gawk, lista di contributori a: | | Contributori |
| gawk, installare: | | Installazione |
| gawk, codice sorgente, ottenere il: | | Scaricare |
| gawk, distribuzione di: | | Contenuti della distribuzione |
| gawk, e l’intelligenza artificiale: | | Contenuti della distribuzione |
| gawk, configurazione, opzioni di: | | Ulteriori opzioni di configurazione |
| gawk, configurazione di: | | Filosofia della configurazione |
| gawk, versione MS-Windows di: | | Uso su PC |
| gawk, versione VMS di: | | Installazione su VMS |
| gawk, problemi di implementazione: | | Note |
| gawk, problemi di implementazione, compatibilità all’indietro: | | Modalità di compatibilità |
| gawk, problemi di implementazione, debug: | | Modalità di compatibilità |
| gawk, aggiungere funzionalità a: | | Aggiungere codice |
| gawk, stile di codifica in: | | Aggiungere codice |
| gawk: | | Prefazione |
| gawkextlib (Progetto): | | gawkextlib |
| gawklibpath_append (funzione della shell): | | File da usare a inizio sessione |
| gawklibpath_default (funzione della shell): | | File da usare a inizio sessione |
| gawklibpath_prepend (funzione della shell): | | File da usare a inizio sessione |
| gawkpath_append (funzione della shell): | | File da usare a inizio sessione |
| gawkpath_default (funzione della shell): | | File da usare a inizio sessione |
| gawkpath_prepend (funzione della shell): | | File da usare a inizio sessione |
| GAWK_LOCALE_DIR (variabile d’ambiente): | | Utilizzare gettext |
| GAWK_READ_TIMEOUT (variabile d’ambiente): | | Timeout in lettura |
| GAWK_SOCK_RETRIES (variabile d’ambiente): | | Continuazione dopo errori |
| generare data e ora: | | Funzioni di tempo |
| gensub() (funzione gawk): | | Costanti regexp normali |
| gensub() (funzione gawk): | | Funzioni per stringhe |
| gensub() (funzione gawk), protezione caratteri: | | Dettagli ostici |
| gestione di file: | | Gestione File Dati |
| gestione errori: | | FD speciali |
| gestione errori, variabile ERRNO e: | | Variabili auto-assegnate |
| getaddrinfo(), funzione di libreria C: | | Reti TCP/IP |
| getgrent(), funzione di libreria C: | | Funzioni Group |
| getgrent(), funzione definita dall’utente: | | Funzioni Group |
| getgrent(), funzione di libreria C: | | Funzioni Group |
| getgrent(), funzione definita dall’utente: | | Funzioni Group |
| getgrgid(), funzione di libreria C: | | Funzioni Group |
| getgrgid(), funzione definita dall’utente: | | Funzioni Group |
| getgrnam(), funzione di libreria C: | | Funzioni Group |
| getgrnam(), funzione definita dall’utente: | | Funzioni Group |
| getgruser(), funzione di libreria C: | | Funzioni Group |
| getgruser(), funzione definita dall’utente: | | Funzioni Group |
| getline (comando): | | Leggere file |
| getline (comando), input esplicito con: | | Getline |
| getline (comando), codice di ritorno: | | Getline |
| getline (comando), in una variabile: | | Getline variabile |
| getline (comando), da un file: | | Getline file |
| getline (comando), coprocessi, usare da: | | Getline coprocesso |
| getline (comando), variabile FILENAME e: | | Note su getline |
| getline (comando), varianti: | | Sommario di getline |
| getline (comando), coprocessi, usare da: | | Chiusura file e pipe |
| getline (comando), criteri di ricerca BEGINFILE/ENDFILE e: | | BEGINFILE/ENDFILE |
| getline (comando), risoluzione di problemi: | | Controllo di file |
| getline (comando), funzione definita dall’utente, _pw_init(): | | Funzioni Passwd |
| getline (comando), funzione definita dall’utente, _gr_init(): | | Funzioni Group |
| getline (comando), stalli e: | | I/O bidirezionale |
| getlocaltime(), funzione definita dall’utente: | | Funzione getlocaltime |
| getopt(), funzione di libreria C: | | Funzione getopt |
| getopt(), funzione definita dall’utente: | | Funzione getopt |
| getopt(), funzione definita dall’utente: | | Funzione getopt |
| getpwent(), funzione di libreria C: | | Funzioni Passwd |
| getpwent(), funzione definita dall’utente: | | Funzioni Passwd |
| getpwent(), funzione di libreria C: | | Funzioni Passwd |
| getpwent(), funzione definita dall’utente: | | Funzioni Passwd |
| getpwnam(), funzione di libreria C: | | Funzioni Passwd |
| getpwnam(), funzione definita dall’utente: | | Funzioni Passwd |
| getpwuid(), funzione di libreria C: | | Funzioni Passwd |
| getpwuid(), funzione definita dall’utente: | | Funzioni Passwd |
| gettext, libreria: | | Utilizzare gettext |
| gettext, libreria, categorie di localizzazione: | | Utilizzare gettext |
| gettext(), funzione di libreria C: | | Utilizzare gettext |
| gettimeofday() (estensione): | | Esempio di estensione Time |
| Git, uso per il codice sorgente di gawk: | | File derivati |
| git (programma di utilità): | | gawkextlib |
| git (programma di utilità): | | Accedere ai sorgenti |
| git (programma di utilità): | | Aggiungere codice |
| globali, variabili, per funzioni di libreria: | | Nomi di variabili di libreria |
| GNITS mailing list: | | Ringraziamenti |
| GNU, progetto: | | Storia del manuale |
| GNU, opzioni estese sulla riga di comando: | | Riga di comando |
| GNU, opzioni estese sulla riga di comando: | | Opzioni |
| GNU, opzioni estese sulla riga di comando, stampare una lista di: | | Opzioni |
| GNU, General Public License: | | Glossario |
| GNU, Lesser General Public License: | | Glossario |
| GNU, Free Documentation License: | | Licenza per Documentazione Libera GNU (FDL) |
| GNU awk: | | Prefazione |
| GNU/Linux: | | Storia del manuale |
| GNU/Linux: | | Esempio I18N |
| GNU/Linux: | | Glossario |
| Go, implementazione di awk: | | Altre versioni |
| Go, linguaggio di programmazione: | | Altre versioni |
| goawk: | | Altre versioni |
| goawk, sorgente di: | | Altre versioni |
| Gordon, Assaf: | | Contributori |
| GPL (General Public License): | | Storia del manuale |
| GPL (General Public License), stampare: | | Opzioni |
| GPL (General Public License): | | Glossario |
| grcat (programma C): | | Funzioni Group |
| Grigera, Juan: | | Contributori |
| gruppi, Unix supplementari visualizzati in gawk: | | Variabili auto-assegnate |
| gruppi, lista dei, leggere la: | | Funzioni Group |
| gruppi, informazioni sui: | | Funzioni Group |
| gruppi, file dei: | | Funzioni Group |
| gruppo di discussione comp.lang.awk: | | Usenet |
| gsub() (funzione): | | Costanti regexp normali |
| gsub() (funzione): | | Funzioni per stringhe |
| gsub() (funzione), argomenti di: | | Funzioni per stringhe |
| gsub() (funzione), protezione caratteri: | | Dettagli ostici |
| Guerrero, Juan Manuel: | | Ringraziamenti |
| Guerrero, Juan Manuel: | | Contributori |
| Guerrero, Juan Manuel: | | Manutentori |
| guidati-dai-dati, linguaggi di programmazione: | | Fondamenti ad alto livello |
|
| H | | |
|---|
| h (comando del debugger), (alias per help): | | Comandi vari del debugger |
| Hankerson, Darrel: | | Ringraziamenti |
| Hankerson, Darrel: | | Contributori |
| Haque, John: | | Contributori |
| Hartholz, Marshall: | | Ringraziamenti |
| Hartholz, Elaine: | | Ringraziamenti |
| Hasegawa, Isamu: | | Contributori |
| help (comando del debugger): | | Comandi vari del debugger |
| histsort.awk (programma): | | Programma riordino diario |
| Hughes, Phil: | | Ringraziamenti |
| HUP (segnale), per profilazione dinamica: | | Profilare |
|
| I | | |
|---|
| i (comando del debugger), (alias per info): | | Informazioni sul debugger |
| id (programma di utilità): | | Programma id |
| ID di gruppo dell’utente gawk: | | Variabili auto-assegnate |
| ID effettivo dell’utente di gawk: | | Variabili auto-assegnate |
| id.awk (programma): | | Programma id |
| identificativi in un programma: | | Variabili auto-assegnate |
| if (istruzione), uso di espressioni regolari in: | | Uso di regexp |
| if (istruzione), azioni, modificabili: | | Intervalli |
| if (istruzione): | | Istruzione if |
| igawk.sh (programma): | | Programma igawk |
| ignorare un punto d’interruzione: | | Controllo dei breakpoint |
| ignore (comando del debugger): | | Controllo dei breakpoint |
| IGNORECASE (variabile), con operatori ~ e !~: | | Maiuscolo-Minuscolo |
| IGNORECASE (variabile): | | Variabili modificabili dall'utente |
| IGNORECASE (variabile), indici dei vettori e: | | Introduzione ai vettori |
| IGNORECASE (variabile), programmi di esempio: | | Funzioni di libreria |
| IGNORECASE (variabile), funzioni di ordinamento dei vettori e: | | Funzioni di ordinamento di vettori |
| Illumos, awk conforme a POSIX e: | | Altre versioni |
| implementazione, problemi di, gawk, limiti: | | Note su getline |
| implementazione, di awk: | | Altre versioni |
| implementazione, di awk in Java: | | Altre versioni |
| implicito, spazio-dei-nomi: | | Cambiare lo spazio-dei-nomi |
| impostare, directory con catalogo messaggi tradotti: | | Funzioni di internazionalizzazione |
| impostare, un punto d’interruzione: | | Controllo dei breakpoint |
| impostare, un punto d’osservazione: | | Vedere e modificare dati |
| in (operatore): | | Operatori di confronto |
| in (operatore): | | Precedenza |
| in (operatore): | | Istruzione for |
| in (operatore), verificare se un elemento esiste in un vettore: | | Visitare elementi |
| in (operatore), uso in cicli: | | Visitare un intero vettore |
| in (operatore), ordine di accesso dei vettori: | | Visitare un intero vettore |
| in (operatore), verificare se un elemento esiste in un vettore multidimensionale: | | Vettori multidimensionali |
| includere file, direttiva @include: | | Includere file |
| incremento, operatori di: | | Operatori di incremento |
| indefinite, funzioni: | | Precisazioni sulle funzioni |
| index() (funzione): | | Funzioni per stringhe |
| indici di vettore, separatore di: | | Variabili modificabili dall'utente |
| indici di vettore: | | Introduzione ai vettori |
| indici di vettore, numeri come: | | Indici numerici di vettore |
| indici di vettore, variabili non inizializzate come: | | Indici non inizializzati |
| indici di vettore, stringhe nulle come: | | Indici non inizializzati |
| indici di vettore, multidimensionale: | | Vettori multidimensionali |
| indici di vettore, multidimensionale, visitare gli: | | Visitare vettori multidimensionali |
| indici di vettore, ordinamento in base agli: | | Funzioni per stringhe |
| indiretta, chiamata di funzione: | | Chiamate indirette |
| indiretta, chiamata di funzione, @-notazione: | | Chiamate indirette |
| indirizzo email per segnalare bug, bug-gawk@gnu.org: | | Indirizzo Bug |
| individuare, la stringa più lunga da sinistra: | | Righe multiple |
| individuare, tramite espressioni: | | Tipi di variabile e confronti |
| individuare, la stringa nulla: | | Funzioni per stringhe |
| info (comando del debugger): | | Informazioni sul debugger |
| informazioni di tipo monetario, localizzazione: | | Utilizzare gettext |
| inizializzazione, automatica: | | Maggiore sofisticazione |
| inizializzazione, della generazione di numeri casuali: | | Funzioni numeriche |
| inplace (estensione): | | Esempio di estensione Inplace |
| input, standard: | | Leggere dal terminale |
| input, eseguire awk senza usare: | | Leggere dal terminale |
| input, eseguire awk senza usare: | | Leggere dal terminale |
| input, esempi: | | File dati di esempio |
| input, assegnamenti di variabile e: | | Altri argomenti |
| input, leggere: | | Leggere file |
| input: | | Leggere file |
| input, suddividere in record: | | Record |
| input, record multiriga: | | Righe multiple |
| input: | | Righe multiple |
| input, esplicito: | | Getline |
| input, ridirezione dell’: | | Getline file |
| input, pipeline: | | Getline pipe |
| input, standard: | | FD speciali |
| input, chiusura: | | Chiusura file e pipe |
| input, contare elementi nel: | | Programma wc |
| input, dati non decimali: | | Dati non decimali |
| input, analizzatore di, personalizzato: | | Analizzatori di input |
| input/output, dalle regole BEGIN ed END: | | I/O e BEGIN/END |
| input/output, binario: | | Variabili modificabili dall'utente |
| input/output, funzioni di: | | Funzioni di I/O |
| input/output, bidirezionale: | | I/O bidirezionale |
| input/output, bufferizzazione: | | I/O bidirezionale |
| insiemi di caratteri (codifiche macchina di caratteri): | | Glossario |
| insonnia, cura per: | | Programma alarm |
| installare gawk: | | Installazione |
| installare gawk, su sistemi operativi per PC: | | Installazione su PC |
| installare gawk, su MS-Windows: | | Installazione binaria su PC |
| installare gawk, su Cygwin: | | Cygwin |
| installare gawk, su VMS: | | Installazione su VMS |
| INT (segnale) (MS-Windows): | | Profilare |
| int() (funzione): | | Funzioni numeriche |
| intelligenza artificiale, gawk e: | | Contenuti della distribuzione |
| interagire con altri programmi: | | Funzioni di I/O |
| interi, indici di vettore: | | Indici numerici di vettore |
| interi, senza segno: | | Aritmetica del computer |
| interi, a precisione arbitraria: | | Interi a precisione arbitraria |
| internazionalizzazione, localizzazione, classi di caratteri: | | Espressioni tra parentesi quadre |
| internazionalizzazione, localizzazione: | | Variabili modificabili dall'utente |
| internazionalizzazione: | | Funzioni di internazionalizzazione |
| internazionalizzazione, localizzazione: | | Internazionalizzazione |
| internazionalizzazione, localizzazione, gawk e: | | Internazionalizzazione |
| internazionalizzazione, di programmi awk: | | I18N e L10N |
| internazionalizzazione, di programmi awk: | | Utilizzare gettext |
| internazionalizzazione, localizzazione, categorie di localizzazione: | | Utilizzare gettext |
| internazionalizzazione, localizzazione, informazioni di tipo monetario: | | Utilizzare gettext |
| internazionalizzazione, localizzazione, simboli di monete: | | Utilizzare gettext |
| internazionalizzazione, di programmi awk: | | I18N per programmatore |
| internazionalizzazione, localizzazione, stringhe marcate: | | I18N per programmatore |
| internazionalizzazione, localizzazione, portabilità e: | | Portabilità nell'I18N |
| interpretatore awk incorporabile, codice sorgente: | | Altre versioni |
| interruzione visualizzazioni automatiche, nel debugger: | | Vedere e modificare dati |
| interruzioni di riga: | | Istruzioni/Righe |
| intervalli di ricerca: | | Intervalli |
| intervalli di ricerca, continuazione di riga e: | | Intervalli |
| isarray() (funzione gawk): | | Funzioni per i tipi |
| ISO, 8601 (standard per marcature temporali): | | Funzioni di tempo |
| ISO, 8859-1 (codifica caratteri): | | Glossario |
| ISO, Latin-1 (codifica caratteri): | | Glossario |
| ISO: | | Glossario |
| istruzione, print: | | Stampare |
| istruzione, printf: | | Stampare |
| istruzione, print, virgole, omettere: | | Esempi su print |
| istruzione, printf, colonne, allineamento: | | Esempi su print |
| istruzione, print, continuazione di riga e: | | Esempi su print |
| istruzione, printf: | | Printf |
| istruzione, printf, sintassi: | | Printf Fondamenti |
| istruzione, printf, lettere di controllo del formato: | | Lettere di controllo |
| istruzione, printf, modificatori: | | Modificatori di formato |
| istruzione, printf, specificatori di posizione: | | Modificatori di formato |
| istruzione, print: | | Ridirezione |
| istruzione, printf: | | Ridirezione |
| istruzione, print, operatori I/O in: | | Precedenza |
| istruzione, printf, operatori I/O in: | | Precedenza |
| istruzione, if: | | Istruzione if |
| istruzione, while: | | Istruzione while |
| istruzione, for: | | Istruzione for |
| istruzione, break: | | Istruzione break |
| istruzione, continue: | | Istruzione continue |
| istruzione, next: | | Istruzione next |
| istruzione, nextfile: | | Istruzione nextfile |
| istruzione, exit: | | Istruzione exit |
| istruzione, print, OFMT (variabile) e: | | Variabili modificabili dall'utente |
| istruzione, delete: | | Cancellazione |
| istruzione, return, in funzioni definite dall’utente: | | Istruzione return |
| istruzione, print, funzione sprintf() e: | | Funzione round |
| istruzione, printf, funzione sprintf() e: | | Funzione round |
| istruzione, printf, specificatori di posizione: | | Ordinamento di printf |
| istruzione, printf, specificatori di posizione, frammisti a formati standard: | | Ordinamento di printf |
| istruzioni, multiple: | | Istruzioni/Righe |
| istruzioni, effetti collaterali delle: | | Panoramica sulle azioni |
| istruzioni, tener traccia delle, nel debugger: | | Informazioni sul debugger |
| istruzioni composte, istruzioni di controllo e: | | Istruzioni |
| istruzioni di controllo: | | Istruzioni |
|
| J | | |
|---|
| Jacobs, Andrew: | | Funzioni Passwd |
| Jaegermann, Michal: | | Ringraziamenti |
| Jaegermann, Michal: | | Contributori |
| Jannick: | | Contributori |
| Java, implementazione di awk: | | Altre versioni |
| Java, linguaggio di programmazione: | | Glossario |
| jawk: | | Altre versioni |
| jedi, cavalieri: | | Non documentato |
| Johansen, Chris: | | Programma signature |
| join(), funzione definita dall’utente: | | Funzione join |
| JSON, RapidJson, libreria per analizzare: | | gawkextlib |
|
| K | | |
|---|
| Kahrs, Jürgen: | | Ringraziamenti |
| Kahrs, Jürgen: | | Contributori |
| Kasal, Stepan: | | Ringraziamenti |
| Kenobi, Obi-Wan: | | Non documentato |
| Kernighan, Brian: | | Storia |
| Kernighan, Brian: | | Convenzioni |
| Kernighan, Brian: | | Ringraziamenti |
| Kernighan, Brian: | | Getline pipe |
| Kernighan, Brian: | | Concatenazione |
| Kernighan, Brian: | | Funzioni di libreria |
| Kernighan, Brian: | | BTL |
| Kernighan, Brian: | | Contributori |
| Kernighan, Brian: | | Altre versioni |
| Kernighan, Brian: | | Fondamenti sui tipi di dati |
| Kernighan, Brian: | | Glossario |
| kill (comando), profilazione dinamica e: | | Profilare |
| Kwok, Conrad: | | Contributori |
|
| L | | |
|---|
| l (comando del debugger), (alias per list): | | Comandi vari del debugger |
| labels.awk (programma): | | Programma labels |
| LANG (variabile d’ambiente): | | Esempio I18N |
| Langston, Peter: | | Funzionalità avanzate |
| LANGUAGE (variabile d’ambiente): | | Utilizzare gettext |
| LANGUAGE (variabile d’ambiente): | | Esempio I18N |
| larghezza costante, campi di: | | Dimensione costante |
| LC_ALL (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_ALL (variabile d’ambiente): | | Esempio I18N |
| LC_COLLATE (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_CTYPE (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_MESSAGES (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_MESSAGES (variabile d’ambiente), categoria di localizzazione, funzione bindtextdomain() di (gawk): | | I18N per programmatore |
| LC_MESSAGES (variabile d’ambiente): | | Esempio I18N |
| LC_MONETARY (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_NUMERIC (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| LC_TIME (variabile d’ambiente), categoria di localizzazione: | | Utilizzare gettext |
| leggere, file in input: | | Leggere file |
| leggere, comandi da un file nel debugger: | | Informazioni sul debugger |
| leggibilità, di un file-dati, controllare la: | | Controllo di file |
| length() (funzione): | | Funzioni per stringhe |
| Lesser General Public License (LGPL): | | Glossario |
| LGPL (Lesser General Public License): | | Glossario |
| libmawk (interpretatore): | | Altre versioni |
| libreria di funzioni awk: | | Funzioni di libreria |
| libreria di funzioni awk, vettori associativi e: | | Nomi di variabili di libreria |
| libreria di funzioni awk, asserzioni: | | Funzione assert |
| libreria di funzioni awk, arrotondamento di numeri: | | Funzione round |
| libreria di funzioni awk, valori di carattere come numeri: | | Funzioni ordinali |
| libreria di funzioni awk, trasformare vettori in stringhe: | | Funzione join |
| libreria di funzioni awk, gestire ora del giorno (marcature temporali): | | Funzione getlocaltime |
| libreria di funzioni awk, gestire file di dati: | | Gestione File Dati |
| libreria di funzioni awk, opzioni sulla riga di comando: | | Funzione getopt |
| libreria di funzioni awk, leggere la lista degli utenti: | | Funzioni Passwd |
| libreria di funzioni awk, leggere la lista dei gruppi: | | Funzioni Group |
| libreria di funzioni awk, programma di esempio per usare una: | | Programma igawk |
| libreria gettext: | | Utilizzare gettext |
| libreria gettext, categorie di localizzazione: | | Utilizzare gettext |
| limitazioni, nei nomi di funzione: | | Sintassi delle definizioni |
| limitazioni, del debugger: | | Limitazioni |
| limite-di-parola, individuare il: | | Operatori di regexp GNU |
| limite-di-parola, operatore (gawk): | | Operatori di regexp GNU |
| linguaggi di programmazione, ricetta per: | | Storia |
| linguaggi di programmazione, guidati-dai-dati vs. procedurali: | | Per iniziare |
| linguaggi di programmazione, Go: | | Altre versioni |
| linguaggi di programmazione, guidati dai dati: | | Fondamenti ad alto livello |
| linguaggi di programmazione, Ada: | | Glossario |
| linguaggi di programmazione, Java: | | Glossario |
| lint, controlli, con programma vuoto: | | Riga di comando |
| lint, controlli, emissione di avvertimenti: | | Opzioni |
| lint, controlli POSIXLY_CORRECT (variabile d’ambiente): | | Opzioni |
| lint, controlli: | | Variabili modificabili dall'utente |
| lint, controlli, indici di vettori: | | Indici non inizializzati |
| lint, controlli, elementi di vettori: | | Cancellazione |
| lint, controlli, funzione indefinita: | | Precisazioni sulle funzioni |
| LINT (variabile): | | Variabili modificabili dall'utente |
| list (comando del debugger): | | Comandi vari del debugger |
| lista degli utenti, leggere la: | | Funzioni Passwd |
| lista dei gruppi, leggere la: | | Funzioni Group |
| locali, variabili, in una funzione: | | Campo di validità variabili |
| localizzazione, separatore decimale della: | | Opzioni |
| localizzazione, definizione di: | | Localizzazioni |
| localizzazione: | | I18N e L10N |
| localizzazione, categorie di: | | Utilizzare gettext |
| log (registro), file di, marcature temporali nei: | | Funzioni di tempo |
| log() (funzione): | | Funzioni numeriche |
| logaritmo: | | Funzioni numeriche |
| logico, valore, vero/falso: | | Valori di verità |
| logico, operatore: | | Operatori booleani |
| login, informazioni: | | Funzioni Passwd |
| lshift() (funzione gawk): | | Funzioni a livello di bit |
| lunghezza, di una stringa: | | Funzioni per stringhe |
| lunghezza, di un record in input: | | Funzioni per stringhe |
| lvalue/rvalue: | | Operatori di assegnamento |
|
| M | | |
|---|
| mailing list, GNITS: | | Ringraziamenti |
| maiuscolo/minuscolo, regexp e: | | Maiuscolo-Minuscolo |
| maiuscolo/minuscolo, confronti tra stringhe e: | | Variabili modificabili dall'utente |
| maiuscolo/minuscolo, regexp e: | | Variabili modificabili dall'utente |
| maiuscolo/minuscolo, distinzione, negli indici dei vettori: | | Introduzione ai vettori |
| maiuscolo/minuscolo, conversione da/a: | | Funzioni per stringhe |
| Malmberg, John: | | Ringraziamenti |
| Malmberg, John: | | Contributori |
| Malmberg, John: | | Manutentori |
| manipolazione di bit, funzioni per la: | | Funzioni a livello di bit |
| marcate, estrazione di stringhe (internazionalizzazione): | | Estrazione di stringhe |
| marcature temporali: | | Funzioni di tempo |
| marcature temporali, formato stringa: | | Funzioni di tempo |
| marcature temporali: | | Funzioni di tempo |
| marcature temporali, conversione date nelle: | | Funzioni di tempo |
| marcature temporali, formattate: | | Funzione getlocaltime |
| mark (bit di parità in ASCII): | | Funzioni ordinali |
| Marx, Groucho: | | Operatori di incremento |
| match() (funzione): | | Funzioni per stringhe |
| match() (funzione), variabili RSTART/RLENGTH: | | Funzioni per stringhe |
| match() (funzione), effetti collaterali: | | Funzioni per stringhe |
| mawk (programma di utilità): | | Sequenze di protezione |
| mawk (programma di utilità): | | Getline pipe |
| mawk (programma di utilità): | | Concatenazione |
| mawk (programma di utilità): | | Istruzione nextfile |
| mawk (programma di utilità): | | Altre versioni |
| McIlroy, Doug: | | Glossario |
| McPhee, Patrick: | | Contributori |
| memoria, allocare per estensioni: | | Funzioni di allocazione memoria |
| memoria tampone, scrivere su disco: | | Funzioni di I/O |
| meno (-), nomi di file che iniziano con: | | Opzioni |
| meno (-), -- marcatore della fine delle opzioni: | | Opzioni |
| meno (-), in espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| meno (-), operatore -=: | | Operatori di assegnamento |
| meno (-), operatore --: | | Operatori di incremento |
| meno (-), operatore --: | | Precedenza |
| meno (-), operatore -: | | Precedenza |
| meno (-), operatore -: | | Precedenza |
| meno (-), operatore -=: | | Precedenza |
| message object file (.mo): | | Utilizzare gettext |
| message object file (.mo), specificare la directory di: | | Utilizzare gettext |
| message object file (.mo), specificare la directory di: | | I18N per programmatore |
| message object file (.mo), conversione da portable object file: | | Esempio I18N |
| messaggi, stampare dalle estensioni: | | Stampare messaggi |
| messaggi tradotti, impostare directory con catalogo: | | Funzioni di internazionalizzazione |
| metacaratteri, sequenze di protezione per: | | Sequenze di protezione |
| metacaratteri, in espressioni regolari: | | Operatori di espressioni regolari |
| mktime() (funzione gawk): | | Funzioni di tempo |
| modalità compatibile di (gawk), specificare: | | Opzioni |
| modalità compatibile di (gawk), nomi di file: | | Avvertimenti speciali |
| modalità compatibile di (gawk), numeri ottali: | | Numeri non-decimali |
| modalità compatibile di (gawk), numeri esadecimali: | | Numeri non-decimali |
| modalità compatibile di (gawk), estensioni nella: | | POSIX/GNU |
| modalità POSIX: | | Opzioni |
| modalità POSIX: | | Opzioni |
| modalità POSIX: | | Dettagli sugli operatori di regexp |
| modalità POSIX: | | Sommario di Input |
| modalità POSIX: | | Avvertimenti speciali |
| modalità POSIX: | | Chiusura file e pipe |
| modalità POSIX: | | Costanti scalari |
| modalità POSIX: | | Localizzazione e conversioni |
| modalità POSIX: | | Confronto POSIX di stringhe |
| modalità POSIX: | | Confronto POSIX di stringhe |
| modalità POSIX: | | Funzioni per stringhe |
| modalità POSIX: | | Controllare visita vettori |
| modificabili dall’utente, variabili: | | Variabili modificabili dall'utente |
| modificatori, in specificatori di formato: | | Modificatori di formato |
| modulo, definizione di: | | Spazio-dei-nomi globale |
| modulo-troncamento, operazione di: | | Operatori aritmetici |
| monete, simboli di (nella localizzazione): | | Utilizzare gettext |
| monete, rappresentazioni di (nella localizzazione): | | Utilizzare gettext |
| Moore, Duncan: | | Note su getline |
| mostrare nel debugger, argomenti delle funzioni: | | Informazioni sul debugger |
| mostrare nel debugger, punti d’interruzione: | | Informazioni sul debugger |
| mostrare nel debugger, variabili locali: | | Informazioni sul debugger |
| mostrare nel debugger, nome del file sorgente corrente: | | Informazioni sul debugger |
| mostrare nel debugger, nome di tutti i file sorgente: | | Informazioni sul debugger |
| mostrare nel debugger, punti d’osservazione: | | Informazioni sul debugger |
| MPFR, controllare disponibilità: | | Controllare disponibilità MPFR |
| msgfmt (programma di utilità): | | Esempio I18N |
| multidimensionali, vettori: | | Vettori multidimensionali |
|
| N | | |
|---|
| n (comando del debugger), (alias per next): | | Trovare il bug |
| n (comando del debugger), (alias per next): | | Controllo esecuzione debugger |
| nascondere valori di variabile: | | Sintassi delle definizioni |
| Neacsu, Mircea: | | Altre versioni |
| NetBSD: | | Glossario |
| newsgroup comp.lang.awk: | | Usenet |
| next (comando del debugger): | | Trovare il bug |
| next (comando del debugger): | | Controllo esecuzione debugger |
| next (istruzione): | | Operatori booleani |
| next (istruzione), criteri di ricerca BEGIN/END e: | | I/O e BEGIN/END |
| next (istruzione), criteri di ricerca BEGINFILE/ENDFILE e: | | BEGINFILE/ENDFILE |
| next (istruzione): | | Istruzione next |
| next (istruzione), in funzione definita dall’utente: | | Istruzione next |
| next (istruzione), in funzioni definite dall’utente: | | Precisazioni sulle funzioni |
| next file (istruzione obsoleta): | | Storia delle funzionalità |
| nextfile (istruzione), criteri di ricerca BEGIN/END e: | | I/O e BEGIN/END |
| nextfile (istruzione), criteri di ricerca BEGINFILE/ENDFILE e: | | BEGINFILE/ENDFILE |
| nextfile (istruzione): | | Istruzione nextfile |
| nextfile (istruzione), in funzioni definite dall’utente: | | Istruzione nextfile |
| nexti (comando del debugger): | | Controllo esecuzione debugger |
| NF (variabile): | | Campi |
| NF (variabile), decremento: | | Cambiare i campi |
| NF (variabile): | | Variabili auto-assegnate |
| ni (comando del debugger), (alias for nexti): | | Controllo esecuzione debugger |
| noassign.awk (programma): | | Ignorare assegnamenti di variabili |
| nomi, di file, flussi standard in gawk: | | FD speciali |
| nomi, di file, nella modalità compatibile di gawk: | | Avvertimenti speciali |
| nomi, di file, distinguere: | | Variabili auto-assegnate |
| nomi, di funzione: | | Sintassi delle definizioni |
| nomi, di funzione, limitazioni nei: | | Sintassi delle definizioni |
| nomi, di vettore/variabile: | | Nomi di variabili di libreria |
| nomi, di funzione: | | Nomi di variabili di libreria |
| nomi, permessi, questioni sui: | | Nomi di variabili di libreria |
| nomi, di file, assegnamenti di variabile visti come: | | Ignorare assegnamenti di variabili |
| nomi, qualificati (in uno spazio-dei-nomi), definizione di: | | Nomi qualificati |
| nomi, di componente (in uno spazio-dei-nomi): | | Nomi qualificati |
| nomi, qualificati (in uno spazio-dei-nomi): | | Nomi qualificati |
| nomi, scritti in maiuscolo, sempre nello spazio-dei-nomi awk: | | Spazio-dei-nomi di default |
| nomi, regole per assegnarli, agli spazi-dei-nomi e ai loro componenti: | | Regole per i nomi |
| nomi, gestione (in uno spazio-dei-nomi): | | Gestione interna dei nomi |
| non documentate, funzionalità: | | Non documentato |
| non inizializzate, variabili, come indici di vettore: | | Indici non inizializzati |
| not (operatore logico-booleano): | | Operatori booleani |
| NR (variabile): | | Record |
| NR (variabile): | | Variabili auto-assegnate |
| NR (variabile), modifica di: | | Variabili auto-assegnate |
| nulle, stringhe: | | Valori di verità |
| nulle, stringhe, come indici di vettore: | | Indici non inizializzati |
| nulle, stringhe, eliminazione di elementi di un vettore e: | | Cancellazione |
| numeri, ottali: | | Numeri non-decimali |
| numeri, esadecimali: | | Numeri non-decimali |
| numeri, ottali, nella modalità compatibile di (gawk): | | Numeri non-decimali |
| numeri, esadecimali, nella modalità compatibile di (gawk): | | Numeri non-decimali |
| numeri, conversione in stringhe: | | Stringhe e numeri |
| numeri, conversione in stringhe: | | Variabili modificabili dall'utente |
| numeri, conversione in stringhe: | | Variabili modificabili dall'utente |
| numeri, come indici di vettore: | | Indici numerici di vettore |
| numeri, interi, come indici di vettore: | | Indici numerici di vettore |
| numeri, casuali, funzioni rand()/srand(): | | Funzioni numeriche |
| numeri, casuali, inizializzazione della generazione di: | | Funzioni numeriche |
| numeri, casuali, seme di: | | Funzioni numeriche |
| numeri, conversione in stringhe: | | Funzioni a livello di bit |
| numeri, visti come stringhe di bit: | | Funzioni a livello di bit |
| numeri, arrotondamento: | | Funzione round |
| numeri, casuali, generatore Cliff: | | Funzione random Cliff |
| numeri, come valori di carattere: | | Funzioni ordinali |
| numeri, interi, senza segno: | | Aritmetica del computer |
| numeri, in virgola mobile: | | Aritmetica del computer |
| numeri, interi, a precisione arbitraria: | | Interi a precisione arbitraria |
| numeri, in virgola mobile, VAX/VMS: | | Esecuzione su VMS |
| numeriche, costanti: | | Costanti scalari |
| numeriche, stringhe: | | Tipi di variabile |
| numeriche, funzioni: | | Funzioni numeriche |
| numerico, formato di output: | | OFMT |
| numero, di campi in un record: | | Campi non costanti |
| numero, di elementi in un vettore: | | Funzioni per stringhe |
|
| O | | |
|---|
| o (comando del debugger), (alias per option): | | Informazioni sul debugger |
| obsolete, funzionalità: | | Parti obsolete |
| OFMT (variabile): | | OFMT |
| OFMT (variabile): | | Stringhe e numeri |
| OFMT (variabile): | | Variabili modificabili dall'utente |
| OFS (variabile): | | Cambiare i campi |
| OFS (variabile): | | Variabili modificabili dall'utente |
| OpenBSD: | | Glossario |
| OpenSolaris: | | Altre versioni |
| operatore, di campo, $: | | Campi |
| operatore, di campo, dollaro come: | | Campi |
| operatore, in: | | Istruzione for |
| operatore, in, uso in cicli: | | Visitare un intero vettore |
| operatore, in, ordine di accesso dei vettori: | | Visitare un intero vettore |
| operatori, ricerca in stringhe: | | Uso di regexp |
| operatori, specifici per GNU: | | Operatori di regexp GNU |
| operatori, ricerca in stringhe, per buffer: | | Operatori di regexp GNU |
| operatori, limite-di-parola (gawk): | | Operatori di regexp GNU |
| operatori, input/output: | | Getline file |
| operatori, input/output: | | Getline pipe |
| operatori, input/output: | | Getline coprocesso |
| operatori, input/output: | | Ridirezione |
| operatori, input/output: | | Ridirezione |
| operatori, aritmetici: | | Operatori aritmetici |
| operatori, di stringa: | | Concatenazione |
| operatori, di assegnamento: | | Operatori di assegnamento |
| operatori, di assegnamento: | | Operatori di assegnamento |
| operatori, di assegnamento, ordine di valutazione: | | Operatori di assegnamento |
| operatori, di decremento/incremento: | | Operatori di incremento |
| operatori, precedenza degli: | | Operatori di incremento |
| operatori, relazionali: | | Tipi di variabile e confronti |
| operatori, di confronto: | | Operatori di confronto |
| operatori, booleani: | | Operatori booleani |
| operatori, logici: | | Operatori booleani |
| operatori, di cortocircuito: | | Operatori booleani |
| operatori, precedenza: | | Precedenza |
| operatori, input/output: | | Precedenza |
| operatori, input/output: | | Precedenza |
| operatori, input/output: | | Precedenza |
| operazione sui bit, AND: | | Funzioni a livello di bit |
| operazione sui bit, OR: | | Funzioni a livello di bit |
| operazione sui bit, XOR: | | Funzioni a livello di bit |
| operazione sui bit: | | Funzioni a livello di bit |
| operazione sui bit, AND: | | Funzioni a livello di bit |
| operazione sui bit, complemento: | | Funzioni a livello di bit |
| operazione sui bit, OR: | | Funzioni a livello di bit |
| operazione sui bit, XOR: | | Funzioni a livello di bit |
| option (comando del debugger): | | Informazioni sul debugger |
| opzione, -f: | | Lunghi |
| opzione, --lint: | | Riga di comando |
| opzione, -F: | | Opzioni |
| opzione, --field-separator: | | Opzioni |
| opzione, -f: | | Opzioni |
| opzione, --file: | | Opzioni |
| opzione, -v: | | Opzioni |
| opzione, --assign: | | Opzioni |
| opzione, -W: | | Opzioni |
| opzione, -b: | | Opzioni |
| opzione, --characters-as-bytes: | | Opzioni |
| opzione, -c: | | Opzioni |
| opzione, --tradizional: | | Opzioni |
| opzione, -C: | | Opzioni |
| opzione, --copyright: | | Opzioni |
| opzione, -d: | | Opzioni |
| opzione, --dump-variables: | | Opzioni |
| opzione, -D: | | Opzioni |
| opzione, --debug: | | Opzioni |
| opzione, -e: | | Opzioni |
| opzione, --source: | | Opzioni |
| opzione, -E: | | Opzioni |
| opzione, --exec: | | Opzioni |
| opzione, -g: | | Opzioni |
| opzione, --gen-pot: | | Opzioni |
| opzione, -h: | | Opzioni |
| opzione, --help: | | Opzioni |
| opzione, -i: | | Opzioni |
| opzione, --include: | | Opzioni |
| opzione, -l: | | Opzioni |
| opzione, --load: | | Opzioni |
| opzione, -L: | | Opzioni |
| opzione, --lint: | | Opzioni |
| opzione, -M: | | Opzioni |
| opzione, --bignum: | | Opzioni |
| opzione, -n: | | Opzioni |
| opzione, --non-decimal-data: | | Opzioni |
| opzione, -N: | | Opzioni |
| opzione, --use-lc-numeric: | | Opzioni |
| opzione, -o: | | Opzioni |
| opzione, --pretty-print: | | Opzioni |
| opzione, -O: | | Opzioni |
| opzione, --optimize: | | Opzioni |
| opzione, -p: | | Opzioni |
| opzione, --profile: | | Opzioni |
| opzione, -P: | | Opzioni |
| opzione, --posix: | | Opzioni |
| opzione, --traditional, e opzione --posix: | | Opzioni |
| opzione, --posix, e opzione --traditional: | | Opzioni |
| opzione, -r: | | Opzioni |
| opzione, --re-interval: | | Opzioni |
| opzione, -s: | | Opzioni |
| opzione, --no-optimize: | | Opzioni |
| opzione, -S: | | Opzioni |
| opzione, --sandbox: | | Opzioni |
| opzione, -t: | | Opzioni |
| opzione, --lint-old: | | Opzioni |
| opzione, -V: | | Opzioni |
| opzione, --version: | | Opzioni |
| opzione, -F, opzione -Ft imposta FS a TAB: | | Opzioni |
| opzione, -f, usi multipli: | | Opzioni |
| opzione, -e: | | Opzioni |
| opzione, -F, sulla riga di comando: | | Separatori campo da riga di comando |
| opzione, --sandbox, ridirezione dell’input con getline: | | Getline |
| opzione, --sandbox, ridirezione dell’output con print, printf: | | Ridirezione |
| opzione, -v: | | Opzioni di assegnamento |
| opzione, --sandbox, disabilitare la funzione system(): | | Funzioni di I/O |
| opzione, --dump-variables, uso per funzioni di libreria: | | Nomi di variabili di libreria |
| opzione, --non-decimal-data: | | Dati non decimali |
| opzione, --non-decimal-data, funzione strtonum() e: | | Dati non decimali |
| opzione, --profile: | | Profilare |
| opzione, --gen-pot: | | Estrazione di stringhe |
| opzione, --gen-pot: | | Estrazione di stringhe |
| opzioni, sulla riga di comando, per eseguire awk: | | Riga di comando |
| opzioni, estese GNU: | | Riga di comando |
| opzioni, sulla riga di comando: | | Opzioni |
| opzioni, estese GNU: | | Opzioni |
| opzioni, sulla riga di comando, fine delle: | | Opzioni |
| opzioni, stampare una lista di: | | Opzioni |
| opzioni, deprecate: | | Parti obsolete |
| opzioni, sulla riga di comando, elaborazione di: | | Funzione getopt |
| opzioni, sulla riga di comando, estrazione stringhe: | | Estrazione di stringhe |
| opzioni di configurazione, di gawk: | | Ulteriori opzioni di configurazione |
| opzioni di configurazione, --disable-extensions: | | Ulteriori opzioni di configurazione |
| opzioni di configurazione, --disable-lint: | | Ulteriori opzioni di configurazione |
| opzioni di configurazione, --disable-mpfr: | | Ulteriori opzioni di configurazione |
| opzioni di configurazione, --disable-nls: | | Ulteriori opzioni di configurazione |
| opzioni di configurazione, --enable-versioned-extension-dir: | | Ulteriori opzioni di configurazione |
| or (operatore logico-booleano): | | Operatori booleani |
| OR (operazione sui bit): | | Funzioni a livello di bit |
| OR (operazione sui bit): | | Funzioni a livello di bit |
| or() (funzione gawk): | | Funzioni a livello di bit |
| ora del giorno, gestire: | | Funzione getlocaltime |
| ord(), funzione definita dall’utente: | | Funzioni ordinali |
| ord() (estensione): | | Esempio di estensione Ord |
| ordinamento, di vettori: | | Funzioni per stringhe |
| ordinamento, di vettori, in base agli indici: | | Funzioni per stringhe |
| ordinare caratteri in lingue differenti: | | Utilizzare gettext |
| ordine di valutazione, concatenazione: | | Concatenazione |
| ordine di valutazione, funzioni: | | Chiamare funzioni predefinite |
| ORS (variabile): | | Separatori di output |
| ORS (variabile): | | Variabili modificabili dall'utente |
| ottali, numeri, abilitare l’interpretazione di: | | Opzioni |
| ottali, numeri: | | Numeri non-decimali |
| output, separatore di campo: | | Cambiare i campi |
| output, stampare: | | Stampare |
| output, record: | | Separatori di output |
| output, specificatore di formato, OFMT: | | OFMT |
| output, formattare: | | Printf |
| output, ridirezione: | | Ridirezione |
| output, a pipe: | | Ridirezione |
| output, standard: | | FD speciali |
| output, file in: | | Chiusura file e pipe |
| output, bufferizzazione: | | Funzioni di I/O |
| output, nella memoria tampone (buffer): | | Funzioni di I/O |
| output, bufferizzazione: | | Funzioni di I/O |
| output, duplicarlo su più file: | | Programma tee |
| output, processore di, personalizzato: | | Processori di output |
| output, processore di: | | Processori di output |
|
| P | | |
|---|
| p (comando del debugger), (alias per print): | | Trovare il bug |
| p (comando del debugger), (alias per print): | | Vedere e modificare dati |
| pacchetto, definizione di: | | Spazio-dei-nomi globale |
| Papadopoulos, Panos: | | Contributori |
| parent process ID del programma gawk: | | Variabili auto-assegnate |
| parentesi, quadre ([]), operatore regexp: | | Dettagli sugli operatori di regexp |
| parentesi, (()), operatore regexp: | | Dettagli sugli operatori di regexp |
| parentesi, graffe ({}), operatore regexp: | | Dettagli sugli operatori di regexp |
| parentesi, acuta sinistra (<), operatore < (I/O): | | Getline file |
| parentesi, acuta destra (>), operatore > (I/O): | | Ridirezione |
| parentesi, acuta destra (>), operatore >> (I/O): | | Ridirezione |
| parentesi, acuta sinistra (<), operatore <: | | Operatori di confronto |
| parentesi, acuta sinistra (<), operatore <=: | | Operatori di confronto |
| parentesi, acuta destra (>), operatore >=: | | Operatori di confronto |
| parentesi, acuta destra (>), operatore >: | | Operatori di confronto |
| parentesi, acuta sinistra (<), operatore <: | | Precedenza |
| parentesi, acuta sinistra (<), operatore <=: | | Precedenza |
| parentesi, acuta destra (>), operatore >=: | | Precedenza |
| parentesi, acuta destra (>), operatore >: | | Precedenza |
| parentesi, acuta destra (>), operatore >> (I/O): | | Precedenza |
| parentesi, graffe ({}), azioni e: | | Panoramica sulle azioni |
| parentesi, graffe ({}), istruzioni, raggruppare: | | Istruzioni |
| parentesi, graffe ({}): | | Profilare |
| parentesi, (()), in un profilo: | | Profilare |
| parola, definizione in regexp: | | Operatori di regexp GNU |
| parola, chiave case: | | Istruzione switch |
| parola, chiave default: | | Istruzione switch |
| parole, contare le: | | Programma wc |
| parole, duplicate, ricerca di: | | Programma dupword |
| parole, statistica utilizzo delle: | | Programma utilizzo parole |
| password, file delle: | | Funzioni Passwd |
| patsplit() (funzione gawk): | | Funzioni per stringhe |
| pawk, implementazione simile ad awk per Python: | | Altre versioni |
| pawk (versione con profilazione di Brian Kernighan awk): | | Altre versioni |
| PC, gawk su sistemi operativi: | | Installazione su PC |
| PC, gawk su sistemi operativi per: | | Uso su PC |
| percento (%), operatore %=: | | Operatori di assegnamento |
| percento (%), operatore %: | | Precedenza |
| percento (%), operatore %=: | | Precedenza |
| percorso di ricerca, per file sorgente: | | AWKPATH (Variabile) |
| percorso di ricerca, per estensioni: | | AWKLIBPATH (Variabile) |
| percorso di ricerca, per file sorgente: | | Esercizi sui programmi |
| percorso di ricerca, per estensioni: | | Trovare le estensioni |
| percorso di ricerca: | | Uso su PC |
| percorso di ricerca, per file sorgente: | | Uso su PC |
| percorso di ricerca, per file sorgente: | | Esecuzione su VMS |
| Perl: | | Future estensioni |
| personalizzato, analizzatore di input: | | Analizzatori di input |
| personalizzato, processore di output: | | Processori di output |
| personalizzato, processore bidirezionale: | | Processori bidirezionali |
| Peters, Arno: | | Contributori |
| Peterson, Hal: | | Contributori |
| piattaforma di esecuzione: | | Variabili auto-assegnate |
| pila (stack) delle chiamate, visualizzare nel debugger: | | Stack di esecuzione |
| pipe, input: | | Getline pipe |
| pipe, output: | | Ridirezione |
| pipe, chiusura: | | Chiusura file e pipe |
| Pitts, Dave: | | Ringraziamenti |
| più (+), operatore regexp: | | Dettagli sugli operatori di regexp |
| più (+), operatore +=: | | Operatori di assegnamento |
| più (+), operatore ++: | | Operatori di incremento |
| più (+), operatore ++: | | Operatori di incremento |
| più (+), operatore ++: | | Precedenza |
| più (+), operatore +: | | Precedenza |
| più (+), operatore +: | | Precedenza |
| più (+), operatore +=: | | Precedenza |
| Plauger, P.J.: | | Funzioni di libreria |
| plug-in: | | Introduzione alle estensioni |
| portabilità, #! (script eseguibili): | | Script eseguibili |
| portabilità, variabile ARGV: | | Script eseguibili |
| portabilità, continuazione di riga con barra inversa e: | | Istruzioni/Righe |
| portabilità, generare file oggetto: | | Opzioni |
| portabilità, variabile d’ambiente POSIXLY_CORRECT: | | Opzioni |
| portabilità: | | Sequenze di protezione |
| portabilità, barra inversa in sequenze di protezione: | | Sequenze di protezione |
| portabilità, file di dati come un unico record: | | gawk divisione record |
| portabilità, variabile NF, decrementare: | | Cambiare i campi |
| portabilità, funzione close(): | | Chiusura file e pipe |
| portabilità, nuovo awk vs. vecchio awk: | | Stringhe e numeri |
| portabilità, operatore **: | | Operatori aritmetici |
| portabilità, operatore **=: | | Operatori di assegnamento |
| portabilità, operatori: | | Operatori di incremento |
| portabilità, operatori, non in POSIX awk: | | Precedenza |
| portabilità, eliminazione di elementi di un vettore: | | Cancellazione |
| portabilità, funzione length(): | | Funzioni per stringhe |
| portabilità, funzione substr(): | | Funzioni per stringhe |
| portabilità, nella definizione di funzioni: | | Sintassi delle definizioni |
| portabilità, istruzione next in funzioni definite dall’utente: | | Precisazioni sulle funzioni |
| portabilità, programmi di esempio: | | Funzioni di libreria |
| portabilità, libreria gettext e: | | Utilizzare gettext |
| portabilità, internazionalizzazione e: | | Portabilità nell'I18N |
| portabilità, gawk: | | Nuovi sistemi |
| portable object file (.po): | | Utilizzare gettext |
| portable object file (.po): | | I18N per traduttore |
| portable object file (.po), conversione in message object file: | | Esempio I18N |
| portable object template (.pot) (file): | | Utilizzare gettext |
| portare gawk: | | Nuovi sistemi |
| POSIX, awk e: | | Prefazione |
| POSIX, modalità: | | Opzioni |
| POSIX, modalità: | | Opzioni |
| POSIX, modalità: | | Dettagli sugli operatori di regexp |
| POSIX, modalità: | | Sommario di Input |
| POSIX, modalità: | | Chiusura file e pipe |
| POSIX, programmi, implementazione in awk: | | Cloni |
| POSIX, modalità: | | Problemi virgola mobile POSIX |
| POSIX, estensioni gawk non incluse in: | | POSIX/GNU |
| POSIX, modalità: | | Storia delle funzionalità |
| POSIX, modalità: | | Storia delle funzionalità |
| POSIX awk: | | Questo manuale |
| POSIX awk, opzioni estese GNU: | | Opzioni |
| POSIX awk, barre inverse in costanti stringa: | | Sequenze di protezione |
| POSIX awk, uso del punto (.): | | Dettagli sugli operatori di regexp |
| POSIX awk, espressioni regolari: | | Dettagli sugli operatori di regexp |
| POSIX awk, espressioni di intervallo: | | Espressioni di intervallo |
| POSIX awk, espressioni tra parentesi quadre: | | Espressioni tra parentesi quadre |
| POSIX awk, espressioni tra parentesi quadre, classi di caratteri: | | Espressioni tra parentesi quadre |
| POSIX awk, espressioni tra parentesi quadre, classi di caratteri: | | Espressioni tra parentesi quadre |
| POSIX awk, separatore di campo: | | Campo intera riga |
| POSIX awk, < (operatore): | | Getline file |
| POSIX awk, | (operatore I/O): | | Getline pipe |
| POSIX awk, OFMT (variabile): | | OFMT |
| POSIX awk, stringhe di formato printf: | | Modificatori di formato |
| POSIX awk, OFMT (variabile): | | Stringhe e numeri |
| POSIX awk, operatori aritmetici: | | Operatori aritmetici |
| POSIX awk: | | Operatori di assegnamento |
| POSIX awk, **= (operatore): | | Operatori di assegnamento |
| POSIX awk, stringhe numeriche: | | Tipi di variabile |
| POSIX awk, ** (operatore): | | Precedenza |
| POSIX awk, criteri di ricerca BEGIN/END: | | I/O e BEGIN/END |
| POSIX awk, break (istruzione): | | Istruzione break |
| POSIX awk, continue (istruzione): | | Istruzione continue |
| POSIX awk, next/nextfile (istruzioni): | | Istruzione next |
| POSIX awk, CONVFMT (variabile): | | Variabili modificabili dall'utente |
| POSIX awk, FS (variabile): | | Variabili modificabili dall'utente |
| POSIX awk, length() (funzione): | | Funzioni per stringhe |
| POSIX awk, gsub()/sub() (funzioni): | | Dettagli ostici |
| POSIX awk, marcature temporali: | | Funzioni di tempo |
| POSIX awk, date (programma di utilità): | | Funzioni di tempo |
| POSIX awk, function (parola chiave): | | Sintassi delle definizioni |
| POSIX awk, differenze tra versioni awk: | | POSIX |
| POSIXLY_CORRECT (variabile d’ambiente): | | Opzioni |
| posizione, specificatori di, istruzione printf: | | Ordinamento di printf |
| PREC (variabile): | | Variabili modificabili dall'utente |
| precedenza, operatori regexp: | | Dettagli sugli operatori di regexp |
| precedenza: | | Operatori di incremento |
| precedenza: | | Precedenza |
| precisione, massima consentita dalla libreria MPFR: | | Variabili auto-assegnate |
| precisione, minima richiesta dalla libreria MPFR: | | Variabili auto-assegnate |
| precisione, arbitraria: | | Calcolo con precisione arbitraria |
| precisione, multipla: | | Calcolo con precisione arbitraria |
| precisione, infinita: | | Calcolo con precisione arbitraria |
| precisione, singola: | | Aritmetica del computer |
| precisione, doppia: | | Aritmetica del computer |
| precisione, arbitraria: | | Aritmetica del computer |
| precisione, arbitraria, interi a: | | Interi a precisione arbitraria |
| predefinita, variabile, impostare con opzione -v: | | Opzioni |
| predefinita, variabile: | | Variabili predefinite |
| predefinita, variabile, che fornisce informazioni: | | Variabili auto-assegnate |
| predefinita, funzione: | | Funzioni |
| predefinita, funzione, ordine di valutazione: | | Chiamare funzioni predefinite |
| print (comando del debugger): | | Trovare il bug |
| print (comando del debugger): | | Vedere e modificare dati |
| print (istruzione), continuazione di riga e: | | Esempi su print |
| print (istruzione), criteri di ricerca BEGIN/END e: | | I/O e BEGIN/END |
| print (istruzione), variabile OFMT e: | | Variabili modificabili dall'utente |
| print (istruzione), funzione sprintf() e: | | Funzione round |
| printf (comando del debugger): | | Vedere e modificare dati |
| printf (istruzione): | | Printf |
| printf (istruzione), sintassi: | | Printf Fondamenti |
| printf (istruzione), lettere di controllo del formato: | | Lettere di controllo |
| printf (istruzione), modificatori: | | Modificatori di formato |
| printf (istruzione), specificatori di posizione: | | Modificatori di formato |
| printf (istruzione), funzione sprintf() e: | | Funzione round |
| printf (istruzione), specificatori di posizione: | | Ordinamento di printf |
| printf (istruzione), specificatori di posizione, frammisti a formati standard: | | Ordinamento di printf |
| private, variabili: | | Nomi di variabili di libreria |
| problemi, risoluzione di, refusi, variabili globali: | | Opzioni |
| problemi, risoluzione di, barra inversa prima di caratteri non speciali: | | Sequenze di protezione |
| problemi, risoluzione di, costanti regexp vs. costanti stringa: | | Espressioni regolari calcolate |
| problemi, risoluzione di, awk usa FS anziché IFS: | | Separatori di campo |
| problemi, risoluzione di, errori fatali, specificare larghezza dei campi: | | Dati di lunghezza fissa |
| problemi, risoluzione di, divisione: | | Operatori aritmetici |
| problemi, risoluzione di, concatenazione di stringhe: | | Concatenazione |
| problemi, risoluzione di, operatore ==: | | Operatori di confronto |
| problemi, risoluzione di, sintassi della chiamata di funzione: | | Chiamate di funzione |
| problemi, risoluzione di, gawk, errori fatali, argomenti di funzione e: | | Chiamare funzioni predefinite |
| problemi, risoluzione di, funzione match(): | | Funzioni per stringhe |
| problemi, risoluzione di, funzioni gsub()/sub(): | | Funzioni per stringhe |
| problemi, risoluzione di, funzione substr(): | | Funzioni per stringhe |
| problemi, risoluzione di, funzione fflush(): | | Funzioni di I/O |
| problemi, risoluzione di, funzione system(): | | Funzioni di I/O |
| problemi, risoluzione di, gawk: | | Modalità di compatibilità |
| problemi di implementazione, gawk, limitazioni: | | Ridirezione |
| problemi di implementazione, gawk: | | Note |
| problemi di implementazione, gawk, debug: | | Modalità di compatibilità |
| process group ID del programma gawk: | | Variabili auto-assegnate |
| process ID del programma gawk: | | Variabili auto-assegnate |
| processi, comunicazioni bidirezionali con: | | I/O bidirezionale |
| processore bidirezionale personalizzato: | | Processori bidirezionali |
| processore di output, personalizzato: | | Processori di output |
| processore di output: | | Processori di output |
| PROCINFO (vettore), vettori in: | | Altri argomenti |
| PROCINFO (vettore): | | Variabili auto-assegnate |
| PROCINFO (vettore), ambiente di compilazione: | | Variabili auto-assegnate |
| PROCINFO (vettore), valori di sorted_in: | | Controllare visita |
| PROCINFO (vettore): | | Funzioni di tempo |
| PROCINFO (vettore): | | Funzioni Passwd |
| PROCINFO (vettore), verificare la divisione in campi: | | Funzioni Passwd |
| PROCINFO (vettore), appartenenza a gruppi e: | | Funzioni Group |
| PROCINFO (vettore), process ID di utente e di gruppo e: | | Programma id |
| PROCINFO (vettore), comunicazioni attraverso le pty e: | | I/O bidirezionale |
| profilare programmi awk: | | Profilare |
| profilare programmi awk, dinamicamente: | | Profilare |
| profilazione, dinamica: | | Profilare |
| profilazione, differenza rispetto alla stampa elegante: | | Profilare |
| profilazione, interazione con spazio-dei-nomi: | | Spazio-dei-nomi e funzionalità |
| progetto, GNU: | | Storia del manuale |
| progetto, gawkextlib: | | gawkextlib |
| progetto, GNU: | | Glossario |
| programma, definizione di: | | Per iniziare |
| programma, expand: | | Molto semplice |
| programma, identificativi in un: | | Variabili auto-assegnate |
| programma, testbits.awk: | | Funzioni a livello di bit |
| programma, noassign.awk: | | Ignorare assegnamenti di variabili |
| programma, cut.awk: | | Programma cut |
| programma, egrep.awk: | | Programma egrep |
| programma, id.awk: | | Programma id |
| programma, split.awk: | | Programma split |
| programma, tee.awk: | | Programma tee |
| programma, uniq.awk: | | Programma uniq |
| programma, wc.awk: | | Programma wc |
| programma, dupword.awk: | | Programma dupword |
| programma, alarm.awk: | | Programma alarm |
| programma, translate.awk: | | Programma translate |
| programma, labels.awk: | | Programma labels |
| programma, wordfreq.awk: | | Programma utilizzo parole |
| programma, histsort.awk: | | Programma riordino diario |
| programma, extract.awk: | | Programma extract |
| programma, awksed.awk: | | Programma sed semplice |
| programma, igawk.sh: | | Programma igawk |
| programma, anagram.awk: | | Programma anagram |
| programma, signature: | | Programma signature |
| programma, aaa (amazing awk assembler): | | Glossario |
| programma, awf (formattatore incredibilmente duttile): | | Glossario |
| programma C, grcat: | | Funzioni Group |
| programma di utilità, mawk: | | Sequenze di protezione |
| programma di utilità, egrep: | | Espressioni tra parentesi quadre |
| programma di utilità, sed: | | Campo intera riga |
| programma di utilità, w: | | Dati di lunghezza fissa |
| programma di utilità, mawk: | | Getline pipe |
| programma di utilità, mawk: | | Concatenazione |
| programma di utilità, mawk: | | Istruzione nextfile |
| programma di utilità, cut: | | Programma cut |
| programma di utilità, egrep: | | Programma egrep |
| programma di utilità, id: | | Programma id |
| programma di utilità, split: | | Programma split |
| programma di utilità, tee: | | Programma tee |
| programma di utilità, uniq: | | Programma uniq |
| programma di utilità, wc: | | Programma wc |
| programma di utilità, sleep: | | Programma alarm |
| programma di utilità, tr: | | Programma translate |
| programma di utilità, sort: | | Programma utilizzo parole |
| programma di utilità, sed: | | Programma sed semplice |
| programma di utilità, sort, coprocessi e: | | I/O bidirezionale |
| programma di utilità, xgettext: | | Estrazione di stringhe |
| programma di utilità, msgfmt: | | Esempio I18N |
| programma di utilità, git: | | gawkextlib |
| programma di utilità, mawk: | | Altre versioni |
| programma di utilità, git: | | Accedere ai sorgenti |
| programma di utilità, git: | | Aggiungere codice |
| programma di utilità, sed: | | Glossario |
| programma di utilità, chem: | | Glossario |
| programma di utilità GNU, date: | | Funzioni di tempo |
| programma di utilità POSIX, date: | | Funzioni di tempo |
| programmazione, ricetta per linguaggi di: | | Storia |
| programmazione, convenzioni di, parametri di funzione: | | Istruzione return |
| programmazione, convenzioni di, nomi di variabili private: | | Nomi di variabili di libreria |
| programmazione, convenzioni di, opzione --non-decimal-data: | | Dati non decimali |
| programmazione, convenzioni di, estensioni gawk: | | Operazioni interne file |
| programmazione, concetti di: | | Concetti fondamentali |
| programmazione, concetti di: | | Concetti fondamentali |
| programmazione, passi fondamentali: | | Fondamenti ad alto livello |
| programmi awk: | | Per iniziare |
| programmi awk, eseguire: | | Eseguire gawk |
| programmi awk, eseguire, da script di shell: | | Monouso |
| programmi awk, eseguire, senza file in input: | | Leggere dal terminale |
| programmi awk, eseguire: | | Lunghi |
| programmi awk, lunghi: | | Lunghi |
| programmi awk, in file: | | Lunghi |
| programmi awk: | | Script eseguibili |
| programmi awk, documentazione dei: | | Commenti |
| programmi awk, esempi molto corti: | | Molto semplice |
| programmi awk: | | Due regole |
| programmi awk, complessi: | | Quando |
| programmi awk, collocazione dei: | | Opzioni |
| programmi awk, collocazione dei: | | Opzioni |
| programmi awk, collocazione dei: | | Opzioni |
| programmi awk, variabili di shell nei: | | Usare variabili di shell |
| programmi awk, eseguire: | | Istruzione next |
| programmi awk, internazionalizzare: | | Funzioni di internazionalizzazione |
| programmi awk, documentazione dei: | | Nomi di variabili di libreria |
| programmi awk, documentazione dei: | | Nomi di variabili di libreria |
| programmi awk, asserzioni in programmi lunghi: | | Funzione assert |
| programmi awk, esempi di: | | Programmi di esempio |
| programmi awk, profilare: | | Profilare |
| programmi awk, internazionalizzare: | | I18N e L10N |
| programmi awk, internazionalizzare: | | I18N per programmatore |
| programmi awk, debug dei: | | Debugger |
| programmi compilati: | | Fondamenti ad alto livello |
| programmi compilati: | | Glossario |
| programmi interpretati: | | Fondamenti ad alto livello |
| programmi interpretati: | | Glossario |
| programmi POSIX, implementazione in awk: | | Cloni |
| prompt del debugger: | | Invocazione del debugger |
| prompt del debugger: | | Informazioni sul debugger |
| proseguire dopo errore in input: | | Proseguire dopo errore in input |
| protezione, nella riga di comando di gawk: | | Lunghi |
| protezione, per piccoli programmi awk: | | Commenti |
| protezione, nella riga di comando di gawk, trucchi per la: | | Protezione |
| protezione caratteri nelle funzioni gsub()/gensub()/sub(): | | Dettagli ostici |
| prova, modalità di: | | Opzioni |
| puntatori a funzioni: | | Chiamate indirette |
| punto (.), operatore regexp: | | Dettagli sugli operatori di regexp |
| punto d’interruzione, (breakpoint): | | Terminologia nel debug |
| punto d’interruzione, (break), impostare: | | Controllo dei breakpoint |
| punto d’interruzione, (breakpoint), cancellare in una determinata posizione: | | Controllo dei breakpoint |
| punto d’interruzione, (breakpoint), cancellare per numero: | | Controllo dei breakpoint |
| punto d’interruzione, (disable), come disabilitare o abilitare: | | Controllo dei breakpoint |
| punto d’interruzione, (tbreak) temporaneo: | | Controllo dei breakpoint |
| punto d’interruzione, comandi da eseguire al: | | Controllo esecuzione debugger |
| punto d’osservazione, (watchpoint): | | Terminologia nel debug |
| punto e virgola (;), separare istruzioni nelle azioni: | | Istruzioni/Righe |
| punto e virgola (;), separare regole: | | Istruzioni/Righe |
| punto e virgola (;), separare istruzioni nelle azioni: | | Panoramica sulle azioni |
| punto e virgola (;), separare istruzioni nelle azioni: | | Istruzioni |
| punto e virgola (;), AWKPATH variabile e: | | Uso su PC |
| punto esclamativo (!), operatore !~: | | Uso di regexp |
| punto esclamativo (!), operatore !~: | | Espressioni regolari calcolate |
| punto esclamativo (!), operatore !~: | | Maiuscolo-Minuscolo |
| punto esclamativo (!), operatore !~: | | Costanti come espressioni regolari |
| punto esclamativo (!), operatore !=: | | Operatori di confronto |
| punto esclamativo (!), operatore !~: | | Operatori di confronto |
| punto esclamativo (!), operatore !~: | | Operatori di confronto |
| punto esclamativo (!), operatore !: | | Operatori booleani |
| punto esclamativo (!), operatore !: | | Precedenza |
| punto esclamativo (!), operatore !=: | | Precedenza |
| punto esclamativo (!), operatore !~: | | Precedenza |
| punto esclamativo (!), operatore !~: | | Espressioni come criteri di ricerca |
| punto esclamativo (!), operatore !: | | Intervalli |
| punto esclamativo (!), operatore !: | | Programma egrep |
| punto interrogativo (?), operatore regexp: | | Dettagli sugli operatori di regexp |
| punto interrogativo (?), operatore regexp: | | Operatori di regexp GNU |
| punto interrogativo (?), operatore ?:: | | Precedenza |
| pwcat (programma): | | Funzioni Passwd |
|
| Q | | |
|---|
| q (comando del debugger), (alias per quit): | | Comandi vari del debugger |
| QSE awk: | | Altre versioni |
| qualificato, nome, definizione di: | | Nomi qualificati |
| Quanstrom, Erik: | | Programma alarm |
| questioni sui nomi permessi: | | Nomi di variabili di libreria |
| QuikTrim Awk: | | Altre versioni |
| quit (comando del debugger): | | Comandi vari del debugger |
| QUIT (segnale) (MS-Windows): | | Profilare |
|
| R | | |
|---|
| r (comando del debugger), (alias per run): | | Controllo esecuzione debugger |
| radice quadrata: | | Funzioni numeriche |
| Rakitzis, Byron: | | Programma riordino diario |
| Ramey, Chet: | | Ringraziamenti |
| Ramey, Chet: | | Tipi di dati generali |
| rand() (funzione): | | Funzioni numeriche |
| Rankin, Pat: | | Ringraziamenti |
| Rankin, Pat: | | Operatori di assegnamento |
| Rankin, Pat: | | Contributori |
| RapidJson, libreria per analizzare JSON: | | gawkextlib |
| rappresentazioni di monete (nella localizzazione): | | Utilizzare gettext |
| reada() (estensione): | | Esempio di estensione Rwarray |
| readable.awk (programma): | | Controllo di file |
| readdir (estensione): | | Esempio di estensione Readdir |
| readfile(), funzione definita dall’utente: | | Funzione readfile |
| readfile() (estensione): | | Esempio di estensione Readfile |
| record: | | Leggere file |
| record, suddividere l’input in: | | Record |
| record, separatore di: | | awk divisione record |
| record, separatore di: | | awk divisione record |
| record, fine dei: | | awk divisione record |
| record, separatore di, espressioni regolari come: | | awk divisione record |
| record, trattare file come un solo: | | gawk divisione record |
| record, multiriga: | | Righe multiple |
| record, stampare: | | Print |
| record, separatore di: | | Variabili modificabili dall'utente |
| record, in input, lunghezza di un: | | Funzioni per stringhe |
| record: | | Fondamenti ad alto livello |
| record unico, trattare file come un solo: | | gawk divisione record |
| regexp: | | Espressioni regolari |
| regexp, costanti: | | Uso di regexp |
| regexp, maiuscolo/minuscolo: | | Maiuscolo-Minuscolo |
| regexp, costanti: | | Costanti come espressioni regolari |
| regexp, costanti, /=…/, operatore /= e: | | Operatori di assegnamento |
| regexp, costanti: | | Operatori di confronto |
| regexp, costanti, come criteri di ricerca: | | Espressioni come criteri di ricerca |
| registrazione di estensione: | | Funzioni di registrazione |
| registro (log), file di, marcature temporali nel: | | Funzioni di tempo |
| regola, definizione di: | | Per iniziare |
| regola, END: | | BEGIN/END |
| regola, BEGIN: | | Usare BEGIN/END |
| regola, END: | | Usare BEGIN/END |
| regola, END, operatori e: | | Usare BEGIN/END |
| regola, BEGIN, exit (istruzione) e: | | Istruzione exit |
| regola, END, exit (istruzione) e: | | Istruzione exit |
| regola, END, funzione definita dall’utente assert() e: | | Funzione assert |
| regola, BEGIN, funzione definita dall’utente assert() e: | | Funzione assert |
| regola, BEGIN, programma pwcat: | | Funzioni Passwd |
| regola, BEGIN, eseguire programmi awk e: | | Programma cut |
| regola, BEGIN, profilazione e: | | Profilare |
| regola, END, profilazione e: | | Profilare |
| regola, BEGIN, variabile TEXTDOMAIN e: | | I18N per programmatore |
| relazionali, operatori: | | Tipi di variabile e confronti |
| reti, funzionalità per: | | Reti speciali |
| reti, programmazione di: | | Reti TCP/IP |
| return (comando del debugger): | | Controllo esecuzione debugger |
| return (istruzione), in funzioni definite dall’utente: | | Istruzione return |
| rev(), funzione definita dall’utente: | | Esempio di funzione |
| revoutput (estensione): | | Esempio di estensione Revout |
| revtwoway (estensione): | | Esempio di estensione Rev2way |
| rewind(), funzione definita dall’utente: | | Funzione rewind |
| ricerca, percorso di, per file sorgente: | | AWKPATH (Variabile) |
| ricerca, in stringhe, operatori: | | Uso di regexp |
| ricerca, in stringhe: | | Funzioni per stringhe |
| ricerca, regexp in stringhe: | | Funzioni per stringhe |
| ricerca, in file, di espressioni regolari: | | Programma egrep |
| ricerca, di parole: | | Programma dupword |
| ricerca, percorso di, per file sorgente: | | Esercizi sui programmi |
| ricetta per un linguaggio di programmazione: | | Storia |
| ricorsive, funzioni: | | Sintassi delle definizioni |
| ridirezionare l’output di gawk, nel debugger: | | Informazioni sul debugger |
| ridirezione dell’input: | | Getline file |
| ridirezione dell’output: | | Ridirezione |
| ridirezione in VMS: | | Esecuzione su VMS |
| riga di comando, formati: | | Eseguire gawk |
| riga di comando, opzione -f: | | Lunghi |
| riga di comando, eseguire awk da: | | Riga di comando |
| riga di comando, opzioni: | | Opzioni |
| riga di comando, opzioni, fine delle: | | Opzioni |
| riga di comando, argomenti: | | Altri argomenti |
| riga di comando, impostare FS sulla: | | Separatori campo da riga di comando |
| riga di comando, directory su: | | Directory su riga di comando |
| riga di comando, variabili, assegnare da: | | Opzioni di assegnamento |
| riga di comando, argomenti: | | Variabili auto-assegnate |
| riga di comando, argomenti: | | Variabili auto-assegnate |
| riga di comando, argomenti: | | ARGC e ARGV |
| riga di comando, opzioni, elaborazione di: | | Funzione getopt |
| riga di comando, opzioni, estrazione stringhe: | | Estrazione di stringhe |
| righe, vuote, stampare: | | Print |
| righe, individuare intervalli di: | | Intervalli |
| righe, saltare tra delimitatori: | | Intervalli |
| righe, contare le: | | Programma wc |
| righe, duplicate, rimuovere: | | Programma riordino diario |
| righe multiple, record su: | | Righe multiple |
| rimpiazzare, caratteri in una stringa: | | Funzioni per stringhe |
| rimpiazzare, caratteri in un file: | | Programma translate |
| rimuovere righe duplicate: | | Programma riordino diario |
| ripetere dei comandi, nel debugger: | | Lista dei comandi di debug |
| ripristinare, spazio-dei-nomi corrente: | | Cambiare lo spazio-dei-nomi |
| risoluzione di problemi, refusi, variabili globali: | | Opzioni |
| risoluzione di problemi, opzione --non-decimal-data: | | Opzioni |
| risoluzione di problemi, barra inversa prima di caratteri non speciali: | | Sequenze di protezione |
| risoluzione di problemi, costanti regexp vs. costanti stringa: | | Espressioni regolari calcolate |
| risoluzione di problemi, awk usa FS anziché IFS: | | Separatori di campo |
| risoluzione di problemi, errori fatali, specificare larghezza dei campi: | | Dati di lunghezza fissa |
| risoluzione di problemi, divisione: | | Operatori aritmetici |
| risoluzione di problemi, concatenazione di stringhe: | | Concatenazione |
| risoluzione di problemi, operatore ==: | | Operatori di confronto |
| risoluzione di problemi, sintassi della chiamata di funzione: | | Chiamate di funzione |
| risoluzione di problemi, gawk, errori fatali, argomenti di funzione e: | | Chiamare funzioni predefinite |
| risoluzione di problemi, funzione match(): | | Funzioni per stringhe |
| risoluzione di problemi, funzioni gsub()/sub(): | | Funzioni per stringhe |
| risoluzione di problemi, funzione substr(): | | Funzioni per stringhe |
| risoluzione di problemi, funzione fflush(): | | Funzioni di I/O |
| risoluzione di problemi, funzione system(): | | Funzioni di I/O |
| risoluzione di problemi, leggibilità file-dati: | | Controllo di file |
| risoluzione di problemi, funzione getline: | | Controllo di file |
| risoluzione di problemi, gawk, segnalare bug: | | Bug |
| risoluzione di problemi, gawk: | | Modalità di compatibilità |
| Ritchie, Dennis: | | Fondamenti sui tipi di dati |
| ritorno a capo: | | Istruzioni/Righe |
| ritorno a capo: | | Opzioni |
| ritorno a capo, in regexp dinamiche: | | Espressioni regolari calcolate |
| ritorno a capo, in costanti regexp: | | Espressioni regolari calcolate |
| ritorno a capo, come separatore di record: | | awk divisione record |
| ritorno a capo, come separatore di record: | | awk divisione record |
| ritorno a capo, stampare un: | | Esempi su print |
| ritorno a capo: | | Operatori booleani |
| ritorno a capo, separatore di istruzioni nelle azioni: | | Panoramica sulle azioni |
| ritorno a capo, separatore di istruzioni nelle azioni: | | Istruzioni |
| RLENGTH (variabile): | | Variabili auto-assegnate |
| RLENGTH (variabile), funzione match() e: | | Funzioni per stringhe |
| Robbins, Miriam: | | Ringraziamenti |
| Robbins, Jean: | | Ringraziamenti |
| Robbins, Harry: | | Ringraziamenti |
| Robbins, Arnold: | | Separatori campo da riga di comando |
| Robbins, Bill: | | Getline pipe |
| Robbins, Miriam: | | Getline pipe |
| Robbins, Arnold: | | Getline pipe |
| Robbins, Arnold: | | Funzioni Passwd |
| Robbins, Miriam: | | Funzioni Passwd |
| Robbins, Arnold: | | Programma alarm |
| Robbins, Arnold: | | Tipi di dati generali |
| Robbins, Arnold: | | Contributori |
| Robbins, Arnold: | | Manutentori |
| Robbins, Arnold: | | Future estensioni |
| Rommel, Kai Uwe: | | Contributori |
| round(), funzione definita dall’utente: | | Funzione round |
| ROUNDMODE (variabile): | | Variabili modificabili dall'utente |
| ROUNDMODE (variabile): | | Impostare modo di arrotondare |
| RS (variabile): | | awk divisione record |
| RS (variabile), record multiriga e: | | Righe multiple |
| RS (variabile): | | Variabili modificabili dall'utente |
| rshift() (funzione gawk): | | Funzioni a livello di bit |
| RSTART (variabile): | | Variabili auto-assegnate |
| RSTART (variabile), funzione match() e: | | Funzioni per stringhe |
| RT (variabile): | | awk divisione record |
| RT (variabile): | | gawk divisione record |
| RT (variabile): | | Righe multiple |
| RT (variabile): | | Variabili auto-assegnate |
| Rubin, Paul: | | Storia |
| Rubin, Paul: | | Contributori |
| run (comando del debugger): | | Trovare il bug |
| run (comando del debugger): | | Controllo esecuzione debugger |
| rvalue/lvalue: | | Operatori di assegnamento |
|
| S | | |
|---|
| s (comando del debugger), (alias per step): | | Controllo esecuzione debugger |
| salvare dei comandi su un file, nel debugger: | | Informazioni sul debugger |
| salvataggio opzioni, nel debugger: | | Informazioni sul debugger |
| sandbox, modalità: | | Opzioni |
| scalare o vettore: | | Funzioni per i tipi |
| scalari, valori: | | Fondamenti sui tipi di dati |
| Schorr, Andrew: | | Ringraziamenti |
| Schorr, Andrew: | | Variabili auto-assegnate |
| Schorr, Andrew: | | Contributori |
| Schreiber, Bert: | | Ringraziamenti |
| Schreiber, Rita: | | Ringraziamenti |
| scrivere su disco i buffer di output contenuti in memoria: | | Funzioni di I/O |
| sed (programma di utilità): | | Campo intera riga |
| sed (programma di utilità): | | Programma sed semplice |
| sed (programma di utilità): | | Glossario |
| segnalare bug, indirizzo email, bug-gawk@gnu.org: | | Indirizzo Bug |
| segnali, USR1/SIGUSR1 (per profilazione): | | Profilare |
| segnali, HUP/SIGHUP (per profilazione): | | Profilare |
| segnali, INT/SIGINT (MS-Windows): | | Profilare |
| segnali, QUIT/SIGQUIT (MS-Windows): | | Profilare |
| segno, interi senza: | | Aritmetica del computer |
| seno: | | Funzioni numeriche |
| senza segno, interi: | | Aritmetica del computer |
| separatore decimale, carattere specifico della localizzazione: | | Opzioni |
| separatore di campo, scelta del: | | Separatori di campo |
| separatore di campo, espressioni regolari come: | | Separatori di campo |
| separatore di campo, spazi vuoti come: | | Separatori di campo di default |
| separatore di campo, FS (variabile) come: | | Separatori di campo di default |
| separatore di campo, espressioni regolari come: | | Separare campi con regexp |
| separatore di campo, specificare sulla riga di comando: | | Separatori campo da riga di comando |
| separatore di campo, \ (barra inversa) come: | | Separatori campo da riga di comando |
| separatore di campo, POSIX e il: | | Campo intera riga |
| separatore di campo, nei record multiriga: | | Righe multiple |
| separatore di campo, variabile FIELDWIDTHS e: | | Variabili modificabili dall'utente |
| separatore di campo, variabile FPAT e: | | Variabili modificabili dall'utente |
| separatore di campo: | | Variabili modificabili dall'utente |
| separatore di campo: | | Variabili modificabili dall'utente |
| separatore di campo, spazi come: | | Programma cut |
| separatore di campo: | | Cambiare i campi |
| separatore di indici: | | Variabili modificabili dall'utente |
| separatore di istruzioni, nelle azioni: | | Panoramica sulle azioni |
| separatore di record: | | awk divisione record |
| separatore di record, ritorno a capo come: | | awk divisione record |
| separatore di record, cambiare il: | | awk divisione record |
| separatore di record, espressioni regolari come: | | awk divisione record |
| separatore di record, per record multiriga: | | Righe multiple |
| separatore di record, in output: | | Separatori di output |
| separatore di record: | | Variabili modificabili dall'utente |
| sequenze di protezione: | | Sequenze di protezione |
| sequenze di protezione, in stringhe: | | Sequenze di protezione |
| serie di caratteri (codifiche dei caratteri da parte della macchina): | | Funzioni ordinali |
| set (comando del debugger): | | Vedere e modificare dati |
| shell, script: | | Monouso |
| shell, protezione, regole per: | | Protezione |
| shell, protezione, regole per: | | Protezione |
| shell, inviare comandi tramite pipe alla: | | Ridirezione |
| shell, variabili di: | | Usare variabili di shell |
| shell, uso di doppio apice: | | Usare variabili di shell |
| si (comando del debugger), (alias per stepi): | | Controllo esecuzione debugger |
| sidebar, Ricetta per un linguaggio di programmazione: | | Storia |
| sidebar, Comprendere ‘#!’: | | Script eseguibili |
| sidebar, Barra inversa prima di un carattere normale: | | Sequenze di protezione |
| sidebar, Sequenze di protezione per metacaratteri: | | Sequenze di protezione |
| sidebar, Usare \n in espressioni tra parentesi quadre in regexp dinamiche: | | Espressioni regolari calcolate |
| sidebar, RS = "\0" non è portabile: | | gawk divisione record |
| sidebar, Comprendere $0: | | Cambiare i campi |
| sidebar, Cambiare FS non incide sui campi: | | Campo intera riga |
| sidebar, FS e IGNORECASE: | | Sommario sulla separazione campi |
| sidebar, Inviare pipe alla sh: | | Ridirezione |
| sidebar, Usare il codice di ritorno di close(): | | Chiusura file e pipe |
| sidebar, La base di una costante non influisce sul suo valore: | | Numeri non-decimali |
| sidebar, awk prima di POSIX usava OFMT per la conversione di stringhe: | | Stringhe e numeri |
| sidebar, Ambiguità sintattiche tra ‘/=’ e le espressioni regolari: | | Operatori di assegnamento |
| sidebar, Ordine di valutazione degli operatori: | | Operatori di incremento |
| sidebar, Modificare NR e FNR: | | Variabili auto-assegnate |
| sidebar, Individuare la stringa nulla: | | Funzioni per stringhe |
| sidebar, Bufferizzazione interattiva e non interattiva: | | Funzioni di I/O |
| sidebar, Controllare la bufferizzazione dell’output con system(): | | Funzioni di I/O |
| sidebar, Attenzione. Non è tutto oro quel che luccica!: | | Funzioni a livello di bit |
| sidebar, Allora perché gawk ha BEGINFILE e ENDFILE?: | | Funzione filetrans |
| sidebar, Modalità di arrotondamento e conversioni: | | Impostare modo di arrotondare |
| SIGHUP (segnale) (per profilazione dinamica): | | Profilare |
| SIGINT (segnale) (MS-Windows): | | Profilare |
| signature (programma): | | Programma signature |
| SIGQUIT (segnale) (MS-Windows): | | Profilare |
| SIGUSR1 (segnale) (per profilazione dinamica): | | Profilare |
| silent (comando del debugger): | | Controllo esecuzione debugger |
| simboli di monete (nella localizzazione): | | Utilizzare gettext |
| sin() (funzione): | | Funzioni numeriche |
| singola, precisione: | | Aritmetica del computer |
| singolo carattere, campi di un: | | Campi di un solo carattere |
| sintattica, ambiguità: operatore /= vs. costante regexp /=…/: | | Operatori di assegnamento |
| sistemi operativi, basati su BSD: | | Storia del manuale |
| sistemi operativi: | | Installazione |
| sistemi operativi, per PC, gawk su: | | Installazione su PC |
| sistemi operativi, per PC, gawk su: | | Uso su PC |
| sistemi operativi, portare gawk su altri: | | Nuovi sistemi |
| sistemi operativi, basati su BSD: | | Glossario |
| Skywalker, Luke: | | Non documentato |
| sleep (programma di utilità): | | Programma alarm |
| sleep() (estensione): | | Esempio di estensione Time |
| Smith, Gavin: | | Ringraziamenti |
| Solaris, versione POSIX awk: | | Altre versioni |
| sorgente, codice, gawk: | | Distribuzione di Gawk |
| sorgente, codice, Brian Kernighan awk: | | Altre versioni |
| sorgente, codice, awka: | | Altre versioni |
| sorgente, codice, pawk: | | Altre versioni |
| sorgente, codice, BusyBox Awk: | | Altre versioni |
| sorgente, codice, Solaris awk: | | Altre versioni |
| sorgente, codice, Illumos awk: | | Altre versioni |
| sorgente, goawk: | | Altre versioni |
| sorgente, codice, jawk: | | Altre versioni |
| sorgente, codice, libmawk (interpretatore): | | Altre versioni |
| sorgente, codice, pawk (versione Python): | | Altre versioni |
| sorgente, codice, QSE awk: | | Altre versioni |
| sorgente, codice, QuikTrim Awk: | | Altre versioni |
| sort (programma di utilità): | | Programma utilizzo parole |
| sort (programma di utilità), coprocessi e: | | I/O bidirezionale |
| sort() (funzione), ordinamento di vettori: | | Funzioni di ordinamento di vettori |
| sostituzione in stringa: | | Funzioni per stringhe |
| sottostringa: | | Funzioni per stringhe |
| sparsi, vettori: | | Introduzione ai vettori |
| spazi, come separatore di campo: | | Programma cut |
| spazi vuoti, ritorno a capo come: | | Opzioni |
| spazi vuoti, come separatore di campo: | | Separatori di campo di default |
| spazio bianco, definizione di: | | Campi |
| spazio bianco, nelle chiamate di funzione: | | Chiamare funzioni predefinite |
| spazio-dei-nomi, definizione: | | Spazio-dei-nomi globale |
| spazio-dei-nomi, globale, in awk standard: | | Spazio-dei-nomi globale |
| spazio-dei-nomi, nomi qualificati: | | Nomi qualificati |
| spazio-dei-nomi, default: | | Spazio-dei-nomi di default |
| spazio-dei-nomi, awk: | | Spazio-dei-nomi di default |
| spazio-dei-nomi, cambiare lo: | | Cambiare lo spazio-dei-nomi |
| spazio-dei-nomi, implicito: | | Cambiare lo spazio-dei-nomi |
| spazio-dei-nomi, corrente, cambiare e ripristinare: | | Cambiare lo spazio-dei-nomi |
| spazio-dei-nomi, regole per assegnare i nomi: | | Regole per i nomi |
| spazio-dei-nomi, componenti, regole per assegnare i nomi: | | Regole per i nomi |
| spazio-dei-nomi, esempio di codice: | | Esempio di spazio-dei-nomi |
| spazio-dei-nomi, interazione con la profilazione: | | Spazio-dei-nomi e funzionalità |
| spazio-dei-nomi, interazione con la stampa elegante: | | Spazio-dei-nomi e funzionalità |
| spazio-dei-nomi, interazione con il debugger: | | Spazio-dei-nomi e funzionalità |
| spazio-dei-nomi, interazione con l’estensione API: | | Spazio-dei-nomi e funzionalità |
| spazio-dei-nomi, compatibilità all’indietro: | | Sommario sugli spazi-dei-nomi |
| specificatori di formato: | | Printf Fondamenti |
| specificatori di formato, istruzione printf: | | Lettere di controllo |
| specificatori di formato, funzione strftime() di gawk: | | Funzioni di tempo |
| specificatori di formato, frammisti a specificatori di posizione non standard: | | Ordinamento di printf |
| specificatori di posizione, istruzione printf: | | Modificatori di formato |
| specificatori di posizione, istruzione printf: | | Ordinamento di printf |
| specificatori di posizione, istruzione printf, frammisti a formati standard: | | Ordinamento di printf |
| Spencer, Henry: | | Glossario |
| split (programma di utilità): | | Programma split |
| split() (funzione), eliminazione di elementi di vettori: | | Cancellazione |
| split() (funzione): | | Funzioni per stringhe |
| split.awk (programma): | | Programma split |
| spostamento, bit a bit: | | Funzioni a livello di bit |
| spostamento a destra, bit a bit: | | Funzioni a livello di bit |
| spostamento a sinistra, bit a bit: | | Funzioni a livello di bit |
| sprintf() (funzione): | | OFMT |
| sprintf() (funzione): | | Funzioni per stringhe |
| sprintf() (funzione), istruzioni print/printf e: | | Funzione round |
| sqrt() (funzione): | | Funzioni numeriche |
| srand() (funzione): | | Funzioni numeriche |
| stack (pila) delle chiamate, nel debugger: | | Terminologia nel debug |
| stack (pila) delle chiamate, visualizzare nel debugger: | | Stack di esecuzione |
| stack frame (debugger): | | Terminologia nel debug |
| stalli: | | I/O bidirezionale |
| Stallman, Richard: | | Storia del manuale |
| Stallman, Richard: | | Ringraziamenti |
| Stallman, Richard: | | Contributori |
| Stallman, Richard: | | Glossario |
| stampa, lista di opzioni: | | Opzioni |
| stampa elegante: | | Opzioni |
| stampa elegante: | | Profilare |
| stampa elegante, differenza rispetto alla profilazione: | | Profilare |
| stampa elegante, interazione con spazio-dei-nomi: | | Spazio-dei-nomi e funzionalità |
| stampare: | | Stampare |
| stampare, informazioni utente: | | Programma id |
| stampare, righe di testo non duplicate: | | Programma uniq |
| stampare, etichette per lettera: | | Programma labels |
| stampare, singoli elementi di un vettore, nel debugger: | | Trovare il bug |
| stampare, tutti gli elementi di un vettore, nel debugger: | | Trovare il bug |
| stampare, variabili, nel debugger: | | Vedere e modificare dati |
| stampare, messaggi dalle estensioni: | | Stampare messaggi |
| standard error: | | FD speciali |
| standard input: | | Leggere dal terminale |
| standard input: | | FD speciali |
| standard output: | | FD speciali |
| stat() (estensione): | | Esempio di estensione funzioni file |
| statistica utilizzo delle parole: | | Programma utilizzo parole |
| stato d’uscita, di gawk: | | Codice di ritorno |
| step (comando del debugger): | | Controllo esecuzione debugger |
| stepi (comando del debugger): | | Controllo esecuzione debugger |
| strftime() (funzione gawk): | | Funzioni di tempo |
| stringa, vuota: | | awk divisione record |
| stringa, vuota: | | awk divisione record |
| stringa, vuota: | | Separare campi con regexp |
| stringa, più lunga da sinistra, individuare la: | | Righe multiple |
| stringa, costante: | | Costanti scalari |
| stringa, limitazioni della lunghezza: | | Costanti scalari |
| stringa, continuazione su più righe: | | Costanti scalari |
| stringa, conversione: | | Stringhe e numeri |
| stringa, operatori di: | | Concatenazione |
| stringa, numerica: | | Tipi di variabile |
| stringa, conversione in numero: | | Variabili modificabili dall'utente |
| stringa, conversione in numero: | | Variabili modificabili dall'utente |
| stringa, lunghezza di una: | | Funzioni per stringhe |
| stringa, ricercare espressioni regolari in una: | | Funzioni per stringhe |
| stringa, divisione, esempio: | | Funzioni per stringhe |
| stringa, formattazione: | | Funzioni per stringhe |
| stringa, conversione in numero: | | Funzioni per stringhe |
| stringa, rimpiazzare in una: | | Funzioni per stringhe |
| stringa, conversione maiuscolo/minuscolo: | | Funzioni per stringhe |
| stringa, conversione: | | Funzioni a livello di bit |
| stringa, trasformare vettore in: | | Funzione join |
| stringa, marcata, per localizzazione: | | I18N per programmatore |
| stringa, estrazione di: | | Estrazione di stringhe |
| stringa, marcata, estrazione di (internazionalizzazione): | | Estrazione di stringhe |
| stringa nulla, come argomento a gawk, protezione della: | | Protezione |
| stringa nulla: | | awk divisione record |
| stringa nulla: | | Separare campi con regexp |
| stringa nulla, conversione da tipo numerico a tipo stringa: | | Stringhe e numeri |
| stringa nulla, come indice di vettore: | | Indici non inizializzati |
| stringa nulla, eliminazione di elementi di un vettore e: | | Cancellazione |
| stringa nulla, individuare la: | | Funzioni per stringhe |
| stringa nulla: | | Fondamenti sui tipi di dati |
| strtonum() (funzione gawk): | | Funzioni per stringhe |
| strtonum() (funzione gawk), opzione --non-decimal-data e: | | Dati non decimali |
| sub() (funzione): | | Costanti regexp normali |
| sub() (funzione): | | Funzioni per stringhe |
| sub() (funzione), argomenti di: | | Funzioni per stringhe |
| sub() (funzione), protezione caratteri: | | Dettagli ostici |
| SUBSEP (variabile): | | Variabili modificabili dall'utente |
| SUBSEP (variabile), vettori multidimensionali e: | | Vettori multidimensionali |
| substr() (funzione): | | Funzioni per stringhe |
| Sumner, Andrew: | | Altre versioni |
| sveglia, programma di esempio: | | Programma alarm |
| switch (istruzione): | | Istruzione switch |
| SYMTAB (vettore): | | Variabili auto-assegnate |
| system() (funzione): | | Funzioni di I/O |
| systime() (funzione gawk): | | Funzioni di tempo |
|
| T | | |
|---|
| t (comando del debugger), (alias per tbreak): | | Controllo dei breakpoint |
| tbreak (comando del debugger): | | Controllo dei breakpoint |
| Tcl: | | Nomi di variabili di libreria |
| TCP/IP, funzionalità per: | | Reti speciali |
| TCP/IP: | | Reti TCP/IP |
| tee (programma di utilità): | | Programma tee |
| tee.awk (programma): | | Programma tee |
| tempo, ottenerlo: | | Funzioni di tempo |
| tempo, sveglia, programma di esempio: | | Programma alarm |
| tempo, localizzazione e: | | Utilizzare gettext |
| tempo limite, entro il quale leggere input: | | Timeout in lettura |
| temporaneo, punto d’interruzione: | | Controllo dei breakpoint |
| testbits.awk (programma): | | Funzioni a livello di bit |
| testext (estensione): | | Esempio di estensione API Test |
| testo, stampare: | | Print |
| testo, stampare, righe non duplicate di: | | Programma uniq |
| Texinfo: | | Convenzioni |
| Texinfo, inizi di capitolo nei file: | | Dettagli sugli operatori di regexp |
| Texinfo: | | Funzioni di libreria |
| Texinfo: | | Programma dupword |
| Texinfo, estrarre programma da file sorgente: | | Programma extract |
| Texinfo: | | Programma extract |
| Texinfo: | | Contenuti della distribuzione |
| Texinfo: | | Aggiungere codice |
| TEXTDOMAIN (variabile): | | Variabili modificabili dall'utente |
| TEXTDOMAIN (variabile): | | I18N per programmatore |
| TEXTDOMAIN (variabile), BEGIN (regola) e: | | I18N per programmatore |
| TEXTDOMAIN (variabile), portabilità e: | | Portabilità nell'I18N |
| textdomain(), funzione di libreria C: | | Utilizzare gettext |
| tilde (~), operatore ~: | | Uso di regexp |
| tilde (~), operatore ~: | | Espressioni regolari calcolate |
| tilde (~), operatore ~: | | Maiuscolo-Minuscolo |
| tilde (~), operatore ~: | | Costanti come espressioni regolari |
| tilde (~), operatore ~: | | Operatori di confronto |
| tilde (~), operatore ~: | | Operatori di confronto |
| tilde (~), operatore ~: | | Precedenza |
| tilde (~), operatore ~: | | Espressioni come criteri di ricerca |
| tipo di una variabile: | | Funzioni per i tipi |
| tolower() (funzione): | | Funzioni per stringhe |
| toupper() (funzione): | | Funzioni per stringhe |
| tr (programma di utilità): | | Programma translate |
| tracciatura a ritroso, mostrare nel debugger: | | Stack di esecuzione |
| trace (comando del debugger): | | Comandi vari del debugger |
| traduzione di stringhe, funzioni di: | | Funzioni di internazionalizzazione |
| traduzione di stringhe: | | Funzioni di internazionalizzazione |
| translate.awk (programma): | | Programma translate |
| trattare un file come un solo record: | | gawk divisione record |
| trattino basso (_), nei nomi di variabili private: | | Nomi di variabili di libreria |
| trattino basso (_), macro C: | | Utilizzare gettext |
| trattino basso (_), stringa traducibile: | | I18N per programmatore |
| trovare, sottostringhe in una stringa: | | Funzioni per stringhe |
| trovare, estensioni: | | Trovare le estensioni |
| Trueman, David: | | Storia |
| Trueman, David: | | Ringraziamenti |
| Trueman, David: | | Contributori |
| typeof() (funzione gawk): | | Funzioni per i tipi |
|
| U | | |
|---|
| u (comando del debugger), (alias per until): | | Controllo esecuzione debugger |
| uguale (=), operatore =: | | Operatori di assegnamento |
| uguale (=), operatore ==: | | Operatori di confronto |
| uguale (=), operatore ==: | | Precedenza |
| undisplay (comando del debugger): | | Vedere e modificare dati |
| unico record, trattare un file come un: | | gawk divisione record |
| Unicode: | | Funzioni ordinali |
| Unicode: | | Intervalli e localizzazione |
| Unicode: | | Glossario |
| uniq (programma di utilità): | | Programma uniq |
| uniq.awk (programma): | | Programma uniq |
| Unix, script awk e: | | Script eseguibili |
| Unix: | | Glossario |
| Unix awk, barra inversa in sequenze di protezione: | | Sequenze di protezione |
| Unix awk, file di password, separatore di campo e: | | Separatori campo da riga di comando |
| Unix awk, funzione close() e: | | Chiusura file e pipe |
| until (comando del debugger): | | Controllo esecuzione debugger |
| unwatch (comando del debugger): | | Vedere e modificare dati |
| up (comando del debugger): | | Stack di esecuzione |
| uscire dal debugger: | | Comandi vari del debugger |
| uscire dal debugger: | | Comandi vari del debugger |
| USR1 (segnale), per profilazione dinamica: | | Profilare |
| utente, funzioni definite dall’: | | Funzioni definite dall'utente |
| utenti, leggere la lista degli: | | Funzioni Passwd |
| utenti, informazioni riguardo agli, ottenere: | | Funzioni Passwd |
| utenti, informazioni riguardo agli, stampare: | | Programma id |
|
| V | | |
|---|
| valori, esadecimali, abilitare l’interpretazione di: | | Opzioni |
| valori, ottali, abilitare l’interpretazione di: | | Opzioni |
| valori, regexp: | | Costanti regexp forti |
| valori, di verità: | | Valori di verità |
| valori, numerici: | | Fondamenti sui tipi di dati |
| valori, di tipo stringa: | | Fondamenti sui tipi di dati |
| valori, scalari: | | Fondamenti sui tipi di dati |
| valutare espressioni, nel debugger: | | Vedere e modificare dati |
| valutazione, ordine di, concatenazione: | | Concatenazione |
| valutazione, ordine di: | | Operatori di incremento |
| variabile, ARGC/ARGV, portabilità e: | | Script eseguibili |
| variabile, FS, carattere TAB come: | | Opzioni |
| variabile, FILENAME: | | Leggere file |
| variabile, RT: | | gawk divisione record |
| variabile, OFS: | | Separatori di output |
| variabile, OFMT, POSIX awk in: | | OFMT |
| variabile, ERRNO, con funzione close(): | | Chiusura file e pipe |
| variabile, BINMODE: | | Variabili modificabili dall'utente |
| variabile, CONVFMT: | | Variabili modificabili dall'utente |
| variabile, FIELDWIDTHS: | | Variabili modificabili dall'utente |
| variabile, FPAT: | | Variabili modificabili dall'utente |
| variabile, FS: | | Variabili modificabili dall'utente |
| variabile, IGNORECASE: | | Variabili modificabili dall'utente |
| variabile, LINT: | | Variabili modificabili dall'utente |
| variabile, OFMT: | | Variabili modificabili dall'utente |
| variabile, OFS: | | Variabili modificabili dall'utente |
| variabile, ORS: | | Variabili modificabili dall'utente |
| variabile, PREC: | | Variabili modificabili dall'utente |
| variabile, ROUNDMODE: | | Variabili modificabili dall'utente |
| variabile, RS: | | Variabili modificabili dall'utente |
| variabile, SUBSEP: | | Variabili modificabili dall'utente |
| variabile, TEXTDOMAIN: | | Variabili modificabili dall'utente |
| variabile, ARGIND: | | Variabili auto-assegnate |
| variabile, ERRNO: | | Variabili auto-assegnate |
| variabile, FILENAME: | | Variabili auto-assegnate |
| variabile, FNR: | | Variabili auto-assegnate |
| variabile, NF: | | Variabili auto-assegnate |
| variabile, NR: | | Variabili auto-assegnate |
| variabile, RLENGTH: | | Variabili auto-assegnate |
| variabile, RSTART: | | Variabili auto-assegnate |
| variabile, RT: | | Variabili auto-assegnate |
| variabile, NR, modifica di: | | Variabili auto-assegnate |
| variabile, FNR, modifica di: | | Variabili auto-assegnate |
| variabile, ARGC/ARGV, utilizzo: | | ARGC e ARGV |
| variabile, IGNORECASE, indici di vettore e: | | Introduzione ai vettori |
| variabile, CONVFMT, indici di vettore e: | | Indici numerici di vettore |
| variabile, SUBSEP, vettori multidimensionali e: | | Vettori multidimensionali |
| variabile, RSTART, funzione match() e: | | Funzioni per stringhe |
| variabile, RLENGTH, funzione match() e: | | Funzioni per stringhe |
| variabile, IGNORECASE, programmi di esempio: | | Funzioni di libreria |
| variabile, FS, eseguire programmi awk e: | | Programma cut |
| variabile, IGNORECASE, funzioni di ordinamento dei vettori e: | | Funzioni di ordinamento di vettori |
| variabile, ERRNO: | | Reti TCP/IP |
| variabile, TEXTDOMAIN: | | I18N per programmatore |
| variabile, TEXTDOMAIN, BEGIN (regola) e: | | I18N per programmatore |
| variabile, TEXTDOMAIN, portabilità e: | | Portabilità nell'I18N |
| variabile, ROUNDMODE: | | Impostare modo di arrotondare |
| variabile, BINMODE: | | Uso su PC |
| variabili: | | Altre funzionalità |
| variabili, impostazione: | | Opzioni |
| variabili, predefinite, impostare con opzione -v: | | Opzioni |
| variabili, globali, stampare una lista delle: | | Opzioni |
| variabili, usare in comando getline: | | Getline variabile |
| variabili, usare in comando getline: | | Getline variabile file |
| variabili, usare in comando getline: | | Getline variabile pipe |
| variabili, usare in comando getline: | | Getline variabile coprocesso |
| variabili, definite dall’utente: | | Variabili |
| variabili, predefinite: | | Usare variabili |
| variabili, inizializzazione: | | Usare variabili |
| variabili, assegnare da riga di comando: | | Opzioni di assegnamento |
| variabili, conversione di tipo: | | Stringhe e numeri |
| variabili, tipi di: | | Operatori di assegnamento |
| variabili, tipi di: | | Tipi di variabile e confronti |
| variabili, tipi di, espressioni di confronto e: | | Tipi di variabile e confronti |
| variabili, di tipo indicatore (flag): | | Operatori booleani |
| variabili, predefinite: | | Variabili predefinite |
| variabili, predefinite, modificabili dall’utente: | | Variabili modificabili dall'utente |
| variabili, predefinite, che forniscono informazioni: | | Variabili auto-assegnate |
| variabili, non inizializzate, come indici di vettore: | | Indici non inizializzati |
| variabili, tipi di: | | Funzioni per i tipi |
| variabili, nascoste: | | Sintassi delle definizioni |
| variabili, locali, in una funzione: | | Campo di validità variabili |
| variabili, globali, per funzioni di libreria: | | Nomi di variabili di libreria |
| variabili, private: | | Nomi di variabili di libreria |
| variabili, di tipo indicatore (flag): | | Programma tee |
| variabili, globali, accesso dalle estensioni: | | Accedere alla tabella simboli |
| variabili, informative dell’API: | | Variabili informative di estens. API |
| variabili: | | Fondamenti sui tipi di dati |
| variabili d’ambiente, POSIXLY_CORRECT: | | Opzioni |
| variabili d’ambiente, usate da gawk: | | Variabili d'ambiente |
| variabili d’ambiente, AWKPATH: | | AWKPATH (Variabile) |
| variabili d’ambiente, AWKLIBPATH: | | AWKLIBPATH (Variabile) |
| variabili d’ambiente, GAWK_READ_TIMEOUT: | | Timeout in lettura |
| variabili d’ambiente, GAWK_SOCK_RETRIES: | | Continuazione dopo errori |
| variabili d’ambiente, nel vettore ENVIRON: | | Variabili auto-assegnate |
| variabili d’ambiente, LANGUAGE: | | Utilizzare gettext |
| variabili d’ambiente, GAWK_LOCALE_DIR: | | Utilizzare gettext |
| variabili d’ambiente, LANGUAGE: | | Esempio I18N |
| variabili d’ambiente, LC_ALL: | | Esempio I18N |
| variabili d’ambiente, LANG: | | Esempio I18N |
| variabili d’ambiente, LC_MESSAGES: | | Esempio I18N |
| variabili d’ambiente, AWKPATH: | | Uso su PC |
| VAX/VMS, numeri in virgola mobile,: | | Esecuzione su VMS |
| vero, valore logico (diverso da zero e da stringa nulla): | | Valori di verità |
| versione, di gawk: | | Variabili auto-assegnate |
| versione, della libreria GNU MP: | | Variabili auto-assegnate |
| versione, della libreria GNU MPFR: | | Variabili auto-assegnate |
| versione, dell’estensione API gawk: | | Variabili auto-assegnate |
| versione, dell’estensione API gawk: | | Versione dell'estensione |
| vettore, ARGV: | | Opzioni |
| vettore, ENVIRON: | | Variabili auto-assegnate |
| vettore, FUNCTAB: | | Variabili auto-assegnate |
| vettore, PROCINFO: | | Variabili auto-assegnate |
| vettore, SYMTAB: | | Variabili auto-assegnate |
| vettore, PROCINFO: | | Funzioni di tempo |
| vettore, PROCINFO: | | Funzioni Passwd |
| vettore, PROCINFO, verificare la divisione in campi: | | Funzioni Passwd |
| vettore, PROCINFO, process ID di utente e di gruppo e: | | Programma id |
| vettore, PROCINFO, comunicazioni attraverso le pty e: | | I/O bidirezionale |
| vettori: | | Vettori |
| vettori, indicizzazione di: | | Introduzione ai vettori |
| vettori, associativi: | | Introduzione ai vettori |
| vettori, sparsi: | | Introduzione ai vettori |
| vettori, ordinamento, variabile IGNORECASE e: | | Introduzione ai vettori |
| vettori, elementi, esaminare gli: | | Visitare elementi |
| vettori, elementi: | | Visitare elementi |
| vettori, elementi, non assegnati: | | Visitare elementi |
| vettori, elementi, inesistenti: | | Visitare elementi |
| vettori, elementi, assegnare valori: | | Impostare elementi |
| vettori, esempio sull’uso: | | Esempio di vettore |
| vettori, visitare: | | Visitare un intero vettore |
| vettori, istruzione for e: | | Visitare un intero vettore |
| vettori, elementi, ordine di accesso da parte dell’operatore in: | | Visitare un intero vettore |
| vettori, ordine di visita, controllo dell’: | | Controllare visita |
| vettori, indici, numerici: | | Indici numerici di vettore |
| vettori, indici, variabili non inizializzate come: | | Indici non inizializzati |
| vettori, elementi, eliminazione di: | | Cancellazione |
| vettori, eliminare l’intero contenuto: | | Cancellazione |
| vettori, multidimensionali: | | Vettori multidimensionali |
| vettori, multidimensionali, visitare: | | Visitare vettori multidimensionali |
| vettori, di vettori: | | Vettori di vettori |
| vettori, ordinamento: | | Funzioni per stringhe |
| vettori, determinare il numero degli elementi: | | Funzioni per stringhe |
| vettori, ordinamento, in base agli indici: | | Funzioni per stringhe |
| vettori, determinare il numero degli elementi: | | Funzioni per stringhe |
| vettori, come parametri di funzione: | | Parametri per valore/riferimento |
| vettori, associativi, funzioni di libreria e: | | Nomi di variabili di libreria |
| vettori, trasformare in stringhe: | | Funzione join |
| vettori, ordinamento, asort() (funzione gawk): | | Funzioni di ordinamento di vettori |
| vettori, ordinamento, asorti() (funzione gawk): | | Funzioni di ordinamento di vettori |
| vettori, ordinamento, variabile IGNORECASE e: | | Funzioni di ordinamento di vettori |
| vettori, manipolazione nelle estensioni: | | Manipolazione di vettori |
| Vinschen, Corinna: | | Ringraziamenti |
| virgola (,), negli intervalli di ricerca: | | Intervalli |
| virgola mobile, numeri in, precisione arbitraria: | | Calcolo con precisione arbitraria |
| virgola mobile, numeri in: | | Aritmetica del computer |
| virgola mobile, numeri in, precisione singola: | | Aritmetica del computer |
| virgola mobile, numeri in, precisione doppia: | | Aritmetica del computer |
| virgola mobile, numeri in, precisione arbitraria: | | Aritmetica del computer |
| visitare, vettori: | | Visitare un intero vettore |
| visitare, vettori multidimensionali: | | Visitare vettori multidimensionali |
| visualizzare le opzioni del debugger: | | Informazioni sul debugger |
| visualizzazioni automatiche, nel debugger: | | Informazioni sul debugger |
| VMS, installare gawk su: | | Installazione su VMS |
| VMS, compilare gawk per: | | Compilazione su VMS |
| vuoto, criterio di ricerca: | | Vuoto |
|
| W | | |
|---|
| w (comando del debugger), (alias per watch): | | Vedere e modificare dati |
| w (programma di utilità): | | Dati di lunghezza fissa |
| wait() (estensione): | | Esempio di estensione Fork |
| waitpid() (estensione): | | Esempio di estensione Fork |
| walk_array(), funzione definita dall’utente: | | Visitare vettori |
| Wall, Larry: | | Introduzione ai vettori |
| Wall, Larry: | | Future estensioni |
| Wallin, Anders: | | Contributori |
| watch (comando del debugger): | | Vedere e modificare dati |
| watchpoint (debugger): | | Terminologia nel debug |
| wc (programma di utilità): | | Programma wc |
| wc.awk (programma): | | Programma wc |
| Weinberger, Peter: | | Storia |
| Weinberger, Peter: | | Contributori |
| where (comando del debugger), (alias per backtrace): | | Stack di esecuzione |
| while (istruzione), uso di espressioni regolari in: | | Uso di regexp |
| while (istruzione): | | Istruzione while |
| Williams, Kent: | | Contributori |
| Woehlke, Matthew: | | Contributori |
| Woods, John: | | Contributori |
| wordfreq.awk (programma): | | Programma utilizzo parole |
| writea() (estensione): | | Esempio di estensione Rwarray |
|
| X | | |
|---|
| xgettext (programma di utilità): | | Estrazione di stringhe |
| XML, Expat, libreria per analizzare: | | gawkextlib |
| XOR (operazione sui bit): | | Funzioni a livello di bit |
| XOR (operazione sui bit): | | Funzioni a livello di bit |
| xor() (funzione gawk): | | Funzioni a livello di bit |
|
| Y | | |
|---|
| Yawitz, Efraim: | | Contributori |
|
| Z | | |
|---|
| Zaretskii, Eli: | | Ringraziamenti |
| Zaretskii, Eli: | | Contributori |
| Zaretskii, Eli: | | Manutentori |
| zerofile.awk (programma): | | File vuoti |
| Zoulas, Christos: | | Contributori |
|