/EXTERN=COMMON_BLOCK treats globals like FORTRAN COMMON-blocks. This
is how it was in the old VAX C. It is actually a genious way of doing
things, but not the way it is done on Unix and PC systems.

/EXTERN=STRICT_REFDEF treats globals like Unix and PC systems.
The variable is defined in one C/OBJ-file and referenced
in the rest of the C/OBJ-files.

/EXTERN=RELAXED_REFDEF is a Digital variation, which basicly is
like /EXTERN=STRICT_REFDEF but works with multiple definitions
of the same symbol (this makes it easier to compile old VAX C
code).

Implementation:

                  defining module            referencing module

C code            int i;                     extern int i;
                  i = 0;                     i = 0;


common               .psect i,OVR               .psect i,OVR  
                $i:  .blkl  1              $i:  .blkl  1      
                     movl   #0,$i               movl   #0,$i  

refdef               .psect $LOCAL,NOOVR        movl,#0,i
                i::  .blkl  1
                     movl   #0,i

(pseudo assembler code similar to Macro-32)

Consequences for coding:

                                          x*global  x*extern  1*global+(x-1)*extern
                                                                 = standard
VAX C & DEC C with /EXTERN=COMMON_BLOCK      OK        OK            OK
DEC C with /EXTERN=RELAXED_REFDEF            OK        not           OK
DEC C with /EXTERN=STRICT_REFDEF             not       not           OK

See DECC1.ZIP for examples (Z = x*global, ZZ = x*extern,
ZZZ = 1*global+(x-1)*extern).

VAX C and DEC C with /EXTERN=COMMON_BLOCK has a problem with
initializing of global variables when using object-libraries
similar to that of FORTRAN. That is worked around f.ex. by
calling a dummy function in the relevant module.

See DECC2.ZIP for examples:

Z      = Fortran with block-data (problem)
ZZ     = Fortran with called subroutine (works)
ZM     = Fortran with referenced block-data (works)
ZZM    = Fortran with referenced subroutine (works)
ZZZ    = C without function (problem)
ZZZZ   = C with called function (works)
ZZZZZ  = C with referenced function (works)

Actually I think the referencing method used in ZZZZZ is
prettier than the calling method used in ZZZZ.