week6 materjalid

Author: sim642

src/main/java/week6/AktkHandwrittenParser.java

@@ -0,0 +1,11 @@
+package week6;
+
+import static week5.AktkToken.Type.*;
+
+public class AktkHandwrittenParser {
+
+    public static AktkNode parse(String input) {
+        throw new UnsupportedOperationException();
+    }
+
+}

src/main/java/week6/AktkNode.java

@@ -0,0 +1,38 @@
+package week6;
+
+import java.util.Map;
+
+import static week5.AktkToken.Type.*;
+
+public interface AktkNode {
+
+    static AktkNode num(int value) {
+        throw new UnsupportedOperationException();
+    }
+
+    static AktkNode var(String name) {
+        throw new UnsupportedOperationException();
+    }
+
+    static AktkNode plus(AktkNode left, AktkNode right) {
+        throw new UnsupportedOperationException();
+    }
+
+    static AktkNode minus(AktkNode left, AktkNode right) {
+        throw new UnsupportedOperationException();
+    }
+
+    static AktkNode mul(AktkNode left, AktkNode right) {
+        throw new UnsupportedOperationException();
+    }
+
+    static AktkNode div(AktkNode left, AktkNode right) {
+        throw new UnsupportedOperationException();
+    }
+
+    int eval(Map<String, Integer> env);
+
+    default String toPrettyString() {
+        return toString();
+    }
+}

src/main/java/week6/AktkParseException.java

@@ -0,0 +1,36 @@
+package week6;
+
+import week5.AktkToken;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/*
+ * Seda klassi ei ole vaja muuta ega esitada
+ */
+public class AktkParseException extends RuntimeException {
+    private final AktkToken token;
+    private final Set<AktkToken.Type> expected;
+
+    public AktkToken getToken() {
+        return token;
+    }
+
+    public Set<AktkToken.Type> getExpected() {
+        return expected;
+    }
+
+    public AktkParseException(AktkToken tok, AktkToken.Type... expected) {
+        super("Unexpected token '" + tok + "' but expected: " + Arrays.toString(expected));
+        this.token = tok;
+        this.expected = new LinkedHashSet<>(Arrays.asList(expected));
+    }
+
+    // Kui ei soovi täpsema veatöötlusega tegeleda.
+    public AktkParseException() {
+        token = null;
+        expected = null;
+    }
+
+}

src/main/java/week6/kalaparser/IntroParser.java

@@ -0,0 +1,24 @@
+package week6.kalaparser;
+
+/**
+ * Kirjutame ise parseri, et saaks parseri abifunktsioonidest aru!
+ * Testide läbimiseks ei pea ASTi tagastama, seega on parse meetodi tüüp esialgu void.
+ */
+public class IntroParser {
+
+    public static void parse(String input) {
+        throw new UnsupportedOperationException();
+    }
+
+    static void main() {
+        String input = "aaabbb";
+        System.out.println("Parsing: " + input);
+        try {
+            IntroParser.parse(input);
+            System.out.print("ACCEPT!");
+        } catch (RuntimeException e) {
+            System.out.println("REJECT!");
+        }
+    }
+
+}

src/main/java/week6/kalaparser/KalaNode.java

@@ -0,0 +1,74 @@
+package week6.kalaparser;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.StringJoiner;
+
+import static week6.kalaparser.KalaNode.*;
+
+public sealed interface KalaNode permits KalaIdent, KalaList, KalaNull {
+
+    int sum(Map<String, Integer> env);
+
+    static KalaNode mkNull() {
+        return new KalaNull();
+    }
+
+    static KalaNode mkIdent(String name) {
+        return new KalaIdent(name);
+    }
+
+    static KalaNode mkList(List<KalaNode> args) {
+        return new KalaList(args);
+    }
+
+    static KalaNode mkList(KalaNode... args) {
+        return mkList(Arrays.asList(args));
+    }
+
+
+    // Siit edasi on siis lahendus ette antud, et selle peale mitte jälle liiga palju aega kulutada.
+    // Nende peidetud "sisemiste" klasside asemel võid kodutöös teha täiesti eraldi avalikud klassid!
+
+    record KalaIdent(String name) implements KalaNode {
+
+        @Override
+        public String toString() {
+            return name;
+        }
+
+        @Override
+        public int sum(Map<String, Integer> env) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    record KalaList(List<KalaNode> args) implements KalaNode {
+
+        @Override
+        public String toString() {
+            StringJoiner joiner = new StringJoiner(", ", "(", ")");
+            for (KalaNode arg : args) joiner.add(arg.toString());
+            return joiner.toString();
+        }
+
+        @Override
+        public int sum(Map<String, Integer> env) {
+            return args.stream().mapToInt(n -> n.sum(env)).sum();
+        }
+    }
+
+    record KalaNull() implements KalaNode {
+
+        @Override
+        public String toString() {
+            return "NULL";
+        }
+
+        @Override
+        public int sum(Map<String, Integer> env) {
+            return 0;
+        }
+    }
+}

src/main/java/week6/kalaparser/KalaParseException.java

@@ -0,0 +1,27 @@
+package week6.kalaparser;
+
+import week5.kalalexer.KalaToken;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class KalaParseException extends RuntimeException {
+    private final KalaToken token;
+    private final Set<KalaToken.Type> expected;
+
+    public KalaToken getToken() {
+        return token;
+    }
+
+    public Set<KalaToken.Type> getExpected() {
+        return expected;
+    }
+
+    public KalaParseException(KalaToken tok, KalaToken.Type... expected) {
+        super("Unexpected token '" + tok + "', but expected: " + Arrays.toString(expected));
+        this.token = tok;
+        this.expected = new LinkedHashSet<>(Arrays.asList(expected));
+    }
+
+}

src/main/java/week6/kalaparser/KalaParser.java

@@ -0,0 +1,60 @@
+package week6.kalaparser;
+
+import week5.kalalexer.KalaLexer;
+import week5.kalalexer.KalaToken;
+
+import java.util.List;
+
+import static week5.kalalexer.KalaToken.Type.*;
+
+public class KalaParser {
+
+    private final List<KalaToken> tokens;
+    private int pos;
+
+    private KalaParser(KalaLexer lexer) {
+        this.tokens = lexer.readAllTokens();
+        this.pos = 0;
+    }
+
+    public static KalaNode parse(String input) {
+        KalaLexer lexer = new KalaLexer(input);
+        // Ja kuidagi võiks nüüd seda lekserit kasutada oma parseris...
+        KalaParser parser = new KalaParser(lexer);
+        return parser.parse();
+    }
+
+    private KalaNode parse() {
+        KalaNode node = s();
+        done();
+        return node;
+    }
+
+    private void done() {
+        if (peek().type() != EOF) throw new KalaParseException(peek(), EOF);
+    }
+
+    private KalaToken peek() {
+        return tokens.get(pos);
+    }
+
+    private void match(KalaToken.Type tokenType) {
+        if (peek().type() != tokenType) {
+            throw new KalaParseException(peek(), tokenType);
+        }
+        pos++;
+    }
+
+
+    // S → (L) | ()
+    // L → A,L | A
+    // A → w | 0 | S
+    private KalaNode s() {
+        return null;
+    }
+
+    static void main() {
+        KalaNode ast = parse("(kala, (x,y  , null, (), (kala,()) ))");
+        System.out.println(ast);
+    }
+}

src/main/java/week6/lausearvutus/Formula.java

@@ -0,0 +1,43 @@
+package week6.lausearvutus;
+
+import java.util.Map;
+
+/**
+ * Klassi Formula ei ole vaja muuta
+ * (aga tõenäoliselt tahad luua sellele konkreetseid alamklasse).
+ *
+ * Soovi korral võid siia ka meetodeid juurde lisada.
+ */
+public interface Formula {
+    /**
+     * Konkreetsete valemi puhul peab toString andma valemi tavapärasel
+     * infikssel kujul, aga nii, et kõigi binaarsete tehete ümber on sulud
+     * ja eituste ning lausemuutujate ümber (vahetult) sulge ei ole.
+     * Näiteks valemile A∨B&(¬(¬C)) vastava Formula korral peaks toString-i
+     * tulemus olema "(A∨(B&¬¬C))"; valemi A&B&C&D puhul peab tulemus olema
+     * "(((A&B)&C)&D)".
+     * <p>
+     * Tulemus ei tohi sisaldada tühikuid.
+     */
+    @Override
+    String toString();
+
+
+    /**
+     * Konkreetsetes alamklassides peab equals tagastama true parajasti siis,
+     * kui argumendiks on Formula, millel on täpselt sama struktuur
+     * (sh. muutujanimed), nagu sellel valemil.
+     */
+    @Override
+    boolean equals(Object obj);
+
+    /**
+     * Konkreetsetes alamkassides peab evaluate tagastama valemi väärtuse
+     * näidatud väärtustusel.
+     * <p>
+     * Kui mõne muutuja väärtus puudub, siis tuleb visata erind
+     * (seda ka siis, kui valemi väärtus selle muutuja väärtusest ei sõltu).
+     */
+    boolean evaluate(Map<Character, Boolean> variableValues);
+
+}

src/main/java/week6/lausearvutus/FormulaUtils.java

@@ -0,0 +1,39 @@
+package week6.lausearvutus;
+
+public class FormulaUtils {
+
+    static void main() {
+        String valem = "x&y∨r";
+        System.out.println(parseFormula(valem));
+    }
+
+    /**
+     * parseFormula peab tagastama sõnena antud lausearvutuse valemile
+     * vastava andmestruktuuri.
+     * <p>
+     * Süntaktiliselt mittekorrektsete valemite korral tuleb visata erind.
+     */
+    public static Formula parseFormula(String formula) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * moveNegations peab tagastama uue valemi, kus kõik eitused on
+     * viidud vahetult lausemuutujate ette järgmiste reeglite põhjal:
+     * <p>
+     * ¬(¬F)  === F
+     * ¬(F&G) === ¬F∨¬G
+     * ¬(F∨G) === ¬F&¬G
+     * ¬(F→G) === F&¬G
+     * ¬(F↔G) === F↔¬G
+     * <p>
+     * NB! Antud reeglites tähistavad F ja G suvalisi valemeid, mitte tingimata
+     * ainult lausemuutujaid.
+     * <p>
+     * NB! Kuigi eitusi saaks sisse viia ka teisiti, tuleks praegu kasutada
+     * just neid teisendusi.
+     */
+    public static Formula moveNegations(Formula valem) {
+        throw new UnsupportedOperationException();
+    }
+}