写一个Java代码，实现 语义分析与中间代码生成，输出四元式

以下是一个简单的 Java 代码，实现了一个简单的语义分析器和中间代码生成器，并输出了对应的四元式：

import java.util.*;

public class SemanticAnalyzer {
    private List<Token> tokens;
    private int tokenIndex;
    private Map<String, Symbol> symbolTable;
    private List<Quadruple> quadruples;

    public SemanticAnalyzer(List<Token> tokens) {
        this.tokens = tokens;
        this.tokenIndex = 0;
        this.symbolTable = new HashMap<>();
        this.quadruples = new ArrayList<>();
    }

    public List<Quadruple> analyze() {
        program();
        return quadruples;
    }

    private void program() {
        while (tokenIndex < tokens.size()) {
            statement();
        }
    }

    private void statement() {
        Token token = tokens.get(tokenIndex);
        if (token.getType() == TokenType.IDENTIFIER) {
            String name = token.getValue();
            Symbol symbol = symbolTable.get(name);
            if (symbol == null) {
                symbol = new Symbol(name);
                symbolTable.put(name, symbol);
            }
            tokenIndex++;
            token = tokens.get(tokenIndex);
            if (token.getType() == TokenType.ASSIGN) {
                tokenIndex++;
                int value = expression();
                quadruples.add(new Quadruple(Operator.ASSIGN, value, null, symbol));
            }
        } else {
            error("Expecting identifier");
        }
    }

    private int expression() {
        int value = term();
        Token token = tokens.get(tokenIndex);
        while (token.getType() == TokenType.PLUS || token.getType() == TokenType.MINUS) {
            tokenIndex++;
            int termValue = term();
            Symbol result = new Symbol("t" + (symbolTable.size() + 1));
            symbolTable.put(result.getName(), result);
            Operator operator = token.getType() == TokenType.PLUS ? Operator.PLUS : Operator.MINUS;
            quadruples.add(new Quadruple(operator, value, termValue, result));
            value = result;
            token = tokens.get(tokenIndex);
        }
        return value;
    }

    private int term() {
        int value = factor();
        Token token = tokens.get(tokenIndex);
        while (token.getType() == TokenType.MULTIPLY || token.getType() == TokenType.DIVIDE) {
            tokenIndex++;
            int factorValue = factor();
            Symbol result = new Symbol("t" + (symbolTable.size() + 1));
            symbolTable.put(result.getName(), result);
            Operator operator = token.getType() == TokenType.MULTIPLY ? Operator.MULTIPLY : Operator.DIVIDE;
            quadruples.add(new Quadruple(operator, value, factorValue, result));
            value = result;
            token = tokens.get(tokenIndex);
        }
        return value;
    }

    private int factor() {
        Token token = tokens.get(tokenIndex);
        if (token.getType() == TokenType.NUMBER) {
            int value = Integer.parseInt(token.getValue());
            tokenIndex++;
            return value;
        } else if (token.getType() == TokenType.IDENTIFIER) {
            String name = token.getValue();
            Symbol symbol = symbolTable.get(name);
            if (symbol != null) {
                tokenIndex++;
                return symbol;
            } else {
                error("Undefined identifier: " + name);
            }
        } else {
            error("Expecting number or identifier");
        }
        return 0;
    }

    private void error(String message) {
        throw new RuntimeException("Semantic error: " + message);
    }
}

class Symbol {
    private String name;

    public Symbol(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Quadruple {
    private Operator operator;
    private Object arg1;
    private Object arg2;
    private Object result;

    public Quadruple(Operator operator, Object arg1, Object arg2, Object result) {
        this.operator = operator;
        this.arg1 = arg1;
        this.arg2 = arg2;
        this.result = result;
    }

    public Operator getOperator() {
        return operator;
    }

    public Object getArg1() {
        return arg1;
    }

    public Object getArg2() {
        return arg2;
    }

    public Object getResult() {
        return result;
    }

    public String toString() {
        return "(" + operator + ", " + arg1 + ", " + arg2 + ", " + result + ")";
    }
}

enum Operator {
    ASSIGN,
    PLUS,
    MINUS,
    MULTIPLY,
    DIVIDE
}

这个代码实现了一个简单的表达式语言的语义分析器和中间代码生成器。它支持变量赋值、加减乘除等基本操作，并且会生成对应的四元式。

你可以按照以下方式使用这个代码：

List<Token> tokens = // 词法分析器生成的 Token 列表
SemanticAnalyzer analyzer = new SemanticAnalyzer(tokens);
List<Quadruple> quadruples = analyzer.analyze();
for (Quadruple q : quadruples) {
    System.out.println(q);
}

输出的结果应该会是一些四元式，形如 `(operator, arg1, arg2, result)`。