Programming Languages

Names, Bindings, Scopes

(Slides are adopted from Concepts of Programming Languages, R.W. Sebesta)

2
Imperative Lang. and von Neumann
 Imperative languages are abstractions of von
Neumann architecture
 Key components of von Neumann architecture:
 Memory: store data and instructions
 Processor: do operations to modify memory contents
 Imperative language abstractions:
 Variables  memory cells Memory
 Expressions  CPU executions

Processor
3
Roadmap
Ch. 1 Classification of languages
What make a “good” language?
Ch. 2 Evolution of languages
Ch. 3 How to define languages?
Ch. 4 How to compile and translate programs?
Ch. 5 Variables in languages

Ch. 7 Statements and program constructs in languages

Ch. 15 Functional and logic languages

4
 Programmers’ View of Memory
int i,a[100];
a OS
void foo()
{ int i,j;
.. = j;
i = ..; i Memory
} j
• How variables are defined?
• How are they associated
Processor
with storage? i

(virtual) Memory 5
 General Memory Layout
Address
 Space for saved
Stack
$sp (stack procedure information
Pointer)

int i,a[100];
void foo()
Heap Explicitly created space,
{ int i,j,*p; e.g., malloc()
.. = j;
i = ..; Static Static or global variables,
p=malloc(); declared once per program
} Code
0 Program code
6
Overview
Study fundamental semantic issues of variables:
 Attributes of variables (Sec. 5.1, 5.2, 5.3)
 Name, value, type, address, lifetime, scope
 Binding of variables (Sec. 5.4)
 Scope and lifetime (Sec. 5.5, 5.6)
 Referencing environments (Sec. 5.7)
 Named constants (Sec. 5.8)

7
Variable Attributes: Name, Value
 Name: also called identifier
 Length:
 Most modern PL do not impose a limit
 Connectors: e.g., underscore “_”
 Model PL prefer camel notation, e.g., MyStack
 Case sensitivity:
 C, C++, and Java names are case sensitive
 Names that look alike are different: rose, ROSE
 Value:
 The contents of the location with which the variable
is associated

8
Variable Attributes: Type
 Type:
 Determines (1) the range of values that the variable
can store; and (2) the set of operations that can be
performed for values of that type
 Uses of type system: error detection through type
checking, program modularization, documentation
 Can a variable have different types at different times?
 Are two given types equivalent?
 What happen when two variables of different types
operate together?
 Type will be discussed in length in next chapter

9
Variable Attributes: Address
 Which address is variable i int i,a[100];
bound? void foo()
 What if foo() is in recursion?
{ int i,j;
 Which binding is visible in .. = j;
which part of the code? i = ..;
 For how long does a binding }
last? void bar()
{ int j;
 Binding and lifetime .. = j;
i = ..;
}
10
Overview
Study fundamental semantic issues of variables:
 Attributes of variables (Sec. 5.1, 5.2, 5.3)
 Name, value, type, address, lifetime, scope
 Binding of variables (Sec. 5.4)
 Storage Binding
 Scope and lifetime (Sec. 5.5, 5.6)
 Referencing environments (Sec. 5.7)
 Named constants (Sec. 5.8)

11
The Concept of Binding
 Binding: an association, e.g. between a variable
and its storage or its type
 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 FORTRAN 77 variable to a memory
cell (or a C static variable)
 Runtime: bind a local variable to a memory in stack

12
Static and Dynamic Binding
 A binding is static if it first occurs before run
time and remains unchanged throughout
program execution
 A binding is dynamic if it first occurs during
execution or can change during execution
int i,a[100];

void foo()
{ int i,j;
.. = j;
i = ..;
}
13
Storage Bindings and Lifetime
 Storage binding:
 Allocation: get a cell from some pool of available cells
 Deallocation: put a cell back into the pool
 The lifetime of a variable is the time during
which it is bound to a particular memory cell
 Starts when a variable is bound to a specific cell and
ends when it is unbound
 Four categories for scalar variables according to
lifetimes: static, stack-dynamic, explicit-heap-
dynamic, implicit heap-dynamic

14
Static Variables
 Bound to memory cells before execution begins
and remains throughout execution, e.g., all
FORTRAN 77, C static and global variables
 Advantages:
 Efficiency (direct addressing, no runtime allocation
overhead), for globally accessible variables, history-
sensitive subprogram support
 Disadvantage:
 Lack of flexibility (no recursion), no sharing of storage
among variables
 Size of data objects must be known at compile time
 Data structures cannot be created dynamically

15
Static Memory Model Cannot
Support Recursion

16
Stack-dynamic Variables
 Storage bindings are created when declaration
statements are elaborated at runtime
 If scalar, all attributes except address are statically
bound, e.g., local variables in C subprograms and Java
methods, allocated from the runtime stack
 Advantage:
 Allows recursion; conserves storage by all subprog.
 Disadvantages:
 Overhead of allocation and deallocation
 Subprograms cannot be history sensitive
 Inefficient references (indirect addressing)

17
Stack-dynamic Variables

18
Explicit Heap-dynamic Variables
 Heap: a section of virtual address space
reserved for dynamic memory allocation
 Allocated and deallocated (in heap) by explicit
directives or operators, specified by the
programmer, which take effect during execution
 Referenced through pointers or references, e.g.
dynamic objects in C++ (via new and delete)
 Static type binding, dynamic storage binding
 Explicit or implicit deallocation (garbage collection)

19
Explicit Heap-dynamic Variables
Person *p;
p=(Person *) malloc(sizeof Person);
p->name = “Mike”; p->age = 40;
free(p);
 Java objects are explicit heap-dynamic variable
 implicit garbage collection (no free or delete)
 Advantage: can construct dynamic structures
 Disadvantage: inefficient, unreliable, heap
management cost

20
Explicit Heap-dynamic Variables

1-21
21
Implicit Heap-dynamic Variables
 Allocation and deallocation caused by
assignment statements, regardless of what the
variable was previously used for
 All variables in APL; all strings and arrays in Perl and
JavaScript
 Advantage: flexibility
 Disadvantages:
 Runtime overhead for maintaining dynamic attributes
 Loss of error detection by compiler

22
Overview
Study fundamental semantic issues of variables:
 Attributes of variables (Sec. 5.1, 5.2, 5.3)
 Binding of variables (Sec. 5.4)
 Scope and lifetime (Sec. 5.5, 5.6)
 Referencing environments (Sec. 5.7)
 Named constants (Sec. 5.8)

23
Why Scope?
 Given multiple bindings of a single name, how
do we know which binding does an occurrence
of this name refer to?

24
Scope
 The scope of a variable is the range of
statements over which it is visible
 A variable is visible in a statement if it can be
referenced in that statement
 The nonlocal variables of a program unit are
those that are visible but not declared there
 The scope rules of a language determine how a
reference to a name is associated with a
variable and its declaration

25
Scope
 Scope of a binding (declaration)
 The region of the program over which the binding is
maintained

26
Static Scope
 Scope of a variable can be statically determined
 Based on program text, a spatial concept
 To connect a name reference to a variable, you
(or the compiler) must find the declaration
 First search locally, then in increasingly larger
enclosing scopes, until one is found for the given
name, or an undeclared variable error

27
Static Scope
 Variables can be hidden from a unit by having a
"closer" variable with the same name
 C++ and Ada allow access to "hidden" variables:
unit.name (in Ada)
class_name::name (in C++)
 Block: a method of creating new static scopes
inside program units (from ALGOL 60)
 e.g.: C and C++ in any compound statement
for (...) {
int index;
...
}
28
An Example of Block Scope in C

29
Dynamic Scope
 Based on calling sequences of program units,
not their textual layout (temporal versus spatial)
 Can only be determined at run time
 References to variables are connected to
declarations by searching back through the
chain of subprogram calls that forced execution
to this point

30
Scope Example
MAIN
- declaration of x
SUB1 MAIN calls SUB1
- declaration of x
...
SUB1 calls SUB2
call SUB2 SUB2 uses x
...

SUB2 Static scoping:

31
Static vs. Dynamic Scoping

32
Evaluation of Dynamic Scope
 Advantage:
 Convenience (no need to pass parameters from caller
to callee)
 Disadvantage:
 Local variables of an active subprogram are visible to
any other active subprograms  reliability
 Cannot statically type check references to nonlocals
 Poor readability
 Longer accesses to nonlocal variables

33
Scope and Lifetime
 Scope and lifetime are sometimes closely related,
but are different concepts
 Ex.: a static variable in a C or C++ function
 Scope is static and local to the function
 Lifetime extends over entire execution of program
 Ex.: subprogram calls
void printheader() { … }
void compute() {
int sum; … //scope vs lifetime of sum
printheader();
}
34
Overview
Study fundamental semantic issues of variables:
 Attributes of variables (Sec. 5.1, 5.2, 5.3)
 Binding of variables (Sec. 5.4)
 Type (Sec. 5.5, 5.6, 5.7)
 Scope and lifetime (Sec. 5.8, 5.9)
 Referencing environments (Sec. 5.10)
 Named constants (Sec. 5.11)

35
Referencing Environments
 Referencing environment of a statement is the
collection of all names visible to the statement
 In a static-scoped language, it is the local
variables plus all of the visible variables in all of
the enclosing scopes
 In a dynamic-scoped language, the referencing
environment is the local variables plus all visible
variables in all active subprograms
 A subprogram is active if its execution has begun but
has not yet terminated

36
Referencing Environments

37
Named Constants
 A named constant is a variable that is bound to a
value only once, when it is bound to storage
 Advantages: readability, modifiability, can be used to
parameterize programs
 Binding of values to named constants can be
static (called manifest constants) or dynamic
 FORTRAN 90: only constant-valued expressions
 Ada, C++, Java: expressions of any kind
 The binding of a variable to a value at the time it
is bound to storage is called initialization
 Often done on declaration statement

38
Summary
 Variables are abstractions for memory cells of
the computer and are characterized by name,
address, value, type, lifetime, scope
 Binding is the association of attributes with
program entities: type and storage binding
 Scope determines the visibility of variables in a
statement

39