ICS 141 Klefstad

Subprograms

Outline definitions design issues for subprograms referencing environment parameter passing Semantic model for parameter passing modes parameter passing implementations parameter passing modes available in languages parameter passing examples hints for evaluating different parameter modes generics compiling larger systems accessing non-local environments activation record local blocks

definitions

subprogram
- either a procedure or a function
- calling unit is suspended
- subprogram body is executed
- control returns to caller when subprogram is done
- a subprogram is active while running
subprogram definition
- describes actions of a subprogram abstraction
subprogram call
- explicit activation of one subprogram by another subprogram

subprogram header
- declares name, parameter, and return type of a subprogram
- also called a prototype or forward declaration
parameter profile
- number, type, order of parameters and return type
- also called signature

design issues for subprograms

scope of parameters and variables
parameter passing methods?
type checking of parameters?
allocation of local variables: static or dynamic?

pointers to subprograms as parameters?
overloading?
generic subprograms?
partial compilation for larger systems: separate and independent

referencing environment

local variables - those defined inside the subroutine
may be static or stack-dynamic (semi-static)
static:
- no run-time allocation/deallocation overhead
- may retain values across calls
- access is direct (and may be faster)
stack-dynamic (semi-static)
- allows recursion
- allows efficient reuse of (stack) memory
- access is indirect (and may be slower)
- some machines may allow locals in registers (much faster!)

parameter passing terms

formal parameter

those named in a subprogram header

e.g.,

  void p(int x, int y) { }
  x and y are formal parameters for p

actual parameter

those given in a call

e.g.,

  p(1, 2);
  1 and 2 are actual parameters for p

binding methods

positional parameters

e.g.,
```
  p(1,2);
```
keyword parameters
- e.g.,
```
p(y=>2, x=>1);
```

defaults

e.g., to have x take its default value

void p(int x=10, int y=25) { }
p(y=>2); -- p(10,25) Ada style
p(2); -- p(2,25) C++ style
p(, 2); -- p(10, 2) Fortran style

Semantic model for parameter passing modes

clean model used in Ada
in mode - actual transmits data in the formal
out mode - formal transmits data to the actual
inout mode - both in then out

parameter passing implementations

pass by copy
- formal has its own storage area
- values are copied between formal and actual
- three variations:
  - pass by value
    - formal is initialized to actual's value
    - no information flows back to actual
    - may pass constant actual parameters
  - pass by result
    - no incoming value
    - value is copied into actual at subprogram return
  - pass by value-result
    - formal is initialized to actual`s value
    - change to formal does not immediately change actual
    - value of formal is copied into actual at subprogram return

pass by reference
- formal is a pointer to the actual data object
- one implicit level of indirection at each reference to formal
- modification of formal causes immediate modification to actual
- must pass variables, cannot pass literal constants

pass by name
- like pass by reference except actual is re-evaluated in calling scope at each reference
- thunk
  - an implicit function which calculates the address of actual at each reference to formal

parameter passing modes available in languages

Fortran
- usually by reference
Lisp
- all by reference
Algol
- name (default)
- value
C
- value (must pass address to get reference)

Pascal
- value (default)
- reference (with VAR)
Ada
- in (read-only)
- out (write-only)
- in out (both readable and writable)
- may be implemented by reference or by copy (compiler choice)
C++
- value (default)
- reference (with &)

parameter passing examples

example

PROCEDURE test IS
  PROCEDURE swap(a : mode integer; b : mode integer) IS
    temp: integer;
  BEGIN
    temp := a;
    a := b;
    b := temp;
  END;
  a: ARRAY (0..10) OF integer := (OTHERS => 0);
  i: integer := 1;
BEGIN
  swap(i, a(i));
END;

hints for evaluating different parameter modes

copy
- value
  - initialize formal to actual's value
- result
  - value copied to actual on return
- value-result
  - initialized, copied on return
reference
- textually substitute evaluated actual for all occurances of formal
name
- textually substitute literal actual for all occurances of formal
- referencing environment for actual is calling environment

generics

generic program units may be parameterized by:
- type
- subprogram
generics have two components
- definition
  - defines generic parameters and unit template
- instantiation
  - creates a unit when types & subprograms are made specific

generics (continued)

Ada example

definition

GENERIC
  TYPE element IS (<>);
PACKAGE power_set IS
  TYPE set IS ARRAY(element) OF boolean;
END;

instantiation

PACKAGE char_set IS NEW power_set(character);
delims: set := (':' | ',' | '!' => true, OTHERS => false);
TYPE day IS (mon, tue, wed, ..., sun);
PACKAGE day_set IS NEW power_set(day);
lecture_day: set := (tue|thu => true, OTHERS => false);
...
IF lecture_day(today) THEN ...

generics (continued)

C++ example

template
  <class T>
class PowerSet
{
public:
  PowerSet();
  void addElement(T element);
  bool isElement(T element);
  PowerSet<T> union(PowerSet<T> right);
  PowerSet<T> intersect(PowerSet<T> right);
};
int main()
{
  PowerSet<char> parens;
  parens.addElement(')');
  parens.addElement('(');
  char c;
  cin.get(c);
  if ( parens.isElement(c) )

  ...

}

compiling larger systems

some languages don't allow partial compilation
- e.g., original Pascal, Fortran II
independent compilation
- interfaces may not be checked for consistency
- e.g., Fortran, old C
separate compilation
- interfaces are checked
- e.g., Ada, C++

accessing non-local environments

want to reference a non-local variable with offset o and distance d
two common approaches
- static chain
  - a linked list of activation records
  - one pointer per activation record
  - gives O(d) access to non-local variables
- displays
  - an array of activation record pointers
  - one array per activation record
  - gives O(1) access to non-local variables

activation record

holds all info needed for a subroutine activation
typically holds the following:
- return point
- dynamic link
- static link
- parameters
- local variables
- tempory variables

local blocks

may be handled one of two ways:
- (re)allocate storage for block at each entry
- preallocate all storage once at subroutine activation

e.g.,

int main()
{
  int n = 10;
  int m = 20;
  for (int i = 0; i < n; i++ )(
  {
    int local = 50;
    m += i * local;
  }
  for (int i = 0; i < n; i++ )(
  {
    int diff = m - i;
    m *= n;
  }
}