Lernen, einen Compiler zu schreiben

Question

Bevorzugte Sprachen : C/C++, Java und Ruby.

Ich bin auf der Suche nach hilfreichen Büchern/Tutorials über das Schreiben eines eigenen Compilers, einfach zu Ausbildungszwecken. Ich kenne mich am besten mit C/C++, Java und Ruby aus, daher bevorzuge ich Quellen, die eine dieser drei beinhalten, aber jede gute Quelle ist akzeptabel.

Answer 1

Kein Buch, sondern eine technische Abhandlung und eine enorm unterhaltsame Lernerfahrung, wenn Sie mehr über Compiler (und Metacompiler) wissen wollen... Diese Website führt Sie durch den Aufbau eines völlig eigenständigen Compiler-Systems, das sich selbst und andere Sprachen kompilieren kann:

_Tutorial: Metacompiler Teil 1_

Dies alles basiert auf einem erstaunlichen 10-seitigen technischen Dokument:

Val Schorre META II: Eine Syntax-orientierte Compiler-Schreibsprache

aus dem ehrlichen Jahr 1964. Damit habe ich 1970 gelernt, wie man Compiler baut. Es gibt einen überwältigenden Moment, wenn man endlich begreift, wie der Compiler sich selbst regenerieren kann....

Ich kenne den Autor der Website aus meiner Studienzeit, aber ich habe nichts mit der Website zu tun.

Answer 2

Wenn Sie daran interessiert sind, einen Compiler für eine funktionale Sprache (und nicht für eine prozedurale Sprache) zu schreiben, ist Simon Peyton-Jones und David Lesters " Implementierung funktionaler Sprachen: ein Tutorium " ist ein hervorragender Leitfaden.

Die konzeptionellen Grundlagen der Funktionsauswertung werden anhand von Beispielen in einer einfachen, aber leistungsfähigen funktionalen Sprache namens "Core" vermittelt. Zusätzlich wird jeder Teil des Core-Sprachcompilers anhand von Codebeispielen in Miranda (einer rein funktionalen Sprache, die Haskell sehr ähnlich ist) erklärt.

Es werden mehrere verschiedene Arten von Compilern beschrieben, aber selbst wenn Sie nur den so genannten Template-Compiler für Core verfolgen, werden Sie ein ausgezeichnetes Verständnis dafür haben, wie funktionale Programmierung funktioniert.

Answer 3

Ich mochte die Crenshaw-Anleitung denn es macht deutlich, dass ein Compiler nur ein weiteres Programm ist, das eine Eingabe liest und eine Ausgabe schreibt.

Lesen Sie es.

Arbeiten Sie daran, wenn Sie wollen, aber schauen Sie sich dann eine andere Referenz an, wie größere und vollständigere Compiler wirklich geschrieben werden.

Und lesen Über das Vertrauen in das Vertrauen um eine Vorstellung davon zu bekommen, was man in diesem Bereich alles machen kann.

Answer 4

Sie können verwenden BCEL von der Apache Software Foundation. Mit diesem Tool können Sie Assembler-ähnlichen Code erzeugen, aber es ist Java mit der BCEL-API. Hier erfahren Sie, wie Sie Code in einer Zwischensprache (in diesem Fall Bytecode) erzeugen können.

Einfaches Beispiel

1. Erstellen Sie eine Java-Klasse mit dieser Funktion:

   public String maxAsString(int a, int b) {
       if (a > b) {
           return Integer.valueOf(a).toString();
       } else if (a < b) {
           return Integer.valueOf(b).toString();
       } else {
           return "equals";
       }
   }

Führen Sie nun BCELifier mit dieser Klasse aus

BCELifier bcelifier = new BCELifier("MyClass", System.out);
bcelifier.start();

Sie können das Ergebnis auf der Konsole für die gesamte Klasse sehen (wie man Bytecode MyClass.java erstellt). Der Code für die Funktion lautet wie folgt:

private void createMethod_1() {
  InstructionList il = new InstructionList();
  MethodGen method = new MethodGen(ACC_PUBLIC, Type.STRING, new Type[] { Type.INT, Type.INT }, new String[] { "arg0", "arg1" }, "maxAsString", "MyClass", il, _cp);

  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load first parameter to address 1
  il.append(InstructionFactory.createLoad(Type.INT, 2)); // Load second parameter to adress 2
    BranchInstruction if_icmple_2 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPLE, null); // Do if condition (compare a > b)
  il.append(if_icmple_2);
  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load value from address 1 into the stack
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_13 = il.append(InstructionFactory.createLoad(Type.INT, 1));
  il.append(InstructionFactory.createLoad(Type.INT, 2));
    BranchInstruction if_icmpge_15 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPGE, null); // Do if condition (compare a < b)
  il.append(if_icmpge_15);
  il.append(InstructionFactory.createLoad(Type.INT, 2));
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_26 = il.append(new PUSH(_cp, "equals")); // Return "equals" string
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  if_icmple_2.setTarget(ih_13);
  if_icmpge_15.setTarget(ih_26);
  method.setMaxStack();
  method.setMaxLocals();
  _cg.addMethod(method.getMethod());
  il.dispose();
}

Answer 5

Ich bin überrascht, dass es noch nicht erwähnt wurde, aber Donald Knuths Die Kunst der Computerprogrammierung wurde ursprünglich als eine Art Anleitung zum Schreiben von Compilern verfasst.

Natürlich hat Dr. Knuths Neigung, Themen in die Tiefe zu gehen, dazu geführt, dass das Compiler-Schreib-Tutorial auf schätzungsweise 9 Bände erweitert wurde, von denen nur drei tatsächlich veröffentlicht wurden. Es ist eine ziemlich vollständige Darstellung von Programmierthemen und deckt alles ab, was man jemals über das Schreiben eines Compilers wissen muss, und zwar bis ins kleinste Detail.