Especially if you use an ASCII-based terminal, files can
have characters that your terminal can't display.
Some characters will lock up your communications software or hardware,
make your screen look strange, or cause other weird problems.
So if you'd like to look at a file and you aren't sure what's in there,
it's not a good idea to just
It turns non-printable characters into a printable form.
In fact, although most manual pages don't explain how, you can read the
output and see what's in the file.
Another utility for displaying non-printable files is
I usually use its
option when I need to look at a file
character by character.
Let's look at a file that's almost guaranteed to be unprintable: a
This example is on a
standard V7 (UNIX Version 7) filesystem.
(Unfortunately, some UNIX systems won't let you read a directory.
If you want to follow along on one of those systems, try a
compressed file (
or an executable program from
A directory usually has some long lines, so it's a good idea to pipe
's output through
cat -v . | fold -62
od -c .
0000000 377 016 . \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
0000020 > 007 . . \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
0000040 341 \n c o m p \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
0000060 \0 \0 M a s s A v e F o o d \0 \0 \0
0000100 \0 \0 h i s t \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
Each entry in a V7-type directory is 16 bytes long (that's also 16
characters, in the
command starts each line with the number of bytes, in
octal, shown since the start of the file.
The first line starts at byte 0.
The second line starts at byte 20 (that's byte 16 in decimal, the way most of
And so on.
for now, though.
We'll come back in a minute.
Time to dissect the
You've probably seen sequences like
Those are control characters.
(Find them in the
Another character like this is
, the character NUL (ASCII 0).
There are a lot of NULs in the directory; more about that below.
A DEL character (ASCII 177 octal) is shown as
ASCII chart (
has its own symbol for characters outside the ASCII range
with their high bits set,
also called metacharacters.
prints those as
followed by another character.
There are two of them in the
To get a metacharacter, you add 200 octal.
Let's look at
The octal value of the letter
, it means the character you get
by adding 141+200, or 341 octal.
You can decode the character
in the same way.
stands for the DEL character, which is octal 177.
Add 200+177 to get 377 octal.
If a character isn't
it's a regular printable character.
The entries in the directory (
) are all made of regular ASCII
If you're wondering where the entries
are in the
listing, the answer is: they aren't.
Those entries have been deleted from the directory.
two NUL (ASCII 0, or
) bytes in front of the name when
a file has been deleted.
has two options,
for displaying white space in a line.
option doesn't convert TAB and trailing space characters to a
visible form without those options.
Next, time for
it's easier to explain than
shows some characters starting with a backslash (
It uses the standard UNIX and C abbreviations for
control characters (
where it can.
stands for a newline character,
for a tab, etc.
There's a newline at the start of the
entry - see it in the
That explains why the
output was broken onto a new line
at that place:
doesn't translate newlines when it finds them.
is a NUL character (ASCII 0).
It's used to pad the ends of entries in V7 directories when a name isn't the
full 14 characters long.
shows the octal value of other characters as three digits.
For instance, the
means "the character 7 octal."
shows this as
Metacharacters, the ones with octal values 200 and above, are shown as
, you'll see their octal values - like
Each directory entry on a
UNIX Version 7 filesystem
starts with a two-byte "pointer" to its location in the
disk's inode table.
When you type a filename, UNIX uses this pointer to find the actual file information
on the disk.
The entry for this directory (named
Its parent (named
) is at
's entry is
Find those in the
output, if you want - and compare the two
, regular printable characters are shown as is by
program finds printable strings of characters (such as filenames) inside
mostly non-printable files (like executable binaries).