P1 : Recognizer

Objectives

• Implement a recognizer based on the recursive descent algorithm

Description

In this program you are going to implement a recursive descent parser for recognizing sentences in the language defined by the following grammar.

<pop> -> [<bop>, <pop>] | <bop>
<bop> -> <boop> | (<pop>)
<boop> -> x | y | z

Specification

You may write this program in Java, C, C++, C# or any other language you know which can be run on onyx. You may work in groups of two people for this assignment.

• The program should read from standard input and write to standard output.
• The output of the program should be a message indicating whether the input was a valid sentence in the language. (e. g. Yes/No or Valid/Invalid) Explanations of what is wrong are optional.
• For this grammar, lexemes are single characters so lexical analysis is trivial. The program needs a variable (look-ahead) to store the next character from the input so that it can determine which rule to invoke.
• The main function should call next to read the first character into the look-ahead variable and then call pop (the start symbol). When pop returns, it should print a success message.
• Your recognizer will need four functions. The structure of each recursive descent function should reflect the grammar rules for the corresponding non-terminal. Each function should print an error message and quit if it gets an invalid character.
  • next - returns the character in the look-ahead variable when it is called. Before returning, it should read the next character from standard input into the look-ahead variable. Space and tab characters should be ignored; newlines can be assumed to terminate a sentence.
  • pop - the recursive descent function for the pop rule
  • bop - the recursive descent function for the bop rule
  • boop - the recursive descent function for the boop rule
• Modify the in the so that it correctly compiles and runs your program. This means you need to delete the rules for the languages you are not using. The clean rule should remove class files, object files and executables as appropriate for the language you are using.

Testing

I should be able to compile and run your program by typing

make run < testfile

make list

The directory on onyx has a makefile with rules for compiling and running the languages listed explicitly above and for running an executable file. For other languages, you need to figure out what command(s) are needed to run your program.

The handouts directory also contains some files containing both valid and invalid sentences from this language. You can use these to test your recognizer. If the name ends in a b, the sentence it contains is invalid. Try to come up with some tests of your own as well. Create a directory called tests and put your test files there. (These test files should be potential sentences that can be redirected into your program as input, similar to the examples I provided. If you write a test script or a JUnit test class, leave it in the main directory, document it in your README file and add a test rule to your makefile.)