Scope: Where An Identifier Has Meaning
                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(Lexical Scope) The name of a global variable or function that is defined
within a file is known (i.e., has meaning) from the point at which it is
defined until the end of the file.  So is a name declared in a global extern
statement or function prototype.

(Block Scope) The name of an argument to a function is known within its
function block.  The name of a local variable is known within the smallest
block that contains its definition, starting at the point where it is defined.
So is a name declared in a local extern statement or function prototype.

An identifier refers to the variable or function with that name in the smallest
enclosing context in which it is known.

File foo.c  (X, A, B, C, and E are variable names; the digits are annotations)
~~~~~~~~~~
int A1;             // Global [known until end of foo.c; knowable outside]
static int X;       // Global [known until end of foo.c; unknowable outside]

void ONE            // Function [known until end of foo.c; knowable outside]
  (int B1)          // Argument to function [known within function block]
{
    int A2, C1;         // Local variables [known until end of function block]

    // X = global X; A = local A2; B = argument B1; C = local C1; E unknown
    // ONE() is known; TWO() and THREE() are unknown

    {
        int A3, B2;         // Local variables [known until end of this block]
        extern int E1;      // Global external [known until end of this block]

        // X = global X; A = local A3; B = local B2; C = local C1; E = extern E1
        // ONE() known; TWO() and THREE() unknown
    }
}

void THREE (int);   // Function prototype [known until end of foo.c]

static void TWO     // Function [known until end of foo.c; unknowable outside]
  (int A4)          // Arguments to function [known within function block]
{
    int C2, ONE;        // Local variables [known until end of function block]

    // X = global X; A = argument A4; B unknown; C = local C2; E unknown
    // ONE = local ONE; ONE() unknown; TWO() and THREE() known
}

extern int E2;      // Global external [known until end of foo.c]

void THREE          // Function [known until end of foo.c; knowable outside]
  (int C3)          // Arguments to function [known within function block]
{
    // X = global X; A = global A1; B unknown; C = argument C3; E = extern E2
    // ONE(), TWO(), and THREE() known
}


File bar.c  (X, A, B, C, and E are variable names; the digits are annotations)
~~~~~~~~~~
int E3;             // Global [known until end of bar.c; knowable outside]

void FOUR           // Function [known until end of bar.c; knowable outside]
  (int A5)          // Arguments to function [known within function block]
{
    void THREE (int);   // Function prototype [known to end of function block]

    // X unknown; A = argument A5; B unknown; C unknown; E = global E3
    // ONE() and TWO() unknown; THREE() and FOUR() known
}                                                            // CS-223-02/05/20