Subprograms

[jimin-kiim]

• Introduction
• Parameters
• Local Referencing Environments
• Semantic Models of Parameter Passing
• Overloaded Subprograms, Generic Subprograms
• Closures
• Coroutines (symmetric control)

[jimin-kiim]

Introduction

• Two fundamental abstraction facilities
  • Process abstraction
  • Data abstraction

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

Basic Definitions

• subprogram definition : the interface to and the actions of the subprogram abstraction
• subprogram call : an explicit request that the subprogram be executed
• subprogram header : the first part of the definition, including the name, the kind of subprogram, and the formal parameters
• parameter profile (aka signature) : the number, order, and types of its parameters
• protocol : a subprogram’s parameter profile and, if it is a function, its return type
• prototypes : Function declarations in C and C++
• subprogram declaration : provides the protocol, but not the body, of the subprogram
• formal parameter : a dummy variable listed in the subprogram header and used in the subprogram
• actual parameter : a value or address used in the subprogram call statement

[jimin-kiim]

Parameters

• positional parameter
  • the binding of actual parameters to formal parameters is by position.
  • Safe and effective
• keyword parameter
  • the name of the formal parameter to which an actual parameter is to be bound is specified with the actual parameter
  • advantage: Parameters can appear in any order, thereby avoiding parameter correspondence errors
  • disadvantage: User must know the formal parameter’s names
• In certain languages (e.g.,C++,Python,Ruby,PHP), formal parameters can have default values (if no actual parameter is passed)

Variables numbers of parameters

• C# : methods can accept a variable number of parameters as long as they are of the same type
• Python : the actual is a list of values and the corresponding formal parameter is a name with an asterisk

Procedures and Functions

• Procedures : collection of statements that define parameterized computations
• Functions : structurally resemble procedures but are semantically modeled on mathematical functions

[jimin-kiim]

Local Referencing Environments

• Local variables can be stack-dynamic
  • 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 – Advantages and disadvantages are the opposite of those for stack-dynamic local variables

[jimin-kiim]

Semantic Models of Parameter Passing

• Three semantics models of formal parameters
  • In mode : receive data from the corresponding actual parameter
  • Out mode: transmit data to the actual parameter
  • Inout mode: do both
• Two models for parameter transmission
  • an actual value is copied (to the caller, to the called, or both ways)
  • an access path to the value is transmitted.

Pass-by-value ( in mode)

• The value of the actual parameter is used to initialize the corresponding formal parameter
• Normally implemented by copying
• Can be implemented by transmitting an access path but not recommended (enforcing write protection is not easy)
• access path mode
  • must write- protect in the called subprogram and accesses cost more (indirect addressing)
• physical move
  • additional storage is required (stored twice) and the actual move can be costly (for large parameters)

    Pass-by-Result (Out Mode)

• 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, by physical move

  Pass-by-Value-Result ( pass-by-copy) (inout Mode)

• a combination of pass-by-value and pass-by- result
• formal parameters have local storage
• Advantage:
  • No aliasing problem as in pass-by-reference
  • The semantics of pass-by-value-result is identical to those of pass-bay-reference unless aliasing occurs
• Disadvantage:
  • Those of pass-by-result, pass-by-value

    Pass-by-Reference (pass-by-sharing) (Inout Mode)

• Pass an access path
• Advantage
  • Passing process is efficient (no copying and no duplicated storage)
• Disadvantages – Slower accesses (compared to pass-by-value) to formal parameters – Potentials for unwanted side effects (collisions) – Unwanted aliases (access broadened)

  Pass-by-Name (Inout Mode)

• by textual substitution
• 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
• Allows flexibility in late binding
• Implementation requires that the referencing environment of the caller is passed with the parameter, so the actual parameter address can be calculated

Implementing Parameter-Passing Methods

• In most languages parameter communication takes place through the run-time stack
  • The run-time stack is used extensively for subprogram control linkage and parameter passing
• Pass-by-value
  • Copy parameter values into stack-locations
• Pass-by-result
  • Implemented as the opposite of pass-by-value
• Pass-by-value-result
  • Implemented as a combination of both (pass-by-value & pass-by-result)
• Pass-by-reference
  • the simplest to implement; only an address is placed in the stack
  • In the case of literals, the address of the literal is put in the stack
  • In the case of an expression, the compiler must build code to evaluate the expression

[jimin-kiim]

Multidimensional Arrays as Parameters

• If a multidimensional array is passed to a subprogram and the subprogram is separately compiled, the compiler needs to know the declared size of that array to build the storage mapping function

[jimin-kiim]

Parameters that are Subprogram Names

• It is sometimes convenient to pass subprogram names as parameters
• Shallow binding
  • The environment of the call statement that enacts the passed subprogram
  • Most natural for dynamic-scoped languages
• Deep binding
  • The environment of the definition of the passed subprogram
  • Most natural for static-scoped languages
• Ad hoc binding
  • The environment of the call statement that passed the subprogram

[jimin-kiim]

Calling Subprograms Indirectly

• Occur when the specific subprogram to be called is not known until run time
• The call to the subprogram is made through a pointer or reference to the subprogram, which has been set during execution before the call is made

[jimin-kiim]

Overloaded Subprograms

• overloaded subprogram: one that has the same name as another subprogram in the same referencing environment
• Every version of an overloaded subprogram has a unique protocol
• The meaning of a call to an overloaded subprogram is determined by the actual parameter list and/or possibly the type of the returned value

Generic Subprograms

• Polymorphism is the useful concept for software reuse
• Lessen the need to create different subprograms that implement the same algorithm on different types of data
• A generic or polymorphic subprogram takes parameters of different types on different activations
• Three major classes of polymorphisms
  • Ad-hoc polymorphism
  • Provided by overloaded subprograms
  • Different codes for different subprograms
  • Considered to be entirely distinct functions by the compiler
  • Subtype polymorphism
  • Allow a function not only to take an object of a certain type T but to work correctly on an object that belongs to a type S that is a subtype of T
  • Parametric polymorphism (generic subprograms)
  • Provide a means to execute the same code for any type
  • Different instantiations of such subprograms can be given different generic parameters, producing subprograms that take different types of parameters
  • Available in several object-oriented languages

    User-Defined Overloaded Operators

• Operators can be overloaded in Ada, C++, Python, and Ruby

  def __add__ (self, second) :
  return Complex(self.real + second.real, self.imag + second.imag)

[jimin-kiim]

Closures

• closure : a subprogram and the referencing environment where it was defined
• To support closures, an implementation may need to provide unlimited extent to some variables (because a subprogram may access a nonlocal variable that is normally no longer alive)

  function makeAdder(x) {
  return function(y) {return x + y;}
  // The closure is the anonymous function returned by makeAdder
  }
  ...
  var add10 = makeAdder(10);
  var add5 = makeAdder(5);
  document.write(′′add 10 to 20: ′′+add10(20)+′′<br />′′); 
  document.write(′′add 5 to 20: ′′+add5(20)+′′<br />′′);

[jimin-kiim]

Coroutines (symmetric control)

• coroutine (symmetric control): a subprogram that has multiple entries and controls them itself
• caller and called coroutines are on a more equal basis
• Coroutines are created in an application by a program unit called the master unit, which is not a coroutine
• resume : a coroutine call
• repeatedly resume each other, possibly forever
• 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
• provide quasi-concurrent execution of program units (the coroutines); their execution is interleaved, but not overlapped