Chapter 9

1. Chapter 9 Subprograms

2. Fundamentals of Subprograms • Each subprogram has a single entry point • The calling program is suspended during execution of the called subprogram • Control always returns to the caller when the called subprogram’s execution terminates

3. Basic Definitions • A subprogram definition describes the interface to and the actions of the subprogram abstraction • A subprogram call is an explicit request that the subprogram be executed • A subprogram header is the first part of the definition, including the name, the kind of subprogram, and the formal parameters • The parameter profile (aka signature) of a subprogram is the number, order, and types of its parameters • The protocol is a subprogram’s parameter profile and, if it is a function, its return type

4. Basic Definitions (continued) • Function declarations in C and C++ are often called prototypes • A subprogram declaration provides the protocol, but not the body, of the subprogram • A formal parameter is a dummy variable listed in the subprogram header and used in the subprogram • An actual parameter represents a value or address used in the subprogram call statement

5. Actual/Formal Parameter Correspondence • Two approaches: • Positional • The binding of actual parameters to formal parameters is by position: the first actual parameter is bound to the first formal parameter and so forth • Safe and effective • Keyword • The name of the formal parameter to which an actual parameter is to be bound is specified with the actual parameter • Parameters can appear in any order

6. Parameter Correspondence: Example • Example on Keyword: Ada call statement can be as Sumer(Length => My_Length, List => My_Array, Sum => My_Sum); • Where the definition of Sumer has the formal parameters Length, List, and Sum. • Ada and Fortran 95 allow bothe and they can be mixed in a call, as in Sumer( My_Length, List => My_Array, Sum => My_Sum);

7. Formal Parameter Default Values • In C++, Fortran 95, Ada, and PHP, formal parameters can have default values. A default value is used if no actual parameter is passed to the formal parameter in the subprogram header. • Example: Ada Function Compute_Pay(Income : Float; Exemptions : Integer := 1; Tax_Rate : Float) return Float; • Consider the following call Pay := Compute_Pay(20000.0, Tax_Rate => 0.15); • No need to include comma for the absent actual parameter, because all actual parameter after an absent one must be keyword parameters.

8. Formal Parameter Default Values • In C++, default parameters must appear last because parameters are positionally associated. • Once a default parameter is omitted in a call, all remaining formal parameters must have defualt values. • Example: C++ float compute_pay (float income, float tax_rate, integer exemptions = 1); • Notice that the parameters are rearanged so that the one with default value is last. An example call is pay := compute_pay(20000.0, 0.15);

9. Procedures and Functions • There are two categories of subprograms • Procedures are collection of statements that define parameterized computations. • Procedures can produce results in two ways: • Change global variables. • Through parameters that allow the transfer of data. 2. Functions are modeled on mathematical functions • They returns a value. • They can be used in any expression. • They are expected to produce no side effects • In practice, program functions have side effects

10. Design Issues for Subprograms • What parameter passing methods are provided? • Are parameter types checked? • Are local variables static or dynamic? • Can subprogram definitions appear in other subprogram definitions? • Can subprograms be overloaded? • Can subprogram be generic?

11. Local Variables Environments • Local variables can be stack-dynamic (bound to storage) • Advantages • Support for recursion • Storage for locals is shared among some subprograms • Disadvantages • Allocation/de-allocation, initialization time • Indirect addressing • Subprograms cannot be history sensitive • Local variables can be static • More efficient (no indirection) • No run-time overhead • Cannot support recursion

12. Parameter Passing Methods • Ways in which parameters are transmitted to and/or from called subprograms • Pass-by-value • Pass-by-result • Pass-by-value-result • Pass-by-reference • Pass-by-name

13. Models of Parameter Passing

14. Pass-by-Value (In Mode) • The value of the actual parameter is used to initialize the corresponding formal parameter. • Normally implemented by copying • When copies are used, additional storage is required • Storage and copy operations can be costly

15. Pass-by-Result (Out Mode) • When a parameter is passed by result, no value is transmitted to the subprogram; the corresponding formal parameter acts as a local variable; its value is transmitted to caller’s actual parameter when control is returned to the caller • Require extra storage location and copy operation • Potential problem: sub(p1, p1); whichever formal parameter is copied back last will represent the current value of p1.

16. Pass-by-Value-Result (Inout Mode) • A combination of pass-by-value and pass-by-result • Sometimes called pass-by-copy • Formal parameters have local storage • Disadvantages: • Those of pass-by-result • Those of pass-by-value

17. Pass-by-Reference (Inout Mode) • Pass an access path • Also called pass-by-sharing • Passing process is efficient (no copying and no duplicated storage) • Disadvantages • Potentials for un-wanted side effects • Potentials unwanted aliases

18. Pass-by-Name (Inout Mode) • By textual substitution. The actual parameters is textually substituted for the corresponding formal parameter in all its occurrences in the subprogram. • Formals are bound to an access method at the time of the call, but actual binding to a value or address takes place at the time of a reference or assignment • Not used by widely used languages.

19. Implementing Parameter-Passing Methods • In most language parameter communication takes place thru the run-time stack. • Pass-by-value: parameters have their values copied into stack location. The stack then serve as storage for the formal parameters. • Pass-by-result: the values assigned to the actual parameters are places in the stack, where they can be retrieved by the calling program upon termination of the subprogram. • Pass-by-value-result: The stack location for the parameters is initialized by the call and is then used like a local variable in the called subprogram. • Pass-by-reference are the simplest to implement; only an address is placed in the stack.

20. Parameter Passing Methods of Major Languages • Fortran • Always used the inout model (pass-by-reference or pass-by-value-result). • Before Fortran 77: pass-by-reference. • Fortran 77 and later: simple variables are often passed by value-result. • C • Pass-by-value. • Pass-by-reference is achieved by using pointers as parameters. • C++ • Pass-by-value. • A special pointer type called reference type for pass-by-reference. • Java • All parameters are passed by value. • Object parameters are passed by reference.

21. Parameter Passing Methods of Major Languages • Ada • Three modes of parameter transmission: in, out, in out. • in is the default mode. • Formal parameters declared out can be assigned but not referenced; those declared in can be referenced but not assigned; in out parameters can be referenced and assigned. Procedure Adder( A : in out Integer; B : in Integer; C : out Float)

22. Parameter Passing Methods of Major Languages • C# • Default method: pass-by-value • Pass-by-reference is specified by preceding both a formal parameter and its actual parameter with ref Void sumer( ref int oldsum, int newone) { … } … sumer( ref sum, newvalue); • The first parameter to sumer is pass-by-reference and the second is pass-by-value.

23. Type Checking Parameters • Considered very important for reliability • FORTRAN 77 and original C: No type checking • Pascal, Fortran 90, Java, and Ada: Type checking • Relatively new languages Perl, JavaScript, and PHP do not require type checking

24. Multidimensional Arrays as Parameters: C, C++ • Multidimensional Arrays are arrays of arrays, and they are stored in row major order. The mapping function for mat[i, j] is Address(mat[i, j]) = address(mat[0, 0]) + i * number_of_columns + j • This doesn’t need the number of rows. • When an array is passed as a parameter, the formal parameter must include the number of columns but not the number of rows. Consider the prototype void fun (int mat [ ][10]);

25. Multidimensional Arrays as Parameters: C, C++ • Disallows writing flexible subprograms (arrays of different number of rows) • Solution: Pass a pointer to the array and the sizes of the dimensions as other parameters. Consider the prototype void fun (float *mat_ptr, int num_rows, int num_cols);

26. Multidimensional Arrays as Parameters: Pascal and Ada • Pascal • Type checking. • Declared size is part of the array’s type • Ada • Constrained arrays - Type checking • Unconstrained arrays • The index ranges are not given in the array type definition. • Definition of variables of unconstrained array types must include index ranges. Example typ Mat_Type is array (Integer range <>, Integer range <>) of Float; Mat_1 : Mat_Type(1 .. 100, 1 .. 20);

27. Multidimensional Arrays as Parameters: Java and C# • Similar to Ada • Arrays are objects; they are all single-dimensioned, but the elements can be arrays. • Each array inherits a named constant (length in Java, Length in C#) that is set to the length of the array when the array object is created.

28. Parameters that are Subprogram Names: Parameter Type Checking • C and C++: • Functions cannot be passed as parameters • Pointers to functions can be passed • The type of a pointer to a function is the function’s protocol • Because the protocol includes all parameter types, such parameters can be type checked • FORTRAN 95 • It has a mechanism for subprograms to be passed as parameters • Type checked • Ada • Does not allow subprogram to be passed as parameters • The functionality of passing subprogram as parameters is provided by Ada’s generic facility.

29. Parameters that are Subprogram Names: Referencing Environment • In languages that allow nested subprograms, such as JavaScript, the question is what referencing environment for executing the passed subprogram should be used. • There are three choices: • Shallow binding: The environment of the call statement that enacts the passed subprogram. • Deep binding: The environment of the definition of the passed subprogram. • Ad hoc binding: The environment of the call statement that passed the subprogram.

30. function sub1 { var x; function sub2 () { alert(x); // prints x }; function sub3 () { var x; x = 3; sub4(sub2); }; function sub4 (subx) { var x; x =4; subx(); }; x = 1; sub3(); }; Parameters that are Subprogram Names: Referencing Environment – JavaScript Example

31. Overloaded Subprograms • An overloaded subprogram is one that has the same name as another subprogram in the same referencing environment • Every version of an overloaded subprogram has a unique protocol • Different in number, order, and type of its parameters, and the type of its return type. • C++, Java, C#, and Ada include predefined overloaded subprograms • many classes have overloaded constructors.

32. Overloaded Subprograms • In Ada, the return type of an overloaded function can be used to disambiguate calls. • two overloaded functions can have the same parameters and differ only in their return types. • Ada, Java, C++, and C# allow users to write multiple versions of subprograms with the same name

33. Generic Subprograms • A generic or polymorphic subprogram takes parameters of different types on different activations. • Programmer should not need to write four different sort sub-programs to sort four arrays that differ only in element type. • Java 5.0, Ada, and C++ support generic subprogram.

34. User-Defined Overloaded Operators • Operators can be overloaded in Ada and C++ • An Ada example Function “*”(A,B: in Vec_Type): return Integer is Sum: Integer := 0; begin for Index in A’range loop Sum := Sum + A(Index) * B(Index) end loop return sum; end “*”; c = a * b; -- a, b, and c are of type Vec_Type

35. Coroutines • A coroutine is a subprogram that has multiple entries and controls them itself • Also called symmetric control: caller and called coroutines are on a more equal basis • A coroutine call is named a resume • The first resume of a coroutine is to its beginning, but subsequent calls enter at the point just after the last executed statement in the coroutine • Coroutines repeatedly resume each other, possibly forever • Coroutines provide quasi-concurrent execution of program units (the coroutines); their execution is interleaved, but not overlapped

36. Coroutines Illustrated: Possible Execution Controls

37. Coroutines Illustrated: Possible Execution Controls

38. Coroutines Illustrated: Possible Execution Controls with Loops