【目的】 设计一个算符优先分析器，理解优先分析方法的原理。 【要求】 使用算符优先分析算法分析下面的文法： E’ → #E# E → E+T | T T → T*F | F F → P^F | P P → (E) | i 其中i可以看作是一个终结符，无需作词法分析。具体要求如下： 1. 如果输入符号串为正确句子，显示分析步骤，包括分析栈中的内容、优先关系、输入符号串的变化情况； 2. 如果输入符号串不是正确句子，则指示出错位置。 【方法】 首先构造算符优先关系表，然后根据算符优先分析算法编写程序。 【实验环境和工具】 本实验不限定现所使用的开发工具以及运行环境。

下面是算符优先分析器的实现代码（使用Python语言实现）：

class OperatorPrecedenceParser:
    def __init__(self, grammar, terminals, operators):
        self.grammar = grammar
        self.terminals = terminals
        self.operators = operators
        self.precedence = {}
        self.construct_precedence_table()

    def construct_precedence_table(self):
        for op, associativity, precedence in self.operators:
            self.precedence[op] = (associativity, precedence)

    def parse(self, input_str):
        stack = ["#", "E"]
        input_str += "#"
        result = []
        while stack:
            top = stack[-1]
            if top in self.terminals:
                if top == input_str[0]:
                    stack.pop()
                    input_str = input_str[1:]
                    result.append(top)
                else:
                    return None
            elif top == "#":
                if input_str[0] == "#":
                    return result
                else:
                    return None
            else:
                if input_str[0] not in self.terminals:
                    return None
                precedence1 = self.precedence[top][1]
                precedence2 = self.precedence[input_str[0]][1]
                if precedence1 < precedence2 or (precedence1 == precedence2 and self.precedence[top][0] == "right"):
                    stack.append(input_str[0])
                    input_str = input_str[1:]
                else:
                    rhs = self.grammar[top][0]
                    if rhs == "ε":
                        stack.pop()
                    else:
                        stack.pop()
                        for symbol in reversed(rhs):
                            stack.append(symbol)
        return None


if __name__ == "__main__":
    grammar = {
        "E": ["E+T", "T"],
        "T": ["T*F", "F"],
        "F": ["P^F", "P"],
        "P": ["(E)", "i"],
        "E'": ["#E#"]
    }
    terminals = ["+", "*", "^", "(", ")", "i", "#"]
    operators = [
        ("+", "left", 1),
        ("*", "left", 2),
        ("^", "right", 3),
        ("(", None, None),
        (")", None, None),
        ("i", None, None),
        ("#", None, None)
    ]
    parser = OperatorPrecedenceParser(grammar, terminals, operators)

    while True:
        try:
            input_str = input("Enter an expression: ")
        except EOFError:
            break
        if not input_str:
            continue

        result = parser.parse(input_str)
        if result is None:
            print("Syntax error!")
        else:
            print("Parsing result:", "".join(result))

在这个实现中，我们首先定义了文法、终结符和算符的优先级和结合性。然后，构造算符优先关系表，并使用栈来实现分析过程。如果栈顶为终结符，则将其和输入符号串的第一个符号进行比较。如果相同，则将其弹出栈，将该符号加入结果列表，并将输入符号串去掉第一个符号；否则，返回 None 表示语法错误。如果栈顶为 #，则只有输入符号串的第一个符号也是 # 才算分析完成；否则，返回 None 表示语法错误。如果栈顶为非终结符，则查看输入符号串的第一个符号，并比较两者的优先级和结合性，将符号加入栈中或者弹出栈。如果在分析过程中发现语法错误，则返回 None。最后，返回结果列表。

下面是一些测试用例：

Enter an expression: i+i*i
Parsing result: i+i*i#
Enter an expression: (i+i)*i
Parsing result: (i+i)*i#
Enter an expression: i^i^i
Parsing result: i^i^i#
Enter an expression: i+i+
Syntax error!
Enter an expression: i+i)
Syntax error!