Parameter Passing and Static vs Dynamic Scope

• Runtime Environments and Activation Records: activation records, control links (the call chain) and access links (the lexical chain).
• l-values (locations) and r-values (contents) of expressions, as in assignment (see the note Functions and Parameter Passing).

• Formal and actual parameters. Formals are the names in the procedure declaration; actuals are the expressions in the call.
• l-value and r-value. A[i] has an l-value (the address of the element) and an r-value (the number stored there). Mechanisms differ in which of these they pass and when they compute it.
• Environment and state. The environment maps names to locations; the state maps locations to values. Scope rules fix the environment; assignments change the state.
• Aliasing. Two names denote the same location. Call by reference creates aliases (a formal and a global, or two formals), which changes results.
• Static (lexical) scope. A name refers to the declaration in the nearest enclosing block or procedure in the program text. Resolved at compile time; implemented with access links or displays.
• Dynamic scope. A name refers to the declaration in the most recently called, still active, procedure that declares it. Resolved at run time by searching down the call stack.

The four mechanisms

Example 1: one variable, four outcomes

int a = 1;
void f(int x) { x = x + 1; a = a + 10; x = x + 100; }
main: f(a);  then a is ?

Example 2: when the argument's location moves

int i = 0; int A[2] = {5, 7};
void q(int x) { i = 1; x = x + 1; }
main: q(A[i]);

• Value: A is unchanged, {5, 7}.
• Reference: the address of A[0] is fixed at the call; A becomes {6, 7}.
• Value-result: x starts as 5 and becomes 6; it is copied back to A[0], the location noted at the call: {6, 7}.
• Name: x = x + 1 re-evaluates A[i] with $i = 1$ on both sides: A[1] = A[1] + 1, so A becomes {5, 8}.

Example 3: swap fails under call by name

void swap(int x, int y) { int t = x; x = y; y = t; }
int i = 0; int A[2] = {1, 5};
main: swap(i, A[i]);

Example 4: aliasing between formals

int a = 2;
void h(int x, int y) { x = x + 1; y = y + y; }
main: h(a, a);

Example 5: all four mechanisms on one call

int i = 1; int A[5] = {10, 20, 30, 40, 50};
void p(int x, int y) { y = y + 1; x = x + 2; i = i + 1; y = y + x; }
main: p(i, A[i]);

Static versus dynamic scope

int x = 1;
void f() { print(x); }
void g() { int x = 2; f(); }
main: g(); f();

int n = 1;
void show() { print(n); }
void inc()  { n = n + 1; }
void two()  { int n = 5; inc(); show(); }
main: two(); show();

Static scope with nested procedures

int x = 10;
void p() {
    int x = 20;
    void q() { print(x); }
    void r() { int x = 30; q(); }
    r(); q();
}
main: p();

• Static: q is declared inside p, so its free x is p's, whoever calls it. Both calls print 20: output 20 20.
• Dynamic: the first call of q comes from r, whose x is the most recent: 30. The second comes from p: 20. Output 30 20.
• If q were declared at the outer level instead (next to p), static scope would print the global: 10 10. Dynamic scope would still print 30 20, because the call history is unchanged.

• Reference and name agree on a simple variable argument whose location cannot change (Example 1); they differ for A[i] when i changes (Examples 2 and 3).
• Value-result and reference agree unless aliasing exists during the call (Examples 1 and 4).
• Call by value never changes the actual; but passing a pointer by value still lets the callee change the pointed-to object, which is how C simulates reference parameters.
• Call by name is lazy: an argument never used is never evaluated, and one used twice is evaluated twice.
• Static scope is decided by program text; dynamic scope by the call history. The same program can print different results under the two rules only if some procedure has a free name declared in more than one place.
• C, C++, Java and Pascal use static scope; C passes everything by value (arrays decay to a pointer passed by value); C++ adds reference parameters.

• "Value-result is the same as reference." Not when the procedure also reaches the actual through another name.
• "Dynamic scope means the variable is allocated dynamically." It is about name resolution, not storage.
• "Under static scope the callee sees the caller's locals." Only if the callee is textually nested in the caller.

• Output under a stated mechanism. Trace each assignment, keeping the formal's location (reference), a separate copy (value, value-result) or the argument text (name). For value-result, apply the copy-back order the question implies.
• Output under static and dynamic scope. For each free name, find the enclosing declaration (static) or the most recent active one on the call chain (dynamic). Assignments to a free name change whichever variable that rule picks.
• Aliasing traps. The same variable passed twice, or a global also passed as an argument.
• Array arguments with changing indices. Separate name from reference.
• Value-result copy-back can undo a global update made during the call. (Example 5: $i$ ends at 3, not 4).
• Nested procedures under static scope. Find where the procedure is declared, not where it is called (Example 8).
• Which needs what at run time. Static scope uses access links or displays; dynamic scope searches the control chain.

• Runtime Environments and Activation Records: prerequisite. Activation records, control links and access links.
• Functions and Parameter Passing: related. C's call by value and pointer parameters at the programming level.