Programming Languages and Design Lecture 7 Subroutines and Control Abstraction

1. Programming Languages and DesignLecture 7Subroutines and Control Abstraction Instructor: Li Ma Department of Computer Science Texas Southern University, Houston April, 2008

2. Review of Previous Lectures • Introduction to programming languages • Syntax specifications of programming languages • Semantic specifications of programming languages • Functional Programming • Scheme • Object-Oriented Programming • C++ & Java • Names, binding, and scopes • Static vs. Dynamic

3. Today’s Lecture • Parameter passing mechanisms • By constant-value • By result • By value-result • By reference • By name • References • “Foundations of Programming Languages: Design and Implementation”, S. H. Roosta, Chapter 3 (§3.2) • “Programming Language Pragmatics”, Michael Scott, Chapter 8 (§8.1 – 8.3)

4. Name is Abstraction • Names enable programmers to refer to variables, constants, operations, and types using identifier names • Names are control abstractions and data abstractions for program fragments and data structures • Data abstraction: • Object-oriented classes hide data representation details behind a set of operations • Control abstraction: • Subroutines (procedures and functions) allow programmers to focus on manageable subset of program text • Subroutine interface hides implementation details

5. Mechanisms for Processing Control Abstraction • Single entry (except FORTRAN, PL/I) • Caller is suspended • Control returns to caller

6. Subroutine Design Issues • Syntax, type checking • Parameter passing mechanisms • Static or dynamic allocation of locals • Static or dynamic scope • Environment of parameter functions • Overloading • Generics • Separate compilation

7. Parameters in Subroutine • Parameter transmission is the major alternative method for sharing data objects among subroutines • Formal parameter, or parameter • Local data object within a subprogram • Specification of the parameter in the invoked subprogram • Actual parameter, or argument • Specification of the parameter in the invoking subprogram • A data object shared with the caller program

8. Call by Value • Allocate memory for parameter • Initialize parameter with the argument’s value • Call procedure • Nothing happens on return • Used in C, C++, Pascal, Lisp, ML, etc. • Accesses are usually more efficient with this method • But additional storage is required for the formal parameters in the called subprogram

9. Call-by-Value Example int a = 1; void foo (int x) { // a and x have same value, // changes to a or x don’t // affect each other } // argument can be expression foo (a + a); // no modifications to a

10. Call by Result • Argument must be variable • Allocate memory for parameter • Don’t initialize parameter • Call Procedure • . . . (within here, parameter will get a value) • Copy parameter into argument variable • Return from procedure • Additional storage is required for the formal parameters in the called subprogram

11. Call-by-Result Example int a = 2; void foo (int x) { // x is not initialized, // changes to a or x don’t // affect each other } // argument must be variable foo (a); // a will be modified

12. Call by Value-Result • Copy-In-Copy-Out, or passing by copy • Combination of the first two • Copy argument value on call • Copy result on return • Used by Ada for parameters of primitive type in in-out mode • Additional storage is required for the formal parameters and time for coping values

13. Call-by-Value-Result Example int a = 3; void foo (int x) { // a and x have same value // changes to a or x don’t // affect each other } // argument must be variable foo (a); // a might be modified

14. Call by Reference • A pointer to the memory location of the data object is made available to the called subprogram • Evaluate argument to get the location of the variable • Call procedure • Nothing happens on return • Used by FORTRAN before 1977, Pascal var parameter • Passing process is efficient in both time and space • But access to the formal parameter is slower due to one more level of indirect addressing

15. Call-by-Reference Example int a = 4; void foo (int x) { // a and x reference same location // changes to a and x // affect each other } // argument can be an expression foo (a); // a might be modified

16. Call by Name • Don’t evaluate argument • Create closure to evaluate argument • Call procedure • Evaluate argument by calling parameter closure • Nothing happens on return • Used by ALGOL-60, Simula-67 • Similar to macro expansion (e.g, TeX)

17. Call-by-Name Example int a = 5; void foo (int x) { // x is a function // to get value of argument, // evaluate x() when value is needed } // argument can be an expression foo (a + a); // no modifications to a

18. Languages Comparison in Parameter Passing • In Pascal, parameters are passed by value • The key word var is needed if passing by reference • Fortran passes all parameters by reference • If the parameter is not an l-value (it is an expression), then the compiler will create a temporary variable to hold the value, and pass this variable by reference • In Java, parameters of primitive types are passed by value; Object parameters are passed by sharing • Choose by value or by reference according to the argument (implemented as value or address)

19. Languages Comparison in Parameter Passing (cont’) • Parameters in C are always passed by value, it must pass the address of variable explicitly int v1, v2; void swap (int *a, int *b) { int t=*a; *a=*b; *b=t; } … swap (&v1, &v2); • C++ introduces an explicit notion of a reference void swap (int &a, int &b) { int t=a; a=b; b=t; }

20. Choose Passing Parameter Method • In a language that provides both value and reference parameters (Pascal, Modula), it needs rules to make decision • Concern about the efficiency and safety • If need to change the value of an argument – call by reference – efficient • If do not want to change the value of the argument – call by value – safe • Concern about the potential cost • Copying the large value from actuals to formals is potentially time-consuming • Accessing a parameter that is passed by reference requires an extra level of indirection

21. Choose Passing Parameter Method (cont’) • To combine the efficiency of reference parameters and the safety of value parameters • Modula-3 uses READONLY parameter mode • For small parameters, pass a value • For large parameters, pass an address • C uses const parameter void append_to_log (const huge_record *r) { … } … append_to_log (&my_record); • const applies to the record to which r points • The caller passes the address of its record explicitly, the callee will not change the record’s content