生成一个可以输入压缩了的上下文无关文法的LR（0）语法分析的代码，用Python实现

以下是一个可以输入压缩了的上下文无关文法的LR(0)语法分析器的Python代码：

# LR(0)语法分析器

# 读取输入的文法
def read_grammar():
    grammar = {}
    while True:
        rule = input().strip().split('->')
        if rule[0] == '':
            break
        grammar[rule[0]] = []
        for r in rule[1].split('|'):
            grammar[rule[0]].append(r.strip().split(' '))
    return grammar

# 构造LR(0)自动机的状态
def closure(I, grammar):
    while True:
        flag = False
        for item in I:
            if item[-1] in grammar:
                for rule in grammar[item[-1]]:
                    new_item = item[:-1] + ['.'] + rule
                    if new_item not in I:
                        I.append(new_item)
                        flag = True
        if not flag:
            break
    return I

# 计算LR(0)自动机的状态转移函数
def goto(I, X, grammar):
    J = []
    for item in I:
        if item[-1] == X and len(item) > 1:
            J.append(item[:-1] + [X, '.'])
    return closure(J, grammar)

# 构造LR(0)自动机
def build_LR0_automaton(grammar):
    C = [closure([['.', list(grammar.keys())[0]]], grammar)]
    L = {}
    i = 0
    while i < len(C):
        I = C[i]
        for X in set([item[-1] for item in I if item[-1] in grammar]):
            J = goto(I, X, grammar)
            if J != [] and J not in C:
                C.append(J)
            if (i, X) not in L:
                L[(i, X)] = C.index(J)
        i += 1
    return C, L

# 构造LR(0)分析表
def build_LR0_table(C, L, grammar):
    action = {}
    goto = {}
    for i in range(len(C)):
        for item in C[i]:
            if item[-1] == '.' and len(item) > 1:
                for a in grammar[item[-2]]:
                    if (i, a) not in action:
                        action[(i, a)] = ('shift', L[(i, a)])
                    else:
                        print('Error: Shift-Reduce Conflict')
            elif item[-1] == '.' and len(item) == 1 and item[0] != list(grammar.keys())[0]:
                for a in grammar.keys():
                    if (i, a) not in action:
                        action[(i, a)] = ('reduce', item[:-1], grammar[item[:-1]])
                    else:
                        print('Error: Reduce-Reduce Conflict')
        for X in grammar:
            if (i, X) in L:
                if X not in goto:
                    goto[(i, X)] = L[(i, X)]
                else:
                    print('Error: Goto-Goto Conflict')
    return action, goto

# LR(0)语法分析器
def LR0_parser(input_str, action, goto):
    stack = [0]
    input_str += '$'
    i = 0
    while True:
        s = stack[-1]
        a = input_str[i]
        if (s, a) not in action:
            print('Error: Invalid Input')
            return False
        act = action[(s, a)]
        if act[0] == 'shift':
            stack.append(a)
            stack.append(act[1])
            i += 1
        elif act[0] == 'reduce':
            for j in range(2 * len(act[2])):
                stack.pop()
            t = stack[-1]
            stack.append(act[1])
            stack.append(goto[(t, act[1])])
        elif act[0] == 'accept':
            print('Accept')
            return True

使用方法：

1. 首先，调用 `read_grammar()` 函数读取输入的文法，例如：

E -> E + T | T
T -> T * F | F
F -> ( E ) | id

2. 然后，调用 `build_LR0_automaton(grammar)` 函数构造LR(0)自动机，其中 `grammar` 是上一步读取到的文法，例如：

C, L = build_LR0_automaton(grammar)

3. 接下来，调用 `build_LR0_table(C, L, grammar)` 函数构造LR(0)分析表，其中 `C` 和 `L` 分别是上一步构造的LR(0)自动机的状态集和状态转移函数，`grammar` 是文法，例如：

action, goto = build_LR0_table(C, L, grammar)

4. 最后，调用 `LR0_parser(input_str, action, goto)` 函数进行语法分析，其中 `input_str` 是输入的字符串，例如：

LR0_parser('id + id * id', action, goto)