The first declaration of an identifier, including implicit declarations before C99, must specify by
the presence or absence of the keyword `static` whether the identifier has internal or external
linkage. This requirement allows for one-pass compilation in an implementation which must
treat internal linkage items differently from external linkage items. An example of such an
implementation is one which produces intermediate assembler code, and which therefore must
construct names for internal linkage items to circumvent identifier length and/or case restrictions
in the target assembler.

Pre-C89 practice in this area was inconsistent. Some implementations avoided the renaming
problem simply by restricting internal linkage names by the same rules as the ones used for
external linkage. Others have disallowed a static declaration followed later by a defining
instance, even though such constructs are necessary to declare mutually-recursive static
functions. The requirements adopted in C89 called for changes in some existing programs, but
allowed for maximum flexibility.

The definition model to be used for objects with external linkage was a major C89
standardization issue. The basic problem was to decide which declarations of an object define
storage for the object, and which merely reference an existing object. A related problem was
whether multiple definitions of storage are allowed, or only one is acceptable. Pre-C89
implementations exhibit at least four different models, listed here in order of increasing
restrictiveness:

*Common* Every object declaration with external linkage, regardless of whether the keyword
`extern` appears in the declaration, creates a definition of storage. When all of the modules are
combined together, each definition with the same name is located at the same address in
memory. (The name is derived from /common storage/ in Fortran.) This model was the intent of
the original designer of C, Dennis Ritchie.

*Relaxed Ref/Def* The appearance of the keyword `extern` in a declaration, regardless of
whether it is used inside or outside of the scope of a function, indicates a pure reference (ref),
which does not define storage. Somewhere in all of the translation units, at least one definition
(def) of the object must exist. An external definition is indicated by an object declaration in file
scope containing no storage class indication. A reference without a corresponding definition is
an error. Some implementations also will not generate a reference for items which are declared
with the `extern` keyword but are never used in the code. The UNIX operating system C
compiler and linker implement this model, which is recognized as a /common extension/ to the C
language (see §J.5.11). UNIX C programs which take advantage of this model are standard
conforming in their environment, but are not maximally portable (not strictly conforming).

*Strict Ref/Def* This is the same as the relaxed ref/def model, save that only one definition is
allowed. Again, some implementations may decide not to put out references to items that are not
used. This is the model specified in K&R.

*Initialization* This model requires an explicit initialization to define storage. All other
declarations are references.

The Standard model is a combination of features of the strict ref/def model and the initialization
model. As in the strict ref/def model, only a single translation unit contains the definition of a
given object because many environments cannot effectively or efficiently support the
“distributed definition” inherent in the common or relaxed ref/def approaches. However, either
an initialization, or an appropriate declaration without storage class specifier (see §6.9), serves as
the external definition. This composite approach was chosen to accommodate as wide a range of
environments and existing implementations as possible.