Added PackWithReplacements method.

Author: kennytm

lib/main/sys/Pickle.oz

@@ -44,6 +44,7 @@ export
 
    Pack
    PackWithCells
+   PackWithReplacements
    Unpack
 
 define
@@ -54,7 +55,9 @@ define
    %% Save and its variants
    %%
 
-   Save = BootPickle.save
+   fun {Save URL}
+      {BootPickle.save URL nil}
+   end
 
    proc {SaveCompressed Value FileName Level}
       {Save Value FileName}
@@ -89,7 +92,22 @@ define
    %% Pack and its variants
    %%
 
-   Pack = BootPickle.pack
+   %%% {Pack Object} = BS
+   %%%
+   %%% Serialize an object into a ByteString. May throw an exception if the
+   %%% object contains non-serializable components (e.g. cells, unbound variables)
+   fun {Pack Value}
+      {BootPickle.pack Value nil}
+   end
+
+   %%% {PackWithReplacements Object [From1#To1 From2#To2 ...]} = BS
+   %%%
+   %%% Serialize an object into a ByteString with some components temporarily
+   %%% replaced. If the object contains any of FromN, they will all be replaced
+   %%% by ToN before the serialization starts. Deserializing the byte string
+   %%% will only give back ToN, not FromN. The Object itself will stay the same
+   %%% after calling PackWithReplacements.
+   PackWithReplacements = BootPickle.pack
 
    fun {PackWithCells Value}
       {Pack Value}

platform-test/base/pickle.oz

@@ -23,9 +23,10 @@
 
 functor
 import
-   BootPickle(pack:Pack unpack:Unpack) at 'x-oz://boot/Pickle'
-   %Pickle(pack:Pack unpack:Unpack)
+   %BootPickle(pack:Pack unpack:Unpack) at 'x-oz://boot/Pickle'
+   Pickle(pack:Pack unpack:Unpack packWithReplacements:PackWithReplacements)
    BootName(newUnique:NewUniqueName newNamed:NewNamedName) at 'x-oz://boot/Name'
+   System
 export
    Return
 define
@@ -115,5 +116,29 @@ define
                       {All Nogoods fun {$ X} {TryPack X}==[X] end} = true
                       {Thread.terminate BadThread}
                    end keys:[pickle])
+
+           packWithReplacements(
+               proc {$}
+                   A = {NewCell 1}
+                   B = {NewCell 1}
+                   C = A
+                   S U
+                   Replacements = [A#a B#b]
+                   Obj = [fun {$} A#B#c end A B C d A]
+               in
+                   S = {PackWithReplacements Obj Replacements}
+                   U = {Unpack S}
+                   [a b a d a] = U.2
+                   %a#b#c = {U.1}
+                   %% ^ TODO cannot test this on local machine, the unpickler
+                   %%   will recognize the anonymous function as a global node
+                   %%   and reuse the existing method in this VM.
+                   [A B C d A] = Obj.2
+                   A#B#c = {Obj.1}
+                   true = {IsCell A}
+                   true = {IsCell B}
+                   true = (A \= B)
+               end
+           )
           ])
 end

vm/vm/main/modules/modpickle.hh

@@ -47,9 +47,9 @@ public:
   public:
     Pack(): Builtin("pack") {}
 
-    static void call(VM vm, In value, Out result) {
+    static void call(VM vm, In value, In temporaryReplacement, Out result) {
       std::ostringstream buf;
-      pickle(vm, value, buf);
+      pickle(vm, value, temporaryReplacement, buf);
       std::string str = buf.str();
       auto bytes = newLString(vm,
         reinterpret_cast<const unsigned char*>(str.data()), str.size());
@@ -78,13 +78,13 @@ public:
   public:
     Save(): Builtin("save") {}
 
-    static void call(VM vm, In value, In fileNameVS) {
+    static void call(VM vm, In value, In temporaryReplacement, In fileNameVS) {
       size_t fileNameSize = ozVSLengthForBuffer(vm, fileNameVS);
       std::string fileName;
       ozVSGet(vm, fileNameVS, fileNameSize, fileName);
 
       std::ofstream file(fileName, std::ios_base::binary);
-      pickle(vm, value, file);
+      pickle(vm, value, temporaryReplacement, file);
     }
   };
 

vm/vm/main/pickler.cc

@@ -64,7 +64,14 @@ UnstableNode Pickler::buildTypesRecord(VM vm) {
     4);
 }
 
-void Pickler::pickle(RichNode value) {
+static void restoreNodes(VM vm, VMAllocatedList<NodeBackup>& list) {
+  for (auto& nodeBackup : list) {
+    nodeBackup.restore();
+  }
+  list.clear(vm);
+}
+
+void Pickler::pickle(RichNode value, RichNode temporaryReplacement) {
   auto typesRecord = RichNode(*vm->getPickleTypesRecord()).as<Record>();
   auto statelessTypes = RichNode(*typesRecord.getArity()).as<Arity>();
 
@@ -78,6 +85,29 @@ void Pickler::pickle(RichNode value) {
   VMAllocatedList<PickleNode> nodes;
   UnstableNode resources = buildNil(vm);
 
+  // Apply temporary replacements.
+  VMAllocatedList<NodeBackup> nodeReplacementBackups;
+  {
+    VMAllocatedList<std::pair<RichNode, RichNode>> replacements;
+
+    ozListForEach(vm, temporaryReplacement, [&replacements, this](RichNode pair) {
+      using namespace patternmatching;
+      RichNode from, to;
+      if (matchesSharp(vm, pair, capture(from), capture(to))) {
+        replacements.push_front_new(vm, from, to);
+      } else {
+        raiseTypeError(vm, "Tuple of the form From#To", pair);
+      }
+    }, "List of pairs");
+
+    for (auto& replacement : replacements) {
+      nodeReplacementBackups.push_front(vm, replacement.first.makeBackup());
+      replacement.first.reinit(vm, replacement.second);
+    }
+
+    replacements.clear(vm);
+  }
+
   // Replace serialized nodes by Serialized(index)
   // and add them to the nodes list
   while (!cb.todoFrom.empty()) {
@@ -111,11 +141,9 @@ void Pickler::pickle(RichNode value) {
   }
 
   // Restore nodes
-  while (!nodeBackups.empty()) {
-    nodeBackups.front().restore();
-    nodeBackups.remove_front(vm);
-  }
+  restoreNodes(vm, nodeBackups);
 
+  // Ensure no remaining futures or resources.
   if (futures) {
     for (auto& pickleNode : nodes) {
       if (isFuture(pickleNode.node)) {
@@ -127,11 +155,13 @@ void Pickler::pickle(RichNode value) {
       if (isFuture(pickleNode.node)) {
         RichNode future = pickleNode.node;
         nodes.clear(vm);
+        restoreNodes(vm, nodeReplacementBackups);
         waitFor(vm, future);
       }
     }
   } else if (!RichNode(resources).is<Atom>()) {
     nodes.clear(vm);
+    restoreNodes(vm, nodeReplacementBackups);
 
     raiseError(vm, "dp",
       "generic",
@@ -161,6 +191,9 @@ void Pickler::pickle(RichNode value) {
 
   nativeint eof = 0;
   writeSize(eof);
+
+  nodes.clear(vm);
+  restoreNodes(vm, nodeReplacementBackups);
 }
 
 void Pickler::writeValues(VMAllocatedList<PickleNode>& nodes) {

vm/vm/main/pickler.hh

@@ -50,7 +50,7 @@ public:
   Pickler(VM vm, std::ostream& output):
     vm(vm), output(output) {}
 
-  void pickle(RichNode value);
+  void pickle(RichNode value, RichNode temporaryReplacement);
 
 private:
   void writeValues(VMAllocatedList<PickleNode>& nodes);
@@ -92,9 +92,15 @@ private:
 // Entry point //
 /////////////////
 
+inline
+void pickle(VM vm, RichNode value, RichNode temporaryReplacement, std::ostream& output) {
+  Pickler(vm, output).pickle(value, temporaryReplacement);
+}
+
 inline
 void pickle(VM vm, RichNode value, std::ostream& output) {
-  Pickler(vm, output).pickle(value);
+  auto temporaryReplacement = Atom::build(vm, vm->coreatoms.nil);
+  pickle(vm, value, temporaryReplacement, output);
 }
 
 }