Evaluating Lisp Expressions

It will be really cumbersome for you to debug your code by typing in a Lisp expression every time you run your program, so I want you to instead read the Lisp expression from a file. You should use a command-line argument to indicate the name of the file. Here's a simple example of using one:

public class Demo {
   public static void main(String[] args) {
      for (int i=0; i < args.length; i++) {
         System.out.println(args[i]);
      }
   }
}

To run this program in jGrasp, copy and paste it into a file named Demo.java. Then go to the Build menu, and check the "Run Arguments" checkbox near the bottom of the drop-down menu. A new text box with the title Run Arguments will appear over your program window. You can then put hello there friend into the Run Arguments box, and run the program. You should then get this output:

hello
there
friend

Alternatively, if you are running your Java programs through the terminal window, you would enter your command-line aguments like this:

javac Demo.java
java Demo hello there friend

The program will display the output shown above.

If you are using another Java development environment, you'll have to figure out how to enable command-line arguments. They will all do it, but it's all in different places.

You should indicate the name of the file containing your Lisp expression. For example, I put a test Lisp expression in a file named input1.txt. I would then put input1.txt in as a command-line argument, and use the value of args[0] as the name of the file to open.

Reading data from a file in Java is super easy if the data is space-delimited. It's more work if it isn't. To that end, we're going to simplify this part of the assignment and assume that in the input file, every entry in the Lisp expression is separated by spaces, including the parentheses. A sample expression would look like this:

( + ( * 2 3 ) 4 5 )

This way, you won't have to worry about how to separate parentheses from numbers or operators. Based on that, the following code would read each of those items in the Lisp expression, one by one, and print them to the screen:

import java.util.Scanner;
import java.io.IOException;
import java.io.File;

public class TestFileReader {
   public static void main(String[] args) throws IOException {
      Scanner input = new Scanner(new File(args[0]));
      while (input.hasNext()) {
         String symbol = input.next();
         System.out.println(symbol);
      }
   }
}

Evaluating the answer to a Lisp expression is a great application for a stack. Here's what the process looks like:

• Start with an empty stack.
• While there are more symbols from the Lisp expression to be read…
  • Get the next symbol.
  • If that symbol is anything other than a closing parenthesis, push it on the stack.
  • If that token is a closing parenthesis, pop items one-by-one off your stack, and add them as they come off to a different temporary stack. Once you finally pop off a left parenthesis, your new temporary stack has a symbol on top, and a series of numbers following it. Pop the symbol off the stack, and use it to evaluate the arithmetic result of applying that symbol to all of the numbers that follow on the stack. Once you have finally obtained that arithmetic result (which is a single number), push that answer back on the original stack.

Try this out on paper first with a bunch of examples to see if you understand it. Understanding how the process works is a necessary prerequisite for being able to code up a solution.

Get the assignment working for the case with no nested parentheses, like the first example above.

Get the complete assignment working.