Chapter – 5: Names, Bindings, Type Checking, and ScopeIntroduction

• Imperative languages are abstractions of von Neumann architecture: Memory (stores both instructions and data); Processor (provides operations for modifying the contents of the memory).

• Variables characterized by attributes (properties), most important:– Type (fundamental concept): to design, must consider

scope, lifetime, type checking, initialization, and type compatibility.

Names (Identifier): string of characters used to identify some entity in a program. Name is a fundamental attribute of variables, labels, subprograms, formal parameters, program constructs.

• Design issues for names:– Maximum length? Are connector characters allowed?– Are names case sensitive? Are special words reserved

words or keywords?

• Length– If too short, they cannot be connotative.– Language examples: 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. Ada may impose limit on length up to 200 characters.

Impose limit in order to make the symbol table not too large, simplify maintenance.Names in most PLs have the same form: letter followed by a string of letters, digits, and underscore.

Ch5-1

• Connectors– Pascal, Modula-2, and FORTRAN 77 don't allow; Others

do• Case sensitivity

– Disadvantage: Detriment to readability (names that look alike are different)

Worse in C++ and Java because predefined names are mixed case (e.g. IndexOutOfBoundsException; parseInt)

– C, C++, and Java names are case sensitive• The names in other languages are not

• Special words (void, procedure, begin, end, if, else, int, char, etc.)– 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 (special words are keywords) Real VarName (Real is a data type followed with a name, therefore Real is a keyword), declarative statement.

Real = 3.4 (Real is a variable)[Real Apple Real=1.2] – A reserved word is a special word that cannot be used as

a user-defined name.– As a language design choice, reserved words are better

than keywords because the ability to redefine keywords can be confusing (e.g. in Fortran: Integer Real Real Integer)

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

Variables Attributes

Ch5-2

• Name - not all variables have them (e.g. of not having name Explicit heap-dynamic variables).

• Explicit heap-dynamic variables: are nameless memory cells that are allocated/deallocated (from/to) heap by explicit run-time instructions, referenced by pointer or reference variable.

Ex: C++int *intnode; //creater pointerintnode= new int; //create heap-dynamic variabledelete intnode;//deallocate heap-dynamic variable • Address - the memory address with which it is associated

– A variable may have different addresses at different times during execution (e.g. subprogram has a local variable that is allocated from run-time stack. When the subprogram is called, different calls may result in that variable having different addresses).

– A variable may have different addresses at different places in a program.

Ex:

– If two variable names can be used to access the same memory location, they are called aliases (suppose sum and total variables are aliases, any change to total also changes sum and vice versa).

– Aliases are created via pointers, reference variables, C and C++ unions. Union type: type that store different type values at different times during execution. (e.g. consider a table of constants for a compiler which is used to store constants found in a program. One field of each table entry is for the value of the constant. Suppose constants types are int, float, Boolean. It is convenient if the same location (table field), could store a value of any of 3 types. Then all constant values can be addressed in

Ch5-3

Because these two variables are independent of each other, a reference to x in sub1 is unrelated to a reference to x in sub2.

the same way, i.e. location type is union of 3 value types it can store).

– Aliases are harmful to readability (program readers must remember all of them).

• 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.

• Abstract memory cell - the physical cell or collection of cells associated with a variable (float, although may occupy 4 physical bytes, we think as it occupying a single abstract memory cell.

The Concept of Binding• The l-value of a variable is its address; the r-value of a

variable is its value. To access the r-value, the l-value must be determined 1st.

• A binding is an association, such as between an attribute and an entity, or between an operation and a symbol

• Binding time is the time at which a binding takes place.

Possible Binding Times• Language design time-- bind operator symbols to operations

(* is usually bound to multiplication operation at language design time.

• Language implementation time-- bind floating point type to a representation, bound int to a range of possible values.

• 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).• Link time-- a call to a library subprogram is bound to the

subprogram code.• Runtime -- bind a nonstatic local variable to a memory cell.

Ex: consider the C assignment statement

Ch5-4

Type of count is bound at compile time; set of possible values of count is bound at compile design time,; meaning of operator symbol (+) is bound at compiler design time after operands have been determined; internal representation of literal 5 is bound at compiler design time; the value of count is bound at execution time with this statement.

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.• Binding of a variable to a storage cell in a virtual memory

environment is complex, because the page or segment of the address space in which the cell resides may be moved in and out of memory many times during program execution. i.e. variables are bound and unbound repeatedly.

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.

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 (the first appearance of the variable in the program). Both declarations create static bindings to types.

• PL/1, FORTRAN, BASIC, and Perl provide implicit declarations– Advantage: writability

Ch5-5

– Disadvantage: reliability: because they prevent the compiler from detecting some typographical and programmers errors. (Less trouble with Perl, $, @, %).

– In Fortran, Implicit none (prevent accidentally undeclared variables)

Dynamic Type Binding• Dynamic Type Binding (JavaScript and PHP): variable type is

not specified by declaration nor spelling. But specified through an assignment statement; e.g., in JavaScript, list = [2, 4.33, 6, 8]; regardless of previous type of list. It is now 1-dimensional array of length 4. If the statement list = 17.3; is followed, list become a scalar variable.

Advantage: flexibility (generic program units: whatever type data is input will be acceptable, because variables can be bound to correct type when data assigned to them).Disadvantages: High cost (dynamic type checking done in run-time, and must use pure interpreter which takes more times); less reliable, type error detection by the compiler is difficult. Incorrect types of R.H.S of assignments are not detected as errors; rather the type of L.H.S is changed to incorrect type. (e.g. in JavaScript, suppose i, x are storing scalar numeric values, and y storing an array. Suppose instead of writing i=x; we wrote (due to keying error), i=y; no error is detected in this statement, and i is changed to an array. But later on, the uses of i will expect it to be a scalar, and correct results will be impossible.

• Type Inferencing (ML, Miranda, and Haskell)Rather than by assignment statement, types are determined from the context of the reference. e.g. in ML, types of most expressions can be determined without requiring the programmer to specify the types of the variables.

Ex: specifies a function takes real and produces real. The types are inferred from the type of the constant in the expression. Consider the function

Ch5-6

ML determine type of both (parameters and return value), from the operator *. Because it is an arithmetic operator, the type of parameters and function are assumed numeric. Default type of numeric in ML, is int. so it inferred the type is int.If square were called with real value, square(2.7), it will cause an error. We could rewrite it because ML does not allow overloaded functions, this version could not coexist with earlier int version.

• 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.

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– Advantages: efficiency (direct addressing), history-

sensitive subprogram support, i.e. having variables to retain values between separate executions of the subprogram (static bound).

– C&C++ allow including static specifier on a variable definition in a function, making the variables static.

– Disadvantage: lack of flexibility (no recursion); storage cannot be shared among variables (e.g. program has 2 subprograms, both require large arrays. suppose the two subprograms are never active at the same time. If the arrays are static, they cannot share the same storage for their arrays).

• Stack-dynamic--Storage bindings are created for variables when their declaration statements are elaborated (take place when execution reaches the code to which the declaration is

Ch5-7

attached), but whose types are statically bound. Elaboration occurs during run-time. Ex: variable declarations that appears at the beginning of a Java method are elaborated when the method is called; and the variables defined by those declarations are deallocated when the method complete its execution.

• Stack-dynamic variables are allocated from the run-time stack.• Recursive subprograms require some form of dynamic local

storage, so that each active copy of the recursive subprogram has its own version of local variables. These needs are met by stack-dynamic variables. Even if there is no recursion, having stack-dynamic local storage for subprograms make them share the same memory space for their locals.

• If scalar, all attributes except address are statically bound– local variables in C subprograms and Java methods. C#

are by default stack-dynamic. In Ada all non-heap variables in subprograms are stack-dynamic

• Advantage: allows recursion; conserves storage

• Disadvantages: – Run-time overhead of allocation and deallocation– Subprograms cannot be history sensitive– Inefficient references (indirect addressing), slower

access.

• Explicit heap-dynamic -- Allocated and deallocated by explicit directives, specified by the programmer, which take effect during execution. Heap is a collection of storage cells whose organization is highly disorganized because of the unpredictability of its use.

• An explicit heap-dynamic variable has two variables associated with it: a pointer or reference variable through which the heap-dynamic variable can access, and the heap-dynamic variable itself. Because an explicit heap-dynamic

Ch5-8

variable is bound to a type at compile, it is static binding. However, such variable is bound to storage at the time they are created, which run-time.

• e.g. dynamic objects in C++ (via new and delete), all objects in Java, are explicit heap-dynamic.

• Advantage: Explicit heap-dynamic provides for dynamic storage management: dynamic structures (linked lists, trees) that need to grow/shrink during execution, better build using pointer or reference, and explicit heap-dynamic variables.

• Disadvantage: inefficient (cost of references to the variables; complexity of storage management implementation), and unreliable (pointers).

• Implicit heap-dynamic—are names that adapt to whatever use they are asked to serve; allocation and deallocation caused by assignment statements (i.e. bound to heap storage only when they are assigned values).• all variables in APL; all strings and arrays in Perl and

JavaScript

• Advantage: flexibility (allowing highly generic code to be written)

• Disadvantages: Inefficient, because all attributes are dynamic (run-time overhead). Loss of some error detection by compiler. Have the same storage management problems as explicit heap-dynamic.

Type Checking• Generalize the concept of operands and operators to include

subprograms and assignments, i.e. we think of subprograms as operators whose operands are their parameters. The

Ch5-9

assignment symbol will be thought of as a binary operator, with its target variable and its expression being operands.

• 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, or is allowed under language rules to be implicitly converted, by compiler- generated code ( or interpreter), to a legal type– This automatic conversion is called a coercion, (int to

float).

• A type error is the application of an operator to an operand of an inappropriate type, e.g. in original version of C, if an int value was passed to a function that expected a float, a type error would occur (because C compiler did not check parameters types).

• If all bindings of variables to types are static, nearly all type checking can be static

• If type bindings are dynamic, type checking must be dynamic at run-time, is called dynamic type checking. JavaScript, PHP (dynamic binding) allows only dynamic type checking.

• It is better to detect errors at compile-time than at run-time; less costly. But static checking reduces flexibility.

• A programming language is strongly typed if type errors are always detected. This requires that the type of all operands can be determined either at compile-time or run-time.

Strong Typing• Advantage of strong typing: allows the detection of the

misuses of variables that result in type errors.

Ch5-10

• Language examples:– FORTRAN 95 is not: EQUIVALENCE of different

types, allows a variable of one type to refer to a value of a different type. Pascal and Ada are not: variant records. C and C++ are not: parameter type checking can be avoided; unions are not type checked. Ada is, almost (UNCHECKED CONVERSION is loophole).

(Java, C# is similar to Ada): nearly; types can be explicitly cast, which could result in a type error.

• Coercion rules strongly affect strong typing--they can weaken it considerably (C++ versus Ada), no casting in Ada. Ex: suppose a program had int a, b; float d; now the programmer meant to type a+b, but mistakenly typed a+d, the error would not be detected by the compiler. The value of a is coerced to float. So the strong typing is weakened by coercion.

• Although Java has just half the assignment coercions of C++, its strong typing is still far less effective than that of Ada.

Type Compatibility: Two variables being of compatible types, if either one can have its value assigned to the other. Two different types of compatibility.

Name Type Compatibility• Name type compatibility means the two variables have

compatible types if they are in either the same declaration or in declarations that use the same type name.

• Name type compatibility easy to implement but highly restrictive:– Subranges of integer types are not compatible with

integer types. e.g. , consider the following Ada code:

Ch5-11

The variables count and index would not be compatible, i.e. count not be assigned to index or vice versa.

– Formal parameters must be the same type as their corresponding actual parameters (Pascal)

Structure Type Compatibility• Structure type compatibility means that two variables have

compatible types if their types have identical structures.• More flexible, but harder to implement.• Under name type compatibility, only the two type names must

be compared to determine compatibility, while under structured type, the entire structures of the two types must be compared.

• 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)

C uses structure type compatibility for all types except struct and union. Every struct and union declaration creates a new type that is not compatible with any other. OOL (Java, C++, bring another kind of type compatibility, object compatibility and its relationship to inheritance.

Variable Attributes: Scope• The scope of a variable is the range of statements over which

it is visible, i.e. can be referenced in that statement.Ch5-12

Variables of these types considered compatible under structure type compatibility allowing to be mixed, which is not desirable.

• The nonlocal variables of a program unit are those that are visible but not declared there. A variable is local in a program unit or block if it is declared there.

• The scope rules of a language determine how references to names are associated with variables

Static Scope: the method of binding names to nonlocal variables and the scope is statically determined, i.e. prior to execution.• There are two categories of static-scoped languages: those in

which subprograms can be nested, which creates nested static scopes (Ada, JavaScript, PHP); and those in which subprograms cannot be nested (C-based languages). We focuses on languages allow nested subprograms.

• 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.

• Variables can be hidden from a unit by having a "closer" variable with the same name. Consider the following C++ method:

Ch5-13

Under static scoping, reference to x in sub1 is to x declared in Big. Why? Because search for x begins in the procedure in which the reference occurs, sub1, but no declaration is found. The search continues in static parent of sub1, Big, where the declaration is found.

• C++ and Ada allow access to these "hidden" variables:

In Ada: unit.name in procedure Big, x declared in Big can be accessed in sub1 by reference Big.x In C++: class_name::name local variable can hide global. Hidden global can be accessed using (scope operator ::), e.g. if x is a global hidden in a subprogram by local x, the global could be referenced as ::x

Blocks A method of creating static scopes inside program units--from ALGOL 60, which allows a section of code to have its own local variables whose scope, is minimized. Such variables are stack-dynamic, so they have their storage allocated when the section is entered and deallocated when the section is exited.Examples: C and C++:

for (...) { int index; ...}

Ada:

Ch5-14

The reference to count in the while loop is to that loop's local count. The count of sub is hidden from the code inside the while loop. In general, a declaration for a variable effectively hides any declaration of a variable with the same name in a large enclosing scope.

Allow any compound statement to have declarations and thus define a new scope. Compound statements are blocks.

declare LCL : FLOAT; begin ... End

Scopes created by blocks are treated like those created by subprograms. References to variables in a block that are not declared there are connected to declarations by searching enclosing scopes in order of increasing size.C++ allows variable definitions to appear anywhere in functions. When a definition appears at a position other than at the beginning of a function, but not within a block, that variable's scope is from its definition statement to the end of function. for statement of C++, Java, C#, allow variable definitions in their initialization expressions. The scope is restricted to for construct.

Evaluation of Static Scoping• Assume MAIN calls A and B

A calls C and D B calls A and E

Ch5-15

MAINMAIN

E

ACD

B

A B

C D E

In Ada, blocks are specified with declare clauses; compound statement is delimited by begin and end

C

A

MAIN MAIN

B

D E

A

C

B

ED

Static Scope Example• Suppose the specification is changed so that D must now

access some data in B

• Solutions:Put D in B (but then C can no longer call it and D cannot access A's variables).Move the data from B that D needs to MAIN (but then all procedures can access them), creates possibility of incorrect accesses. Misspelled identifier in a procedure can be taken as a reference to an identifier in some enclosing scope, instead of being detected as an error. Furthermore, suppose the variable that is moved to MAIN is named x, and x is needed by D and E. But suppose that there is a variable named x declared in A. That would hide the correct x from its original owner, D. Another problem, moving x to MAIN is harm the readability, because it is far away from its use.• Overall: static scoping often encourages many globals than

necessary. One solution to static scoping problems is encapsulation

Dynamic Scope (APL, SNOBOL4, early LISP, Perl, COMMON LISP)• Based on calling sequences of subprograms, not on their

spatial relationship to each other. Scope can be determined in run-time.

Ch5-16

• References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point

Scope Example MAIN

- declaration of x SUB1 - declaration of x - ... call SUB2 ...

SUB2 ... - reference to x - ...

... call SUB1 …

Scope Example

Ch5-17

MAIN calls SUB1SUB1 calls SUB2SUB2 uses x

• Static scoping: Reference to x is to MAIN's x• Dynamic scoping: Reference to x is to SUB1's x• Evaluation of Dynamic Scoping:– Disadvantage (Problems): Local variables of a subprogram are all visible to any other executing subprograms during the execution time span of the subprogram. There is no way to protect local variables from this accessibility. Dynamic scoping result in less reliable program compared with static scoping.

Poor readability, because the calling sequence of subprograms must be known, inorder to determine the meaning of references to non-local variables.–Advantage: Convenience: parameters pass from one subprogram to another are simply variables that are defined in the caller. None of these need to be passed in a dynamically scoped language, because they are implicitly visible in the called subprogram.

Dynamic scoping is not as widely used as static scoping. Programs in static are easier to read, more reliable and execute faster than equivalent programs in dynamic scoping language.

Scope and Lifetime• Scope and lifetime are sometimes closely related, ex: a

variable declared in a Java method that contains no method calls. The scope of such variable is from its declaration to the end of the method. While its lifetime is the period of time between entering execution stage and terminated. (Static scope spatial concept vs. lifetime temporal concept), clearly not the same but appear to be related. But sometimes are different concepts. Consider a static variable in a C or C++ function, it is statically bound to the scope of that function and also statically bound to storage. So its scope is static and local to the function, but its lifetime extends over entire execution of the program of which it is a part.

• Scope and life are unrelated when subprogram call are involved. Consider a C++ function

Ch5-18

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. • In Ada, the referencing environment of a statement includes

the local variables, plus all of the variables declared in the procedures in which the statement is nested (excluding variables in non local scopes that are hidden by declarations in nearer procedures).

• Consider the following Ada skeletal program

Ch5-19

Scope of sum is completely contained within the compute function. It does not extend to the body of the function printHeader, although printHeader executes in the midst of the execution of compute. While lifetime of sum extends over the time during which printHeader executes. Whatever location allocated to sum will stay during and after the execution of printHeader.

1

2

3

4

PointReferencing Environment1X and Y of Sub1, A and B of Example

2X of Sub3, (X of Sub2 is hidden), A and B of Example

3X of Sub2, A and B of Example

4A and B of Example

• 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 that are currently active. Some variables in active subprograms can be hidden from the referencing environment. Recent subprogram activations can have declarations for variables that hide variables with the same names in previous subprogram activations.

• Consider the following program. Assume function calls are: main calls sub2, sub2 calls sub1.

Named Constants• A named constant is a variable that is bound to a value only

when it is bound to storage (i.e. only once)• Advantages: readability, reliability, and modifiability.

Readability use pi instead of 3.14159• Used to parameterize programs. Ex: program process fixed

number of data values (100) usually uses constant (100) in different places

• Consider Java segment:

• When program need to modify the size of data, we need to find all the occurrences of (100) and change it to the needed value. On large programs, it can be tedious and error-prone. An easier and more reliable method is to use a named constant as a program parameters, as in:

Ch5-20

PointReferencing Environment1a and b of sub1, c of sub2, d of main, (c of main and b

of sub2 are hidden)2b and c of sub2, d of main, (c of main is

hidden)

3c and d of main

1

2

3

• when length must be changed; only one line must be changed.• The binding of values to named constants can be either static

(called manifest constants) or dynamic• Languages:

– Static binding of values to named constants: FORTRAN 90: allows only constant expressions to be used as the values of its named constants. These constant expressions can contain previously declared named constants, and constant values, and operators (constant-valued expressions).

– Dynamic binding: Ada, C++, and Java: allow expressions containing variables to be assigned to constants in the declarations. Ex: C++ statement declared result to be integer named constant whose value is the expression. Value of width must be visible when result is allocated and bound to its value.

– In Java, named constants are defined with final reserved word.

– C# has two kinds of named constants: const named constants, which are implicitly static, are statically bound to values. Readonly named constants, which are dynamically bound to values.

– Ada allows named constants of enumeration and structured types.

Variable Initialization• The binding of a variable to a value at the time it is bound to

storage is called initialization. If the variable is statically bound to storage, binding and initialization occur before run time. If the binding is dynamic, initialization is dynamic and initial values can be any expression.

• Initialization is often done on the declaration statement, e.g., in Java: int sum = 0;

C++:

Ch5-21