5.1 Variables, Binding and Scope

5.
1 Variables, Binding and

Scope
Variables, Binding and Scope
2
• Variables
– Names and Attributes
• Initialization
• Constants
• Binding
• Type Checking
– Strong Typing
– Type Compatibility
• Scope
– Scope and Lifetime
– Referencing Environments
• Sebesta Chapter 5
Variables: Introduction
3
• Fundamental semantic issues of variables

• Imperative languages are abstractions of von Neumann
architecture
– Memory / Storage
– Processor / CPU
• Variables are characterized by attributes
• Their design must consider
– Location
– Referencing
– Scope
– Lifetime
– Type checking
– Initialization
– Type compatibility
Variable Attributes
4
• Variables -- abstraction of memory cell(s)

• Characterized by six attributes:
– Name (usually)
– Address (in memory)
– Value (if initialized)
– Type (range of values, interpretation, operations)
– Lifetime
– Scope
• Name - not all variables have them! (anonymous)
Variable Names
5
• User-defined names
• Design issues for names:
– Maximum length?
– Are connector characters allowed?
– Are names case sensitive?
– Are some words reserved words or keywords?
– ONLY UPPERCASE LETTERS ALLOWED?
Name Length
6
• If too short, they can’t explain the meaning

– readability, writability
• If too long,
– ?
• Language examples:
– FORTRAN I: maximum 6
– COBOL: maximum 30
– FORTRAN 90 and ANSI C: maximum 31
– Ada and Java: no limit, all are significant
– C++: no limit, but implementers often impose one
• What is a good maximum length?
Connectors / Non-Letter Characters 7
• Pascal _
– underscore only
• Modula-2, and FORTRAN 77
– none allowed
• Java
– $,_ (but $ is by the system used for inner classes)
• Common Lisp
– many, including *,+,-,_, …
• Advantages of having connectors?
• Disadvantages of having connectors?
Case Sensitivity in Variable Names 8
• Many languages are not case sensitive

• C, C++, and Java names are case sensitive
• Common Lisp: case sensitive (default)
– but REPL reader can map all characters to a single case,
• result not case sensitive
• Prolog: case of first character determines whether it's
constant or variable!
• Disadvantage: readability
– names that look alike are different
• C++ and Java: predefined names are mixed case
– e.g. IndexOutOfBoundsException)
• Effects on writability?
Special Words
9
• keyword
– special only in certain contexts
• Disadvantage: poor readability
• reserved word
– special word that can’t be re-used by programmer
• Aids readability
– Used to delimit or separate statement clauses
Named Constants
10
• Named constant
– variable bound to a value only when it is bound to
storage
• Advantages:
– readability and modifiability
• Used to parameterize programs
• The binding of values constants can be either
static (called manifest constants) or dynamic
– Pascal: literals only
– FORTRAN 90: constant-valued expressions
– Ada, C++, and Java: expressions of any kind
Variable Addresses
11
• Memory address associated with variable

– also called l-value
• Location may change during execution
– i.e. may have different addresses at different times
• Aliases
– variable names that refer to the same memory
location
• Aliases often reduce readability
– program readers must remember that changing value
of one variable means a change of all others
Variable Aliases
12
• Created by
– pointers
– reference variables
– C and C++ unions
– Pascal variant-records
– and by parameters!
• Original reasons for aliases are no longer valid

– memory limits forced re-use of space in FORTRAN
• Instead, use dynamic allocation

Variable Types and Values
13
• Type - determines the

– range of values
– set of operations that are defined for the variable
– interpretation of bit patterns
– for floating point, determines the precision
• Value - contents of the memory location
associated with the variable
• Abstract memory cell – (graphical)
representation of collection of cells associated
with a variable
The Concept of Binding
14
• The l-value = address

• The r-value = value
• Binding = association
– for a variable, the association of l-value to r-value
• Binding time
– time (during execution) when l-value is associated
with r-value
Variable Initialization
15
• Initialization
– the initial binding of a variable to a value
• Often done with the declaration statement

– e.g., in Java
int sum = 0;
– e.g., in Lisp
(defvar sum 0)
Possible Binding Times
16
• Language design time

– e.g., bind operator symbols to operations
• Language implementation time
– e.g., bind floating point type to a representation
• Compile time
– e.g., bind a variable to a type in C or Java
• Load time
– e.g., bind a FORTRAN 77 variable to a memory cell, or
– bind static variable in C or Java
• Runtime
– e.g., bind a non-static local variable to a memory cell
Static vs. Dynamic Binding
17
• Static
– first occurs before run time and
– remains unchanged throughout program execution
• Dynamic
– first occurs during execution, or
– can change during execution of the program.
Type Bindings
18
• How is a a variable’s type specified?
• When does the binding take place?
• If static, type specified by either

– explicit declaration or
– implicitly
Implicit vs. Explicit Declaration
19
• Explicit type declaration

– as program statement
• Implicit type declaration
– default mechanism
• at the first appearance in the program
– e.g., in FORTRAN, PL/I, BASIC, and Perl
• Type Inferencing (ML, Miranda, and Haskell)
– Type is determined from the context of the reference
• Unification (Prolog)
– Variables are unified with other variables or constants during the
resolution process
• Advantage of implicit declaration: writability
• Disadvantage: reliability (less trouble with Perl)
Dynamic Binding
20
• JavaScript, PHP, Common Lisp
• Specified through an assignment statement e.g.,

JavaScript
list = [2, 4.33, 6, 8];
list = 17.3;
• Advantage: flexibility (generic program units)

• Disadvantages:
– Speed penalty for type checking and interpretation
– Type error detection by the compiler is more difficult
Variable Lifetime
21
• Lifetime
– the time during which it is bound to a particular memory cell
• Allocation
– getting a cell from a pool of available cells
• De-allocation
– returning a cell back into the pool
Static Variables
22
• Static variables
– bound to memory cells before
program execution begins
– remain bound to same memory cells
until program execution terminates
• Example
– (defconstant foo)
– all FORTRAN 77 variables
– C static variables
• Advantages:
– efficiency (direct addressing)
– history-sensitive subprogram support
• Disadvantage:
– less flexible (no recursion)
Stack Dynamic Variables
23
• Storage bindings are created for variables when their

declaration statements are read
• If scalar, all attributes except address are statically
bound
– e.g. local variables in C subprograms and Java methods
• Advantage:
– allows recursion
– conserves storage
• Disadvantages:
– Overhead of allocation and de-allocation
– Subprograms cannot be history sensitive
– Indirect addressing (longer time)
Runtime Stack (Dynamic) 24
• Stack-dynamic
– allocation during
execution at declaration
elaboration time
Heap Variables (Dynamic) 25
• Implicit
– Automatic
• Explicit
– programmer’s
instruction
Explicit Heap-Dynamic Variables 26
• Nameless abstract memory cells (heap)

– Allocated and de-allocated by explicit directives
– Specified by the programmer,
– Takes 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 by comparison
– reliability must be shown
Implicit Heap-Dynamic Variables 27
• Bound to heap storage automatically

– Only when they are assigned values
– All attributes are bound every time they are assigned
• Allocation and de-allocation caused by assignments
– e.g. all variables in APL
– all strings and arrays in Perl an JavaScript
• Advantage:
– Flexibility
– Writability
• Disadvantages:
– Inefficient, because all attributes are dynamic
– More work to do error detection

5.1 Variables, Binding and Scope

Uploaded by

Copyright:

Available Formats

5.1 Variables, Binding and Scope

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

5.1 Variables, Binding and Scope

Uploaded by

Copyright:

Available Formats

5.

1 Variables, Binding and

• Fundamental semantic issues of variables

• Variables -- abstraction of memory cell(s)

• If too short, they can’t explain the meaning

• Many languages are not case sensitive

• Memory address associated with variable

• Original reasons for aliases are no longer valid

• Instead, use dynamic allocation

• Type - determines the

• The l-value = address

• Often done with the declaration statement

• Language design time

• How is a a variable’s type specified?

• When does the binding take place?

• If static, type specified by either

• Explicit type declaration

• JavaScript, PHP, Common Lisp

• Specified through an assignment statement e.g.,

• Advantage: flexibility (generic program units)

• Storage bindings are created for variables when their

• Nameless abstract memory cells (heap)

• Bound to heap storage automatically

You might also like