week9 lõviosa materjalid

Author: sim642

.gitignore

@@ -17,3 +17,5 @@ gen
 
 # week3
 graphs
+# week9
+cmas

src/main/java/toylangs/bolog/BologCompiler.java

@@ -0,0 +1,25 @@
+package toylangs.bolog;
+
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import toylangs.bolog.ast.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class BologCompiler {
+
+    private static final List<String> VARS = Arrays.asList("P", "Q", "R", "S", "T", "U", "V"); // kasuta VARS.indexOf
+
+    private final CMaProgramWriter pw = new CMaProgramWriter();
+
+    public static CMaProgram compile(BologNode node) {
+        BologCompiler bologCompiler = new BologCompiler();
+        bologCompiler.compileNode(node);
+        return bologCompiler.pw.toProgram();
+    }
+
+    private void compileNode(BologNode node) {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/toylangs/dialoog/DialoogCompiler.java

@@ -0,0 +1,19 @@
+package toylangs.dialoog;
+
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import toylangs.dialoog.ast.*;
+
+public class DialoogCompiler {
+    private final CMaProgramWriter pw = new CMaProgramWriter();
+
+    public static CMaProgram compile(DialoogProg prog) {
+        DialoogCompiler dialoogCompiler = new DialoogCompiler();
+        dialoogCompiler.compileNode(prog);
+        return dialoogCompiler.pw.toProgram();
+    }
+
+    private void compileNode(DialoogNode node) {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/toylangs/dialoog/ast/DialoogBinary.java

@@ -1,5 +1,7 @@
 package toylangs.dialoog.ast;
 
+import cma.instruction.CMaBasicInstruction;
+
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -37,6 +39,10 @@ public BinaryOperator<Object> toJava() {
             return javaOp;
         }
 
+        public CMaBasicInstruction.Code toCMa() {
+            return CMaBasicInstruction.Code.valueOf(toString().substring(7).toUpperCase());
+        }
+
         private final static Map<String, BinOp> symbolMap =
                 Arrays.stream(BinOp.values()).collect(toMap(BinOp::getSymb, identity()));
 

src/main/java/toylangs/dialoog/ast/DialoogUnary.java

@@ -1,5 +1,7 @@
 package toylangs.dialoog.ast;
 
+import cma.instruction.CMaBasicInstruction;
+
 import java.util.Arrays;
 import java.util.Map;
 import java.util.function.UnaryOperator;
@@ -28,6 +30,10 @@ public UnaryOperator<Object> toJava() {
             return javaOp;
         }
 
+        public CMaBasicInstruction.Code toCMa() {
+            return CMaBasicInstruction.Code.valueOf(toString().substring(7).toUpperCase());
+        }
+
         private final static Map<String, UnOp> symbolMap =
                 Arrays.stream(UnOp.values()).collect(toMap(UnOp::getSymb, identity()));
 

src/main/java/toylangs/hulk/HulkCompiler.java

@@ -0,0 +1,37 @@
+package toylangs.hulk;
+
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import toylangs.hulk.ast.*;
+
+import java.util.*;
+
+import static cma.CMaUtils.bool2int;
+
+public class HulkCompiler {
+    private static final List<Character> SET_VARIABLES = Arrays.asList('X', 'A', 'B', 'C', 'D', 'G', 'H', 'V'); // kasuta SET_VARIABLES.indexOf
+
+    // kasuta hulga literaali teisendamiseks arvuks (bitset)
+    private static int set2int(Set<Character> set) {
+        List<Character> ELEM_VARIABLES = Arrays.asList('x', 'y', 'z', 'a', 'b', 'c', 'u', 'v');
+        int result = 0;
+        if (set != null) {
+            for (int i = 0; i < ELEM_VARIABLES.size(); i++) {
+                result |= bool2int(set.contains(ELEM_VARIABLES.get(i))) << i;
+            }
+        }
+        return result;
+    }
+
+    private final CMaProgramWriter pw = new CMaProgramWriter();
+
+    public static CMaProgram compile(HulkProg prog) {
+        HulkCompiler hulkCompiler = new HulkCompiler();
+        hulkCompiler.compileNode(prog);
+        return hulkCompiler.pw.toProgram();
+    }
+
+    private void compileNode(HulkNode node) {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/toylangs/imp/ImpCompiler.java

@@ -0,0 +1,52 @@
+package toylangs.imp;
+
+import cma.CMaInterpreter;
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import cma.CMaStack;
+import toylangs.imp.ast.*;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.*;
+
+import static toylangs.imp.ast.ImpNode.*;
+
+public class ImpCompiler {
+    private final CMaProgramWriter pw = new CMaProgramWriter();
+
+    public static CMaProgram compile(ImpProg prog) {
+        ImpCompiler impCompiler = new ImpCompiler();
+        impCompiler.compileNode(prog);
+        return impCompiler.pw.toProgram();
+    }
+
+    private void compileNode(ImpNode node) {
+        throw new UnsupportedOperationException();
+    }
+
+    static void main() throws IOException {
+        ImpProg prog = prog(
+                var('x'),
+
+                assign('x', num(5)),
+                assign('y', add(var('x'), num(1))),
+                assign('x', add(var('y'), num(1)))
+        );
+
+        // väärtustame otse
+        System.out.printf("eval: %d%n", ImpEvaluator.eval(prog));
+
+        // kompileeri avaldist arvutav CMa programm
+        CMaProgram program = compile(prog);
+
+        // kirjuta programm faili, mida saab Vam-iga vaadata
+        CMaStack initialStack = new CMaStack();
+        program.toFile(Paths.get("cmas", "imp.cma"), initialStack);
+
+        // interpreteeri CMa programm
+        CMaStack finalStack = CMaInterpreter.run(program, initialStack);
+        System.out.printf("compiled: %d%n", finalStack.peek());
+        System.out.printf("finalStack: %s%n", finalStack);
+    }
+}

src/main/java/toylangs/modul/ModulCompiler.java

@@ -0,0 +1,28 @@
+package toylangs.modul;
+
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import toylangs.modul.ast.*;
+
+import java.util.List;
+
+public class ModulCompiler {
+    public final CMaProgramWriter pw = new CMaProgramWriter();
+    private final int m;
+    private final List<String> variables;
+
+    protected ModulCompiler(int m, List<String> variables) {
+        this.m = m;
+        this.variables = variables;
+    }
+
+    public static CMaProgram compile(ModulProg prog, List<String> variables) {
+        ModulCompiler modulCompiler = new ModulCompiler(prog.modulus(), variables);
+        modulCompiler.compile(prog.expr());
+        return modulCompiler.pw.toProgram();
+    }
+
+    protected void compile(ModulExpr expr) {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/toylangs/modul/README.md

@@ -47,3 +47,15 @@ Süntaksile kehtivad järgmised nõuded:
 5.  Programm koosneb avaldisest ning sulgudes võtmesõnast `mod`, tühikust ja naturaalarvust.
 6.  Avaldistes võib kasutada sulge, mis on kõige kõrgema prioriteediga.
 7.  Tühisümboleid (tühikud, tabulaatorid, reavahetused) tuleb ignoreerida, välja arvatud ülal nõutud.
+
+## Lõviosa: ModulCompiler
+
+Klassis *ModulCompiler* tuleb implementeerida meetod *compile*, mis kompileerib programmi CMa programmiks. 
+Kompileerimisele kehtivad järgmised nõuded:
+
+1.  Muutujate väärtused antakse *stack*'il etteantud järjekorras.
+2.  Programmi täitmise lõpuks peab *stack*'i pealmine element olema avaldise väärtus, mis on sama nagu *ModulEvaluator*-iga väärtustades.
+3.  Programmi täitmise lõpuks tohivad *stack*'il olla ainult etteantud muutujate algsed väärtused ja arvutatud avaldise väärtus.
+4.  Defineerimata muutuja kasutamisel visatakse *ModulException* **kompileerimise ajal**.
+
+> **PS.** Kuna astendajad on konstantsed, siis astendamise saab kompileerida `DUP` ja `MUL` instruktsioonide jadaks.

src/main/java/toylangs/parm/ParmCompiler.java

@@ -0,0 +1,32 @@
+package toylangs.parm;
+
+import cma.CMaProgram;
+import cma.CMaProgramWriter;
+import toylangs.parm.ast.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static toylangs.parm.ast.ParmNode.*;
+
+public class ParmCompiler {
+
+    public static final List<String> VARS = Arrays.asList("X", "Y", "Z", "A", "B", "C", "D"); // kasuta VARS.indexOf
+
+    private final CMaProgramWriter pw = new CMaProgramWriter();
+
+    public static CMaProgram compile(ParmNode node) {
+        ParmCompiler parmCompiler = new ParmCompiler();
+        parmCompiler.compileNode(node);
+        return parmCompiler.pw.toProgram();
+    }
+
+    private void compileNode(ParmNode node) {
+        throw new UnsupportedOperationException();
+    }
+
+    static void main() {
+        CMaProgram cMaProgram = compile(plus(lit(10), lit(12)));
+        System.out.println(cMaProgram.toString());
+    }
+}