Outline of Class 19: More on Parameters

Held: Friday, March 6, 1998

Administrivia

• I still haven't finished grading the exams. Sorry. Definitely Monday.
• Continue to read chapter 10 of Louden.

• I have observed that most of you misinterpreted question 2 on L-values and R-values. That question was

  Give an assignment statement in an Algol-like language involving variable X such that the R-value of X is used on the left-hand-side of the assignment and the L-value of X is used on the right-hand-side of the assignment. You may choose any type you deem appropriate for X. You may also use other variables in the assignment. Again, you should indicate the type of each variable you use, especially of X.

  • Your goal was to write such an expression without using explicit referencing or dereferencing operations. It is likely that you'll need to rely on the implicit dereferencing we discussed in class.
  • Your assignment should be type correct. For example, it is illegal to store a pointer to a pointer to an integer in a container that is supposed to store pointers to integers.
  • You may use other operations (arithmetic, conditional, arrays, etc.). However, you may not use the "pointer arithmetic" of C and its variants.
  • Many of you failed to ensure that both of the criteria were met (R-value used on the left-hand side, L-value used on the right-hand side).
  • I will accept redone versions of this question Monday at 11am. This also applies to anyone who got an extension on the exam and to those who chose not to do this question.

Parameters, Revisited

Jensen's Device

• To some, pass-by-name is very elegant.
• One instance of this elegance is Jensen's device.
• Here is the most common definition of Jensen's device.

  function sum(exp, counter, start, finish)
  begin
    tmp = 0;
    for counter = start to finish
      tmp = tmp + exp;
    end for
    return tmp
  end sum
  

• What does this compute?
• Does your answer change if exp is A[i] or something similar?
  • Consider sum(A[i], i, 1, 10)

Parameter Passing, Revisited

• Here's another way to look at the five passing strategies.
• In pass-by-value,
  • the actuals are evaluated before the call,
  • new memory is allocated for the formals,
  • the values of the actuals are copied into these new memory locations,
  • the body is executed.
• In pass-by-reference
  • the actuals are evaluated before the call,
  • no new memory is allocated for the formals; rather, the formals name the memory locations of the results of the actuals (optionally, a reference is allocated, but that's equivalent);
  • the body is executed.
• In pass-by-value-return
  • the actuals are evaluated before the call,
  • new memory is allocated for the formals,
  • the values of the actuals are copied into these new memory locations,
  • the body is executed,
  • the values are copied back from the formals to the actuals.
• In pass-by-text (similar to macros),
  • the actuals are not evaluated before the call,
  • in the body of the code, the actuals are substitued for the formals,
  • the new body is executed.
• In pass-by-name,
  • Variables in the actuals are effectively "renamed" to avoid conflict with variables in the body.
  • the actuals are not evaluated before the call,
  • in the body of the code, the actuals are substitued for the formals,
  • the new body is executed.

Call-by-Name, Revisited

• In spite of its many advantages, call-by-name is not used in a large number of languages.
• Why not?
• Primarily because it's difficult to implement efficiently.
  • Often, you need to pass around "code to execute".
  • This code may need to be passed around at run time.
• It becomes surprisingly difficult to implement swap(x,y), which swaps the values of two variables.
  • Why is it difficult? Consider swap(i,A[i]).