Behold the general structure of a CUP specification:

    terminal stringtype lparen, rparen, digit;
non terminal inttype    Number; 
non terminal stringtype Parens; 

Number ::= Number digit
         | digit
         | Parens
         ;

Parens ::= lparen rparen;

Upon encountering a terminal symbol, your code should record the symbol as terminal in the symbol table by issuing:

  symboltable.enterTerminal(symbol)

  symboltable.enterNonTerminal(symbol)

I'm assuming you will want to use Eclipse for development this semester. I'm relatively new to it, but the following instructions worked for me. Any advice is appreciated. If you'd rather do this on Linux without eclipse please let me know and I'll post instructions on how to do it that way.

Eclipse instructions:

1. The files for this assignment are in this zip file. Click on the link and save the archive file somewhere handy.
2. After launching eclipse, create a New Java Project and call it something meaningful (like CSE431 hw1 or Best Lab Ever).
3. With that project selected in the Package Explorer, click File → Import …
4. You want to import an archive file, so look for this in the types of files you can import. For me, it is under the General folder.
5. Let Eclipse import all the files in the zip you downloaded in step 1.
6. Eclipse should automatically build the project by compiling all of the source java files. You will see some warnings issued from the compilation, but you should ignore them (silly Eclipse! Those warnings are from automatically generated code).
7. To run the application, you will have to provide a command-line argument to specify the file to be processed by the application.
   1. Click Run → Run …
   2. Configure the run as a Java Application
   3. Click on the Arguments tab
   4. Fill inthe Program arguments with a file you want to process, such as TestFiles/good1.cup
   5. Click Apply and Run

For this assignment, you will modify only the file Fsa.java, and that is the only file you will turn in.

When you are done, mail only your Fsa.java file (and no other files) to legrand@cs.wustl.edu. You can send it as a single, solitary attachment using pine (or just about any mail reader), or you can use the Linux incantation:

The file as supplied contains a skeletal finite-state machine (simulator), driven by the tables GOTO[][] and ACTION[][], as described in class. Your assignment is to expand and fill in these tables appropriately, and to add code in the switch statement to perform the required translation.

While processing the rules section, you will check each production for right-linear form. That is, there should be only nonterminals on the left side of a rule, and the right side of a rule should be a terminal followed by at most one nonterminal. To determine the type of a symbol previously entered into the symbol table, invoke

   symboltable.isTerminal(symbol)

• Upon encountering any error, you may abort, but produce the white-space delimited string ABORT in your output.
• You may assume that
  • All symbols used in the CUP specification are declared, so that SymbolNotFoundError will not be thrown.
  • There are no empty productions
  • Each production group is properly terminated by a semicolon.
• For your translation, you are to produce a labeled set of transition edges for the grammar's corresponding finite state machine:
  1. For each production you encounter, you must output a line of the following form: Edge NonTerm1 NonTerm2 label where you supply the strings for NonTerm1, NonTerm2, and label. If the transition is to a final state, then NonTerm2 should be the string $FINAL$.
  2. You must also produce a line to indicate the start state: Start NonTerm
• For extra fun, try handling undeclared symbols by inferring their type from the first rule containing their use.
• For some fun, feed the output of your program into my MakeTable program. It will convert your edge descriptive output into tables (quasi)suitable for inclusion in Fsa.java. My program runs as a self-contained jar file: java -jar maketable.jar You can give it a filename or redirect standard input.

To assist you, the Fsa constructor is passed an Enumeration that is the token stream. There is no end-of-input token: the token stream is exhausted when the Enumeration has no more elements. Each element of the Enumeration is a Token x such that x.type() is one of the following:

non terminal obj S;
    terminal obj plus, minus, zero, one;
non terminal obj Rest, D;
    terminal obj bogus, not, really, used;
start with S;
S
	::= zero Rest
	|   one Rest
	;

Rest
	::= plus    D
	|   minus   D
	;

D
	::= zero
	|   one
	|   really
	;
                     

Start S
Edge S Rest zero
Edge S Rest one
Edge Rest D plus
Edge Rest D minus
Edge D $FINAL$ zero
Edge D $FINAL$ one
Edge D $FINAL$ really