Storage Classes

Visibility and lifetime of variables, objects and arrays

A variable, object or array's storage class determines when and where 
memory is allocated for it and when that memory is destroyed. There are 2 
storage classes in FreeBASIC: automatic and static.

Automatic

   Automatic variable, object and array lifetimes begin at the point of 
   declaration and end when leaving the scope they are declared in.

   Automatic entities are guaranteed to have unique storage for each 
   instance of the block in which they are declared. For example, the 
   automatic variables declared within a procedure will be allocated at 
   different addresses and have unique state (value) for each call to the 
   procedure.

   Automatic variables, objects and arrays are defined using the Dim, ReDim 
   and Var keywords without the Shared specifier.

   The memory for automatic variables, objects and arrays is allocated on 
   the program stack.

   Automatic variables, objects and arrays have no linkage.

Static

   Static variable, object and array lifetimes begin at program creation 
   and end with program termination.

   Static entities are guaranteed to have the same storage for each 
   instance of the block in which they are declared. For example, the 
   static variables declared within a procedure will be allocated at the 
   same address, and retain their state (value) across each call to the 
   procedure.

   Static variables, objects and arrays are declared using the Static 
   keyword. Entities declared using the Shared specifier are implicitly 
   static. All entities declared within a procedure that is declared using 
   the Static specifier are also implicitly static.

   The memory for static variables, objects and arrays is allocated in the 
   .BSS section of the executable, or in the .DATA section if they are 
   initialized when defined. Static variable-length arrays must be declared 
   empty, with an empty subscript range list; their element data is still 
   allocated in the free store (when they are resized), but the internal 
   array data is allocated in the .DATA section of the executable to allow 
   the element data to persist throughout program execution.

   Static variables, objects and arrays have internal linkage by default, 
   unless previously declared using the Extern or Common keywords.

Platform Differences
   *  In DOS and Windows platforms, the size of the program stack can be 
     adjusted at compile-time using the -t command-line switch. In Linux 
     platforms, the size of the program stack can be adjusted at load-time 
     by modifying /etc/security/limits.conf, or on a per-thread basis using 
     the shell builtin ulimit.

Differences from QB
   * QuickBASIC allows static entities to be declared within procedures 
     and DEF FN routines only.

See also
   * Extern, Common
   * Dim, ReDim, Var, Shared, Byref (Variables)
   * Static
   * Linkage

