Auto vs Global

[larrybtoys]

How important is it to change all of the AUTO commands at the beginning of a program to GLOBAL when doing a final compile? I like using AUTO while developing a new program but sometimes forget to change them to GLOBAL at the end. Does this matter or does the compiler automatically do it for me during the compile? TIA

[Roger Cabo]

From what I now, there is no difference between Auto and Global for TYPE of a variable.

But Auto doesn't refine the variable type if it has already.
Once you have used:

Auto a As Double
a = 18
____________________________________________________

But then you like to change a to
a = "uio"

Auto will not change your variable type automatically to String or variant on the next F5 or F5+SHIFT.

____________________________________________________

And string can't be defined while

Auto
a = "slfkö"

But with:

Auto a$
a$ = "slfkö"

I use Auto only when I'm to lazy while generate quick code to test anything.
But if you postfix any variable like: a$,b%,c|,d#, auto knows what to do.

And I never had any issues with Auto in a compiled exe.

[(X)]

For the benefit of those that have not yet installed GFA-BASIC 32 for Windows.  Here is an exerpt from the Help Document.

Auto Command

Purpose
Automatic collection and declaration of undeclared variables as global variables

Syntax
Auto

Description
While Auto was implemented to allow the conversion of GFABASIC16 source code (LST) files which do not contain explicit variable declarations (which are required in GFABASIC32) - this is its intended use - it can also be used to audit variable usage within a program where, after changes have been made, variables that are declared either as local or global may no longer be used (see Remarks).

Auto is designed to be placed at the top of a program listing: when the compiler encounters the command, it performs an additional sweep of the following code to detect any undeclared variables, which it adds to the line containing the Auto command. Note: On each compile, whether using Shift-F5 (test compile) or F5 by itself (Run), any text (including comments) after the Auto command will be deleted in preparation for the list of undeclared variables.

Once the list of undeclared variables have been discovered, the Auto command should be replaced with either Global, Dim or Local, whichever is pertinent; otherwise, the compiler will perform the additional sweep every time the program is run and refresh the variable list on each occasion.

Before using the Auto command, it must be understood that it is very simple in its operation and has many limitations - it was, after all, purely designed to update GFABASIC16 listings, which did not have complex data variable types. Hence:

Auto is only designed to search for and return variables with the following postfixes or suffixes: a?, a|, a&, a%, a!, a#, and a$ (not the @ Currency postfix).
Any variable without a postfix, or a Currency variable with the @ postfix, is assumed to be a Double (this was the default in GFABASIC16) - in the case of a Currency variable with the @ postfix, this produces a syntax error; in the case of such a variable to which a String, Variant, UDT or Object has been assigned, similar errors will also be raised
Variables that are followed with a parenthesis are generated as an array without elements (e.g. x&()) - thus, these will need to be properly declared before the program can be run.
In 16 Bit GFA-BASIC, the same variable name could be used as variables and arrays (a% and a%()); this is not allowed in GFABASIC32 and will cause a syntax error.

Example

Auto
a% = 1
a$(0) = 1
b = 33.5

---> becomes after Shift+F5 --->

Auto a$(), a%, b As Double
a% = 1
a$(0) = 1
b = 33.5

Note that the a$() array is undefined and will result in an 'Array Bounds Exceeded' error.

Remarks
As mentioned above, a second use of Auto is auditing variable usage within a program where, after changes, certain variables may no longer be necessary. This will only work properly for those variables that the command recognises and it will not correctly recognise types which have been declared using As rather than by use of a postfix. However, despite thise limitations, it can still be a very useful auditing tool.

In the example below, the sub routine has been optimised and much of the old code has been removed meaning that certain variables are no longer used:

Function Test(f%)
  Local a$, c%, e As Boolean
  e = (f% < 200)
  Return Iif(e, "True", "False")
EndFunction

To audit the variable in the function, you comment the Local declaration line and insert Auto below, then press Shift+F5, which gives you the following listing:

Function Test(f%)
  °Local a$, c%, e As Boolean
  Auto e As Double
  e = (f% < 200)
  Return Iif(e, "True", "False")
EndFunction

As can be seen, Auto has found only the e variable as the a$ and c% variables are no longer needed - it should also be noted that it has erroneously labelled it as a Double, which does not matter as this can be easily corrected. Hence, to complete the audit, all that is necessary is to change Auto to Local and Double to Boolean and you have the fully optimised routine as shown below:

Function Test(f%)
  Local e As Boolean
  e = (f% < 200)
  Return Iif(e, "True", "False")
EndFunction

This may seem unnecessary for the short function above, but, in long, complex procedures with many variables, this is a far quicker and easier way to optimise variable declaration than to do it manually.

See Also
Sub, Procedure, Function, Global, Dim

{Created by Sjouke Hamstra; Last updated: 25/01/2023 by James Gaite; Other Contributors: Jean-Marie Melanson}

[larrybtoys]

Are you saying that a compiled program will run faster when the variables have been specifically declared using GLOBAL etc. rather than using Auto? Or just in the NON-Compiled versions?

[dragonjim]

Only when compiled within the IDE. When the listing is compiled to executable, the Auto is replaced with Global or Dim so there should be no loss of performance.