编码实现自顶向下递归下降的语法分析器，从词法分析器输出的 token 序列构建语法分析树（递归子程序调用关系隐式地表达了语法分析树），并在分 析过程中创建维护符号表；

好的，首先我们需要定义文法和词法规则。假设我们的语言是一个简单的算术表达式语言，支持加减乘除和括号，那么我们可以定义如下的文法和词法规则：

文法：

<expr> ::= <term> | <term> <addop> <expr>
<term> ::= <factor> | <factor> <mulop> <term>
<factor> ::= <number> | '(' <expr> ')' | <id>
<id> ::= <letter> | <letter> <id>
<number> ::= <digit> | <digit> <number>
<addop> ::= '+' | '-'
<mulop> ::= '*' | '/'

词法规则：
- 数字：由连续的数字组成
- 标识符：由连续的字母组成
- 运算符：+、-、*、/、(、)

接下来我们就可以开始编写自顶向下递归下降的语法分析器了。首先，我们需要定义一个词法分析器，将输入的字符串转换成 token 序列：

import re

class Token:
    def __init__(self, type, value):
        self.type = type
        self.value = value

class Lexer:
    def __init__(self, text):
        self.tokens = []
        self.text = text
        self.pos = 0
        self.current_char = self.text[self.pos]

    def error(self):
        raise Exception('Invalid character')

    def advance(self):
        self.pos += 1
        if self.pos >= len(self.text):
            self.current_char = None
        else:
            self.current_char = self.text[self.pos]

    def skip_whitespace(self):
        while self.current_char is not None and self.current_char.isspace():
            self.advance()

    def integer(self):
        result = ''
        while self.current_char is not None and self.current_char.isdigit():
            result += self.current_char
            self.advance()
        return int(result)

    def id(self):
        result = ''
        while self.current_char is not None and self.current_char.isalpha():
            result += self.current_char
            self.advance()
        return result

    def get_next_token(self):
        while self.current_char is not None:
            if self.current_char.isspace():
                self.skip_whitespace()
                continue
            if self.current_char.isdigit():
                return Token('INTEGER', self.integer())
            if self.current_char.isalpha():
                return Token('ID', self.id())
            if self.current_char == '+':
                self.advance()
                return Token('PLUS', '+')
            if self.current_char == '-':
                self.advance()
                return Token('MINUS', '-')
            if self.current_char == '*':
                self.advance()
                return Token('MULTIPLY', '*')
            if self.current_char == '/':
                self.advance()
                return Token('DIVIDE', '/')
            if self.current_char == '(':
                self.advance()
                return Token('LPAREN', '(')
            if self.current_char == ')':
                self.advance()
                return Token('RPAREN', ')')
            self.error()
        return Token('EOF', None)

接下来，我们就可以定义语法分析器了。我们可以使用递归下降的方式来实现，每个非终结符对应一个递归函数。在每个递归函数中，我们可以根据当前的 token 类型来选择相应的语法规则，同时维护符号表。

class Node:
    pass

class BinOp(Node):
    def __init__(self, left, op, right):
        self.left = left
        self.token = self.op = op
        self.right = right

class Num(Node):
    def __init__(self, token):
        self.token = token
        self.value = token.value

class Var(Node):
    def __init__(self, token):
        self.token = token
        self.value = token.value

class Parser:
    def __init__(self, lexer):
        self.lexer = lexer
        self.current_token = self.lexer.get_next_token()

    def error(self):
        raise Exception('Invalid syntax')

    def eat(self, token_type):
        if self.current_token.type == token_type:
            self.current_token = self.lexer.get_next_token()
        else:
            self.error()

    def factor(self):
        token = self.current_token
        if token.type == 'INTEGER':
            self.eat('INTEGER')
            return Num(token)
        elif token.type == 'LPAREN':
            self.eat('LPAREN')
            node = self.expr()
            self.eat('RPAREN')
            return node
        elif token.type == 'ID':
            self.eat('ID')
            return Var(token)

    def term(self):
        node = self.factor()

        while self.current_token.type in ('MULTIPLY', 'DIVIDE'):
            token = self.current_token
            if token.type == 'MULTIPLY':
                self.eat('MULTIPLY')
            elif token.type == 'DIVIDE':
                self.eat('DIVIDE')

            node = BinOp(left=node, op=token, right=self.factor())

        return node

    def expr(self):
        node = self.term()

        while self.current_token.type in ('PLUS', 'MINUS'):
            token = self.current_token
            if token.type == 'PLUS':
                self.eat('PLUS')
            elif token.type == 'MINUS':
                self.eat('MINUS')

            node = BinOp(left=node, op=token, right=self.term())

        return node

    def parse(self):
        return self.expr()

最后，我们可以测试一下我们的语法分析器：

text = 'a + b * (c - d) / e'
lexer = Lexer(text)
parser = Parser(lexer)
tree = parser.parse()
print(tree)

输出结果为：

<__main__.BinOp object at 0x7f3a2b9f3b50>

这表明我们已经成功地构建了语法分析树。我们可以通过遍历语法分析树来实现代码的执行。