Study with the several resources on Docsity
Earn points by helping other students or get them with a premium plan
Prepare for your exams
Study with the several resources on Docsity
Earn points to download
Earn points by helping other students or get them with a premium plan
Material Type: Exam; Class: PROGRAMMING LANGUAGES; Subject: Computer Science; University: Rice University; Term: Fall 2007;
Typology: Exams
1 / 12
This page cannot be seen from the preview
Don't miss anything!
Name:
Id #:
Pledge:
Problem 1. (10 points) Al Gaulle, a programmer for Kludge, Inc., is de- signing a simple extension language for a business software package. He is proposing the grammar for imperative Jam (Project 4) except for the following revision to the syntax for if-expressions:
<if-exp> ::= if
Do you see any problems with this specification (besides the questionable use of Jam as the foundation for his language), particularly his revision to Jam syntax? State your criticism precisely.
His extension is a flawed design because the syntax is ambiguous. There are two distinct parse trees for the following expression:
if flag1 then if flag2 then foo() else bar()
The else clause can be associated with either of the two if expressions.
if flag1 then (if flag2 then foo() else bar())
or
if flag1 then (if flag2 then foo()) else bar()
Problem 3. (20 points) Recall that Scheme let construct (which is not recursive) expands into lambda expressions as follows:
(let [(x1 E1) (x2 E2) ... (xn En)] E)}
abbreviates
((lambda (x1 x2 ... xn) E) E1 E2 ... En) Similarly, the let* construct expands into let expressions as follows:
(let* [(x1 E1) (x2 E2) ... (xn En)] E)
abbreviates
(let [(x1 E1)] (let [(x2 E2)] ... (let [(xn En)] E)...))
The other binding form in the Scheme let family is letrec; it has the same scoping rules as the Jam recursive let. For each of the two expressions on the next page, circle each binding occurrence of a variable and draw arrows from each bound occurrence back to the corresponding binding occurence. For example, given the expression
(lambda (x) (+ x 1))
the correct answer is:
(lambda (x) (+ x 1))
(define-struct let-exp (id rhs body))
(define Eval (lambda (exp env) (cond ; bool, prim, unop, and if eliminated for pedagogic simplicity [(num-exp? exp) (num-exp-arg exp)] [(id-exp? exp) (binding-val (id-lookup (id-exp-arg exp) env))] [(biop-exp? exp) (local [(define rator (biop-exp-rator exp)) (define rand1 (Eval (biop-exp-rand1 exp) env)) (define rand2 (Eval (biop-exp-rand2 exp) env))] (cond [(eq? rator ’+) (+ rand1 rand2)] [(eq? rator ’-) (- rand1 rand2)] [else (error ’Eval "unrecognized binary operator ~a" rator)]))] [(map-exp? exp) (make-closure (map-exp-var exp) (map-exp-body exp) env)] [(app-exp? exp) (Apply (Eval (app-exp-rator exp) env) (Eval (app-exp-rand exp) env))]
[(let-exp? exp) (local [(define var (let-exp-id exp)) (define rhs (let-exp-rhs exp)) (define body (let-exp-body exp)) (define let-env (cons (make-binding var (void)) env))] (begin (set-binding-val! let-env (Eval rhs let-env)) (Eval body new-env)))]
[else (error ’Eval "illegal expression: ~a" exp)])))
(define extend (lambda (env var val) (cons (make-binding var val) env)))
(define id-lookup ; returns binding pair not binding-val (lambda (id env) (cond [(eq? id (binding-var (car env))) (car env)] [else (id-lookup id (cdr env))])))
(define Apply (lambda (head arg-val) ; head must be a closure (local
[(define parm (closure-parm head)) (define body (closure-body head)) (define env (closure-env head))] (Eval body (extend env parm arg-val)))))
The additional code required to support recursive let is enclosed above between pairs of horizontal lines.
(ii) Assume that Jam passes parameters by value rather than by name. Show the major steps in the evaluation of the preceding expression. Please use abbreviations to shorten your trace.
Problem 6. (20 points) Al Gaulle has designed the ultimate Algol dialect supporting passing parameters by value, by name, by reference, by result, and by value-result. For value-result parameter passing, assume that the argument evaluated once on entry to the procedure and that the resulting location is used on exit. Consider the following Algol-like program (written in Java-like notation):
int i,j,a[5]; // a is an 5 element array with indices 0- void swap(int x, int y) { int temp = x; x = y; y = temp; } for (j = 0; j < 5; j++) a[j] := j;
i := 1; swap(i,a[i+1]); write(i,a[2]);
What numbers does the program print if both parameters in swap are passed by:
1 2
2 1
