Commit: d69bf980c4d66a809825c8cbe85914b04004fad5 - cammy (git)

A categorical programming language

Commit MetaInfo

• Revisión: d69bf980c4d66a809825c8cbe85914b04004fad5 (tree)
• Tiempo: 2022-08-14 13:35:28
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Hack up a basic concept for a packed JSON hive.

Cambiar Resumen

• add: json-hive.py
• modified: shell.nix

Diferencia incremental

--- /dev/null
+++ b/json-hive.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env nix-shell
+#! nix-shell -i python3 -p python3
+
+import json
+import os
+import sys
+
+class CammyParser:
+    def __init__(self, s):
+        self._i = 0
+        self._s = s
+
+    def position(self):
+        return self._i
+
+    def hasMore(self):
+        return self._i < len(self._s)
+
+    def eatWhitespace(self):
+        while self.hasMore() and self._s[self._i] in (" ", "\n"):
+            self._i += 1
+
+    def canAndDoesEat(self, c):
+        if self._s[self._i] == c:
+            self._i += 1
+            return True
+        else:
+            return False
+
+    def takeName(self):
+        start = self._i
+        while self.hasMore() and self._s[self._i] not in (")", "(", " ", "\n"):
+            self._i += 1
+        stop = self._i
+        return self._s[start:stop]
+
+    def takeExpression(self):
+        self.eatWhitespace()
+        if self.canAndDoesEat('('):
+            return self.startFunctor()
+        else:
+            return self.takeName()
+
+    def startFunctor(self):
+        start = self._i
+        head = self.takeName()
+        self.eatWhitespace()
+        args = []
+        while not self.canAndDoesEat(')'):
+            args.append(self.takeExpression())
+            self.eatWhitespace()
+            if not self.hasMore():
+                raise ValueError("Unterminated functor starting at %d" % start)
+        return tuple([head] + args)
+
+
+def parse(s):
+    "Parse a Cammy expression, preserving any trailing text."
+    parser = CammyParser(s)
+    sexp = parser.takeExpression()
+    # Parser is now fast-forwarded to the end of the S-expression, so we can
+    # slice from that point and get the docstring/etc.
+    trail = s[parser.position():]
+    return sexp, trail
+
+symbols = {}
+heap = []
+
+strs = {}
+tuples = {}
+
+def merge(sexp):
+    if isinstance(sexp, str):
+        if sexp not in strs:
+            strs[sexp] = len(heap)
+            heap.append(sexp)
+        return strs[sexp]
+    elif isinstance(sexp, tuple):
+        merged = tuple([sexp[0]] + [merge(arg) for arg in sexp[1:]])
+        if merged not in tuples:
+            tuples[merged] = len(heap)
+            heap.append(merged)
+        return tuples[merged]
+    else:
+        raise ValueError("not sure how to merge", sexp)
+
+
+hiveroot = sys.argv[-1]
+for root, dirs, files in os.walk(hiveroot):
+    for file in files:
+        path = os.path.join(root, file)
+        key = os.path.splitext(path)[0][len(hiveroot):]
+        with open(path, "r") as handle:
+            sexp, trail = parse(handle.read())
+        symbols[key] = merge(sexp), trail
+
+# Fixup aliased symbols.
+for i, cell in enumerate(heap):
+    if cell in symbols:
+        heap[i] = symbols[cell][0]
+
+
+print(json.dumps({
+    "symbols": symbols,
+    "heap": heap,
+}))

--- a/shell.nix
+++ b/shell.nix
@@ -26,6 +26,8 @@ in pkgs.stdenv.mkDerivation {
     rlwrap
     # working with sexps
     # ocamlPackages.sexp
+    # working with JSON
+    jq
     # benchmarking
     busybox feedgnuplot linuxPackages.perf
     # publishing