Chapter 5 Names Bindings and Scopes ISBN 0

Chapter 5 Names, Bindings, and Scopes ISBN 0 -321 -49362 -1

Chapter 5 Topics • • Introduction Names Variables The Concept of Binding Scope and Lifetime Referencing Environments Named Constants Copyright © 2015 Pearson. All rights reserved. 1 -2

Introduction • Imperative languages are abstractions of von Neumann architecture – Memory – Processor • Variables are characterized by attributes – To design a type, must consider scope, lifetime, type checking, initialization, and type compatibility Copyright © 2015 Pearson. All rights reserved. 1 -3

Names • Design issues for names: – Are names case sensitive? – Are special words reserved words or keywords? Copyright © 2015 Pearson. All rights reserved. 1 -4

Names (continued) • Length – If too short, they cannot be connotative – Language examples: • C 99: no limit but only the first 63 are significant; also, external names are limited to a maximum of 31 • C# and Java: no limit, and all are significant • C++: no limit, but implementers often impose one Copyright © 2015 Pearson. All rights reserved. 1 -5

Names (continued) • Special characters – PHP: all variable names must begin with dollar signs – Perl: all variable names begin with special characters, which specify the variable’s type – Ruby: variable names that begin with @ are instance variables; those that begin with @@ are class variables Copyright © 2015 Pearson. All rights reserved. 1 -6

Names (continued) • Case sensitivity – Disadvantage: readability (names that look alike are different) • Names in the C-based languages are case sensitive • Names in others are not • Worse in C++, Java, and C# because predefined names are mixed case (e. g. Index. Out. Of. Bounds. Exception) Copyright © 2015 Pearson. All rights reserved. 1 -7

Fortran Variable • Fortran variables – Fortran IV numbers and letters, at least 6 characters – Fortran 77 numbers and letters and “_”, at least 16 characters – must start with a letter • Up through 77, spaces in a Fortran program are ignored – IVALUE and I VAL UE are the same – using strange spacing, while acceptable, is bad practice • Fortran variables are typed • Fortran is case insensitive – ivar is the same as Ivar or Iv. Ar • Fortran variables are typed – INTEGER, REAL, DOUBLE PRECISION, COMPLEX – LOGICAL, CHARACTER (77+)

Names (continued) • Special words – An aid to readability; used to delimit or separate statement clauses - A keyword is a word that is special only in certain contexts – A reserved word is a special word that cannot be used as a user-defined name – Potential problem with reserved words: If there are too many, many collisions occur (e. g. , COBOL has 300 reserved words!) Copyright © 2015 Pearson. All rights reserved. 1 -9

Variables • A variable is an abstraction of a memory cell • Variables can be characterized as a sextuple of attributes: – – – Name Address Value Type Lifetime Scope Copyright © 2015 Pearson. All rights reserved. 1 -10

Variables Attributes • Name - not all variables have them • Address - the memory address with which it is associated – A variable may have different addresses at different times during execution – A variable may have different addresses at different places in a program – If two variable names can be used to access the same memory location, they are called aliases – Aliases are created via pointers, reference variables, C and C++ unions – Aliases are harmful to readability (program readers must remember all of them) Copyright © 2015 Pearson. All rights reserved. 1 -11

Variables Attributes (continued) • Type - determines the range of values of variables and the set of operations that are defined for values of that type; in the case of floating point, type also determines the precision • Value - the contents of the location with which the variable is associated - The l-value of a variable is its address - The r-value of a variable is its value • Abstract memory cell - the physical cell or collection of cells associated with a variable Copyright © 2015 Pearson. All rights reserved. 1 -12

l-value and r-value CSE 4102 m Information in Program can be Characterized q Environment: Maps Name to Storage Loc (l-value) q Store: Maps Location to Value it Contains (l-value to an r-value) Compile Time Environment Name Storage State Value Run Time CH 7. 13

Initial Look at Types CSE 4102 m m m What are Types? q Base Type q Inductive Types What’s a Type System? q What are the Components? q Relate to Programming Languages? What are Type Expressions q Types can be defined inductively Ø Base types (a. k. a. the terminals) Ø Inductive types (a. k. a. grammatical productions) m From: Chapters 6 and 7 of Compilers: Principles, Techniques and Tools, Aho, et al. , Addison-Wesley CH 7. 14

Base Types CSE 4102 m What are the base types ? q int q float q double q char q void q bool q error CH 7. 15

Inductive Type Definition CSE 4102 m m Purpose q Define a type in terms of other simple/smaller types Example q array q pointer q reference q Pair q structure q function q methods q classes q. . . CH 7. 16

The Notion of a Type System CSE 4102 m Token Stream m m Logical Placement of Type Checker: Parser Syntax Tree Type Syntax Checker Tree Int. Code Interm. Generator Repres. Role of Type Checker is to Verify Semantic Contexts q Incompatible Operator/Operands q Existence of Flow-of Control Info (Goto/Labels) q Uniqueness w. r. t. Variable Definition, Case Statement Labels/Ranges, etc. q Naming Checks Across Blocks (Begin/End) q Function Definition vs. Function Call Type Checking can Occur as “Side-Effect” of Parsing via a Judicious Use of Attribute Grammars! CH 7. 17

The Notion of a Type System CSE 4102 m Type System/Checker Based on: q Syntactic Language Construct q The Notion of Types q Rules for Assigning Types to Language Constructs q Strength of Type Checking (Strong vs. Weak) Ø Strong vs. Weak Ø Dynamic vs. Static Ø OOPLS Offer Many Variants m All Expression in Language MUST have Associated Type q Basic (int, real, char, etc. ) q Constructed (from basic and constructed types) CH 7. 18

The Concept of Binding A binding is an association between an entity and an attribute, such as between a variable and its type or value, or between an operation and a symbol • Binding time is the time at which a binding takes place. Copyright © 2015 Pearson. All rights reserved. 1 -19

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 C or C++ static variable to a memory cell) • Runtime -- bind a nonstatic local variable to a memory cell Copyright © 2015 Pearson. All rights reserved. 1 -20

Binding and Memory Allocation CSE 4102 m m Details the way that Memory is Managed within OS Different Allocation Strategies Used by Each Area q Static – Compile Time q Stack – Run Time Ø Sizes of Data Known at Compile Time Ø Parameters during Calls q Heap – Run Time Ø Allocate and Deallocate Memory (malloc) Ø Programmatic Needs CH 7. 21

Type Binding • How is a type specified? • When does the binding take place? • If static, the type may be specified by either an explicit or an implicit declaration Copyright © 2015 Pearson. All rights reserved. 1 -22

What are Possible Static Binding Problems? CSE 4102 m Passing Arrays by Value int x [10000]; char c[20]; abc (t: -----) {. . . zzz(t); . . . } What Happens to Stack During these multiple calls? What’s the Problem Here? What are two Possible Solutions? xyz (a: -----) {. . . abc(a); . . . } xyz(x); CH 7. 23

Static and Dynamic Binding CSE 4102 m Dangling References main() { int *p; p = call_it(); } int *call_it () { int i = 23; return &i } Is there a Problem? What is it? How is it Solved? CH 7. 24

Explicit/Implicit Declaration • An explicit declaration is a program statement used for declaring the types of variables • An implicit declaration is a default mechanism for specifying types of variables through default conventions, rather than declaration statements • Basic, Perl, Ruby, Java. Script, and PHP provide implicit declarations – Advantage: writability (a minor convenience) – Disadvantage: reliability (less trouble with Perl) Copyright © 2015 Pearson. All rights reserved. 1 -25

Explicit/Implicit Declaration (continued) • Some languages use type inferencing to determine types of variables (context) – C# - a variable can be declared with var and an initial value. The initial value sets the type – Visual Basic 9. 0+, ML, Haskell, and F# use type inferencing. The context of the appearance of a variable determines its type Copyright © 2015 Pearson. All rights reserved. 1 -26

Two Languages with Implicit Declarations/Bindings: APL and SNOBOL • Characterized by dynamic typing and dynamic storage allocation • Variables are untyped – A variable acquires a type when it is assigned a value • Storage is allocated to a variable when it is assigned a value Copyright © 2015 Pearson. All rights reserved. 1 -27

Dynamic Type Binding • Dynamic Type Binding (Java. Script, Python, Ruby, PHP, and C# (limited)) • Specified through an assignment statement e. g. , Java. Script list = [2, 4. 33, 6, 8]; list = 17. 3; – Advantage: flexibility (generic program units) – Disadvantages: • High cost (dynamic type checking and interpretation) • Type error detection by the compiler is difficult Copyright © 2015 Pearson. All rights reserved. 1 -28

Fortran Variable Type. Binding • A feature of Fortran – implicit typing – when a variable appears that has not been declared previously it is created (at compile time) – it is assigned a type based on the first character of the name • A-H, O-Z is type REAL • I-N is type INTEGER – a typo can cause the creation of a new variable – not an error • Starting with 77 the implicit statement was added – allowed changing the first letter assignments – most 77 compilers include the implicit none statement that requires that all variables be explicitly typed – prevents the typo problem • It is good practice to use implicit none

Variable Attributes (continued) • Storage Bindings & Lifetime – Allocation - getting a cell from some pool of available cells – Deallocation - putting a cell back into the pool • The lifetime of a variable is the time during which it is bound to a particular memory cell Copyright © 2015 Pearson. All rights reserved. 1 -30

Categories of Variables by Lifetimes • Static--bound to memory cells before execution begins and remains bound to the same memory cell throughout execution, e. g. , C and C++ static variables in functions – Advantages: efficiency (direct addressing), history-sensitive subprogram support – Disadvantage: lack of flexibility (no recursion) Copyright © 2015 Pearson. All rights reserved. 1 -31

Categories of Variables by Lifetimes • Stack-dynamic--Storage bindings are created for variables when their declaration statements are elaborated. (A declaration is elaborated when the executable code associated with it is executed) • If scalar, all attributes except address are statically bound – local variables in C subprograms (not declared static) and Java methods • Advantage: allows recursion; conserves storage • Disadvantages: – Overhead of allocation and deallocation – Subprograms cannot be history sensitive – Inefficient references (indirect addressing) Copyright © 2015 Pearson. All rights reserved. 1 -32

Categories of Variables by Lifetimes • Explicit heap-dynamic -- 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 Copyright © 2015 Pearson. All rights reserved. 1 -33

Categories of Variables by Lifetimes • Implicit heap-dynamic--Allocation and deallocation caused by assignment statements – all variables in APL; all strings and arrays in Perl, Java. Script, and PHP • Advantage: flexibility (generic code) • Disadvantages: – Inefficient, because all attributes are dynamic – Loss of error detection Copyright © 2015 Pearson. All rights reserved. 1 -34

Memory Allocation CSE 4102 m m Details the way that Memory is Managed within OS Different Allocation Strategies Used by Each Area q Static – Compile Time q Stack – Run Time Ø Sizes of Data Known at Compile Time Ø Parameters during Calls q Heap – Run Time Ø Allocate and Deallocate Memory (malloc) Ø Programmatic Needs CH 7. 35

Variable Attributes: Scope • The scope of a variable is the range of statements over which it is visible • The local variables of a program unit are those that are declared in that unit • The nonlocal variables of a program unit are those that are visible in the unit but not declared there • Global variables are a special category of nonlocal variables • The scope rules of a language determine how references to names are associated with variables Copyright © 2015 Pearson. All rights reserved. 1 -36

Static Scope • Based on program text • To connect a name reference to a variable, you (or the compiler) must find the declaration • Search process: search declarations, first locally, then in increasingly larger enclosing scopes, until one is found for the given name • Enclosing static scopes (to a specific scope) are called its static ancestors; the nearest static ancestor is called a static parent • Some languages allow nested subprogram definitions, which create nested static scopes (e. g. , Ada, Java. Script, Common Lisp, Scheme, Fortran 2003+, F#, and Python) Copyright © 2015 Pearson. All rights reserved. 1 -37

Scope (continued) • Variables can be hidden from a unit by having a "closer" variable with the same name Copyright © 2015 Pearson. All rights reserved. 1 -38

Scoping CSE 4102 m What is the problem ? q Consider this example program class Foo { int n; Foo() { n = 0; } int run(int n) { int i; int j; i = 0; j = 0; while (i < n) { int n; n = i * 2; j = j + n; } return j; } }; CH 6. 39

Simple Static Scoping Example CSE 4102 in main program -- n = 100 in laurel -- m = 50 in laurel -- n = 1 in hardy -- n = 100 /* here hardy is called from laurel */ in hardy -- n = 100 /* here hardy is called from main program */ CH 6. 40

Dynamic Scoping Example CSE 4102 in main program -- n = 100 in laurel -- m = 50 in laurel -- n = 1 in hardy -- n = 1 ; ; NOTE DIFFERENCE -- hardy called from laurel in hardy -- n = 100 ; ; hardy is called from the main program CH 6. 41

Scoping and Nested Procedures CSE 4102 CH 6. 42

Nested Procedures and Recursion CSE 4102 CH 6. 43

Resolving the Issue CSE 4102 m m m Observation q Scopes are always properly nested q Each new definition could have a different type Idea q Make the typing environment sensitive to scopes New operations on typing env. q Entering a scope Ø Effect: New declarations overload previous one q Leaving a scope Ø Effect: Old declarations become current again m What are the Issues? q Activating and Tracking Scopes! CH 6. 44

Scoping CSE 4102 m The Scopes class Foo { int n; Foo() { n = 0; } int run(int n) { int i; int j; i = 0; j = 0; while (i < n) { int n; n = i * 2; j = j + n; } return j; } }; Class Scope Method Scope Body Scope Block Scope Key point: Non-shadowed names remain visible CH 6. 45

Handling Scopes CSE 4102 m From a declarative standpoint q Introduce a new typing environment Ø Initially equal to the copy of the original Ø Then augmented with the new declarations Discard environment when leaving the scope From an implementation point of view q Environment directly accounts for scoping q How ? q m Ø Scope chaining! CH 6. 46

Scope Chaining CSE 4102 m m Key Ideas q One scope = One hashtable q Scope chaining = A linked list of scopes Abstract Data Type q Semantic Environment Ø push. Scope – Add a new scope in front of the linked list Ø pop. Scope – Remove the scope at the front of the list Ø lookup(name) – Search for an entry for name. If nothing in first scope, start scanning the subsequent scopes in the linked list. CH 6. 47

Scope Chaining CSE 4102 m Advantages q Updates are non-destructive Ø When we pop a scope, the previous list is unchanged since addition are only done in the top scope q The current list of scopes can be saved (when needed) CH 6. 48

Entering & Leaving Scopes CSE 4102 m m Easy to find out. . . Use the tree structure! q Entering scope Ø When entering a class Ø When entering a method Ø When entering a block q Leaving scope Ø End of class Ø End of method Ø End of block m We’ll Revisit in Chapter 7 on Runtime Environment! CH 6. 49

Blocks – A method of creating static scopes inside program units--from ALGOL 60 – Example in C: void sub() { int count; while (. . . ) { int count; count++; . . . } … } - Note: legal in C and C++, but not in Java and C# - too error-prone Copyright © 2015 Pearson. All rights reserved. 1 -50

Block Structure in Algol • First language to implement a block structure • Similar in form to pascal begin …. . end; • Each block can have its own variables, visible only to that block (local variables). After the block is exited the values of all the local variables are lost. • Blocks Dominant in All Programming Languages

The LET Construct • Most functional languages include some form of let construct • A let construct has two parts – The first part binds names to values – The second part uses the names defined in the first part • In Scheme: (LET ( (name 1 expression 1) … (namen expressionn) ) Copyright © 2015 Pearson. All rights reserved. 1 -52

The LET Construct (continued) • In ML: let val name 1 = expression 1 … val namen = expressionn in expression end; • In F#: – First part: let left_side = expression – (left_side is either a name or a tuple pattern) – All that follows is the second part Copyright © 2015 Pearson. All rights reserved. 1 -53

Declaration Order • C 99, C++, Java, and C# allow variable declarations to appear anywhere a statement can appear – In C 99, C++, and Java, the scope of all local variables is from the declaration to the end of the block – In C#, the scope of any variable declared in a block is the whole block, regardless of the position of the declaration in the block • However, a variable still must be declared before it can be used Copyright © 2015 Pearson. All rights reserved. 1 -54

Declaration Order (continued) • In C++, Java, and C#, variables can be declared in for statements – The scope of such variables is restricted to the for construct – Thus, Cannot be Accessed After for Statement Completes Copyright © 2015 Pearson. All rights reserved. 1 -55

Global Scope • C, C++, PHP, and Python support a program structure that consists of a sequence of function definitions in a file – These languages allow variable declarations to appear outside function definitions • C and C++have both declarations (just attributes) and definitions (attributes and storage) – A declaration outside a function definition specifies that it is defined in another file Copyright © 2015 Pearson. All rights reserved. 1 -56

Global Variables in C – to a File /* This is main. c int a, b c; main() {. . . can access a/b/c xyz(c); . . . } xyz (a: -----) {. . . can access b/c but not a parameter overrides. . . }Copyright © 2015 Pearson. All rights reserved. /* This is code. c int x [10000]; char c[20]; abc (t: -----) {. . . zzz(t); can access c/x } xyz (a: -----) {. . . abc(c); . . . } 1 -57

Global/Scopes in Pascal Program main(); var a. Global. Var: integer; /* WHERE CAN THIS BE ACCESSED? */ procedure. Call. Back; { Outer level procedure } begin end; procedure. Calling. Procedure; { Outer level procedure } var a. Var: integer; /* WHERE CAN THIS BE ACCESSED? */ procedure. Nested. Call. Back; var another. Var: integer; begin {Nested. Call. Back } a. Var : = 1; another. Var : = 2; end; {Nested. Call. Back } begin {Calling. Procedure } Call. Back; Nested. Call. Back; end; {Calling. Procedure } begin /* program code */ Copyright © 2015 Pearson. All rights reserved. End. 1 -58

Global Scope (continued) • PHP – Programs are embedded in HTML markup documents, in any number of fragments, some statements and some function definitions – The scope of a variable (implicitly) declared in a function is local to the function – The scope of a variable implicitly declared outside functions is from the declaration to the end of the program, but skips over any intervening functions • Global variables can be accessed in a function through the $GLOBALS array or by declaring it global Copyright © 2015 Pearson. All rights reserved. 1 -59

Global Scope (continued) • Python – A global variable can be referenced in functions, but can be assigned in a function only if it has been declared to be global in the function Copyright © 2015 Pearson. All rights reserved. 1 -60

Evaluation of Static Scoping • Works well in many situations • Problems: – In most cases, too much access is possible – As a program evolves, the initial structure is destroyed and local variables often become global; subprograms also gravitate toward become global, rather than nested Copyright © 2015 Pearson. All rights reserved. 1 -61

Dynamic Scope • Based on calling sequences of program units, not their textual layout (temporal versus spatial) • References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point Copyright © 2015 Pearson. All rights reserved. 1 -62

Scope Example function big() { function sub 1() var x = 7; call sub 2(); function sub 2() { var y = x; } var x = 3; call sub 1(); } big calls sub 1 calls sub 2 uses x – Static scoping • Reference to x in sub 2 is to big's x – Dynamic scoping • Reference to x in sub 2 is to sub 1's x Copyright © 2015 Pearson. All rights reserved. 1 -63

Scope Example • Evaluation of Dynamic Scoping: – Advantage: convenience – Disadvantages: 1. While a subprogram is executing, its variables are visible to all subprograms it calls 2. Impossible to statically type check 3. Poor readability- it is not possible to statically determine the type of a variable Copyright © 2015 Pearson. All rights reserved. 1 -64

Scope and Lifetime • Scope and lifetime are sometimes closely related, but are different concepts • Consider a static variable in a C or C++ function Copyright © 2015 Pearson. All rights reserved. 1 -65

Static Allocation CSE 4102 m m m Binding Names to Storage Location at Compile Time Program and Procedure/Function Variables Consider C Program: int xyz; char c[20]; Global vars known at compile time int abc () { Static means to allocate at compile static int x; . . . { Data values persist over multiple static int y; calls to abc(). . . } x, y: retain values in successive. . . calls to abc! } CH 7. 66

Recall Memory Pools CSE 4102 Where does memory comes from ? m Three pools q Static q Automatic (Stack) q Dynamic m Dynamic Static CH 7. 67

Static Pool CSE 4102 m Content q All the static “strings” that appear in the program q All the static constants used in the program q All the static variables declared in the program Ø static int Ø static arrays Ø static records Ø static. . m Allocation ? q Well. . . it is static, i. e. , Ø All the sizes are determined at compile time. Ø Cannot grow or shrink CH 7. 68

Static Allocation CSE 4102 m m m Static Allocation is Limited and Programming Language Specific q In Pascal, Global Program Variables Only q In C, Global Variables and Specific Static What are Implications to Compilation Process? Are these two Programs Same? Why? Different? How? main() { int x[1000000]; . . . } main() { static int. . . } x[1000000]; CH 7. 69

Automatic Pool (Stack Allocation) CSE 4102 m m Content q Local variables q Actuals (arguments to methods/functions/procedures) Allocation q Automatic when calling a method/function/procedure Deallocation q Automatic when returning from a method/function/procedure Management policy q Stack-like CH 7. 70

Automatic Pool (Stack Allocation) CSE 4102 m m Tightly Coupled with Procedure Activation Parameters, Local Variables, Temporary Variables q Allocated as Each Procedure/Function Called q Stack Expands for Nested (and Recursive) Calls Two Step Process q Call Sequence: Allocation Activation Record and Enter Data into its Fields q Return Sequence: Restores State of Program to Caller to Continue Execution What Does Caller vs. Callee Do? CH 7. 71

Heap (Dynamic) Allocation CSE 4102 m m Allows for the Management of Dynamic Storage: q Allow Local Names to Persist When Procedure Activation Completes q When a Called Activation Outlives Caller (Fork off a Process ) Important Issues Include: q How Does Allocation Occur? q Is Garbage Collection Available for Programmer Initiated Deallocation? q Or, does Deallocation Occur Automatically? CH 7. 72

Dynamic Pool CSE 4102 m m Content q Anything allocated by the program at runtime Allocation q Depends on the language ØC Ø C++/Java/C# Ø ML/Lisp/Scheme m malloc new implicit Deallocation q Depends on the language ØC Ø C++ Ø Java/C#/ML/Lisp/Scheme free delete Garbage collection CH 7. 73

Referencing Environments • The referencing environment of a statement is the collection of all names that are visible in the statement • In a static-scoped language, it is the local variables plus all of the visible variables in all of the enclosing scopes • A subprogram is active if its execution has begun but has not yet terminated • In a dynamic-scoped language, the referencing environment is the local variables plus all visible variables in all active subprograms Copyright © 2015 Pearson. All rights reserved. 1 -74

This is Referencing Environment class Foo { int n; Foo() { n = 0; } int run(int n) { int i; int j; i = 0; j = 0; while (i < n) { int n; n = i * 2; j = j + n; } return j; } }; Class Scope Method Scope Body Scope Block Scope Key point: Non-shadowed names remain visible

Named Constants • A named constant is a variable that is bound to a value only when it is bound to storage • Advantages: readability and modifiability • Used to parameterize programs • The binding of values to named constants can be either static (called manifest constants) or dynamic • Languages: – C++ and Java: expressions of any kind, dynamically bound – C# has two kinds, readonly and const - the values of const named constants are bound at compile time - The values of readonly named constants are dynamically bound Copyright © 2015 Pearson. All rights reserved. 1 -76

Summary • Case sensitivity and the relationship of names to special words represent design issues of names • Variables are characterized by the sextuples: name, address, value, type, lifetime, scope • Binding is the association of attributes with program entities • Scalar variables are categorized as: static, stack dynamic, explicit heap dynamic, implicit heap dynamic • Strong typing means detecting all type errors Copyright © 2015 Pearson. All rights reserved. 1 -77