week6 praksi lahendused

Author: sim642

sols/week6/kalaparser/IntroParser.java

@@ -0,0 +1,64 @@
+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 {
+
+    private final String input;
+    private int pos;
+
+    public IntroParser(String input) {
+        this.input = input + '$';
+        this.pos = 0;
+    }
+
+    public static void parse(String input) {
+        IntroParser parser = new IntroParser(input);
+        parser.parse();
+    }
+
+    private void parse() {
+        s();
+        done();
+    }
+
+    private void done() {
+        if (peek() != '$') throw new RuntimeException();
+    }
+
+    // S -> a S b
+    private void s() {
+        if (peek() == 'a') {
+            match('a');
+            s();
+            match('b');
+        }
+    }
+
+    private char peek() {
+        return input.charAt(pos);
+    }
+
+    private void match(char expectedChar) {
+        char inputChar = input.charAt(pos);
+        if (inputChar == expectedChar) {
+            pos++;
+        } else {
+            throw new RuntimeException("Unexpected char at " + pos);
+        }
+    }
+
+    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!");
+        }
+    }
+
+}

sols/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) {
+            return env.get(name);
+        }
+    }
+
+    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;
+        }
+    }
+}

sols/week6/kalaparser/KalaParser.java

@@ -0,0 +1,108 @@
+package week6.kalaparser;
+
+import week5.kalalexer.KalaLexer;
+import week5.kalalexer.KalaToken;
+
+import java.util.ArrayList;
+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() {
+        match(LPAREN);
+        if (peek().type() == RPAREN) {
+            match(RPAREN);
+            return KalaNode.mkList();
+        } else {
+            List<KalaNode> list = l();
+            match(RPAREN);
+            return KalaNode.mkList(list);
+        }
+    }
+
+    private List<KalaNode> l() {
+        List<KalaNode> list = new ArrayList<>();
+        list.add(a());
+        if (peek().type() == COMMA) {
+            match(COMMA);
+            list.addAll(l());
+            return list;
+        }
+        return list;
+    }
+
+    // Alternatiivse variandina võib seda iteratiivselt teha.
+    // L → A,L | A esitame EBNF kujul L → A(,A)*
+    private List<KalaNode> l_ebnf() {
+        List<KalaNode> list = new ArrayList<>();
+        list.add(a());
+        while (peek().type() == COMMA) {
+            match(COMMA);
+            list.add(a());
+        }
+        return list;
+    }
+
+    private KalaNode a() {
+        KalaToken node = peek();
+        switch (node.type()) {
+            case IDENT:
+                match(IDENT);
+                return KalaNode.mkIdent((String) node.data());
+            case NULL:
+                match(NULL);
+                return KalaNode.mkNull();
+            case LPAREN:
+                return s();
+            default:
+                throw new KalaParseException(peek(), IDENT, NULL, LPAREN);
+        }
+    }
+
+    static void main() {
+        KalaNode ast = parse("(kala, (x,y  , null, (), (kala,()) ))");
+        System.out.println(ast);
+    }
+}