产生式 语义规则 0)L->E { print(E.val) } 1)E->E1+T { E.val:=E1.val+T.val} 2)E->T { E.val:=T.val} 3)T->T1*F { T.val:=T1.val*F.val} 4)T->F { T.val:=F.val} 5)F->(E) { F.val:=E.val} 6)F->digit { F.val:=digit.lexval} 在上述属性文法基础上，请补充语义子程序，使得基于修改后的属性文法结合LR分析进行语法制导翻译，对表达式2+3*5，既能求得值17，又能同时生成四元式序列如下： （1）（*，3，5，t1） （2）（+，2，t1，t2）

以下为补充的语义子程序：

# 初始化符号栈和值栈
symbol_stack = []
value_stack = []

# 将当前符号入栈
def push_symbol(symbol):
  symbol_stack.append(symbol)

# 将当前值入栈
def push_value(value):
  value_stack.append(value)

# 从符号栈中弹出一个符号
def pop_symbol():
  return symbol_stack.pop()

# 从值栈中弹出一个值
def pop_value():
  return value_stack.pop()

# 生成四元式，将四元式加入四元式列表
quad_list = []
def gen_quad(op, arg1, arg2, result):
  quad_list.append((op, arg1, arg2, result))

# 语义规则对应的语义动作
def action0():
  # 表达式求值完成，输出结果
  print(value_stack[0])

def action1():
  # 计算 E1 + T 的值，生成四元式
  t1 = pop_value()
  e1 = pop_value()
  result = 't' + str(len(value_stack) + 1)
  gen_quad('+', e1, t1, result)
  push_value(result)

def action2():
  # T 的值为 F 的值，将 T 的值入栈
  push_value(pop_value())

def action3():
  # 计算 T1 * F 的值，生成四元式
  f = pop_value()
  t1 = pop_value()
  result = 't' + str(len(value_stack) + 1)
  gen_quad('*', t1, f, result)
  push_value(result)

def action4():
  # F 的值为数字，将 F 的值入栈
  push_value(int(pop_symbol()))

def action5():
  # F 的值为括号内表达式的值，将 F 的值入栈
  pop_symbol()  # 弹出右括号
  push_value(pop_value())
  pop_symbol()  # 弹出左括号

在这个语义子程序中，我们使用了两个栈：符号栈和值栈。符号栈用于存储正在处理的符号，而值栈用于存储表达式中已经求值的部分。在每个语义动作中，我们根据当前处理的符号和值栈中的值，执行相应的操作，然后将新的符号和值入栈。如果需要生成四元式，我们调用 `gen_quad` 函数，并将生成的四元式加入四元式列表 `quad_list` 中。

在此基础上，我们可以将表达式2+3*5转化为 LR 分析表中的符号串，然后使用 LR 分析器进行语法制导翻译。最终得到的值为17，四元式序列为：

( *, 3, 5, t1 )
( +, 2, t1, t2 )