The new age of the VB decompilation - VB Decompiler v9.0

After nearly six months of hard work, I'm happy to introduce VB Decompiler 9.0. You may say, why is it 9.0, not 8.5? There are a few reasons for that. The main one is I've completely ported the project from Visual Basic 6.0 to Delphi XE2. Basically, most of the new version is made from scratch. Though it was impossible to port many things as is, I've done my best to make all features work just like they did in the previous version, or even better.

VB Decompiler v9.0

My main achievement is backward compatibility. You can simply copy the new decompiler's EXE file into the folder containing the old version, and it will work fine! All old databases, plugins, knowledge base, and other things used in the previous versions are fully supported in the new version. VB Decompiler 9.0 supports them because I've created some complex classes for processing VB structures and variable-length VB strings, so that the new version can read and parse the databases initially optimized for Visual Basic. I've done a lot of work, and I've succeeded in ensuring backward compatibility!

Another important change is the full integration of the disassembler in the project. Now the emulator and the disassembler are part of the same class, which makes native code emulation much faster. As for the speed of execution, it has increased significantly compared to the previous versions of VB Decompiler. The reasons are as follows: I've greatly optimized the decompiler code and compiled the project into machine code, and now there is a special version for 64-bit Windows. As you can see, lots of things have been improved. Let's take a closer look at some optimizations.

VB Decompiler 9.0 uses a new TreeView control that, unlike the old one, doesn't slow down when a lot of items are added. You could easily see that when decompiling huge, complex projects containing lots of methods and functions. In the previous versions, going through the list of procedures in such files resulted in the control slowing down, and when you clicked on some item, the control could freeze for a few seconds. But now it's in the past. In the new version, everything works very fast!

I've greatly improved the functions for saving the result of decompilation in the database and loading it from there. I've also added several new fields and made a lot of fixes in the database's internal format. That rules out any garbling of the decompiled listing after loading it from the database even if the system language was changed, the original project file is missing, or some fields of metadata are empty.

I've greatly improved the emulation of native code. I've reworked the processing of FPU commands too, which you can see in the example below. Sample source code:

Const Test = "Test case2" Private Sub Form_Load() Dim d As Double, e As Double a = &H100 b = &H200 c = Tan(Sin(a) * Cos(b)) MsgBox c, 64, "Test case" d = 123456.123456 e = Log(c / d + 7654.123) MsgBox e, 64, Test End Sub

When using VB Decompiler 8.4, the result was as follows:

VB Decompiler v8.4 FPU emulator

VB Decompiler 9.0 Pro produces a different result:

VB Decompiler v9.0 FPU emulator

Now take a look at an example of calling some class properties. It's another accomplishment of VB Decompiler 9.0! The processing of calls to class properties and methods has finally been implemented and tested on a number of projects. So far, this improvement only applies to projects compiled into P-Code, but even that is a huge leap forward in decompiling Visual Basic programs.

The source code was as follows:

Private Sub Form_Load() Dim a As cAttribute Set a = New cAttribute a.ID = "Test 2" a.Description = "Test 1" MsgBox "12345" MsgBox a.Description, vbInformation, a.ID End Sub

Here's the cAttribute class:

Option Explicit Private m_ID As Byte Private m_Description As String Public Property Let Description(ByVal vData As String) m_Description = vData End Property Public Property Get Description() As String Description = m_Description End Property Public Property Let ID(ByVal vData As Byte) m_ID = vData End Property Public Property Get ID() As Byte ID = m_ID End Property

Let's compare the decompiled code samples. Here's how it was in VB Decompiler 8.4:

VB Decompiler 8.4 classes

And here's the same piece of code processed by VB Decompiler 9.0:

VB Decompiler 9.0 classes

I've also added new functions for processing branches, cycles, and nested object properties. Now method prototypes and complex Let/Get/Set properties are generated correctly. The detection of GUIDs of external DLL and OCX files has been improved too. I cannot even tell you about every fix or improvement in this article! In short, a lot of things have been changed for better. One of the major news is the greatly improved functions for handling String References, which now work fine in projects of any size!

VB Decompiler string references

Despite the huge number of changes and improvements, the price of the product stays the same. As before, any software developer can afford buying VB Decompiler! And I'll be happy to see you among our customers! If you already have an active license for VB Decompiler, you can download and install the new version right now using the control panel on this website.

(C) Sergey Chubchenko, VB Decompiler's main developer

* Microsoft, Windows, and Visual Basic are registered trademarks of Microsoft Corporation.

Main     News     Products     Documentation     Articles     Download     Order now     About us    

Privacy policy