Scopes Names, and Bindings
1
Names
Kinds of names
Binding associates a names with an object A Name is an abstraction of an object
Variables, functions, classes, types, labels, blocks, operators, tasks, etc.
Name Spaces
Classes are type abstractions Variables are data abstractions Subroutines are control abstractions
separate lists of names, struct ids in C
2
Binding
Binding Times
Language Design time Compile Time
Keywords Builtin Types
Load Time
Binding variables to locations in memory Static linking Interpreted Languages e.g., Smalltalk Dynamic linking Polymorphism
Run Time
Late binding => flexibility Early binding => safety
3
Object Lifetime
A short biography of an Object
Storage Allocation Mechanisms
Creation of Object instantiation Creation of Names declaration Binding Name and Object Destruction of Bindings Destruction of Objects
Static objects exist throughout execution of program Heap objects explicitly created
Constants, global values, static members in C static keyword overloaded, multiple meanings Garbage collected or explicitly deleted
Stack objects exist within a block
4
Function Calls
Stack Allocation
Compiler determines size of stack frame
Stack allocation for declarations in block statements Advantages of Stack Allocation
Stack frame pushed onto stack when function is called at run time Stack frame popped off stack when function returns
Prologue and Epilog Parameters Local Variables Temporary (compiler generated) variables Bookkeeping information
Allocation is automatic Reentrant allows for recursive calls Space & Time efficient Guarantees no side effects
5
Heap Allocation
Heap is random access memory
Allocation must be explicit
Sequentially addressed memory Requires Memory Management System malloc() in C; new in C++ & Java Can be expensive Deallocation can be explicit or Garbage Collected Memory leaks Memory fragmentation Dangling references
Susceptible to Problems
6
Scope
Scope is the region over which a binding is active Examples:
Static (Lexical) scope Binding at compile time Dynamic scope Binding at runtime
7
Function Scope labels Block (Local) Scope File Scope in C & C++ Package Scope in Java Class Scope
Static Scope
Most common:
Binding determined by (lexical) structure of program
C, C++, Java, etc.
void Foo (char x) { char c = `a'; Fum (x); } void Fum(char y) { c = y; Error }
8
Nested Subroutines
Supported in Pascal, Ada, ML Useful for "helper" functions function m return Integer is {
x is Integer; function sub1 return Integer is {
} Requires a static chain of pointers or a display to keep track of environments on the stack
9
} sub1(); return x;
x := 1
Static Chains
A() { B() { C() {} D() {} } E() {} } Nested Calls:
C D B E A
10
A, E, B, D, C
Dynamic Scope
Scope determined at runtime
A variable local to a calling function will be available in the called function. Requires dynamic chain of pointers to keep track of calling environments
APL, Snobol, Perl
11
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.
a : integer global declaration procedure first a := 1 procedure second a: integer first() a := 2 if read_integer() > 0 second() else first() write_integer(a) What is the result under Static Scope? What is the result under Dynamic Scope?
Static vs Dynamic Scope
12
Visibility
A Binding may be temporarily hidden by a more local binding. Linkage names must be exported to be visible Hidden declarations may be referenced using a qualified name int x = 0; int y = Super.x;
13
Name Overloading
Same name used for more than one distinct function Builtin operators
Function (or operator) names resolved using actual argument types
Example: 1.0 + 2.0 and 1 + 2
Name Mangling in C++
14
Access Control
Declaration is in scope and not hidden, but access is controlled Applies to class members
Private only accessible in this class Public available access throughout scope Protected accessible in this class and its subclasses Package accessible in all classes in package
15
Type Checking
16
What's in a Type
A type is (possibly infinite) set of values and the set of valid operations on those values
A Type System is a set of formal rules that defines a type, including rules for
Integer infinite set of discrete values and operators, e.g., succ(), pred(), +, , *, /, etc.
Constructing a new instance of the type Determining type equivalence between values Determining type compatibility between values Defining and applying operators
17
Type Declaration
Not all languages require explicit type delcaration:
Type implicit in name
Type inferred from context
Perl: $ => scalar, @ => array Basic: $ => string x + 1.0;
Type associated with values, rather than names
Explicit declaration may not be necessary, but:
x := "abc"; x := 2.0; x + 1.0;
Makes program easier to understand Avoids common errors such as misspelling an identifier
18
Type Declaration (2)
What does a type declaration do?
a is array (1..10) of Integer Defines set of valid operations on a Defines set of valid operations on elements of a Establishes size of a in memory Registers a in symbol table Determines scope of a May allocate storage and bind name to object
19
*1st, 2nd & 3rd Class values
First class values
Second class values
Can be passed as parameters Can be stored in variables Cannot be passed as parameters Can be stored in variables Cannot be passed as parameters Cannot be stored in variables
20
Third class values
Type Checking
Use of incompatible types is called a "type clash" Statically typed:
Example: a is Array (1..10) of Integer; a[20] := `a';
Dynamically typed
Type errors detectable at compile time Most Algolstyle languages Type errors detected at runtime Scheme, Smalltalk
Static typing is preferable but not always possible
21
Strong vs Weak Typing
Strongly typed Languages
Weakly typed languages
Type rules strictly enforced at compile time Ada, Java Possibly unsafe type conversion permitted Assembly, C Structural vs. Name equivalence Coercion Promotion Polymorphism
Type Equivalence of composite types
Type Compatibility
22
*Type Semantics
Denotational Semantics
Constructive
A type is a set of values Operations are values of type ...