ICS 141 Klefstad

Names, Types, Bindings, and Scoping

Outline Variables and Their Attributes The Concept of Binding Type Checking Strong Typing Type Compatibility Scope Life-time Referencing Environments Named Constants Variable Initialization

The Concept of Binding

central to understanding the semantics of programming languages
program entities are:
- types, variables, subprograms, statements, ...
properties of these entities are called attributes
assigning meaning to an attribute is called binding
bindings for an entity are stored in a repository called a descriptor

binding time is when this takes place
- static - before run-time
- dynamic - at run-time & may change at run-time
languages with dynamic binding are interpretation oriented
languages with static binding are translation oriented

Variables

von Neumann machines have memory of the form:
```
Address: Value
```
variables are an abstraction of this memory
variables have several attributes:
- name
- scope
- life-time
- value
- type

Name

often called Identifiers
used to identify most programming language entities
may be case sensitive or insensitive
may allow underscores or other special characters
may or may not have a maximum length

keywords special names that have language meaning
- eg Algol: if if then then else else
reserverd keywords that may not be used as identifiers
- can't have a variable named if

Scope

range of instructions over which a variable is accessible
may be global, local, or non-local
dynamic scoping
- scope is defined in terms of program execution
- e.g., Apl, Lisp, Snobol
- a variables scope is in effect until a new declaration of same name is encountered
- easy to implement
- e.g., Lisp
static scoping
- scope is defined in terms of lexical structure of a program
- e.g. C++, Algol, Ada, etc.
- usually more efficient
- variable referred to is known before run-time

Life-time

the interval of time storage area (for value) is bound to a variable
this area of storage is called a data object
acquiring a storage area is called allocation
- static allocation - performed before run-time
- semi-static allocation - at run-time in the AR
- semi-dynamic allocation - at run-time above the AR
- dynamic allocation - at run-time in the heap

Value

usually a binary value
interpreted according to a variables type
e.g.,
```
integer, character, pointer
```
dynamic value - means it can change at run-time
static value - can't change - i.e., constant

Type

specifies a class of values & operations to create, access, & modify
languages usually include some predefined types
- e.g., boolean, integer, floating point, character
- with respective operations

often allow programmers to define new types

e.g.,

class Stack
{
  int top;
  int values[100];
public:

...

};

there are two sorts of type bindings:
- static type binding
  - bound at translation time
  - more efficient - need not check types at run-time
  - e.g., Ada, Pascal, Algol, Fortran, Cobol, ...
- dynamic type binding
  - e.g., Apl, Lisp, Snobol
  - descriptors around at run-time
  - requires dynamic type checking and operator resolution

Type Checking

used to check for consistent usage
also used to resolve operators
type conversion may be done
- implicitly - automatically when needed
- explicitly - only when asked for by programmer

Strong Typing

means all type errors will be detected
may mean all type checking can be done at compile time
but also includes consistent dynamic typing in Object-oriented languages

Type Compatibility

examples

typedef float celsius;
typedef float fahrenheight;
struct Stack {
  int top;
  int values[100];
};
struct Vector {
  int index;
  int values[100];
};
celsius a, b, c;
fahrenheight d, e, f;
Vector m, n, o;
Stack r, s, t;

name equivalence
- types are equivalent if they have the same name
structureally equivalence
- types are equivalent if they have the same name
- or if they have the same constructors for equivalent types

Referencing Environments and Activation Records (AR)

local environment
```
variables in U's AR
```
global environment
```
variables in other units' ARs
```

aliases

two (or more) names denoting the same data object

side effect
```
modification of a global data object
```

recursive activation

unit activates itself either directly or indirectly
each activation has a new AR
binding of AR to code is  dynamic

return point
- pointer to caller's code segment upon return
dynamic link
- pointer to caller's AR
static link
- pointer to AR of lexically enclosing unit
- global variables are accessed by traversing this

Named Constants

literal constant - e.g., 10, 'A', 3.14159
symbolic constant - named constant
- e.g., const float TwoN = 2 * N;
manifest constants those initialized to static expressions
- e.g., const float PI = 3.14159;
- e.g., const float TwoPI = 2 * PI;
proper use greatly enhances modifibility of a program

Variable Initialization

initialization is binding a value at storage binding time
typically done dynamically
may be done statically for static variables
```
static int bufsize = 100;
```