Add written variable for zone writing code to be able to differ between written data and original data

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp

@@ -52,6 +52,13 @@ void BaseTemplate::MakeTypeVarNameInternal(const DataDefinition* def, std::ostri
     MakeSafeTypeNameInternal(def, str);
 }
 
+void BaseTemplate::MakeTypeWrittenVarNameInternal(const DataDefinition* def, std::ostringstream& str)
+{
+    str << "var";
+    MakeSafeTypeNameInternal(def, str);
+    str << "Written";
+}
+
 void BaseTemplate::MakeTypePtrVarNameInternal(const DataDefinition* def, std::ostringstream& str)
 {
     str << "var";
@@ -59,6 +66,13 @@ void BaseTemplate::MakeTypePtrVarNameInternal(const DataDefinition* def, std::os
     str << "Ptr";
 }
 
+void BaseTemplate::MakeTypeWrittenPtrVarNameInternal(const DataDefinition* def, std::ostringstream& str)
+{
+    str << "var";
+    MakeSafeTypeNameInternal(def, str);
+    str << "PtrWritten";
+}
+
 void BaseTemplate::MakeArrayIndicesInternal(const DeclarationModifierComputations& modifierComputations, std::ostringstream& str)
 {
     for (auto index : modifierComputations.GetArrayIndices())
@@ -74,6 +88,14 @@ std::string BaseTemplate::MakeTypeVarName(const DataDefinition* def)
     return str.str();
 }
 
+
+std::string BaseTemplate::MakeTypeWrittenVarName(const DataDefinition* def)
+{
+    std::ostringstream str;
+    MakeTypeWrittenVarNameInternal(def, str);
+    return str.str();
+}
+
 std::string BaseTemplate::MakeTypePtrVarName(const DataDefinition* def)
 {
     std::ostringstream str;
@@ -81,6 +103,13 @@ std::string BaseTemplate::MakeTypePtrVarName(const DataDefinition* def)
     return str.str();
 }
 
+std::string BaseTemplate::MakeTypeWrittenPtrVarName(const DataDefinition* def)
+{
+    std::ostringstream str;
+    MakeTypeWrittenPtrVarNameInternal(def, str);
+    return str.str();
+}
+
 std::string BaseTemplate::MakeSafeTypeName(const DataDefinition* def)
 {
     std::ostringstream str;
@@ -98,6 +127,16 @@ std::string BaseTemplate::MakeMemberAccess(StructureInformation* info, MemberInf
     return str.str();
 }
 
+std::string BaseTemplate::MakeWrittenMemberAccess(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier)
+{
+    std::ostringstream str;
+    MakeTypeWrittenVarNameInternal(info->m_definition, str);
+    str << "->" << member->m_member->m_name;
+    MakeArrayIndicesInternal(modifier, str);
+
+    return str.str();
+}
+
 std::string BaseTemplate::MakeMemberAccess(const std::string& variableName, StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier)
 {
     std::ostringstream str;

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h

@@ -26,7 +26,9 @@ protected:
 private:
     static void MakeSafeTypeNameInternal(const DataDefinition* def, std::ostringstream& str);
     static void MakeTypeVarNameInternal(const DataDefinition* def, std::ostringstream& str);
+    static void MakeTypeWrittenVarNameInternal(const DataDefinition* def, std::ostringstream& str);
     static void MakeTypePtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
+    static void MakeTypeWrittenPtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
     static void MakeArrayIndicesInternal(const DeclarationModifierComputations& modifierComputations, std::ostringstream& str);
     static void MakeOperandStatic(const OperandStatic* op, std::ostringstream& str);
     static void MakeOperandDynamic(const OperandDynamic* op, std::ostringstream& str);
@@ -37,9 +39,12 @@ protected:
     static std::string Upper(std::string str);
     static std::string Lower(std::string str);
     static std::string MakeTypeVarName(const DataDefinition* def);
+    static std::string MakeTypeWrittenVarName(const DataDefinition* def);
     static std::string MakeTypePtrVarName(const DataDefinition* def);
+    static std::string MakeTypeWrittenPtrVarName(const DataDefinition* def);
     static std::string MakeSafeTypeName(const DataDefinition* def);
     static std::string MakeMemberAccess(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier);
+    static std::string MakeWrittenMemberAccess(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier);
     static std::string MakeMemberAccess(const std::string& variableName, StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier);
     static std::string MakeTypeDecl(const TypeDeclaration* decl);
     static std::string MakeFollowingReferences(const std::vector<DeclarationModifier*>& modifiers);

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp

@@ -1,11 +1,9 @@
 #include "ZoneWriteTemplate.h"
 
-
 #include <cassert>
 #include <iostream>
 #include <sstream>
 
-
 #include "Domain/Computations/StructureComputations.h"
 #include "Internal/BaseTemplate.h"
 
@@ -35,6 +33,13 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         return str.str();
     }
 
+    static std::string WrittenVariableDecl(const DataDefinition* def)
+    {
+        std::ostringstream str;
+        str << def->GetFullName() << "* var" << MakeSafeTypeName(def) << "Written;";
+        return str.str();
+    }
+
     static std::string PointerVariableDecl(const DataDefinition* def)
     {
         std::ostringstream str;
@@ -42,6 +47,13 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         return str.str();
     }
 
+    static std::string WrittenPointerVariableDecl(const DataDefinition* def)
+    {
+        std::ostringstream str;
+        str << def->GetFullName() << "** var" << MakeSafeTypeName(def) << "PtrWritten;";
+        return str.str();
+    }
+
     void PrintHeaderPtrArrayWriteMethodDeclaration(const DataDefinition* def) const
     {
         LINE("void WritePtrArray_" << MakeSafeTypeName(def) << "(bool atStreamStart, size_t count);")
@@ -82,11 +94,21 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         LINE("var" << def->m_name << " = nullptr;")
     }
 
+    void PrintWrittenVariableInitialization(const DataDefinition* def) const
+    {
+        LINE("var" << def->m_name << "Written = nullptr;")
+    }
+
     void PrintPointerVariableInitialization(const DataDefinition* def) const
     {
         LINE("var" << def->m_name << "Ptr = nullptr;")
     }
 
+    void PrintWrittenPointerVariableInitialization(const DataDefinition* def) const
+    {
+        LINE("var" << def->m_name << "PtrWritten = nullptr;")
+    }
+
     void PrintConstructorMethod()
     {
         LINE(WriterClassName(m_env.m_asset) << "::" << WriterClassName(m_env.m_asset) << "("<<m_env.m_asset->m_definition->GetFullName()<<"* asset, Zone* zone, IZoneOutputStream* stream)")
@@ -100,7 +122,9 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         m_intendation++;
 
         PrintVariableInitialization(m_env.m_asset->m_definition);
+        PrintWrittenVariableInitialization(m_env.m_asset->m_definition);
         PrintPointerVariableInitialization(m_env.m_asset->m_definition);
+        PrintWrittenPointerVariableInitialization(m_env.m_asset->m_definition);
         LINE("")
 
         for (auto* type : m_env.m_used_types)
@@ -108,6 +132,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
             if (type->m_info && !type->m_info->m_definition->m_anonymous && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset())
             {
                 PrintVariableInitialization(type->m_type);
+                PrintWrittenVariableInitialization(type->m_type);
             }
         }
         for (auto* type : m_env.m_used_types)
@@ -115,6 +140,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
             if (type->m_info && type->m_pointer_array_reference_exists && !type->m_is_context_asset)
             {
                 PrintPointerVariableInitialization(type->m_type);
+                PrintWrittenPointerVariableInitialization(type->m_type);
             }
         }
 
@@ -128,11 +154,11 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         {
             LINE("varScriptString = " << MakeMemberAccess(info, member, modifier) << ";")
             LINE("WriteScriptStringArray(true, " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");")
-            LINE("m_stream->MarkFollowing("<<MakeMemberAccess("writtenData", info, member, modifier)<<");")
+            LINE("m_stream->MarkFollowing("<<MakeWrittenMemberAccess(info, member, modifier)<<");")
         }
         else if (writeType == MemberWriteType::EMBEDDED_ARRAY)
         {
-            LINE("varScriptString = " << MakeMemberAccess(info, member, modifier) << ";")
+            LINE("varScriptStringWritten = " << MakeWrittenMemberAccess(info, member, modifier) << ";")
             LINE("WriteScriptStringArray(false, " << MakeArrayCount(dynamic_cast<ArrayDeclarationModifier*>(modifier.GetDeclarationModifier())) << ");")
         }
         else if (writeType == MemberWriteType::EMBEDDED)
@@ -151,7 +177,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         if (writeType == MemberWriteType::SINGLE_POINTER)
         {
             LINE(WriterClassName(member->m_type) << " writer("<<MakeMemberAccess(info, member, modifier)<<", m_zone, m_stream);")
-            LINE("writer.Write(&" << MakeMemberAccess(info, member, modifier) << ");")
+            LINE("writer.Write(&" << MakeWrittenMemberAccess(info, member, modifier) << ");")
         }
         else if (writeType == MemberWriteType::POINTER_ARRAY)
         {
@@ -170,25 +196,26 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         {
             if (member->m_member->m_type_declaration->m_is_const)
             {
-                LINE("varXString = &" << MakeMemberAccess(info, member, modifier) << ";")
+                LINE("varXStringWritten = &" << MakeWrittenMemberAccess(info, member, modifier) << ";")
             }
             else
             {
-                LINE("varXString = const_cast<const char**>(&" << MakeMemberAccess(info, member, modifier) << ");")
+                LINE("varXStringWritten = const_cast<const char**>(&" << MakeWrittenMemberAccess(info, member, modifier) << ");")
             }
             LINE("WriteXString(false);")
         }
         else if (writeType == MemberWriteType::POINTER_ARRAY)
         {
-            LINE("varXString = " << MakeMemberAccess(info, member, modifier) << ";")
             if (modifier.IsArray())
             {
+                LINE("varXStringWritten = " << MakeWrittenMemberAccess(info, member, modifier) << ";")
                 LINE("WriteXStringArray(false, " << modifier.GetArraySize() << ");")
             }
             else
             {
+                LINE("varXString = " << MakeMemberAccess(info, member, modifier) << ";")
                 LINE("WriteXStringArray(true, " << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");")
-                LINE("m_stream->MarkFollowing(" << MakeMemberAccess("writtenData", info, member, modifier) << ");")
+                LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");")
             }
         }
         else
@@ -211,7 +238,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
             LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers())
                 << ">(" << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");")
         }
-        LINE("m_stream->MarkFollowing(" << MakeMemberAccess("writtenData", info, member, modifier) << ");")
+        LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");")
     }
 
     void WriteMember_PointerArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const
@@ -219,12 +246,13 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         LINE(MakeTypePtrVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";")
         if (modifier.IsArray())
         {
+            LINE(MakeTypeWrittenPtrVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeWrittenMemberAccess(info, member, modifier) << ";")
             LINE("WritePtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false, " << modifier.GetArraySize() << ");")
         }
         else
         {
             LINE("WritePtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");")
-            LINE("m_stream->MarkFollowing("<<MakeMemberAccess("writtenData", info, member, modifier)<<");")
+            LINE("m_stream->MarkFollowing("<<MakeWrittenMemberAccess(info, member, modifier)<<");")
         }
     }
 
@@ -238,49 +266,38 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         else
             arraySizeStr = std::to_string(modifier.GetArraySize());
 
-        std::string memberAccess;
-        if (!(info->m_definition->GetType() == DataDefinitionType::UNION && StructureComputations(info).GetDynamicMember()))
-            memberAccess = MakeMemberAccess("originalData", info, member, modifier);
-        else
-            memberAccess = MakeMemberAccess(info, member, modifier);
-
         if (!member->m_is_leaf)
         {
             if (computations.IsAfterPartialLoad())
             {
-                LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type)<<" = "<<memberAccess<<";")
+                LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type)<<" = "<< MakeMemberAccess(info, member, modifier) <<";")
                 LINE("WriteArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " << arraySizeStr << ");")
             }
             else
             {
                 LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";")
+                LINE(MakeTypeWrittenVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeWrittenMemberAccess(info, member, modifier) << ";")
                 LINE("WriteArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false, " << arraySizeStr << ");")
             }
         }
         else if (computations.IsAfterPartialLoad())
         {
             LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers())
-                << ">(" << memberAccess << ", " << arraySizeStr << ");")
+                << ">(" << MakeMemberAccess(info, member, modifier) << ", " << arraySizeStr << ");")
         }
     }
 
     void WriteMember_DynamicArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const
     {
-        std::string memberAccess;
-        if (!(info->m_definition->GetType() == DataDefinitionType::UNION && StructureComputations(info).GetDynamicMember()))
-            memberAccess = MakeMemberAccess("originalData", info, member, modifier);
-        else
-            memberAccess = MakeMemberAccess(info, member, modifier);
-
         if (member->m_type && !member->m_type->m_is_leaf)
         {
-            LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << memberAccess << ";")
+            LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";")
             LINE("WriteArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");")
         }
         else
         {
             LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers())
-                << ">(" << memberAccess << ", " << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");")
+                << ">(" << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");")
         }
     }
 
@@ -288,29 +305,24 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
     {
         const MemberComputations computations(member);
 
-        std::string memberAccess;
-        if (!(info->m_definition->GetType() == DataDefinitionType::UNION && StructureComputations(info).GetDynamicMember()))
-            memberAccess = MakeMemberAccess("originalData", info, member, modifier);
-        else
-            memberAccess = MakeMemberAccess(info, member, modifier);
-
         if (!member->m_is_leaf)
         {
             if (computations.IsAfterPartialLoad())
             {
-                LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = &" << memberAccess << ";")
+                LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = &" << MakeMemberAccess(info, member, modifier) << ";")
                 LINE("Write_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true);")
             }
             else
             {
                 LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = &" << MakeMemberAccess(info, member, modifier) << ";")
+                LINE(MakeTypeWrittenVarName(member->m_member->m_type_declaration->m_type) << " = &" << MakeWrittenMemberAccess(info, member, modifier) << ";")
                 LINE("Write_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false);")
             }
         }
         else if (computations.IsAfterPartialLoad())
         {
             LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers())
-                << ">(&" << memberAccess << ");")
+                << ">(&" << MakeMemberAccess(info, member, modifier) << ");")
         }
     }
 
@@ -327,7 +339,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
             LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers())
                 << ">(" << MakeMemberAccess(info, member, modifier) << ");")
         }
-        LINE("m_stream->MarkFollowing(" << MakeMemberAccess("writtenData", info, member, modifier) << ");")
+        LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");")
     }
 
     void WriteMember_TypeCheck(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) const
@@ -522,7 +534,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
             return;
         }
 
-        LINE("if(m_stream->ReusableShouldWrite(&" << MakeMemberAccess(info, member, modifier) << "))")
+        LINE("if(m_stream->ReusableShouldWrite(&" << MakeWrittenMemberAccess(info, member, modifier) << "))")
         LINE("{")
         m_intendation++;
 
@@ -761,36 +773,29 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         m_intendation++;
 
         LINE("assert(" << MakeTypeVarName(info->m_definition) << " != nullptr);")
+        LINE("")
 
         auto* dynamicMember = computations.GetDynamicMember();
         if (!(info->m_definition->GetType() == DataDefinitionType::UNION && dynamicMember))
         {
-            LINE("")
-
-            if (dynamicMember)
-            {
-                LINE("auto* originalData = "<<MakeTypeVarName(info->m_definition)<<";")
-            }
-
             LINE("if(atStreamStart)")
             m_intendation++;
 
             if (dynamicMember == nullptr)
             {
-                LINE(MakeTypeVarName(info->m_definition)<<" = m_stream->Write<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) << "); // Size: " << info->
-                    m_definition->GetSize())
+                LINE(MakeTypeWrittenVarName(info->m_definition)<<" = m_stream->Write<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) << "); // Size: "
+                    << info->m_definition->GetSize())
             }
             else
             {
-                LINE(MakeTypeVarName(info->m_definition) << " = m_stream->WritePartial<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) << ", offsetof(" << info->
-                    m_definition->GetFullName()
-                    << ", " << dynamicMember->m_member->m_name << "));")
+                LINE(MakeTypeWrittenVarName(info->m_definition) << " = m_stream->WritePartial<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) << ", offsetof(" <<
+                    info->m_definition->GetFullName() << ", " << dynamicMember->m_member->m_name << "));")
             }
 
             m_intendation--;
 
             LINE("")
-            LINE("auto* writtenData = "<<MakeTypeVarName(info->m_definition)<<";")
+            LINE("assert(" << MakeTypeWrittenVarName(info->m_definition) << " != nullptr);")
         }
         else
         {
@@ -835,16 +840,19 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
 
         LINE("if(atStreamStart)")
         m_intendation++;
-        LINE(MakeTypePtrVarName(info->m_definition)<<" = m_stream->Write<" << info->m_definition->GetFullName() << "*>(" << MakeTypePtrVarName(info->m_definition) << ");")
+        LINE(MakeTypeWrittenPtrVarName(info->m_definition)<<" = m_stream->Write<" << info->m_definition->GetFullName() << "*>(" << MakeTypePtrVarName(info->m_definition) << ");")
         m_intendation--;
 
+        LINE("")
+        LINE("assert(" << MakeTypeWrittenPtrVarName(info->m_definition) << " != nullptr);")
+
         LINE("")
         if (inTemp)
         {
             LINE("m_stream->PushBlock(" << m_env.m_default_temp_block->m_name << ");")
             LINE("")
         }
-        LINE("if(m_stream->ReusableShouldWrite(" << MakeTypePtrVarName(info->m_definition) << "))")
+        LINE("if(m_stream->ReusableShouldWrite(" << MakeTypeWrittenPtrVarName(info->m_definition) << "))")
         LINE("{")
         m_intendation++;
 
@@ -862,7 +870,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         }
 
         LINE("")
-        LINE("m_stream->MarkFollowing(*"<<MakeTypePtrVarName(info->m_definition)<<");")
+        LINE("m_stream->MarkFollowing(*"<<MakeTypeWrittenPtrVarName(info->m_definition)<<");")
 
         m_intendation--;
         LINE("}")
@@ -889,6 +897,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         LINE("")
         LINE("auto* zoneAsset = static_cast<"<<m_env.m_asset->m_definition->GetFullName()<<"*>(m_asset->m_ptr);")
         LINE(MakeTypePtrVarName(m_env.m_asset->m_definition) << " = &zoneAsset;")
+        LINE(MakeTypeWrittenPtrVarName(m_env.m_asset->m_definition) << " = &zoneAsset;")
         LINE("WritePtr_" << MakeSafeTypeName(m_env.m_asset->m_definition) << "(false);")
         LINE("*pAsset = zoneAsset;")
 
@@ -948,7 +957,7 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         {
             LINE("m_stream->Write<" << def->GetFullName() << ">(*" << MakeTypePtrVarName(def) << ");")
         }
-        LINE("m_stream->MarkFollowing(*"<< MakeTypePtrVarName(def)<<");")
+        LINE("m_stream->MarkFollowing(*"<< MakeTypeWrittenPtrVarName(def)<<");")
     }
 
     void PrintWritePtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable)
@@ -960,13 +969,13 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         if (info && StructureComputations(info).IsAsset())
         {
             LINE(WriterClassName(info) << " writer(*"<< MakeTypePtrVarName(def)<<", m_zone, m_stream);")
-            LINE("writer.Write(" << MakeTypePtrVarName(def) << ");")
+            LINE("writer.Write(" << MakeTypeWrittenPtrVarName(def) << ");")
         }
         else
         {
             if (reusable)
             {
-                LINE("if(m_stream->ReusableShouldWrite(" << MakeTypePtrVarName(def) << "))")
+                LINE("if(m_stream->ReusableShouldWrite(" << MakeTypeWrittenPtrVarName(def) << "))")
                 LINE("{")
                 m_intendation++;
 
@@ -996,19 +1005,25 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
 
         LINE("if(atStreamStart)")
         m_intendation++;
-        LINE(MakeTypePtrVarName(def)<<" = m_stream->Write<" << def->GetFullName() << "*>(" << MakeTypePtrVarName(def) << ", count);")
+        LINE(MakeTypeWrittenPtrVarName(def)<<" = m_stream->Write<" << def->GetFullName() << "*>(" << MakeTypePtrVarName(def) << ", count);")
         m_intendation--;
 
+        LINE("")
+        LINE("assert(" << MakeTypeWrittenPtrVarName(def) << " != nullptr);")
+
         LINE("")
         LINE(def->GetFullName() << "** var = " << MakeTypePtrVarName(def) << ";")
+        LINE(def->GetFullName() << "** varWritten = " << MakeTypeWrittenPtrVarName(def) << ";")
         LINE("for(size_t index = 0; index < count; index++)")
         LINE("{")
         m_intendation++;
 
         LINE(MakeTypePtrVarName(def) << " = var;")
+        LINE(MakeTypeWrittenPtrVarName(def) << " = varWritten;")
         PrintWritePtrArrayMethod_PointerCheck(def, info, reusable);
         LINE("")
         LINE("var++;")
+        LINE("varWritten++;")
 
         m_intendation--;
         LINE("}")
@@ -1026,18 +1041,24 @@ class ZoneWriteTemplate::Internal final : BaseTemplate
         LINE("")
         LINE("if(atStreamStart)")
         m_intendation++;
-        LINE(MakeTypeVarName(def)<<" = m_stream->Write<" << def->GetFullName() << ">(" << MakeTypeVarName(def) << ", count);")
+        LINE(MakeTypeWrittenVarName(def)<<" = m_stream->Write<" << def->GetFullName() << ">(" << MakeTypeVarName(def) << ", count);")
         m_intendation--;
 
+        LINE("")
+        LINE("assert(" << MakeTypeWrittenVarName(def) << " != nullptr);")
+
         LINE("")
         LINE(def->GetFullName() << "* var = " << MakeTypeVarName(def) << ";")
+        LINE(def->GetFullName() << "* varWritten = " << MakeTypeWrittenVarName(def) << ";")
         LINE("for(size_t index = 0; index < count; index++)")
         LINE("{")
         m_intendation++;
 
         LINE(MakeTypeVarName(info->m_definition) << " = var;")
+        LINE(MakeTypeWrittenVarName(info->m_definition) << " = varWritten;")
         LINE("Write_" << info->m_definition->m_name << "(false);")
         LINE("var++;")
+        LINE("varWritten++;")
 
         m_intendation--;
         LINE("}")
@@ -1074,7 +1095,9 @@ public:
         m_intendation++;
 
         LINE(VariableDecl(m_env.m_asset->m_definition))
+        LINE(WrittenVariableDecl(m_env.m_asset->m_definition))
         LINE(PointerVariableDecl(m_env.m_asset->m_definition))
+        LINE(WrittenPointerVariableDecl(m_env.m_asset->m_definition))
         LINE("")
 
         // Variable Declarations: type varType;
@@ -1083,6 +1106,7 @@ public:
             if (type->m_info && !type->m_info->m_definition->m_anonymous && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset())
             {
                 LINE(VariableDecl(type->m_type))
+                LINE(WrittenVariableDecl(type->m_type))
             }
         }
         for (auto* type : m_env.m_used_types)
@@ -1090,6 +1114,7 @@ public:
             if (type->m_pointer_array_reference_exists && !type->m_is_context_asset)
             {
                 LINE(PointerVariableDecl(type->m_type))
+                LINE(WrittenPointerVariableDecl(type->m_type))
             }
         }
 

src/ZoneWriting/Writing/AssetWriter.cpp

@@ -5,7 +5,8 @@
 AssetWriter::AssetWriter(XAssetInfoGeneric* asset, Zone* zone, IZoneOutputStream* stream)
     : ContentWriterBase(zone, stream),
       m_asset(asset),
-      varScriptString(nullptr)
+      varScriptString(nullptr),
+      varScriptStringWritten(nullptr)
 {
 }
 
@@ -22,12 +23,15 @@ scr_string_t AssetWriter::UseScriptString(const scr_string_t scrString) const
 
 void AssetWriter::WriteScriptStringArray(const bool atStreamStart, const size_t count)
 {
-    assert(varScriptString != nullptr);
-
     if (atStreamStart)
-        varScriptString = m_stream->Write<scr_string_t>(varScriptString, count);
+    {
+        assert(varScriptString != nullptr);
+        varScriptStringWritten = m_stream->Write<scr_string_t>(varScriptString, count);
+    }
 
-    auto* ptr = varScriptString;
+    assert(varScriptStringWritten != nullptr);
+
+    auto* ptr = varScriptStringWritten;
     for (size_t index = 0; index < count; index++)
     {
         *ptr = UseScriptString(*ptr);

src/ZoneWriting/Writing/AssetWriter.h

@@ -12,6 +12,7 @@ protected:
     XAssetInfoGeneric* m_asset;
 
     scr_string_t* varScriptString;
+    scr_string_t* varScriptStringWritten;
 
     AssetWriter(XAssetInfoGeneric* asset, Zone* zone, IZoneOutputStream* stream);
 

src/ZoneWriting/Writing/ContentWriterBase.cpp

@@ -4,6 +4,7 @@
 
 ContentWriterBase::ContentWriterBase()
     : varXString(nullptr),
+      varXStringWritten(nullptr),
       m_zone(nullptr),
       m_stream(nullptr)
 {
@@ -11,6 +12,7 @@ ContentWriterBase::ContentWriterBase()
 
 ContentWriterBase::ContentWriterBase(Zone* zone, IZoneOutputStream* stream)
     : varXString(nullptr),
+      varXStringWritten(nullptr),
       m_zone(zone),
       m_stream(stream)
 {
@@ -18,31 +20,37 @@ ContentWriterBase::ContentWriterBase(Zone* zone, IZoneOutputStream* stream)
 
 void ContentWriterBase::WriteXString(const bool atStreamStart)
 {
-    assert(varXString != nullptr);
-
     if (atStreamStart)
-        varXString = m_stream->Write<const char*>(varXString);
+    {
+        assert(varXString != nullptr);
+        varXStringWritten = m_stream->Write<const char*>(varXString);
+    }
 
-    if (m_stream->ReusableShouldWrite(varXString))
+    assert(varXStringWritten != nullptr);
+
+    if (m_stream->ReusableShouldWrite(varXStringWritten))
     {
         m_stream->Align(alignof(const char));
-        m_stream->ReusableAddOffset(*varXString);
-        m_stream->WriteNullTerminated(*varXString);
+        m_stream->ReusableAddOffset(*varXStringWritten);
+        m_stream->WriteNullTerminated(*varXStringWritten);
 
-        m_stream->MarkFollowing(*varXString);
+        m_stream->MarkFollowing(*varXStringWritten);
     }
 }
 
 void ContentWriterBase::WriteXStringArray(const bool atStreamStart, const size_t count)
 {
-    assert(varXString != nullptr);
-
     if (atStreamStart)
-        varXString = m_stream->Write<const char*>(varXString, count);
+    {
+        assert(varXString != nullptr);
+        varXStringWritten = m_stream->Write<const char*>(varXString, count);
+    }
+
+    assert(varXStringWritten != nullptr);
 
     for (size_t index = 0; index < count; index++)
     {
         WriteXString(false);
-        varXString++;
+        varXStringWritten++;
     }
 }

src/ZoneWriting/Writing/ContentWriterBase.h

@@ -7,6 +7,7 @@ class ContentWriterBase
 {
 protected:
     const char** varXString;
+    const char** varXStringWritten;
 
     Zone* m_zone;
     IZoneOutputStream* m_stream;