Question

Choose a statement for a programming language of your choice and write a BNF production that defines the syntax of that statement. Clearly distinguish between the terminal and nonterminals symbols.

Then write a Java method that will parse that statement using recursive descent. You may assume that a method getNextToken is available to get the next terminal symbol and that there are methods available to parse each of the nonterminals.

Answer 1

<expression> ::= <number> | "(" <expression>

<Operator> <expression> ")"

<Operator> ::= "+" | "-" | "*" | "/"

Where <number> refers to any non negative real number. An example of a fully parenthesized expression is " (((34-17*8) + (2*7))".

Since every operator corresponds to pair of parentheses, there is no ambiguity about the order in which the operators are to be applied. Suppose we want a program that will read and evaluate such expressions.

To apply recursive decent parsing parsing, we need a subroutine for each rule in the grammar.

Corresponding to the rule for <operator>, we get a subroutine that reads an operator. The operator can be a choice of any of four things. Any other input will be an error.

/**

* If the next character in the input is one of the legal operators, read it and return it, otherwise, through a ParseError.

*/

Static char getoperator () throws ParseError{

TextIO.skipBlanks();

Char op = textIO.peek(); //look ahead at the next char, without reading it

if (op== '+' || op=='-' || op == '*' || op == '/' ) {

TextIO.getAnyChar(); // read the operation, to remove it from the input

return op;

}

else if

(op=='\n') through new ParseError ("Missing operator at end of line");

else

through new ParseError("Missing Operator. Found \ "" + op + "\" instead of +, -,*, or /. ");

}// end getOperator().

}

/**

* An object of type ParseError represents a syntax error found in the user's input.

*/

Private static class ParseError extends Exception {

ParseError(Stiring message){

Super(message);

}

}//end of nested class ParseError.