More so than usual, you are advised to begin this assignment right away. There are design decisions to be made as well as expertise to be developed in the grammar-development cycle. For many students, beginning early on this lab can improve their final grade in this course by a letter! In student reviews of this course, the advice of beginning assignments early is often given.

Preliminaries

1. You need to save some jar files in a reliable place on your computer:
   • You will need the java cup jar and JFlex jar for this lab. They may still be around from .
   • You will need to save the makesymstring jar file in the same place you installed CUP and JFlex from Lab 2. This jar file generates symString.java which is a mapping from terminal symbol to printable string. It's invoked automatically along with CUP.
   Make sure the jar files are really saved as a jar file, and not as a zip file.
2. Download the hw3 zip file into a temporary place, and import it as an existing project into eclipse, just as you did for Lab 2.
3. The ant build.xml file is now distributed without reference to ant tasks for CUP or JFlex. For some of us, those tasks were not working properly. CUP and JFlex are now launched via their jar files, so the build file should work everywhere with the modifications described in the file's comments.
4. When you open the project, be sure to do the following, just as you had to do for Lab 2:
   • In the Properties of the CSE431hw3 project, add the CUP JAR file as an external JAR library.
   • When running build.xml:
     • Be sure that it runs in the same JRE as the workspace.
     • Be sure that the workspace "refreshes" after the build.

   Make the appropriate modifications to the build file, and try building and running the project (see ant tasks' descriptions, below) as distributed, as soon as possible, to avoid any infrastructure issues.

5. In this lab, you are given jmm.cup, which is a CUP grammar for a subset of the Java language jmm , which stands for "Java minus minus".

   Browse through the file and familiarize yourself with the structure of this grammar. It is the only file you should modify, and it is the only file you are allowed to turn in.

Lab notes

• Overall approach:

  You are advised to follow the following strategy as you develop your solution. Failure to follow this advice will increase your development time and could cause anxiety, confusion, and dry flaky skin.

  • I've already created the very top part of the tree for you, starting at the rule for CompilationUnit and ending at TypeDeclaration (which is really just a completed class declaration).
  • Take a look at the kind of tree I produce by running the supplied solution (using the appropriate ant task described below).
  • Slowly descend down the grammar, implementing a little more, and compiling and testing as you go. For example, the next thing you might do is create nodes for each ClassDeclaration. At first that node could just be a simple TemporaryNode, and you can fill in more detail later, such as the class name, protection bits, and class body.
  • Proceed slowly and test each time to make sure your tree is developing the way you want.
• Debugging with tools like CUP can be confusing, because:
  • Your code in the .cup file is translated into .java code.
  • Exceptions raised in the .java file are reported with respect to the .java line numbers.
  So, you'll have to trace that back to problems in your .cup file:
  1. Go to the error line in the Parser.java file, and look up (the file, not the ceiling) to find the case statement that shows the relevant production in your .cup file.
  2. Now look in your .cup file at the semantic code and try to find the problem.
  3. Failure to create objects in semantic actions will lead to null-pointer exceptions. As described below, the TemporaryNode class is available to act as a place-holder while you decide more customized node-types to instantiate.
• The following ant tasks will help you with building and testing your lab:

  build	Default target, runs appropriate tools and compiles your project to bring it up-to-date
  testClassSolution	Runs my solution on all of the test files
  testMySolution	Runs your solution on all of the test files
  clean	Deletes the class files and all automatically generated files. Use this if things are behaving weirdly.
  java main file	Runs your parser on file

• Be certain only to modify the file jmm.cup. It is the only file you will turn in.

Specifics

1. For the rules present in jmm.cup, you are asked to design and implement an abstract syntax tree (AST). It is suggested that you first think about your design and sketch some possible layouts on paper prior to working at the computer. You could also run the class solution to get ideas about how to structure your AST. To help you implement the tree, the following factory methods are provided in the jmm.cup file; each instantiates a subclass of AbstractNode.

   makeNode(Symbol)	Constructs an AST node, labeled by the Symbol supplied as input. This is useful where you want to take a rule such as: SelStmt ::= IF:ifterm LP Expr RP Stmt and make an AbstractNode out of it by: AbstractNode ifnode = makeNode(ifterm);
   makeNode(String)	This is the recommended way to put nodes in the AST to show us the structure you want. In future labs, you'll want more refined subclasses of AbstractNode so you can put in specialized code for each node type, but for now, this kind of node is very useful.
   makeSibling(AbstractNode)	is a method for class AbstractNodethat appends one or more sibling nodes. For example AbstractNode n1 = makeNode("SomeKindofNode"); AbstractNode n2 = makeNode("AnotherKindofNode"); n1.makeSibling(n2); makes n2 a sibling of n1. In general, if n1 is a node in the middle of sibling list1, and n2 is a node in the middle of sibling list2, then the above code would have the effect of appending list2 to list1. This method returns the rightmost sibling in the resulting sibling list.
   adoptChildren(AbstractNode)	is a method for class AbstractNodethat brings a set of siblings under a parent. For example AbstractNode n1 = makeNode("Sib 1"); AbstractNode n2 = makeNode("Sib 2"); AbstractNode p = makeNode("Boss"); p.adoptChildren(n1.makeSibling(n2)); makes p the parent of the siblings n1 and n2.

   • The class AbstractNode can be extended to make useful abstract syntax tree nodes. Examples of this are IntegerNode and TemporaryNode which are included in the jmm.cup file in the action code block.
   • If you need some auxilliary classes or methods to simplify your semantic actions, these can be placed as methods in the action code block. Several examples are already there for you to see how this can be done.
2. To turn in your work, send your jmm.cup file as an attachment via email to legrand@cs.wustl.edu

   Be sure to fill in the header of the jmm.cup file with your name and the email address from which you are submitting your work.