Information: VB64: Alum6 T4 IDE Portal -- General Enhancements & Added Syntax
VB64(Alum6 T4 IDE)
General Enhancements & Added Syntax
Comments / Forum

with permission from BadAssTechnologies Deviant Art

General Enhancements & Added Syntax

Draft: Items in italics are considered long-term goals...

General Enhancements (Draft):

Regarding areas where the original VB6 IDE should be compared, or became deficient due to incompatibility with operating systems advancement or etc...

These are "to follow" and not necessarily in the first release

  • Auto Recovery of open files if IDE freezes

  • Auto inserts string Type character ("$") to String functions for increase in speed (eg: Left$() prevents VB6 converting to a variant as in the case of Left() thern back to a string). Feature is optional or can be forced to variant by (eg) Left~() .

  • Allows Help and Object Browser node annotations.

  • Colorized code export (RTF)

  • Numerous improvements to selection and search during edit.

  • Search / Replace also effects find / change within Form / Control names and tags.

  • Automatic rename of variables -- Editing a variable name automatically renames all variables within scope (ie: if it's a "public" variable, all global references to that variable name will be renamed after a prompt to confirm your action. Conflicts are checked to avoid clashes).

  • Global Search is on by default

  • Auto code beautification (auto capitalise etc, as before, when you leave the line or press escape)

  • Copies beautified code (instead of as raw text) by default in RTF for insertion in documentation

  • Auto bracket identify

  • By default, Remarks in Arial, Code in Lucida Console.

  • Esc key to close warnings messages (rather than having to find and click "OK" or press Alt+F4)

  • Warning of type over

  • "Don't show this message again" for Design Time errors -- instead just goes straight to the fault line with the message in the Report pane.

  • Rename all instances of a variable at once without using search and replace (whole word replace, detects and prevents conflicts)

  • VB6: automatically inserts "()" after refereces to Property Get or Property Let statments but warns against using () in Property Get (which causes the statement to fail an unexpected ways).

  • When Compiling for Release:

  • Auto collates local modules and files (in project folder), takes a snapshot for issue control, stores in .\stages\ folder

  • Include shared modules (in other folders with other projects) and takes a snapshot when compiling for issue control

  • Comment based bookmark feature with indexing

  • User definable size of Text Cursor

  • Easy Access "Live" Variable watch

  • Odd VB6 behaviour is checked and warned about. Eg:

  • Auto Bookmarks.. Remembers where you last were in a subroutine/function

  • Shows "Dirty" (unsaved) modules and forms.

  • Easier access to compile variables

  • Improved indication of source file location for better management of shared resources.

  • Colors local and global variables differently for easy identification.

  • Multiscreen support.

  • Clicking within a line that is wider than the editor pane ensures all of it's contents and any comment are visible without having to scroll the window horizontally.

  • Drag Drop project Open

  • "?" Auto types "Debug.Print" rather than just "Print". (still supports "Debug.?").

  • Exit Sub and Exit Function are trapped and brought out to a label (eg: i___Exit:) to prevent common errors associated with exiting a procedure without cleaning up variables, error traps, or resetting re-entrance flags. (Similar to assembly Function Epilogue*1).

  • For potential forward compatibility with Java scripting, Java keywords system reserved and cannot be used as variable or sub-variable names (eg: .substr, .split(), .join(), .replace(), .getHours()(etc), .charAt(), .length, etc). These will eventually be incorporated into T4 as Syntax alternatives.

  • Surrounding commented words in asterisks causes them to be bolded. Eg: 'my *important* Comment.

  • Comment Block improvrment: By option, commenting out multiple code lines puts the apostrophe on the left of the indented line instead of hard left.

  • Auto End-Brace naming: In the event of long nested conditionals, it is hard to know what the "End If" refers to. This auto-inserts a comment with a summary of the structure.

  • CallStack trace on trace offers enhanced view or variable values as passed in.

  • Optionally Saves a Checksum and Last Save date in plain text within files.

  • Code Pane Lock -- code panes can be manually locked all become locked automatically if not edited for a while. Attempting to edit while locked brings up a simple message box asking if you wanted to unlock the pane. Useful to prevent accidental editing. A locked Pane shows a grey background.

  • Support For Dragon NaturallySpeaking Dictation Software.

  • Debug.Print statements optionally show the originating module/line number they emanate from allowing the source of the print statement to be located.

  • Gosub statements are formally checked to comply with nested procedures , inheriting the parent procedure's local variables but with strict return sequence checking.

  • Option to check Type Mixing when appending strings. Eg: Print "Number " & Counter can be misleading and Print "Number " + Counter can cause an error if Counter is a variant of type Integer but text was expected. Eg: Print "Number " + Cstr(Counter) is preferred.

  • Code Map enhancements with Filter function to show key procedures with comments .

Added Syntax compared to VB6 (Draft):

Where the VB6 compiler is selected, Added Syntax is either available by distributing an additional OCX or through automatically added code.

  • Dim Foo& = 1, Bar$ = Space$(20), etc = declare variables with a default value. Same with Static, Public etc.

  • Dim$, Dim&, Dim!, etc = declare all variables on line as strings, longs, floats, etc. Same with Static$, Public& etc.

  • Foo++ -> Increment (same as Inc Foo)

  • Foo-- -> Decrement(same as Dec Foo)

  • GetIni() & SetIni() -> procedures to get and set and initialisation variables outside of the registry in an INI or DAT file.

  • WaitS(**!) -> Wait Seconds with 1 mS resolution

  • Apd() -> Appends one string to another very rapidly. (In VB6, this becomes very slow once the primary string has extended beyond approximately 60 kB -- when the primary string reaches approximately 1 MB, this increases speed approximately tenfold, 10 MB strings reach approximately 100 fold speed increases). Vital when, for example, one is constructing an HTML return.

  • InstrQ() -> variations on In String scan commands that do not return 0 if unfound but return a pointer just past the end of the string.

  • This.** -> Like Java, this is a convenient reference to the object owning the event.


  • |...| -> Inline Comments. Eg: Dim Foo&|Counter|, Bar$|Content|, etc.

  • If such a bracketed comment is used in a declaration, the comment appears when hovering over the variable in use elsewhere.

  • // -> identifies as a comment as does an apostrophe. This is mainly for compatibility with other languages, but brackets comments in the same way as quote brackets text.

  • //-->

  • These are encoded at the end of the line comments in text/code files for backward compatibility with VB6.

  • /*...*/ is in the roadmap to be supported as within C.

  • //comment[..]etc -> renders color mark up of code in between brackets within a comment. Useful for showing code points in comments

  • AZ$=<*...*> -> RTF (Rich text format) string with any formatted content, including multiple line content, in between. Egs:

  • AZ$=<*

  • This is formatted and colored text.

  • *>

  • Can be on a single line or, if followed by nothing else as shown in the example above, can be multi-line. Most RTF markup is accepted including indents, fonts. Please note: this feature is VB6 backward compatible by being translated to strings containing RTF code.

  • Procedure parameter overloading

  • && -> Logical And (Use "And" for bitwise as belore).

  • || -> Logical Or (Use "Or" for bitwise as belore).

  • ErIg -> Error Ignore. Use this before a line that requires a simple single line error trap independent of global error management. Useful for trapping errors during design time that cannot be avoided, such as network errors. Global error management reasons after the line that the instruction appears in. The Err number is past it in the global value ErIC (which replaces the usual Err because this is zeroed after error trap changes).

  • Break -> Jump out of nearest curly bracketed code container ("{}" is in the roadmap to be used to wrap code similar to Java)

  • Call ProcNamedInString$ -> Similar to call procedure by name but acts on procedures within modules with fast hashing look up.

  • MyBasModuleOrForm.Procedures -> returns a collection of public procedures at runtime.

  • Return * -> supported in the same way as is seen in Java.

  • App.Cls -> clears immediate pane.

  • Debug.Print CallStack() -> Shows call stack in the debug window pane. Not available in the finished executable.

  • Debug.StopIf *condition* -> Like Assert but stopped if condition is True, not if False.

  • An asterisk in an array pointer automatically sets a loop that applies to all elements. Eg: Set CoolBar2(*).Picture = ThemePic.Picture .

  • *.Name -> Returns the name of a variable dynamically. Useful for Enums and in particular.

  • LookUp(DataObject, TxtIndex$) -> Simplified implementation of VB's Dictionary Object. Also implements WriteUp(DataObject, TxtIndex$, Content$) to add items and features LookSet() and LookGet() to save / load from an ini file structure.

  • Type Abbreviations..

  • "As Boolean"R_E_F can be abbreviated to "ƒ", alt+159.

  • "Optional" can be abbreviated by surrounding variable name with "[]".

  • "As Variant" can be abbreviated to "~" .

  • String Definitions. As a rule, VB6 ensures that a string is a binary object. This is usually useful. However, Alum draws from other coding standard and allows string literal (constant) variations. For example..

  • A$ = "\x41¶" ... Normal, (¶ = ascii 20). "\x41¶" is literally in the string.

  • A$ = \"\x41¶" ... The preceding "\" forces use of C like escape sequences, so "A¶" is in the string.

  • A$ = ¶"\x41¶" ... The preceding "¶" forces use of Alum escape sequences like, so the string is "\x41" + VbCrLf. Nb: "¶" can be redefined as VbCr for non Microsoft systems.

  • A$ = º"Your name is ºUserNameºº¶º" ... The preceding "º" forces use of Alum substituions. So if a variable UserName currently has the string "Rob" in it, the resulting string is "Your name is Rob" + VbCrLf. This is mainly to make code more readable.

  • Substitute() -> same as VB6's Replace() but can do multiple replacements. Eg: Substitute(Node.Tag, "¶", vbCrLf, "i=", "") is same as Replace(Replace(Node.Tag, "¶", vbCrLf), "i=", "").

  • MidFrom() -> Used to return from (but not including) Start char(s), ie: a=Mid(strg,Start,[Leng],[Strt]). If Start Chars is/are unfound, returns blank.

  • MidUnto() -> Used to return text up to (but not including) Stop char(s), ie: a=Mid(strg,Stop,[Leng],[Strt]). If Stop Chars is/are unfound, returns ALL from Strt.

  • ™MidUnto() -> The prior (%0153 = ™), eg: ™MidUnto(), forces small derived functions to be embedded as Tight Macros -- This can increase speed.

  • UBoundSafe() -- Returns the upper bound of an array safely if it has not yet been dimensioned as -1. Eg: [ReDim Preserve MyArray(UBoundSafe(MyArray) + 1 ] will work as expected to expand an array even if the array has not yet been dimensioned. Does not work with UDT arrays.

  • Dim MyArray(Seed(0)) --> Seeds MyArray() with Redim MyArray(0) and effectively seeds an empty Base 1 array (if the 0th element is regarded as reserved). This makes it a lot easier to code with dynamic arrays without having to check everywhere encounterred that it is already seeded (eg: with above UBoundSafe()). Seed(*) is thus a reserved system word in Alum6 and * can be any value within scope. .

  • Derivitives and Road Map: Dim MyArray(Seed(-1)) --> Seeds MyArray() with Redim MyArray(-1 To -1) and effectively seeds an empty Base 0 array with Ubound() returning -1 if "empty". Thereafter, where Redim Preserve is used, the lower bound is always remembered -- eg: Redim Preserve MyArray(5) is always corrected to Redim Preserve is used, MyArray(-1 To 9). The reserved word Seed(*) can have any fixed value within scope for *.

  • Supports nested procedures, inheriting the parent procedure's local variables. In VB6 translations, this is done by Gosub with strict return sequence checking.

  • InstrGroup() & InstrRevGroup(): Implements alike: C's strpbrk() .. locate first occurrence in string of any char from another string; and latter combines with strrchr() ... Locate Last Occurrence of a char.

  • SearchWithin() -> End User Search version of Instr() that supports Whole Word / Asterisks and Word Negation (specify "not including" by inserting a hyphen). Designed for use on line by line basis. Faster and easier to use than VB6's Like keyword.


Please note -- Any inventions and innovations initiated by QSL are hereby released herein as "prior art" under the principles of Defensive Publication( &(*)).

Resolved Issues Compared to VB6 IDE:

Regarding areas where the original VB6 IDE should be compared, or became deficient due to incompatibility with operating systems advancement or etc...

  • The T4 IDE has been designed to be Stable and in some tests outperforms the original IDE for crash-resistance because it no longer shares memory with the compiler.

  • T4 has been extensively tested on Windows XP through to Windows 10 operating systems in order to be easy to install where testing and coding needs to be carried out on the target computer.

  • Keep in mind that VB6 itself needs to also be installed if that is your preferred compiler, but note that in our tests, VB6 installs from its original disk sufficiently well for use with T4 and without the need for the second MSDN CD.

  • Also keep in mind that for simpler applications, the VB5CCE Control Creator Edition can be easily and extremely quickly installed on systems up to and including Windows 10. Please see ''Using VB5cce as a partial compiler'' on this subject.

  • Multiple instances of IDE do not cause crash

  • Mouse scroll resolved

  • Re-mappable key press definitions

  • Escape key to close most forms and dialogues

  • Escape key will exit the Runtime Error box (or optionally, you can choose no message box on run time error, and simply have execution halt and open at the defective line).

  • Better bookmarks

  • Support for multiple computer screens

  • Checks (optionally) "Redim" arrays were defined/declared (without which VB6 was capable of missing a typo or being unaware that the the original array was declared as a private member of another module, upon which Redim would create a new array -- effectively skirting the Option Explicit mandate).

  • Checks (optionally) against declaring a local variable named the same as a global variable (can be very confusing and difficult to debug).

  • Enum Auto complete (Intellisense) optionally presented either in the Order They Were Entered in the Enum, or in alphabetical order (default).

  • Pressing Shift+F2 takes you to the relevant item in an Enum, not just to the top of it.

  • Pressing Shift+F2 takes you to the relevant item in a line of constants or a line of declares when items are appended $, &, etc (the VB6 IDE used to just go to the left of the line).

  • A large cursor carat can be set in options.

  • .

  • Find & Replace is improved .

  • Eg: To search for all of a forms property references, by example a single search will identify Me.Visible, FormName.Visible, or just Visible.

  • Searches are always global by default so you don't have to set to global every time, OR you are warned that when no further items are found you are in local search mode.

  • You no longer irreversibly lose what you just typed in the Replace field if you accidentally press Up or Down keys.

  • Shift+Delete raises a warning and suggests you use Ctrl+X instead. This is to get more mature users out over the habit of using the older clipboard shortcut which Microsoft rather tragically later used to permanently (Ie: irreversibly) delete a file in their file explorer. (How many of us learned not to do that the hard way?).

  • Dynamically resizeable code pane text (without having to change font size).

  • Indicates if a module or form is shared (assumes shared if not in the same folder). Reduces unintentional editing of shared resources.

  • Ctrl+Y does redo/repeat in accordance with modern editors.

  • Help does not "vanish" (go behind) when selecting links.

  • Quick Watch can be used to view larger values (possible to scroll).

  • Hovering over variables to see information and values where applicable is more reliable.

Differences to VB6 IDE & Syntax:

Regarding areas where the original VB6 IDE should be compared...

For those further considering Alum6 T4 as a general purpose IDE and coding solution, this section is not relevant. However, for those looking to modernise their approach to the VB6 IDE, the following differences might be notable when considering whether or not this IDE is you.

As this is a highly modernised IDE front end, it of course contains a lot of differences to the VB6 IDE but the following list of differences deal with those changes that are fundamentally different..

  • Both the Components Explorer and Object Browser are combined into the Objects Browser.

  • Instead of a Components Sidebar, you use the new Objects Browser to view loaded components and references as well as loading or removing new references.

  • Programmed Objects (uncompiled BAS modules etc) are no longer listed in the Object Browser but instead in the Code Map Sidebar.

  • Drop down Procedure "Combo" lists at top of Code Pane replaced by Code Map in Sidebar.

  • End => EndApp (End 'App in VB6) making application termination points easier to find.

  • For compilers other than VB6, resource files are handled differently with code re-routed to deposit and extract data and images from a zip file that is optionally shipped with the executable and maintained by T4. (Subject to review. Still capable of using the old resource files but T4 does not support adding to them). Extensions include zip, jar, z, dat, cab but all are windows compatible zip files.

  • Uses Inno Setup for packaging distributables.

  • VBW files can be associated with the T4 executable as an easy way of openning adjacent VPB or MAK files without having to change extrension associations.

  • Certain unusual characters are now reserved characters and cannot be used in variable names. Eg: ¶, §, ƒ, º, •, ®, ©, ™, etc. It may be noted that %173 and %175, « and », will likely be permitted as a valid variable name character to indicate a variable is an input or output. In general, variable name characters should not exceed the normal ascii numeric range with the exception of "_".

  • Ctrl+Y no longer cuts a line to clipboard, but conforming with modern editors, does a "redo".

Form Designer Enhancements (Draft):

Regarding areas where the original VB6 IDE should be compared, or became deficient due to incompatibility with operating systems advancement or etc...

  • Support for auto resizing of child objects and memorizing last position.

  • Overall selection resolved.

  • Picturebox and other items normally not labelled in design mode are labelled.

  • Right click reveals a menu that allows jump to events. Right mouse does not disturb placement in the same way double click was inclined to do with the original form designer.

  • There is a "find" feature for finding items that have been overlaid by other items.

  • Improved Grid Tools are available to align items.

  • Drag drop images and icons into image controls etc.

  • Double clicking a control cannot accidentally move it.

  • Right-Click, "View Code" no longer takes you somewhere arbitrary, but takes you to applicable event code.

Menu Editor becomes Menu Builder (Draft):

Alum Menu Builder..

Regarding areas where the original VB6 IDE should be compared, or became deficient due to incompatibility with operating systems advancement or etc...

  • Alum Menu Builder is far easier to navigate than VB6's menu editor

  • Simple icon placement on menu items.

  • 1000 "Silk" Icons provided with Easy Icon Picker (Attribution Required).

  • Unique "-" seperator underlying menu names auto-generated/assigned.

  • Drag and Drop entire branches.

  • Undo

  • Auto commenting includes caption and menu position in event procedure.

  • If using Alum syntax (backward compatible with VB6 but uses dynamic menus), provides support for runtime customizable menus.

  • VB64 VBS IDE only supports 1st (horizontal) and 2nd (vertical) level menus -- it does not support 3rd or lower level menus except to indent them within the 2nd level.


All specifications and descriptions subject to change.

Next Topics:

TransCompile language Roadmap

Powered by 'Piped'
  Copyright, Privacy & Data Protection Policy, Disclaimer       Terms & Conditions of Sale       Contact Us       Help & About