public class Loader extends JinxBaseListener {

    /**
     * 变量表，以变量名为key，包括：变量索引idx、变量类型
     */
    private final Map<String, ImmutablePair<Integer, Integer>> variables = new HashMap<>();

    /**
     * 指令列表
     */
    private final List<Instruction> instructions = new ArrayList<>();

    private String className;

    @Override
    public void enterJinx(JinxParser.JinxContext ctx) {
        className = ctx.ID().getText();
    }

    @Override
    public void exitVariable(JinxParser.VariableContext ctx) {
        // 变量名
        String name = ctx.ID().getText();
        JinxParser.ValueContext variable = ctx.value();
        // 变量值
        String text = variable.getText();
        // 变量类型
        int type = variable.getStart().getType();
        // 变量索引（在局部变量表中这是第几个变量）
        int idx = variables.size();

        // 把这个变量保存在内存，方便后面知道这个变量的索引和类型
        variables.put(name, ImmutablePair.of(idx, type));
        // 创建保存这个变量的指令
        instructions.add(new VariableInstruction(idx, type, text));
    }

    @Override
    public void exitPrint(JinxParser.PrintContext ctx) {
        String name = ctx.ID().getText();
        if (!variables.containsKey(name)) {
            System.err.printf("variable %s not exist\n", name);
            System.exit(1);
        }
        int idx = variables.get(name).getLeft();
        int type = variables.get(name).getRight();
        // 创建打印的指令
        instructions.add(new PrintInstruction(idx, type));
    }

    public List<Instruction> getInstructions() {
        return instructions;
    }

    public String getClassName() {
        return className;
    }

}

private byte[] generateBytecode(List<Instruction> instructions, String className) {
    ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
    classWriter.visit(V1_8, ACC_PUBLIC + ACC_SUPER, className, null, "java/lang/Object", null);
    // main方法
    MethodVisitor methodVisitor = classWriter.visitMethod(ACC_PUBLIC + ACC_STATIC, "main",
            "([Ljava/lang/String;)V", null, null);
    for (Instruction instruction : instructions) {
        instruction.apply(methodVisitor);
    }
    methodVisitor.visitInsn(RETURN);
    methodVisitor.visitMaxs(0, 0); // 设置COMPUTE_FRAMES后会自动计算，但是此处设置不能省略
    methodVisitor.visitEnd();
    classWriter.visitEnd();
    return classWriter.toByteArray();
}

public void apply(MethodVisitor mv) {
switch (type) {
    case JinxLexer.DOUBLE -> {
        double val = Double.parseDouble(value);
        // 常量池的数据推到栈顶
        mv.visitLdcInsn(val);
        // 栈顶double值存入本地局部变量，idx代表索引
        mv.visitVarInsn(DSTORE, idx);
    }
    case JinxLexer.INT -> {
        int val = Integer.parseInt(value);
        mv.visitLdcInsn(val);
        mv.visitVarInsn(ISTORE, idx);
    }
    case JinxLexer.STRING -> {
        mv.visitLdcInsn(Utils.removeFirstAndLastChar(value));
        mv.visitVarInsn(ASTORE, idx);
    }
}

public void apply(MethodVisitor mv) {
    mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
    switch (type) {
        case JinxLexer.INT -> {
            mv.visitVarInsn(ILOAD, idx);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(I)V", false);
        }
        case JinxLexer.DOUBLE -> {
            mv.visitVarInsn(DLOAD, idx);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(D)V", false);
        }
        case JinxLexer.STRING -> {
            mv.visitVarInsn(ALOAD, idx);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }
    }
}

public void compile0(String file) throws IOException {
    // 词法分析
    JinxLexer lexer = new JinxLexer(CharStreams.fromFileName(file));
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    // 语法分析
    JinxParser parser = new JinxParser(tokens);
    parser.removeErrorListeners();
    parser.addErrorListener(new ErrorHandler()); // 语法分析错误处理
    ParseTree tree = parser.jinx();
    // 语法树遍历
    ParseTreeWalker parseTreeWalker = new ParseTreeWalker();
    Loader loader = new Loader();
    parseTreeWalker.walk(loader, tree);
    // 遍历语法树生成Java指令
    List<Instruction> instructions = loader.getInstructions();
    // 生成Java.class文件
    String className = loader.getClassName();
    String classFile = Paths.get(new File(file).getParent(), className + ".class").toString();
    writeByteArrayToFile(classFile, generateBytecode(instructions, className));
}