Presentation is loading. Please wait.

Presentation is loading. Please wait.

Names, Bindings, and Scopes

Similar presentations


Presentation on theme: "Names, Bindings, and Scopes"— Presentation transcript:

1 Names, Bindings, and Scopes
Chapter 5 Names, Bindings, and Scopes

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

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

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

5 Names (continued) Length If too short, they cannot be connotative
Language examples: C99: 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.

6 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 are instance variables; those that begin with are class variables Copyright © 2015 Pearson. All rights reserved.

7 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. IndexOutOfBoundsException) Copyright © 2015 Pearson. All rights reserved.

8 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 IvAr INTEGER, REAL, DOUBLE PRECISION, COMPLEX LOGICAL, CHARACTER (77+)

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

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

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

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

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

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

15 Base Types What are the base types ? int float double char void bool
error

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

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

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

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

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

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

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

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

24 Static and Dynamic Binding
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?

25 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, JavaScript, and PHP provide implicit declarations Advantage: writability (a minor convenience) Disadvantage: reliability (less trouble with Perl) Copyright © 2015 Pearson. All rights reserved.

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

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

28 Dynamic Type Binding Dynamic Type Binding (JavaScript, Python, Ruby, PHP, and C# (limited)) Specified through an assignment statement e.g., JavaScript 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.

29 Fortran Variable TypeBinding
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

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

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

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

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

34 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, JavaScript, and PHP Advantage: flexibility (generic code) Disadvantages: Inefficient, because all attributes are dynamic Loss of error detection Copyright © 2015 Pearson. All rights reserved.

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

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

37 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, JavaScript, Common Lisp, Scheme, Fortran 2003+, F#, and Python) Copyright © 2015 Pearson. All rights reserved.

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

39 Scoping What is the problem ? 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) { n = i * 2; j = j + n; } return j; };

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

41 Dynamic Scoping Example
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

42 Scoping and Nested Procedures

43 Nested Procedures and Recursion

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

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

46 Handling Scopes From a declarative standpoint
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 Environment directly accounts for scoping How ? Scope chaining!

47 Scope Chaining Key Ideas One scope = One hashtable
Scope chaining = A linked list of scopes Abstract Data Type Semantic Environment pushScope Add a new scope in front of the linked list popScope 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.

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

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

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

51 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

52 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 ( (name1 expression1) (namen expressionn) ) Copyright © 2015 Pearson. All rights reserved.

53 The LET Construct (continued)
In ML: let val name1 = expression1 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.

54 Declaration Order C99, C++, Java, and C# allow variable declarations to appear anywhere a statement can appear In C99, 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.

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

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

57 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 /* This is code.c int x [10000]; char c[20]; abc (t: -----) { . . . zzz(t); can access c/x } xyz (a: -----) abc(c); . . . Copyright © 2015 Pearson. All rights reserved.

58 Global/Scopes in Pascal
Program main(); var aGlobalVar: integer; /* WHERE CAN THIS BE ACCESSED? */ procedureCallBack; { Outer level procedure } begin end; procedureCallingProcedure; var aVar: integer; /* WHERE CAN THIS BE ACCESSED? */ procedureNestedCallBack; var anotherVar: integer; begin {NestedCallBack } aVar := 1; anotherVar := 2; end; {NestedCallBack } begin {CallingProcedure } CallBack; NestedCallBack; end; {CallingProcedure } /* program code */ End. Copyright © 2015 Pearson. All rights reserved.

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

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

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

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

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

64 Scope Example Evaluation of Dynamic Scoping: Advantage: convenience
Disadvantages: While a subprogram is executing, its variables are visible to all subprograms it calls 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.

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

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

67 Recall Memory Pools Where does memory comes from ? Three pools Static
Automatic (Stack) Dynamic Automatic (Stack) Dynamic Static

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

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

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

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

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

73 Dynamic Pool Content Anything allocated by the program at runtime
Allocation Depends on the language C malloc C++/Java/C# new ML/Lisp/Scheme implicit Deallocation C free C++ delete Java/C#/ML/Lisp/Scheme Garbage collection

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

75 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) { n = i * 2; j = j + n; } return j; }; Class Scope Method Scope Body Scope Block Scope Key point: Non-shadowed names remain visible

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

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


Download ppt "Names, Bindings, and Scopes"

Similar presentations


Ads by Google