deCapnKit: safe serialization for capn

mast/capn/deCapnKit.mt

@@ -0,0 +1,138 @@
+import "lib/capn" =~ [=> makeMessageReader :DeepFrozen]
+import "lib/serial/DEBuilderOf" =~ [=> DEBuilderOf :DeepFrozen]
+import "capn/montevalue" =~ [=> reader, => makeWriter]
+
+exports (deCapnKit)
+
+
+def Node :DeepFrozen := Map[Str, Any]  # Named arguments to makeDataExpr
+def Root :DeepFrozen := Bytes          # capn message
+
+def Int32 :DeepFrozen := -(2 ** 31)..!2 ** 31
+
+
+object deCapnKit as DeepFrozen:
+    to makeBuilder():
+
+        def Literal := Any[Int, Double, Str, Char]
+
+        var nextTemp :Int := 0
+        var varReused := [].asMap().diverge()
+        def w := makeWriter()
+
+        def expr(nargs :Map):
+            return M.call(w, "makeDataExpr", [], nargs)
+
+        return object deCapnBuilder implements DEBuilderOf[Node, Root]:
+            method getNodeType() :Near:
+                Node
+            method getRootType() :Near:
+                Root
+
+            to buildRoot(root :Node) :Bytes:
+                return w.dump(expr(root))
+
+            to buildLiteral(it :Literal) :Node:
+                def lit := switch (it) {
+                    match i :Int32  { ["int" => w.makeInteger("int32" => i)] }
+                    match i :Int    { ["int" => w.makeInteger("bigint" => `${i}`)] }
+                    match x :Double { ["double" => x] }
+                    match s :Str    { ["str" => s] }
+                    match ch: Char  { ["char" => ch.asInteger()] }
+                    match bs: Bytes { ["bytes" => bs] }
+                }
+                return ["literal" => lit]
+
+            to buildImport(varName :Str) :Node:
+                return ["noun" => varName]
+
+            to buildIbid(tempIndex :Int) :Node:
+                if (! (tempIndex < nextTemp)):
+                    throw(`assertion failure: $tempIndex < $nextTemp`)
+                varReused[tempIndex] := true
+                # traceln(`buildIbid: $tempIndex marked reused.`)
+                return ["ibid" => tempIndex]
+
+            to buildCall(rec :Node, verb :Str, args :List[Node], nargs :Map[Str, Node]) :Node:
+                def message := ["verb" => verb,
+                                "args" => args,
+                                "namedArgs" => [for k => v in (nargs) ["key" => k, "value" => v]]
+                ]
+                return ["call" => ["receiver" => expr(rec), "message" => message]]
+
+            to buildDefine(rValue :Node) :Pair[Node, Int]:
+                def tempIndex := nextTemp
+                nextTemp += 1
+                varReused[tempIndex] := false
+                def defNode := ["defExpr" => ["index" => tempIndex, "rValue" => expr(rValue)]]
+                return [defNode, tempIndex]
+
+            to buildPromise() :Int:
+                def promIndex := nextTemp
+                nextTemp += 2
+                varReused[promIndex] := false
+                varReused[promIndex + 1] := false
+                return promIndex
+
+            to buildDefrec(resIndex :Int, rValue :Node) :Node:
+                def promIndex := resIndex - 1
+                # traceln(`buildDefrec: $promIndex reused? ${varReused[promIndex]}.`)
+                return if (varReused[promIndex]):
+                    # We have a cycle
+                    ["defRec" => ["promIndex" => promIndex, "rValue" => expr(rValue)]]
+                else:
+                    # No cycle
+                    ["defExpr" => ["index" => promIndex, "rValue" => expr(rValue)]]
+
+    to recognize(msg :Root, builder) :(def _Root := builder.getRootType()):
+        def Node := builder.getNodeType()
+
+        def build(expr):
+            return switch (expr._which()) {
+                match ==0 { # literal
+                    def lit := expr.literal()
+                    switch (lit._which()) {
+                        match ==0 {
+                            def litInt := lit.int()
+                            switch (litInt._which()) {
+                                match ==0 { litInt.int32() }
+                                match ==1 { _makeInt(litInt.bigint()) }
+                            }
+                        }
+                        match ==1 { lit.double() }
+                        match ==2 { lit.str() }
+                        match ==3 { '@' - 64 + lit.char() }
+                        match ==4 { lit.bytes() }
+                    }
+                }
+                match ==1 {
+                    builder.buildImport(expr.noun())
+                }
+                match ==2 {
+                    builder.buildIbid(expr.ibid())
+                }
+                match ==3 {
+                    def call := expr.call()
+                    def msg := call.message()
+                    def args := [for arg in (msg.args()) build(arg)]
+                    def nargs := [for n => arg in (msg.namedArgs()) n => build(arg)]
+                    builder.buildCall(build(call.receiver()), msg.verb(), args, nargs)
+                }
+                match ==4 {  # defExpr
+                    # ISSUE: we're not using the de.index() field. Is it needed?
+                    def de := expr.defExpr()
+                    def [val, _tempIndex] := builder.buildDefine(build(de.rValue()))
+                    val
+                }
+                match ==5 {  # defRec
+                    # ISSUE: we're not using the dr.promIndex() field. Is it needed?
+                    def dr := expr.defRec()
+                    def promIndex := builder.buildPromise()
+                    return builder.buildDefrec(promIndex + 1, build(dr.rValue()))
+                }
+                match other { throw(`not implemented: ${other}`) }
+            }
+
+        def expr := reader.DataExpr(makeMessageReader(msg).getRoot())
+
+        return builder.buildRoot(build(expr))

mast/capn/montevalue.capnp

@@ -1,23 +1,47 @@
 @0xe2597668ccd0fb6a;
 
-struct MonteValue {
-  null @0 :Void;
-  bool @1 :Bool;
-  int @2 :Int32;
-  bigint @3 :Data;
-  double @4 :Float64;
-  bytes @5 :Data;
-  text @6 :Text;
-  list @7 :List(MonteValue);
-}
+struct DataExpr {
+  struct Integer {
+    union {
+      int32  @0 :Int32;
+      bigint @1 :Text;
+    }
+  }
 
-struct NamedArg {
-  key @0 :Text;
-  value @1 :MonteValue;
-}
+  struct NamedArg {
+    key @0 :Text;
+    value @1 :DataExpr;
+  }
+
+  union {
+    literal :union {
+      int    @0 :Integer;
+      double @1 :Float64;
+      str    @2 :Text;
+      char   @3 :Int32;
+      bytes  @4 :Data;
+    }
+
+    noun     @5 :Text;
+    ibid     @6 :Int32;
+
+    call :group {
+      receiver  @7 :DataExpr;
+      message   :group {
+        verb      @8 :Text;
+        args      @9 :List(DataExpr);
+        namedArgs @10 :List(NamedArg);
+      }
+    }
+
+    defExpr :group {
+      index  @11 :Int32;
+      rValue @12 :DataExpr;
+    }
 
-struct MonteMessage {
-  verb @0 :Text;
-  args @1 :List(MonteValue);
-  namedArgs @2 :List(NamedArg);
+    defRec :group {
+      promIndex @13 :Int32;
+      rValue    @14 :DataExpr;
+    }
+  }
 }

mast/fun/uneval.mt

@@ -0,0 +1,51 @@
+import "lib/serial/deSubgraphKit" =~ [=>deSubgraphKit :DeepFrozen]
+import "lib/serial/deMNodeKit" =~ [=>deMNodeKit :DeepFrozen]
+import "lib/serial/deSrcKit" =~ [=>deSrcKit :DeepFrozen]
+import "capn/deCapnKit" =~ [=>deCapnKit :DeepFrozen]
+exports (main)
+
+def test(actual, expected) as DeepFrozen:
+    if (actual == expected):
+        trace(".")
+    else:
+        traceln("")
+        traceln(`want: $expected`)
+        traceln(` got: $actual`)
+
+
+def main(_argv) :Vow[Int] as DeepFrozen:
+    def s := M.toString
+
+    def data := [null, true, false, 1, 2 ** 32 + 123,
+                 # 2.54 messageWriter lacks writeFloat64
+                 # https://github.com/monte-language/typhon/issues/206
+                 "abc",'A',
+                 # b`hello` TODO: Problem: Can't uneval <makeBytes>
+    ]
+    def dataMsg := deSubgraphKit.recognize(data,
+                                           deCapnKit.makeBuilder())
+    def data2 := deCapnKit.recognize(dataMsg, deSubgraphKit.makeBuilder())
+    test(data2, data)
+
+    def x := [1, x, 3]
+    test(s(x), "[1, <**CYCLE**>, 3]")
+
+    test(s(deSubgraphKit.recognize(x, deSrcKit.makeBuilder())),
+         "def t_0 := [def t_2 := 1, t_0, def t_4 := 3]")
+
+    def ast := deSubgraphKit.recognize(x, deMNodeKit.makeBuilder()).canonical()
+    # TODO: def makeKernelECopyVisitor := elang_uriGetter("visitors.KernelECopyVisitor")
+    test(ast, m`def [t_0 :Any, t_1 :Any] := Ref.promise();$\
+                t_1.resolve(_makeList.run(def t_2 :Any := 1, t_0, def t_4 :Any := 3));$\
+                t_0`.canonical() :(astBuilder.getAstGuard()))
+
+    def output := deSubgraphKit.recognize(x, deCapnKit.makeBuilder())
+
+    def xx := deCapnKit.recognize(output, deSubgraphKit.makeBuilder())
+    test(s(xx), "[1, <**CYCLE**>, 3]")
+
+    test(output.size(), 472)
+    test(output.contains(b`_makeList`), true)
+    # def stdout := stdio.stdout()
+    # return when (stdout(output), stdout<-complete()) -> { 0 }
+    return 0

mast/lib/serial/DEBuilderOf.mt

@@ -0,0 +1,104 @@
+#!/usr/bin/env rune
+
+# Copyright 2002 Combex, Inc. under the terms of the MIT X license
+# found at http://www.opensource.org/licenses/mit-license.html ................
+
+# module "org.erights.e.elib.serial.DEBuilderOf"
+import "lib/serial/guards" =~ [=>Guard :DeepFrozen]
+exports (DEBuilderOf)
+
+# /**
+#  * Data-E is the subset of E used for serializing a subgraph by unevaling to an
+#  * expression.
+#  *
+#  * @see <a hrep=
+#  *       "http://www.erights.org/data/serial/jhu-paper/modeling.html#as-eval"
+#  * >Unserialization as Expression Evaluation</a>.
+#  * @author Mark S. Miller
+#  */
+def DEBuilderOf.get(Node :Guard, _Root :Guard) :Guard as DeepFrozen {
+
+    interface _DEBuilder {
+
+        # /**
+        #  * What's the actual type corresponding to the Node type parameter?
+        #  */
+        to getNodeType() :Guard
+
+        # /**
+        #  * What's the actual type corresponding to the Root type parameter?
+        #  */
+        to getRootType() :Guard
+
+        # /**
+        #  * An opportunity to do some post-optimizations, writing out trailers,
+        #  * and closing.
+        #  * <p>
+        #  * [root] => buildRoot()
+        #  * <p>
+        #  * This must appear exactly once at the end.
+        #  */
+        to buildRoot(root :Node) :Node
+
+        # /**
+        #  * For literal values -- ints, float64s, chars, or bare Strings.
+        #  * <p>
+        #  * [] => buildLiteral(value) => [value]
+        #  */
+        to buildLiteral(value :Any[Int, Double, Char, Str]) :Node
+
+        # /**
+        #  * Generates a use-occurrence of a named variable.
+        #  * <p>
+        #  * [] => buildImport(varName) => [value]
+        #  * <p>
+        #  * Load the value of the named variable from the scope.
+        #  */
+        to buildImport(varName :Str) :Node
+
+        # /**
+        #  * Generates a use-occurrence of an temp variable.
+        #  * <p>
+        #  * [] => buildIbid(tempIndex) => [value]
+        #  * <p>
+        #  * Load the value of the temp variable at that index.
+        #  */
+        to buildIbid(tempIndex :Int) :Node
+
+        # /**
+        #  * Generates a call-expression.
+        #  * <p>
+        #  * [rec, arg0,...] => buildCall(verb,arity) => [result]
+        #  */
+        to buildCall(rec :Node, verb :Str, args :List[Node]) :Node
+
+        # /**
+        #  * Allocates the next tempIndex, defines it to hold the value of
+        #  * rValue, and return a pair of the generated definition and the index
+        #  * of the new temp variable.
+        #  * <p>
+        #  * [rValue] => buildDefine() => [rValue]
+        #  * <p>
+        #  * If rValue needs to use the new variable, use
+        #  * buildPromise/buildDefrec instead.
+        #  */
+        to buildDefine(rValue :Node) :Pair[Node, Int]
+
+        # /**
+        #  * Like a forward variable declaration in E (def varName).
+        #  * <p>
+        #  * [] => buildPromise() => []
+        #  * <p>
+        #  * Allocates the next two temp variables. Defines them to hold a
+        #  * promise and its Resolver, respectively.
+        #  */
+        to buildPromise() :Int
+
+        # /**
+        #  * Resolves a promise to the value of rValue.
+        #  * <p>
+        #  * [rValue] => buildDefrec(resolverIndex) => [rValue]
+        #  */
+        to buildDefrec(resolverIndex :Int, rValue :Node) :Node
+    }
+}