Content-type: text/html; charset=UTF-8
Adjustable data format binary editor. Data formats are ASCII, unsigned and signed integers, float, bit-flags, bit-fields, labels, ebcdic and time_t. Different sizes and byte orderings are possible. Data types can be used in structures. Other data formats, filters and procedures can be defined in plugins. Contains copy, past, undo, redo, search, replace, marks, record/play and context sensitive help. Raw edit of hard drives. Under Linux and FreeBSD even usable without X windows.
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 type-over 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 leave 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 hard drives) 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 into a time consuming 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.
composed data type
It is also possible to form composed data types (structures, records).
At different offset within a unit the file content is displays in a different
data type.
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 data type 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-t,d,makemode setting for Nr bytes 4 and check Dec and Add field.
All kind of operations which can be applied to basic (single) data types can also be applied on composed data types: search, replace and the addition of a filter (e.g reorder). To do this you need to make the composed data type the active data type. You can do this by setting the cursor between two of its elements or by using Alt-y,t.
Switching data type
Moving between parts of the screen with different data types
you can do with Prev (Alt-d,v) and Next (Alt-d,n).
Zooming a data type you do with Full (Alt-d,f), removing a
data type with Remove (Alt-d,r).
Save selection saves the selected part of the file in the
format of the active data type.
Adding data types
You can add a data type with ASCII, Integer, Signed, Float, Clone.
Clone gives an identical copy of the currently active
data type.
Integer (alt-d,i) gives the following window:
(*) Hex ( ) Dec ( ) Custom: ( ) Oct ( ) Bin Base nr: Nr bytes: 1 (*) Add field Ok Cancel ( ) Separate
Saving data types:
Press Alt-y,w (Write Type) to save a data type. You can read it again with Alt-y,d (Read Type). /usr/local/share/bed/misc contains some example
saved data types. Read /usr/local/share/bed/misc/README.txt for a description.
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 data type 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 data type 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 data types 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 data type is returned. When
searching for 1 in a hex data type 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 data types 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. If 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, Dec etc give when checked the current active data type.
The last data type is the currently active. In this case that it char2. Which is a plugin data type.
Nr bytes: give the number of bytes each data item occupies. By
some data type you can change this for example by unsigned integers.
Options (applied to all files)
XTerm*metaSendsEscape: true XTerm*altSendsEscape: trueto ~/.Xdefaults or /etc/X11/app-defaults/XTerm to use bed in xterm. Changes take effect after the next restart of X windows or after running xrdb filename.
set|grep TERMreturns TERM=xterm, you probably get a messed up screen.
export TERM=rxvtwill solve the problem (if you have the right bedrc file, this is already done for you).
In the
Edit->Keyboard Shortcutsmenu of gnome-terminal you switch off
[ ] Enable menu access keysand
[ ] Enable menu shortcut keyAlso change the following Shortcut keys:
Help Contents Ctrl+Alt+H(instead of F1)
View Full Screen Ctrl+Alt+F(instead of F11)
XTerm*metaSendsEscape: true XTerm*altSendsEscape: true UXTerm*metaSendsEscape: true UXTerm*altSendsEscape: true KOI8RXTerm*metaSendsEscape: true KOI8RXTerm*altSendsEscape: trueFor the ncurses version you need to download ncurses libraries from http://cygwin.com
options optionsAfter the keyword options options are given in exactly the same way as after bed in the command line. These options are processed after the commandline options and in the order they are given in the configuration file (when multiple options keywords are specified). For example if you add
options -Cto the /usr/local/share/bed/bedrc (and that is the only configuration file) -B on the command line loses its effect.
options -wyou can for example make bed always experimentally determine the sizes of hard drives and DVD's instead of relying on the sizes returned by system calls end the like.
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(5) 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
command line
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 [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 menu items to menu's.
For example:
menuitem 0 "~Quit" 1 = quit
menuitem menunum menuitemlabel menuitemnum
Replaces the existing menu item 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 menu item, while shifting the existing menu items 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 menu item menunum defaults to the last mentioned menu. menuitemnum defaults
to the highest menu item 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 menu item 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 menu items. 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 menu item menuitemnum from menu menunum. menunum defaults to the last
mentioned menu, menuitemnum to the highest numbered menu item.
When only one number is given it is interpret as meaning menuitemnum (for
menunum the default is used).
To delete the fourth menu item 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.
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-F7In 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 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 command line
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.
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 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.
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.
Save current file.
Save currently active file to a file with another name.
Rewrites screen.
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.
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.1). 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 the bed 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 it in the Procedures subsection of the CONFIGURATION section of the manual page.
Close the current file.
Quit application. For all changed files you are asked to save it.
Undo last change. It can't always undo all changes. Currently restricted to the last 5000 changes or how MAXUNDO was otherwise defined during the compilation of bed.
After you have undone something with undo, you can redo it with redo. Redo is impossibly following a change after the undo.
Turns selection on or off.
Copies selected part of the file to copy buffer.
Past selection.
Save selection or copy buffer.
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
Make the file larger, adding zeros to the end of file.
Truncates file on the right of cursor.
Repeats command a certain number of times.
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
Search again for the same search string.
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
Set mark
Goto mark. You are asked to type the corresponding key.
Goto next mark
Goto previous mark.
Shows list of all marks. Press Return to jump to the file offset of the selected mark.
Delete mark. You get an overview of current marks. Press return to delete the currently selected mark.
Delete all marks.
Save marks to file.
Read saved marks.
Moves file display so that the file offset at the cursor position is shifted to the upper left corner of the file display.
Goto the beginning of file.
Goto end of file.
To the top of page.
Goto end of page
Goto the middle of the page.
Goto the data type on the right of this data type.
Goto the data type shown on the left of current active data screen.
Closes data type screen part.
Zooms current data type (For example ASCII).
Adds previous file to the screen
Adds the next file to the screen.
Goto previous file. Zooming the file.
Goto next file.
Goto the first opened buffer.
Goto last opened file.
Zooms current window
Get opened file from the screen without closing it
List opened files. Press Enter to edit selected file.
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.
(MS Windows Consoles only)
Hides or shows message line.
Hides or shows menu bar.
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.
Go back one character.
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.
Opens new document of size 1. You can enlarge the document with Alt-e,x.
Displays information about current file.
Checks if current file is modified by comparing changed parts with the original file.
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 bed.1).
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.
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 manual page bed.1 or bed -h for more information.
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.
Insert file content within active datatype. The content of the file is interpreted as consisting of data in the active datatype.
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.
Moves one item forwards. Item is the active datatype unit.
Moves one item backwards. Item is the active datatype unit.
Go to previous file offset.
Go again to file offset before undo move.
Scrolls file up. The second line is scrolled up to the first line position.
Scrolls file down. The first line is scrolled down to the second line position.
Shift left one item. The second item is shifted leftwards to the first item position.
Shift right one item. The first item is shifted rightwards to the second item position.
Shift left one byte. The second byte is shifted leftwards to the second byte position.
Shift right one byte. The first byte is shifted rightwards to the first byte position.
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
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 unsigned integer help (Alt-d,i).
Skip empty parts within a composed datatype. Useful if a file contains records with parts you are not interested in.
Create a datatype that is identical to the active (sub) datatype.
Create signed integer datatype. See unsigned integer help (Alt-d,i) for more information.
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.
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.
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 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.
List of all datatypes. Use movement keys to select one of them and press Return to create it.
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'.
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.
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.
Removes last filter (Reorder, Duplicate, Skip or some other filter defined in a plugin).
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.
Modify parameters of active (sub-) datatype. Things like number of bytes and the base of Integers.
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.
Save datatype to file so you don't have to recreate complex datatype everytime you need them.
Read saved datatype. So that the current file is displayed in that format.
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 necessarily 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.
Save recorded keystrokes to file.
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.
If you have recorded keystrokes after program startup you can play them off with this procedure.
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.
Shows which procedure is bounded to a key sequence in the format used in bed's configuration file (bedrc). You are asked to press a key sequence.
Besides the procedure is shown what you need to write in the configuration file to declare this key-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 key sequence you want to bind it to. You could for example press C-a get 1 as answer and replace '27 91 50 52 126' in the previous keys statement with 1. So you could add keys 1 = makeselection to the end of ~/.bedrc
To know a procedure bounded to the menu, you press the key sequence needed to operate the menu using only the highlighted characters. 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 manual page bed.1 for more details about assigning procedures to menu items and keys.
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.
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}.
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.
Parent datatype. Make active datatype the datatype in which the current datatype is contained.
If applied to a composed datatype, this makes the current active datatype the member of the composed datatype the cursor is on.
Raw edit of disk drives.
Select a device to edit like a large file. When you make changes keep in mind that bed saves information in blocks (of something like 512, 1024 or 4096 bytes long). So with the changes you make, you also write back the old content around the change. If another process changed something there, you will write old information back. The devices shown are taken out of /proc/partitions. Subvolumes of LVM partitions are not included. To edit them start bed with something like
bed /dev/mapper/*
Before editing any hard disk device decide with which permissions and under what user and group you want to do that. Before changing anything in a real hard drive, try you changes first on a test file or better a test USB-stick.
Repeatedly calls undo (Alt-e,u) plugin undoall.cpp
Repeatedly calls redo (Alt-e,r) plugin undoall.cpp
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
/*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.
Bed running the Fedora 10 version of Linux doesn't load plugins.
It has something to do with NSA Security-Enhanced Linux (SELinux).
See
selinux(8)
If the command
getenforcereturns Enforcing, your installation has this problem. If you have root permissions you can turn it of with the command
setenforce 0To keep it disabled after a reboot you have to make the following changes in /etc/selinux/config:
Remove: set SELINUX=enforcing Add: set SELINUX=disabled
For more information follow setenforce(1)
You can also keep SELinux enforcing and do the following:
chcon -t textrel_shlib_t *.plug for bedplug in *.plug; do semanage fcontext -a -t textrel_shlib_t $bedplug ;done
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.
/*start stupid.cpp #compile with make stupid.plug #put in ~/.bedrc plugin /usr/local/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" BEDPLUGINInstead 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.
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) {
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.
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.
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).
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.
E-Mail: binaryeditor+bed@eml.cc
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://cygwin.com
- GNU regex (different from libregex.a from cygwin): e.g. http://ftp.gnu.org/old-gnu/regex/regex-0.12.tar.gz
- pdcurses source http://pdcurses.sourceforge.net
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)