[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico] [volume] [parte]
Alcuni programmi si occupano di elaborare i file a livello di byte. Per esempio, può trattarsi di trasformazioni di caratteri singoli o di spazi in caratteri di tabulazione e viceversa. Comunque, a questo livello, non è detto che debba sempre trattarsi di file di testo puri e semplici.
Tabella 96.1. Riepilogo dei programmi per la gestione dei file a livello di byte.
Alcuni programmi consentono di convertire il contenuto di un file, operando a livello di byte. La situazione più comune riguarda l'espansione dei caratteri di tabulazione (ovvero la loro trasformazione in caratteri spazio normali, nella quantità necessaria a mantenere le distanze previste) e, nel senso opposto, la conversione inversa per ridurre la dimensione complessiva del file.
Il programma di servizio expand (1) emette attraverso lo standard output una trasformazione dei file forniti come argomento, in cui i simboli di tabulazione sono trasformati in spazi veri e propri. Se non viene specificato diversamente attraverso le opzioni, gli stop di tabulazione si intendono ogni otto caratteri.
|
|
Tabella 96.2. Alcune opzioni.
| Opzione | Descrizione |
|
| Permette di specificare una tabulazione diversa da quella predefinita (ogni otto colonne). Se viene specificato solo un numero, si intende una tabulazione ogni n colonne, altrimenti, si intende una sequenza di stop di tabulazione, in cui la prima colonna corrisponde al numero zero. Una volta esaurito l'elenco, gli stop di tabulazione successivi vengono sostituiti con uno spazio singolo. |
|
| Questa è una variante dell'opzione -t, in cui si mette direttamente il numero corrispondente alla tabulazione che si vuole avere. |
|
| Converte solo i caratteri di tabulazione iniziali, cioè quelli che precedono caratteri diversi da spazio, o che precedono altri caratteri di tabulazione. |
I comandi mostrati sotto sono equivalenti: servono tutti a espandere i caratteri di tabulazione del file pippo.txt generando il file pippo1.txt, utilizzando intervalli di tabulazione ogni otto colonne. Il valore è stato specificato per completezza, dal momento che un intervallo di otto colonne è quello predefinito.
$ expand -8 pippo.txt > pippo1.txt[Invio]
$ expand -t 8 pippo.txt > pippo1.txt[Invio]
$ expand --tabs=8 pippo.txt > pippo1.txt[Invio]
Il programma di servizio unexpand (2) emette attraverso lo standard output una trasformazione dei file forniti come argomento, in cui gli spazi sono trasformati in caratteri di tabulazione per quanto possibile. Se non viene specificato diversamente attraverso le opzioni, gli stop di tabulazione si intendono ogni otto caratteri. Normalmente, il programma trasforma solo gli spazi iniziali.
|
|
Tabella 96.3. Alcune opzioni.
| Opzione | Descrizione |
|
| Permette di specificare una tabulazione diversa da quella predefinita (ogni otto colonne). Se viene specificato solo un numero, si intende una tabulazione ogni n colonne, altrimenti, si intende una sequenza di stop di tabulazione, in cui la prima colonna corrisponde al numero zero. Una volta esaurito l'elenco, non vengono fatte altre trasformazioni. |
|
| Non si limita a trasformare solo gli spazi iniziali. |
Esiste un programma di servizio che spesso passa inosservato, ma è molto importante nell'elaborazione di file a livello di byte singolo (o di carattere). Si tratta di tr, (3) il cui obiettivo fondamentale è quello di convertire un insieme di caratteri (o di simboli) in un altro insieme, oppure consente l'eliminazione di alcuni caratteri, oppure solo di quelli doppi. Dal momento che con tr è necessario distinguere tra situazioni differenti, è opportuno descrivere separatamente la sua sintassi. L'elenco di modelli sintattici che viene mostrato è semplificato rispetto alle possibilità effettive di tr; inoltre si deve considerare che l'input proviene dallo standard input e l'output viene emesso attraverso lo standard output.
| Modello sintattico | Descrizione |
|
| Questo rappresenta la situazione comune, in cui l'insieme di caratteri indicato nella prima stringa viene sostituito con l'insieme dei caratteri della seconda stringa. |
|
| Con l'opzione -s (ovvero --squeeze-repeats), si intendono eliminare i doppioni, relativi ai caratteri indicati nella stringa. |
|
| Con l'opzione -d (ovvero --delete), si intendono eliminare i caratteri indicati nella stringa. Se si usa anche l'opzione -c (--complement), i caratteri che vengono eliminati sono tutti esclusi quelli della stringa indicata. |
|
| Se alla cancellazione si aggiunge l'opzione di eliminazione dei doppioni, le cose vanno diversamente: prima vengono eliminati i caratteri corrispondenti a quelli della prima stringa; quindi vengono eliminati i doppioni dei caratteri appartenenti alla seconda stringa. |
Le stringhe utilizzate come argomenti di tr vanno scritte secondo una sintassi particolare, che assomiglia vagamente alle espressioni regolari. In generale, ogni carattere (lettera, numero, simbolo) rappresenta esattamente se stesso, salvo le eccezioni che vengono descritte qui.
Sono ammissibili delle sequenze di escape formate da una barra obliqua inversa seguita da un carattere o da un numero che deve essere inteso in modo ottale. La tabella 96.5 elenca queste sequenze di escape (si veda anche la sezione 255.1).
Tabella 96.5. Sequenze di escape per le stringhe di tr.
| Codice | Descrizione |
|
| <BEL>. |
|
| <BS>. |
|
| <FF>. |
|
| <LF>. |
|
| <CR>. |
|
| <HT> (tabulazione normale). |
|
| <VT>. |
|
| Il carattere corrispondente al codice ottale indicato. |
|
| Una barra obliqua inversa singola. |
Possono essere indicati degli intervalli di caratteri, attraverso la notazione m-n. Il carattere iniziale, m, deve essere precedente a quello finale, in base alla sequenza stabilita dalla codifica a cui si fa riferimento. A titolo di esempio, l'intervallo 0-4, è equivalente alla sequenza di caratteri 01234.
È possibile indicare una serie di caratteri ripetuti, attraverso una notazione particolare: [x*n]. Qui le parentesi quadre fanno parte della notazione: x è il carattere da ripetere n volte. Se si omette il numero, si intende una quantità indefinitamente grande. È probabile che non sia conveniente l'uso di questa forma, anche per non complicare inutilmente l'interpretazione umana degli argomenti di tr; tuttavia è necessario conoscerne l'esistenza, per poter leggere gli script realizzati da altri.
Possono essere indicate delle classi di caratteri, in modo simile alle espressioni regolari: [:classe:]. Le classi utili nella traduzione da un insieme all'altro sono solo lower e upper, allo scopo di convertire le lettere minuscole in maiuscole, oppure per fare l'inverso. Tutte le altre classi possono servire solo per la cancellazione dei caratteri, dal momento che non si espandono in un modo ordinato e prevedibile.
In teoria, è ammissibile anche la notazione delle classi di equivalenza: [=x=], che però, allo stato attuale, nella realizzazione GNU di tr non serve a molto, dal momento che si traduce semplicemente nella stessa lettera indicata (x).
La traslitterazione è l'operazione più semplice da realizzare con tr; basta l'indicazione delle stringhe: quella di origine e quella di destinazione. Vengono mostrati alcuni esempi.
$ tr abc def < primo.txt > secondo.txt[Invio]
Questo esempio mostra la lettura del file primo.txt, che viene elaborato da tr in modo da trasformare ogni lettera «a» in «d», ogni lettera «b» in «e» e ogni lettera «c» in «f». Il risultato viene salvato nel file secondo.txt.
$ tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ \
\< primo.txt > secondo.txt[Invio]
$ tr a-z A-Z < primo.txt > secondo.txt[Invio]
$ tr '[:lower:]' '[:upper:]' < primo.txt > secondo.txt[Invio]
Questi tre esempi sono molto simili: quello che si vuole ottenere è la conversione delle lettere minuscole in maiuscole. Di sicuro, il modo più corretto per raggiungere questo risultato è quello di utilizzare l'ultima delle tre forme, dal momento che così si dovrebbe garantire la compatibilità con le proprie convenzioni locali, includendo correttamente anche le lettere accentate (che qui non sono state mostrate).
La cancellazione serve solo per eliminare dei caratteri, senza convertirli in qualche modo. Il comando seguente può essere utile per convertire un file di testo in cui il codice di interruzione di riga è in stile Dos, ovvero è composto dalla sequenza <CR><LF>.
$ tr -d '\r' < primo.txt > secondo.txt[Invio]
In questo modo si elimina solo il codice <CR>, rappresentato dalla sequenza di escape \r, ottenendo di lasciare solo i codici <LF>, adatti nella maggior parte dei sistemi Unix.(4)
$ tr -s '\n' < primo.txt > secondo.txt[Invio]
Con questo comando si vogliono eliminare le righe vuote multiple; tuttavia, non vengono eliminate le righe che sono semplicemente bianche, intese come quelle che contengono degli spazi.
$ tr -c -s '[a-zA-Z0-9]' '[ *]' < primo.txt > secondo.txt[Invio]
Questo esempio mostra l'uso dell'opzione di complemento (-c). In pratica, si vogliono identificare nella prima stringa tutti i caratteri che non siano alfanumerici (escludendo le lettere accentate), sostituendoli con un carattere spazio. Per indicare tanti caratteri spazio quanti sono necessari nella seconda stringa, si utilizza la notazione speciale [ *] che ripete lo spazio in modo indefinito. Infine, gli spazi multipli vengono semplicemente eliminati.
$ tr -c -s '[a-zA-Z0-9]' '[\n*]' < primo.txt > secondo.txt[Invio]
Il comando appena mostrato si comporta come nell'esempio precedente, solo che invece di usare lo spazio per sostituire ciò che non è un carattere alfanumerico, si utilizza il codice <LF>, corrispondente al codice di interruzione di riga. Lo scopo è quello di individuare tutte le parole del testo e di ottenerne l'elenco, dove ognuna occupa una riga separata.
$ tr -c -s '[:alnum:]' '[\n*]' < primo.txt > secondo.txt[Invio]
Questa variante precisa meglio l'intenzione di selezionare tutti i caratteri non alfanumerici, perché la stringa di cui si fa il complemento contiene l'indicazione della classe alnum, che comprende anche le lettere accentate della propria localizzazione.
Alcuni programmi si occupano di calcolare valori di vario genere in base al contenuto dell'input. Può trattarsi del conteggio di elementi determinati o del calcolo di codici di controllo (checksum).
Il programma di servizio sum (5) calcola un codice di controllo a 16 bit per ogni file fornito negli argomenti. Emette attraverso lo standard output il valore ottenuto insieme alla dimensione (arrotondata) in blocchi. Il valore predefinito della dimensione dei blocchi è di 1 024 byte.
|
|
Questo programma viene considerato obsoleto e al suo posto si preferisce utilizzare cksum
Tabella 96.6. Alcune opzioni.
| Opzione | Descrizione |
|
| Utilizza l'algoritmo predefinito (compatibile con BSD). |
|
| Utilizza l'algoritmo compatibile con System V. In tal caso, i blocchi hanno una dimensione di 512 byte. |
Il programma di servizio cksum (6) calcola un codice di controllo CRC (Cyclic redundancy check) per ogni file fornito negli argomenti:
|
|
Non utilizza opzioni, tranne quelle standard dei programmi GNU.
Il programma di servizio md5sum (7) calcola un codice di controllo MD5 (Message digest) a 128 bit per ogni file fornito negli argomenti, oppure verifica la corrispondenza di una serie di codici di controllo accumulati precedentemente in un file, con i file relativi:
|
|
In condizioni normali, md5sum emette una serie di righe nella forma:
|
|
Per esempio, una cosa del genere:
|
Questa informazione può essere conservata per verificare in seguito se gli stessi file corrispondono sempre agli originali, oppure se sono stati danneggiati o manomessi. La verifica può essere manuale (visiva), oppure può essere lo stesso md5sum a verificarla, utilizzando per questo l'opzione -c.
Tabella 96.7. Alcune opzioni.
| Opzione | Descrizione |
|
| Utilizzando questa opzione, negli argomenti di md5sum si può indicare solo un file, che deve consistere nell'elenco di firme abbinate ai file corrispondenti: vengono ricalcolate le firme di questi file e viene verificata la corrispondenza con le firme già annotate. In caso di differenza, viene emessa una segnalazione di errore. |
|
| Genera maggiori informazioni. |
Segue la descrizione di alcuni esempi.
$ md5sum *.txt > firme[Invio]
Raccoglie le firme MD5 di tutti i file che terminano con l'estensione .txt.
$ md5sum -c firme[Invio]
Controlla tutti i file elencati nel file firme per verificare che il contenuto di questi non sia stato alterato in alcun modo.
Il programma di servizio sha1sum (8) calcola un codice di controllo SHA1 a 160 bit per ogni file fornito negli argomenti, oppure verifica la corrispondenza di una serie di codici di controllo accumulati precedentemente in un file, con i file relativi:
|
|
|
|
In condizioni normali il programma serve a calcolare codice di controllo dei file indicati alla fine della riga di comando, generando un risultato simile a quello dell'esempio seguente:
$ sha1sum /bin/*sh[Invio]
|
Questa informazione può essere conservata per verificare in seguito se gli stessi file corrispondono sempre agli originali, oppure se sono stati danneggiati o manomessi. La verifica può essere manuale (visiva), oppure può essere lo stesso programma a farla, utilizzando per questo l'opzione -c, ma in tal caso si fornisce un solo file, che corrisponde a quello contenente l'elenco accumulato in precedenza. Nell'esempio seguente si suppone di avere salvato il controllo precedente nel file elenco.sha1sum:
$ sha1sum -c elenco.sha1sum[Invio]
|
Tabella 96.8. Alcune opzioni.
Per poter leggere il contenuto di file che non sono soltanto file di testo, diventa necessario trasformare alcuni o tutti i byte in qualcosa di leggibile, come può essere in esadecimale o in ottale.
Il programma di servizio hexdump, o hd, (9) consente di visualizzare il contenuto di un file binario attraverso una qualche forma di trasformazione utile per la lettura umana:
|
|
|
|
I due modelli sintattici mostrano l'uso di questo programma attraverso nomi diversi; in particolare, l'uso del nome hd implica automaticamente la presenza dell'opzione -C. Se si omette l'indicazione dei file nella riga di comando, il programma utilizza per questo lo standard input.
Tabella 96.9. Alcune opzioni.
| Opzione | Significato mnemonico | Descrizione |
|
| byte | Mostra una traduzione del contenuto del file in ottale, separando i codici in ottale, byte per byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C. |
|
| character | Mostra una traduzione del contenuto del file in modo normale, quando possibile, altrimenti usa la notazione ottale. I byte vengono separati uno a uno. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C. |
|
| canonical | Mostra il risultato in forma «canonica», pari all'uso del comando con il nome hd. |
|
| decimal | Mostra una traduzione del contenuto del file in forma decimale, dove ogni valore corrisponde a una coppia di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C. |
|
| octal | Mostra una traduzione del contenuto del file in forma ottale, a coppie di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C. |
|
| exadecimal | Mostra una traduzione del contenuto del file in forma esadecimale, a coppie di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C. |
|
| length | Legge solo i primi n byte. |
|
| skip | Salta i primi n byte a partire dall'inizio del file. |
Vengono mostrati alcuni esempi, senza spiegazione, che prendono in considerazione lo stesso file di partenza:
$ hexdump /bin/arch[Invio]
0000000 457f 464c 0101 0001 0000 0000 0000 0000 0000010 0002 0003 0001 0000 8300 0804 0034 0000 0000020 0710 0000 0000 0000 0034 0020 0007 0028 0000030 0018 0017 0006 0000 0034 0000 8034 0804 0000040 8034 0804 00e0 0000 00e0 0000 0005 0000 ... 0000aa0 0004 0000 0000 0000 0001 0000 0003 0000 0000ab0 0000 0000 0000 0000 0658 0000 00b5 0000 0000ac0 0000 0000 0000 0000 0001 0000 0000 0000 0000ad0 |
$ hd /bin/arch[Invio]
00000000 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 |.ELF............| 00000010 02 00 03 00 01 00 00 00 00 83 04 08 34 00 00 00 |............4...| 00000020 10 07 00 00 00 00 00 00 34 00 20 00 07 00 28 00 |........4. ...(.| 00000030 18 00 17 00 06 00 00 00 34 00 00 00 34 80 04 08 |........4...4...| 00000040 34 80 04 08 e0 00 00 00 e0 00 00 00 05 00 00 00 |4...à...à.......| ... 00000aa0 04 00 00 00 00 00 00 00 01 00 00 00 03 00 00 00 |................| 00000ab0 00 00 00 00 00 00 00 00 58 06 00 00 b5 00 00 00 |........X...µ...| 00000ac0 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 |................| 00000ad0 |
$ hexdump -b /bin/arch[Invio]
0000000 177 105 114 106 001 001 001 000 000 000 000 000 000 000 000 000 0000010 002 000 003 000 001 000 000 000 000 203 004 010 064 000 000 000 0000020 020 007 000 000 000 000 000 000 064 000 040 000 007 000 050 000 0000030 030 000 027 000 006 000 000 000 064 000 000 000 064 200 004 010 0000040 064 200 004 010 340 000 000 000 340 000 000 000 005 000 000 000 ... 0000aa0 004 000 000 000 000 000 000 000 001 000 000 000 003 000 000 000 0000ab0 000 000 000 000 000 000 000 000 130 006 000 000 265 000 000 000 0000ac0 000 000 000 000 000 000 000 000 001 000 000 000 000 000 000 000 0000ad0 |
$ hexdump -c /bin/arch[Invio]
0000000 177 E L F 001 001 001 \0 \0 \0 \0 \0 \0 \0 \0 \0 0000010 002 \0 003 \0 001 \0 \0 \0 \0 203 004 \b 4 \0 \0 \0 0000020 020 \a \0 \0 \0 \0 \0 \0 4 \0 \0 \a \0 ( \0 0000030 030 \0 027 \0 006 \0 \0 \0 4 \0 \0 \0 4 200 004 \b 0000040 4 200 004 \b à \0 \0 \0 à \0 \0 \0 005 \0 \0 \0 ... 0000aa0 004 \0 \0 \0 \0 \0 \0 \0 001 \0 \0 \0 003 \0 \0 \0 0000ab0 \0 \0 \0 \0 \0 \0 \0 \0 X 006 \0 \0 µ \0 \0 \0 0000ac0 \0 \0 \0 \0 \0 \0 \0 \0 001 \0 \0 \0 \0 \0 \0 \0 0000ad0 |
$ hexdump -d /bin/arch[Invio]
0000000 17791 17996 00257 00001 00000 00000 00000 00000 0000010 00002 00003 00001 00000 33536 02052 00052 00000 0000020 01808 00000 00000 00000 00052 00032 00007 00040 0000030 00024 00023 00006 00000 00052 00000 32820 02052 0000040 32820 02052 00224 00000 00224 00000 00005 00000 ... 0000aa0 00004 00000 00000 00000 00001 00000 00003 00000 0000ab0 00000 00000 00000 00000 01624 00000 00181 00000 0000ac0 00000 00000 00000 00000 00001 00000 00000 00000 0000ad0 |
$ hexdump -o /bin/arch[Invio]
0000000 042577 043114 000401 000001 000000 000000 000000 000000 0000010 000002 000003 000001 000000 101400 004004 000064 000000 0000020 003420 000000 000000 000000 000064 000040 000007 000050 0000030 000030 000027 000006 000000 000064 000000 100064 004004 0000040 100064 004004 000340 000000 000340 000000 000005 000000 ... 0000aa0 000004 000000 000000 000000 000001 000000 000003 000000 0000ab0 000000 000000 000000 000000 003130 000000 000265 000000 0000ac0 000000 000000 000000 000000 000001 000000 000000 000000 0000ad0 |
$ hexdump -x /bin/arch[Invio]
0000000 457f 464c 0101 0001 0000 0000 0000 0000 0000010 0002 0003 0001 0000 8300 0804 0034 0000 0000020 0710 0000 0000 0000 0034 0020 0007 0028 0000030 0018 0017 0006 0000 0034 0000 8034 0804 0000040 8034 0804 00e0 0000 00e0 0000 0005 0000 ... 0000aa0 0004 0000 0000 0000 0001 0000 0003 0000 0000ab0 0000 0000 0000 0000 0658 0000 00b5 0000 0000ac0 0000 0000 0000 0000 0001 0000 0000 0000 0000ad0 |
La pagina di manuale hexdump(1) riporta anche altre opzioni che qui non sono state indicate; in particolare, è possibile programmare il risultato dell'elaborazione attraverso le opzioni -e e -f.
Appunti di informatica libera 2004.10.10 --- Copyright © 2000-2004 Daniele Giacomini -- <daniele (ad) swlibero·org>, <daniele·giacomini (ad) poste·it>
1) GNU core utilities GNU GPL
2) GNU core utilities GNU GPL
3) GNU core utilities GNU GPL
4) Purtroppo non si può ottenere il contrario con tr.
5) GNU core utilities GNU GPL
6) GNU core utilities GNU GPL
7) GNU core utilities GNU GPL
8) GNU core utilities GNU GPL
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome gestione_dei_file_presi_byte_per_byte.html
[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico]