Homework #10

CS 341 - Principles of Programming Languages
Homework #10

Due: at the beginning of class 18

Note: This work is to be done in pairs. Each pair will submit one assignment. Although you may divide the work, both team members should be able to present/describe their partner's work upon request.

To submit this homework, change into the directory containing all necessary files: MiniScheme5.jj and supporting abstract syntax tree .java files, and enter the command "submit341 ms5".

MiniScheme Project Phase 5

In this phase of the project, you will extend phase 4 to include pair-related structures and procedures: cons, list, pair?, null?, car, cdr, set-car!, and set-cdr!.

Notes:

An empty list (null) is different than a non-return-value (e.g. "(write 1)"). You should probably define a static final NULL constant that can be compared using == to test for "null?".
Two empty lists are eqv? equal. Two pairs are equal if they are the same objects in memory.
If car is given a non-pair operand, print "car: expects argument of type pair" to the error stream and exit with code 9.
If cdr is given a non-pair operand, print "cdr: expects argument of type pair" to the error stream and exit with code 10.
If set-car! is given a non-pair first operand, print "set-car!: expects type pair as 1st argument" to the error stream and exit with code 11.
If set-cdr! is given a non-pair first operand, print "set-cdr!: expects type pair as 1st argument" to the error stream and exit with code 12.
As always, keep a separation between the tasks of (1) building the abstract syntax tree (e.g. ConsExp, ListExp) and (2) interpreting the abstract syntax tree (e.g. producing Cons pairs). In this context, this means:
- ASTNodes ConsExp and ListExp should not have subexpressions evaluated during parsing.
- Evaluation of ConsExp subexpressions should be evaluated left-to-right and result in a Cons (pair) object with car/cdr fields constructed with the resulting values.
- Evaluation of ListExp subexpressions should be evaluated left-to-right, but resulting values should be cons'd right to left beginning with a NULL for the end of the list. Easy method: Evaluate subexpressions, pushing return values onto a stack. Create a return value initialized as NULL. While your stack isn't empty, set your return value to be a Cons of a value popped from your stack and the old return value.

Grammar

Grammar notes:

Non-terminals are surrounded with angle brackets "<" and ">".
Terminals (e.g. "(" and ")" are represented as themselves without quotes, unless otherwise noted below).
--> denotes a right arrow. Choices to the right of the arrow are separated by a pipe (i.e. "|").
{ }* and { }+ denote a Kleene star and plus/cross, respectively. { }? denotes an optional subexpression.

<program> --> { <definition> | <expression> }*

<definition> --> ( define <variable> <expression> )

<variable> --> <any <identifier> that isn't also a keyword>
<identifier> --> <initial> { <subsequent> }*
<initial> --> [a-z!$%&*/:<=>?^_~]
<subsequent> --> <initial> | <digit> | [+-.@]
<digit> --> [0-9]

<expression> --> <variable>
| <literal>
| <conditional>
| <assignment>
| <derived expression>
| <lambda expression>
| <procedure call>

<literal> --> <integer> | <boolean>
<integer> --> { + | - }? { <digit> }+
<boolean> --> #t | #f

<conditional> --> ( if <expression> <expression> { <expression> }? )

<assignment> --> ( set! <variable> <expression> )

<derived expression> --> ( read )
| ( write <expression> )
| ( newline )
| ( + <expression> <expression> )
| ( - <expression> <expression> )
| ( * <expression> <expression> )
| ( quotient <expression> <expression> )
| ( let ( { <binding spec> }* ) <body> )
| ( and { <expression> }* )
| ( or { <expression> }* )
| ( not <expression> )
| ( eqv? <expression> <expression> )
| ( < <expression> <expression> )
| ( integer? <expression> )
| ( boolean? <expression> )
| ( pair? <expression> )
| ( null? <expression> )
| ( cons <expression> <expression> )
| ( list { <expression> }* )
| ( car <expression> )
| ( cdr <expression> )
| ( set-car! <expression> <expression> )
| ( set-cdr! <expression> <expression> )

<binding spec> --> ( <variable> <expression> )
<lambda expression> --> ( lambda ( { <variable> }* ) <body> )
<body> --> { <definition> }* { <expression> }+
<procedure call> --> ( { <expression> }+ )