Lịch sử phiên bản

A banner as soon as the file opens

Under the menu, the number of missing libraries and interfaces, with their list (GUID and name). The detailed list is also in the object browser.

“Supply files…”

The button accepts one or more .ocx, .dll, .tlb, .olb or .exe files, with the local engine as with the remote one; the binary is reopened at once with the new names. Only the type description is read: the component is never run.

The Visual Basic 6 controls, recognised out of the box

• MSFlexGrid, MSDBGrid, Hierarchical FlexGrid, DataGrid, MSChart, SSTab, RichTextBox, MaskEdBox, MSComm, Common Controls 2, ADO Data Control, Forms 2.0.
• The old Sheridan 3D, Outline, Crystal Reports 4.6 and Windows 2000 Imaging (scanning) controls.
• The VB and VBA libraries themselves are no longer reported missing on a server without Visual Basic 6 installed.
• Calls that could be resolved came out as vtable offsets: on a customer's program, more than 140,000 calls get their name back.

Parameters

A ByRef parameter is no longer inferred from the mere fact that the procedure writes it, since VB6 allows writing a ByVal parameter; its type comes from the function that reads it or the library that declares it. ByRef … As Currency, object parameters and As String parameters better recognised.

Arrays

Indexed accesses keep their array in more cases: constant offset, index passed through a temporary variable, fixed-size arrays in a local user-defined type.

Files

The Put # statement is reconstructed; it was missing entirely. Print on an object is no longer confused with Print # to a file.

Late binding

Correct argument count, indexed properties kept on write, member names read from the type library, accented names correctly decoded (they came out as ideograms).

Functions, return values, control flow

• MsgBox no longer loses its arguments; InStr on a Variant is reconstructed; CreateObject no longer carries an invented argument; “= False” is no longer lost where “= True” came out right.
• Complete structure returns; spurious returns and duplicated lines removed; Variants better tracked from one call to the next.
• Labels targeted by a jump always exist; correct stack level at branches; procedures without an ebp frame read better.
• Fewer “?” markers (unproven values) in the output, without ever replacing a “?” with a plausible but wrong value.

• A link to the documentation in the Help menu.
• The object browser is translated into French and Spanish.
• The notes added to an exported project are written in the interface language.
• The binary's resources (icons, images, strings) are listed and served.
• Optional sharing of library descriptions with the server: the question is only asked if the server keeps a shared catalogue; a refusal is never asked again, and the choice can be withdrawn in the preferences. The shared catalogue is not active yet: nothing is sent in this version.

• The package contains no part of the decompiler: decompilation is still served by our servers.
• Binaries and installers signed and timestamped; application obfuscated.

The branches of a Select Case came out empty

When the compiler turned a Select Case into a jump table, all seven branches appeared empty and the final value was lost. They now show their content, string literals included.

If ComponentType() > 6 Then
ElseIf ComponentType() = 0 Then
Else
End If

GetFilename = (? & ?)

If ComponentType() = 0 Then
    s = (FormName & ".frm")
ElseIf ComponentType() = 1 Then
    s = (FormName & ".ctl")
' … all seven branches

Method calls disappeared without a trace

When an object was stored in a module-level variable, the call that followed was sometimes silently dropped: eleven statements recovered on our reference binaries, including window display calls.

If Method = 0 Then
    OHash.Insert key(i), rec(i)
ElseIf Method = 1 Then
    ' (nothing)
Else
    ' (nothing)
End If

If Method = 0 Then
    OHash.Insert key(i), rec(i)
ElseIf Method = 1 Then
    AHash.Insert key(i), rec(i)
Else
    Collect.Insert key(i), rec(i)
End If

The value of a single branch was shown for all of them

When several branches of a test assigned different values to the same variable, the product sometimes showed the value of a single branch, as if valid for every path. Nothing flagged it.

If aExport Then
ElseIf nom Like "*.ocx" Then
Else
End If

s = "Type=Exe" & "Startup=" & …

If aExport = 0 Then
    s = ("Type=Exe" & vbCrLf)
ElseIf nom Like "*.ocx" Then
    s = ("Type=OleDll" & vbCrLf)
Else
    s = ("Type=Control" & vbCrLf)
End If

Releasing an object variable showed an invented value

A plain Set X = Nothing could come out as an expression that made sense in no program. Twenty-three termination procedures checked: none left.

Set node = (Me And 1)
Set hash = eax
Set p0   = arg_8

Set node = Nothing
Set hash = Nothing
Set p0   = Nothing

Some calls named the wrong method

Within a class, a call could carry the name of another method, a defect invisible when reading since the displayed name does exist. The called member is now identified by its real position rather than its declaration order.

chrono.Elapsed
table.Find size, …
r = table.Delete(key)

chrono.Reset
table.Init size, …
r = table.Find(key)

A method with no return value was shown as if it had one

Collection.Add and Err.Raise return nothing. Their internal result was taken for a value and assigned to a variable: twelve false assignments fewer.

• Third-party controls: TreeView, ListView and the like. Their properties and methods carry their names, including for the objects they return.
• Standard Windows interfaces: named instead of shown as an identifier.
• Private WithEvents variables: their type is recovered, which makes their event handlers readable.
• On a UserControl: the controls placed on it are written as in the source, without a spurious prefix.

The ? marker flags a value the product could not establish with certainty. We would rather show it than invent one, but the fewer there are, the better. On our reference binaries, their number dropped by about a third since the previous version. Causes addressed: field addresses lost in the middle of a loop, computed array elements, register-passed arguments, values shared between several branches of a test.

• Module variables are declared. Without their declaration line, Visual Basic 6 read an array access as a call to a non-existent function and rejected the whole file.
• Fixed-size local arrays too, with their real bounds read from the binary.
• Variadic procedures are recognised as such.
• Relayed parameters keep their array nature across several call levels.
• An interface with a masked name is no longer written as is: VB6 rejects any identifier starting with an underscore.