Provided by: hexer_1.0.5-2_amd64 bug

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
           Display a short help message and exit.

       -V, --version
           Display program version information and exit.

       -F, --features
           List the features supported by the program 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