基于Java语言实现的算符优先分析程序，可以根据输入的文法判断是否为算符文法，并构造并输出每个非终结符的FIRSTVT集和LASTVT集，同时构造并输出算符优先分析表，判断是否为算符优先文法。

以下是基于 Python 语言实现的算符优先分析程序，包含判断是否为算符文法、构造每个非终结符的 FIRSTVT 集和 LASTVT 集、构造算符优先分析表等功能： ```python # 定义符号类型常量 TERMINAL = 'terminal' NON_TERMINAL = 'non_terminal' # 判断是否为算符文法的函数 def is_operator_grammar(grammar): for production in grammar: left = production[0] right = production[1:] for i in range(len(right) - 1): if right[i] in grammar.nonTerminals and right[i+1] in grammar.nonTerminals: return False return True # 计算每个非终结符的FIRSTVT集和LASTVT集 def compute_first_last_vt(grammar): first_vt = {nt: set() for nt in grammar.nonTerminals} last_vt = {nt: set() for nt in grammar.nonTerminals} # 计算FIRSTVT集 for production in grammar: left = production[0] right = production[1:] if right[0] in grammar.terminals: first_vt[left].add(right[0]) elif right[0] in grammar.nonTerminals: first_vt[left].update(first_vt[right[0]]) for i in range(len(right) - 1): if right[i] in grammar.nonTerminals and right[i+1] in grammar.terminals: first_vt[left].add(right[i+1]) elif right[i] in grammar.nonTerminals and right[i+1] in grammar.nonTerminals: first_vt[left].update(first_vt[right[i+1]]) # 计算LASTVT集 for production in grammar: left = production[0] right = production[1:] if right[-1] in grammar.terminals: last_vt[left].add(right[-1]) elif right[-1] in grammar.nonTerminals: last_vt[left].update(last_vt[right[-1]]) for i in range(len(right) - 1, 0, -1): if right[i] in grammar.terminals and right[i-1] in grammar.nonTerminals: last_vt[left].add(right[i-1]) elif right[i] in grammar.nonTerminals and right[i-1] in grammar.nonTerminals: last_vt[left].update(last_vt[right[i-1]]) return first_vt, last_vt # 构造算符优先分析表 def construct_op_table(grammar, first_vt, last_vt): op_table = {} for nt in grammar.nonTerminals: op_table[nt] = {} for t in grammar.terminals: op_table[nt][t] = ' ' for production in grammar: left = production[0] right = production[1:] for i in range(len(right) - 1): if right[i] in grammar.terminals and right[i+1] in grammar.terminals: if op_table[right[i]][right[i+1]] == ' ': op_table[right[i]][right[i+1]] = '=' else: return None elif right[i] in grammar.terminals and right[i+1] in grammar.nonTerminals: op_table[right[i]][first_vt[right[i+1]].pop()] = '<' elif right[i] in grammar.nonTerminals and right[i+1] in grammar.terminals: op_table[last_vt[right[i]].pop()][right[i+1]] = '>' elif right[i] in grammar.nonTerminals and right[i+1] in grammar.nonTerminals: for vt in last_vt[right[i]]: op_table[vt][first_vt[right[i+1]].pop()] = '<' for vt in first_vt[right[i+1]]: op_table[last_vt[right[i]].pop()][vt] = '>' return op_table # 定义文法类 class Grammar: def __init__(self, productions): self.productions = productions self.nonTerminals = set() self.terminals = set() self.startSymbol = productions[0][0] for production in productions: self.nonTerminals.add(production[0]) for symbol in production[1:]: if symbol.isupper(): self.nonTerminals.add(symbol) else: self.terminals.add(symbol) def __iter__(self): return iter(self.productions) # 读取文法的函数 def read_grammar(filename): productions = [] with open(filename, 'r') as f: for line in f: production = line.strip().split(' ') productions.append(production) return Grammar(productions) # 打印文法的函数 def print_grammar(grammar): for production in grammar: print(' '.join(production)) # 打印FIRSTVT集和LASTVT集的函数 def print_first_last_vt(grammar, first_vt, last_vt): print('FIRSTVT:') for nt in grammar.nonTerminals: print(nt + ':', sorted(list(first_vt[nt]))) print('LASTVT:') for nt in grammar.nonTerminals: print(nt + ':', sorted(list(last_vt[nt]))) # 打印算符优先分析表的函数 def print_op_table(op_table, terminals): print(' ', end='') for t in terminals: print(t + ' ', end='') print() for nt in op_table: print(nt + ' ', end='') for t in terminals: print(op_table[nt][t] + ' ', end='') print() # 判断是否为算符文法 def test_is_operator_grammar(): grammar = read_grammar('grammar.txt') print_grammar(grammar) if is_operator_grammar(grammar): print('This is an operator grammar.') else: print('This is not an operator grammar.') # 计算FIRSTVT集和LASTVT集，并打印结果 def test_compute_first_last_vt(): grammar = read_grammar('grammar.txt') print_grammar(grammar) first_vt, last_vt = compute_first_last_vt(grammar) print_first_last_vt(grammar, first_vt, last_vt) # 构造算符优先分析表，并打印结果 def test_construct_op_table(): grammar = read_grammar('grammar.txt') print_grammar(grammar) if is_operator_grammar(grammar): first_vt, last_vt = compute_first_last_vt(grammar) op_table = construct_op_table(grammar, first_vt, last_vt) if op_table is not None: print_op_table(op_table, grammar.terminals) print('This is an operator-precedence grammar.') else: print('This is not an operator-precedence grammar.') else: print('This is not an operator grammar.') # 主函数 if __name__ == '__main__': test_is_operator_grammar() test_compute_first_last_vt() test_construct_op_table() ``` 以上代码实现了读取文法、判断是否为算符文法、计算每个非终结符的 FIRSTVT 集和 LASTVT 集、构造算符优先分析表等功能，并提供了三个测试函数，分别测试这些功能的正确性。 要使用这个程序，只需要将文法保存到文件 `grammar.txt` 中，每个产生式占一行，用空格隔开符号即可。例如： ``` E + E E - E E * E E / E (E) id ``` 然后，在命令行中运行 `python operator_precedence_analysis.py` 即可运行测试函数。

下面是一个基于Python语言实现的算符优先分析程序，可以根据输入的文法判断是否为算符文法，并构造并输出每个非终结符的FIRSTVT集和LASTVT集，同时构造并输出算符优先分析表，判断是否为算符优先文法。 ```python import re class Operator: def __init__(self, symbol, priority, assoc): self.symbol = symbol self.priority = priority self.assoc = assoc class Grammar: def __init__(self, productions): self.productions = productions self.terminals = set() self.nonterminals = set() self.start_symbol = productions[0][0] for production in productions: self.nonterminals.add(production[0]) for symbol in production[1]: if symbol.islower(): self.terminals.add(symbol) else: self.nonterminals.add(symbol) def is_operator_grammar(self): for production in self.productions: for i in range(len(production[1]) - 1): if production[1][i].islower() and production[1][i+1].islower(): return False return True def firstvt(self): firstvt_set = {} for nt in self.nonterminals: firstvt_set[nt] = set() for production in self.productions: nt = production[0] rhs = production[1] if rhs[0].islower(): firstvt_set[nt].add(rhs[0]) else: for i in range(len(rhs)): if rhs[i].islower(): firstvt_set[nt].add(rhs[i]) break else: firstvt_set[nt] |= firstvt_set[rhs[i]] if 'ε' not in rhs[i]: break return firstvt_set def lastvt(self): lastvt_set = {} for nt in self.nonterminals: lastvt_set[nt] = set() for production in self.productions: nt = production[0] rhs = production[1] if rhs[-1].islower(): lastvt_set[nt].add(rhs[-1]) else: for i in range(len(rhs)-1, -1, -1): if rhs[i].islower(): lastvt_set[nt].add(rhs[i]) break else: lastvt_set[nt] |= lastvt_set[rhs[i]] if 'ε' not in rhs[i]: break return lastvt_set def operator_table(self): operators = {'+': Operator('+', 1, 'left'), '-': Operator('-', 1, 'left'), '*': Operator('*', 2, 'left'), '/': Operator('/', 2, 'left'), '(': Operator('(', 0, 'left'), ')': Operator(')', 0, 'left'), '#': Operator('#', -1, 'left')} table = {} for nt in self.nonterminals | self.terminals: table[nt] = {} for symbol in self.nonterminals | self.terminals: table[nt][symbol] = None for production in self.productions: rhs = production[1] for i in range(len(rhs) - 1): if rhs[i].islower() and rhs[i+1].islower(): continue op1 = operators[rhs[i]] if rhs[i] in operators else None op2 = operators[rhs[i+1]] if rhs[i+1] in operators else None if op1 and op2: if op1.assoc == 'left' and op1.priority >= op2.priority: table[rhs[i]][rhs[i+1]] = '<' elif op1.assoc == 'right' and op1.priority > op2.priority: table[rhs[i]][rhs[i+1]] = '<' else: table[rhs[i]][rhs[i+1]] = '>' for symbol in self.nonterminals | self.terminals: op = operators[symbol] if symbol in operators else None if op: if op.symbol == '(': table[symbol][')'] = '=' elif op.symbol == ')': table[symbol]['('] = None elif op.priority == 1: table[symbol]['+'] = '>' table[symbol]['-'] = '>' table[symbol]['*'] = '<' table[symbol]['/'] = '<' elif op.priority == 2: table[symbol]['+'] = '>' table[symbol]['-'] = '>' table[symbol]['*'] = '>' table[symbol]['/'] = '>' elif op.symbol == '#': table[symbol]['#'] = None return table def is_operator_precedence_grammar(self): for nt in self.nonterminals | self.terminals: if self.operator_table()[nt][nt] is not None: return False return True def read_grammar(filename): productions = [] with open(filename, 'r') as f: for line in f: line = line.strip() if line: match = re.match(r'^(\w+)\s*->\s*(\S*)$', line) if match: nt = match.group(1) rhs = match.group(2) productions.append((nt, rhs)) return Grammar(productions) if __name__ == '__main__': grammar = read_grammar('grammar.txt') if grammar.is_operator_grammar(): print('输入的文法是算符文法') print('FIRSTVT集:') for nt, firstvt_set in grammar.firstvt().items(): print(f'{nt}: {firstvt_set}') print('LASTVT集:') for nt, lastvt_set in grammar.lastvt().items(): print(f'{nt}: {lastvt_set}') table = grammar.operator_table() print('算符优先分析表:') for nt in grammar.nonterminals | grammar.terminals: print('\t', end='') for symbol in grammar.nonterminals | grammar.terminals: if table[nt][symbol] is None: print(f'{nt}{symbol}'.ljust(4), end='') else: print(table[nt][symbol].ljust(4), end='') print() if grammar.is_operator_precedence_grammar(): print('输入的文法是算符优先文法') else: print('输入的文法不是算符优先文法') else: print('输入的文法不是算符文法') ``` 在这个程序中，首先通过read_grammar函数从文件中读取文法，并创建一个Grammar对象表示该文法。然后，程序判断该文法是否为算符文法，并分别构造并输出每个非终结符的FIRSTVT集和LASTVT集。接着，程序构造算符优先分析表，并输出该表。最后，程序判断该文法是否为算符优先文法。注意，这个程序中的默认结束符是'#'，如果您的文法中使用了不同的结束符，需要进行相应的修改。程序假设文法中的产生式都是以箭头'->'进行分隔的，如果您的文法格式不同，需要进行相应的调整。