names - COP4020 Programming Languages Names Scopes and...

Info iconThis preview shows page 1. Sign up to view the full content.

View Full Document Right Arrow Icon
This is the end of the preview. Sign up to access the rest of the document.

Unformatted text preview: COP4020 Programming Languages Names, Scopes, and Bindings Prof. Xin Yuan Overview Abstractions and names Binding time Object and binding lifetime 02/20/12 COP4020 Spring 2011 2 Name High level languages provide abstraction relative to the assembly languages Abstraction: high level language features separate from details of computer architecture (machine independence). A name is a mnemonic character string used to represent something else. 02/20/12 Names are essential in high-level languages for supporting abstraction. Names enable programmers to refer to variables, constants, operations, and types instead of low level concepts such as memory address. COP4020 Spring 2011 3 Name and abstraction Names enable control abstractions and data abstractions in high level languages Control abstraction: Data abstraction: 02/20/12 Subroutines (procedures and functions) allow programmers to focus on manageable subset of program text, subroutine interface hides implementation details Control flow constructs (if-then, while, for, return) hide low-level machine ops Object-oriented classes hide data representation details behind a set of operations Enhances a level of machine-independence COP4020 Spring 2011 4 Name related issues Name: a mnemonic character string used to represent something else Related issues: Binding time: A binding is an association between a name and an entity. 02/20/12 When is a name bound to the object it represents? Some binding is done at language design time (design decision). The lifetime of object and lifetime of binding determine the storage mechanisms for the objectives Scoping rules: the region that a binding a used. Alias: multiple names are bound to the same object COP4020 Spring 2011 5 Binding Time Binding time is the time at which the binding between a name and an object is created. Depending on the names, binding may happen in many different times. Potential binding time includes: Language design time: the design of specific language constructs. Language implementation time: fixation of implementation constants. Example: C++ float point type uses IEEE 754 standard. Program writing time: the programmer's choice of algorithms and data structures 02/20/12 Example: The primitive data type in C++ include int, char, float, double. Example: a routine is called foo(). COP4020 Spring 2011 6 Binding Time Potential binding time includes: Compile time: the time of translation of high-level constructs to machine code and choice of memory layout for data objects. Link time: the time at which multiple object codes (machine code files) and libraries are combined into one executable In an older OS, the binding between a global variable and the physical memory location is determined at load time. Run time: when a program executes 02/20/12 Which cout routine to use? /usr/lib/libc.a or /usr/lib/ Load time: when the operating system loads the executable in memory Example: how is “for(i=0; i<100; i++) a[i] = 1.0;” translated? Binding between the value of a variable to the variable. COP4020 Spring 2011 7 More binding time examples Language design: Syntax (names ↔ grammar) Keywords (names ↔ builtins) + (add), % (mod), ** (power) Built-in primitive types (type name ↔ type) main (C), writeln (Pascal) Meaning of operators (operator ↔ operation) class (C++ and Java), endif or end if (Fortran, space insignificant) Reserved words (names ↔ special constructs) if (a>0) b:=a; (C syntax style) if a>0 then b:=a end if (Ada syntax style) float, short, int, long, string Language implementation Internal representation of types and literals (type ↔ byte encoding) 02/20/12 3.1 (IEEE 754) and "foo bar” (\0 terminated or embedded string length) Storage allocation method for variables (static/stack/heap) COP4020 Spring 2011 8 The Effect of Binding Time Early binding times (before run time) are associated with greater efficiency and clarity of program code Compilers make implementation decisions at compile time (avoiding to generate code that makes the decision at run time) Syntax and static semantics checking is performed only once at compile time and does not impose any run-time overheads Late binding times (at run time) are associated with greater flexibility (but may leave programmers sometimes guessing what’s going on) 02/20/12 Interpreters allow programs to be extended at run time Languages such as Smalltalk-80 with polymorphic types allow variable names to refer to objects of multiple types at run time Method binding in object-oriented languages must be late to support dynamic binding COP4020 Spring 2011 9 Binding Lifetime versus Object Lifetime Key events in object lifetime: Binding lifetime: time between creation and destruction of binding to object Object creation Creation of bindings The object is manipulated via its binding Deactivation and reactivation of (temporarily invisible) bindings Destruction of bindings Destruction of objects Example: a pointer variable is set to the address of an object Example: a formal argument is bound to an actual argument Object lifetime: time between creation and destruction of an object 02/20/12 COP4020 Spring 2011 10 Binding Lifetime versus Object Lifetime (cont’d) Bindings are temporarily invisible when code is executed where the binding (name ↔ object) is out of scope 02/20/12 COP4020 Spring 2011 11 A C++ Example { } 02/20/12 SomeClass* myobject = new SomeClass; ... { OtherClass myobject; ... // the myobject name is bound to other object ... } ... // myobject binding is visible again ... myobject->action() // myobject in action(): // the name is not in scope // but object is bound to ‘this’ delete myobject; return; COP4020 Spring 2011 12 Problems with object/binding lifetime mismatch Memory leak: the binding is destroyed while the object is not, making it noway to access/delete the object { SomeClass* myobject = new SomeClass; ... ... myobject->action(); return; } 02/20/12 COP4020 Spring 2011 13 Problems with object/binding lifetime mismatch Dangling reference: object destroyed before binding is destroyed … myobject = new SomeClass; foo(myobject); Foo(SomeClass *a) { …… delete (myobject); // my objective is a global variable a->action(); } 02/20/12 COP4020 Spring 2011 14 Problems with object/binding lifetime mismatch Dangling reference: object destroyed before binding is destroyed char * ptr; // a global variable Foo() { char buff[1000]; cin >> buff; ptr = strtok(buff, “ “); …… } main() { … foo(); cout << ptr; …… } 02/20/12 COP4020 Spring 2011 15 Summary Names are esstential in high level languages to support abstraction. Supporting names involve many issues Binding time: the time when the binding between a name and an objective is created. Potential binding times Lifetime of objects and bindings. 02/20/12 COP4020 Spring 2011 16 ...
View Full Document

This note was uploaded on 02/20/2012 for the course COP 4020 taught by Professor Engelen during the Spring '11 term at FSU.

Ask a homework question - tutors are online