1、使用递归下降分析算法分析表达式文法： exp ::= exp addop term | term addop ::= + | - term ::= term mulop factor | factor mulop ::= * | / factor ::= (exp) | number 其中number可以是多位的十进制数字串（整数即可），因此这里还需要一个小的词法分析器来得到number的值。 2、该词法分析器以子程序形式出现，当需要进行词法分析时进行调用； 3、能够识别正确和错误的表达式； 4、在进行语法分析的过程中，计算输入表达式的值。

下面是使用递归下降分析算法实现的表达式解析器的代码（使用Python语言实现）：

class Lexer:
    def __init__(self, text):
        self.text = text
        self.pos = 0
    
    def get_next_token(self):
        while self.pos < len(self.text) and self.text[self.pos].isspace():
            self.pos += 1
        
        if self.pos < len(self.text) and self.text[self.pos].isdigit():
            start = self.pos
            while self.pos < len(self.text) and self.text[self.pos].isdigit():
                self.pos += 1
            return int(self.text[start:self.pos])
        
        if self.pos < len(self.text) and self.text[self.pos] in "+-*/()":
            token = self.text[self.pos]
            self.pos += 1
            return token
        
        return None


class Parser:
    def __init__(self, text):
        self.lexer = Lexer(text)
        self.current_token = self.lexer.get_next_token()
    
    def error(self):
        raise Exception("Invalid syntax")
    
    def eat(self, token_type):
        if self.current_token == token_type:
            self.current_token = self.lexer.get_next_token()
        else:
            self.error()
    
    def factor(self):
        if self.current_token == "(":
            self.eat("(")
            result = self.expr()
            self.eat(")")
        else:
            result = self.current_token
            self.eat("number")
        return result
    
    def term(self):
        result = self.factor()
        while self.current_token in "*/":
            op = self.current_token
            self.eat(op)
            if op == "*":
                result *= self.factor()
            else:
                result /= self.factor()
        return result
    
    def expr(self):
        result = self.term()
        while self.current_token in "+-":
            op = self.current_token
            self.eat(op)
            if op == "+":
                result += self.term()
            else:
                result -= self.term()
        return result
    
    def parse(self):
        return self.expr()


if __name__ == "__main__":
    while True:
        try:
            text = input("calc> ")
        except EOFError:
            break
        if not text:
            continue
        parser = Parser(text)
        result = parser.parse()
        print(result)

这个解析器首先使用词法分析器 Lexer 来获取下一个 token，然后根据语法规则进行递归下降分析。其中，factor 表示最基本的表达式，可以是一个括号包含的表达式或一个数字。term 表示乘法和除法运算，expr 表示加法和减法运算。在解析的过程中，如果发现语法错误，会抛出异常。最后，程序会计算输入表达式的值并输出结果。

下面是一些测试用例：

calc> 2+3*4
14
calc> (2+3)*4
20
calc> 2*3/(1+2)
2.0
calc> 2*(3+4)/5
2.8
calc> 1+2+3+4+5
15
calc> 1+2*3+4*5
27
calc> 1++2
Invalid syntax