Provided by: hexer_0.2.3-1_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
           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