Kompilaatori kodutöö, vihje 2
package week10;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import week7.AktkAst;
import week7.ast.*;
import week9.AktkBinding;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.objectweb.asm.Opcodes.*;
public class AktkCompiler {
static void main(String[] args) throws IOException {
// lihtsam viis "käsurea parameetrite andmiseks":
//args = new String[] {"inputs/yks_pluss_yks.aktk"};
if (args.length != 1) {
throw new IllegalArgumentException("Sellele programmile tuleb anda parameetriks kompileeritava AKTK faili nimi");
}
Path sourceFile = Paths.get(args[0]);
if (!Files.isRegularFile(sourceFile)) {
throw new IllegalArgumentException("Ei leia faili nimega '" + sourceFile + "'");
}
String className = sourceFile.getFileName().toString().replace(".aktk", "");
Path classFile = sourceFile.toAbsolutePath().getParent().resolve(className + ".class");
createClassFile(sourceFile, className, classFile);
}
private static void createClassFile(Path sourceFile, String className, Path classFile) throws IOException {
// loen faili sisu muutujasse
String source = Files.readString(sourceFile);
// parsin ja moodustan AST'i
Statement ast = AktkAst.createAst(source);
// seon muutujad
AktkBinding.bind(ast);
// kompileerin
byte[] bytes = createClass(ast, className);
Files.write(classFile, bytes);
}
public static byte[] createClass(Statement statement, String className) {
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
// Klassi attribuudid
cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, className, null, "java/lang/Object", null);
cw.visitSource(null, null);
// main meetod
MethodVisitor mv = cw.visitMethod(
ACC_PUBLIC + ACC_STATIC, // modifikaatorid
"main", // meetodi nimi
"([Ljava/lang/String;)V", // meetodi kirjeldaja
null, // geneerikute info
new String[] { "java/io/IOException" });
mv.visitCode();
// terve AKTK programm tuleb kompileerida main meetodi sisse
new AktkCompiler(mv).compileStatement(statement);
mv.visitInsn(RETURN);
mv.visitMaxs(0, 0);
mv.visitEnd();
// klassi lõpetamine
cw.visitEnd();
// klassi baidijada genereerimine
return cw.toByteArray();
}
private final MethodVisitor mv;
private final Map<VariableBinding, Integer> variableIndices = new HashMap<>();
public AktkCompiler(MethodVisitor mv) {
this.mv = mv;
}
private int getVariableIndex(VariableBinding binding) {
// Kasuta teadaolevat indeksit, kui see on olemas,
// või leia järgmine vaba indeks ja salvesta see.
// Esimene muutuja saab indeksi 1, sest indeksil 0 on main meetodi parameeter (String args[]).
return variableIndices.computeIfAbsent(binding, ignoreBinding -> variableIndices.size() + 1);
}
private void compileStatement(Statement statement) {
switch (statement) {
case Assignment assignment -> {
// 1) genereeri avaldise väärtustamise kood
// 2) genereeri väärtuse muutujasse salvestamise kood
}
case Block(List<Statement> statements) -> {
for (Statement stmt : statements) {
compileStatement(stmt);
}
}
case ExpressionStatement(Expression expression) -> {
// NB! Ära unusta, et ExpressionStatement viskab arvutatud väärtuse minema
}
case FunctionDefinition _ ->
throw new UnsupportedOperationException("cannot compile function definitions");
case IfStatement(Expression condition, Block thenBranch, Block elseBranch) -> {
Label doneLabel = new Label();
Label elseLabel = new Label();
// ...
}
case ReturnStatement _ -> throw new UnsupportedOperationException("cannot compile return statements");
case VariableDeclaration variableDeclaration -> {
}
case WhileStatement(Expression condition, Block body) -> {
}
}
}
private void compileExpression(Expression expression) {
switch (expression) {
case FunctionCall functionCall -> {
// genereeri argumentide väärtustamise kood
if (functionCall.isArithmeticOperation()) {
compileArithmeticOperation(functionCall);
} else if (functionCall.isComparisonOperation()) {
compileComparisonOperation(functionCall);
} else {
compileBuiltinFunction(functionCall);
}
}
case IntegerLiteral(Integer value) -> {
}
case StringLiteral(String value) -> throw new UnsupportedOperationException("cannot compile strings");
case Variable variable -> {
}
}
}
private void compileArithmeticOperation(FunctionCall functionCall) {
}
private void compileComparisonOperation(FunctionCall call) {
}
private void compileBuiltinFunction(FunctionCall functionCall) {
}
}
