Note: this article only applies to conversions to VB.NET.

One of our customers came up with the following question:

I have some code in my project that was developed by a person used to Fortran naming conventions. In his code, variables starting with letters I to N are meant to be integers while others are Double. Ideally, there would be a pragma such that we can indicate that undeclared variables starting with letters I to N are to be declared as integer while other undeclared variables should be declared double. Is this possible?

The short answer to this question is that the original developer could have used the DefInt and DefDbl VB6 directives to force the type of all undeclared variables. Adding these directives just before migration wasn’t an option, however, because they might introduce subtle bugs if the developer failed to adhere to the naming rule in some cases. Also, the approach based on Defxxx directive can’t be applied if the naming convention is based on multiple-character prefixes, as such “int” for integers and “dbl” for Double.

Even though VB Migration Partner doesn’t provide a pragma that perform the requested task, what our customer asked for is quite in reach for our super-flexible software. In fact, if you use the DeclareImplicitVariables pragma, then all variables that weren’t explicitly declared are rendered as “Object” variables and are prefixed with 05B1 warning “The xxx variable wasn’t declared explicitly”. Thanks to this detail, using a PostProcess pragma to replace the variable type isn’t hard at all:

'## PostProcess "(?<=05B1\): The '(?[I-N].*?)'.+\r?\n\t+Dim )\k As Object( = 
Nothing)?", "${name} As Short", True, False, ""

'## PostProcess "(?<=05B1\): The '(?[A-Z-[I-N]].*?)'.+\r?\n\t+Dim )\k As 
Object( = Nothing)?", "${name} As Double", True, False, ""