Names, Scopes and Bindings

1. Names, Scopes and Bindings Aaron Bloomfield CS 415 Fall 20051

2. Binding • A binding is an association between two things, such as a name and the thing it represents • Example: int x • When this statement is compiled, x is bound to a memory space

3. Binding Time • The time at which the association between two items is created • There are many different binding times that can be implemented: • Language design time • Language implementation time • Program writing time • Compile time • Link time • Load time • Run time

4. Binding Times • Language design time • These are control flow constructs, primitives, and other semantics • Think of reserved words: i.e. if, for, else, while, etc. • Language implementation time • These include I/O couplings • System dependent things such as max heap and stack sizes • Think of constants: MAX_INT, etc. • In Algol, this included the I/O procedure names

5. Binding Times • Program writing time • When you the programmer choose data structures and names • Compile time • The compiler maps high level constructs to machine code • Think of the assembly for a compiled procedure • Link time • Separate compilation means not every part of a program has to be compiled at the same time • Libraries are linked to your program and bound

6. Binding Times • Load time • For primitive operating systems • Binds physical addresses • Most OSes do this during link time with virtual addresses • Run time • Very broad term covering the span of execution • Values to variable bindings occur here

7. Binding Times • Very important to design and implementation of programming languages • Early bindings = greater efficiency • Later bindings = greater flexibility

8. Scope rules • The textual region of the program in which a binding is active is its scope • Static scoping is more common in modern programming langauges • Found in C, C++, Pascal

9. Static scope • All scoping can be determined at compile time • Most often this is done with a textual top-to-bottom scan • Most basic static scope rule: everything has global scope

10. Fortran Implementation • Global scopes • Local scopes limited to their subroutines • Local variable scope extends through the execution of the subroutine unless the variable is saved

11. Nested Subroutines • Introduced in Algol 60 and is found in some modern languages • Pascal, Ada • Subroutines can be declared inside other subroutines • This confuses the scope rules even more

12. Closest Nested Scope Rule • A variable declared has its scope in the current subroutine, and any internally nested subroutines, unless there is a definition with the same name more locally

13. Closest Nested Scope Rule Example procedure level1() variable x; procedure level2() variable x; begin (* level 2 code *) end begin (* level 1 code *) end procedure outside() begin (*outside code*) end

14. Dynamic Scope Rules • Generally less complicated to implement • The “current” binding for a name is the one most recently encountered during execution, and not yet destroyed by returning from its scope • APL, Snobol, early dialects of Lisp, and Perl have dynamic scoping

15. Implications • Semantic rules are dynamic rather than static • Type checking is generally deferred until run time • To accommodate these rules, dynamically scoped languages are most often interpreted • Very easy for an interpreter to look up the meaning of a name • All that is needed is a stack of declarations • However, it makes it harder to understand programs • The modern consensus seems to be that dynamic scoping is usually a bad idea

16. Dynamic scope example int print_base = 10; print_integer (int n) { switch (print_base) { case 10: ... case 8: ... case 16: ... case 2: ... } } foo { print_integer (10); int print_base = 16; print_integer (10); print_base = 2; print_integer (4); }

17. Alternatives to achieve the same result • Overloading and optional parameters • print_integer takes an optional parameter (one with a default value) that specifies the base • print_integer is overloaded: one form prints in decimal, the other form takes an additional parameter that specifies the base • Better or worse than dynamic scoping?

18. More implications • With dynamic scoping, no program fragment that makes use of non-local names is guaranteed a predictable referencing environment

20. Referencing Environments • A referencing environment is the complete set of bindings in effect at a given point in a program • Static scope rules: • Referencing environment dependent on lexical nesting of program blocks • Dynamic scope rules: • Referencing environment dependent on the order in which declarations are reached

21. What about references to functions? • When are dynamic scope rules applied? • When the function is called? • Shallow binding • When the reference is created? • Deep binding

22. int max_score; float scale_score (int raw_score) { return (float) raw_score / (float) max_score; } float highest_score (int[] scores, function_ptr scaling_function) { float max_score = 0; foreach score in scores { float percent = scaling_function (score); if ( percent > max_score ) max_score = percent; } return max_score; } main() { max_score = 50; int[] scores = ... print highest_score (scores, scale_score); } function is called reference is created

23. Deep Binding • Generally the default in lexically scoped languages • Dynamically scoped languages tend to use shallow binding

24. Implementing Deep Binding • Subroutine Closure

25. The Symbol Table • During compilation, keeps track of all the identifiers • Only matters in a statically scoped language! • Why? • Basic functions: lookup() and insert() • Must keep track of scope as well • Often by enter_scope() and leave_scope() functions

26. Activation records • When a subroutine starts, a number of things have to be stored: • A copy of the parameters (pass by value) • The return address when the subroutine exits • Local variables in the subroutine • Etc. • This data is called the activation record • Fortran (up until 90) only had space for one activation record • Thus, you couldn’t call more than one subroutine at a time

27. Recursive vs. Iterative • Ocaml will recognize tail recursion and convert it to a while loop: let foo x = if x = 0 then 0 else 1 + foo (x-1);; • A call to foo 1000000 would require one million activation records if called recursively • That’s many, many megs of memory! • In addition to the time spent creating them and branching to the next recursive call of the subroutine • An iterative solution avoids all that • Although there is still the branch for the loop

28. Lifetimes Lifetime = time from creation to deletion • Bindings • Objects

29. Storage Management • Static - absolute address, retained throughout program • Stack - LIFO, subroutine calls • Heap – allocation/deallocation at arbitrary times

30. Heap Management • Free list

31. Who Manages the Heap? • User • System

32. Garbage Collection • Mark and Sweep • Reference Counting

33. Aliases