.VB File Format – VB6 and VBA

The shape of a file

VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
END
Attribute VB_Name = "Dictionary"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = True
Option Explicit

#Const UseScriptingDictionaryIfAvailable = True

Private dict_pCompareMode As CompareMethod

Public Enum CompareMethod
    BinaryCompare = VBA.vbBinaryCompare
    TextCompare = VBA.vbTextCompare
End Enum

Public Property Get CompareMode() As CompareMethod
Attribute CompareMode.VB_Description = "Set or get the string comparison method."
    CompareMode = dict_pCompareMode
End Property

• The header appears in .cls (and form) files only: VERSION 1.0 CLASS, then a BEGIN … END block of class properties (MultiUse, Persistable, DataBindingBehavior, DataSourceBehavior, MTSTransactionMode; the value -1 is True and a comment after the line gives the readable form). A standard module has none.
• Attribute lines hold settings the editor keeps out of the code window and writes at the top of the exported file (and after a procedure’s heading, for that procedure): VB_Name (the module’s name), VB_GlobalNameSpace, VB_Creatable, VB_PredeclaredId (a class with a default instance, like a form), VB_Exposed (public outside the project), VB_Description, VB_UserMemId (0 makes a member the default member of the class), VB_VarHelpID, VB_ProcData.VB_Invoke_Func. The editor strips them on import, so they exist only in files.
• Then the code: Option statements first, then the declarations of the module, then the procedures. Comments start with ' or Rem and run to the end of the line; a line continues with a space and an underscore as its last character (a comment cannot be continued); a colon separates statements; a statement may have a numeric line label or a Name: label.

Declarations and types

Option Explicit
Option Base 1
Option Compare Text
Option Private Module

Private Const MaxItems As Long = 100
Public Counter As Integer
Dim buffer(1 To 10) As Double
Private names() As String
Private Type Point
    X As Long
    Y As Long
End Type
Private Declare PtrSafe Function GetTickCount Lib "kernel32" () As Long
Private WithEvents sheet As Worksheet
DefInt A-C

Dim declares a variable of a procedure or module; Private and Public (older: Global) declare module-level ones; Static keeps a local between calls; Const makes a constant. Dim a(1 To 10) gives explicit bounds (Dim a(10) has bounds 0 to 10, 11 elements, unless Option Base 1). Deftype statements (DefInt A-C, DefStr S, DefLng, DefBool, DefByte, DefCur, DefDate, DefDbl, DefObj, DefSng, DefVar, DefLngLng, DefLngPtr) make undeclared names beginning with those letters that type. Type characters % & ^ ! # @ $ (^ is LongLong) may end a name or a number.

Procedures, classes and events

Public Property Get Count() As Long
    Count = m_count
End Property
Public Property Let Count(ByVal Value As Long)
    m_count = Value
End Property
Public Property Set Owner(ByVal Value As Object)
    Set m_owner = Value
End Property

Public Event Changed(ByVal NewValue As Long)

Private Sub Class_Initialize()
    Set m_owner = Nothing
End Sub

Public Function Find(ByVal key As String, Optional ByVal start As Long = 1) As Long
    Dim i As Long
    For i = start To UBound(m_keys)
        If m_keys(i) = key Then
            Find = i               ' the result is assigned to the name
            Exit Function
        End If
    Next i
    Find = -1
End Function

• Procedures: Sub, Function (the result is assigned to the function’s name) and Property Get, Property Let (a value) and Property Set (an object); Public, Private or Friend and Static. Parameters are ByRef by default (the opposite of .NET), may be ByVal, Optional (with a default, or tested with IsMissing on a Variant) or ParamArray. A call is Foo(a, b) in an expression, but as a statement either Call Foo(a, b) or Foo a, b with no brackets.
• Objects: Set x = New Foo or Set x = other assign object references; plain x = y assigns the default member’s value (Let, optional). Nothing clears a reference, and If x Is Nothing tests it. Dim x As New Foo creates the object on first use.
• Classes have no inheritance; they implement interfaces with Implements IFoo (then every member of the interface is written as IFoo_Member). Class_Initialize and Class_Terminate are the constructor and destructor.
• Events: Public Event Name(args) declares one, RaiseEvent Name(args) raises it, and a WithEvents variable receives it in a procedure named variable_Name; the form and control events (Form_Load, Command1_Click) work the same way.
• Declare: Declare Function Name Lib "library" Alias "entry" (args) As Type imports a native function; with PtrSafe and LongPtr (the VBA7 compilation constant, Office 2010 and later) it is also valid in 64-bit Office, and the compilation constants Win64, Win32 and Mac select code by platform in #If blocks.

Statements

Sub Demo(path As String)
    Dim n As Long, f As Integer, line As String
    On Error GoTo Handler
    f = FreeFile
    Open path For Input As #f
    Do While Not EOF(f)
        Line Input #f, line
        n = n + 1
        Debug.Print n; line
    Loop
    Close #f
    Select Case n
        Case 0: MsgBox "empty"
        Case 1 To 9: MsgBox "short"
        Case Else: MsgBox "long"
    End Select
    With ActiveSheet.Range("A1")
        .Value = n
    End With
    Exit Sub
Handler:
    MsgBox "Error " & Err.Number & ": " & Err.Description
    Resume Next
End Sub

The operators are ^ * / \ Mod + - &, the comparisons = <> < > <= >= Like Is and the logical operators Not And Or Xor Eqv Imp (bitwise on numbers; there is no short-circuit AndAlso). The library is the VBA library (VBA.Strings, VBA.Math, VBA.DateTime, VBA.Interaction, VBA.FileSystem, VBA.Conversion) listed on the standard library page, with host objects (Application, ActiveSheet) and the Debug object (Debug.Print, Debug.Assert).

Against Visual Basic .NET

Not described

Known, not yet covered

• Reference: the Open Specifications document [MS-VBAL] (the specification of the VBA language) and the Visual Basic 6 language reference could not be fetched in this pass: the published addresses of the specification returned errors from this machine and the VB6 documentation is not in a public repository. This page is written from Microsoft’s VBA language reference (the Markdown sources of MicrosoftDocs/VBA-Docs, read for the data types, keywords, statements and functions), from the real VBA and VB6 files listed on the overview and from knowledge of the languages. No example here was run (no VBA or VB6 host was available).
• Reference: the formal grammar and the lexical details (the exact rules for line labels, type characters on numbers, Rem after a colon, any limit on the number of continuations, date literals), the Variant conversion rules, the VB6-only features (control arrays, Declare aliases by ordinal, Optional without a default for non-Variants, ActiveX and the App, Screen and Printer objects) and the VBA host object models are not described.
• Viewer: the file statements (Open, Print, Input, Line …) are coloured as keywords only at the start of a statement; a procedure called Print with a bracket, or a variable called Name that is assigned to, is not coloured as one.

See also

• VB6 forms and projects – the form header, .frm and .vbp files
• VBScript – the scripting subset
• Versions and history