1 / 42

Scope Rules

Scope Rules. Programming Language Principles Lecture 16. Prepared by Manuel E. Bermúdez, Ph.D. Associate Professor University of Florida. 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.

echo-branch
Download Presentation

Scope Rules

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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): CONTROLSTACK __________________________________________________ ec ...  <λ,x,i,k> R ... ec ec ... enδk en ...ec __________________________________________________ where en = [R/x] ei. <--- defines lexical scoping !

  4. RPAL Is Statically Scoped (cont’d) • 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 = 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.

  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: 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 ???

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

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

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

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

  14. Access to non-locals • Needed to handle nested scoping. • Two methods: • Static links • Displays. • Will cover displays (and contrast them) later.

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

  16. Static Link (cont’d) • Compiler keeps track of nesting levels: • variableais at level 1, • variablebis at level 2, • variablecis at level 3. • To access a variable, subtract the variable's nesting depth from the current depth, and follow that many static links.

  17. Examples • ForBto accessa, depth[B]-depth[a] = 2-1= 1; follow 1 static link. • ForCto accessb, depth[C]-depth[b] = 3-2= 1; follow 1 static link. • ForCto accessa, depth[C]-depth[a] = 3-1= 2; follow 2 static links.

  18. 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) • 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. • 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) • 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) • Various terms for modules: • Clu: clusters • Modula, Ada, Java: packages • C++: namespaces

  23. Example (Pseudo Modula) 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; module Zorch; export A,b; var b:integer; var c:real: proc A(); ... end end Zorch; • 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 • 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) • 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. 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) • 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) • 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) • Intrinsics added first (integer, real). • Situation depicts environment inwithstatement. • A2, F2andTare synonyms.

  30. 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 • 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) • 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. • Most languages allow it in some limited fashion, e.g. arithmetic operators (a+bfor 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 • 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) • 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) • 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;

  37. 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) • 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. Scope Rules Programming Language Principles Lecture 16 Prepared by Manuel E. Bermúdez, Ph.D. Associate Professor University of Florida

More Related