Java-在简单的递归下降解析器上扩展

Question

I've written this simple recursive parser method that evaluates simple arithmetic expressions (consisting of only +, -, *, and /).

However, I am currently stuck on a few things:

1. How do I implement the recognition of parentheses?
2. How do I implement the recognition of unary operators? eg unary minus (-) and factorial (!)

3. How do I implement the recognition of functions? eg sin(x)

    private static double eval(String s) { if (s.charAt(0) == '-' || s.charAt(0) == '+') { s = "0" + s; } if (s.indexOf("+") > -1) { return (eval(s.substring(0, s.indexOf("+"))) + eval(s.substring(s.indexOf("+") + 1, s.length()))); } else if (s.indexOf("-") > -1) { return (eval(s.substring(0, s.indexOf("-"))) - eval(s.substring(s.indexOf("-") + 1, s.length()))); } else if (s.indexOf("*") > -1) { return (eval(s.substring(0, s.indexOf("*"))) * eval(s.substring(s.indexOf("*") + 1, s.length()))); } else if (s.indexOf("/") > -1) { return (eval(s.substring(0, s.indexOf("/"))) / eval(s.substring(s.indexOf("/") + 1, s.length()))); } else if (s.indexOf("^") > -1) { return (Math.pow(evaluate(s.substring(0, s.indexOf("^"))), evaluate(s.substring(s.indexOf("^") + 1, s.length())))); } return Double.parseDouble(s); } 

Any help is appreciated. Thanks in advance!

Answer 1

It looks like broad one but I'll try to put here my thought instead unreadable comment.

1. Looking for parantheses can be tricky because there are ones used for precedence and other for function arguments. What I'd do is to first look for '('. If it follows function, then skip it, otherwise go through all characters that follow until number of '(' == ')' and that would be what you pass to eval, everything before , between () and after ) would go to separate call to eval().

2. For unary operator '-' you'll most likely need to lookup previous character in you expression. Something like:

    } else if (s.indexOf("-") > -1) { // keeping this index would make more sense now if char at index -1 from '-' in list of characters indicating unary operator return -eval(s.substring(s.indexOf("-")+1, s.length()))); else { return (eval(s.substring(0, s.indexOf("-"))) - eval(s.substring(s.indexOf("-") + 1, s.length()))); } } 

These characters would absolutely be parantheses, other operators or if '-' had index 0. Just ask yourself how do you recognize unary operator and apply the same rules here.

The same approach would be for '!':

if(s.indexOf("!") > -1) {
    return fact(eval(s.substring(s.indexOf("-") + 1, s.length())));
}

EDIT: As the OP correctly noticed, this approach would skip some expression parts so what's to be done for both functions and unary operators:

return eval(everything before + eval(expression)+ everything after);

3. Functions look exactly like unary operators, you only need to figure out precedence, so just put recognition of 'sin(' before looking for operators. Then apply the same approach as with unary operators. If you find function you remove the last closing parantheses.

    return fun(eval(rest of expression)); 

Hope those thoughts help you a bit.