Scope Rules

1
Scope Rules
Programming Language Principles Lecture 16

• 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.
• 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
RPAL Is Statically Scoped

• (CSE Rule 4)
• CONTROL STACK
• __________________________________________________
  
• ec ... ? lt?,x,i,kgt R ... ec
• ec ... en dk
  en ...ec
• __________________________________________________
  
• where en R/x ei. lt--- defines lexical
  scoping !

4
RPAL Is Statically Scoped (contd)

• ei is the environment in effect when the lambda
  closure was created.
• Change ei to ec (the current environment at the
  point of function application), and RPAL becomes
  dynamically scoped.

5
Example

• let Sqr x x x
• in
• let f a b Sqr a b
• in
• Print(f 4 3 (let Sqr x xx in f 4 3)) )
• In RPAL, this program prints 19 19 38.
• If RPAL used dynamic scoping, the result would be
  19 11 30.

6
Suggested Exercise

• Run the CSE by hand, and see the environments.
• Changing RPAL from lexical to dynamic scoping
  involves changing ONE letter !
• (The power of formal semantic specification ...)
• Some dynamically scoped languages SNOBOL, APL,
  perl (?) early LISP (later changed by J.
  McCarthy).

7
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.

8
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.

9
Example Passing Procedures as Parameters in
Pascal
The output of this program is ???

• program test(output)
• procedure dummy
• begin end
• procedure Q(procedure S ninteger)
• procedure R
• begin writeln(n) end
• begin Q
• if n1 then Q(R,0) else S
• end
• begin main
• Q(dummy,1)
• end.

10
(No Transcript)
11
(No Transcript)
12
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.

13
Types of Static Scope (contd)

• Nested procedures (Algol, Pascal, Ada, Modula,
  RPAL).
• Each procedure has its own scope, visible to
  itself and all procedures nested within it.

14
Types of Static Scope (contd)

• 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)

15
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
• cb-1
• if b1 then B
• else aa-c
• end C
• begin
• ba-4
• if blt2 then C
• else a0
• end B
• begin
• a5
• B

16
Access to non-locals

• Needed to handle nested scoping.
• Two methods
• Static links
• Displays.
• Will cover displays (and contrast them) later.

17
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

18
(No Transcript)
19
Static Link (contd)

• 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.

20
Examples

• For B to access a, depthB-deptha 2-1 1
  follow 1 static link.
• For C to access b, depthC-depthb
• 3-2 1 follow 1 static link.
• For C to access a, depthC-deptha
• 3-1 2 follow 2 static links.

21
Block Scoping

• In the C language, execution blocks, delimited
  with , define scopes.
• int t
• t a
• a b
• float t3.14
• printf("f",t)
• b t

22
Block Scoping (contd)

• 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.

23
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.

24
Modular Scoping (contd)

• 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.

25
Modular Scoping (contd)

• Various terms for modules
• Clu clusters
• Modula, Ada, Java packages
• C namespaces

26
Example (Pseudo Modula)

• module Zorch
• export A,b
• var binteger
• var creal
• proc A()
• ...
• end
• end Zorch

module Zip import A export D var
treal proc D() ... end end Zip
module Zap import b,D export Q proc
Q() ... end proc R() ...
end 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.

27
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).

28
Module Types and Classes (contd)

• 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).

29
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.

30
Symbol Tables (contd)

• 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.

31
Symbol Tables (contd)

• Must allow forward declarations (name used before
  it is declared)
• Hash coded table, each entry a linked list of
  hash synonyms.

32
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.

33
Example (contd)

• Other mechanisms Central Reference Tables.
• Used to keep track of run-time environments.
• Equivalent to RPAL's environment trees.

34
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).

35
Binding of Reference Environments (contd)

• 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 ...

36
Overloading

• Multiple meanings for the same name, context
  dependent.
• Most languages allow it in some limited fashion,
  e.g. arithmetic operators
• (ab for ints and reals).
• In C, one can overload both functions and
  operators. Can only overload fcns in Java (may
  change, more later).

37
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 finteger
• begin
• f 10 // won't return 10
• end

38
Pitfalls in Language Design (contd)

• 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

39
Pitfalls in Language Design (contd)

• 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 end
40
Pitfalls in Language Design (contd)

• 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

41
Pitfalls in Language Design (contd)

• 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).

42
Scope Rules
Programming Language Principles Lecture 16

• Prepared by
• Manuel E. Bermúdez, Ph.D.
• Associate Professor
• University of Florida