CIT 594 Bugs
Interpeter, part 1
Spring 2015, David Matuszek
Given a program in the Bugs language, you now can create an AST (Abstract Syntax Tree) for it. The next step is to interpret the AST, so that your Bugs program "does something."
In this assignment you will write the first half of the interpreter. (The next assignment will be to complete the interpreter.) We will leave three things for later: Implementing function calls, displaying the bugs' actions on the screen, and coordinating the actions of multiple bugs.
Now might be a very good time to review The Bugs Language.
Name your Bug interpreter class
Bug. Each "bug" will be an instance of this class.
Two fundamental methods are needed:
public double evaluate(Tree<Token> tree), for parts of the tree (mostly, expressions) that need to return a value, and
public void interpret(Tree<Token> tree), for parts of the tree (such as statements) that do not return a value.
Each of these methods will use either a
switch statement or a multi-branch
if statement to examine the String value in the root of the given tree, and call the appropriate method to evaluate or interpret the tree.
You will begin by calling
interpret with the
root node of a Bug (the AST representing a
definition>. To interpret this node, you interpret
each of its five children, as follows:
nameof the Bug in an instance variable.
loopnode will walk its children repeatedly). Some nodes, such as an assignment node, may cause certain children to be
evaluated, rather than
Note: Although the interpretation proceeds top down, starting at theFor keeping track of variables and their values, write the following two methods:
Bugroot, you will need to write the methods by starting at the bottom and working your way up (just as you did in the
Parser), so that you can test as you go. Of course, full JUnit testing is required.
void store(String variable, double value)is used to perform the assignment
double fetch(String variable)is used to retrieve the current value of
variable. (If there is no such variable, throw some kind of
HashMap<String, Double>to keep track of the values of variables. However, there are three variables that need to be treated specially:
angle. These do not go into the HashMap, but are instance variables of the Bug class, for reasons that should become clear when we implement functions. Make sure that
fetchhandle these three variables correctly.
These are more-or-less in the order given in the Bugs Grammar, not in the
order you need to write them. Write the lowest-level, most fundamental methods first (like
store), so that you can test them, then work your way up to the higher-level methods.
storeeach named variable, with an initial value of zero.
expressionchild, and "move" this Bug forward (its
angletells what direction it is facing) by that amount, by setting new values of
y. You will need a small amount of trigonometry to determine the new values of
y; get help from a classmate if necessary.
expressionchildren, and set
yto these two values, respectively.
expressionchild, and add this amount to this Bug's
angle. If necessary, adjust the value to be between 0.0 and 360.0, inclusive. (Maintain full accuracy--do not use int values!).
expressionchild, and set this Bug's
angleto the new value. If necessary, adjust the value to be between 0.0 and 360.0, inclusive. (Maintain full accuracy--do not use int values!).
storethe result of the evaluation into the variable name.
block) repeatedly. The loop ends when an
exit ifstatement in the block is interpreted. (This may be a bit tricky; you can probably do it by setting and clearing a
booleanvariable, but remember, you can have loops inside loops (inside loops....)).
casechild, in order, until one returns "true"--then stop. (It seems strange to evaluate a case clause, rather than interpreting it, but this is an easy way to implement the switch statement.) Remember, "false" is any number between -0.001 and +0.001, and "true" is any number that isn't false.
java.awt.Colorvalue (there is no shortcut to doing this, you just need a big
ifstatement), and store the result in this Bug's
colorinstance variable. Throw some kind of
RuntimeExceptionif the name isn't a legal color.
Bugclass should have an instance variable
HashMap<String, Tree<Token>> functions
functionnode as the value.
ifstatement), and return
0.0for "false." Remember, two numbers are "equal" if they are within 0.001 of each other.
interpret, not one huge test method for each. For example,
testAssignmentStatement. Remember that JUnit 4 tests can be named whatever you like.
void, you need to test it by its effect. That means that pretty much everything you interpret should set the values of some variables, so you can
fetchthose variables and see if they were set correctly.