Hex Editor - Binary File Editing Software for Windows

What's New in Structure Viewer (version 4.71)

Hex Editor Neo is a constantly developing application. Structure Viewer in version 4.71 adds support for the following:

_SVC_VER compiler version macro
Starting from the current version, Structure Viewer defines a macro that holds a current compiler version. Compiler version in 4.71 has a value of 0x200 (major version: 2, minor version: 0).
New built-in types
The parser now natively recognizes three additional types: bool (one-byte boolean type), string (null-terminated single-byte character string) and wstring (null-terminated two-byte character string).
Dynamic typing

When evaluating expressions, dynamic typing rules are used. For example, adding two integers produces an integer, but adding a floating-point number and an integer number produces a floating-point number. The same rules apply to other types and other operators.

Note that this feature introduces a breaking change: the syntax for defining constants has changed.

You can now define variables, and change their values at a later time. Variable's type is polymorphic, that is, it may be changed by assigning a value of another type.
Constant and Variable Arrays

You can now define constant or variable arrays and reference their elements in expressions:

const Months[]={

public struct A
    short month;
    $print("Month as string",Months[month]);
Scripting support

You may now call functions written in Javascript or VBScript from the Structure Viewer expressions. In addition, a number of internal functions are provided. Structure Viewer makes two objects, parser and document, available to the running script.


function ScriptAdd(a,b)
    return a+b;

function IsModified()
    return document.Modified;


#pragma script("functions.js")

struct A
    if (IsModified())
        $print("warning","The document has been modified!");
    char array[ScriptAdd(10,8)];    // equivalent to char array[10+8];
Hex Editor Neo's parser now understands the if statement and switch statement.
“Infinite” Arrays
An array may now be declared as having an infinite (unknown) number of elements. Combined with a new $break_array directive, this allows declaring arrays for which the number of elements is not known beforehand.
#pragma byte_order
You may now instruct the parser how your multi-byte values are packed.
Array optimization

Arrays of simple integer types are now optimized by the parser, reducing the binding time and memory consumption. In addition, you may refer to character arrays (arrays of type char and wchar_t) in expressions. In this case, the contents of an array is represented as a string:

struct A
    char TagName[10];
    if (TagName == "#Default")
        // do something
hidden: and visible: directives
You may now use “hidden:” and "visible:" directives to change the visibility of a field in a user-defined type. The visibility only affects the displaying of the field, otherwise it remains visible when referenced in expressions.
public and private user-defined types.
A user-defined type may now be marked as private or public: private types are not displayed in the Bind Structure Dialog.
$bind directive
$bind directive allows a structure definition to bind another structure.
current_offset built-in variable
You may now use the current_offset pseudo variable in expressions. It will always equal to the offset the next field will be bound to.
array_index built-in variable

This variable evaluates to a current array index when used in an user-defined type. For example:

struct B;

struct A
    B b[10];  // array of 10 B's

struct B
    int b;
    if (array_index == 3)  // fourth element contains another integer
        int c;
“Synchronize Position” mode
A new “Synchronize Position” mode allows you to easily match the location of a bound field anywhere in the document.
Overall performance enhancements and several bug fixes.
Structure Viewer can now easily handle extremely complex structures and arrays with billions and billions of items. Navigating such complex structure is very simple and fast.