scope rules prepared by manuel e. bermúdez, ph.d. associate professor university of florida...
Post on 04-Jan-2016
223 Views
Preview:
TRANSCRIPT
Scope Rules
Prepared by
Manuel E. Bermúdez, Ph.D.Associate ProfessorUniversity of Florida
Programming Language ConceptsLecture 11
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.
Example
let Sqr x = x * x
in
let f a b = Sqr a + b
in
Print(f 4 3 + (let Sqr x = x+x in f 4 3)) )
• In RPAL, this program prints 19 + 19 = 38.
• If RPAL used dynamic scoping, the result would be 19 + 11 = 30.
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.
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.
Example: Passing Procedures as Parameters in Pascal:
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.
The output of this program is ???
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.
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.
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)
Nested Scoping Example (in pseudo-Pascal): 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 } begin b:=a-4; if b<2 then C; else a:=0; end;{ B } begin a:=5; B; end;{ A }
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.
Access to non-locals
• Needed to handle nested scoping.
• Two methods: • Static links• Displays.
• Will cover displays (and contrast them) later.
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
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.
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.
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;}
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.
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.
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.
Modular Scoping (cont’d)
• Various terms for modules:
• Clu: clusters• Modula, Ada, Java: packages• C++: namespaces
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;
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.
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).
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).
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.
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.
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.
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.
Example (cont’d)
• Other mechanisms: Central Reference Tables.• Used to keep track of run-time
environments.• Equivalent to RPAL's environment
trees.
Binding of Reference Environments
• Needed when passing a function/proc as a parameter.
• Need subroutine closures: 4 items.
1. The fact that it is a function.2. Functionality (prototype, parameters, etc.)3. Pointer to body of fcn/proc.4. Referencing environment (environment link in
RPAL).
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 ...
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).
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;
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;
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;
end;
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;
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).
Scope Rules
Prepared by
Manuel E. Bermúdez, Ph.D.Associate ProfessorUniversity of Florida
Programming Language ConceptsLecture 11
top related