week5 praksi lahendused

Author: sim642

sols/week5/grammar/RegexGrammar.java

@@ -0,0 +1,57 @@
+package week5.grammar;
+
+import week4.regex.RegexParser;
+import week4.regex.ast.*;
+
+public class RegexGrammar {
+
+    // Konstandid ilutrüki jaoks
+    private static final char EPS = 'ε';
+    private static final String ARROW = " → ";
+
+    public static void printGrammar(RegexNode node) {
+        new RegexGrammar().printGrammarNode(node, 'S');
+    }
+
+    private char nextNt = 'A';
+    // Genereeri järgmine mitte-terminal (eeldades, et neid liiga palju ei ole).
+    private char getNextNt() {
+        if (nextNt == 'S') nextNt++; // Jätame S vahele, et seda saaks kasutada algsümbolina.
+        return nextNt++;
+    }
+
+    /**
+     * @param nt Praegu defineeritav mitte-terminal
+     */
+    private void printGrammarNode(RegexNode regex, char nt) {
+        switch (regex) {
+            case Letter(char symbol) -> System.out.println(nt + ARROW + symbol);
+            case Epsilon _ -> System.out.println(nt + ARROW + EPS);
+            case Repetition(RegexNode child) -> {
+                char childNt = getNextNt();
+                System.out.println(nt + ARROW + childNt + nt);
+                System.out.println(nt + ARROW + EPS);
+                printGrammarNode(child, childNt);
+            }
+            case Concatenation(RegexNode left, RegexNode right) -> {
+                char leftNt = getNextNt();
+                char rightNt = getNextNt();
+                System.out.println(nt + ARROW + leftNt + rightNt);
+                printGrammarNode(left, leftNt);
+                printGrammarNode(right, rightNt);
+            }
+            case Alternation(RegexNode left, RegexNode right) -> {
+                char leftNt = getNextNt();
+                char rightNt = getNextNt();
+                System.out.println(nt + ARROW + leftNt);
+                System.out.println(nt + ARROW + rightNt);
+                printGrammarNode(left, leftNt);
+                printGrammarNode(right, rightNt);
+            }
+        }
+    }
+
+    static void main() {
+        printGrammar(RegexParser.parse("(a|bc)*"));
+    }
+}

sols/week5/kalalexer/KalaLexer.java

@@ -0,0 +1,60 @@
+package week5.kalalexer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static week5.kalalexer.KalaToken.Type.*;
+
+public class KalaLexer {
+    private static final char TERMINATOR = '\0';
+    private final String input;
+    private int pos;
+
+    public KalaLexer(String input) {
+        this.input = input + TERMINATOR;
+        pos = 0;
+    }
+
+    public List<KalaToken> readAllTokens() {
+        List<KalaToken> tokens = new ArrayList<>();
+        while (peek() != TERMINATOR) {
+            switch (peek()) {
+                case '(':
+                    tokens.add(new KalaToken(LPAREN));
+                    pos++;
+                    break;
+                case ')':
+                    tokens.add(new KalaToken(RPAREN));
+                    pos++;
+                    break;
+                case ',':
+                    tokens.add(new KalaToken(COMMA));
+                    pos++;
+                    break;
+                default:
+                    if (Character.isLetter(peek())) {
+                        KalaToken tok = readIdentOrNull();
+                        tokens.add(tok);
+                    } else pos++;
+            }
+        }
+        tokens.add(new KalaToken(EOF));
+        return tokens;
+    }
+
+    private KalaToken readIdentOrNull() {
+        StringBuilder sb = new StringBuilder();
+        while (Character.isLetter(peek())) {
+            sb.append(peek());
+            pos++;
+        }
+        if (sb.toString().equals("null")) {
+            return new KalaToken(NULL);
+        } else
+            return new KalaToken(IDENT, sb.toString());
+    }
+
+    private char peek() {
+        return input.charAt(pos);
+    }
+}

sols/week5/kalalexer/Unescaper.java

@@ -0,0 +1,55 @@
+package week5.kalalexer;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+public class Unescaper {
+
+    /**
+     * Töötleb sisendsõne selliselt, et escape'itud reavahetused on asendatud päris reavahetustega.
+     */
+    private static String unescape(String str) {
+        StringBuilder output = new StringBuilder();
+        boolean escape = false;
+        for (char c : str.toCharArray()) {
+            if (escape) {
+                if (c == 'n') output.append('\n');
+                else throw new IllegalArgumentException("Unknown escape literal");
+                escape = false;
+            }
+            else if (c == '\\') escape = true;
+            else output.append(c);
+        }
+        return output.toString();
+    }
+
+
+    /**
+     * Testime, kas meetod teeb seda, mida vaja failis inputs/escaped.txt oleva kirjutisega.
+     */
+    static void main() throws IOException {
+
+        // Esialgne sõne:
+        String mystring = "foo\nbar\nbaz";
+        System.out.print("Original: ");
+        System.out.println(Arrays.toString(mystring.toCharArray()));
+        System.out.println();
+
+        // sisend failist
+        String input = Files.readString(Paths.get("inputs", "escaped.txt")).trim();
+        System.out.print("Input: ");
+        System.out.println(Arrays.toString(input.toCharArray()));
+        System.out.println();
+
+        // funktsiooni väljund
+        String unescaped = unescape(input.substring(1, input.length() - 1));
+        System.out.print("Unescaped: ");
+        System.out.println(Arrays.toString(unescaped.toCharArray()));
+        System.out.println();
+
+        // funktsiooni väljund peaks olema see, mis oodatud
+        System.out.println(!unescaped.equals(mystring) ? "Ei tööta!" : "Suurepärane töö!");
+    }
+}