                                  Scoping and Linkage

    JIT Compile Mode makes use of the current task's hash sym table and its parent
    tasks' tables.  It fetches syms from parent tasks' tables if not found locally
    in the current task's table and it places new syms in the current task's table.
    Conceptually, syms are at the scope of environment vars in other operating
    systems.

    When a sym is placed into a table, older syms with ident names will be
    overshadowed if they exist.  Duplicates are not allowed in many cases,
    especially in asm blks.  Dupicates are allowed, by design in other cases, so
    that you can repeatedly #include the same file from the cmd line while
    developing it.  Or, so you can repeatedly declare a function with a standard
    name, like DrawIt().  This case might occur when the Adam Task is starting-up
    loading-in many little utilities.

    extern binds a new HTT_FUN or HTT_GLBL_VAR sym to an existing sym of the same
    name if it exists in the sym table (just in just-in-time code).  It also can be
    used to generate a fwd reference.

    import binds a new HTT_FUN or HTT_GLBL_VAR sym to a sym of the same name
    imported from the task's sym table at Load() time.  If no sym exists to bind to
    at Load() time, the code using this sym will be left incomplete until the sym is
    defined.

    _extern binds a new HTT_FUN or HTT_GLBL_VAR sym to an existing sym, of a differe
    nt name.  It must exists in the sym table.  Basically, this binds C to asm.

    _import binds a new HTT_FUN or HTT_GLBL_VAR sym to a sym, of a different name
    imported from the task's sym table at Load() time.  If no sym exists to bind to
    at Load() time, the code using this sym will be left incomplete until the sym is
    defined.  Basically, this binds C to asm from elsewhere.

    Ahead of Time Compilation
                        GlobalScope/FunctionScope
                        | CodeHeap/DataHeap/Stack/Register
                        | | TaskHashEntry:ExportSysSym/Define/Function/Class
                        | | | UsageScope: Module/AsmLocal/AsmBlk/TaskAndChildren/Function
                        | | | |UsageScope: Glbl/AsmLocal/Remainder/glblThisBlkAndRemainder
                        | | | || StaticVarInit/DynamicVarInitAllowed/NoInitAllowed
                        | | | || | Are dups allowed within the namespace? A dup overshadows the original.
                        | | | || | DupsAllowed/NoDups/NoDupsButPad/WarningUnlessClosedOut

    asm export label::  G C S MG   N
    asm        label:   G C   MG   N
    asm local  @@label: G C   AL   N
    asm IMPORT label;   G C   MR   N
    asm export label::  F C S BG   N
    asm        label:   F C   BG   N
    asm local  @@label: F C   AL   N
    asm IMPORT label;   F C   BR   N
    C   goto   label:   F C   FG   N

               #define  x     MR   D
               function G C S MR   D
               var      F R   FR   N
               var      F S   FR   N
    static     var      F C   FR D N
               var      G C S MR D D
               var      G D   MR N D
               class    G     MR   D
    class      member   G     MR   P
    extern     class    G     MR   D
    extern     function G C   MR   W
    import     function G C   MR   D
    import     var      G C   MR   D
    _extern    function G C   MR   D
    _extern    var      G C   MR   D
    _import    function G C   MR   D
    _import    var      G C   MR   D

    Just in Time Compilation
                        GlobalScope/FunctionScope
                        | CodeHeap/DataHeap/Stack/Register
                        | | TaskHashEntry:ExportSysSym/Define/Function/Class
                        | | | UsageScope: Module/AsmLocal/AsmBlk/TaskAndChildren/Function
                        | | | |UsageScope: Glbl/AsmLocal/Remainder/glblThisBlkAndRemainder
                        | | | || StaticVarInit/DynamicVarInitAllowed/NoInitAllowed
                        | | | || | Are dups allowed within the namespace? A dup overshadows the original.
                        | | | || | DupsAllowed/NoDups/NoDupsButPad/WarningUnlessClosedOut

    asm export label::  G C S Tg   N
    asm        label:   G C   BG   N
    asm local  @@label: G C   AL   N
    asm IMPORT label;   G C   TR   N
    asm export label::  F C   BG   N
    asm        label:   F C   BG   N
    asm local  @@label: F C   AL   N
    asm IMPORT label;   F C   BR   N
    C   goto   label:   F C   FG   N

               #define  x   D TR   D
               function G C F TR   D
               var      F R   FR   N
               var      F S   FR   N
    static     var      F C   FR D N
               var      G C G TR D D
               var      G D G TR S D
               class    G   C TR   D
    class      member   G     TR   P
    extern     class    G   C TR   D
    extern     function G C F TR   W
    extern     var      G C G TR   D
    extern     var      G D G TR   D
    _extern    function G C F TR   D
    _extern    var      G C G TR   D

    * Goto labels must not have the same name as global scope objects.  GoTo's are
    rare and I don't want to slow the compiler and add code to fix this.  You will
    get errors if a collision happens, so it's not very dangerous, but the error
    message is baffling.

    * The member names pad and reserved are special because multiple instances with
    the same name are allowed in a class.

    * Use reg or noreg in front of local var names to override automatic reg var
    allocation.  You can, optionally, specify a reg after the reg keyword.

    * Local non-reg function vars can be accessed in asm blks with &i[RBP] for
    example.

    * Glbl vars and functions can be accessed in asm with and & as in
            MOV     RAX,I64 [&glbl_var]
            CALL    I32 &Fun
            CALL    I32 &SYS_SYM

    * In JIT asm code, &SYS_SYM and &Fun don't need IMPORT.

    * All offspring tasks of a task inherit syms.

    * The sizeof() and HolyC structure members can be used in asm blks.

    * Using &i in HolyC or i.u8[2] on a local var, i, will force it to noreg.

    * Using try/catch in a function will force all local vars to noreg.

    * An unused gap on the stk is left for reg vars.

    * Note: static function vars do not go on the data heap, no matter the setting
    of the OPTf_GLBLS_ON_DATA_HEAP.  They may in the future.

    * OPTf_EXTERNS_TO_IMPORTS will treat _extern as _import and extern as import.
    This allows a header to be used either as a JIT compiled or AOT compiled header.