1. Names, Bindings, and Scopes
Chapter 5
Names, Bindings, and Scopes

2. Chapter 5 Topics Introduction Names Variables The Concept of Binding
Scope
Scope and Lifetime
Referencing Environments
Named Constants
Copyright © 2015 Pearson. All rights reserved.

3. Introduction
Imperative languages are abstractions of von Neumann architecture
Memory
Processor
Variables are characterized by attributes
To design a type, must consider scope, lifetime, type checking, initialization, and type compatibility
Copyright © 2015 Pearson. All rights reserved.

4. Names Design issues for names: Are names case sensitive?
Are special words reserved words or keywords?
Copyright © 2015 Pearson. All rights reserved.

5. Names (continued) Length If too short, they cannot be connotative
Language examples:
C99: no limit but only the first 63 are significant; also, external names are limited to a maximum of 31
C# and Java: no limit, and all are significant
C++: no limit, but implementers often impose one
Copyright © 2015 Pearson. All rights reserved.

6. Names (continued) Special characters
PHP: all variable names must begin with dollar signs
Perl: all variable names begin with special characters, which specify the variable’s type
Ruby: variable names that begin are instance variables; those that begin with are class variables
Copyright © 2015 Pearson. All rights reserved.

7. Names (continued) Case sensitivity
Disadvantage: readability (names that look alike are different)
Names in the C-based languages are case sensitive
Names in others are not
Worse in C++, Java, and C# because predefined names are mixed case (e.g. IndexOutOfBoundsException)
Copyright © 2015 Pearson. All rights reserved.

8. Fortran Variable Fortran variables
Fortran IV numbers and letters, at least 6 characters
Fortran 77 numbers and letters and “_”, at least 16 characters
must start with a letter
Up through 77, spaces in a Fortran program are ignored
IVALUE and I VAL UE are the same
using strange spacing, while acceptable, is bad practice
Fortran variables are typed
Fortran is case insensitive
ivar is the same as Ivar or IvAr
INTEGER, REAL, DOUBLE PRECISION, COMPLEX
LOGICAL, CHARACTER (77+)

9. Names (continued) Special words
An aid to readability; used to delimit or separate statement clauses
A keyword is a word that is special only in
certain contexts
A reserved word is a special word that cannot be used as a user-defined name
Potential problem with reserved words: If there are too many, many collisions occur (e.g., COBOL has 300 reserved words!)
Copyright © 2015 Pearson. All rights reserved.

10. Variables A variable is an abstraction of a memory cell
Variables can be characterized as a sextuple of attributes:
Name
Address
Value
Type
Lifetime
Scope
Copyright © 2015 Pearson. All rights reserved.

11. Variables Attributes Name - not all variables have them
Address - the memory address with which it is associated
A variable may have different addresses at different times during execution
A variable may have different addresses at different places in a program
If two variable names can be used to access the same memory location, they are called aliases
Aliases are created via pointers, reference variables, C and C++ unions
Aliases are harmful to readability (program readers must remember all of them)
Copyright © 2015 Pearson. All rights reserved.

12. Variables Attributes (continued)
Type - determines the range of values of variables and the set of operations that are defined for values of that type; in the case of floating point, type also determines the precision
Value - the contents of the location with which the variable is associated
- The l-value of a variable is its address
- The r-value of a variable is its value
Abstract memory cell - the physical cell or collection of cells associated with a variable
Copyright © 2015 Pearson. All rights reserved.

13. l-value and r-value Information in Program can be Characterized
Environment: Maps Name to Storage Loc (l-value)
Store: Maps Location to Value it Contains (l-value to an r-value)
Environment
State
Compile
Time
Run
Time
Name Storage Value

14. Initial Look at Types What are Types? Base Type Inductive Types
What’s a Type System?
What are the Components?
Relate to Programming Languages?
What are Type Expressions
Types can be defined inductively
Base types (a.k.a. the terminals)
Inductive types (a.k.a. grammatical productions)
From: Chapters 6 and 7 of Compilers: Principles, Techniques and Tools, Aho, et al., Addison-Wesley

15. Base Types What are the base types ? int float double char void bool
error

16. Inductive Type Definition
Purpose
Define a type in terms of other simple/smaller types
Example
array
pointer
reference
Pair
structure
function
methods
classes
...

17. The Notion of a Type System
Logical Placement of Type Checker:
Role of Type Checker is to Verify Semantic Contexts
Incompatible Operator/Operands
Existence of Flow-of Control Info (Goto/Labels)
Uniqueness w.r.t. Variable Definition, Case Statement Labels/Ranges, etc.
Naming Checks Across Blocks (Begin/End)
Function Definition vs. Function Call
Type Checking can Occur as “Side-Effect” of Parsing via a Judicious Use of Attribute Grammars!
Token
Stream
Parser
Syntax
Tree
Type
Checker
Syntax
Tree
Int. Code
Generator
Interm.
Repres.

18. The Notion of a Type System
Type System/Checker Based on:
Syntactic Language Construct
The Notion of Types
Rules for Assigning Types to Language Constructs
Strength of Type Checking (Strong vs. Weak)
Strong vs. Weak
Dynamic vs. Static
OOPLS Offer Many Variants
All Expression in Language MUST have Associated Type
Basic (int, real, char, etc.)
Constructed (from basic and constructed types)

19. The Concept of Binding
A binding is an association between an entity and an attribute, such as between a variable and its type or value, or between an operation and a symbol
Binding time is the time at which a binding takes place.
Copyright © 2015 Pearson. All rights reserved.

20. Possible Binding Times
Language design time -- bind operator symbols to operations
Language implementation time-- bind floating point type to a representation
Compile time -- bind a variable to a type in C or Java
Load time -- bind a C or C++ static variable to a memory cell)
Runtime -- bind a nonstatic local variable to a memory cell
Copyright © 2015 Pearson. All rights reserved.

21. Binding and Memory Allocation
Details the way that Memory is Managed within OS
Different Allocation Strategies Used by Each Area
Static – Compile Time
Stack – Run Time
Sizes of Data Known at Compile Time
Parameters during Calls
Heap – Run Time
Allocate and Deallocate Memory (malloc)
Programmatic Needs

22. Type Binding How is a type specified?
When does the binding take place?
If static, the type may be specified by either an explicit or an implicit declaration
Copyright © 2015 Pearson. All rights reserved.

23. What are Possible Static Binding Problems?
Passing Arrays by Value
int x [10000];
char c[20];
abc (t: -----)
{ . . .
zzz(t);
. . . }
xyz (a: -----)
abc(a);
xyz(x);
What Happens to Stack During
these multiple calls?
What’s the Problem Here?
What are two Possible Solutions?

24. Static and Dynamic Binding
Dangling References
main() {
int *p;
p = call_it(); }
int *call_it ()
int i = 23;
return &i
Is there a Problem?
What is it?
How is it Solved?

25. Explicit/Implicit Declaration
An explicit declaration is a program statement used for declaring the types of variables
An implicit declaration is a default mechanism for specifying types of variables through default conventions, rather than declaration statements
Basic, Perl, Ruby, JavaScript, and PHP provide implicit declarations
Advantage: writability (a minor convenience)
Disadvantage: reliability (less trouble with Perl)
Copyright © 2015 Pearson. All rights reserved.

26. Explicit/Implicit Declaration (continued)
Some languages use type inferencing to determine types of variables (context)
C# - a variable can be declared with var and an initial value. The initial value sets the type
Visual Basic 9.0+, ML, Haskell, and F# use type inferencing. The context of the appearance of a variable determines its type
Copyright © 2015 Pearson. All rights reserved.

27. Two Languages with Implicit Declarations/Bindings: APL and SNOBOL
Characterized by dynamic typing and dynamic storage allocation
Variables are untyped
A variable acquires a type when it is assigned a value
Storage is allocated to a variable when it is assigned a value
Copyright © 2015 Pearson. All rights reserved.

28. Dynamic Type Binding
Dynamic Type Binding (JavaScript, Python, Ruby, PHP, and C# (limited))
Specified through an assignment statement e.g., JavaScript
list = [2, 4.33, 6, 8];
list = 17.3;
Advantage: flexibility (generic program units)
Disadvantages:
High cost (dynamic type checking and interpretation)
Type error detection by the compiler is difficult
Copyright © 2015 Pearson. All rights reserved.

29. Fortran Variable TypeBinding
A feature of Fortran – implicit typing
when a variable appears that has not been declared previously it is created (at compile time)
it is assigned a type based on the first character of the name
A-H,O-Z is type REAL
I-N is type INTEGER
a typo can cause the creation of a new variable – not an error
Starting with 77 the implicit statement was added
allowed changing the first letter assignments
most 77 compilers include the implicit none statement that requires that all variables be explicitly typed – prevents the typo problem
It is good practice to use implicit none

30. Variable Attributes (continued)
Storage Bindings & Lifetime
Allocation - getting a cell from some pool of available cells
Deallocation - putting a cell back into the pool
The lifetime of a variable is the time during which it is bound to a particular memory cell
Copyright © 2015 Pearson. All rights reserved.

31. Categories of Variables by Lifetimes
Static--bound to memory cells before execution begins and remains bound to the same memory cell throughout execution, e.g., C and C++ static variables in functions
Advantages: efficiency (direct addressing), history-sensitive subprogram support
Disadvantage: lack of flexibility (no recursion)
Copyright © 2015 Pearson. All rights reserved.

32. Categories of Variables by Lifetimes
Stack-dynamic--Storage bindings are created for variables when their declaration statements are elaborated.
(A declaration is elaborated when the executable code associated with it is executed)
If scalar, all attributes except address are statically bound
local variables in C subprograms (not declared static) and Java methods
Advantage: allows recursion; conserves storage
Disadvantages:
Overhead of allocation and deallocation
Subprograms cannot be history sensitive
Inefficient references (indirect addressing)
Copyright © 2015 Pearson. All rights reserved.

33. Categories of Variables by Lifetimes
Explicit heap-dynamic -- Allocated and deallocated by explicit directives, specified by the programmer, which take effect during execution
Referenced only through pointers or references, e.g. dynamic objects in C++ (via new and delete), all objects in Java
Advantage: provides for dynamic storage management
Disadvantage: inefficient and unreliable
Copyright © 2015 Pearson. All rights reserved.

34. Categories of Variables by Lifetimes
Implicit heap-dynamic--Allocation and deallocation caused by assignment statements
all variables in APL; all strings and arrays in Perl, JavaScript, and PHP
Advantage: flexibility (generic code)
Disadvantages:
Inefficient, because all attributes are dynamic
Loss of error detection
Copyright © 2015 Pearson. All rights reserved.

35. Memory Allocation Details the way that Memory is Managed within OS
Different Allocation Strategies Used by Each Area
Static – Compile Time
Stack – Run Time
Sizes of Data Known at Compile Time
Parameters during Calls
Heap – Run Time
Allocate and Deallocate Memory (malloc)
Programmatic Needs

36. Variable Attributes: Scope
The scope of a variable is the range of statements over which it is visible
The local variables of a program unit are those that are declared in that unit
The nonlocal variables of a program unit are those that are visible in the unit but not declared there
Global variables are a special category of nonlocal variables
The scope rules of a language determine how references to names are associated with variables
Copyright © 2015 Pearson. All rights reserved.

37. Static Scope Based on program text
To connect a name reference to a variable, you (or the compiler) must find the declaration
Search process: search declarations, first locally, then in increasingly larger enclosing scopes, until one is found for the given name
Enclosing static scopes (to a specific scope) are called its static ancestors; the nearest static ancestor is called a static parent
Some languages allow nested subprogram definitions, which create nested static scopes (e.g., Ada, JavaScript, Common Lisp, Scheme, Fortran 2003+, F#, and Python)
Copyright © 2015 Pearson. All rights reserved.

38. Scope (continued)
Variables can be hidden from a unit by having a "closer" variable with the same name
Copyright © 2015 Pearson. All rights reserved.

39. Scoping What is the problem ? Consider this example program
class Foo {
int n;
Foo() { n = 0;}
int run(int n) {
int i;
int j;
i = 0;
j = 0;
while (i < n) {
n = i * 2;
j = j + n; }
return j; };

40. Simple Static Scoping Example
in main program -- n = 100
in laurel -- m = 50
in laurel -- n = 1
in hardy -- n = /* here hardy is called from laurel */
in hardy -- n = /* here hardy is called from main program */

41. Dynamic Scoping Example
in main program -- n = 100
in laurel -- m = 50
in laurel -- n = 1
in hardy -- n = 1 ;; NOTE DIFFERENCE -- hardy called from laurel
in hardy -- n = 100 ;; hardy is called from the main program

42. Scoping and Nested Procedures

43. Nested Procedures and Recursion

44. Resolving the Issue Observation Scopes are always properly nested
Each new definition could have a different type
Idea
Make the typing environment sensitive to scopes
New operations on typing env.
Entering a scope
Effect: New declarations overload previous one
Leaving a scope
Effect: Old declarations become current again
What are the Issues?
Activating and Tracking Scopes!

45. Scoping The Scopes Class Scope Method Scope Body Scope Block Scope
class Foo {
int n;
Foo() { n = 0;}
int run(int n) {
int i;
int j;
i = 0;
j = 0;
while (i < n) {
n = i * 2;
j = j + n; }
return j; };
Class Scope
Method Scope
Body Scope
Block Scope
Key point: Non-shadowed names remain visible

46. Handling Scopes From a declarative standpoint
Introduce a new typing environment
Initially equal to the copy of the original
Then augmented with the new declarations
Discard environment when leaving the scope
From an implementation point of view
Environment directly accounts for scoping
How ?
Scope chaining!

47. Scope Chaining Key Ideas One scope = One hashtable
Scope chaining = A linked list of scopes
Abstract Data Type
Semantic Environment
pushScope
Add a new scope in front of the linked list
popScope
Remove the scope at the front of the list
lookup(name)
Search for an entry for name. If nothing in first scope, start scanning the subsequent scopes in the linked list.

48. Scope Chaining Advantages Updates are non-destructive
When we pop a scope, the previous list is unchanged since addition are only done in the top scope
The current list of scopes can be saved (when needed)

49. Entering & Leaving Scopes
Easy to find out...
Use the tree structure!
Entering scope
When entering a class
When entering a method
When entering a block
Leaving scope
End of class
End of method
End of block
We’ll Revisit in Chapter 7 on Runtime Environment!

50. Blocks - Note: legal in C and C++, but not in Java
A method of creating static scopes inside program units--from ALGOL 60
Example in C:
void sub() {
int count;
while (...) {
count++;
... } …
- Note: legal in C and C++, but not in Java
and C# - too error-prone
Copyright © 2015 Pearson. All rights reserved.

51. Block Structure in Algol
First language to implement a block structure
Similar in form to pascal
begin
…..
end;
Each block can have its own variables, visible only to that block (local variables). After the block is exited the values of all the local variables are lost.
Blocks Dominant in All Programming Languages

52. The LET Construct
Most functional languages include some form of let construct
A let construct has two parts
The first part binds names to values
The second part uses the names defined in the first part
In Scheme:
(LET (
(name1 expression1) …
(namen expressionn) )
Copyright © 2015 Pearson. All rights reserved.

53. The LET Construct (continued)
In ML:
let
val name1 = expression1 …
val namen = expressionn in
expression
end;
In F#:
First part: let left_side = expression
(left_side is either a name or a tuple pattern)
All that follows is the second part
Copyright © 2015 Pearson. All rights reserved.

54. Declaration Order
C99, C++, Java, and C# allow variable declarations to appear anywhere a statement can appear
In C99, C++, and Java, the scope of all local variables is from the declaration to the end of the block
In C#, the scope of any variable declared in a block is the whole block, regardless of the position of the declaration in the block
However, a variable still must be declared before it can be used
Copyright © 2015 Pearson. All rights reserved.

55. Declaration Order (continued)
In C++, Java, and C#, variables can be declared in for statements
The scope of such variables is restricted to the for construct
Thus, Cannot be Accessed After for Statement Completes
Copyright © 2015 Pearson. All rights reserved.

56. Global Scope
C, C++, PHP, and Python support a program structure that consists of a sequence of function definitions in a file
These languages allow variable declarations to appear outside function definitions
C and C++have both declarations (just attributes) and definitions (attributes and storage)
A declaration outside a function definition specifies that it is defined in another file
Copyright © 2015 Pearson. All rights reserved.

57. Global Variables in C – to a File
/* This is main.c
int a, b c;
main()
{ . . .
can access a/b/c
xyz(c);
. . . }
xyz (a: -----)
can access b/c
but not a
parameter overrides
/* This is code.c
int x [10000];
char c[20];
abc (t: -----)
{ . . .
zzz(t);
can access c/x }
xyz (a: -----)
abc(c);
. . .
Copyright © 2015 Pearson. All rights reserved.

58. Global/Scopes in Pascal
Program main(); var aGlobalVar: integer; /* WHERE CAN THIS BE ACCESSED? */ procedureCallBack; { Outer level procedure } begin end; procedureCallingProcedure; var aVar: integer; /* WHERE CAN THIS BE ACCESSED? */ procedureNestedCallBack; var anotherVar: integer; begin {NestedCallBack } aVar := 1; anotherVar := 2; end; {NestedCallBack } begin {CallingProcedure } CallBack; NestedCallBack; end; {CallingProcedure } /* program code */ End.
Copyright © 2015 Pearson. All rights reserved.

59. Global Scope (continued)
PHP
Programs are embedded in HTML markup documents, in any number of fragments, some statements and some function definitions
The scope of a variable (implicitly) declared in a function is local to the function
The scope of a variable implicitly declared outside functions is from the declaration to the end of the program, but skips over any intervening functions
Global variables can be accessed in a function through the $GLOBALS array or by declaring it global
Copyright © 2015 Pearson. All rights reserved.

60. Global Scope (continued)
Python
A global variable can be referenced in functions, but can be assigned in a function only if it has been declared to be global in the function
Copyright © 2015 Pearson. All rights reserved.

61. Evaluation of Static Scoping
Works well in many situations
Problems:
In most cases, too much access is possible
As a program evolves, the initial structure is destroyed and local variables often become global; subprograms also gravitate toward become global, rather than nested
Copyright © 2015 Pearson. All rights reserved.

62. Dynamic Scope
Based on calling sequences of program units, not their textual layout (temporal versus spatial)
References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point
Copyright © 2015 Pearson. All rights reserved.

63. Scope Example Static scoping Dynamic scoping
function big() {
function sub1()
var x = 7;
call sub2();
function sub2() {
var y = x; }
var x = 3;
call sub1();
Static scoping
Reference to x in sub2 is to big's x
Dynamic scoping
Reference to x in sub2 is to sub1's x
big calls sub1
sub1 calls sub2
sub2 uses x
Copyright © 2015 Pearson. All rights reserved.

64. Scope Example Evaluation of Dynamic Scoping: Advantage: convenience
Disadvantages:
While a subprogram is executing, its variables are visible to all subprograms it calls
Impossible to statically type check
3. Poor readability- it is not possible to statically
determine the type of a variable
Copyright © 2015 Pearson. All rights reserved.

65. Scope and Lifetime
Scope and lifetime are sometimes closely related, but are different concepts
Consider a static variable in a C or C++ function
Copyright © 2015 Pearson. All rights reserved.

66. Static Allocation Binding Names to Storage Location at Compile Time
Program and Procedure/Function Variables
Consider C Program:
int xyz;
char c[20];
int abc () {
static int x;
. . .
static int y; }
Global vars known at compile time
Static means to allocate at compile
Data values persist over multiple
calls to abc()
x, y: retain values in successive
calls to abc!

67. Recall Memory Pools Where does memory comes from ? Three pools Static
Automatic (Stack)
Dynamic
Automatic (Stack)
Dynamic
Static

68. Static Pool
Content
All the static “strings” that appear in the program
All the static constants used in the program
All the static variables declared in the program
static int
static arrays
static records
static ....
Allocation ?
Well... it is static, i.e.,
All the sizes are determined at compile time.
Cannot grow or shrink

69. Static Allocation
Static Allocation is Limited and Programming Language Specific
In Pascal, Global Program Variables Only
In C, Global Variables and Specific Static
What are Implications to Compilation Process?
Are these two Programs Same? Why? Different? How?
main() {
int x[ ];
. . . }
main() {
static int x[ ];
. . . }

70. Automatic Pool (Stack Allocation)
Content
Local variables
Actuals (arguments to methods/functions/procedures)
Allocation
Automatic when calling a method/function/procedure
Deallocation
Automatic when returning from a method/function/procedure
Management policy
Stack-like

71. Automatic Pool (Stack Allocation)
Tightly Coupled with Procedure Activation
Parameters, Local Variables, Temporary Variables
Allocated as Each Procedure/Function Called
Stack Expands for Nested (and Recursive) Calls
Two Step Process
Call Sequence: Allocation Activation Record and Enter Data into its Fields
Return Sequence: Restores State of Program to Caller to Continue Execution
What Does Caller vs. Callee Do?

72. Heap (Dynamic) Allocation
Allows for the Management of Dynamic Storage:
Allow Local Names to Persist When Procedure Activation Completes
When a Called Activation Outlives Caller (Fork off a Process )
Important Issues Include:
How Does Allocation Occur?
Is Garbage Collection Available for Programmer Initiated Deallocation?
Or, does Deallocation Occur Automatically?

73. Dynamic Pool Content Anything allocated by the program at runtime
Allocation
Depends on the language
C malloc
C++/Java/C# new
ML/Lisp/Scheme implicit
Deallocation
C free
C++ delete
Java/C#/ML/Lisp/Scheme Garbage collection

74. Referencing Environments
The referencing environment of a statement is the collection of all names that are visible in the statement
In a static-scoped language, it is the local variables plus all of the visible variables in all of the enclosing scopes
A subprogram is active if its execution has begun but has not yet terminated
In a dynamic-scoped language, the referencing environment is the local variables plus all visible variables in all active subprograms
Copyright © 2015 Pearson. All rights reserved.

75. This is Referencing Environment
class Foo {
int n;
Foo() { n = 0;}
int run(int n) {
int i;
int j;
i = 0;
j = 0;
while (i < n) {
n = i * 2;
j = j + n; }
return j; };
Class Scope
Method Scope
Body Scope
Block Scope
Key point: Non-shadowed names remain visible

76. Named Constants
A named constant is a variable that is bound to a value only when it is bound to storage
Advantages: readability and modifiability
Used to parameterize programs
The binding of values to named constants can be either static (called manifest constants) or dynamic
Languages:
C++ and Java: expressions of any kind, dynamically bound
C# has two kinds, readonly and const
- the values of const named constants are bound at
compile time
- The values of readonly named constants are
dynamically bound
Copyright © 2015 Pearson. All rights reserved.

77. Summary
Case sensitivity and the relationship of names to special words represent design issues of names
Variables are characterized by the sextuples: name, address, value, type, lifetime, scope
Binding is the association of attributes with program entities
Scalar variables are categorized as: static, stack dynamic, explicit heap dynamic, implicit heap dynamic
Strong typing means detecting all type errors
Copyright © 2015 Pearson. All rights reserved.