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

2. Chapter 5 Topics Introduction Names Variables The Concept of Binding
Type Checking
Strong Typing
Type Compatibility
Scope and Lifetime
Referencing Environments
Named Constants
Copyright © 2006 Addison-Wesley. All rights reserved.

3. Introduction
Imperative languages are abstractions of von Neumann architecture
Memory (instructions & data)
Processor
Variables characterized by attributes
Type (Ch 6): to design, must consider scope, lifetime, type checking, initialization, and type compatibility
Copyright © 2006 Addison-Wesley. All rights reserved.

4. Names Design issues for names/identifiers:
used with variables, subprograms, parameters, other constructs
Maximum length?
Are names case sensitive?
Are special words reserved words or keywords?
Copyright © 2006 Addison-Wesley. All rights reserved.

5. Names (continued) Length
Tradeoffs: Name should be connotative, but want reasonable length for symbol table
I think 1 character is long enough for a variable name
What in the world does L stand for?
FORTRAN I: maximum 6
COBOL: maximum 30
FORTRAN 90 and ANSI C: maximum 31
Ada and Java: no limit, and all are significant
C++: no limit, but implementers often impose one
Copyright © 2006 Addison-Wesley. All rights reserved.

6. Names (continued) Case sensitivity Disadvantage: readability
names that look alike are different
worse in C++ and Java because predefined names are mixed case (e.g. IndexOutOfBoundsException)
C, C++, and Java names are case sensitive
The names in many other languages are not
“Camel” notation – myItem - embedded uppercase – is a style choice, not a language decision, although if predefined methods/classes use camel style it's forced on users.
Copyright © 2006 Addison-Wesley. All rights reserved.

7. 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, e.g., in Fortran
Real VarName (Real is a data type followed with a name, therefore Real is a keyword)
Real = 3.4 (Real is a variable)
A reserved word is a special word that cannot be used as a user-defined name. Generally less confusing.
Copyright © 2006 Addison-Wesley. All rights reserved.

8. 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 © 2006 Addison-Wesley. All rights reserved.

9. Variables Attributes Name - not all variables have them
Address - the memory address with which it is associated
Sometimes called the l-value
A variable may have different addresses at different times during execution
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 (ch 6)
Aliases are harmful to readability (program readers must remember all of them)
Copyright © 2006 Addison-Wesley. All rights reserved.

10. 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 (r-value)
Abstract memory cell - the physical cell or collection of cells associated with a variable
Copyright © 2006 Addison-Wesley. All rights reserved.

11. The Concept of Binding
A binding is an association, such as between an attribute and an entity (e.g., type of a variable), or between an operation and a symbol (e.g., meaning of *), or a function and its definition
Binding time is the time at which a binding takes place.
Copyright © 2006 Addison-Wesley. All rights reserved.

12. Possible Binding Times
Language design time -- bind operator symbols (e.g., *) to operations
Language implementation time-- bind floating point type to a representation
Compile time -- bind a variable to a type
Link time – bind library subprogram to code
Load time -- bind a FORTRAN 77 variable to a memory cell (or a C static variable)
Runtime -- bind a nonstatic local variable to a memory cell
Copyright © 2006 Addison-Wesley. All rights reserved.

13. Binding Example count = count + 5;
type of count is bound at compile time
possible values bound at language/compiler design time
meaning of + bound at compile time, when types of operands determined (also at language design time)
internal representation of 5 bound at compiler design time
value bound at execution time
Copyright © 2006 Addison-Wesley. All rights reserved.

14. 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 of the program
NOTE: doesn't consider paging etc. which is at the hardware level
Copyright © 2006 Addison-Wesley. All rights reserved.

15. 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 © 2006 Addison-Wesley. All rights reserved.

16. Explicit/Implicit Declaration
An explicit declaration is a program statement used for declaring the types of variables: int count;
An implicit declaration is a default mechanism for specifying types of variables (the first appearance of the variable in the program)
Both create static bindings to types
FORTRAN, PL/I, BASIC, and Perl provide implicit declarations
Advantage: writability
Disadvantage: reliability
Copyright © 2006 Addison-Wesley. All rights reserved.

17. Perl Begin with $ is scalar (string or numeric) Begin with @ is array
Begin with % is hash
Different namespaces
Advantage: can tell from name what type of data it is
Contrast Fortran: first initial gave data type for implicit, but could have explicit which didn't follow convention
Copyright © 2006 Addison-Wesley. All rights reserved.

18. Dynamic Type Binding
Type not specified by declaration, not determined by name (JavaScript and PHP)
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 requires run-time descriptors, normally interpreted)
Type error detection by the compiler is difficult
Copyright © 2006 Addison-Wesley. All rights reserved.

19. Dynamic Type Example i = x; // desired
i = y; // typed accidentally, y is array
Later uses of i expect a scalar, but it is now an array so incorrect results occur. With static binding, i = y; would generate an error, easier to find problem.
Copyright © 2006 Addison-Wesley. All rights reserved.

20. Other forms of Typing Type Inferencing (ML, Miranda, and Haskell)
Rather than by assignment statement, types are determined from the context of the reference
fun circumf(r) = * r * r;
infers a real result from constant in expression
fun times10(x) = 10 * x;
infers int result
fun square(x : real) = x * x;
infers real from parameter
Copyright © 2006 Addison-Wesley. All rights reserved.

21. Time to Explore Begin the first exercise in Perl….
Copyright © 2006 Addison-Wesley. All rights reserved.

22. Variable Attributes - Lifetime
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
Heap
allocate
Var
lifetime
deallocate
Copyright © 2006 Addison-Wesley. All rights reserved.

23. 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., all FORTRAN 77 variables, C static variables (not C++ class variables)
Advantages: efficiency (direct addressing), history-sensitive subprogram support
Disadvantage: lack of flexibility (no recursion), storage can't be shared among subprograms
Copyright © 2006 Addison-Wesley. All rights reserved.

24. Categories of Variables by Lifetimes
Stack-dynamic--Storage bindings are created for variables when their declaration statements are elaborated (i.e., when execution reaches code)
Stack-dynamic variables are allocated from the run-time stack
Variables may be allocated at the beginning of a method, even though declarations may be spread throughout (i.e., storage binding occurs before variable is visible)
Advantage: allows recursion; conserves storage
Disadvantages:
Overhead of allocation and deallocation (not too bad, since all memory allocated/deallocated together)
Subprograms cannot be history sensitive
Inefficient references (indirect addressing)
Copyright © 2006 Addison-Wesley. All rights reserved.

25. 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
C# methods that define a pointer must include reserved word unsafe
Copyright © 2006 Addison-Wesley. All rights reserved.

26. 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 and JavaScript
Advantage: flexibility
Disadvantages:
Inefficient, because all attributes are dynamic
Loss of error detection
Copyright © 2006 Addison-Wesley. All rights reserved.

27. Type Checking
Type checking is the activity of ensuring that the operands of an operator are of compatible types
A compatible type is one that is either:
legal for the operator
allowed under language rules to be implicitly converted, by compiler- generated code, to a legal type
This automatic conversion is called a coercion.
A type error is the application of an operator to an operand of an inappropriate type
Copyright © 2006 Addison-Wesley. All rights reserved.

28. Type Checking (continued)
Concept of type checking can be generalized to include:
subprograms (e.g., operands are parameters)
assignment
If all type bindings are static, nearly all type checking can be static
If type bindings are dynamic, type checking must be dynamic
A programming language is strongly typed if type errors are always detected (even memory cells that can hold various types)
Copyright © 2006 Addison-Wesley. All rights reserved.

29. Strong Typing
Advantage of strong typing: allows the detection of the misuses of variables that result in type errors
Language examples:
FORTRAN 77 is not: parameters, EQUIVALENCE
Pascal is not: variant records
C and C++ are not: unions are not type checked
Ada is, almost (UNCHECKED CONVERSION is loophole, doesn't actually “convert” just uses bits as new type) (Java and C# are similar)
Copyright © 2006 Addison-Wesley. All rights reserved.

30. Strong Typing (continued)
Coercion rules strongly affect strong typing--they can weaken it considerably (C++ has a lot of coercion, versus Ada with very little)
Although Java has just half the assignment coercions of C++, its strong typing is still far less effective than that of Ada
Copyright © 2006 Addison-Wesley. All rights reserved.

31. Type Equivalence
For user-defined types, coercion is rare and the issue is not type compatibility but type equivalence
If two variables are equivalent then either one can have its value assigned to the other
Two approaches are name type equivalence and structure type equivalence
Are these equivalent?
Not in C: it uses
name equivalence for struct, enum & union – unless defined in different files! C++ removed different file exception.
struct date {
int month,
int day,
int year };
struct date2 {
int m,
int d,
int y};
Copyright © 2006 Addison-Wesley. All rights reserved.

32. Name Type Equivalence
Name type equivalence means the two variables have equivalent types if they are in either the same declaration or in declarations that use the same type name
double x, y; // same declaration
int count;
int size; // count & int use same type name
Easy to implement but highly restrictive:
Subranges of integer types are not compatible with integer types
Included in Ada, Algol68, Pascal
Often used as subscripts of arrays
All types must have names
Formal parameters must be the same type as their corresponding actual parameters.
what does this imply about arrays in C++?
Copyright © 2006 Addison-Wesley. All rights reserved.

33. Structure Type Equivalence
Structure type equivalence means that two variables have equivalent types if their types have identical structures
More flexible, but harder to implement
C uses structure equivalence for data types other than struct, union, and enum
Copyright © 2006 Addison-Wesley. All rights reserved.

34. Type Compatibility (continued)
Consider the problem of two structured types:
Are two record types compatible if they are structurally the same but use different field names?
Are two array types compatible if they are the same except that the subscripts are different?
(e.g. [1..10] and [0..9])
Are two enumeration types compatible if their components are spelled differently?
With structural type compatibility, you cannot differentiate between types of the same structure (e.g. different units of speed, both float)
Copyright © 2006 Addison-Wesley. All rights reserved.

35. Variable Attributes: Scope
The scope of a variable is the range of statements over which it is visible
The nonlocal variables of a program unit are those that are visible but not declared there
The scope rules of a language determine how references to names are associated with variables
Copyright © 2006 Addison-Wesley. All rights reserved.

36. 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
Copyright © 2006 Addison-Wesley. All rights reserved.

37. Static Scope Example
procedure Big is
X : Integer;
procedure Sub1 is
begin ...
end;
procedure Sub2 is
begin
..X..
begin – of Big
...
Scope of Sub1
Scope of Big
Scope of Sub2
Reference to X in Sub2 refers to X in Big. The X in Sub1 is not the static ancestor of Sub2.
C & C++ do not allow nested procedures. Nor does Java. Inner classes may accomplish some of same goals
Copyright © 2006 Addison-Wesley. All rights reserved.

38. Scope (continued)
Variables can be hidden from a unit by having a "closer" variable with the same name
int count;
while (...) {
... }
illegal in Java and C#, legal in C and C++
C++ and Ada allow access to these "hidden" variables
In Ada: unit.name
In C++: class_name::name, ::name for global
Copyright © 2006 Addison-Wesley. All rights reserved.

39. Blocks C and C++: for (...) { int index; ... }
A method of creating static scopes inside program units--from ALGOL 60
Examples:
C and C++: for (...) {
int index;
... }
Ada: declare LCL : FLOAT;
begin
end
Copyright © 2006 Addison-Wesley. All rights reserved.

40. Evaluation of Static Scoping
Assume MAIN calls A and B
A calls C and D
B calls A and E
MAIN E A C D B
Copyright © 2006 Addison-Wesley. All rights reserved.

41. Static Scope Potential Call Graph
potential calls
desired calls
MAIN
MAIN A B A B C D E C D E
What if E needs access to variables in A? Could move it. But if need access to variables in A and B, may resort to globals (or variables in main). Overall design may end up with too many globals.
What if E needs to call D? May move it to the same level as A and B.
Static scoping issues led to design of better encapsulation structures.
Copyright © 2006 Addison-Wesley. All rights reserved.

42. 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. Must be determined at runtime.
Copyright © 2006 Addison-Wesley. All rights reserved.

43. Scope Example MAIN calls SUB1 SUB1 calls SUB2 SUB2 uses x MAIN
- declaration of x
SUB1
- declaration of x -
...
call SUB2
SUB2
- reference to x -
call SUB1 …
MAIN calls SUB1
SUB1 calls SUB2
SUB2 uses x
Copyright © 2006 Addison-Wesley. All rights reserved.

44. Scope Example Static scoping Dynamic scoping
Reference to x is to MAIN's x
Dynamic scoping
Reference to x is to SUB1's x
Evaluation of Dynamic Scoping:
Advantage: convenience (fewer parameters)
Disadvantage: poor readability. No way to protect local variables from any other functions on the call stack. Slower access to non-locals.
Copyright © 2006 Addison-Wesley. All rights reserved.

45. Scope and Lifetime
Scope and lifetime are sometimes closely related, but are different concepts
Scope and lifetime for local variable in Java method with no method calls very closely related.
Consider a static variable in a C or C++ function. Lifetime is entire program execution, but scope is just that function.
Copyright © 2006 Addison-Wesley. All rights reserved.

46. 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 © 2006 Addison-Wesley. All rights reserved.

47. Referencing Environments (cont)
Referencing Environment concept is important because data structures must be created to provide access to all nonlocal variables (covered in Chapter 10)
Copyright © 2006 Addison-Wesley. All rights reserved.

48. Referencing Environments Static Example
procedure Example is
A, B : Integer; ...
procedure Sub1 is
X, Y : Integer;
begin – #1 ...
end;
procedure Sub2 is
X : Integer; ...
procedure Sub3 is
X : Integer;
begin - #2
begin - …#3
end; // Sub2
begin #4
end.
Point 1 env: X and Y of Sub1, A and B of example
Point 2 env: X of Sub3 (X of Sub2 is hidden), A and B of Example
Point 3 env: X of Sub2, A and B of Example
Point 4 env: A and B of Example
Copyright © 2006 Addison-Wesley. All rights reserved.

49. Referencing Environments Dynamic Example
void sub1() {
int a, b; #1 }
void sub2() {
int b, c; #2
sub1;
int main() {
int c, d; #3
sub2();
Assume main calls sub2, which calls sub1:
Point 1 env: a and b of sub1, c of sub2, d of main (c of main and b of sub2 hidden)
Point 2 env: b and c of sub2, d of main (c of main hidden)
Point 3 env: c and d of main
Copyright © 2006 Addison-Wesley. All rights reserved.

50. Named Constants
A named constant is a variable that is bound to a value only when it is bound to storage
Advantages: readability and maintainability
Used to parameterize programs
The binding of values to named constants can be either static (called manifest constants) or dynamic
Languages:
FORTRAN 90: constant-valued expressions
Ada, C++, and Java: expressions of any kind
Ex: const int result = 2 * width + 1;
C# has const (static) and readonly (dynamic)
Copyright © 2006 Addison-Wesley. All rights reserved.

51. Variable Initialization
The binding of a variable to a value at the time it is bound to storage is called initialization
Initialization is often done on the declaration statement, e.g., in Java
int sum = 0;
Copyright © 2006 Addison-Wesley. All rights reserved.

52. Exercise See scoping exercise
Copyright © 2006 Addison-Wesley. All rights reserved.

53. 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 © 2006 Addison-Wesley. All rights reserved.