1. Programming Language Concepts
19/05/2018
Scope Rules
Programming Language Concepts
Lecture 08
Prepared by
Manuel E. Bermúdez, Ph.D.
Associate Professor
University of Florida

2. Definition Scope: the region of program text in which a binding holds.
19/05/2018
Definition
Scope: the region of program text in which a binding holds.
Static binding is prevalent in most modern PLs.
New scope in each function.
Activate bindings for parameters and locals.
Deactivate bindings of globals obscured by locals.
Deactivate bindings upon function return.

3. Example In RPAL, this program prints 19 + 19 = 38.
19/05/2018
Example
let Sqr x = x * x in
let f a b = Sqr a + b
Print(f (let Sqr x = x+x in f 4 3)) )
In RPAL, this program prints = 38.
If RPAL used dynamic scoping, the result would be = 30.

4. 19/05/2018
Terminology
Referencing environment: the set of active bindings at a given point in a program's execution.
Deep binding: the reference environment of a fcn/proc is determined when the function is created.
Shallow binding: the reference environment of a fcn/proc is determined when the function is called.

5. Structure of Referencing Environments
19/05/2018
Structure of Referencing Environments
Normally, a stack suffices (C, C++, Java).
If a procedure (not merely a pointer) can be passed as a parameter, the referencing environments are organized as a tree.

6. Example: Passing Procedures as Parameters in Pascal:
19/05/2018
Example: Passing Procedures as Parameters in Pascal:
The output of this program is ???
program test(output);
procedure dummy;
begin end;
procedure Q(procedure S; n:integer);
procedure R;
begin writeln(n) end;
begin { Q }
if n=1 then Q(R,0) else S;
end;
begin {main}
Q(dummy,1)
end.

7. 19/05/2018

8. 19/05/2018

9. Types of Static Scope Flat: (BASIC, Cobol)
19/05/2018
Types of Static Scope
Flat: (BASIC, Cobol)
All name sin the same scope, all visible everywhere.
Local/global (Fortan, C, Prolog)
Only two referencing environments: current and global.

10. Types of Static Scope (cont’d)
19/05/2018
Types of Static Scope (cont’d)
Nested procedures (Algol, Pascal, Ada, Modula, RPAL).
Each procedure has its own scope, visible to itself and all procedures nested within it.

11. Types of Static Scope (cont’d)
19/05/2018
Types of Static Scope (cont’d)
Modular scope (Modula, Ada, C++, Java).
Scopes defined by modules, which explicitly export names to:
The global scope (public)
The scopes of subclasses (protected)
Nowhere (private)

12. Nested Scoping Example (in pseudo-Pascal):
19/05/2018
Nested Scoping Example (in pseudo-Pascal):
A can only see a.
B can see a and b but not c.
C can see a, b, and c.
C can see many versions of b and a, depending on the calling sequence.
proc A;
var a;
proc B;
var b:
proc C;
var c;
begin
c:=b-1;
if b=1 then B
else a:=a-c;
end;{ C }
b:=a-4;
if b<2 then C;
else a:=0;
end;{ B }
a:=5; B;
end;{ A }

13. Access to non-locals Needed to handle nested scoping. Two methods:
19/05/2018
Access to non-locals
Needed to handle nested scoping.
Two methods:
Static links
Displays.
Will cover displays (and contrast them) later.

14. 19/05/2018
Static Link
Pointer to the most recent instance of the next statically enclosing procedure (see diagram).
Each instance of B points to the most recent version of A
Each instance of C points to the most recent version of B

15. 19/05/2018

16. Static Link (cont’d) Compiler keeps track of nesting levels:
19/05/2018
Static Link (cont’d)
Compiler keeps track of nesting levels:
variable a is at level 1,
variable b is at level 2,
variable c is at level 3.
To access a variable, subtract the variable's nesting depth from the current depth, and follow that many static links.

17. 19/05/2018
Examples
For B to access a, depth[B]-depth[a] = 2-1= 1; follow 1 static link.
For C to access b, depth[C]-depth[b] =
3-2= 1; follow 1 static link.
For C to access a, depth[C]-depth[a] =
3-1= 2; follow 2 static links.

18. 19/05/2018
Block Scoping
In the C language, execution blocks, delimited with {}, define scopes. {
int t;
t = a;
a = b;
float t=3.14;
printf("%f",t); }
b = t;

19. Block Scoping (cont’d)
19/05/2018
Block Scoping (cont’d)
The variable's scope is limited to the {} block that contains its declaration.
Handled like ordinary local variables:
Space allocated in subroutine prologue (frame setup)
Deallocated in subroutine epilogue (frame destruction).
Compiler's symbol table keeps track of declarations.

20. Modular Scoping First languages to incorporate information hiding.
19/05/2018
Modular Scoping
First languages to incorporate information hiding.
Reduces "cognitive load" on programmers.
CIA principle: if a code segment doesn't need to know about an object, it shouldn't.
Tends to narrow (simplify) interfaces.
Aids in abstraction.

21. Modular Scoping (cont’d)
19/05/2018
Modular Scoping (cont’d)
Modules allow encapsulation of objects.
Objects inside the module are visible to each other.
Objects inside are only visible outside if explicitly exported.
Objects outside not visible inside unless imported.

22. Modular Scoping (cont’d)
19/05/2018
Modular Scoping (cont’d)
Various terms for modules:
Clu: clusters
Modula, Ada, Java: packages
C++: namespaces

23. Example (Pseudo Modula)
19/05/2018
Example (Pseudo Modula)
module Zorch;
export A,b;
var b:integer;
var c:real:
proc A();
...
end
end Zorch;
module Zip;
import A;
export D;
var t:real;
proc D();
...
end;
end Zip;
module Zap;
import b,D;
export Q;
proc Q();
...
end;
proc R();
end Zap;
Procedure A can see b and c.
Procedure D can see A and t, but not b or c.
Procedures Q and R can see b and D, but not A, c, or t.

24. Module Types and Classes
19/05/2018
Module Types and Classes
In Modula-2, Turing, and Ada83, a module can define only one instance of the object (module as manager).
In Simula, Euclid, and ML, programmer can declare an arbitrary number of module objects (module as type).

25. Module Types and Classes (cont’d)
19/05/2018
Module Types and Classes (cont’d)
Historically, this led to classes (Smalltalk, Eiffel, C++, Java), and object-orientation.
Classes define types (abstraction).
Classes encapsulate object data and methods (encapsulation).
Classes hide information (information hiding).
Classes facilitate polymorphism and inheritance (polymorphism).

26. 19/05/2018
Symbol Tables
Compiler must keep track of declared names (type, variables, constants, etc.)
Table stores mapping of names to attributes.
Must enforce scope rules. Typical operations:
Enter a new name, with relevant information (type, components, etc.)
Lookup a name. Must return correct instance, in accordance with scope rules.

27. Symbol Tables (cont’d)
19/05/2018
Symbol Tables (cont’d)
Open_scope. New scope must allow visibility of names in outer scopes, and redeclaration of names in new scope.
Close_scope. Probably non-destructively, without reclaiming space (need debugging info). Restore mapping of previous scope.

28. Symbol Tables (cont’d)
19/05/2018
Symbol Tables (cont’d)
Must allow forward declarations (name used before it is declared)
Hash coded table, each entry a linked list of hash synonyms.

29. Example LeBlanc-Cook symbol table (see text book)
19/05/2018
Example
LeBlanc-Cook symbol table (see text book)
Intrinsics added first (integer, real).
Situation depicts environment in with statement.
A2, F2 and T are synonyms.

30. Example (cont’d) Other mechanisms: Central Reference Tables.
19/05/2018
Example (cont’d)
Other mechanisms: Central Reference Tables.
Used to keep track of run-time environments.
Equivalent to RPAL's environment trees.

31. Binding of Reference Environments
19/05/2018
Binding of Reference Environments
Needed when passing a function/proc as a parameter.
Need subroutine closures: 4 items.
The fact that it is a function.
Functionality (prototype, parameters, etc.)
Pointer to body of fcn/proc.
Referencing environment (environment link in RPAL).

32. Binding of Reference Environments (cont’d)
19/05/2018
Binding of Reference Environments (cont’d)
In C, functions are second-class.
Can only pass function pointer (item 3) as a parameter.
Fcns/procs are first class in Lisp, ML, Haskell, RPAL, but not in Modula, Ada, C, C++, or Java. Some would argue they are, but ...

33. Overloading Multiple meanings for the same name, context dependent.
19/05/2018
Overloading
Multiple meanings for the same name, context dependent.
Most languages allow it in some limited fashion, e.g. arithmetic operators
(a+b for ints and reals).
In C++, one can overload both functions and operators. Can only overload fcns in Java (may change, more later).

34. Pitfalls in Language Design
19/05/2018
Pitfalls in Language Design
In Pascal, functions return values by assigning to the function name (no return statement). If the function name is redeclared, it becomes impossible to return a value.
Example:
function f: integer;
var f:integer;
begin
f := 10; // won't return 10
end;

35. Pitfalls in Language Design (cont’d)
19/05/2018
Pitfalls in Language Design (cont’d)
Using an outer scope name, and then declaring it (maybe much later), is illegal in Pascal. Very expensive to check.
const m = 0;
procedure f;
const n = m; { illegal use of m, }
{ m not yet declared.}
...
m = 0; { scope of m is all }
{ of f }
end;

36. Pitfalls in Language Design (cont’d)
19/05/2018
Pitfalls in Language Design (cont’d)
The same applies to functions:
procedure f;
...
end;
procedure A;
procedure B;
begin
f; {intent is to call }
{outer f }
end; {error: f used before}
{it's declared }
...
procedure f;
end;

37. Pitfalls in Language Design (cont’d)
19/05/2018
Pitfalls in Language Design (cont’d)
Some Pascal compilers (and most Pascal successors) specify that the scope of a declaration is limited to the remainder of (not the entire) block.
Confusingly, Pascal allows use of pointer types before they are declared:
type
aptr = ^a;
a = record
data: ...;
next: aptr;
end;

38. Pitfalls in Language Design (cont’d)
19/05/2018
Pitfalls in Language Design (cont’d)
Modula-3 changed this: scope of name is still the entire block, but names need not be declared before they are used.
C, C++, Java have a mixed strategy: variables must be declared before they are used, but not type (class) names. Class names are visible over the entire containing module (package).
Separate compilation (read in book).

39. Programming Language Concepts
19/05/2018
Scope Rules
Programming Language Concepts
Lecture 08
Prepared by
Manuel E. Bermúdez, Ph.D.
Associate Professor
University of Florida