Variable and Procedure Linkage
Name visibility within and between modules
Linkage refers to the visibility of the name of a variable, object or procedure between one or more modules of a program. In other words, a linkage dictates how a name is shared between modules. There are two main types of linkage a name can have: internal and external.
Internal linkage
Names with internal linkage only refer to variables, objects or procedures defined within their own module; they are not outwardly visible to other modules. This means that two or more modules can refer to different things using the same name. Note that linkage only refers to visibility of a name, and depending on storage class and lifetime, a variable, object or procedure with internal linkage may be shared between modules using its address.
Module-scope declarations
Variable and object names declared at module-scope have internal linkage unless otherwise declared with `Extern` or `Common`. For example, variable names first introduced with `Dim` or `Static` have internal linkage, and those variables can only be referred to by name within the module in which they are defined. Note that using `Shared` only allows name visibility within the module's procedures, and does not contribute to the name's linkage.
Procedure names declared with `Private` have internal linkage.
Local-scope declarations
All variable and object names declared at local-scope (in a `Do` loop, or procedure body, for instance) have internal linkage.
External linkage
Names with external linkage may refer to variables, objects or procedures defined within their module or in another module. Having external linkage means that a name is outwardly visible to other modules, and all modules that use that same external name all refer to the same variable, object or procedure. Thus, only one module may define an external name (the compiler will complain about a duplicated definition if it finds an additional definition of a name with external linkage).
Module-scope declarations
Variable and object names declared at module-scope are declared to have external linkage with `Extern` or `Common`.
`Extern` declares the variable having external linkage, but does not define it. This external declaration must come before any definition of the same name (a declaration without `Extern` specifies internal linkage, and currently, any further external declarations of that name signify a duplicated definition). Variable and object names with external linkage declared using `Extern` are always in the shared scope, and so can be referred to within procedure bodies.
`Common` declares the variable having external linkage as well as defining the variable. But, it is different from `Extern` in that the `Common` definition of the variable may appear in more than one module. When used with arrays, only variable-length arrays without subscripts may be declared, and the array must be sized at run-time using `Dim` or `ReDim` before it can be used. Variable and object names with external linkage declared using `Common` are only in the shared scope if the `Shared` scope specifier is also given. Shared variables can be referred to within procedure bodies.
When both `Extern` and `Common` are both used to declare and define a variable, the effect is that the meaning of `Common` statement is altered to behave as though it were a `Dim` declaration. So it is generally, not recommended to mix `Extern` and `Common` on the same variable in the same module. However, variables may be declared and defined with `Common` in one module and then referenced with `Extern` in another module without confusion.
Procedure names are declared to have external linkage by default. Declarations using `Public` explicitly specify external linkage.
Local-scope declarations
Currently, names declared at local-scope cannot have external linkage.