Names, Bindings, and

Scopes

Copyright © 2009 Addison-Wesley. All rights reserved. 1-1

Lecture 3 Topics

• Introduction
• Names
• Variables
• The Concept of Binding
• Scope
• Scope and Lifetime
• Referencing Environments
• Named Constants

Copyright © 2009 Addison-Wesley. All rights reserved. 1-2

Introduction

• Imperative languages are abstractions of

von Neumann architecture
– Memory
– Processor
• Variables characterized by attributes
– To design a type, must consider scope, lifetime,
initialization, and type compatibility

Copyright © 2009 Addison-Wesley. All rights reserved. 1-3

Names

• Design issues for names:

– Are names case sensitive?
– Are they special words reserved words or
keywords?

Copyright © 2009 Addison-Wesley. All rights reserved. 1-4

Names (continued)

• Length
– If too short, they cannot be meaningful
– Language examples:
• FORTRAN 95: maximum of 31
• C99: no limit but only the first 63 are significant.
• C#, C++, Ada, and Java: no limit, and all are
significant

Copyright © 2009 Addison-Wesley. All rights reserved. 1-5

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 with @ are
instance variables; those that begin with @@ are
class variables

Copyright © 2009 Addison-Wesley. All rights reserved. 1-6

Names (continued)

• Case sensitivity
– Disadvantage: readability (names that look alike
are different)
• Names in the C-based languages are case sensitive
hence in C, names do not include upper case letters
• Worse in C++, Java, and C# because predefined
names are mixed case (e.g. parseInt)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-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
– Potential problem with reserved words: If there
are too many, many collisions occur (e.g.,
COBOL has 300 reserved words!)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-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 © 2009 Addison-Wesley. All rights reserved. 1-9

Variables Attributes

• Name - Most variables have names.

• 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++ with their unions types.
– Aliases are harmful to readability

Copyright © 2009 Addison-Wesley. All rights reserved. 1-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
- 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 © 2009 Addison-Wesley. All rights reserved. 1-11

The Concept of Binding

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.

Copyright © 2009 Addison-Wesley. All rights reserved. 1-12

Possible Binding Times

• Language design time -- bind operator

symbols to operations
• Language implementation time-- bind
data type to possible 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 non-static local
variable to a memory cell
Copyright © 2009 Addison-Wesley. All rights reserved. 1-13
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.

Copyright © 2009 Addison-Wesley. All rights reserved. 1-14

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

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)
• FORTRAN, BASIC, and Perl provide implicit
declarations (Fortran has both explicit and
implicit)
– Advantage: writability
– Disadvantage: reliability
Copyright © 2009 Addison-Wesley. All rights reserved. 1-16
Dynamic Type Binding

• Dynamic Type Binding (JavaScript and PHP)

• Specified through an assignment statement
e.g., JavaScript
list = [2, 4.33, 6, 8];
list = 17.3;
– Advantage: flexibility
– Disadvantages:
• High cost (dynamic type checking and
interpretation)
• Type error detection by the compiler is difficult

Copyright © 2009 Addison-Wesley. All rights reserved. 1-17

Variable Attributes (continued)

• Type Inferencing
– Rather than by assignment statement, types are
determined (by the compiler) from the context
of the reference
• 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 © 2009 Addison-Wesley. All rights reserved. 1-18

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
– Advantages: efficiency (direct addressing)
– Disadvantage: lack of flexibility (no recursion)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-19

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 and Java methods
• Advantage: allows recursion; conserves storage
• Disadvantages:
– Overhead of allocation and deallocation
– Subprograms cannot be history sensitive
– Inefficient references (indirect addressing)
Copyright © 2009 Addison-Wesley. All rights reserved. 1-20
 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. Example in C++
int *intnode; // Create a pointer
intnode = new int; // Create the heap-dynamic variable
...
delete intnode; // Deallocate the heap-dynamic variable
// to which intnode points

• Advantage: provides for dynamic storage

management
• Disadvantage: inefficient and unreliable
Copyright © 2009 Addison-Wesley. All rights reserved. 1-21
 Categories of Variables by Lifetimes

• Implicit heap-dynamic--Allocation and

deallocation caused by assignment
statements
– Example in JavaScript
highs = [74, 84, 86, 90, 71];
• Advantage: flexibility (generic code)
• Disadvantages:
– Inefficient, because all attributes are dynamic
– Loss of error detection

Copyright © 2009 Addison-Wesley. All rights reserved. 1-22

Variable Attributes: 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.
• Local variable is local in a program unit or
block if it is declared there.
• Non-local variable of a program unit or
block are those that are visible within the
program unit or block but are not declared
there.
Copyright © 2009 Addison-Wesley. All rights reserved. 1-23
Static Scope

• Binding names to non-local variables is called

static scoping.
• The attributes of the variable are determined by
finding the statement in which it was declared.
• 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, Fortran 2003, and PHP)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-24

Scope (continued)

• Consider the following JavaScript function,

big, in which the two functions sub1 and
sub2 are nested:
function big() {
function sub1() {
var x = 7;
sub2();
}
function sub2() {
var y = x;
}
var x = 3;
sub1();
}
Copyright © 2009 Addison-Wesley. All rights reserved. 1-25
Blocks

– A method of creating static scopes inside program

units--from ALGOL 60
– Example in C:
void sub() {
int count;
while (...) {
int count;
count++;
...
}
…
}

- Note: legal in C and C++, but not in Java

and C# - too error-prone

Copyright © 2009 Addison-Wesley. All rights reserved. 1-26

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 © 2009 Addison-Wesley. All rights reserved. 1-27

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

Copyright © 2009 Addison-Wesley. All rights reserved. 1-28

Global Scope

• C, C++, PHP, and Python support a

program structure that consists of a
sequence of function definitions
– These languages allow variable declarations to
appear outside function definitions

• C and C++have both declarations (just

attributes) and definitions (attributes and
storage)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-29

Scope Example
Big
- declaration of X
Sub1
- declaration of X -
...
call Sub2
... Big calls Sub1
Sub1 calls Sub2
Sub2 Sub2 uses X
...
- reference to X -
...

...
call Sub2
…

Copyright © 2009 Addison-Wesley. All rights reserved. 1-30

Scope Example
• Static scoping
– Reference to X is to Big's X
• Dynamic scoping
– Reference to X is to Sub1's X
• Evaluation of Dynamic Scoping:
– Advantage: convenience
– Disadvantages:
1. While a subprogram is executing, its variables are
visible to all subprograms it calls
2. Impossible to statically type check
3. Poor readability- it is not possible to statically
determine the type of a variable
Copyright © 2009 Addison-Wesley. All rights reserved. 1-31
Scope and Lifetime

• Scope and lifetime are sometimes closely

related, but are different concepts
• Consider a static variable in a C or C++
function
void printheader() {
...
} /* end of printheader */
void compute() {
int sum;
...
printheader();
} /* end of compute */

Copyright © 2009 Addison-Wesley. All rights reserved. 1-32

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 © 2009 Addison-Wesley. All rights reserved. 1-33

Named Constants

• A named constant is a variable that is bound to a

value only once.
• Advantages: readability and reliability
• 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., Java
• final int pie = 3.142;

Copyright © 2009 Addison-Wesley. All rights reserved. 1-34

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 © 2009 Addison-Wesley. All rights reserved. 1-35