Initial commit

1 files changed, 215 insertions, 0 deletions

diff --git a/lepa.ha b/lepa.ha
new file mode 100644
index 0000000..2f08d6e
--- /dev/null
+++ b/lepa.ha
@@ -0,0 +1,215 @@
+// Usage: lepa FILE
+// This is a simple program that reads from FILE lines starting with a letter
+// pair, that is a word consisting of two capital letters such as XY, saves
+// them in a table and lets the user access and visualize them in different
+// ways. It is intended to be a tool to train a memory scheme for letter pair
+// (e.g. for memory sports), but I mostly wrote it to try out Hare.
+
+use ascii;
+use bufio;
+use encoding::utf8;
+use fmt;
+use fs;
+use io;
+use math::random;
+use os;
+use strings;
+use time;
+
+type notlp = !void;
+
+def N: u32 = 26;
+let table: [N][N]str = [[""...]...];
+const commands: [_](str, *fn() void, str) = [
+        ("r", &dorand, "Start random training session"),
+        ("?", &printhelp, "Print help"),
+        ("q", &quit, "Quit"),
+];
+
+// Start random training session
+fn dorand() void = {
+        let pairs: [N*N](u32, u32) = [(0, 0)...];
+        let k = makeallpairs(pairs[0..N*N]);
+        let ran = math::random::init(time::unix(time::now(0)): u64);
+        for (true) {
+                const p = pairs[math::random::u32n(&ran, k)];
+                fmt::printfln("{}", pairstr(p))!;
+                if (waitline()) return;
+                fmt::printfln("{}", table[p.0][p.1])!;
+                if (waitline()) return;
+        };
+};
+
+// Print help
+fn printhelp() void = {
+        fmt::printfln("Available commands:")!;
+        for (let i: size = 0; i < len(commands); i += 1)
+                fmt::printfln("{}\t{}", commands[i].0, commands[i].2)!;
+};
+
+// Quit
+fn quit() void = os::exit(0);
+
+fn mainloop() void = {
+        for (true) {
+                let line: str = match(bufio::scanline(os::stdin)) {
+                case io::error =>
+                        fmt::fatal("Error during io");
+                case io::EOF =>
+                        fmt::printfln("^D")!;
+                        os::exit(0);
+                case let line: []u8 =>
+                        yield strings::fromutf8(line);
+                };
+                let i: size = 0;
+                for (i < len(commands); i += 1) {
+                        if (line == commands[i].0) {
+                                commands[i].1();
+                                break;
+                        };
+                };
+                if (i == len(commands))
+                        fmt::printfln("?")!;
+                free(line);
+        };
+};
+
+// Determines if c is one of the N characters declared as letters
+fn isvalidle(c: rune) bool = ascii::isupper(c);
+
+// Index corresponding to character c in the table
+fn index(c: rune) u32 = (c: u32) - ('A': u32);
+
+// Character corresponding to index i in the table
+fn rundex(i: u32) rune = (i + ('A': u32)): rune;
+
+// Rune to string
+// TODO is there really no standard library function for this?
+fn runetostring(r: rune) str = {
+        let arr: []u8 = encoding::utf8::encoderune(r);
+        return strings::fromutf8(arr);
+};
+
+// Pair of indexes to string
+fn pairstr(p: (u32, u32)) str = {
+        const s1 = strings::dup(runetostring(rundex(p.0: u32)));
+        const s2 = strings::dup(runetostring(rundex(p.1: u32)));
+        return strings::concat(s1, s2);
+};
+
+// Read the table of letter pairs from file
+fn read(file: (io::file | fs::error)) void = {
+        const f = match(file) {
+        case let f: io::file =>
+                yield f;
+        case let e: fs::error =>
+                fmt::fatal("Error reading file: {}", fs::strerror(e));
+        };
+        const lines = match(io::drain(f)) {
+        case let lines: []u8 =>
+                yield strings::fromutf8(lines);
+        case io::error =>
+                fmt::fatal("Error reading table");
+        };
+        const lines = strings::split(lines, "\n");
+
+        for (let i = 0z; i < len(lines); i += 1) {
+                const runes: []rune = strings::runes(lines[i]);
+                if (len(lines[i]) == 0 || runes[0] == '#')
+                        continue;
+                const c1 = runes[0];
+                const c2 = runes[1];
+                if (!(isvalidle(c1) && isvalidle(c2)))
+                        fmt::fatal("Error reading line: {}", lines[i]);
+                let j: size = 2;
+                for (j < len(runes) && ascii::isspace(runes[j]))
+                        j += 1;
+                const word: str = strings::sub(lines[i], j, strings::end);
+                if (len(word) > 0)
+                        table[index(c1)][index(c2)] = strings::dup(word);
+                free(runes);
+        };
+        free(lines);
+};
+
+// Make list of all non-empty pairs
+fn makeallpairs(allpairs: [](u32, u32)) u32 = {
+        let k: u32 = 0;
+        for (let i: u32 = 0; i < N; i += 1) {
+                for (let j: u32 = 0; j < N; j += 1) {
+                        if (table[i][j] != "") {
+                                allpairs[k] = (i, j);
+                                k += 1;
+                        };
+                };
+        };
+        return k;
+};
+
+// Print one entry of the tabl
+fn printentry(p: (str | (u32, u32))) (void | notlp) = {
+        const ind: (u32, u32) = match(p) {
+        case let pair: (u32, u32) =>
+                yield pair;
+        case let s: str =>
+                yield if (len(s) != 2) {
+                        return notlp;
+                } else {
+                        const runes = strings::runes(s);
+                        yield (index(runes[0]), index(runes[1]));
+                };
+        };
+        const i = ind.0;
+        const j = ind.1;
+        if (table[i][j] != "") {
+                const r1: rune = rundex(i: u32);
+                const r2: rune = rundex(j: u32);
+                fmt::printfln("{}{}:\t{}", r1, r2, table[i][j])!;
+        };
+};
+
+// Print one line of the table
+fn printline(c: (u32 | rune)) void = {
+        const i: u32 = match(c) {
+        case let i: u32 =>
+                yield i;
+        case let r: rune =>
+                yield index(r);
+        };
+        fmt::printfln("{}:", rundex(i))!;
+        for (let j: size = 0; j < len(table[i]); j += 1) {
+                // TODO: not ignore error?
+                printentry((i: u32, j: u32))!;
+        };
+};
+
+// Print all non-empty letter pairs
+fn printall() void = {
+        fmt::println("List of pairs:")!;
+        for (let i: size = 0; i < len(table); i += 1) {
+                printline(i: u32);
+                fmt::println("")!;
+        };
+};
+
+// Read a line from standard input, return true if EOF
+fn waitline() bool = {
+        match(bufio::scanline(os::stdin)) {
+        case io::error =>
+                fmt::fatal("Error during io");
+        case []u8 =>
+                return false;
+        case io::EOF =>
+                fmt::printfln("^D")!;
+                return true;
+        };
+};
+
+export fn main() void = {
+        if (len(os::args) != 2)
+                fmt::fatal("Usage: {} file", os::args[0]);
+
+        read(os::open(os::args[1]));
+
+        mainloop();
+};