Transcript Slide 1
Names and Bindings
Names
A name is a string of characters used to identify some entity
in a program
Several design choices are involved even in specifying
allowable names
Case sensitivity
Minimum or maximum length
Connectors
Treatment of special words
Length
If too short, names cannot be connotative
If too long, extra space required for the symbol table
Some 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++: technically no limit, but implementers often impose
one
Names continued
Most PLs have the same form for names: a letter followed by a
string of letter, digits and underscores
Underscores very popular in 1970s and 1980s to represent
spaces
Replaced in C-based languages by camel notation
Prior to Fortran90, names could contain spaces
C-based languages are case sensitive
Detriment to readability?
Writability questionable?
Special Words
Aid in readability
Used to delimit or separate statement clauses
Keyword is special only in certain contexts
Fortran is the only remaining widely used language whose
special words are keywords
Reserved words cannot be used as names
Cannot be redefined
Potentially less confusing, but too many means user has trouble
making up new ones
Predefined names are between special words and user-
defined names
Can be redefined
Variables
Abstraction of a computer memory cell or collection of cells
Made up of six attributes:
Name
Address
Value
Type
Lifetime
Scope
Address of a Variable
The machine memory address with which a variable is
associated
Can change during the course of execution
Different addresses at different times during execution
Different addresses at different locations in a program
Sometimes referred to as l-value
left-hand side of an assignment
Multiple variables can have the same address, in which case the
variables are called aliases
Hindrance to readability
Can be created in several ways
Variable Type
Determines range of values the variable can store
Determines the set of operations that are defined for values
of that type
E.g. int of Java specifies:
Range of -2147483648 to 2147483647
Arithmetic operations +, -,*, /,%
Variable Value
The contents of the memory cell or cells associated with the
variable
Abstract memory cell has the size required by the variable
with which it is associated
The value of each simple, non-structured type is considered to
occupy a single abstract memory cell
E.g. Though a floating point number may occupy 4 physical
bytes, the value is thought of as occupying a single abstract
memory cell`
R-value, since this is what is required when used on the RHS
of an assignment statement
Binding
A binding is an association
Attribute and an entity
Operation and a symbol
The time when the association takes place is the binding time
Both binding and binding time are important for semantics of
programming languages
Possible Binding Times
Language design time -- bind operator symbols to operations
Language implementation time -- bind floating point type to
a representation
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)
Runtime -- bind a nonstatic local variable to a memory cell
Java assignment example
Count = count + 5;
Type of count bound at compile time
Set of possible values bound at compiler design time
Meaning of + bound at compile time (when types of operands
have been determined)
Internal representation of literal 5 bound at compiler design time
Value of count is bound at execution time with this statement
Static vs. Dynamic Bindings
Static binding
First occurs before run time AND
Remains unchanged throughout program execution
Dynamic binding
First occurs at run time OR
Can change in the course of program execution
Type Binding
Before a variable can be referenced in a program, it must be
bound to a data type
Two questions:
When does type binding take place?
How is type specified?
Static Type Binding
Explicit declaration lists variable names and specifies that
they are a particular type
Implicit declaration associates variables with types though
default conventions
First appearance constitutes its implicit declaration
Both versions in use today
Advantage of implicit: writability
Disadvantage: reliability (though less so in Perl)
Dynamic Type Binding
Type of variable is determined when it is assigned a value
Advantage
Programming flexibility
Disadvantages
Reduced reliability
Cost
Usually implemented in languages with interpreters rather
than compilers
Type Inference
Not by assignment, but by context
E.g ML function declaration:
Fun circumf(r) = 3.14159 * r * r
Floating point (real) type inferred from the constant
Fun square(x) = x * x
Arithmetic operator * indicates numeric type, so return type and
arguments are default numeric type int
Allocation and Deallocation
Allocation
Process by which an available memory cell is taken from a
pool of available memory and bound to a variable
Deallocation
Process of placing a memory cell that has been unbound from
a variable back to the pool of available memory
Lifetime
The time during which the variable is bound to a specific
memory location
Scalar variables fall into four categories based on their
lifetimes:
Static
Stack-dynamic
Explicit heap-dynamic
Implict heap-dynamic
Static Variables
Bound to memory locations before program execution begins
Remain bound throughout the program execution
Advantages:
Efficiency through direct accessing
History sensitive subprogram support
Disadvantages
Reduced flexibility (no recursion, no shared storage)
Stack-Dynamic Variables
Storage bindings are created when their declaration statements are
elaborated, but type is dynamically bound
Elaboration refers to the storage allocations and binding process
indicated by the declaration
Occurs during run-time
If scalar, all attributes except address are statically bound
Advantages
Allows recursion, conserves storage
Disadvantages
Overhead of allocation and deallocation
Subprograms cannot be history sensitive
Inefficient references (indirect addressing)
Explicit Heap-Dynamic Variables
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
Implicit Heap-Dynamic Variables
Bound to heap storage only when they are assigned values
(i.e. assignment statements)
E.g. all strings and arrays in Perl and JavaScript
Advantage
Extremely flexible
Disadvantage
Inefficient, since all attributes are dynamic
Loss of error detection