Question

Assignment:

Show the symbol table for the following C programs at the printf lines

(a) using lexical scope and (b) using dynamic scope.

What does the program print using each kind of scope rule?

Program 1:

const int b = 10;

int foo()

{

   int a = b + 10;

   return a;

}

int bar()

{

   int b = 4;

   return foo();

}

int main()

{

   printf(“foo = %d\n”,foo());

   printf(“bar = %d\n”,bar());

   return 0;

}

Program 2:

int a;

                void first()
{
                a = 12
}

void second()

                {
                int a = 6;
                first();
}

                void main()

                {
                a = 4;

                                second();

                                printf("%d\n",a);
}

Answer 1

Lexical(Static) scoping determines the value of a variable by the structure of the code that refers to variable..
while In dynamic scoping runtime stack of the program will decide the value by reference of a variable.

Program 1:-

const int b = 10;//b1
int foo()
{
int a = b + 10;//b2*+10
return a;
}

int bar()
{
int b = 4;//b2=4
return foo();
}
int main()
{
printf(“foo = %d\n”,foo());
printf(“bar = %d\n”,bar());
return 0;
}

Using lexical scoping for understanding
for global variable assign a label b1 and for local b2,
So, foo() will return 20.
But in bar() we have local b=4 and it is structured in foo()
while running foo() it will consider b2 instead of b1.
So final awnser will be
foo = 20
bar = 14

Using dynamic scoping
foo() will same as lexical scoping.
But for bar() we have b2=4 and then it will return foo() from the bar()
but as soon as it enters in the foo() value of b2 will be out of scope
and foo() will use b1=10 and will count a=20 and returns.
So, this time awnser will be
foo = 20
bar = 20

Program 2:-
int a;//a1
void first()
{
a=12;//a2*
}
void second()

{
  
int a = 6;//a2
first();
}
void main()

{
  
a = 4;
//a1
second();
  
printf("%d\n",a);//a1
}

Using lexical scoping,
Here also for understanding let us take label a1 and a2 for global and local variable.
In lexical while calling second() by structure of program in
first a assigned to 12 is local variable(a2) second().
So, a1 is not affected still.
So it will print 4.

Using Dynamic scoping,
difference is second() will call first().
This time a of second go out of scope and stack of a will refer to the global variable
which will be affected by first() and it will be 12.
So, it will print 12.

Like, please.

and comment if you have any queries.