MCS-287 Lab Project 3: Parameter Passing (Spring 2000)

Due: April 17, 2000

The crux of this lab is to compare interpreters for four different variants of a programming language, which differ in how parameters are passed (and how arrays are stored), as described in chapter six. However, before you can make these four variant interpreters, you will need to have a basic interpreter to build the variations on. This is what chapter 5 accomplishes, and will be the initial focus of your work. Thus you can and should get started long before we get to chapter 6 in class. All the exercises drawn from chapter 5 should be done by April 7th.

Your project report should reflect your final product, rather than focusing on each incremental step along the way. Your project report should explain your comparison of parameter passing variations, and the functionality of your interpreter procedures that allows you to make these comparisons. Don't go into the details in English: your audience can read Scheme. You may assume your audience is familiar with the EOPL book and the supplemental notes that are on our course web page.

As a starting point I have provided you a working interpreter, including if and let expressions. (It is Figure 5.3.2, with all the supporting code.) This interpreter is linked from the web version of this lab handout. You can use the interpreter in either of two ways:
1. You can use the procedure run, passing in a character string which is the expression to evaluate. For example,
```
(run "let x = 3 in *(x, x)")
```
  would evaluate to 9.
2. You can use the procedure read-eval-print, with no arguments, which starts a read-eval-print loop (REPL) going for the interpreted language. Each time it prompts, you can type in an expression in the language. You can split the expression over as many lines as you like, but need to type a semicolon at the end of it. For example,
```
(read-eval-print)
--> let n = 5 in *(n, n);
25
--> 
```
  where the two arrows are prompts printed by the REPL, and the 25 is the value it prints. In Dr Scheme, the REPL takes place in a box, with the output and input in different colors. When you are done using the REPL, you can press the Break button to quit.
Familiarize yourself with this interpreter, trying out expressions such as those on pages 145, 146, and 148.
You will need in later portions of this lab to extend the evaluator to handle extra kinds of expressions, such as procedure creation (proc) in section 5.4 and variable assignment in section 5.5. The parser I have provided already understands the concrete syntax of all these kinds of expressions and produces the corresponding ASTs (record types). For testing and debugging you may find it useful to just parse, or just evaluate, rather than always doing the two together. You can just evaluate using eval-exp, which you will be extending during the lab. To just parse, you have two options, similar to the two options shown above.
1. You can apply character-string-parser to a string which is an expression, and you will get back the AST as a record.
2. You can use the procedure read-print, which acts like read-eval-print except that it just shows the AST for each expression you enter, rather than doing any evaluation.
Try these two out to make sure you understand the tools you have available.
Do exercises 5.1.3 and 5.1.4 on page 145.
Do exercise 5.4.4 on page 155.
Do exercise 5.5.1 on page 156. (You won't need to alter the let clause, contrary to what the exercise says, if you removed it entirely in doing exercise 5.4.4.) Also, you should add variable assignment, as in figure 5.5.1.
Do exercise 5.5.4 on page 158 and add some primitive procedures for performing output.
Do exercise 5.5.5 on page 159. Use the add-binding-to-env! procedure I added to the environment ADT.
If you have time and ability, do exercise 5.6.5 on page 167. This makes the language more pleasant, but is not needed for the project on parameter passing mechanisms. You can earn an A- without this exercise.
Do exercise 6.1.1 on page 183. Use my section 6.1 notes.
Do exercise 6.1.2 on page 186. Use my section 6.1 notes.
Do exercise 6.2.3 on page 193. Use my section 6.2 notes, not literally figure 6.2.1.
Do exercise 6.2.4 on page 193. Again, use my notes as a guide.
Finally, for the crux of the lab project, write an expression (in the language of your interpreters) that has four different numerical values, depending on which of the four interpreters of exercises 6.1.1, 6.1.2, 6.2.3, and 6.2.4 you use. Explain (using diagrams) how the four different values are arrived at, and demonstrate using your interpreters that these four values are indeed produced.

Instructor: Max Hailperin