Names and Bindings

1. Namesand Bindings

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

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

4. 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?

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

6. Variables • Abstraction of a computer memory cell or collection of cells • Made up of six attributes: • Name • Address • Value • Type • Lifetime • Scope

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

8. 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 +, -,*, /,%

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

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

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

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

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

14. 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?

15. 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)

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

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

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

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

20. 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)

21. 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)

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

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