All tests pass

Apparently I don't need to make prototypes for the from/toAnything
functions. Removing that requirement simplifies things somewhat.

The next goal is to transition to using shared memory for interprocess
communication. Freeing memory is vital here. I need add a standard
function to all the language bindings for decrementing the memory block
counters. I also need to make some memory-based benchmarks. Prolly also
add in some valgind magic.

library/Morloc/CodeGenerator/Grammars/Translator/Cpp.hs

@@ -687,13 +687,11 @@ generateAnonymousStructs = do
     let fields = [(pretty k, v) | (k, v) <- zip fieldNames fieldTypes]
 
     let structDecl = structTypedefTemplate params rname fields
-        serialDecl = serialHeaderTemplate params rtype
-        deserialDecl = deserialHeaderTemplate params rtype
         serializer = serializerTemplate params rtype fields
         deserializer = deserializerTemplate False params rtype fields
 
 
-    return ([structDecl, serialDecl, deserialDecl], [serializer, deserializer])
+    return ([structDecl], [serializer, deserializer])
 
   -- monadic form of `maybe` function
   maybeM :: Monad m => a -> (b -> m a) -> Maybe b -> m a
@@ -726,13 +724,13 @@ generateSourcedSerializers es0 = do
       , opNativeManifoldM = \(NativeManifold_ i _ _ e) -> Map.union <$> MM.metaTypedefs i CppLang <*> pure e
       }
 
-    groupQuad :: ([a],[a]) -> (a, a, a, a) -> ([a],[a])
-    groupQuad (xs,ys) (x1, y1, x2, y2) = (x1:x2:xs, y1:y2:ys)
+    groupQuad :: ([a],[a]) -> (a, a) -> ([a],[a])
+    groupQuad (xs,ys) (x, y) = (x:xs, y:ys)
 
-    makeSerial :: Scope -> TVar -> ([TVar], TypeU, Bool) -> Maybe (MDoc, MDoc, MDoc, MDoc)
+    makeSerial :: Scope -> TVar -> ([TVar], TypeU, Bool) -> Maybe (MDoc, MDoc)
     makeSerial _ _ (_, NamU _ (TV "struct") _ _, _) = Nothing
     makeSerial scope _ (ps, NamU r (TV v) _ rs, _)
-      = Just (serialDecl, serializer, deserialDecl, deserializer) where
+      = Just (serializer, deserializer) where
 
         templateTerms = ["T" <> pretty p | p <- ps]
 
@@ -743,9 +741,6 @@ generateSourcedSerializers es0 = do
 
         fields = [(pretty k, showDefType ps (typeOf t)) | (k, t) <- rs']
 
-        serialDecl = serialHeaderTemplate params rtype
-        deserialDecl = deserialHeaderTemplate params rtype
-
         serializer = serializerTemplate params rtype fields
 
         deserializer = deserializerTemplate (r == NamObject) params rtype fields
@@ -798,48 +793,19 @@ structTypedefTemplate params rname fields = vsep [template, struct] where
 
 
 
--- Example
--- > template <class T>
--- > __mlc_Person__<T> fromAnything(const Schema* schema, const Anything* anything, __mlc_Person__<T>* dummy = nullptr)
-serialHeaderTemplate :: [MDoc] -> MDoc -> MDoc
-serialHeaderTemplate params rtype = vsep [template, prototype]
-  where
-  template = makeTemplateHeader params
-  prototype = [idoc|#{rtype} fromAnything(const Schema* schema, const Anything* anything, #{rtype}* dummy = nullptr);|]
-
-
-
-
--- Example:
--- > template<typename T>
--- > Anything* toAnything(const Schema* schema, const __mlc_Person__<T>& obj)
-deserialHeaderTemplate :: [MDoc] -> MDoc -> MDoc
-deserialHeaderTemplate params rtype = vsep [template, prototype]
-  where
-  template = makeTemplateHeader params
-  prototype = [idoc|Anything* toAnything(const Schema* schema, const #{rtype}& obj);|]
-
-
-
 serializerTemplate
   :: [MDoc] -- template parameters
   -> MDoc -- type of thing being serialized
   -> [(MDoc, MDoc)] -- key and type for all fields
   -> MDoc -- output serializer function
 serializerTemplate params rtype fields = [idoc|
 #{makeTemplateHeader params}
-Anything* toAnything(const Schema* schema, const #{rtype}& obj)
+void* toAnything(void* dest, const Schema* schema, const #{rtype}& obj)
 {
-    Anything* result = map_data_(#{pretty $ length fields});
-    #{align $ vsep (zipWith assignFields [0..] fields)}
-    return result;
+    return toAnything(dest, schema, std::make_tuple#{arguments});
 }
 |] where
-  assignFields :: Int -> (MDoc, MDoc) -> MDoc
-  assignFields idx (keyName, _) = vsep
-    [ [idoc|result->data.obj_arr[#{pretty idx}] = toAnything(schema->parameters[#{pretty idx}], obj.#{keyName});|]
-    , [idoc|result->data.obj_arr[#{pretty idx}]->key = strdup("#{keyName}");|]
-    ]
+  arguments = tupled ["obj." <> key | (key, _) <- fields]
 
 
 
@@ -854,15 +820,16 @@ deserializerTemplate isObj params rtype fields
 #{makeTemplateHeader params}
 #{block 4 header body}
 |] where
-  header = [idoc|#{rtype} fromAnything(const Schema* schema, const Anything* anything, #{rtype}* dummy)|]
+  header = [idoc|#{rtype} fromAnything(const Schema* schema, const void * anything, #{rtype}* dummy = nullptr)|]
   body = vsep $ [ [idoc|#{rtype} obj;|] ]
               <> zipWith assignFields [0..] fields
               <> ["return obj;"]
 
   assignFields :: Int -> (MDoc, MDoc) -> MDoc
   assignFields idx (keyName, keyType) = vsep
     [ [idoc|#{keyType}* elemental_dumby_#{keyName} = nullptr;|]
-    , [idoc|obj.#{keyName} = fromAnything(schema->parameters[#{pretty idx}], anything->data.obj_arr[#{pretty idx}], elemental_dumby_#{keyName});|]
+    , [idoc|obj.#{keyName} = fromAnything(schema->parameters[#{pretty idx}], (char*)anything + schema->offsets[#{pretty idx}], elemental_dumby_#{keyName});|]
+
     ]
 
   -- XXX: here need to add back the isObj handling, if is object, need to call