J PPL Unit 2 Lecture 4 Scope Part 1

PRINCIPLES OF PROGRAMMING
LANGUAGES
Dr. D. C. Kiran
Associate Professor
Department of
Computer Science & Engineering
PRINCIPLES OF PROGRAMMING LANGUAGES
Scope of Variable: Part 1
Dr. D. C. Kiran
Department of Computer Science and Engineering
Topics To Be Covered
• Scope of Variable
• Lexical Scoping
• Dynamic Scoping
Scope of Variable
• The scope of a variable is the range of statements over which

it is visible
• The non local variables (free variables) of a program unit are
those that are visible but not declared there
The scope rules of a language determine how references to

names are associated with variables.
• Disallowing them altogether (except keywords and special
forms)
• Lexical Scoping: Compile Time
-- Only two scoping Levels- Global and Local.
-- Nested scoping
• Dynamic Scoping: At run time.
Static Scope
• Also called Lexical Scope

• Lexical scope rules specify the association of variables
with declarations based on just the examination of the
source code
• The binding of variables to declarations is done at compile
time
• It is based on their spatial relationship
• Pascal and C use Static Scoping rules
Static Scope
void main() {
int x,y,z,m; f, g while 3
while(…) ---1
{
d, e, m while 2
int a,b,c,m;
…………… while 1
a ,b, c, m
while(…)-2
{
x, y, z, m main
int d,e,m;
d = b + x + m;
} Statically visible variables
} While 3 F G X Y Z M
while(………)-3
While 2 D E M A B C X Y Z
{
int f,g;
While 1 A B C M X Y Z
f=b + x + m; Main X Y Z M
}
}
Dynamic Scope
• The binding of variables to declarations is done at run time

• It is based on the calling sequence of subprograms.
void sub3() { Call Sequence In sub3:

int x, z; main calls sub1
reference to x is local
x = u + v; sub1 calls sub1
} sub1 calls sub2 reference to u searches all activation
void sub2() { sub2 calls sub3 records on stack until main
int w, x; ... Run time Stack reference to v is in most recent
} activation record of sub1
void sub1() { Sub3 :x,z
int v, w; ...
Sub2 :w,x
} • Pure Lisp and original
Sub1: v,w
int main() { Common Lisp, as well
int v, u; ... Sub1: v,w as Snobol and APL use
} Main: v,u Dynamic Scoping Rules
Implementation of Dynamic Scope
Deep Access:
Non-local references are found by searching the activation
record instances on the dynamic chain.
Example in previous slide
Shallow Access:
• Put locals in a central place
• One stack for each variable name
• Central table with an entry for each variable name
Dynamic Scoping check the visibility of Non-local variable

void main()
fun2
{
int a,b,c,d,e,f; fun1
fun1() main a b c d e f
}
int fun1( )
{
int res, a,b,g,h,i,j;
fun2()
}
int fun2( )
{
int a,b,g,l,m,n;
Draw run time stack
m= i+f;
}

void main()
fun2
{
int a,b,c,d,e,f; fun1 a b g h i j c d e f
}
int fun1( )
{
Fun2()
}
int fun2( )
{
int a,b,g,l,m,n;
m= i+f;
}

void main()
fun2 a b g l m n c d e f h i j
{
}
int fun1( )
{
Fun2()
}
int fun2( )
{
int a,b,g,l,m,n;
m= i+f;
}
Exercise:
void main()
fun2
{
int a,b,c,d,e,f; fun1
fun1() main
fun2()
}
int fun1( )
{
}
int fun2( )
{
int a,b,g,l,m,n;
Draw run time stack
Fill the visible variables
}
Calculate the address of non local variable
Exercise:
void main()
fun2 a b g l m n c d e f
{
fun2()
}
int fun1( )
{
}
int fun2( )
{
int a,b,g,l,m,n;
Draw run time stack
Fill the visible variables
}
Calculate the address of non local variable
Example 1 :Static vs Dynamic
int i = 10;
void fun1() {
printf(“Inside fun1…%d\n”, i);
}
void fun2() { Static Scope
int i = 20; Inside fun1… 10
fun1(); Inside fun1… 10
}
Inside fun1… 10
int main() {
fun1();
fun2(); Dynamic Scope
fun1(); Inside fun1… 10
} Inside fun1… 20
Inside fun1… 10
var a : integer;
procedure first
a := 1;
procedure second
var a : integer;
first();
begin
a := 2;
second();
write_integer(a);
end;
15
var a : integer;
procedure first
a := 1;
var a : integer;
main()
procedure second a := 2;
var a : integer; second()
first(); var a : integer;
first()
begin a := 1;
a := 2; write_integer(a);
second();
write_integer(a);
The program prints 1
end;
16
var a : integer;
procedure first
a := 1;
var a : integer;
main()
procedure second a := 2;
var a : integer; second()
first(); var a : integer;
first()
begin a := 1;
a := 2; write_integer(a);
second();
write_integer(a);
The program prints 2
end;
17
Summary: Takeaway
• Scope of Variable
• Lexical Scoping
 Compiler will identify
 A.K.A Static Scoping
• Dynamic Scoping
Identified during runtime
 Deep access
 Shallow access
• Examples
THANK YOU
Dr. D. C. Kiran
Department of Computer Science and Engineering
dckiran@pes.edu
9829935135

J PPL Unit 2 Lecture 4 Scope Part 1

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

J PPL Unit 2 Lecture 4 Scope Part 1

Uploaded by

Copyright:

Available Formats

PRINCIPLES OF PROGRAMMING

Scope of Variable: Part 1

• The scope of a variable is the range of statements over which

The scope rules of a language determine how references to

• Also called Lexical Scope

• The binding of variables to declarations is done at run time

void sub3() { Call Sequence In sub3:

Dynamic Scoping check the visibility of Non-local variable

Dynamic Scoping check the visibility of Non-local variable

Dynamic Scoping check the visibility of Non-local variable

You might also like