1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

grammar Jinx;

@header {
package com.nosuchfield.jinx.code;
}

jinx: CLASS ID LEFT_BR classBody RIGHT_BR EOF;
classBody: (variable | print)*;
variable: VARIABLE ID EQUALS value;
print: PRINT ID;
value: STRING | INT | DOUBLE;

LEFT_BR: '{';
RIGHT_BR: '}';
CLASS: 'class';
VARIABLE: 'var';
PRINT: 'print';
EQUALS: '=';
STRING: '"' ('\\"' | ~'"')+ '"';
DOUBLE: [0-9]+ '.' [0-9]+;
INT: [0-9]+;
// 这个ID不能放在前面，不然会被提前解析，导致print等字符串被解析为ID
ID: [a-zA-Z] [a-zA-Z0-9]*;

WS: [\n\r\t ]+ -> skip;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

public class Loader extends JinxBaseListener {

    


    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;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
    
    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); 
    methodVisitor.visitEnd();
    classWriter.visitEnd();
    return classWriter.toByteArray();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public void apply(MethodVisitor mv) {
switch (type) {
    case JinxLexer.DOUBLE -> {
        double val = Double.parseDouble(value);
        
        mv.visitLdcInsn(val);
        
        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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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);
    
    List<Instruction> instructions = loader.getInstructions();
    
    String className = loader.getClassName();
    String classFile = Paths.get(new File(file).getParent(), className + ".class").toString();
    writeByteArrayToFile(classFile, generateBytecode(instructions, className));
}