Behaviour of dynamically scoped variables after returning from a function

Question

Are any modifications to the value of a dynamically scoped variable persistent even after the function (in which modifications were made) returns? For example, in the following code (assuming dynamic scoping):

void weird_function (int i)
{
    i = 5;
    return;
}

int main (void)
{
    int i = 4;
    weird_function(i);
    printf(“%d\n”, i);
    return 0;
}

ignoring call-by-value semantics; when the control returns to main after calling weird_function, would the variable i (which is dynamically scoped) contain 4 or 5?

 

In other words, would the dynamically scoped variables be allocated on heap or do they live in the stack frame of current function? Do dynamically scoped variables essentially act like global variables in this particular regard?

Comments

In Dynamic Scoping:- Output will be $i=5$.

In other words, would the dynamically scoped variables be allocated on heap or do they live in the stack frame of current function? 

Dynamic Scoping does not need any additional data structure, it can be done in function stack only with the help of dynamic link or control link. Dynamic/Control link point to data in the activation record which called the function.

In your case dynamic link of function

void weird_function (int i)

points to local data of the function

int main (void)

thus it will print 5 which was assigned by weird_function().

---

l actually found the correct answer and have added it. While your answer was right, the reason was wrong. See, we can't use dynamic links for dynamic scoping because variables are being identified with their name (not their address) even at runtime. So, there has to be a way for a runtime symbol-table to be maintained which can then be searched for the required variable name.

I mistakenly thought that this symbol table will be on the call stack (so that lexical and dynamic variables are interleaved) and would be copied "up" every time a function was called. That is where my question came from.

See my answer for more details.

Thanks for answering.

Answer 1

I actually found the answer — the new value (5) will persist. Following is a possible implementation of dynamic scoping which makes it clear:

• Each time a subroutine is called, its local variables are pushed on a stack with their name-to-object binding
• When a reference to a variable is made, the stack is searched top-down for the variable's name-to-object binding
• After the subroutine returns, the bindings of the local variables are popped.

EDIT: Turns out, Bash is a dynamically scoped language. Try the following in a Bash shell:

$ i=1
$ function f () { local i=3 ; g ; echo "f: $i" ; }
$ function g () { echo "g: $i" ; i=2 ; }
$ f

Output will be:

g: 3
f: 2