Interpreter, V1

We discussed a working interpreter for expressions in class. In this assignment you will start with this set of classes and expand it to support the minimal language whose syntax is shown below.

Objectives

• Extend a working interpreter.
• Implement scanning for floating-point numbers
• Implement parsing for unary minus
• Add variables to the expression evaluator.

Grammar

The basic unit of this language is a statement. Statements will be scanned, parsed and evaluated one at a time. It is not safe to make any assumptions about whitespace.

A program in this language is a sequence of statements. So the start symbol is <statement>.

    < statement> -> < assignExpr>;

    <assignExpr>  -> <var> = <expr> 
    <expr>  -> <term> {[+ | -] <term> }* 
    <term>   -> <primary>  {[* | /] <primary>}* 
    <primary>  -> <var> | <number>  
                    | (<expr>) | - <primary> 

Specification

The existing java files ( documentation) can be copied from the ~tcole/teaching/cs354/handouts/i1/ directory on onyx. Before you do anything else, take the time to read through the code for these classes and make sure you understand how they work. It does not make sense to try to modify existing code until you understand what it is doing to begin with.

Modify and add to the classes of the existing interpreter to add the following functionality:

• The lexer currently handles only integers. Modify the part of the lexer that reads numbers so that it will read floating point numbers. Just store all numbers as floating point numbers so that you don't have to worry about types.
• Add unary minus (negation) to the parser. You will need to modify the primary method. Depending on how you do it, you may also need to modify the Token and Evaluator classes. You should not have to modify the Scanner for this part.
• Create a class that can be used to store the values of variables. Call this class Environment. The environment stores all the current variable bindings. You need figure out a way to store these bindings that allows a variable to be looked up based on its name. (Hint: Think about a hashtable.) You should store the values in the form of Lexemes to make it easy to use them in the evaluation process. (Note: In the last assignment of this series, you will need to store a reference to a parent environment. This will allow you to create a linked list of environments to implement function scope.)

  The functionality that you need for an environment includes the following.

  Operation	Explanation
  constructor	Create an empty environment. This is basically the constructor.
  insert( variable, value)	Insert a new symbol into the environment.
  update( variable, newValue)	Change the value associated with a symbol in the environment.
  lookup( variable)	Retrieve the value associated with the given symbol in the environment.
  print( )	List all the associations in the environment. You'll probably need this for debugging.
  Optional (for this assignment): Later you will need
  extend( currentEnv) (another constructor?)	Create another environment whose parent is the current environment.

  You may want to create a test method class for your Environment class. If you do, include it with your submission and document it in your README.

  Keep in mind that we will eventually want to support function scopes in a program so try to make your class flexible enough that you can later link Environments together.

  Both the Interpreter and the Evaluator classes will need to know about the environment eventually. To support multiple scopes later, the eval method needs to take an environment as a parameter.

• Currently, the Interpreter only evaluates expressions. Assignments are ignored. Using the Environment class from the previous part, modify the evaluator to store and look up values for the variables.
• Create a subdirectory called myTests which contains at least 3 test files that you used to test the additional functionality.
• Possibilities for extra credit. (I generally limit extra credit points to 10% of the maximum value of the assignment so don't get too carried away.)
  • Add strings to the language as a primitive type. (That is, just use a Java String to store their value.) You will need a new token for strings. The lexer can handle strings by reading all the characters between a pair of double quotes. Assignment needs to change since a string expression shouldn't be used in an arithmetic expression. Add a second rule like

        <assignExpr>  -> <string> 
    

  • Add a print statement to the language. The simplest way is probably to add a new token and a new rule (or rules) for statement.

        < statement> -> print ;
                       |  print ;
        <value>  -> <expr>  |  <string>
        <valueList>  -> <value>  | <vlaueList>, <value>
    

  • It is a little more complicated to support both integers and floating point numbers. The lexer needs to differentiate between them and the evaluator needs to do some extra work to determine the type of a binary expression based on the type of the operands. You would probably need a couple of new tokens.

Testing

• testProg
• tests - a directory containing tests for the interpreter before your modifications. All of these tests should still work.

Create a new subdirectory called myTests and write at least 3 test files that you can use to test the added functionality of your interpreter. Part of your score will be based on your test files so try to provide tests for everything you added.

FYI: testProg is a shell script written in bash. You should be able to tell what it does by reading the file in an editor or listing it to the screen with the cat command.

Documentation

Use javadoc comments to document your Environment class and all the methods that you added or modified in the existing classes. You should also include a file called README that tells me what the files you've submitted are, explains your test files and provides any other information I need to know to grade your program. If you are trying for extra credit, tell me what to look for.

Submission

Required files

• All the source files needed to compile and run the program. In addition to those provided, you should have a file called Environment.java that contains the data structure you are using for storing variables and their values.
• the directory myTests
• makefile
• README (This file should include anything you want to tell me about this assignment including anything that you think deserves extra credit.)
• If you wrote a test class for your Environment class, include it with your submission and document it.

Put all the required filed for the assignment in a single directory, change to that directory and submit using the following command:

submit tcole cs354 i1