Added Serializer.extractByLabels.

This is mainly used to quickly extract Chunks without needing the full
serialized result.

Author: kennytm

lib/compiler/NewAssembler.oz

@@ -431,23 +431,13 @@ define
       end
 
       meth LookForXRegsInPattern(Pattern)
-         proc {Loop Qs}
-            case Qs
-            of nil then
-               skip
-            [] _#_#patmatcapture(Idx)#Qr then
-               if Idx >= @xRegCount then
-                  xRegCount := Idx+1
-               end
-               {Loop Qr}
-            [] _#_#_#Qr then
-               {Loop Qr}
-            end
-         end
-
-         Qs = {BootSerializer.serialize {BootSerializer.new} [Pattern#_]}
+         Qs = {BootSerializer.extractByLabels Pattern r(patmatcapture:_)}
       in
-         {Loop Qs}
+         {ForAll Qs proc {$ _#patmatcapture(Idx)}
+            if Idx >= @xRegCount then
+               xRegCount := Idx + 1
+            end
+         end}
       end
 
       meth output($)

platform-test/CMakeLists.txt

@@ -13,7 +13,7 @@ set(BASE_FUNCTORS
     #"finalize.oz" "gc.oz"
     "state.oz" "thread.oz"
     "vm.oz"
-    "reflection.oz"
+    "reflection.oz" "serializer.oz"
 )
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/base")
 foreach(FUNCTOR ${BASE_FUNCTORS})

platform-test/base/serializer.oz

@@ -0,0 +1,79 @@
+%%%
+%%% Authors:
+%%%   Kenny Chan <[email protected]>
+%%%
+%%% Copyright:
+%%%   Kenny Chan 2014
+%%%
+%%% Last change:
+%%%   $Date$ by $Author$
+%%%   $Revision$
+%%%
+%%% This file is part of Mozart, an implementation of Oz 3:
+%%%   http://www.mozart-oz.org
+%%%
+%%% See the file "LICENSE" or
+%%%   http://www.mozart-oz.org/LICENSE.html
+%%% for information on usage and redistribution
+%%% of this file, and for a DISCLAIMER OF ALL
+%%% WARRANTIES.
+%%%
+
+functor
+import
+    Serializer at 'x-oz://boot/Serializer'
+
+export
+    Return
+
+define
+    Return = serializer([
+        extractByLabels1(
+            proc {$}
+                Q = {NewChunk a(1)}
+                R = {NewChunk b(Q)}
+                T = {NewChunk c(2)}
+                S = [R Q fun {$} T end]
+                L = {Serializer.extractByLabels S r(chunk:_)}
+            in
+                true = (Q \= R)
+                true = (R \= T)
+                true = (Q \= T)
+                3 = {Length L}
+                32 = for sum:S Obj#Rec in L do
+                    chunk(_) = Rec
+                    if Obj == Q then
+                        {S 2}
+                    elseif Obj == R then
+                        {S 7}
+                    elseif Obj == T then
+                        {S 23}
+                    else
+                        {S 71}
+                    end
+                end
+            end
+        )
+
+        extractByLabels2(
+            proc {$}
+                proc {TestFunc X _}
+                    case X
+                    of Y#r(Z) then {TestFunc Y Z}
+                    [] Y|_ then {TestFunc Y _}
+                    else skip
+                    end
+                end
+
+                L = {Serializer.extractByLabels TestFunc r(patmatcapture:_)}
+            in
+                for _#Rec in L do
+                    patmatcapture(A) = Rec
+                in
+                    true = {IsNumber A}
+                end
+            end
+        )
+    ])
+
+end

vm/vm/main/modules/modserializer.hh

@@ -65,6 +65,15 @@ public:
       }
     }
   };
+
+  class ExtractByLabels: public Builtin<ExtractByLabels> {
+  public:
+    ExtractByLabels(): Builtin("extractByLabels") {}
+
+    static void call(VM vm, In object, In labelsRecord, Out result) {
+      result = Serializer::extractByLabels(vm, object, labelsRecord);
+    }
+  };
 };
 
 }

vm/vm/main/serializer-decl.hh

@@ -108,6 +108,8 @@ public:
 public:
   UnstableNode doSerialize(VM vm, RichNode todo);
 
+  static UnstableNode extractByLabels(VM vm, RichNode object, RichNode labels);
+
 private:
   UnstableNode done;
 };

vm/vm/main/serializer.cc

@@ -92,4 +92,36 @@ UnstableNode Serializer::doSerialize(VM vm, RichNode todo) {
   return UnstableNode(vm, done);
 }
 
+UnstableNode Serializer::extractByLabels(VM vm, RichNode object, RichNode labels) {
+  SerializationCallback cb(vm);
+
+  Dottable validLabels(labels);
+  OzListBuilder resultList(vm);
+
+  VMAllocatedList<NodeBackup> nodeBackups;
+
+  auto n = OptVar::build(vm);
+  cb.copy(n, object);
+
+  while (!cb.todoFrom.empty()) {
+    auto from = cb.todoFrom.pop_front(vm);
+    if (!from.is<Serialized>()) {
+      auto serialized = from.type()->serialize(vm, &cb, from);
+      auto label = RecordLike(serialized).label(vm);
+      if (validLabels.hasFeature(vm, label)) {
+        resultList.push_back(vm, buildSharp(vm, from, serialized));
+      }
+      nodeBackups.push_front(vm, from.makeBackup());
+      from.reinit(vm, Serialized::build(vm, 0));
+    }
+  }
+
+  for (auto& nodeBackup : nodeBackups) {
+    nodeBackup.restore();
+  }
+  nodeBackups.clear(vm);
+
+  return resultList.get(vm);
+}
+
 }