0% found this document useful (0 votes)

40 views

Lec 06

Uploaded by

Lilian Voss

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

40 views

Lec 06

Uploaded by

Lilian Voss

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 42

Lecture 06

Names, Bindings, and Scopes

Topics

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

Copyright © 2015 Pearson. All rights reserved. 1-2

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. 1-3

Variables

• A variable is an abstraction of a memory cell

• Variables can be characterized with 6
attributes:
– Name
– Address
– Value
– Type
– Lifetime
– Scope

Copyright © 2015 Pearson. All rights reserved. 1-4

Variables Attributes
• Name – string of characters used to identify some
entity in a program. 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. 1-5
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

• Lifetime of a variable is the time during which it is bound to a

particular memory cell

• Scope of a variable is the range of statements over which it is

visible

Copyright © 2015 Pearson. All rights reserved. 1-6

Names

• Design issues for names:

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

• Length
- Mostly format: a letter followed by a string consists
of letters, digits, and underscore characters ( _ )
– If too short, they cannot be connotative
– Language examples:
• C# and Java: no limit, and all are significant
• C++: no limit, but implementers often impose one

Copyright © 2015 Pearson. All rights reserved. 1-7

Names (continued)

• Special characters
– PHP: all variable names must begin with dollar
signs ($)

– Perl: all variable names begin with special

characters ($, @ or %), which specify the
variable’s type

– Ruby: variable names that begin with @ are

instance variables; those that begin with @@ are
class variables

Copyright © 2015 Pearson. All rights reserved. 1-8

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. 1-9

Names (continued)
In most languages, special words
are reserved words, which means
they cannot be redefined by
programmers, but in some they
are only keywords, which means
• Special words they can be redefined.

– 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
– E.g.: In Fortran, the word Integer at the beginning of a
statement and followed by a name, is considered a keyword
that declare the statement.
If the word Integer is followed by the assignment operator, it
is a variable name
Integer Apple
Integer = 4
Copyright © 2015 Pearson. All rights reserved. 1-10
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. 1-11

Processes in Binding Times
• Language design time -- bind operator symbols to
operations (symbol * is bound to multiplication)

• 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

• Link time -- multiple object codes (machine code

files) and libraries are combined into one executable

• Runtime -- bind a nonstatic local variable to a

memory cell

Copyright © 2015 Pearson. All rights reserved. 1-12

Examples of Binding Times

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 © 2015 Pearson. All rights reserved. 1-14

Static 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. 1-15

Explicit/Implicit Declaration (Static)
• 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)
– Eg: If a name begins with @, it is an array in Perl

Copyright © 2015 Pearson. All rights reserved. 1-16

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
var sum = 0;
var total = 0.0;
var name = "Fred";
The types of sum, total, and name are int, float, and
string, respectively

– 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. 1-17
Dynamic Type Binding
• Usually implemented using pure interpreters rather
than compilers (JavaScript, Python, Ruby, PHP, and
C# (limited))

• Specified through an assignment statement

e.g., C# use dynamic reserved word in declaration
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. 1-18
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

Copyright © 2015 Pearson. All rights reserved. 1-19

Storage Binding & Lifetime

1-20
Storage Binding
• 4 categories: static, stack-dynamic, explicit heap-
dynamic, and implicit heap-dynamic.

• 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 (cannot support
recursive functions, cannot be shared among
variables)
Copyright © 2015 Pearson. All rights reserved. 1-21
Categories of Variables by Lifetimes
• Stack-dynamic--Storage bindings are created for
variables when their declaration statements are
elaborated (occurs during run time).
• In Java, C++ and C#, variables defined in function are by
default stack dynamic

• Advantage - allows recursion

- conserves storage
(All subprograms share the same memory space for their local variables)
• Disadvantages:
– Overhead of allocation and deallocation
– Subprograms cannot be history sensitive
– Slower references (indirect addressing)
Copyright © 2015 Pearson. All rights reserved. 1-22
Categories of Variables by Lifetimes
• Explicit heap-dynamic -- Allocated and
deallocated by explicit directives, specified by the
programmer, which take effect during execution
(nameless (abstract) memory cells that are allocated and deallocated by
explicit run-time instructions written by the programmer)

• Referenced only through pointers or references (C++)

int *intnode; // Create a pointer
intnode = new int; // Create the heap-dynamic variable
. . .
delete intnode; // Deallocate the heap-dynamic variable

• Advantage: provides for dynamic storage management

• Disadvantage: difficulty of using pointer and reference
variables correctly, costly & complicated
Copyright © 2015 Pearson. All rights reserved. 1-23
Categories of Variables by Lifetimes

• Implicit heap-dynamic - Allocation and

deallocation caused by assignment statements
– all strings and arrays in Perl, JavaScript, and PHP
highs = [74, 84, 86, 90, 71];
Regardless of whether the variable named highs (JavaScript) was
previously used in the program or what it was used for, it is now an
array of five numeric values.

• Advantage: flexibility (generic code)

• Disadvantages:
– Inefficient, because all attributes are dynamic
– Loss of error detection
Copyright © 2015 Pearson. All rights reserved. 1-24
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. 1-25

Blocks

– Block: section of code to have its own local

variables whose scope is minimized
– Example in C:
void sub() {
int count;
while (...) {
int count;
count++; define new scope
...
}
…
}

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

and C# - too error-prone

Copyright © 2015 Pearson. 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 © 2015 Pearson. 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

void fun() {
. . .
for (int count = 0; count < 10; count++){
. . .
}
.
}

Copyright © 2015 Pearson. All rights reserved. 1-28

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. 1-29
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. 1-30
Global Scope (continued)

$day = "Monday";
$month = "January";
function calendar() {
$day = "Tuesday";
global $month;
print "local day is $day <br />";
$gday = $GLOBALS['day'];
print "global day is $gday <br \>";
print "global month is $month <br />";
}
calendar();

Interpretation of this code produces the following:

local day is Tuesday
global day is Monday
global month is January

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)

Static Scoping
• Variables can be hidden from a unit by having a
"closer" variable with the same name (e.g.: JavaScript)
function big() {
function sub1() {
var x = 7;
sub2();
}
function sub2() {
var y = x;
}
var x = 3;
sub1();
}
reference to the variable x in sub2 is to the x declared in the procedure big.
This is true because the search for x begins in the procedure in which the
reference occurs, sub2, but no declaration for x is found there.
The search continues in the static parent of sub2, big, where the declaration of
x is found. The x declared in sub1 is ignored, because it is not in the static
ancestry of sub2.

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

Dynamic Scope

• Dynamic scoping is based on the calling sequence

of subprograms, not on their spatial relationship
to each other. Thus, the scope can be determined
only at run time.

• 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

Scope Example
function big() {
big calls sub1 big
big function sub1()
var x = 7; sub1 calls sub2
sub2 uses x
function sub2() { sub1
var y = x;
sub1 sub2 }
var x = 3; sub2
}
– Static scoping
• Reference to x in sub2 is to big's x = 3
1) Search for x begins in sub2, but no declaration for x is found.
2) Search static parent of sub2, big  declaration of x is found. X in sub1 is
ignored, because it is not in the static ancestry of sub2

– Dynamic scoping
• Reference to x in sub2 is to sub1's x = 7
1) Search for x begins in sub2, but no declaration for x is found.
2) Search dynamic parent / calling function of sub2, sub1  x is found.

Scope Example

• 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

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 */
The scope of the variable 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. However,
the lifetime of sum extends over the time during which printheader executes.
Whatever storage location sum is bound to before the call to printheader,
that binding will continue during and after the execution of printheader 1-38
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

Referencing Environments (Dynamic Scope)

void sub1() {
int a, b;
. . . 1
} /* end of sub1 */
void sub2() {
int b, c;
.. . . 2
sub1();
} /* end of sub2 */
void main() {
int c, d;
. . . 3
sub2();
} /* end of main */

Point Referencing Environment

1 a and b of sub1, c of sub2, d of main, (c of main
and b of sub2 are hidden)
2 b and c of sub2, d of main, (c of main is hidden)
3 c and d of main

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

Named Constants
• Java
void example() {
final int len = 100;
int[] intList = new int[len];
}

• C++
const int result = 2 * width + 1;