Hex Editor

Overview

The hex editor was designed for reverse engineering 6502 machine code, initially for the Atari 8-bit computer systems, but expanded to Apple ][ and other 6502-based processors. There is also support for most other 8-bit processors, but as the author doesn’t have experience with other 8-bit processors they have not been extensively tested.

Opening a file to edit will present the main hex edit user interface that shows many different views of the data. Editing is supported in the hex view, character view, and the disassembly. There is also a bitmap view but is presently only for viewing, not editing.

Viewing Data

The various views can be scrolled independently, but there is only one cursor location. Clicking on a location in one view will move the other views to show the same location. Selections are analogous; see below.

Segments

Binary data is parsed using code that started life as part of Omnivore but I spun it out because it’s useful as a standalone library: atrcopy. It knows a lot about Atari 8-bit files and disk images, knows some stuff about Apple ][ files and disk images, and knows almost nothing about anything else (yet). Atrcopy thinks of binary data in terms of segments, where a segment is simply a portion of the disk image.

The interesting feature of atrcopy is due to the use of numpy, and it’s this: segments can provide views of the same data in different orders. And, changing a byte in one segment also changes the value in other segments that contain that byte because there is only one copy of the data.

This turns out to be super useful. For instance, the first segment that appears in Omnivore’s list of segments will contain all the data from the disk image, in the order that the bytes appear in the file. This may or may not mean much depending on the format of the image. As an example, the catalog of an Apple DOS 3.3 disk is stored in sectors that increment downwards, so the catalog appears backwards(-ish. It’s complicated). So atrcopy goes further and breaks this disk image segment into smaller segments depending on the type of the file. In the catalog example above, it creates another segment that displays the catalog in the correct order. Changing a byte in either of those segments will change the value in the other, because it’s really the same value. It’s just two different looks into the same data.

Editing Data

Hex data can be edited by:

  • clicking on a cell and changing the hex data
  • selecting a region (or multiple regions; see Selections below) and using one of the operations in the Bytes Menu
  • cutting and pasting hex data from elsewhere in the file
  • cutting and pasting hex data from another file edited in a different tab or window
  • pasting in data from an external application.

Character data can be edited by clicking on a character in the character map to set the cursor and then typing. Inverse text is supported for Atari modes. Also supported are all the selection and cut/paste methods as above.

Baseline Data

Omnivore automatically highlights changes to each segment as compared to the state of the data when first loaded.

Optionally, you can specify a baseline difference file to compare to a different set of data, like a canonical or reference image. This is useful to compare changes to some known state over several Omnivore editing sessions, as Omnivore will remember the path to the reference image and will reload it when the disk image is edited in the future.

As data is changed, the changes as compared to the baseline will be displayed in red.

By default, baseline data difference highlighting is turned on, you can change this with the Show Baseline Differences menu item.

Selections

Left clicking on a byte in any of the data views (hex, char, disassembly, bitmap, etc.) and dragging the mouse with the button held down will start a new selection, finished by releasing the mouse button. The selection will be shown in all views of the data, scrolling each view independently if necessary.

The selection may be extended by shift-left-click, extending from either the beginning or the end of the selection as appropriate.

Multiple selections are supported by holding the Control key (Command on Mac) while clicking and dragging as above. Extending a selection when using multiple selection is not currently supported.

Find

The data is searchable in multiple ways. Starting any search will display a search bar on the bottom of the main window. The basic search bar available with the `Find`_ menu item tries to be flexible and will show matches in any data view using an appropriate conversion for that view. For instance, the text string “00” in the search bar will find values of 0 in the hex view, strings of “00” in the character view, labels that have “00” anywhere in their text, “00” as an operand in the disassembly, or anything that has “00” in a comment.

The Find Next and `Find Prev`_ menu items (or keyboard shortcuts) will traverse the list of matches.

A more complicated search can be performed using the Find Using Expression menu item that support ranges of addresses or specific data values as search parameters using arbitrary boolean expressions.

Comments

Comments are a hugely important part of reverse engineering, because by definition the original source has been lost (or was never available). As you figure things out, it’s important to write things down. Omnivore supports adding a comment to any byte in the file, and it will appear in any segment that views that byte.

In the sidebar is a big ol’ list of comments, and selecting one of the comments will move the data views to display the byte that is referenced by that comment. Because there may be multiple views of the same byte, the comment shown in the comments list is the first segment that contains that comment.

Note that segments must have a defined origin for the segment to be considered as the primary for that comment.

Disassembler

Omnivore started out as a reverse engineering tool for Atari 8-bit computers, which use the 6502 processor. After developing for a while, I found a python disassembler called udis that supports multiple processors. Through its usage, Omnivore can disassemble (and assemble! See below) code for:

  • 6502
  • 65816
  • 65c02
  • 6800
  • 6809
  • 6811
  • 8051
  • 8080
  • z80

but the 6502 is the only processor have direct knowledge of and so the only one I’ve tested thoroughly. Bug reports (and patches!) for the other processors are welcome.

Mini-Assembler

The disassembly can be edited using a simple mini-assembler; clicking on an opcode provides a text entry box to change the command. The mini-assembler supports all CPU types, not just 6502.

Labels

Labels can be set on an address, and the label will be reflected in the disassembly code. Also, memory mapping files can be supplied that automatically label operating system locations.

Data Regions

To support reverse engineering, regions can be marked as data, code, ANTIC display lists, and other types. Regions are highlighted in a different style and changes how the disassembly is displayed.

Static Tracing of Disassembly

To help identify regions, static tracing can be used. Turning on static tracing assumes that every byte is data and shows temporary highlights over the entire segment. Starting a trace at an address causes Omnivore to follow the path of execution until it hits a return, break or bad instruction, marking every byte that it traverses as code. It will also follow both code paths at any branch. This is not an emulator, however, so it is not able to tell if there is any self-modifying code. Any blocks of code that aren’t reached will require additional traces. When tracing is finished, the results can be applied to the segment to mark as data or code.


File Menu

New

A list of supported file types that can be created by Omnivore.

Choosing an item in this list will open up a new tab in the current window showing a new blank template of the selected file format.

Available templates include:

  • Apple DOS 3.3 (140K) AUTOBRUN image
  • Apple DOS 3.3 (140K) blank image
  • Atari DOS 2 DD (180K) blank image
  • Atari DOS 2 ED (130K) blank image
  • Atari DOS 2 SD (90K) blank image
  • Atari DOS 2.0S SD (90K) system disk
  • Atari DOS 2.5 ED (130K) system disk
  • Getaway Map
  • Jumpman Level
  • template://no-json.dsk

Open

Open a file using a file select dialog box.

Open Recent

This submenu contain a list of the files most recently loaded or saved.

You can limit the number of items to remember in the General tab of the Preferences dialog.

Insert File

Insert binary data at the cursor

The data from the loaded file will overwrite data starting at the cursor, so it’s not inserted in the text editor sense where space is created in the existing data.

Save

Save the file, overwriting the previously saved version

Save As

Save the file to a new filename, leaving the originally loaded unchanged on disk.

Save Segment As

Disassembly (.s)

ATasm LST file (.lst)

Raw Data (.dat)

Save As Image

Save the current view as an image (if possible with this editor)

Revert

Reverts the file to the last saved version on disk

This throws away any edits and is not undoable.

Page Setup

Choose options for printing

Print

Print the current view to a printer

Export as XEX

Create an Atari 8-bit executable from a set of segments.

Opens a dialog window providing a list of segments to be added to the new executable and a starting address at which the Atari will begin executing the program on completion of the load.

Export as Boot Disk

Create an Atari 8-bit boot disk from a set of segments.

Opens a dialog window providing a list of segments to be added to the boot disk and a starting address at which the Atari will begin executing the program after reading all the sectors written to disk.

This creates a smaller-than-normal ATR image with a custom bootloader. Any sectors beyond the number fo sectors required to create the image are not included in the image.

Quit

Quit the program

Edit Menu

Undo

Undo the last action

Actions that modify data are undoable; some that modify the metadata are but movement commands are not stored in the undo list, so for example cursor moves or changes to selection regions are not undoable.

Redo

Redo the last operation that was undone. See Undo.

The commands in this menu operate on the current selection to change the byte values to:

Revert to Baseline Data

Restore the selection to the data contained in the Baseline Data file.

Cut

Cut and remove the current selection

Copy

Copy the current selection

Copy Special

Copy Disassembly Text

Copy the disassembly text of the current selection to the clipboard.

Copy Disassembly Comments

Copy the text of the comments only, using the disassembly for line breaks. Any blank lines that appear in the disassembly are included in the copy.

Copy as Escaped String

Copy the current selection as a text string containing a string (with escaped characters where necessary) that reproduces the bytes in the selection.

Python note: both double quotes and single quotes are escaped as hex values so the resulting string is safe to use inside either of those characters as the string delimiter.

Copy as C Data

Copy the current selection as text where each byte is converted to the C source code representation.

Paste

Paste from the clipboard

Paste Special

Paste and Repeat

Paste and repeat clipboard data until current selection is filled

Paste Comments

Paste text as comment lines

Select All

Select the entire document

Select None

Clear selection

Invert Selection

Inverts the selection; that is, select everything that is currently unselected and unselect those that were selected.

Mark Selection As

Code

Marks the selected bytes as valid code to be disassembled using the current processor definition.

Data

Marks the selected bytes as data, not to be disassembled but shown as byte values in the disassembly listing.

Uninitialized Data

Marks the selected bytes as unitialized data, skipping over those bytes and placing an origin directive in the disassembly that points to the next address that contains any other type of data.

Display List

Marks the selected bytes as an ANTIC display list, which will be shown as data in the disassembly listing. The data will be grouped by ANTIC command, where all bytes that belong to a command will be on a single line. This can result in a large number of data bytes appearing on one line when displaying a graphics 8 display list, for example. Exporting the disassembly will produce listings that break up these long lines into normal amounts, defaulting to 4 bytes on a line.

Jumpman Level Data

Marks the selected bytes as Jumpman drawing element descriptors. This is not used much for direct editing now that the Jumpman Level Editor is available.

Jumpman Harvest Table

Marks the selected bytes as a Jumpman harvest table. This is not used much for direct editing now that the Jumpman Level Editor is available.

Find

Find bytes or characters in the raw data or in disassembly comments

Find Using Expression

Find bytes using logical and arithmetic comparisons

Find Next

Find next match

Find to Selection

Convert all matched locations to multi-selection

Preferences

Open a window to change program settings and defaults.

View Menu

Predefined Machines

These are built-in machine definitions that store preset values for Processor, Memory Map, Colors, Font, Character Display and Bitmap Display.

Currently defined machine types are:

  • Generic 6502
  • Atari 800
  • Atari 800 (show undocumented opcodes)
  • Atari 800 (highlight undocumented opcodes)
  • Atari 5200
  • Apple ][

Processor

The processor type defines the opcodes displayed in the disassembly window and those understood by the mini-assembler.

Currently supported processors are:

  • 6502
  • 6502 (with undocumented opcodes)
  • 6502 (highlighted undocumented opcodes)
  • 65c02
  • 65816
  • 6800
  • 6809
  • 6811
  • 8051
  • 8080
  • Z80

Assembler Syntax

MAC/65

cc65

MADS

Merlin

Add New Assembler

Add the syntax characteristics for a new assembler.

Edit Assemblers

Modify the list of assemblers, rearranging the order or editing the characteristics of existing assemlers.

Set Current as System Default

Mark an assembler that will become the default for future editing sessions.

Memory Map

In the disassembly window, target addresses for jumps, branches, loads, stores, compares, etc. can be replaced by text labels that are defined for the particular platform. For example, on the Atari 8-bit platform, occurrences of $E459 will be replaced by SIOV.

Some platforms like the Atari 8-bits have hardware locations that perform different functions depending on whether it is read from or written to. The disassembler can handle this, so reading the location $D000 will show the label M0PF (missile 0 to playfield collisions) while writing will show HPOSP0 (set the horizontal position of player 0).

Currently supported platforms are:

  • No Memory Map
  • Atari 400/800
  • Atari 5200
  • Apple ][
  • KIM-1

Colors

This list sets the color encoding standard for all bitmapped graphics of the disk image. Currently supported are:

  • NTSC
  • PAL

ANTIC Powerup Colors

Changes the color palette to ANTIC Powerup Colors

Use ANTIC Colors

Open a window to choose the color palette from the available colors of the ANTIC processor.

Font

8x8 Atari Default Font

8x8 Atari Custom Computer Font

7x8 Apple ][ Default Font

7x8 Apple ][ Font w/Mouse Text

mountainking.fnt

mountainking.fnt

mountainking.fnt

mountainking.fnt

getaway.var

Load Font

Get Font From Selection

Character Display

Character Display Modes

This submenu contains a list of all available font renderers. Selecting an item in this list will change how the text is displayed in the character map window.

  • Antic 2 (Gr 0)
  • Antic 4 (40x24, 5 color)
  • Antic 5 (40x12, 5 color)
  • Antic 6 (Gr 1) Uppercase and Numbers
  • Antic 6 (Gr 1) Lowercase and Symbols
  • Antic 7 (Gr 2) Uppercase and Numbers
  • Antic 7 (Gr 2) Lowercase and Symbols
  • Apple ][

Character Mappings

This submenu contains a list of all available character mappings. Most platforms use a regular ASCII mapping, but some like the Atari 8-bits have different character mappings depending on the usage: the ANTIC mapping if looking at screen memory and the ATASCII mapping for normal usage.

  • ATASCII Characters
  • Antic Map

Map Width

Set the number of bytes per row of the character display.

Bitmap Display

This submenu contains a list of all available bitmap renderers. Selecting an item in this list will change the rendering of the graphics display.

  • B/W, 1bpp, on=black
  • B/W, 1bpp, on=white
  • Player/Missile, normal width
  • Player/Missile, double width
  • Player/Missile, quad width
  • B/W, Apple 2, Linear
  • Antic B (Gr 6, 1bpp)
  • Antic C (Gr 6+, 1bpp)
  • Antic D (Gr 7, 2bpp)
  • Antic E (Gr 7+, 2bpp)
  • GTIA 9 (4bpp, 16 luminances, 1 color)
  • GTIA 10 (4bpp, 9 colors)
  • GTIA 11 (4bpp, 1 luminace, 16 colors)
  • 2bpp
  • 4bpp
  • 2 Bit Planes (little endian)
  • 2 Bit Planes (little endian, interleave by line)
  • 2 Bit Planes (big endian)
  • 2 Bit Planes (big endian, interleave by line)
  • 3 Bit Planes (little endian)
  • 3 Bit Planes (little endian, interleave by line)
  • 3 Bit Planes (big endian)
  • 3 Bit Planes (big endian, interleave by line)
  • 4 Bit Planes (little endian)
  • 4 Bit Planes (little endian, interleave by line)
  • 4 Bit Planes (big endian)
  • 4 Bit Planes (big endian, interleave by line)

Bitmap Width

Set the number of bytes per row of the bitmap display, which in turn sets the width in pixels.

Bitmap Zoom

Set the zoom factor of bitmap display. This is an integer value greater than zero that scales the display size of each pixel in the bitmap.

Show Baseline Differences

Toggle whether differences to the Baseline Data are highlighted or not.

Text Font

Open a font selection window to choose the font and size used to display the values in the hex grid and the disassembly text.

Pane Visibility:

Toggles whether or not the named extra pane is shown or hidden in the current window.

Current Task:

Changes the view in the entire window to a new editing task. The files in the current task are not lost, it’s just a way to edit different types of files while using the same top level window on the desktop.

Bytes Menu

The commands in this menu operate on the current selection to change the byte values to:

Zero Bytes

Set to zero

FF Bytes

Set to $ff

NOP Bytes

Set to the NOP command of the current processor

Set Value

Prompts the user and sets the data to the specified value

Set High Bit

Or with $80

Clear High Bit

And with $7f

Bitwise NOT

Invert every bit in each byte

OR With

Logical OR the selected data with the user specified value

AND With

Logical AND the selected data with the user specified value

XOR With

Logical XOR the selected data with the user specified value

Left Shift

Shift bits left (multiply by 2), inserting zeros in the low bit

Right Shift

Shift bits right (divide by 2), inserting zeros in the high bit

Left Rotate

Shift bits left where the high bit wraps around to become the new low bit

Right Rotate

Shift bits right where the low bit wraps around to become the new high bit

Reverse Bits

Reverse the bit pattern of each byte; e.g. $c0 or 11000000 in binary becomes 00000011 in binary, $03 in hex

Add

Adds the user specified value to the data, performing a logical AND with $ff if necessary to keep all values in the 8-bit range.

Subtract

Subtracts the user specified value from the data (AND with $ff if necessary). Note the difference between this and Subtract From

Subtract From

Subtracts the data from the user specified value (AND with $ff if necessary). Note the difference between this and Subtract

Multiply

Multiply the data from the user specified value (AND with $ff if necessary).

Divide By

Divides the data by the user specified value by the data, ignoring the remainder. Note the difference between this and Divide From

Divide From

Divides the data from the user specified value (that is to say: dividing the user specified value by the data), ignoring the remainder. Note the difference between this and Divide By

Ramp Up

Starting with the user specified value at the first selected byte, loops over each byte in the selection and adds one to the value of the previous byte. At $ff, it wraps around to $00.

Ramp Down

Starting with the user specified value at the first selected byte, loops over each byte in the selection and subtracts one from the value of the previous byte. At $00, it wraps around to $ff.

Reverse Selection

Reverses the order of bytes in the selection

Reverse In Groups

Segment Menu

View Segment

This submenu contains a list of all segments in the disk image. Selecting one of these items will change the view to the selected segment.

New Segment From Selection

Create a new segment in the segment list using the current selection.

All the bytes in the current selection will be shown in the new segment. If there are multiple selections, the new segment will show the bytes as contiguous but they will represent the original locations in the disk image.

Multiple Segments From Selection

Create a set of segments from the current selection, given the desired length of the resulting segments. If the number of bytes in the selection is not an exact multiple of the specified length, the last segment created will contain the remaining bytes. It will not be padded with zeros.

Interleave Segments

Create new segment by interleaving segments

Set Segment Origin

Sets the origin of the current segment to an address, changing the starting point for all windows displaying this segment’s data.

Add Comment

Add a text comment to a byte location.

A comment is associated with a single byte, so although a range can be selected, the comment is applied to only the first byte in the range.

Bytes with comments will be highlighted in all displays.

Remove Comment

Remove any comments that are in the selected range, or if no selection from the current cursor position.

Add Label

Add a label to a byte location.

Like Add Comment, a label is associated with a single byte, so although a range can be selected, the comment is applied to only the first byte in the range.

Unlike comments, labels are not highlighted and are only shown in the disassembly window.

Remove Label

Remove the label at the current cursor position, or if there is a selection, all labels in the selected range.

Manage Segment Labels

Import

Imports a text file that defines labels and addresses.

The text file should contain the address and the label on a single line. It’s pretty generous about parsing the input; there are two major types recognized.

The first is typical assembler format:

<label> = <address>

where the address can be in decimal without a prefix or in hex with the $ or 0x prefix.

and the second is a line with a hex value first and the label following. Any line without an = character is parsed this way, such that the first thing that lookslike a hex or decimal number is used as the address, and the first thing after that that looks like a valid text string is used as the label. It can be comma separated, space separated, tab separated, etc; anything but =.

Export User Defined Labels

Exports a text file containing label/address pairs.

The text file will have a format that can be included in most assemblers:

<label> = $<hex address>

for example:

SIOV = $E459
SETVBV = $E45C

Export All Labels

Exports a text file containing label/address pairs.

The text file will have a format that can be included in most assemblers:

<label> = $<hex address>

for example:

SIOV = $E459
SETVBV = $E45C

Start New Disassembly Trace

Add Trace Start Point

Start a trace at the cursor or at all instructions in the selected ranges

Apply Trace to Segment

Copy the results of the trace to the current segment

Clear Trace

Clear the current trace

Disk Image Menu

File Type

No parser

Raw Data

Change the parser that generates segments from the disk image.

Atari 8-bit Disk Image

  • KBoot Disk Image:
  • Sparta DOS Disk Image:
  • Atari DOS Disk Image:
  • Atari Boot Disk Image:

Atari 8-bit Executable

  • XEX (Atari 8-bit executable):

Atari 8-bit Cartridge

  • Standard 2 KB Cartridge:
  • Standard 4 KB Cartridge:
  • Right slot 4 KB Cartridge:
  • Blizzard 4 KB Cartridge:
  • Standard 8 KB Cartridge:
  • Right slot 8 KB Cartridge:
  • OSS 8 KB Cartridge:
  • Phoenix 8 KB Cartridge:
  • Low bank 8 KB Cartridge:
  • Standard 16 KB Cartridge:
  • OSS one chip 16 KB Cartridge:
  • OSS two chip (034M) 16 KB Cartridge:
  • OSS two chip (043M) 16 KB Cartridge:
  • MegaCart 16 KB Cartridge:
  • Blizzard 16 KB Cartridge:
  • XEGS 32 KB Cartridge:
  • Switchable XEGS 32 KB Cartridge:
  • Williams 32 KB Cartridge:
  • MegaCart 32 KB Cartridge:
  • Blizzard 32 KB Cartridge:
  • AST 32 KB Cartridge:
  • Ultracart 32 KB Cartridge:
  • DB 32 KB Cartridge:
  • Bounty Bob 40 KB Cartridge:
  • XEGS (banks 0-7) 64 KB Cartridge:
  • XEGS (banks 8-15) 64 KB Cartridge:
  • Switchable XEGS 64 KB Cartridge:
  • Williams 64 KB Cartridge:
  • Express 64 KB Cartridge:
  • Diamond 64 KB Cartridge:
  • SpartaDOS X 64 KB Cartridge:
  • MegaCart 64 KB Cartridge:
  • Atrax SDX 64 KB Cartridge:
  • Turbosoft 64 KB Cartridge:
  • XEGS 128 KB Cartridge:
  • Switchable XEGS 128 KB Cartridge:
  • SpartaDOS X 128 KB Cartridge:
  • Atrax 128 KB Cartridge:
  • MegaCart 128 KB Cartridge:
  • Atarimax 128 KB Flash Cartridge:
  • Atrax SDX 128 KB Cartridge:
  • Turbosoft 128 KB Cartridge:
  • SIC! 128 KB Cartridge:
  • XEGS 256 KB Cartridge:
  • Switchable XEGS 256 KB Cartridge:
  • MegaCart 256 KB Cartridge:
  • SIC! 256 KB Cartridge:
  • XEGS 512 KB Cartridge:
  • Switchable XEGS 512 KB Cartridge:
  • MegaCart 512 KB Cartridge:
  • SIC! 512 KB Cartridge:
  • XEGS 1 MB Cartridge:
  • Switchable XEGS 1 MB Cartridge:
  • MegaCart 1 MB Cartridge:
  • Atarimax 1 MB Flash Cartridge:
  • MegaMax 2 MB Cartridge:
  • MegaCart 2 MB Cartridge:
  • Flash MegaCart 4 MB Cartridge:
  • The!Cart 32 MB Cartridge:
  • The!Cart 64 MB Cartridge:
  • The!Cart 128 MB Cartridge:

Atari 5200 Cartridge

  • Standard 4 KB 5200 Cartridge:
  • Standard 8 KB 5200 Cartridge:
  • One chip 16 KB 5200 Cartridge:
  • Two chip 16 KB 5200 Cartridge:
  • Standard 32 KB 5200 Cartridge:
  • Bounty Bob 40 KB 5200 Cartridge:

MAME

  • MAME ROM Zipfile:

Apple ][ Disk Image

  • DOS 3.3 Disk Image:
  • ProDOS Disk Image:

Apple ][ Binary

  • BIN (Apple ][ executable):

Run Emulator

Run the current emulator using the current emulator.

The current emulator is shown in the Emulators sub-menu.

Emulators

This submenu contains a list of the known emulators and a checkbox to indicate the current emulator.

Add New Emulator

Open up a window to define a reference to an external emulator

Omnivore can run the disk image in any emulator that is capable of being started from a command line. It spawns a separate process and feeds the emulator a path to the disk image along with any necessary command line arguments that you have to specify when setting up the emulator in this window.

Edit Emulators

Make changes to the current list of emulators.

This opens a window with a list of the currently defined emulators to make changes to existing emulators or add/delete any already defined.

Set Current as System Default

The currently specified emulator in the Emulators list will be set as the system default and remembered for subsequent editing sessions.

Expand Disk Image

Resize the document to add extra data at the end

Add Baseline Difference File

Open a window to select a Baseline Data file.

The absolute path to the baseline file is stored, so if the baseline file is moved to a new location you will have to use this command again to point to the new location.

Find Next Difference

Move the cursor to the next block of data that is different than the Baseline Data file.

This will wrap around to the beginning of the segment if it doesn’t find a difference before the end.

Find Previous Difference

Move the cursor to the previous block of data that is different than the Baseline Data file.Data

This will wrap around to the end of the segment if it doesn’t find a difference before the beginning.

List Differences

Show a text representation of the differences

Goto Address

Move the cursor to an address. If the address is in this segment, moves there. If not, it searches through all the segments (in segment list order) to find one that does contain that address.

If that address is not valid for any segment, it will return an error message.

Documents Menu

This menu contains a list of all documents open in the current session, across all windows and tabs. Selecting an item in this list will switch the view to that document, using the editor that was being used the last time it was edited.

Window Menu

New View In

This menu will contain a list of all editors that can modify this file. Selecting an item in this list will add a new view into this file using the selected editor. For instance, you can have a map editor and a hex editor on the same file; they point to the same data and modifying data in one window will show up in the other window.

New Window

Open a new, blank Omnivore window that can be used to load new files or to provide a second view on a currently loaded file.

Help Menu

About

Display window with version number and author info

User Guide

Display the user guide in a new window

Open Log Directory in File Manager

Open the log directory in the desktop file manager program.

The log directory will contain debug logs (if enabled) and other files, most of which are generally only useful for developers or to get more information to send to the developers in the event of a problem.

Show Debug Log

Displays a window that can be used to turn on debugging of particular parts of the program.

The log levels shown initially are the default log levels for each logger. Using the Filter text entry box, you can enter a string or a comma separated list of strings that will be used to select which loggers get switched to DEBUG mode. Everything else gets set to its default state, usually either INFO or WARNING.

The string is not a regular expression, but will match partial strings.

More Debugging

Widget Inspector

Open the wxPython Widget Inspector

Raise Exception

Raise an exception to test the error reporter