Subprograms subroutines, procedures, functions, methods

Vocabulary float average(float list[], int n) { … } av = average(marks,20); call header / prototype protocol formal parameters actual (arguments) parameter profile

Functions vs Procedures  procedures are statements - do not return a value Collections.sort(marks, 20);  functions are expressions - return a value double x = Math.exp(10.0);  in c, c++, Java, all methods are functions; can be used as procedures; ‘void’s must be used as procedures

Parameters keyword positional call call - return return pass-by- value reference name example Java: all parameters are positional primitive parameters are call, pass by value object parameters are call-return, pass by reference

Keyword parameter passing  order of actual parameters can be changed if each parameter is identified by keyword (FORTRAN, Ada) av = average(n=>20,list=>marks)

Direction of data passing call - data goes into subprogram only at beginning of execution return - data goes from subprogram back to caller at end of execution call-return - data passes in both directions: into subroutine at call and back to caller at end of execution

Direction of data passing call - protects caller’s data from effects of subprogram return - useful for initializing data in caller; alternative route for returning data call-return - gives subprogram access to change caller data caller subprogram caller subprogram caller subprogram

Implementing parameters (1)  Pass-by-value pass-by-value (call) pass-by-result (return) pass-by-value-result (call - return)  Data is copied between actual and formal parameters a = 10proc sub(int x) sub (a) { print a print x x = 1000 print x } a x

Implementing parameters (1)  Pass-by-value pass-by-value (call) pass-by-result (return) pass-by-value-result (call - return)  What happens when actual parameters are not variables? (constants or expressions)

Implementing parameters (1)  Pass by value, result, value-result a = 10proc sub(int x) sub (a) { print a print x x = 1000 print x } a x stack sub

Implementing parameters (2)  Pass-by-reference (call - return OR call if actual parameters are made read- only)  Formal parameter refers to same memory cell as actual parameter a = 10proc sub(int x) sub (a) { print a print x x = 1000 print x } a x

Implementing parameters (2)  Pass-by-reference a = 10proc sub(int x) sub (a) { print a print x x = 1000 print x } a x stack sub address of a

Implementing parameters (2)  Pass-by-reference  Formal parameter refers to same memory cell as actual parameter  What happens when actual parameters are not variables? (constants or expressions) java example jButton.addActionListener(new ButtonListener());

Implementing parameters (3)  Pass-by-name  formal is bound to actual only when accessed or assigned (i.e., not at call)  effect depends on form of actual parameter: constant - same as pass-by-value variable - same as pass-by-reference expression - like reference but reference may change

Implementing parameters (3) - pass-by-name example procedure BIGSUB p. 364 Sebesta integer GLOBAL, LIST[1:2]; procedure SUB(PARAM) begin PARAM := 3; GLOBAL := GLOBAL + 1; // note scope! PARAM := 5; end; begin LIST[1] := 2; LIST[2] := 2; GLOBAL := 1; SUB(LIST[GLOBAL]); end;

Implementing Parameters (3)  Pass-by-name x j=4 x thunk sub(x) j=2 sub(list[j]) list[j] j list

Parameters - design issues (1)  type checking no checking - mismatched types -> reinterpretation of data type checking - control of type match or legal coercion

Parameters - design issues (2)  array parameters - for 2 or more dimensions, length of 2nd, 3rd, etc dimensions is needed to computer offset  tradeoff compile-time (efficient) offset expression forces fixed array dimensions call-time (less efficient) offset expression handles arrays of any size (java)

Parameters - design issues (3) security / efficiency tradeoff  security: design according to minimum access requirements: call, return, call-return  efficiency: reference is time and space efficient for large data objects but implies call-return  compromises allow programmer choice ‘read-only’ references (C++) what does java offer?

Passing procedures as parameters  example of procedure passing procedure m() var integer[3] arr = {1,2,3}; procedure s (integer[3] k) begin print (k[1]+k[2]+k[3]); end procedure sub (integer[3] cc, procedure w) begin w(cc); end begin sub(arr, s); end

Issues unique to procedure parameters  Does protocol of actual parameter procedure match protocol of formal? 1.- early Pascal unchecked 2.- later Pascal – parameters in formal procedure parameter 3.- c pointers to procedures are passed; their type identifies protocol

Function design  extreme definition: NO SIDE-EFFECTS no access to global variables only call parameters only effect through return value  return values: single primitive value – math model single value including reference/pointer any one value including record, array or procedure

Coroutines – preview to concurrency  subroutines in symmetric control model (not caller-callee relationship)  goal: virtual parallelism  Simula – process simulation  java – threads  classic example – large file copy read and write coroutines with shared buffer

Sharing data space  global identifiers by scoping rules  instructions to compiler to share space (Fortran COMMON)  explicit specification of external units needed (Fortran 90, java)

Reusability with subprograms  OVERLOADING: reusing a subprogram name in different scopes with different protocols (like operators * ) conflict with default parameters  POLYMORPHIC: different parameter types in different activations dynamic typing type templates C++ * C++ allows overloading of operators

C++ templates template void Swap (Etype & First, Etype & Second) { Etype Temp = First; First = Second; Second = Temp; }... in calling program int X = 5, Y = 6, Z = 7; double A = 3.5, B = 9.4; Swap(X,Y);//instantiate int version Swap(X,Z);//re-use int version Swap(A,B);//instantiate double version Swap(A,Z);// illegal – type mismatch

Reusability and compilation  problem: variables and procedures defined in one unit and accessed in another – type checking 1.separate compilation (Ada) compile time check of compatibility 2.independent compilation (c) no type checking – run time type errors 3.no compilation except complete programs (original Fortran II)

Separate Compilation  compilation checks library of exported entities for types and protocols of external references function int max(int,int) unit A A’s compilation unit int max(int,int) library i = max(j,k) unit B compile A compile B ?