NAME
hexer - binary file editor
SYNOPSIS
hexer [options] [file [...]]
DESCRIPTION
hexer is a multi-buffer editor for viewing and manipulating binary
files. It can’t (shouldn’t) be used for editing block devices, because
it tries to load the whole file into a buffer (it should work for
diskettes). The most important features of hexer are: multi buffers,
multi level undo, command line editing with completion, binary regular
expressions (see below). The user interface is kept similar to vi, so
if you know how to use vi, you’ll get started easily.
OPTIONS
-R, --readonly
-v, --view
Edit files in read only mode.
-r, --recover filename
Recover the file filename after a crash. (not implemented)
-c, --command command
Start the editing session by executing the editor command command.
If command contains spaces, it must be surrounded by double quotes.
It is possible to specify multiple commands on the command line:
hexer -c command1 -c command2 ...
-t, --tite
Turn off the usage of the termcap/terminfo ti/te sequence.
-h, --help
Print out a short help message and exit.
+command
This is equivalent to the -c option.
Note: The long options are not available on all systems.
CUSTOMIZING
The editor reads its startup commands from the file ~/.hexerrc (another
startup file may be specified by setting the environment variable
HEXERRC). Empty lines and lines starting with a ‘"’‐character (double
quote) are ignored. It is not possible to have a command and a comment
in the same line.
EDITOR COMMANDS
As in vi, there are several editing modes:
Command Mode
Some commands in Command Mode can take a numeric argument. To
enter a numeric argument just type the (decimal) number. The
number will be echoed at the bottom line of the screen as you type.
To enter an octal number, type a ‘0’ as the first digit. To enter
a hexadecimal number, type ‘0x’ (this is not a problem, because the
x-command with a zero counter wouldn’t make sense anyway). Some of
the commands can take a visually selected area as an argument (see
subsection Visual Mode).
b Move backwards to the beginning of a word.
e Move to the end of a word.
G If a numeric argument n is given, move the cursor to
position n. If no argument is specified, set the position
to the end of the buffer. The first byte in the buffer is
at position ‘0’, so the command to move to the beginning of
the buffer is ‘0G’.
Control-G
Display the buffer name, size, status and the current
position at the bottom line.
h j k l
Move the cursor. The arrow keys work as well. The numeric
argument (if specified) determines the number rows or
columns the cursor will move. Different from vi: the cursor
can be positioned behind the last byte in the buffer.
i Enter Insert Mode (see below) at the current position of the
point. If a numeric argument n is given, the typed text
will be inserted n times. Note: Moving the cursor (using
the arrow keys) will discard the numeric argument.
n Move to the next match using the current RE. This is
equivalent to typing ‘/’, <Return>.
N Move to the previous match using the current RE. This is
equivalent to typing ‘?’, <Return>.
Control-O
Paste over. Copy the kill buffer to the current position
overwriting the contents of the current buffer. If a
numeric argument n is given, the kill buffer is pasted n
times.
p Paste. Insert the kill buffer at the current position. If
a numeric argument n is given, the kill buffer is pasted n
times.
r Replace a single byte using the Replace Mode. If an area is
selected, all bytes in the selected area are replaced. If a
numeric argument is given, the specified number of bytes is
replaced.
R Enter Replace Mode (see below). If a numeric argument n is
given, the replace command is repeated n times. Note:
Moving the cursor (using the arrow keys) will discard the
numeric argument.
Control-R
Redo the last undo.
u Undo the last change to the current buffer.
Whenever possible hexer creates a file name.hexer in the current
directory (the swapfile) for each buffer visited (where name is the
name of the buffer). All changes made to the buffer name are
stored in that file, so it is possible to undo (and redo) all
changes made to the buffer. If the swapfile can’t be created, the
undo list is stored in the memory.
v Enter Visual Mode (see below). Visual selection of areas.
w Move forward to the beginning of a word.
x Delete the byte under the cursor. If a numeric argument n
is given, n bytes are deleted. In Visual Mode, the selected
area is deleted. Note: The bytes deleted using the x-
command are not copied to the kill buffer.
Control-X
The same as the x-command, but the bytes deleted are copied
to the kill buffer.
y Yank. Yank the byte under the cursor into the kill buffer.
If a numeric argument n is given, n bytes are yanked into
the kill buffer. In Visual Mode, the selected area is
copied to the kill buffer.
zb Place the cursor in the bottom line of the screen.
zt Place the cursor in the top line of the screen.
zz Place the cursor in the middle line of the screen.
Note that the commands zb, zt and zz don’t change the
position in the file - only the screen is scrolled (if
necessary).
: Enter Exh Mode (see below). The Exh Mode is similar to the
ex-mode in vi, but not compatible. If an area is selected,
the bounds of the selection are copied to the command line.
/ Search forward through the buffer using a RE(regular
expression). If no RE is specified, the RE given in the
previous /- or ?-command is reused.
Note: The REs in hexer are a little bit different from
regular expressions in vi (see section REGULAR EXPRESSIONS).
? Search reverse using a regular expression.
. Repeat the last change to the buffer at the current
position. This means that if the previous command deleted n
bytes and replaced them by m other bytes (n or m may be
zero), the .-command will do exactly the same at the current
position in the file.
< Shift the hex column left n bytes, where n is the (optional)
numeric argument. Note that the <-command only changes the
way the buffer is displayed in the hex column, the buffer
itself is kept unchanged.
> Shift the hex column right n bytes.
Control-^
Switch to the alternate buffer (see below).
% Enter a calculator command (see section CALCULATOR).
Visual Mode
Select an area on the buffer. You can enter the Visual Mode by
using the v-command or by specifying an area in Exh Mode. The
selection starts at the cursor position when entering the Visual
Mode and ends at the current cursor position. You can leave the
Visual Mode without performing a command on the selected area by
pressing v or Escape. To perform a command on the selected area
simply enter the command as if you where in Command Mode. Commands
that can’t use the selection will ignore it. As in Command Mode,
it is possible to specify a numeric argument. Commands that can
take the selection as an argument will ignore the numeric argument.
Insert Mode
In Insert Mode the bytes you type are inserted at the current
position of the cursor. At any time, you can toggle the active
column (hex column or text column) by pressing the TAB-key. If the
hex column is active the bytes are entered as two digit hex
numbers, if the text column is active, the bytes are entered as
ASCII text. The Delete- or BackSpace-key deletes the previously
inserted byte. If the hex column is active, the previously
inserted nibble (hex digit) is deleted. It is not possible to
delete more bytes than have been inserted in the current insert
command. While in Insert Mode, you can move the cursor using the
arrow keys. Note that moving the cursor discards the numeric
argument given to the insert command. To leave the Insert Mode,
type Escape. If a numeric argument n was given to the insert
command and is hasn’t been discarded by a cursor movement, the
typed bytes are inserted n times.
Replace Mode
In Replace Mode you replace the bytes under the cursor as you type.
Hitting BackSpace restores the original contents of the buffer.
The effect of a numeric argument is similar to the Insert Mode: the
typed bytes are replaced n times. As in Insert Mode, moving the
cursor using the arrow keys discards the numeric argument.
Exh Mode
The Exh Mode in hexer is kept similar to the ex-mode in vi.
Typically, an exh command looks like:
:area command arguments
Perform the command command on the area area.
:command arguments
Perform the command command at the current
position.
:area Select the area area.
:position
Move the cursor to position position.
An area may be defined as:
position1,position2
The area starts at position1 and ends at
position2 (inclusive).
position
The area selects one byte at position
% The area selects the entire buffer.
A position may be defined as:
offset A decimal, octal (prefixed with ‘0’) or hex
(prefixed with ‘0x’) number.
. The beginning of the buffer.
$ The end of the buffer.
/regexp/
A regular expression (see section REGULAR
EXPRESSIONS). The buffer is searched forward
starting at the current position. If a match was
found, the current position is set to the
position of the match.
?regexp?
The buffer is searched reverse.
Commands may be abbreviated with a unique prefix of the
command, some commands may be abbreviated with a single
character, even if that character isn’t a unique prefix
of the command name. Currently the following commands
are supported:
s, substitute
Synopsis: area s /regexp/replace/flags
Search for the regular expression regexp and
replace it with replace (see section REGULAR
EXPRESSIONS). replace may contain ‘\’ references
to subexpressions of regexp. flags:
g: global, this flag is ignored (it doesn’t
make sense in a binary editor).
c: confirm, ask the user to confirm each
substitution.
(Note that the ‘/’ character used as separator
could be any character, it’s just common practice
to use ‘/’.) Trailing separators may be omitted.
If area is omitted, the whole buffer is searched.
w, write
Synopsis: area w filename
Write area to the file filename. If area is
omitted. the whole buffer is written to the file,
if filename is omitted, the filename associated
with the buffer is used.
r, read
Synopsis: position r filename
Insert the contents of the file filename at
position. If position is omitted, the current
position is used.
e, edit
Synopsis: e name or: e #
Change to buffer name. If there is no such
buffer, hexer tries to open a file named name and
load it into a new buffer. If name is a hash
sign (#), the alternate buffer is selected. On
success the current buffer becomes the alternate
buffer.
b, buffer
Synopsis: b name
or: b
Change to buffer name. On success the current
buffer becomes the alternate buffer. If name is
omitted, a list of all buffers is displayed.
n, next
Select the next buffer in the buffer list.
N, previous
Select the previous buffer in th buffer list.
S, skip
Select the next unvisited buffer in the buffer
list.
rewind Select the first buffer in the buffer list.
wall Write all unsaved buffers.
c, close
Synopsis: c name
or: c! name
or: c
or: c!
Close the buffer name. If name is omitted, the
current buffer is closed. If the buffer has been
modified, but not saved, it can’t be closed using
a :c-command; use :c! to override.
h, help
View an online help text.
q, quit
Synopsis: q name
or: q! name
or: q
or: q!
Close all buffers and exit the editor. If an
opened buffer has bee modified, but not saved,
the :q-command can’t be performed; use :q! to
override.
map
imap
vmap Synopsis: map from to
or: imap from to
or: vmap from to
The key sequence from is mapped to to. To enter
special keys (e.g. function keys), mask them
using Control-V. :map affects the Command Mode
only, :imap affects the Insert Mode only and
:vmap affects the Visual Mode only. It is not
possible to re-map key sequences on the command
line editor.
unmap
iunmap
vunmap Synopsis: unmap from
or: iunmap from
or: vunmap from
Delete a key mapping created with :map, :imap or
:vmap.
set Synopsis: set variable [...]
or: set variable=value [...]
or: set novariable [...]
or: set
There are not too many variables that could be
modified, this might change though. The
following variables can be used: iso (bool):
display the whole ISO-8859/1 character set; ascii
(bool): display ASCII characters only; TERM
(string): the name of the terminal; maxmatch
(number), specialnl (bool): see section REGULAR
EXPRESSIONS. :set called without an argument
lists all variables and values.
d, delete
Synopsis: area d
Delete all bytes in area. The deleted bytes are
copied to the kill buffer.
y, yank
Synopsis: area y
Copy the bytes in area to the kill buffer.
version
Display the version number of hexer.
zz Place the cursor in the middle line of the
screen. Note that the screen is scrolled (if
necessary); the cursor position is kept
unchanged.
zt Place the cursor in the top line of the screen.
zb Place the cursor in the bottom line of the
screen.
wq The same as :x.
x, exit
Save all buffers and exit the editor.
If a command is called and can’t use the given
positions, areas or arguments, the additional positions,
areas, arguments are ignored.
Conditional commands: It is possible to specify a list
of terminal names for which the given command should be
executed. The syntax is:
:terminals:command
where terminals is a colon-separated list of terminal
names. The command is executed if and only if the value
of TERM is in the list. I.e. you could have a command
like
:xterm:set iso
in your .hexerrc-file (use the ISO character set only if
working on an xterm).
Cursor Motion
In Command Mode, Insert Mode, Replace Mode and Visual
Mode, you can use the following cursor motion commands:
Arrow Keys
Move the cursor.
Control-F
Move forward one page.
Control-B
Move back one page.
Control-D
Move forward half a page.
Control-U
Move back half a page.
COMMAND LINE EDITING
On the command line you can use the following commands:
UpArrow DownArrow
Move up and down through the history of the current
context.
LeftArrow RightArrow
Move the cursor.
Control-A
Move the cursor to the beginning of the line.
Control-E
Move the cursor to the end of the line.
Control-K
Delete all characters from the current cursor
position up to the end of the line.
Control-U
Delete all characters from the beginning of the line
up to the current cursor position.
Delete
BackSpace
Delete the character left of the cursor.
Control-D
Delete the character under the cursor.
Enter Return
Accept the line.
Escape Discard the line. Note: This is different from vi.
TAB Try to complete currently typed word. If the
completion is not unique, the word is completed as
far as unique. If the TAB-key is hit twice on the
same position, a list of all possible completions is
displayed.
REGULAR EXPRESSIONS
In this section it is assumed that you are familiar with REs
(regular expressions). In most applications (egrep, vi,
...) REs work on lines, that means it is not possible to
use a RE containing a line break (newline character). In
hexer, the buffer is not split up into distinct lines and a
newline character is considered to be a ‘normal’ character,
now here’s the problem: imagine searching for "a.*b" in a 5
MB file, this would take very long (might be up to several
minutes on a slow machine). That’s why there’s a maxmatch
limit (a repeat operator matches at most maxmatch
occurrences of its operand). The default value of maxmatch
is 1024, but it may be customized using the :set-command.
For simple expressions (expressions for which the length of
the match can be determined from the expression) it is
possible to override the maxmatch limit by doubling the ‘*’
or ‘+’ operator, e.g. "a.**b" or "foo\(bar\)\+\+".
Note that the context specifiers ‘^’/‘$’ (beginning/end of a
line) and ‘\<’/‘\>’ (beginning/end of a word) are available
and actually do what you expect. If you don’t want the
atoms ‘.’ and ‘[^...]’ to match the newline character you
can set the specialnl option using the :set-command.
To enter a special character, you can use the standard C
‘\’‐escape sequences. To enter a character using its octal
code, use a ‘\o’‐prefix followed by up to three octal
digits. (C-style octal escapes are not supported, because
‘\0’, ... ‘\9’ are interpreted as back-references to
subexpressions of the RE.) To enter a character using it’s
hex code, type a ‘\x’-prefix followed by up to two hex
digits; decimal codes can be entered using a ‘\d’‐prefix
followed by up to three decimal digits. It is possible to
enter strings of codes by doubling the base specifier, e.g.
"\xxfe ff 5a 7e" or "\oo276 277 132 176". Note that such a
string is treated as an atom, i.e. the RE "\xxff fe*"
matches any number (< maxmatch) of repetitions of ff fe.
It is possible to use all kinds of character ‘\’‐escapes
(escapes representing a single character) within
‘[]’‐ranges. Within a range, the ‘o’ selecting an octal
base for the escape may be omitted, since back-references
within a range don’t make sense. When specifying a minimum
and/or maximum number of repetitions using the
‘\{,}’‐operator, the numbers may be given in decimal (no
prefix), octal (‘0’-prefix) or hex (‘0x’-prefix). If no
maximum number is specified and the operand is not a simple
expression, at most maxmatch matches will be found.
CALCULATOR
Hexer provides a simple calculator (myc) capable of all
operations available in C. To enter a myc command just
enter a % (percent) sign and an expression in infix
notation. It is possible to use parentheses. myc
understands the following binary infix operators (from
highest priority to lowest): ** (power), * (multiply), /
(divide), % (modulo), + (add), - (subtract), << (shift
left), >> (shift right), < (less), <= (less or equal), >
(greater), >= (greater or equal), == (equal), != (not
equal), & (arithmetical and), | (arithmetical or), ^
(arithmetical exclusive or), && (logical and), || (logical
or), = (assign); and the following unary prefix operators:
- (negate, unary minus), ! (logical not), ~ (bitwise
complement). myc knows three data types: boolean, integer
(32 bit), float (64 bit, equivalent to C double). On some
esoteric platforms the precision of integer and float may be
different. As in C the result of a division depends on the
data types of the operands. An integer divided by an
integer yields an integer. If you want the result to be a
float, make sure one of the operands is a float, e.g. type
4/7. instead of 4/7 or a/(b+0.) instead of a/b. The power
operation returns a float if the result is too large to fit
in an integer. The result of a calculation is stored in the
special variables $$ and $n where n is the number of the
command.
BUGS
Probably. Please report bugs to demetrio@cs.uni-sb.de.
COPYRIGHT
hexer is not in the public domain, but freely distributable.
It may be used for any non-commercial purpose. See file
COPYRIGHT for details.
AUTHOR
Sascha Demetrio
demetrio@cs.uni-sb.de