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

19
(No Transcript)
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 gt max_score )
• max_score percent
• return max_score
• main()
• max_score 50
• int scores ...

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 couldnt 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
• Thats 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