[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [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 131.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.
expand [opzioni] [file...] |
|
Tabella 131.2. Alcune opzioni.
|
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.
unexpand [opzioni] [file...] |
|
Tabella 131.3. Alcune opzioni.
|
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, ma consente anche 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.
|
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 131.5 elenca queste sequenze di escape (si veda anche la sezione 307.1).
|
Tabella 131.5. Sequenze di escape per le stringhe di tr.
|
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.
sum [opzioni] [file...] |
Questo programma viene considerato obsoleto e al suo posto si preferisce utilizzare cksum
|
Tabella 131.6. Alcune opzioni. |
Il programma di servizio cksum (6) calcola un codice di controllo CRC (Cyclic redundancy check) per ogni file fornito negli argomenti:
cksum [opzioni] [file...] |
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:
md5sum [opzioni] [file...] |
In condizioni normali, md5sum emette una serie di righe nella forma:
firma file |
Per esempio, una cosa del genere:
fdbf0c571fb4942a6c505d732e163876 a2ps.1.gz f2c766c141c6e5bb55c8edf6ce4ecba6 ab.1.gz 00169ba95302aca74597f000b61c3255 access.1.gz 69cf0ef0436aff6830a8a8a11b53b27b addftinfo.1.gz |
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 131.8. Alcune opzioni.
|
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:
sha1sum [opzioni] [file...] |
sha1sum [opzioni] -c file |
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]
13c36c7b1327b2bf4bc692e27e55125f6335ea82 /bin/ash f4e6f05cafcffa4c43218f5b8c9e55a056cea459 /bin/bash 13c36c7b1327b2bf4bc692e27e55125f6335ea82 /bin/dash 20e6f3f8e2705e281be4892498550fd4a8c7c3e0 /bin/fdflush f4e6f05cafcffa4c43218f5b8c9e55a056cea459 /bin/rbash f4e6f05cafcffa4c43218f5b8c9e55a056cea459 /bin/sh |
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]
/bin/ash: OK /bin/bash: OK /bin/dash: OK /bin/fdflush: OK /bin/rbash: OK /bin/sh: OK |
|
Tabella 131.11. 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:
hexdump [opzioni] [file...] |
hd [opzioni] [file...] |
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 131.12. Alcune opzioni.
|
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.
Il programma di servizio hexcat, (10) consente di visualizzare il contenuto di uno o più file in forma esadecimale. Non prevede alcuna opzione:
hexcat [file...] |
L'esempio seguente mostra il funzionamento di hexcat:
$ hexcat /bin/true[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 60 89 04 08 34 00 00 00 ........`...4... 00000020 - b8 29 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............... 00000050 - 04 00 00 00 03 00 00 00 14 01 00 00 14 81 04 08 ................ 00000060 - 14 81 04 08 13 00 00 00 13 00 00 00 04 00 00 00 ................ 00000070 - 01 00 00 00 01 00 00 00 00 00 00 00 00 80 04 08 ................ ... ... 00002d40 - 00 00 00 00 00 00 00 00 20 00 00 00 00 00 00 00 ........ ....... 00002d50 - 01 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00 ................ 00002d60 - 00 29 00 00 b5 00 00 00 00 00 00 00 00 00 00 00 .)..µ........... 00002d70 - 01 00 00 00 00 00 00 00 ........ |
Appunti di informatica libera 2006.07.01 --- Copyright © 2000-2006 Daniele Giacomini -- <daniele (ad) swlibero·org>
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
10) hexcat software libero con licenza speciale
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome gestione_dei_file_presi_byte_per_byte.htm
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico]
