
   

NAME

   bed - Variable dataformat binary editor

SYNOPSIS

   bed [ Options ] [ Files ]

DESCRIPTION

   Menu  driven binary editor. Dataformats are ascii, unsigned and signed
   integers,  float,  bitflags,  bitfields,  labels,  ebcdic  and time_t.
   Different sizes and byte ordenings are possible. Datatypes can be used
   in  structures.  Other  dataformats,  filters  and  procedures  can be
   defined  in plugins. Contains copy, past, undo, redo, search, replace,
   marks,  record/play  and  context  sensitive  help.  Linux & FreeBSD &
   Win95: edit block devices (linux limit 1023 gigabyte).

  Interface

   Some  general  remarks  about  working  with  bed.  In  bed you can do
   everything  with  the  menu.  You  open  a  menu  by  pressing  Alt in
   combination  with  the  highlighted  key.  A  menuitem  is selected by
   pressing  only  the highlighted key or using movement keys followed by
   Enter.  You  can  get help about a menuitem by pressing F1. You escape
   from  menu  by  pressing  Esc.  In  dialog  boxes  you can jump to the
   highlighted character by pressing Alt-char or by using Tab and Alt-tab
   or  shift-tab. Options are switched on by pressing space or *. Buttons
   like  Ok  and Cancel are operated by moving to the button and pressing
   Enter.

   While  editing  the usual movement keys should work, if they don't run
   bed -k.

   Select  works  wp5.1  (and  vi)  like:  You  specify  a starting point
   (Alt-e,s)  and  with whatever moving function exist you go to an other
   point and you then press copy (Alt-e,c) or save selection (Alt-e,a).

   bed  has  only  a  typeover mode, so your data doesn't move to another
   offset  without  explicitly  saying  so.  To  extend a file you should
   explicitly  call Alt-e,x. If you like to left something out you should
   copy  everything  after  it  past  it over what you like to remove and
   truncate the file with Alt-e,t.

   To  be  able  to  handle  large files (e.g. whole harddrives) bed only
   holds in memory what is changed and reads the other parts from disk at
   the moments they are needed.

   If  bed  seems  to  get in some end less operation, you can try Ctrl-C
   (Ctrl-Break  when using win95 with pdcurses). It should bring bed back
   to it's main loop, but sometimes problems arise.

  Data types

   In  bed  you  can display the filecontent in different dataformats for
   example:  ASCII,  signed  and  unsigned  integers of variable base and
   size,  and  Floating  point  number of size 4 (float),8(double) and 12
   (long  double).  Beside  this  standard  types there are lots of other
   datatypes like: bitflags, bitfields, translate (enum), ebcdic etc. You
   can also also add new datatypes in plugins.

   composed datatype
   It  is also possible to form composed datatypes (structures, records).
   At  different  offset  within  a unit the filecontent is displays in a
   different datatype.
struct nameincome {
        char name[20];
        unsigned long income;
        };

   For  example  if  the  file  contains a database of strings of size 20
   followed  by  a  digit of 4 bytes, you can make a composed datatype of
   Ascii/20 and Dec/4. You do this simple by first making a ascii of size
   20  by  pressing  Alt-d,a  and  filling in 20 for Nr Bytes and setting
   Separate  and  then  adding  a  unsigned  integer  by pressing Alt-d,i
   setting for Nr bytes 4 and check Dec and Add field.

   All  kind  of  operations  which  can  be  applied  to  basic (single)
   datatypes  can  also be applied on composed datatypes: search, replace
   and  the  addition  of  a filter (e.g reorder). To do this you need to
   make  the  composed  datatype  the active datatype. You can do this by
   setting the cursor between two of its elements or by using Alt-y,t.

   Switching datatype
   Moving between parts of the screen with different datatypes you can do
   with Prev (Alt-d,v) and Next (Alt-d,n).
   Zooming  a  datatype  you  do with Full (Alt-d,f), removing a datatype
   with Remove (Alt-d,r).
   Save  selection  saves  the selected part of the file in the format of
   the active datatype.
   Adding datatypes
   You  can  add  a  datatype  with Ascii, Integer, Signed, Float, Clone.
   Clone gives an identical copy of the currently active datatype.
   Integer (alt-d,i) gives the following window:

   (*) Hex   ( ) Dec   ( ) Custom:
   ( ) Oct   ( ) Bin   Base nr:

   Nr bytes:   1
                          (*) Add field
     Ok        Cancel     ( ) Separate

   You  can  specify  the base of the integer in the field Base nr or you
   can  use  one  of  the  options  Hex,Oct,Dec  or  Bin.  Hex stands for
   hexidecimal,  Oct  for  octal, Dec for decimal and bin for binary. You
   can also check Custom and specify a base number.
   You  can  specify the number of bytes and the order in which the bytes
   are interpreted.
   You can set Add field or Separate. Separate makes a separate datatype.
   Add  field  means  that this datatype is added to the currently active
   datatype,  making  a  composed  datatype (struct, record). In the last
   case where in the existing datatype the new field is placed depends on
   the cursor position:
   -  At  the end of the existing datatype if the cursor is at the end of
   the screen
   -  At  the  beginning of the existing datatype if the cursor is at the
   beginning of the screen
   - Otherwise at the place closest to the cursor.
   - After the cursor position if the distances are equal
   Modifying datatypes:
   Basic  datatypes you can change by pressing Alt-y,g (Config). This are
   operation  you  can  apply  on  some  datatypes  which changes certain
   aspects  while leaving other aspects the same. It are usually the same
   options you had when creating a datatype.
   Filters:
   It  is possible to place filters between the file and a datatype. Such
   a  filter  can transform the filecontent before interpretating it as a
   certain kind of datatype. Currently there are the following filters:
   Reorder (Alt-y,o)
   Duplicate (Alt-y,i)
   Skip (Alt-y,k)
   Backward (Alt-t,d,backward)
   Index2table (Alt-t,d,index2table)
   Translate (Alt-d,l)
   You  can  find  a  description  by  pressing  F1  in the menu with the
   appropriate  menu  item  selected.  The  same description you can find
   somewhat  further  in this file in the list of all procedures. You can
   remove the last added filter by pressing Alt-y,m (Rm filter).
   When  using  some  filters,  filters,  like  Skip, Index2table and and
   possibly Backward, differences in file content are not always shown on
   the   screen.  Skip  for  example  skips  some  bytes.  Normal  search
   translates  the  search  string in a string of bytes and then searches
   for  this string in the raw content of the file. This is obviously not
   possible  if skipped bytes can contain different data within the file.
   Regex  search  uses  a different method. It first transformes the file
   content  to the search datatype and then searches in this datatype for
   the search string. So if you use this kind if filters you should check
   regex  search.  The  same  applies  for  other  datatype  were what is
   displayed can corresponced to different bytes like Float and Empty.

   Saving datatypes:
   Press  Alt-y,w  (Write Type) to save a datatype. You can read it again
   with  Alt-y,d  (Read  Type). /usr/share/bed/misc contains some example
   saved    datatypes.    Read   /usr/share/bed/misc/README.txt   for   a
   description.

  Search

   When  you  press on search of the Move menu (Alt-m,s), you come in the
   search  window.  Standard you search in the currently active datatype.
   To  select  a  different  data  type  you  press  on  space  when  the
   appropriate data type is selected (like Ascii).
   When you instead presses on Return the search string is also converted
   from the old data type to the new data type.
   Beside  this  there are also the usual features like starting from the
   top  or  the  bottum  of  the  file  instead  of  the cursor position,
   searching  backwards,  searching  case  insensitive  and using regular
   expressions.

   Regular  expression: Use the GNU regular expression library to match a
   pattern   against  the  text  (See  regex(7)  ).  When  using  regular
   expression  you  can search forward and backward in ascii text. In any
   other data type you can only search forward. When "Regular expression"
   is  not checked everything is first converted to a general byte string
   and  then for this byte string is searched in the file. When searching
   with regular expressions enabled the file is block for block converted
   to  the currently active datatype and this printable representation is
   searched  for  regular expressions in exactly the same way as when the
   file  was  originally  in  this form. This means for example that when
   searching case sensitively the hex datatype ff is different from FF.
   When using a floating point plugin different byte strings can give the
   same superficial appearance. When you convert the search pattern first
   into  bytes  and  then search for the bytes, you will only find one of
   this  underlying  byte  strings. When searching in regex mode you will
   find  all  of them. The char2 plugin contains a data type which leaves
   out  every  other  byte. And when converting to bytes you have to fill
   them  in with something and when in the file they are filled different
   you  will  not  find  the  byte string. But when searching only in the
   superficial appearance you can find them.
   I haven't tried any attempt to optimize regular expressions so regular
   expression  search in ascii is very slow, and this conversion to other
   datatypes  before  searching  makes  it  even  slower.  So  only small
   distances can be searched this way.
   Further shortcoming of regular expressions search:
   -  Only one hit in a single datatype is returned. When searching for 1
   in a hex datatype it stops only once in 11.
   -  The  same byte can generate a hit in different alignments. Only one
   is shown. To see them all you should change the alignment around every
   hit.

   Case  sensitive:  When  checked  upper  and  lower  case  are  treated
   distinctively
   Boundaries:  Multibyte  datatypes  can be aligned differently a 4 byte
   digit  can  start  at offset 0,1,2 or 3 and give then different 4 byte
   digits.  Without  checking  Boundaries  all  will  be  returned.  With
   Boundaries  checked only bytes aligned in the same way as is now shown
   on the screen are returned.
   Forward:  When  checked  the file is searched in the forward direction
   going  from  lower  to  higher  offsets.  When not checked the file is
   searched backward.
   Edge  file:  When  checked  the  file is searched from the edge of the
   file.  From  offset  0  when  searching forward, from end of file when
   searching backward.
   Find: Here you type the search pattern
   List:   Generated   a   list   of   all   hits.   When  compiled  with
   CONFIG_THREADS=y you can go on editing whilehits are marked so you can
   view them in marklist (Alt-k,l).
   Ascii, Dec etc give when checked the current active datatype. The last
   datatype is the currently active. In this case that it char2. Which is
   a plugin datatype.
   Nr  bytes:  give  the number of bytes each data item occupies. By some
   datatype you can change this for example by unsigned integers.

  Replace

   Everything  has  the  same meaning as in search, with a replace string
   added.
   At  the  place  where  the search string is found the replacestring is
   placed. The replace string
   overwrites the data. When Regular expression is checked you can insert
   the whole search string by & or
   supexpressions  by \1 \2 to \9. In the searchstring subexpressions are
   demarcated by \(pattern\).

  Tools

   A few options not handles by other menus.
   Numbertype:  changing  the number type in which the offset in the file
   is shown (or removing offset numbers).
   Messageline: switching the messageline on and off,
   Menu: switching the menu bar on and off
   Commandmode:  setting  commandmode on and off. Inside command mode the
   normal keys are not automatically put into the document. This makes it
   possible  to bound commands to normal keys, like is done inside vi. By
   default  there  are  no  keysbindings of this kind, but you can put it
   into the configuration file if you want.
   Procedures:  View list off all procedures which can be bounded to keys
   or  are  part  of the menu. Press return on a procedure to execute the
   procedure.
   Dynamic: view procedures defined in plugins
   Load plugin: filemanager to select a plugin
   Key binding: shows the procedure bounded to a particular key

OPTIONS

   -f bedrc
           Use configuration file bedrc, instead of env BEDRC
   or c
          /.bedrc or c:/Program Files/bed/bedrc
   -w
           Always test filesize
   -d SIZE
           Set filesize to SIZE (dangerous!!)
   -v
           Version information
   -c
           Source and compile info
   -h
           This screen
   -s FILE
           play recorded keystrokes file FILE
   -e procedure
           execute procedure at startup
   -p plugin
           load plugin at startup
   -k
           Configure key bindings for current terminal
   -B
           black-white
   The commandline you can specify files
   doslike
           separated with  caseinsenstive no wildcard
   unixlike
           separated with / casesensitive wildcards (*,?,[..],etc)
   extentions
   can use disk letters (e.g. c
          /)
   /cygdrive/c is c
          /
   inside bed
           separeted with   caseinsensitive wildcards



CONFIGURATION

   In  the  configuration file you can change colors, assign keys, change
   the  menulayout,  loud  plugins.  and configure to call procedure's at
   certain moments. As configuration file is used the first file found of
   following:  the  argument to -f at the commandline , the environmental
   variable BEDRC, ~/.bedrc or /usr/share/bed/bedrc.

  Path

   plugindir path
   Set  directory  were  is  looked  for  plugins  to  path. Also effects
   Alt-t,l.
   datatypedir path
   Set  directory  were  is  looked  for saved datatypes to path. Effects
   Alt-y,w and Alt-y,d.

  Keys

   When  the  keys don't work or you want to make different key bindings,
   you can assign
    new key bindings in the configuration file.
   In bedrc the keys are defined by lines of the following format:
   keys key1 key2 ...keyn = procedure

   for example:

   keys 27 115 = search

   In which case Alt-s is bound to 'search' which is the search function.

   The  numbers  are  a  decimal  representation  of the escape sequences
   generated  by  a  key  or  a key combination. Within bed you can press
   Alt-t,k to press a key and see the keycodes and keybinding.

   Bed version 0.2.7 added the possibility to make keys statements of the
   following format:
   keys capname = procedure
   capname is a terminfo name for a key sequence. For example
   keys kf1 = selectprocedure
   binds  selectprocedure  to  function  key  F1.  See  man  terminfo for
   details. There seems to be as much variation in keylabels as keycodes,
   so don't expect to much.

   bed -k
   If  you  only want to assign the right meaning to the keys used by the
   program  (instead of making new keybinding), you can press bed -k. You
   are  asked to press function keys and it will append the corresponding
   key assignments to ~/.bedrc.
   Personal keybindings
   If  you  want to make personal keybindings you should come to know the
   procedure  argument  to  keys. To come to know the name of a procedure
   mentioned  in  the  menu  or bounded to an other key you press Alt-t,k
   followed by the key or menukey combination.
   If  you  want  for  example  to know what the name is of the procedure
   behind  Alt-f,o  you  press  Alt-t,k  followed  by  Alt-f,o and on the
   commandline  you  see something like "menu item Alt-f,o = addfile". To
   bind this to insert you press Alt-t,k ,INS and get as answer something
   like:  No  keybinding  for  27  91 50 126 You add now at the bottum of
   ~/.bedrc
   keys 27 91 50 126 = addfile
   An  other  way  to  learn  the names of the procedures is the read the
   Procedures  section  later  in  this manual, but the program itself is
   always more up to date then the manual.

  Menu

   New  in  bed-0.2.12  is the possibility to change the menu layout. You
   can  add new items to the menu, add new menus and delete menuitems and
   menu's.  A  'menu'  corresponds  to the list of names you get when you
   press  for  example  Alt-f,  (the  menu  with  menulabel  "~File").  A
   'menuitem' corresponds on name in this list for example "~Open C-o".
   The  menu's  are  numbered. The first menu on the left usually "~File"
   has  number  0, the following menu "~Edit" number 1 etc. This number I
   will call 'menunum' in this manual.

   menu [menunum] menulabel [+]
   This  command  is  used to give a menu a certain label and keybinding.
   One  character  in  label  should be prefixed by ~ meaning that is the
   highlighted  letter  what should be pressed in combination with Alt to
   open the menu. The menu label should be surrounded by "'-s. e.g.
        menu 0 "My F~ile"
   Changes  the  label of the "~File" menu to "My ~File". To insert a new
   empty  menu  at position 0 shifting the other menu's to the right, you
   should add a + after the previous command, getting:
        menu 0 "My F~ile" +
   To create an empty menu at the very right you can use:
        menu 8 "~Hallo"
   In this case you can also leave out 8,
        menu "~Hallo"
   In  the  menu  command  menunum  defaults  to  the  highest  used menu
   number+1.

   menuitem   [menunum]   menuitemlabel   [keylabel]   [menitemnum]  [+]=
   procedure
   This command is used to add menuitems to menu's. For example:
          menuitem 0 "~Quit" 1 = quit

          menuitem menunum menuitemlabel menuitemnum
   Replaces  the existing menuitem at position 1 in menu 0 with the label
   "~Quit"  and  the  procedure  quit.  Menuitem's  are  numbered  from 0
   starting  from  above.  If  you  like  to  insert  the menuitem, while
   shifting  the  existing  menuitems  downwards,  you can add a +, which
   gives:
          menuitem 0 "~Quit" 1 + = quit
   If you like to add a keylabel (e.g. M-q) you can change it to
          menuitem 0 "~Quit" "M-q" 1 + = quit
   this will be displaced as something like " Quit M-q " to make M-q work
   you should also add something like:
          keys 27 113 =quit
   In  menuitem  menunum defaults to the last mentioned menu. menuitemnum
   defaults  to  the  highest menuitem number + 1 (in this menu). You can
   write:
     menu "S~imple"
     menuitem "~New" = emptyfile
     menuitem "~Open" = addfile
     menuitem "~Save" = dosave
     menuitem "~Quit" = quit

   menuitem [menunum] LINE [menitemnum] [+]
   This  command  is  used  to  create  a blank like in a menu (leaving a
   menuitem empty).
   To insert a line after "~Open" in the previous menu you can write:
        menuitem LINE 2 +

   deletemenu [menunum]
   This  command  is used to delete a menu and all it's menuitems. If you
   dislikes the first menu ("~File") you simply writes:
        deletemenu 0
   In deletemenu menunum defaults to the highest numbered menu.

   deletemenuitem [menunum] [menitemnum]
   Deletes  menuitem  menuitemnum  from menu menunum. menunum defaults to
   the last mentioned menu, menuitemnum to the highest numbered menuitem.
   When  only  one number is given it is interpret as meaning menuitemnum
   (for  menunum  the default is used). To delete the fourth menuitem out
   of the first menu, you write:
          deletemenuitem 0 3
   In all menu commands you can explicitly use the default value by using
   a negative number.

  Call_on

   Instead  of  calling a procedure after pressing a key or using a menu,
   you  can also specify in the configuration file that procedure will be
   called at certain moment (on startup,open,switch).
   call_on_start procedure
   Calls  procedure  at  startup,  which  means  after the program is has
   started, and a file is opened. Operated is on this file.
   call_on_open procedure
   Procedure is called every time a file is opened.
   call_on_switch procedure
   Procedure is called every time you switch to a file.

  Context

   When  you  use  more  than one terminal (for example linux console and
   rxvt),  you  can set a environmental variable to differentiate between
   the type of terminal and use the context key word in ~/.bedrc.
   Everything  started  with  the  context  keyword  until  the following
   context   keyword  or  end  of  file  is  only  used  when  the  right
   environmental variable set.
   The format of context is the following.
   context [!] variablename [variablevalue]
   For example:
   context term xterm
   You can also say
   context variablename
   when  it  should  apply  for all cases in which the variablename has a
   definition.
   For example
   context termcap
   applies in all cases in which termcap is defined.
   If  you like to apply the next configuration only when an enviromental
   variable  is  not  set  or  has a different value, you have to write !
   before the enviromental variable.
   context ! DISPLAY
   means  to  apply  the  statements following this context statement and
   before the next context statement only when DISPLAY is not set.
   If  there  is no environmental variable shared by the context you like
   to  give  the  same configuration you can set a environmental variable
   and use this at a context argument. It is possible to set enviromental
   variables within the configuration file with:
   setenv name val
   To do the same by TERM=cons25 as with TERM=cons50 you can write:
        context TERM cons25
        setenv consoleterm yes
        context TERM cons50
        setenv consoleterm yes
        context TERM cons43
        setenv consoleterm yes
        context consoleterm
        keys  27 91 97 = beginfile #S-F3
        keys  27 91 98 = endfile #S-F4
        keys  27 91 101 = middlepage #S-F7

   In combination with '!' you can this way create every possible boolean
   logic  formula  (using  the statement that every propositional logical
   formula  can be written with only not and or). With setenv you have an
   or  and  '!' adds the not. To apply statementZ only if X and Y you use
   "X and Y"<=>"not (not X or not Y)" transforming this to bedrc you get
context !X
setenv dont 1
context !Y
setenv dont 1
context !dont 1
statementZ



  Color

   Colors can also be changed in the configuration file. There are around
   17  screen  elements  which  you  can give a foreground and background
   color and a list of attributes (standout, underline, etc).
   The format is:

   color screen-element [foreground background] [attr,attr...]

   You can give only attributes or both the foreground and the background
   color and any number of attributes.

   The screen parts are the following:
   TEXT: The color the text is showed in. It is better not to give this a
   color because this makes the screen updating much slower (some feature
   of ncurses)
   COMMAND: the commandline
   SELECTION: selection
   CURSOR: cursor in active datatype
   CURSORPAS: cursor in passive datatype
   SELCURSOR: cursor during selection
   BAR: the menubar
   BARKEY: Key highlighting in the menubar
   MENU: Opened menu's
   MENUKEY: key highlighting in menu
   MENUSEL: color of menu element which is selected
   OPENTITLE: title of file manager
   OPENKEY: key highlighting of key manager
   OPENNORMAL: background key manager
   OPENLIST: color of non active items of list
   OPENLISTSEL: color of active item
   OPENLISTACT: color of active item when this piece is used
   SHOWBACK: Search/replace window
   SPACEAFTER: color of space before and between datatypes

   The  colors  and  attributes  are  just  the  colors and attributes of
   ncurses.  When  they  don't  look the way the name suggests you should
   send your complains to the makers of ncurses.

   Colors: BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE
   Attributes:  NORMAL  STANDOUT UNDERLINE REVERSE BLINK DIM BOLD PROTECT
   INVIS ALTCHARSET CHARTEXT

   For  me  only  STANDOUT  UNDERLINE  REVERSE  BLINK  BOLD have a useful
   meaning.
   On example:

   color BAR WHITE RED blink

   Which makes a blinking white on red menu bar (on my computer it blinks
   only under linux console and not in xterm or rxvt).

   To make the cursor bold and underlined you can do

   color cursor bold underline

   The  color lines can be intermixed with the keys lines and can also be
   specific to a context.


  Procedures

   When  you want to make you own key bindings you need to know the names
   of  the  procedures  you  can  bind  to keys. A selected subset of the
   procedures  can also be assigned by using the name of the key they are
   normally bound to. There are the following key labels: home , end, f1,
   up,  down,  left,  right, pgup, pgdn, stab, delete, backspace and esc.
   When  you  assign  a  key  sequence  to a key label the meaning in the
   filemanager, search window and menu is also changed. so
          keys 1 = home
   gives Contr-A the home functionality in all this application parts.

   For  the filemanager and search window this is the only way the change
   keybindings.  Inside  the  menu  you  can  also  change keybindings by
   putting 253 in front of the key numbers. See procedure firstmenuitem.
   What  follows  are  all  procedures  mentioned  in  the  menu  with  a
   description  and  their  place  in  the  menu.  It is exactly the same
   information as you get when you press F1 within the menu.

   addfile

                               Open (Alt-f,o)

   Filemanager:  Name:  Alt-n:  switch  to  line  were  you  can  write a
   filename. Del,Backspace,C-h,C-u,left,right,home,end,C-a and C-e should
   work  if bed is well configured (see bed.1 for key definitions) Files:
   Alt-f: switch to list of files. You can open a file by pressing Enter.
   Use  UP  and DOWN to move between files. Directories: Alt-d: switch to
   list of directories. Change to directory by pressing Enter.

   Tab,Alt-Tab   and/or   Shift-Tab   can   be   used   to  jump  between
   File,Directories and Name.

   dosave

                               Save (Alt-f,s)

   Save current file.

   saveas

                             Save as (Alt-f,a)

   Save currently active file to a file with another name.

   rewrite

                             Refresh (Alt-f,r)

   Rewrites screen.

   selectprocedure

                            Procedures (Alt-t,p)

   Listing  of  available  built-in  procedures to bind to keys or use in
   plugins.  You can press return on the name to run the procedure. Press
   F1 to get help about the procedure.

   selectdynprocedure

                             Dynamic (Alt-t,d)

   Listing   of  available  dynamic  procedures  (procedures  defined  in
   plugins)  or  faked  dynamic  procedures (plugins compiled in the main
   program).  The  procedures can be bound to keys, placed in the menu or
   used  in  other  plugins.  You  can press return on the name to let it
   work. Press F1 to get help about a procedure.

   To  load  a  plugin  in  bed  you  should  use Alt-t,l or use a plugin
   statement in bed's configuration file:

   plugin PLUGINFILENAME

   Where  PLUGINFILENAME  is  the filename of a plugin (ends with .plug).
   (See  the  PLUGINS  section  of  bed's  manual). To change the default
   directory used by bed for looking for plugins use:

   plugindir PATH

   Where  PATH  is  a  unix  path (see the CONFIGURATION section of bed's
   manual).

   Bed  comes  with a certain number of plugins. Some are compiled in the
   main  program, others are precompiled dynamic modules and some have to
   be  compiled  by  the  user. Details differ depending on the operating
   system.  The  MS  windows  version  of  bed  doesn't currently support
   dynamic plugins, so to be used a plugin should be compiled in the main
   program  and not all plugins (that work under MS windows) are compiled
   in by default.

   Plugins  supplied with bed reside in the plugins/examples directory of
   bed support files. To compile all plugins copy the whole bed directory
   tree  to a place were you have write access, goto plugins/examples and
   press  make.  Depending  on you gcc installation you have sometimes to
   use a home compiled bed before you can load a plugin you have compiled
   yourself.

   A description of the plugins is given in plugins/examples/README.

   The  same  descriptions  you  can  get  in  this  procedure listing by
   pressing F1, you can can also find in the Procedures subsection of the
   CONFIGURATION section of beds manual.

   closethis

                              Close (Alt-f,c)

   Close the current file.

   quit

                               Exit (Alt-f,x)

   Quit application. For all changed files you are asked to save it.

   undo

                               Undo (Alt-e,u)

   Undo last change.

   redo

                               Redo (Alt-e,r)

   After you have undone something with undo, you can redo it with redo.

   setselect

                              Select (Alt-e,s)

   Turns selection on or of.

   copyselect

                               Copy (Alt-e,c)

   Copies selected part of the file to copy buffer.

   pastselect

                               Past (Alt-e,p)

   Past selection.

   saveselect

                          Save selection (Alt-e,a)

   Save selection or copy buffer.

   replace

                             Replace (Alt-e,e)

   Regular  expression: Use the GNU regular expression library to match a
   pattern  against  the  text  (See  man regex(7)). In normal search the
   search  string  is  first converted to bytes and then matched with the
   raw  file  content.  With  regex  search  the  file  content  is first
   converted  to  the  datatype  before regex search. Sometimes different
   bytes  have the same appearance in a datatype. In that case you should
   always  search  with  regex  checked,  examples: Float, char2 and when
   filters  like  duplicate  or  skip  are  applied. Case sensitive: When
   checked  upper  and  lower case are treated distinctively. Boundaries:
   Multibyte  datatypes  can be aligned differently. For example a 4 byte
   digit  can  start  at offset 0,1,2 or 3 and that will give different 4
   byte  digits.  Without  checking Boundaries all will be returned. With
   Boundaries  checked only bytes aligned in the same way as is now shown
   on the screen are returned. Forward: When checked the file is searched
   in  the forward direction going from lower to higher offsets. When not
   checked  the  file  is  searched backward. Edge file: When checked the
   file  is  searched  from  the  edge  of  the  file. From offset 0 when
   searching  forward,  from  end  of file when searching backward. Find:
   Here  you  type  the  search  pattern  Replace: At the place where the
   search string is found the replacestring is placed. The replace string
   overwrites the data. When Regular expression is checked you can insert
   the  whole search string by & or supexpressions by \1 \2 to \9. In the
   searchstring  subexpressions  are  demarcated  by  \(pattern\).  List:
   Generates  a list of all hits. When compiled with CONFIG_THREADS=y you
   can  go  on  editing  while  hits  are  marked so you can view them in
   marklist  (Alt-k,l).  Ascii,  Digit  etc  are when checked the current
   active  datatype.  Base:  Base of digit. E.g 16 for heximal. Nr bytes:
   Gives  the  number of bytes each data item occupies. By some datatypes
   you can change this for example by unsigned integers. Reverse: Reverse
   bytes  while  transforming from datatype to bytes. Set: After changing
   datatype  info  (base,bytes,type) you press Return on Set to make this
   the  search datatype. Convert: the same as Set in addition the current
   search string is converted. Ok: search Cancel: Cancel

   extend

                           Extend file (Alt-e,x)

   Make the file larger, adding zeros to the end of file.

   truncate

                             Truncate (Alt-e,t)

   Truncates file on the right of cursor.

   repeat

                            Repeat nr (Alt-e,n)

   Repeats command a certain number of times.

   search

                              Search (Alt-m,s)

   You  can move through the dialog by pressing Alt in combination with a
   highlighted  character, or by pressing Tab,Shift-Tab or Alt-Tab. Press
   Shift  to  check  options.  Standard  you  search within the currently
   active  datatype,  but  you  can  also  use  Ascii  or Digit (unsigned
   integers)  by  selecting  them, specifying base and bytes and pressing
   Set.  Regular  expression:  Use  the GNU regular expression library to
   match  a pattern against the text (See man regex(7)). In normal search
   the  search  string  is first converted to bytes and then matched with
   the  raw  file  content.  With  regex search the file content is first
   converted  to  the  datatype  before regex search. Sometimes different
   bytes  have the same appearance in a datatype. In that case you should
   always  search  with  regex  checked,  examples: Float, char2 and when
   filters  like  duplicate  or  skip  are  applied. Case sensitive: When
   checked  upper  and  lower case are treated distinctively. Boundaries:
   Multibyte  datatypes  can be aligned differently. For example a 4 byte
   digit  can  start  at offset 0,1,2 or 3 and that will give different 4
   byte  digits.  Without  checking Boundaries all will be returned. With
   Boundaries  checked only bytes aligned in the same way as is now shown
   on the screen are returned. Forward: When checked the file is searched
   in  the forward direction going from lower to higher offsets. When not
   checked  the  file  is  searched backward. Edge file: When checked the
   file  is  searched  from  the  edge  of  the  file. From offset 0 when
   searching  forward,  from  end of file when searching backward. If not
   checked  searching starts at the current position. Find: Here you type
   the  search  pattern List: Generates a list of all hits. When compiled
   with CONFIG_THREADS=y you can go on editing while hits are marked. You
   can  view  the  hits  in marklist (Alt-k,l). Ascii, Digit etc are when
   checked  the  current active datatype. Base: Base of digit. E.g 16 for
   heximal.  Nr bytes: Gives the number of bytes each data item occupies.
   By  some  datatypes  you  can  change  this  for  example  by unsigned
   integers.  Reverse:  Reverse bytes while transforming from datatype to
   bytes.  Set:  After changing datatype info (base,bytes,type) you press
   Return  on  Set to make this the search datatype. Convert: the same as
   Set  in  addition  the  current search string is converted. Ok: search
   Cancel: Cancel

   nextsearch

                            Nextsearch (Alt-m,n)

   Search again for the same search string.

   gettopos

                             Position (Alt-m,p)

   Ask for a file offset and jumps to this offset. Forward: count up Edge
   File:  If  checked: count from begin (forward) or end (backward) file.
   If  not  checked  you  count  from the cursor position. Boundaries: If
   checked:  In  multibyte  units  the  screen  is aligned at the current
   alignment (boundary) after changing position. Position: Offset to jump
   to. You can specify in what format to specify the offset. All: specify
   offset  with 0x for hex and 0 for oct. Numbers not starting with 0 are
   decimal numbers. Hex,Dec,Oct: type of number without need to use 0x or
   0

   keymark

                               Make (Alt-k,m)

   Set mark

   tomark

                               Goto (Alt-k,g)

   Goto mark. You are asked to type the corresponding key.

   nextmark

                               Next (Alt-k,x)

   Goto next mark

   prevmark

                             Previous (Alt-k,p)

   Goto previous mark.

   showmarks

                               List (Alt-k,l)

   Shows  list  of  all marks. Press Return to jump to the file offset of
   the selected mark.

   deletemark

                              Delete (Alt-k,t)

   Delete  mark.  You  get  an overview of current marks. Press return to
   delete the currently selected mark.

   clearmarks

                              Clear (Alt-k,c)

   Delete all marks.

   savemarks

                               Save (Alt-k,s)

   Save marks to file.

   readmarks

                               Read (Alt-k,r)

   Read saved marks.

   postotop

                               Top (Alt-i,t)

   Moves  file  display so that the file offset at the cursor position is
   shifted to the upper left corner of the file display.

   beginfile

                            Begin file (Alt-m,b)

   Goto the beginning of file.

   endfile

                             End file (Alt-m,e)

   Goto end of file.

   beginpage

                             Begin Pg (Alt-m,i)

   To the top of page.

   endpage

                              End Pg (Alt-m,d)

   Goto end of page

   middlepage

                            Middle Pg (Alt-m, )

   Goto the middle of the page.

   nextmode

                               Next (Alt-d,n)

   Goto the data type on the right of this data type.

   prevmode

                               Prev (Alt-d,v)

   Goto the data type shown on the left of current active data screen.

   removemode

                              Remove (Alt-d,r)

   Closes data type screen part.

   zoommode

                               Full (Alt-d,f)

   Zooms current data type (For example ASCII).

   addprev

                             Add Prev (Alt-w,d)

   Adds previous file to the screen

   addnext

                             Add Next (Alt-w,a)

   Adds the next file to the screen.

   prevfile

                               Prev (Alt-w,p)

   Goto previous file. Zooming the file.

   nextfile

                               Next (Alt-w,n)

   Goto next file.

   firstfile

                              First (Alt-w,f)

   Goto the first opened buffer.

   lastfile

                               Last (Alt-w,t)

   Goto last opened file.

   zoomwindow

                               Zoom (Alt-w,z)

   Zooms current window

   hidewindow

                               Hide (Alt-w,h)

   Get opened file from the screen without closing it

   listfiles

                               List (Alt-w,l)

   List opened files. Press Enter to edit selected file.

   askbase

                              Offset (Alt-t,o)

   Changes  the file offset number type. Offsets can be shown as decimal,
   hexadecimal  or  octal  numbers.  You  can also turn of the display of
   offsets.

   switchmessage

                           Messageline (Alt-t,m)

   Hides or shows message line.

   switchmenu

                               Menu (Alt-t,u)

   Hides or shows menu bar.

   switchcommand

                       Commandmode(on/off) (Alt-t,c)

   Switches  command mode on or off. In command mode procedures are bound
   to  normal  characters as in pagers like 'less' and 'more' and in vi's
   command  mode.  Some  of less's and vi's keys are already bound in the
   configuration  file.  If you like some more you should add them to the
   configuration  file.  You  can  mail  them  to  me if you like to help
   others.

   backchar

   Left

   Go back one character.

   beginline

   Go to begin line (Home).

   endline

   Goto end line (End).

   fileinfo

   Show the name and size of file in the message line. (No key binding).

   firstmenuitem

   Goto the first menu element. (Home).

   Only  applies  within  an opened menu. You have to put 253 immediately
   after the keys keyword. So for example:

   keys 253 1 = firstmenuitem

   makes that within an opened menu contr-a jumps to the first menu item.

   lastmenuitem

   Goto last menu element. See firstmenuitem for more information. (End).

   fromcommand

   Turns command mode off.

   linedown

   Down one line (Down).

   lineup

   Up one line (Up).

   nextchar

   Next character. (Right).

   nextmenu

   Goto  next  opened  menu.  (Right). Only applies in the context of the
   menu. See firstmenuitem for more information,

   nextmenuitem

   Goto next menu item. (Down). See firstmenuitem for more information.

   nop

   Does nothing.

   pagedown

   Page down. (Pgdn).

   pageup

   Page up. (Pgup).

   prevmenu

   Goto previous menu. (Left). See firstmenuitem for more information.

   prevmenuitem

   Goto previous menuitem (Up). See firstmenuitem for more information.

   tocommand

   Turns command mode on.

   tosubscreen

   Goto  the  data screen corresponding to the number you type after this
   command.  0  is  the  first  from  the left, 1 the second etc. (No key
   binding).

   emptyfile

                               New (Alt-f,n)

   Opens  new  document  of  size  1.  You  can enlarge the document with
   Alt-e,x.

   filedata

                             Fileinfo (Alt-f,f)

   Displays information about current file.

   checkchanged

                            Modified? (Alt-f,m)

   Checks if current file is modified by comparing changed parts with the
   original file.

   suspend

                              Shell (Alt-f,h)

   Go to shell. Starts a new shell or uses suspend.

   If  a new shell is evoked, it uses the SHELL environmental variable to
   decide which shell to use. You can also set environmental variables in
   beds configuration file (see manual).

   input

                              Input (Alt-e,i)

   Modifies  current  data item. With this procedure you edit the current
   item  and  only  after  pressing Enter the modifications are inserted.
   Certain  datatypes  you  can't edit without this procedure (e.g. Float
   and  Time_t).  If  you don't use this procedure, then the data item is
   converted to and from binary format after every key you press.

   editdata

                               Edit (Alt-e,d)

   Evokes text editor to edit selected data in active datatype.

   If  the  environmental  variable  EDITOR is set to the full path of an
   editor  that  editor  is  used. You can set environmental variables in
   beds configuration file with the following command:

   setenv name [val]

   Leaving out val means unsetenv.

   See bed's manual page or bed -h for more information.

   select

   Turn  on or off selection. Selections can be copied and pasted, saved,
   edited etc.

   saveshown

                            Save Shown (Alt-e,v)

   Save  selection  in the active datatype as shown on the screen. So the
   selected data is first converted to the active datatype and then saved
   to a file.

   readshown

                           Insert shown (Alt-e,h)

   Insert file content within active datatype. The content of the file is
   interpreted as consisting of data in the active datatype.

   gotolastsearchpos

                           Not searched (Alt-m,o)

   Jumps  to  file  offset  not  yet  searched. Useful if you interrupted
   searching  or  are  searching on the background and want to know where
   search was left.

   nextitem

                            Next Item (Alt-m,x)

   Moves one item forwards. Item is the active datatype unit.

   backitem

                            Back Item (Alt-m,a)

   Moves one item backwards. Item is the active datatype unit.

   prevpos

                            Undo move (Alt-m,m)

   Go to previous file offset.

   nextpos

                            Redo move (Alt-m,v)

   Go again to file offset before undo move.

   scrollup

                                Up (Alt-i,u)

   Scrolls  file  up.  The  second  line is scrolled up to the first line
   position.

   edscholldown

                               Down (Alt-i,w)

   Scrolls  file down. The first line is scrolled down to the second line
   position.

   scrollitem

                            Left item (Alt-i,l)

   Shift left one item. The second item is shifted leftwards to the first
   item position.

   scrollbackitem

                            Right item (Alt-i,r)

   Shift  right  one  item.  The  first item is shifted rightwards to the
   second item position.

   scrollbyte

                            Left byte (Alt-i,f)

   Shift  left  one  byte.  The  second  byte is shifted leftwards to the
   second byte position.

   scrollbackbyte

                            Right byte (Alt-i,g)

   Shift  right  one  byte.  The  first byte is shifted rightwards to the
   first byte position.

   makemode

                             Integer (Alt-d,i)

   Create  unsigned  integer datatype. You can select bases from 2 to 36.
   The  number  of  bytes  per  unit  range  from 1 to some unknown limit
   depending  on hardware speed. You can start a separate datatype or add
   a  field  to  an  existing  datatype.  In  the  last case where in the
   existing  datatype  the  new  field  is  placed  depends on the cursor
   position:  -  At  the end of the existing datatype if the cursor is at
   the  end  of the screen - At the beginning of the existing datatype if
   the  cursor is at the beginning of the screen - Otherwise at the place
   closest  to  the  cursor. - After the cursor position if the distances
   are equal

   naarASCII

                              Ascii (Alt-d,a)

   Create  ascii  datatype.  No  print:  character to show if byte is not
   printable.  You  can  also decide which byte values are interpreted as
   printable  characters.  Strict is ascii only, +161-255 adds byte value
   161-255  etc. It is possible to make units of more then one character.
   The meaning of separete/add field is explained under Integer help.

   emptycontain

                              Empty (Alt-d,y)

   Skip empty parts within a composed datatype. Useful if a file contains
   records with parts you are not interested in.

   copymode

                              Clone (Alt-d,c)

   Create a datatype that is identical to the active (sub) datatype.

   addSigned

                              Signed (Alt-d,s)

   Create signed integer datatype. See Integer help for more information.

   addFloat

                              Float (Alt-d,o)

   Create  float  datatype: 4 bytes: float 8 bytes: double 12 bytes: long
   double

   It  is  not  possible  to use normal search in the float datatype, you
   need  to  use regex search. Normal search translates the search string
   from  the datatype format back to raw bytes and searches for these raw
   bytes.  This  is  not  possible  because  float as displayed has not a
   perfect  precision  so  that  that  the  float  that  is displayed can
   correspondent to more then one raw byte array.

   addBitFlags

                             BitFlags (Alt-d,b)

   Create bitflags. Give every bit a label which is shown if that bit has
   value  1.  Not  char:  If  that  bit is zero, the value of Not char is
   shown.  Add:  Bit-label  correspondences  are assigned by typing a bit
   number  after Bit and the corresponding label after Label and pressing
   return  on  Add.  Bits  are  numbered from 0 to (8*bytenr-1). With the
   lowest  bit  having  number  0.  This  creates  a  list  of  bit-label
   correspondences   under   Flags.   Flags:   You   can  edit  one  such
   correspondence   by   pressing   Alt-f   followed   by  selecting  the
   correspondence  and  pressing  return.  You  change  the Bit and label
   values  and again press Return at Add. Del: If you press on delete the
   selected  correspondence  is  deleted.  Between: What to write between
   bytes.  Default: nothing. Order: When editing a file in bitflags every
   item  is  shown  as  some flags. If you want to set a certain flag you
   write  the  label.  If  order  is set this is only possible if you are
   above  the position of this label. If order is not set you can set the
   label  at  every  position. Example: If the flags are zyx and order is
   set  you  can  change  ---  in  --x  only by pressing x at position 0,
   without order you can press x also at position 1 or 2.

   bitfielder

                             Bitfield (Alt-d,e)

   This  is  a  record/struct in which you specify the number of bits for
   every field. After making a bitfield around a datatype it works like a
   normal  composed  datatype.  You just add the other fields. You change
   the  number  of  bits of a certain field by setting the cursor on that
   field  and  selecting  again  Alt-d,e but now you press 'Change Bits'.
   Another  way  is  to make the bitfield the active datatype by pressing
   Alt-y,t (Parent) and then selecting Config (Alt-y,g).

   translate

                            Translate (Alt-d,l)

   Translate assigns labels to values of another datatype. You can use it
   when  numbers  have  a  certain  meaning.  After  selecting  'New'  or
   'Change':  Type:  The  To  datatype  is  what  is  shown on the screen
   (usually Ascii). For certain values of the 'From' datatype you specify
   what should be shown in the To datatype. Add: After specifiying the To
   and  From datatypes, you specify the From and To values and press Add.
   Default:  If  there  is  no  assignment Default is shown. Assignments:
   After  pressing  Alt-g  you  can select a certain existing assignment.
   Pressing Return makes it editable, pressing Del deletes it.

   After  selecting  'Use;  Select  label and press return to insert this
   value.

   listtypes

                               List (Alt-d,t)

   List  of  all  datatypes.  Use movement keys to select one of them and
   press Return to create it.

   reorderunit

                             Reorder (Alt-y,o)

   One of the filters that is transforms the data when read from the file
   and  before  interpreted  by the datatype. Reorders bytes within item.
   Unit  gives  the  number  of  bytes to keep together. If the bytes are
   'abcdef',  reorder  with  unit=1  gives  'fedcba',  with  unit=2 gives
   'efcdab', with unit=3 gives 'defabc'.

   duplicate

                            Duplicate (Alt-y,i)

   Useful  if  you like to use the same data more than once in a composed
   datatype.  It  acts  like  an union in c. Filter that duplicates bytes
   before  being  interpret  by  the  active (sub-) datatype. You have to
   specify  how  many  times  it  is duplicated (dubnr). The active (sub)
   datatype   consists   of   a   certain   number   of   bytes   (size).
   usenr=(size/dubnr)  gives  the  number  of  bytes used for every item.
   dubnr  times  the  same  usenr  bytes  are  appended  and given to the
   datatype.  Example: You use ascii/4 (ascii consisting of 4 bytes). You
   say duplicate 2 and the file consists of abcdefghijkl. Before applying
   the  filter  this  was displayed as abcd efgh ijkl. After applying the
   duplicate filter it becomes abab cdcd efef ghghe ijij klkl.

   addskip

                               Skip (Alt-y,k)

   Filter  to  skips a certain number of bytes. You have to specify after
   how  many  bytes  and  how  many bytes are to be skipped. This is then
   repeatedly  applied  to  every  unit  of  the  active (sub-) datatype.
   Example:   The   active   datatype   is  ascii/4.  The  file  contains
   'abcdefghijkl'.  abcd  efgh  ijkl  is  displayed.  Applying  Skip with
   After=2  and Skip=1 gives: abde ghjk. After ab c is skipped after de f
   is skipped and after jk l is skipped. It is not possible to use normal
   search  in  a  datatype  were  Skip  is applied. You need to use regex
   search.  Normal  search translates the search string from the datatype
   format  back  to  raw  bytes and searches for that string. This is not
   possible   when   Skip  is  applied  because  one  search  string  can
   correspondent to more then one raw content bytes string.

   rmlastfilter

                            Rm filter (Alt-y,m)

   Removes  last  filter  (Reorder,  Duplicate, Skip or some other filter
   defined in a plugin).

   repeatcontain

                              Repeat (Alt-y,p)

   Repeats  active  (sub-)datatype  a certain number of times. It behaves
   the  same  as a composed datatype with multiple version of the current
   active (sub-) datatype.

   datatypeconfig

                              Config (Alt-y,g)

   Modify  parameters  of  active  (sub-) datatype. Things like number of
   bytes and the base of Integers.

   dataconfig

                               Misc (Alt-y,s)

   Modify  some  general  display parameters of datatype. Label: Name for
   datatype  shown  on  the  message line Apart: number of spaces between
   items  of  this  datatype  Spaceafter:  number  of spaces between this
   datatype   and   an  other  datatype  or  the  offset  numbers.  Conf:
   Configuration  string  every  datatype  has. Usually you don't need to
   change this.

   savedatatype

                            Write Type (Alt-y,w)

   Save  datatype  to file so you don't have to recreate complex datatype
   everytime you need them.

   readcontain

                            Read Type (Alt-y,d)

   Read  saved  datatype.  So  that the current file is displayed in that
   format.

   record

                              Record (Alt-t,r)

   Start  recording. Keystrokes are recorded until you press C-t. You can
   save recorded keystrokes to replay them at some other moment.

   Take notice of the fact that RAW keystrokes are saved. This means that
   the  recorded  keystrokes  are  very unportable. They are not portable
   between  operating systems but also not portable between terminals and
   configurations.  What's  is recorded within xterm does not nessesarily
   work  with  rxvt  or  with  linux  console.  You can use more portable
   keystrokes  by using only Alt-char and Control-char keys. The movement
   and  function keys are very unportable and also combinations of Alt or
   Control that make use of non alphabetic characters.

   saverecord

                          Save Recorded (Alt-t,s)

   Save recorded keystrokes to file.

   playkeysfile

                            Play file (Alt-t,y)

   Play  saved  keystrokes  (recorded with Record). The program runs like
   the keystrokes are pressed by the user, except when other programs are
   evoked from bed.

   playrecord

                          Play Recorded (Alt-t,a)

   If  you  have  recorded  keystrokes after program startup you can play
   them off with this procedure.

   opendynlib

                           Load plugin (Alt-t,l)

   Load   plugin   in  program.  The  plugin  can  contain  datatypes  or
   procedures. Procedures you can view under Dynamic (Alt-t,d), datatypes
   under Alt-d,t.

   showprocedure

                           Key binding (Alt-t,k)

   Shows  procedure  in  menu or binded to key sequence. You are asked to
   press  the  keys  you want to know the procedure off. Within menus you
   can  only  use  a key and not movement keys to go to the procedure you
   are interested in.

   Beside  the  procedure  it  is  shown  what  you  need to write in the
   configuration file to declare this key/menu-procedure binding.

   Examples  After  Alt-t,k, you press F12 and get keys 27 91 50 52 126 =
   makeselection

   The procedure is makeselection which is bounded to escape sequence: 27
   91  50  52  126  If  you  like  to  bind makeselection to an other key
   sequence you press after Alt-t,k, the keys you want to bind it to, for
   example  C-a  and  replace '27 91 50 52 126' with what you found there
   for example 1. So add keys 1 = makeselection to the end of ~/.bedrc

   After Alt-t,k you press Alt-f,x and get

   menuitem 0 "E~xit" "M-x" 12 = quit

   Procedure  quit  is  bounded to a menuitem. The menu item is in menu 0
   (the  first  menu) has label 'E~xit' and had keylabel 'M-x' and is the
   twelves  menuitem  in  the  menu  (starting  with 0 and counting empty
   places).

   If  you  like  to  change  to name from 'E~xit' to '~Quit' you can add
   menuitem 0 "~Quit" "M-x" 12 = quit to the end of ~/.bedrc

   See the bed manual page for more details about assigning procedures to
   menu items and keys.

   newcontain

                               Sub (Alt-y,u)

   With  this  function you can create a composed datatype within another
   composed  datatype.  First  make  a element of a composed datatype the
   active  datatype  and  then  use this function (Alt-y,u) to make a sub
   composed  datatype  around the active datatype. After this you can add
   more datatypes to this sub composed datatype, by using the "Add field"
   option  while  starting  a  new  datatype  or  by  using  Alt-y,r. New
   datatypes  created  with  add  field  are  always  added to the lowest
   composed  datatype  in  which  the  active  datatype is contained. The
   message line shows what datatype is active. Use Alt-y,t and Alt-y,c to
   change  to  the datatype this datatype is contained in and back again.
   You can also make the composed datatype the active datatype by placing
   the  cursor  between two of it's member (child) datatypes. Subcomposed
   datatypes  can be useful if you want to use a filter for only a subset
   of  the members of a composed datatype. For example a file consists of
   records  of  three ascii strings and you like to exchange the position
   of  the first two strings. After creating three ascii strings of 10 in
   one  record (composed datatype), you set the cursor on the first field
   and  press  Alt-y,u.  This  makes  a  subcomposed datatype around this
   field.  To  add the second field to this composed datatype you set the
   cursor  at  the second field and press Alt-y,r. Now you set the cursor
   between  the  first  two fields (or you press Alt-y,t) and you reorder
   with unit 10 using Alt-y,o.

   stretchcontain

                             Stretch (Alt-y,r)

   Used  to  handle nested composed datatypes (made with Alt-y,u). If you
   have   made   a   composed   (struct/record)   datatype  for  example:
   {{a,b,c},d,g}  Here the letters are datatypes and {..} is one composed
   datatype.  {a,b,c}  is a nested (or sub) composed datatype. If you put
   the  cursor  on  d  and apply this function, you can add d to this sub
   composed datatype. So you get then {{a,b,c,d},g}.

   levelout

                             Levelout (Alt-y,v)

   Applies  if  active  datatype is a composed/record datatype. With this
   function the composed datatype is removed so that the item(s) endup at
   a  higher level. It can be used in two cases: 1. a nested composed; 2.
   a composed containing only one datatype.

   uplevel

                              Parent (Alt-y,t)

   Parent  datatype.  Make  active  datatype  the  datatype  in which the
   current datatype is contained.

   downlevel

                              Child (Alt-y,c)

   If  applied  to  a  composed  datatype,  this makes the current active
   datatype the member of the composed datatype the cursor is on.

   goto1

   Goto the first open file.

   toclipboard

   Puts selection in active datatype in MS Windows clipboard.

   pastclipboard

   Insert MS Windows clipboard in active datatype.

   selectdisk

                               Disk (Alt-f,d)

   Edit  raw data of floppies and hard disks. This way you can handle the
   whole disk like a large file.

   If  you save something to a hard disk you should keep in mind that bed
   saves  by blocks (probably 4096 bytes). This can lead to problems when
   some other process changes the hard disk close to the change you made.
   In  this  case by saving what you changed, you will also save some old
   data  at  the  place  the other program had changed something. So make
   absolutely  certain  that no other process could possibly have changed
   something around the place you change during the editing.

   Under  Linux,  FreeBSD  and  Windows NT bed makes use of some standard
   interface  for  raw disk access. Under windows 95 you need to use some
   undocumented  thunk  to  a  win16  dll  to  use the DOS Protected Mode
   Interface to execute a BIOS interrupt. So if you use Windows 95 backup
   all your hard disks before opening a disk.

   Under  win95  you  shouldn't give too much trust to the specified disk
   size.  What  the  bios says is not exactly right and sometimes totally
   wrong (when using a large harddrive with an old bios). Returned floppy
   sizes  are  mostly right so bed takes over the bios value if -w is not
   specified  at  startup.  To  determine the real harddisk size bed uses
   some  ad  hoc  heuristic  while  trying  how  far it can can read. The
   problem  is  that  at  very large offsets the bios disk read interrupt
   returns  SUCCESS  again,  so you have to try larger, but not too large
   offsets.  At  my computer reading a HD floppy at offset 2948608 fails,
   but  reading  at offset 5120000 succeeds. A DD floppy fails at 1474048
   but  succeeds  at  2948608.  If  the  size  seems  to  be wrong try to
   determine  it  and specify it with the -d option at startup. Bed saves
   the  disksize  so  you have to specify it only once (within regedit at
   HKEY_LOCAL_MACHINE SOFTWARE\Bed\hardisks).

   filetype

   Uses  the unix program file to guess the filetype of the data starting
   at  the  current cursor position. It can be used when the cursor is on
   the  first  byte  of  a  file  or  when  searching  for files inside a
   harddrive device. plugin file.cpp

   filter

   Gives  the  content  of  the  selection  as  input to a user specified
   command  (e.g.  grep  '^X'|sort|uniq)  and  places  the output of that
   command in the copy buffer. plugin filter.cpp

   disassembler

   File content at cursor position is translated to assembler code. Makes
   use  of  gdb.  Use  nextdisassem to jump to the next machine code. Use
   gotosymol  (elftables.plug)  to  jump to procedure using its procedure
   name plugin disass.cc

   nextdisassem

   Jumps  to  next  machine  code  instruction and disassemble it: Cursor
   position  is  moved  the  length of the current machine code statement
   further and disassembler is called. plugin disass.cc

   backward

   Adds  the  backward filter. This filter tries to reverse the direction
   of the last applied filter. plugin backward.cc

   compare

   Compares  last  made  selection  with  current  file at current cursor
   position  for the length of that selection. Bed itself has no limit on
   selection  size,  but  some  Xwindows  programs  force  such limits on
   others. See the help of makeselection. plugin searchclip.cc

   searchclip

   Searches  in  current  file  for the content the bed's copy buffer. It
   takes  over the search settings (direction, case sensitivity, regex or
   not, on boundaries or not, from current position or from edge of file)
   of  Alt-m,s.  Currently  it repeatedly searches for the first block of
   the  copy  buffer  and  then  compares  it with the whole copy buffer.
   plugin searchclip.cc

   tryinstall1

   Installs Float with installpart/1 and getFLoat plugin install.cc

   tryinstall2

   Installs Digit with installpart(part,0) and getDigit plugin install.cc

   datatypeinfo

   Gives information on active datatype. plugin datatypeinfo.cc

   cutselect

   Standard cut: selection is put in copy buffer, file after selection is
   moved to begin selection and rest file is truncated plugin cut.cc

   insertpast

   Standard  past:  file  is  extended  and  content  after  current file
   position  moved  so  that  copy  buffer content can be inserted plugin
   cut.cc

   index2table

   index2table

   index2table  interprets the file content as long's (4 bytes) which are
   indexes  in a table at some offset in the current file. Instead of the
   index  number  it displays the content of that table at that position.
   index2table  is  a  filter  that  should  be  applied  to  a  datatype
   appropriate for the data in the table. For this purpose this procedure
   asks to specify at what offset in the file the labels start, with what
   index  the  table  starts and table length. Index2table is for example
   used to show the names of procedures in a symbol table. index2table is
   then  applied  to  ascii  strings that shows this label instead of the
   index. dynsym and symtab are sub classes of index2table. They are used
   by  misc/dynsym.bedda  and  misc/symtab.bedda.  Because  of  this  use
   index2table was previously called symtable. plugin index2table.cc

   section

   Used  by  composed datatype file sectionheader.bedda to show labels of
   names in section header plugin elftables.cc

   dynsym

   Used  by  composed  datatype  file  dynsym.bedda to show the procedure
   names in dynsym (dynamische) symbol table. plugin elftables.cc

   symtab

   Used  by  composed  datatype  file  symtab.bedda to show the procedure
   names in symtab (statische) symbol table. plugin elftables.cc

   gotosymbol

   Procedure  searches  in  symbol  tables  symtab and dynsym for a given
   symbol.  It  sets  the  cursor  to  its fileoffset and starts a better
   fitting  datatype.  It  shows  the  offset and its size in the message
   line. plugin elftables.cc

   switchsize

   Switches  xterm  size  to  a large size if small or to a small size if
   large plugin switchsize.cc

   rxvtmenu

   Adds rxvt menu. You can remove the scrollbar, reverse video and if you
   don't have a buggy rxvt you can change fonts. plugin rxvt.cc

   pastclipboard

   Past  clipboard.  This  is  data  copied by bed or a Xwindows program.
   plugin putselect.cc

   makeselection

   Turn  on or off selection. Selections can be copied and pasted, saved,
   edited  etc. Within a xterm the selection is usually shared with other
   X window Programs.

   Bed itself has no limit on selection size. In case you are running bed
   under   Xwindows   while  using  the  selection  mechanism  of  plugin
   putselect.plug (the default) you can get into trouble.

   In  certain  Linux  distributions the X windows system is sabotaged by
   loading  in  the  standard  configuration of KDE an antisocial program
   called klipper. Klipper asks periodically for the X windows selections
   so  problems  arise while using large selections. bed gets around this
   problem  by  only giving the first few bytes of selections to programs
   of class klipper. But maybe there are klipper like programs around who
   don't use class name klipper. plugin putselect.cc

   pastselection

   Past Xwindows selection. plugin putselect.cc

   copyclipboard

   Copies selection. plugin putselect.cc

   pastspecial

   Only  available if a bed owns the clipboard. Shown: With this function
   you  can  past  data  formatted as shown on the screen. So you can for
   example  insert  in ascii the data as shown in heximals Datatype: Past
   datatype of copied data. plugin putselect.cc

   exportselection

   Make selection the xwindows selection. plugin putselect.cc

PLUGINS



  Introduction

   Bed  has  the  possibility  to call c functions from within bed and to
   access some of the data of bed.
   Here is an example:
/*Begin example1.cpp */
#ifdef GLOBAL
#endif
#ifdef EDITOR
int  example1(void) {
        message("Hello world!!!");
        }
#endif
call(example1)
/* End example1 */

   Everything  in  the area in which GLOBAL is defined is code outside of
   the  EDITOR  class.  Everything  inside  the  area  in which EDITOR is
   defined is inside the Editor class and at the end of the files are the
   names of the procedures which should be bounded to a key in bed.
   In  this  example the procedure example1 uses an function of bed which
   writes  a  message to the messageline and call(example1) says that the
   function example1 should be accessible by bed.
   This  function  example1  you can bound to a key the same way as bed's
   own procedures . For example
   keys 1 = example1
   to bind contr-A to example1.
   To compile the example you need just to do
          make example1.plug
   in  the  plugings/examples  directory. Which assumes that there is the
   original  Makefile  and the make variable PLUGINDIR is assigned to the
   directory in which plugin.cpp, faked.h and mainprocedures.h reside.
   Ones compiled you have to put the line
   plugin ABSOLUTEFILENAME
   in ~/.bedrc before you bind a key to the corresponding functions.
   So in for this example you can add
   plugin /usr/share/bed/plugins/example1.plug
   keys 1 = example1
   in  ~/.bedrc to enjoy the pleasure of getting "Hello world!!" when you
   press Contr-A.
   In  the  procedures you write you can use all the procedures which can
   bounded  to  keys  (which  have  the format int name(void)), plus some
   extra procedures I am going to describe now.


  Editor

   The following functions are inside class Editor:

   int topos(OFFTYPE pos)
   Go  to  offset  pos  in  the  current  file.  pos  is  rounded down to
   boundaries of active datatype.

   int toborderpos(OFFTYPE pos)
   Go to offset pos in the current file.

   OFFTYPE dosearch(char *str, int len)
   Search for str with length len in the current document

   OFFTYPE getfilepos()
   Get the offset of the first byte on the screen.

   int geteditpos()
   Get  the offset of the cursor in the current screen. The offset of the
   cursor in the file is getfilepos()+geteditpos()

   OFFTYPE getmem(OFFTYPE pos,char *buf,OFFTYPE len) 

   Get  from  position  pos  a piece of the current file with length len.
   Returns OFFTYPEINVALID on error, otherwise len;

   OFFTYPE putmem(OFFTYPE pos,char *buf,OFFTYPE len)
   Put   at   position   pos   the  array  buf  of  length  len.  Returns
   OFFTYPEINVALID on error, otherwise len;
   int getselbuf(char **buf) 
   Put  a  pointer to the cutbuffer in *buf and returns the length of the
   cutbuffer. Returns negative on error;

   int putselbuf(char *buf,int len)
   Puts buf with length len in the cutbuffer.

   OFFTYPE getselect(void)
   OFFTYPE setselect(OFFTYPE pos)
   getselect  returns  the  starting position of the current selection or
   OFFTYPEINVALID  if there is no selection. Putselect put's the starting
   position of the selection or with OFFTYPEINVALID unselects.
   (The end position is the cursor position).

   OFFTYPE Editor::getselregion(OFFTYPE *start)
   Returns  length  of  selection and puts start position in start. start
   has to point to an OFFTYPE.

   int screensize()
   Get the number of bytes currently on the screen.

   char *getfilename(char *buf)
   The current filename is copied to buf.

   int message(char *format ...)
   Write to messageline. Same format as printf.

   int getkeyinput(char *format ...)
   Ask in the same format as printf. And get an key as answer.

   int inputget(char *answer,const char *format,...)
   Ask  in  the same format as printf and get an answer in answer (should
   hold enough memory).

   OFFTYPE filesize(void)
   Get filesize.

   int toscreen(void)
   Makes that the effect of previous operations is shown on the screen.
   void filesup(void)
   When  a  newwin (of ncurses) is used you can with filesup get the file
   windows of bed again on top.

  Global

   extern Editor *editfile(const char *file)
   Open  a  new  file.  When  you  want to do operations on this file you
   should  hold in mind that the previous functions are part of the class
   Editor. So when you can do for example:
/*start stupid.cpp
#compile with make stupid.plug
#put in ~/.bedrc
plugin /usr/share/bed/plugins/stupid.plug
keys 1 stupid
# and call contr-A in bed
*/
#ifdef EDITOR
int another(void) {
        topos(400);
        toscreen();
        getkeyinput("I am going to delete everyting O.K. ");
        putmem(0,"Hello",5);
        }

int stupid(void) {
        Editor *ed=editfile("/boot/zimage");
        return ed->another();
        }
#endif
call(stupid)
/*end stupid.c */

   call(proc)
   Determines  that  proc can by used to bind keys to, add to menu and is
   seen  in  Alt-t,d  (Dynamic).  proc  is  a  procedure  of the form int
   Editor::proc(void). A call(proc) should not ended with ';'.

   call_on_start(proc)  call_on_open(proc) call_on_switch(proc) call proc
   once  after program start, everytime a file is opened or everytime the
   program switches to a file.

   sethelp(proc,text)
   Adds  helptext  text  to  procedure.  Shown  on pressing F1 in Dynamic
   procedure  listing (Alt-t,d) and in menu if procedure is added to menu
   with menuitem statement.

   extern Editor *newfile(void);
   Opens empty file.

   extern editor *getactive(void)
   Get the currently active Editor.

   extern void rewriteall(void)
   Rewrites everything on the screen.

   Some  examples  of  plugins are put in plugins/examples: one shows the
   assembler labels of the bytes starting with the cursor (gdb.plug), one
   shows  the  file type (when the cursor is on the first byte of a file)
   (file.plug)  and  and  one  filters  what's  selected through an other
   program (filter.plug).
   A  new  syntax uses class Editor {} instead of the defines. If you use
   the  old  syntax  the file name should end at .cpp, when using the new
   syntax  at  .cc.  In  the  new  syntax  you  should  put the following
   statements above any code:
#include "global.h"
BEDPLUGIN

   Instead of #ifdef EDITOR ... #endif you write
class Editor {
public:
#include "faked.h"
int proc(void) {
        }
};
call(proc)

   and  put  you  procedures under #include "faked.h" the call statements
   you place under the '}'.

   WARNING!!
   You  should NEVER define any variables within class Editor (or between
   #ifdef  EDITOR  and  its  #endif.  You  should  also  never try access
   variables  of  the  main  program (relating to class Editor) directly.
   With  this  version of gcc it is possible to distribute the procedures
   of a class over different files, but not it's data.

  Datatypes

   int Editor::installpart(ScreenPart *part,int field);

   Installs  datatype  part,  which  means  that this datatype is used to
   display  the  curent  file.  If  field is zero this becomes a separate
   datatype,  otherwise  it  is added to the active datatype. It uses the
   default settings and doesn't ask the user any questions.

   int Editor::installpart(ScreenPart *part);

   Installs  datatype  part,  which  means  that this datatype is used to
   display  the  curent file. The user is presented with an configuration
   screen to set some options.

   extern ScreenPart* getAscii(Editor *ed)
   extern ScreenPart* getDigit(Editor *ed)
   extern ScreenPart* getFloat(Editor *ed)

   For every datatype X there is a getX(Editor *ed) function that returns
   an  instance  of  this  datatype.  You  can  use  it  by  the  command
   installpart(part). In plugins you can define new datatypes.

   ScreenPart *Editor:activemode(void);

   Returns curently active datatype.

   char *ScreenPart::getname()

   Returns  name  of the class of this datatype. It is a string shared by
   all instances of this class.

   int ScreenPart::equal(ScreenPart *part)

   Test  if  part  is  equal  to  this  datatype. Equal means a different
   instance,  but  no  differences  in  behaviour.  Not only the class is
   identical, but also its parameters like bytes, filters and base.

   int ScreenPart::datbytes(int b=-1)

   Returns  the  number  of  bytes  of  one  item  of this datatype. If b
   different from -1 the number of bytes is changed to this number.

   int ScreenPart::getbytes()

   Returns  the  number  of bytes one item correspondence to on the file.
   This can be different then what is returned by datbytes() when filters
   like Skip (Alt-y,k) or Duplicate (Alt-y,i) are applied.

   ScreenPart *ScreenPart::getchild(int &forstart,int &binstart,int pos)

   If  the  datatype (ScreenPart) upon which is procedure is applied is a
   composed  or  Repeat  it  returns the child datatype under the cursor,
   otherwise it returns the current datatype.

   ScreenPart *ScreenPart::getsubpart()

   Repeatedly   applies  getchild  until  is  finds  a  datatype  without
   children.

   ScreenPart *ScreenPart::getparent() 

   Returns contain current Screenpart is contained in, or NULL when there
   is not sucn thing.

   ScreenPart    *ScreenPart::getsuperpart(void)    Repeatedly    applies
   getpartent until is finds a datatype without parent.

   int ScreenPart::calcsizes(void)

   Calculate  sizes  of  ScreenPart.  Should  sometimes  be  called after
   changing some parameter of a datatype or adding a filter.

   Write you own datatypes:
   You  define  a  class  as  a  subclass  of  ScreenPart or one existing
   datatype (Digit,Ascii, Signed, Float etc). Lets start with an example:
#include <stdio.h>
#include <limits.h>
#include <ctype.h>
#include "global.h"
BEDPLUGIN
#include "screenpart.h"
class char2 : public ScreenPart {
public:
declareparent
char2 ( Editor *ed): ScreenPart( ed, 1 ,256, 2 )  {
apart=0;
};
int form2bin(char *formal, unsigned char *bin, int &len) {
bin[0]=formal[0];
return 2;
}
ScreenPart *newone(void) {return new char2(*this);}
int bin2formal(unsigned char *bin, char *formal, int len) {
        if(isprint(bin[0]))
                formal[0]=bin[0];
        else
                formal[0]='.';
        return 0;       }
  int isel(int ch) {return isprint(ch);}
        };
datatype(char2)
parentd(ScreenPart,char2)

   After
#include "global.h"
BEDPLUGIN

   which is included in every plugin,
#include "screenpart.h"

   is included because we need to become a sub class of ScreenPart.

   class char2 the new datatype.
          declareparent

   Is  a  statement  what  should be included in every datatype class. In
   combination  with  parentd  it  is  used to determine the parent child
   relations between classes.
          char2 ( Editor *ed): ScreenPart( ed, 1 ,256, 2 ) {

   every  datatype  class  should also contain a contructer with as first
   argument  Editor  *ed  and  it  should  call  the  parent constructor.
   ScreenPart  takes  as  first  argument  ed,  as  second the numbers of
   characters  every  item  needs to be displayed on the screen. As third
   argument  the  base  of  the  datatype (or something arbritary if this
   datatype  has  no  base) and ad fourth argument the number of bytes of
   the screen this datatype uses.
          apart=0

   States  that  the  items  are  zero  space  apart of each other on the
   screen.  The  default  is  1  space  between  items. int form2bin(char
   *formal, unsigned char *bin, int &len) { form2bin comes from format to
   bin. It transforms formatted input to binary form (the raw form in the
   file).  formal  contains  the  formatted input, bin is filled with its
   binary  form. len is a reference to the length of formal and should be
   set  to  the  length  of formal that is actually used. form2bin should
   return the number of bytes placed in bin.
          int bin2formal(unsigned char *bin, char *formal, int len) {

   bin2formal  transforms  binary input to formatted output. bin contains
   the  binary  input,  in  formal  the  formatted  output is placed. len
   contains  the  length  of bin. It should return 0 on success and -1 on
   error.
           int isel(int ch)

   isel  determines  what  character  input  (e.g.  keyboard)  input this
   datatype  can handle. Unsigned decimal integers can handle for example
   0-9  (isdigit(ch)).  It  should  return nonzero when it can handle the
   input and 0 when not.

          datatype(char2)

   The  datatype  statement makes the datatype known to bed, it adds this
   datatype  to the datatype list so that it is seen with Alt-d,t and you
   can use it in saved datatypes. You can use ScreenPart *getchar2(Editor
   *ed) to get char2.

          parentd(ScreenPart,char2)

   Also  a  obligatory  statement,  stating  that  char2  is  a  child of
   ScreenPart.

   Other   statements   functions  which  can  be  defined  in  datatypes
   (ScreenPart's):

   int chbytes(int byt)
   Changes  the  number  of bytes the datatype uses (used by Alt-y,g). If
   byt=-1 is should return a number greeter then 0 if the number of bytes
   can  be  changed.  If  bytes>0 is should change its number of bytes to
   this  value  and  return  the number of bytes it occupies. On error is
   should return -1.

   int chbase(int base)
   Returns  the current base (ScreenPart::type) with b==-1, returns -type
   if  b==0.  Returns  -1  if  base can't be set and changes to base base
   otherwise returning the base.

   char *getconvstr(void)

   A  procedure  that  can  be defined to return a string describing some
   extra  options  set  in  the  current  instance of this datatype. When
   saving  datatypes this string will also be saved and when the datatype
   is  recreated  from  the  saved  datatype  it  will  be  given  to the
   curresponding procedure setconvstring to set these options. The string
   can  be  a static string if you like; it will not be freed by the main
   program.

   int setconvstr(char *str)

   Procedure  that  can  be  defined  to set the options of a string this
   datatype  returned  with  getconvstr.  It  should  return -1 on error,
   otherwise it should return 0.

   userconfig(int modify)

   Procedure  that  can be defined to create your own dialog presented to
   the user to configure the datatype If modify=1 the datatype is already
   shown  on  the  screen,  as  when it is called by Alt-y,g. If modify=0
   useconfig  is  called  on  creation  of the datatype. In the last case
   usrconfig  should  call installpart(sub,separ) to add this datatype to
   the screen.

   Most   datatype   classes   would  also  contain  a  copy  constructor
   Datatype(Datatype &fl)

   For additions and modifications you can look at the example plugins or
   in  faked.h or the Tools menu inside bed (Key binding and Procedures).

  Filters

   int ScreenPart::addfilter(Filter *fil)

   Adds  Filter  fil  to  the  filters of current datatype. Returns -1 on
   failure. Otherwise it returns the number of filters.

   int ScreenPart::rmlastfilt(char *name=NULL)

   Removes last filter. If name!=NULL it only removes this filter if name
   is  the  name  of  the the last filter. Name is for example Duplicate,
   Reorder, Skip etc.

   Filter *ScreenPart::getlastfilter(void)

   Get the last applied filter if it exist, otherwise it returns NULL.

   Creating filters

   A  filter  sits  between  the datatype and the file and transforms the
   data. It is a sub class of Filter (lets call it SubFilter).

   Filter contains the following variables:
   char  *name;  /*All  references  to  this name should contain the same
   pointer.  set  by  name=filtername(SubFilter) (without "") extern char
   *filtername(SubFilter); should be defined above the class. */

   int bytesfile; /*Number of bytes of each unit at the file side of this
   filter */
   int bytesscreen; /*Number of bytes of each unit at the screen side */
   int  err;  /*set  this  if  an  error  occured,  that makes the filter
   unusable*/
   Screen side and file side doesn't mean that this is also the number of
   bytes  per bytes on respectively the screen or the file. Other filters
   before or after can change this.

   It  contains the procedure fromfile which transfroms the data from the
   file to the datatype (ScreenPart):

   virtual  int  fromfile(unsigned  char  *input,int  &len,unsigned  char
   *output)

   Input:  contains the input, len the length of the input. If less bytes
   are  used  len  is  set to the acually used length. output points to a
   array  in which the output is written. The function returns the length
   of the output.

   virtual  int  tofile(unsigned  char  *input,int  &inplen,unsigned char
   *output)

   To  file  is  identical  except  that  now  the  direction is from the
   datatype to the file.

   Beside these, it should contain the following procedures:

   SubFilter(int filebytes,int screenbytes,char *conf)

   Constructor  with as arguments the number of bytes at the file side of
   the  filter (filebytes), the number of bytes at the screen side of the
   filter  (screenbytes)  and  a  config  string (conf). conf is a string
   returned  by  convstr  of  the  same  filter class and is used to save
   settings of the filter when saving datatypes.

   char *convstr(void)

   Procedure  that  returns  a  configuration  string used to set options
   while recreating this filter.

   SubFilter(Filter &rev)

   A copy contructor.

   Filter *newone(void)

   Returns a new copy of this filter

   int chbytes(int b)

   Changes the number of bytesfile to b. Returns -1 on failure, otherwise
   returns bytesscreen (after having recalculated it's value).

   int chbytesback(int b)

   Changes  the  number  of  bytesscreen  to  b.  Returns  -1 on failure,
   otherwise returns bytesfile (after having recalculated it's value).

   int equal(Filter *fil)

   Returns 1 if fil is equal to this filter, 0 otherwise.

   virtual int screen2filepos(int pos)

   Can  be  defined  to  return the byte position on the fileside given a
   position on the screenside.

   virtual int file2screenpos(int pos) 

   The same as screen2filepos in the opposide direction.

   Outside   of   the   class   you   should  register  the  filter  with
   registerfilterclass(SubFilter).  Needed for example to use this filter
   while reading saved datatypes.

   Currently  you  should  write  your own procedure to add a filter to a
   datatype. The most simple procedure is the following:

#include "global.h"
#include "screenpart.h"
#include "reverse.h"
BEDPLUGIN
class Editor {
public:
#include "faked.h"
int addFilter(void) {
        ScreenPart *part=activemode();
        int byt=part->datbytes();
                Reverse *sub=new Reverse(byt,byt,"1");
                if(sub->error()) {
                        message("cant add filter");
                        return -1;
                }
                   addfilter(sub);
        return 0;
        }
};
call(addFilter)

   You  should  Reverse  change  in the name of the Filter and "1" to the
   config string.

ENVIRONMENT

   BEDRC
          Absolute filename of configuration file.
   EDITOR
          Preferred editor
          unix: export EDITOR=vi
          windows: set EDITOR=notepad
   PAGER
          Preferred  pager used to show context sensitive help in bed. If
          the pager returns immediately, bed refreshes its screen, so you
          can't use more.
   LINES_USE_PAGER
          The  pager  set  by  PAGER  is  only used when the help text is
          larger  (in  lines) then LINES_USE_PAGER. Otherwise an internal
          pager is used.
   SHELL
          Preferred shell. Use unix like / to separate dirs
   TMPDIR (unix) or TMP or TEMP (win95) 
          Directory for temporary files
   It is possible to set environmental variables in the configuration
          file:
   setenv name [val]
          Leaving out val means unsetenv.



FILES

   ~/.bedrc
          Individual configuration.
   /usr/share/bed/bedrc
          System wide configuration.
   /usr/share/bed/plugins/*
          Files   needed   to   compile   plugins:   plugin.cpp   faked.h
          mainprocedures.h Makefile



PORTABILITY

   Binaries available for:
   Linux Fedora 9
   FreeBSD 4.4
   Windows95

   If  bed  doesn't  run  or  compile  with your linux, FreeBSD or cygwin
   distribution  or  you have a different widely used Unix variant with a
   working  gcc  and  ncurses installation and able to run on my computer
   (athlon  800mhz, 192 meg ram, 40 gig Harddrive), send me a copy of the
   CDROMs containing the distribution and I will try to port bed to it.


AUTHOR

   Jaap Korthals Altes
   Onnemaheerd 62
   9736 AP Groningen
   The Netherlands

   SMS: +31618329514

   E-Mail: jkaltes3@hotmail.com
   But the account is probably disabled before I read it.

HOMEPAGE

   http://bedlinux.tripod.com


DOWNLOAD

   http://bedlinux.tripod.com/download.html
   ftp://sunsite.unc.edu/pub/Linux/apps/editors/terminal/
   Source:
   http://bedlinux.tripod.com/download/bed-0.2.22.src.tar.gz
   Fedora 9 binary:
   http://bedlinux.tripod.com/download/bed-0.2.22.bin.ELF.tar.gz
   FreeBSD 4.4 binary:
   http://bedlinux.tripod.com/download/bed-0.2.22.FreeBSD.tar.gz
   Windows 95/98/Me Binary:
   http://bedlinux.tripod.com/download/bed-0.2.22.win32.zip     (pdcurses
   version and binpatch to ncurses version)
   Needs cygwin1.dll out of the bootstrap package of cygwin. You can also
   take  this  one http://bedlinux.tripod.com/download/cygwin1.dll.zip It
   is   compiled   with   the   free   CYGWIN   version   of   gcc.   See
   http://sources.redhat.com/cygwin/

   To compile bed for win32 you need:
   - gcc,binutils,gnu make,grep,
   sed,textutils,findutils,fileutils,diffutils,which  and  probably  some
   other utilities from cygwin http://sources.redhat.com/cygwin/
   -   GNU   regex   (different   from   libregex.a   from  cygwin):  e.g
   http://ftp.gnu.org/pub/gnu/regex/
   - pdcurses source http://pdcurses.sourceforge.net


SEE ALSO

   printf(3),  scanf(3),  strings(1),  grep(1),  dd(1)  head(1), tail(1),
   regex(7),  ncurses(3),  od(1), hexdump(1), beav(1), bvi(1) terminfo(5)
   readelf(1)
     _________________________________________________________________



Index

   NAME

   SYNOPSIS

   DESCRIPTION

        Interface

        Data types

        Search

        Replace

        Tools

   OPTIONS

   CONFIGURATION 

        Path

        Keys

        Menu

        Call_on

        Context

        Color

        Procedures

   PLUGINS

        Introduction

        Editor

        Global

        Datatypes

        Filters

   ENVIRONMENT

   FILES

   PORTABILITY

   AUTHOR

   HOMEPAGE

   DOWNLOAD

   SEE ALSO
     _________________________________________________________________

   This document was created by man2html, using the manual pages.
   Time: 19:47:22 GMT, March 05, 2004
