From 10cbd47bdcc41d6e2597e523c97095e342196ba9 Mon Sep 17 00:00:00 2001 From: Jan Date: Mon, 21 Apr 2025 10:38:55 +0200 Subject: [PATCH] chore: use std::format for zcg templates --- .../Templates/Internal/BaseTemplate.cpp | 13 +- .../Templates/Internal/BaseTemplate.h | 31 +- .../Generating/Templates/ZoneLoadTemplate.cpp | 481 ++++++++-------- .../Generating/Templates/ZoneMarkTemplate.cpp | 269 +++++---- .../Templates/ZoneWriteTemplate.cpp | 519 +++++++++--------- 5 files changed, 649 insertions(+), 664 deletions(-) diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp index c454554b..eb72f0fd 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp @@ -74,7 +74,7 @@ void BaseTemplate::MakeTypeWrittenPtrVarNameInternal(const DataDefinition* def, void BaseTemplate::MakeArrayIndicesInternal(const DeclarationModifierComputations& modifierComputations, std::ostringstream& str) { - for (auto index : modifierComputations.GetArrayIndices()) + for (const auto index : modifierComputations.GetArrayIndices()) { str << "[" << index << "]"; } @@ -115,7 +115,7 @@ std::string BaseTemplate::MakeSafeTypeName(const DataDefinition* def) return str.str(); } -std::string BaseTemplate::MakeMemberAccess(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) +std::string BaseTemplate::MakeMemberAccess(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { std::ostringstream str; MakeTypeVarNameInternal(info->m_definition, str); @@ -125,7 +125,8 @@ std::string BaseTemplate::MakeMemberAccess(StructureInformation* info, MemberInf return str.str(); } -std::string BaseTemplate::MakeWrittenMemberAccess(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) +std::string + BaseTemplate::MakeWrittenMemberAccess(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { std::ostringstream str; MakeTypeWrittenVarNameInternal(info->m_definition, str); @@ -137,7 +138,7 @@ std::string BaseTemplate::MakeWrittenMemberAccess(StructureInformation* info, Me std::string BaseTemplate::MakeMemberAccess(const std::string& variableName, StructureInformation* info, - MemberInformation* member, + const MemberInformation* member, const DeclarationModifierComputations& modifier) { std::ostringstream str; @@ -185,13 +186,13 @@ std::string BaseTemplate::MakeArrayIndices(const DeclarationModifierComputations return str.str(); } -std::string BaseTemplate::MakeCustomActionCall(CustomAction* action) +std::string BaseTemplate::MakeCustomActionCall(const CustomAction* action) { std::ostringstream str; str << "m_actions." << action->m_action_name << "("; auto first = true; - for (auto* def : action->m_parameter_types) + for (const auto* def : action->m_parameter_types) { if (first) { diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h b/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h index 74296029..c95fd764 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h @@ -7,13 +7,13 @@ #include "Domain/Evaluation/Operation.h" #include "Generating/RenderingContext.h" +#include #include -#include class BaseTemplate { protected: - static constexpr const char* INTENDATION = " "; + static constexpr auto INTENDATION = " "; BaseTemplate(std::ostream& stream, RenderingContext* context); @@ -26,16 +26,17 @@ protected: 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 StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier); + static std::string + MakeWrittenMemberAccess(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier); static std::string MakeMemberAccess(const std::string& variableName, StructureInformation* info, - MemberInformation* member, + const MemberInformation* member, const DeclarationModifierComputations& modifier); static std::string MakeTypeDecl(const TypeDeclaration* decl); static std::string MakeFollowingReferences(const std::vector& modifiers); static std::string MakeArrayIndices(const DeclarationModifierComputations& modifierComputations); - static std::string MakeCustomActionCall(CustomAction* action); + static std::string MakeCustomActionCall(const CustomAction* action); static std::string MakeArrayCount(const ArrayDeclarationModifier* arrayModifier); static std::string MakeEvaluation(const IEvaluation* evaluation); @@ -61,16 +62,34 @@ private: DoIntendation(); \ m_out << x << "\n"; \ } +#define LINEF(...) \ + { \ + DoIntendation(); \ + m_out << std::format(__VA_ARGS__) << "\n"; \ + } #define LINE_START(x) \ { \ DoIntendation(); \ m_out << x; \ } +#define LINE_STARTF(...) \ + { \ + DoIntendation(); \ + m_out << std::format(__VA_ARGS__); \ + } #define LINE_MIDDLE(x) \ { \ m_out << x; \ } +#define LINE_MIDDLEF(...) \ + { \ + m_out << std::format(__VA_ARGS__); \ + } #define LINE_END(x) \ { \ m_out << x << "\n"; \ } +#define LINE_ENDF(...) \ + { \ + m_out << std::format(__VA_ARGS__) << "\n"; \ + } diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp index 53064960..d088da67 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp @@ -10,8 +10,8 @@ namespace { - static constexpr int TAG_HEADER = 1; - static constexpr int TAG_SOURCE = 2; + constexpr int TAG_HEADER = 1; + constexpr int TAG_SOURCE = 2; class Template final : BaseTemplate { @@ -25,46 +25,45 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") LINE("#pragma once") LINE("") LINE("#include \"Loading/AssetLoader.h\"") - LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"") + LINEF("#include \"Game/{0}/{0}.h\"", m_env.m_game) if (m_env.m_has_actions) { - LINE("#include \"Game/" << m_env.m_game << "/XAssets/" << Lower(m_env.m_asset->m_definition->m_name) << "/" - << Lower(m_env.m_asset->m_definition->m_name) << "_actions.h\"") + LINEF("#include \"Game/{0}/XAssets/{1}/{1}_actions.h\"", m_env.m_game, Lower(m_env.m_asset->m_definition->m_name)) } LINE("#include ") LINE("") - LINE("namespace " << m_env.m_game) + LINEF("namespace {0}", m_env.m_game) LINE("{") m_intendation++; - LINE("class " << LoaderClassName(m_env.m_asset) << " final : public AssetLoader") + LINEF("class {0} final : public AssetLoader", LoaderClassName(m_env.m_asset)) LINE("{") m_intendation++; - LINE("XAssetInfo<" << m_env.m_asset->m_definition->GetFullName() << ">* m_asset_info;") + LINEF("XAssetInfo<{0}>* m_asset_info;", m_env.m_asset->m_definition->GetFullName()) if (m_env.m_has_actions) { - LINE("Actions_" << m_env.m_asset->m_definition->m_name << " m_actions;") + LINEF("Actions_{0} m_actions;", m_env.m_asset->m_definition->m_name) } LINE(VariableDecl(m_env.m_asset->m_definition)) LINE(PointerVariableDecl(m_env.m_asset->m_definition)) LINE("") // Variable Declarations: type varType; - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { 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)) } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists && !type->m_is_context_asset) { @@ -75,21 +74,21 @@ namespace LINE("") // Method Declarations - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists) { PrintHeaderPtrArrayLoadMethodDeclaration(type->m_type); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_array_reference_exists && type->m_info && !type->m_info->m_is_leaf && type->m_non_runtime_reference_exists) { PrintHeaderArrayLoadMethodDeclaration(type->m_type); } } - for (auto* type : m_env.m_used_structures) + for (const auto* type : m_env.m_used_structures) { if (type->m_non_runtime_reference_exists && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -117,12 +116,12 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") - LINE("#include \"" << Lower(m_env.m_asset->m_definition->m_name) << "_load_db.h\"") - LINE("#include \"" << Lower(m_env.m_asset->m_definition->m_name) << "_mark_db.h\"") + LINEF("#include \"{0}_load_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) + LINEF("#include \"{0}_mark_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) LINE("#include ") LINE("#include ") LINE("") @@ -130,17 +129,17 @@ namespace if (!m_env.m_referenced_assets.empty()) { LINE("// Referenced Assets:") - for (auto* type : m_env.m_referenced_assets) + for (const auto* type : m_env.m_referenced_assets) { - LINE("#include \"../" << Lower(type->m_type->m_name) << "/" << Lower(type->m_type->m_name) << "_load_db.h\"") + LINEF("#include \"../{0}/{0}_load_db.h\"", Lower(type->m_type->m_name)) } LINE("") } - LINE("using namespace " << m_env.m_game << ";") + LINEF("using namespace {0};", m_env.m_game) LINE("") PrintConstructorMethod(); - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists) { @@ -148,7 +147,7 @@ namespace PrintLoadPtrArrayMethod(type->m_type, type->m_info, type->m_pointer_array_reference_is_reusable); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_array_reference_exists && type->m_info && !type->m_info->m_is_leaf && type->m_non_runtime_reference_exists) { @@ -156,7 +155,7 @@ namespace PrintLoadArrayMethod(type->m_type, type->m_info); } } - for (auto* type : m_env.m_used_structures) + for (const auto* type : m_env.m_used_structures) { if (type->m_non_runtime_reference_exists && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -177,7 +176,7 @@ namespace } private: - enum class MemberLoadType + enum class MemberLoadType : std::uint8_t { ARRAY_POINTER, DYNAMIC_ARRAY, @@ -187,90 +186,82 @@ namespace SINGLE_POINTER }; - static std::string LoaderClassName(StructureInformation* asset) + static std::string LoaderClassName(const StructureInformation* asset) { - std::ostringstream str; - str << "Loader_" << asset->m_definition->m_name; - return str.str(); + return std::format("Loader_{0}", asset->m_definition->m_name); } - static std::string MarkerClassName(StructureInformation* asset) + static std::string MarkerClassName(const StructureInformation* asset) { - std::ostringstream str; - str << "Marker_" << asset->m_definition->m_name; - return str.str(); + return std::format("Marker_{0}", asset->m_definition->m_name); } static std::string VariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "* var" << MakeSafeTypeName(def) << ";"; - return str.str(); + return std::format("{0}* var{1};", def->GetFullName(), MakeSafeTypeName(def)); } static std::string PointerVariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "** var" << MakeSafeTypeName(def) << "Ptr;"; - return str.str(); + return std::format("{0}** var{1}Ptr;", def->GetFullName(), MakeSafeTypeName(def)); } void PrintHeaderPtrArrayLoadMethodDeclaration(const DataDefinition* def) const { - LINE("void LoadPtrArray_" << MakeSafeTypeName(def) << "(bool atStreamStart, size_t count);") + LINEF("void LoadPtrArray_{0}(bool atStreamStart, size_t count);", MakeSafeTypeName(def)) } void PrintHeaderArrayLoadMethodDeclaration(const DataDefinition* def) const { - LINE("void LoadArray_" << MakeSafeTypeName(def) << "(bool atStreamStart, size_t count);") + LINEF("void LoadArray_{0}(bool atStreamStart, size_t count);", MakeSafeTypeName(def)) } void PrintHeaderLoadMethodDeclaration(const StructureInformation* info) const { - LINE("void Load_" << MakeSafeTypeName(info->m_definition) << "(bool atStreamStart);") + LINEF("void Load_{0}(bool atStreamStart);", MakeSafeTypeName(info->m_definition)) } void PrintHeaderTempPtrLoadMethodDeclaration(const StructureInformation* info) const { - LINE("void LoadPtr_" << MakeSafeTypeName(info->m_definition) << "(bool atStreamStart);") + LINEF("void LoadPtr_{0}(bool atStreamStart);", MakeSafeTypeName(info->m_definition)) } void PrintHeaderAssetLoadMethodDeclaration(const StructureInformation* info) const { - LINE("void LoadAsset_" << MakeSafeTypeName(info->m_definition) << "(" << info->m_definition->GetFullName() << "** pAsset);") + LINEF("void LoadAsset_{0}({1}** pAsset);", MakeSafeTypeName(info->m_definition), info->m_definition->GetFullName()) } void PrintHeaderGetNameMethodDeclaration(const StructureInformation* info) const { - LINE("static std::string GetAssetName(" << info->m_definition->GetFullName() << "* pAsset);") + LINEF("static std::string GetAssetName({0}* pAsset);", info->m_definition->GetFullName()) } void PrintHeaderMainLoadMethodDeclaration(const StructureInformation* info) const { - LINE("XAssetInfo<" << info->m_definition->GetFullName() << ">* Load(" << info->m_definition->GetFullName() << "** pAsset);") + LINEF("XAssetInfo<{0}>* Load({0}** pAsset);", info->m_definition->GetFullName()) } void PrintHeaderConstructor() const { - LINE(LoaderClassName(m_env.m_asset) << "(Zone* zone, IZoneInputStream* stream);") + LINEF("{0}(Zone* zone, IZoneInputStream* stream);", LoaderClassName(m_env.m_asset)) } void PrintVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << " = nullptr;") + LINEF("var{0} = nullptr;", def->m_name) } void PrintPointerVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << "Ptr = nullptr;") + LINEF("var{0}Ptr = nullptr;", def->m_name) } void PrintConstructorMethod() { - LINE(LoaderClassName(m_env.m_asset) << "::" << LoaderClassName(m_env.m_asset) << "(Zone* zone, IZoneInputStream* stream)") + LINEF("{0}::{0}(Zone* zone, IZoneInputStream* stream)", LoaderClassName(m_env.m_asset)) m_intendation++; - LINE_START(": AssetLoader(" << m_env.m_asset->m_asset_enum_entry->m_name << ", zone, stream)") + LINE_STARTF(": AssetLoader({0}, zone, stream)", m_env.m_asset->m_asset_enum_entry->m_name) if (m_env.m_has_actions) { LINE_MIDDLE(", m_actions(zone)") @@ -286,14 +277,14 @@ namespace PrintPointerVariableInitialization(m_env.m_asset->m_definition); LINE("") - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { 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); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_info && type->m_pointer_array_reference_exists && !type->m_is_context_asset) { @@ -305,37 +296,37 @@ namespace LINE("}") } - void PrintLoadPtrArrayMethod_Loading(const DataDefinition* def, StructureInformation* info) const + void PrintLoadPtrArrayMethod_Loading(const DataDefinition* def, const StructureInformation* info) const { - LINE("*" << MakeTypePtrVarName(def) << " = m_stream->Alloc<" << def->GetFullName() << ">(" << def->GetAlignment() << ");") + LINEF("*{0} = m_stream->Alloc<{1}>({2});", MakeTypePtrVarName(def), def->GetFullName(), def->GetAlignment()) if (info && !info->m_is_leaf) { - LINE(MakeTypeVarName(info->m_definition) << " = *" << MakeTypePtrVarName(def) << ";") - LINE("Load_" << MakeSafeTypeName(def) << "(true);") + LINEF("{0} = *{1};", MakeTypeVarName(info->m_definition), MakeTypePtrVarName(def)) + LINEF("Load_{0}(true);", MakeSafeTypeName(def)) } else { - LINE("m_stream->Load<" << def->GetFullName() << ">(*" << MakeTypePtrVarName(def) << ");") + LINEF("m_stream->Load<{0}>(*{1});", def->GetFullName(), MakeTypePtrVarName(def)) } } void PrintLoadPtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("if (*" << MakeTypePtrVarName(def) << ")") + LINEF("if (*{0})", MakeTypePtrVarName(def)) LINE("{") m_intendation++; if (info && StructureComputations(info).IsAsset()) { - LINE(LoaderClassName(info) << " loader(m_zone, m_stream);") - LINE("loader.Load(" << MakeTypePtrVarName(def) << ");") + LINEF("{0} loader(m_zone, m_stream);", LoaderClassName(info)) + LINEF("loader.Load({0});", MakeTypePtrVarName(def)) } else { if (reusable) { - LINE("if(*" << MakeTypePtrVarName(def) << " == PTR_FOLLOWING)") + LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(def)) LINE("{") m_intendation++; @@ -347,7 +338,7 @@ namespace LINE("{") m_intendation++; - LINE("*" << MakeTypePtrVarName(def) << " = m_stream->ConvertOffsetToPointer(*" << MakeTypePtrVarName(def) << ");") + LINEF("*{0} = m_stream->ConvertOffsetToPointer(*{0});", MakeTypePtrVarName(def)) m_intendation--; LINE("}") @@ -364,25 +355,25 @@ namespace void PrintLoadPtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("void " << LoaderClassName(m_env.m_asset) << "::LoadPtrArray_" << MakeSafeTypeName(def) << "(const bool atStreamStart, const size_t count)") + LINEF("void {0}::LoadPtrArray_{1}(const bool atStreamStart, const size_t count)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypePtrVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypePtrVarName(def)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE("m_stream->Load<" << def->GetFullName() << "*>(" << MakeTypePtrVarName(def) << ", count);") + LINEF("m_stream->Load<{0}*>({1}, count);", def->GetFullName(), MakeTypePtrVarName(def)) m_intendation--; LINE("") - LINE(def->GetFullName() << "** var = " << MakeTypePtrVarName(def) << ";") + LINEF("{0}** var = {1};", def->GetFullName(), MakeTypePtrVarName(def)) LINE("for(size_t index = 0; index < count; index++)") LINE("{") m_intendation++; - LINE(MakeTypePtrVarName(def) << " = var;") + LINEF("{0} = var;", MakeTypePtrVarName(def)) PrintLoadPtrArrayMethod_PointerCheck(def, info, reusable); LINE("") LINE("var++;") @@ -393,27 +384,27 @@ namespace LINE("}") } - void PrintLoadArrayMethod(const DataDefinition* def, StructureInformation* info) + void PrintLoadArrayMethod(const DataDefinition* def, const StructureInformation* info) { - LINE("void " << LoaderClassName(m_env.m_asset) << "::LoadArray_" << MakeSafeTypeName(def) << "(const bool atStreamStart, const size_t count)") + LINEF("void {0}::LoadArray_{1}(const bool atStreamStart, const size_t count)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(def)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE("m_stream->Load<" << def->GetFullName() << ">(" << MakeTypeVarName(def) << ", count);") + LINEF("m_stream->Load<{0}>({1}, count);", def->GetFullName(), MakeTypeVarName(def)) m_intendation--; LINE("") - LINE(def->GetFullName() << "* var = " << MakeTypeVarName(def) << ";") + LINEF("{0}* var = {1};", def->GetFullName(), MakeTypeVarName(def)) LINE("for(size_t index = 0; index < count; index++)") LINE("{") m_intendation++; - LINE(MakeTypeVarName(info->m_definition) << " = var;") - LINE("Load_" << info->m_definition->m_name << "(false);") + LINEF("{0} = var;", MakeTypeVarName(info->m_definition)) + LINEF("Load_{0}(false);", info->m_definition->m_name) LINE("var++;") m_intendation--; @@ -423,15 +414,15 @@ namespace LINE("}") } - void LoadMember_Asset(StructureInformation* info, - MemberInformation* member, + void LoadMember_Asset(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { if (loadType == MemberLoadType::SINGLE_POINTER) { - LINE(LoaderClassName(member->m_type) << " loader(m_zone, m_stream);") - LINE("loader.Load(&" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("{0} loader(m_zone, m_stream);", LoaderClassName(member->m_type)) + LINEF("loader.Load(&{0});", MakeMemberAccess(info, member, modifier)) } else if (loadType == MemberLoadType::POINTER_ARRAY) { @@ -440,12 +431,12 @@ namespace else { assert(false); - LINE("#error unsupported loadType " << static_cast(loadType) << " for asset") + LINEF("#error unsupported loadType {0} for asset", static_cast(loadType)) } } - void LoadMember_String(StructureInformation* info, - MemberInformation* member, + void LoadMember_String(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { @@ -453,41 +444,42 @@ namespace { if (member->m_member->m_type_declaration->m_is_const) { - LINE("varXString = &" << MakeMemberAccess(info, member, modifier) << ";") + LINEF("varXString = &{0};", MakeMemberAccess(info, member, modifier)) } else { - LINE("varXString = const_cast(&" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("varXString = const_cast(&{0});", MakeMemberAccess(info, member, modifier)) } LINE("LoadXString(false);") } else if (loadType == MemberLoadType::POINTER_ARRAY) { - LINE("varXString = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("varXString = {0};", MakeMemberAccess(info, member, modifier)) if (modifier.IsArray()) { - LINE("LoadXStringArray(false, " << modifier.GetArraySize() << ");") + LINEF("LoadXStringArray(false, {0});", modifier.GetArraySize()) } else { - LINE("LoadXStringArray(true, " << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("LoadXStringArray(true, {0});", MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } else { assert(false); - LINE("#error unsupported loadType " << static_cast(loadType) << " for string") + LINEF("#error unsupported loadType {0} for string", static_cast(loadType)) } } - void LoadMember_ArrayPointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_ArrayPointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); if (member->m_type && !member->m_type->m_is_leaf && !computations.IsInRuntimeBlock()) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("LoadArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " - << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("LoadArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) if (member->m_type->m_post_load_action) { @@ -503,27 +495,30 @@ namespace } else { - LINE("m_stream->Load<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");") + LINEF("m_stream->Load<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } } - void LoadMember_PointerArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_PointerArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypePtrVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0} = {1};", MakeTypePtrVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) if (modifier.IsArray()) { - LINE("LoadPtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false, " << modifier.GetArraySize() << ");") + LINEF("LoadPtrArray_{0}(false, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), modifier.GetArraySize()) } else { - LINE("LoadPtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " - << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("LoadPtrArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } - void LoadMember_EmbeddedArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_EmbeddedArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); std::string arraySizeStr; @@ -535,15 +530,15 @@ namespace if (!member->m_is_leaf) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) if (computations.IsAfterPartialLoad()) { - LINE("LoadArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " << arraySizeStr << ");") + LINEF("LoadArray_{0}(true, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), arraySizeStr) } else { - LINE("LoadArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false, " << arraySizeStr << ");") + LINEF("LoadArray_{0}(false, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), arraySizeStr) } if (member->m_type->m_post_load_action) @@ -560,42 +555,47 @@ namespace } else if (computations.IsAfterPartialLoad()) { - LINE("m_stream->Load<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << arraySizeStr << ");") + LINEF("m_stream->Load<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + arraySizeStr) } } - void LoadMember_DynamicArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_DynamicArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { if (member->m_type && !member->m_type->m_is_leaf) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("LoadArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " - << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("LoadArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetDynamicArraySizeEvaluation())) } else { - LINE("m_stream->Load<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");") + LINEF("m_stream->Load<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetDynamicArraySizeEvaluation())) } } - void LoadMember_Embedded(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_Embedded(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); if (!member->m_is_leaf) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = &" << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0} = &{1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) if (computations.IsAfterPartialLoad()) { - LINE("Load_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true);") + LINEF("Load_{0}(true);", MakeSafeTypeName(member->m_member->m_type_declaration->m_type)) } else { - LINE("Load_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(false);") + LINEF("Load_{0}(false);", MakeSafeTypeName(member->m_member->m_type_declaration->m_type)) } if (member->m_type->m_post_load_action) @@ -612,19 +612,20 @@ namespace } else if (computations.IsAfterPartialLoad()) { - LINE("m_stream->Load<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(&" - << MakeMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->Load<{0}{1}>(&{2});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier)) } } - void LoadMember_SinglePointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void LoadMember_SinglePointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); if (member->m_type && !member->m_type->m_is_leaf && !computations.IsInRuntimeBlock()) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("Load_" << MakeSafeTypeName(member->m_type->m_definition) << "(true);") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Load_{0}(true);", MakeSafeTypeName(member->m_type->m_definition)) if (member->m_type->m_post_load_action) { @@ -640,14 +641,15 @@ namespace } else { - LINE("m_stream->Load<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->Load<{0}{1}>({2});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier)) } } - void LoadMember_TypeCheck(StructureInformation* info, - MemberInformation* member, + void LoadMember_TypeCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { @@ -688,16 +690,13 @@ namespace break; default: - LINE("// t=" << static_cast(loadType)) + LINEF("// t={0}", static_cast(loadType)) break; } } } - static bool LoadMember_ShouldMakeAlloc(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - const MemberLoadType loadType) + static bool LoadMember_ShouldMakeAlloc(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::POINTER_ARRAY && loadType != MemberLoadType::SINGLE_POINTER) { @@ -722,12 +721,12 @@ namespace return true; } - void LoadMember_Alloc(StructureInformation* info, - MemberInformation* member, + void LoadMember_Alloc(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { - if (!LoadMember_ShouldMakeAlloc(info, member, modifier, loadType)) + if (!LoadMember_ShouldMakeAlloc(member, modifier, loadType)) { LoadMember_TypeCheck(info, member, modifier, loadType); return; @@ -736,7 +735,7 @@ namespace const MemberComputations computations(member); if (computations.IsInTempBlock()) { - LINE(member->m_member->m_type_declaration->m_type->GetFullName() << "* ptr = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0}* ptr = {1};", member->m_member->m_type_declaration->m_type->GetFullName(), MakeMemberAccess(info, member, modifier)) } const auto typeDecl = MakeTypeDecl(member->m_member->m_type_declaration.get()); @@ -748,22 +747,24 @@ namespace // allocating. This is more reliable when being used with different compilers and the value used can be seen in the source code directly if (member->m_alloc_alignment) { - LINE(MakeMemberAccess(info, member, modifier) - << " = m_stream->Alloc<" << typeDecl << followingReferences << ">(" << MakeEvaluation(member->m_alloc_alignment.get()) << ");") + LINEF("{0} = m_stream->Alloc<{1}{2}>({3});", + MakeMemberAccess(info, member, modifier), + typeDecl, + followingReferences, + MakeEvaluation(member->m_alloc_alignment.get())) } else { - LINE(MakeMemberAccess(info, member, modifier) - << " = m_stream->Alloc<" << typeDecl << followingReferences << ">(" << modifier.GetAlignment() << ");") + LINEF("{0} = m_stream->Alloc<{1}{2}>({3});", MakeMemberAccess(info, member, modifier), typeDecl, followingReferences, modifier.GetAlignment()) } if (computations.IsInTempBlock()) { LINE("") - LINE(member->m_member->m_type_declaration->m_type->GetFullName() << "** toInsert = nullptr;") - LINE("if(ptr == PTR_INSERT)") + LINEF("{0}** toInsert = nullptr;", member->m_member->m_type_declaration->m_type->GetFullName()) + LINE("if (ptr == PTR_INSERT)") m_intendation++; - LINE("toInsert = m_stream->InsertPointer<" << member->m_member->m_type_declaration->m_type->GetFullName() << ">();") + LINEF("toInsert = m_stream->InsertPointer<{0}>();", member->m_member->m_type_declaration->m_type->GetFullName()) m_intendation--; LINE("") } @@ -773,17 +774,14 @@ namespace if (computations.IsInTempBlock()) { LINE("") - LINE("if(toInsert != nullptr)") + LINE("if (toInsert != nullptr)") m_intendation++; - LINE("*toInsert = " << MakeTypeVarName(info->m_definition) << "->" << member->m_member->m_name << ";") + LINEF("*toInsert = {0}->{1};", MakeTypeVarName(info->m_definition), member->m_member->m_name) m_intendation--; } } - static bool LoadMember_ShouldMakeReuse(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - const MemberLoadType loadType) + static bool LoadMember_ShouldMakeReuse(const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::SINGLE_POINTER && loadType != MemberLoadType::POINTER_ARRAY) { @@ -798,12 +796,12 @@ namespace return true; } - void LoadMember_Reuse(StructureInformation* info, - MemberInformation* member, + void LoadMember_Reuse(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { - if (!LoadMember_ShouldMakeReuse(info, member, modifier, loadType) || !member->m_is_reusable) + if (!LoadMember_ShouldMakeReuse(modifier, loadType) || !member->m_is_reusable) { LoadMember_Alloc(info, member, modifier, loadType); return; @@ -812,8 +810,7 @@ namespace const MemberComputations computations(member); if (computations.IsInTempBlock()) { - LINE("if(" << MakeMemberAccess(info, member, modifier) << " == PTR_FOLLOWING || " << MakeMemberAccess(info, member, modifier) - << " == PTR_INSERT)") + LINEF("if ({0} == PTR_FOLLOWING || {0} == PTR_INSERT)", MakeMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -825,14 +822,14 @@ namespace LINE("{") m_intendation++; - LINE(MakeMemberAccess(info, member, modifier) << " = m_stream->ConvertOffsetToAlias(" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("{0} = m_stream->ConvertOffsetToAlias({0});", MakeMemberAccess(info, member, modifier)) m_intendation--; LINE("}") } else { - LINE("if(" << MakeMemberAccess(info, member, modifier) << " == PTR_FOLLOWING)") + LINEF("if ({0} == PTR_FOLLOWING)", MakeMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -844,44 +841,36 @@ namespace LINE("{") m_intendation++; - LINE(MakeMemberAccess(info, member, modifier) << " = m_stream->ConvertOffsetToPointer(" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("{0} = m_stream->ConvertOffsetToPointer({0});", MakeMemberAccess(info, member, modifier)) m_intendation--; LINE("}") } } - static bool LoadMember_ShouldMakePointerCheck(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - MemberLoadType loadType) + static bool + LoadMember_ShouldMakePointerCheck(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::POINTER_ARRAY && loadType != MemberLoadType::SINGLE_POINTER) - { return false; - } if (loadType == MemberLoadType::POINTER_ARRAY) - { return !modifier.IsArray(); - } if (member->m_is_string) - { return false; - } return true; } - void LoadMember_PointerCheck(StructureInformation* info, - MemberInformation* member, + void LoadMember_PointerCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { - if (LoadMember_ShouldMakePointerCheck(info, member, modifier, loadType)) + if (LoadMember_ShouldMakePointerCheck(member, modifier, loadType)) { - LINE("if (" << MakeMemberAccess(info, member, modifier) << ")") + LINEF("if ({0})", MakeMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -896,14 +885,17 @@ namespace } } - void LoadMember_Block(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier, MemberLoadType loadType) + void LoadMember_Block(const StructureInformation* info, + const MemberInformation* member, + const DeclarationModifierComputations& modifier, + const MemberLoadType loadType) { const MemberComputations computations(member); const auto notInDefaultNormalBlock = computations.IsNotInDefaultNormalBlock(); if (notInDefaultNormalBlock) { - LINE("m_stream->PushBlock(" << member->m_fast_file_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", member->m_fast_file_block->m_name) } LoadMember_PointerCheck(info, member, modifier, loadType); @@ -965,7 +957,7 @@ namespace else { assert(false); - LINE("#error LoadMemberReference failed @ " << member->m_member->m_name) + LINEF("#error LoadMemberReference failed @ {0}", member->m_member->m_name) } } @@ -974,7 +966,7 @@ namespace LINE("") if (member->m_condition) { - LINE("if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -998,7 +990,7 @@ namespace LINE("") if (member->m_condition) { - LINE("if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -1016,7 +1008,7 @@ namespace { if (member->m_condition) { - LINE("else if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -1041,7 +1033,7 @@ namespace { if (member->m_condition) { - LINE("else if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -1052,7 +1044,7 @@ namespace } else { - LINE("#error Middle member of union must have condition (" << member->m_member->m_name << ")") + LINEF("#error Middle member of union must have condition ({0})", member->m_member->m_name) } } } @@ -1076,28 +1068,32 @@ namespace void PrintLoadMethod(StructureInformation* info) { const StructureComputations computations(info); - LINE("void " << LoaderClassName(m_env.m_asset) << "::Load_" << info->m_definition->m_name << "(const bool atStreamStart)") + LINEF("void {0}::Load_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), info->m_definition->m_name) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(info->m_definition)) - auto* dynamicMember = computations.GetDynamicMember(); + const auto* dynamicMember = computations.GetDynamicMember(); if (!(info->m_definition->GetType() == DataDefinitionType::UNION && dynamicMember)) { LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; if (dynamicMember == nullptr) { - LINE("m_stream->Load<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) - << "); // Size: " << info->m_definition->GetSize()) + LINEF("m_stream->Load<{0}>({1}); // Size: {2}", + info->m_definition->GetFullName(), + MakeTypeVarName(info->m_definition), + info->m_definition->GetSize()) } else { - LINE("m_stream->LoadPartial<" << info->m_definition->GetFullName() << ">(" << MakeTypeVarName(info->m_definition) << ", offsetof(" - << info->m_definition->GetFullName() << ", " << dynamicMember->m_member->m_name << "));") + LINEF("m_stream->LoadPartial<{0}>({1}, offsetof({0}, {2}));", + info->m_definition->GetFullName(), + MakeTypeVarName(info->m_definition), + dynamicMember->m_member->m_name) } m_intendation--; @@ -1110,12 +1106,12 @@ namespace if (computations.IsAsset()) { LINE("") - LINE("m_stream->PushBlock(" << m_env.m_default_normal_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", m_env.m_default_normal_block->m_name) } else if (info->m_block) { LINE("") - LINE("m_stream->PushBlock(" << info->m_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", info->m_block->m_name) } for (const auto& member : info->m_ordered_members) @@ -1136,55 +1132,56 @@ namespace void PrintLoadPtrMethod(StructureInformation* info) { const bool inTemp = info->m_block && info->m_block->m_type == FastFileBlockType::TEMP; - LINE("void " << LoaderClassName(m_env.m_asset) << "::LoadPtr_" << MakeSafeTypeName(info->m_definition) << "(const bool atStreamStart)") + LINEF("void {0}::LoadPtr_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(info->m_definition)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypePtrVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypePtrVarName(info->m_definition)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE("m_stream->Load<" << info->m_definition->GetFullName() << "*>(" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("m_stream->Load<{0}*>({1});", info->m_definition->GetFullName(), MakeTypePtrVarName(info->m_definition)) m_intendation--; LINE("") if (inTemp) { - LINE("m_stream->PushBlock(" << m_env.m_default_temp_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", m_env.m_default_temp_block->m_name) LINE("") } - LINE("if(*" << MakeTypePtrVarName(info->m_definition) << " != nullptr)") + LINEF("if (*{0} != nullptr)", MakeTypePtrVarName(info->m_definition)) LINE("{") m_intendation++; if (inTemp) { - LINE("if(*" << MakeTypePtrVarName(info->m_definition) << " == PTR_FOLLOWING || *" << MakeTypePtrVarName(info->m_definition) - << " == PTR_INSERT)") + LINEF("if (*{0} == PTR_FOLLOWING || *{0} == PTR_INSERT)", MakeTypePtrVarName(info->m_definition)) } else { - LINE("if(*" << MakeTypePtrVarName(info->m_definition) << " == PTR_FOLLOWING)") + LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(info->m_definition)) } LINE("{") m_intendation++; if (inTemp) { - LINE(info->m_definition->GetFullName() << "* ptr = *" << MakeTypePtrVarName(info->m_definition) << ";") + LINEF("{0}* ptr = *{1};", info->m_definition->GetFullName(), MakeTypePtrVarName(info->m_definition)) } - LINE("*" << MakeTypePtrVarName(info->m_definition) << " = m_stream->Alloc<" << info->m_definition->GetFullName() << ">(" - << info->m_definition->GetAlignment() << ");") + LINEF("*{0} = m_stream->Alloc<{1}>({2});", + MakeTypePtrVarName(info->m_definition), + info->m_definition->GetFullName(), + info->m_definition->GetAlignment()) if (inTemp) { LINE("") - LINE(info->m_definition->GetFullName() << "** toInsert = nullptr;") - LINE("if(ptr == PTR_INSERT)") + LINEF("{0}** toInsert = nullptr;", info->m_definition->GetFullName()) + LINE("if (ptr == PTR_INSERT)") m_intendation++; - LINE("toInsert = m_stream->InsertPointer<" << info->m_definition->GetFullName() << ">();") + LINEF("toInsert = m_stream->InsertPointer<{0}>();", info->m_definition->GetFullName()) m_intendation--; } @@ -1197,8 +1194,8 @@ namespace startLoadSection = false; LINE("") } - LINE(MakeTypeVarName(info->m_definition) << " = *" << MakeTypePtrVarName(info->m_definition) << ";") - LINE("Load_" << MakeSafeTypeName(info->m_definition) << "(true);") + LINEF("{0} = *{1};", MakeTypeVarName(info->m_definition), MakeTypePtrVarName(info->m_definition)) + LINEF("Load_{0}(true);", MakeSafeTypeName(info->m_definition)) } else { @@ -1214,7 +1211,7 @@ namespace if (StructureComputations(info).IsAsset()) { LINE("") - LINE("LoadAsset_" << MakeSafeTypeName(info->m_definition) << "(" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("LoadAsset_{0}({1});", MakeSafeTypeName(info->m_definition), MakeTypePtrVarName(info->m_definition)) } if (inTemp) @@ -1224,9 +1221,9 @@ namespace LINE("") } - LINE("if(toInsert != nullptr)") + LINE("if (toInsert != nullptr)") m_intendation++; - LINE("*toInsert = *" << MakeTypePtrVarName(info->m_definition) << ";") + LINEF("*toInsert = *{0};", MakeTypePtrVarName(info->m_definition)) m_intendation--; } @@ -1238,11 +1235,11 @@ namespace if (inTemp) { - LINE("*" << MakeTypePtrVarName(info->m_definition) << " = m_stream->ConvertOffsetToAlias(*" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("*{0} = m_stream->ConvertOffsetToAlias(*{0});", MakeTypePtrVarName(info->m_definition)) } else { - LINE("*" << MakeTypePtrVarName(info->m_definition) << " = m_stream->ConvertOffsetToPointer(*" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("*{0} = m_stream->ConvertOffsetToPointer(*{0});", MakeTypePtrVarName(info->m_definition)) } m_intendation--; @@ -1261,24 +1258,26 @@ namespace LINE("}") } - void PrintLoadAssetMethod(StructureInformation* info) + void PrintLoadAssetMethod(const StructureInformation* info) { - LINE("void " << LoaderClassName(m_env.m_asset) << "::LoadAsset_" << MakeSafeTypeName(info->m_definition) << "(" << info->m_definition->GetFullName() - << "** pAsset)") + LINEF("void {0}::LoadAsset_{1}({2}** pAsset)", + LoaderClassName(m_env.m_asset), + MakeSafeTypeName(info->m_definition), + info->m_definition->GetFullName()) LINE("{") m_intendation++; LINE("assert(pAsset != nullptr);") LINE("") - LINE(MarkerClassName(m_env.m_asset) << " marker(m_zone);") + LINEF("{0} marker(m_zone);", MarkerClassName(m_env.m_asset)) LINE("marker.Mark(*pAsset);") LINE("") - LINE("auto* reallocatedAsset = m_zone->GetMemory()->Alloc<" << info->m_definition->GetFullName() << ">();") - LINE("std::memcpy(reallocatedAsset, *pAsset, sizeof(" << info->m_definition->GetFullName() << "));") + LINEF("auto* reallocatedAsset = m_zone->GetMemory()->Alloc<{0}>();", info->m_definition->GetFullName()) + LINEF("std::memcpy(reallocatedAsset, *pAsset, sizeof({0}));", info->m_definition->GetFullName()) LINE("") - LINE("m_asset_info = reinterpret_castm_definition->GetFullName() - << ">*>(LinkAsset(GetAssetName(*pAsset), reallocatedAsset, marker.GetDependencies(), " - "marker.GetUsedScriptStrings(), marker.GetIndirectAssetReferences()));") + LINEF("m_asset_info = reinterpret_cast*>(LinkAsset(GetAssetName(*pAsset), reallocatedAsset, marker.GetDependencies(), " + "marker.GetUsedScriptStrings(), marker.GetIndirectAssetReferences()));", + info->m_definition->GetFullName()) LINE("*pAsset = m_asset_info->Asset();") m_intendation--; @@ -1287,8 +1286,7 @@ namespace void PrintMainLoadMethod() { - LINE("XAssetInfo<" << m_env.m_asset->m_definition->GetFullName() << ">* " << LoaderClassName(m_env.m_asset) << "::Load(" - << m_env.m_asset->m_definition->GetFullName() << "** pAsset)") + LINEF("XAssetInfo<{0}>* {1}::Load({0}** pAsset)", m_env.m_asset->m_definition->GetFullName(), LoaderClassName(m_env.m_asset)) LINE("{") m_intendation++; @@ -1296,12 +1294,12 @@ namespace LINE("") LINE("m_asset_info = nullptr;") LINE("") - LINE(MakeTypePtrVarName(m_env.m_asset->m_definition) << " = pAsset;") - LINE("LoadPtr_" << MakeSafeTypeName(m_env.m_asset->m_definition) << "(false);") + LINEF("{0} = pAsset;", MakeTypePtrVarName(m_env.m_asset->m_definition)) + LINEF("LoadPtr_{0}(false);", MakeSafeTypeName(m_env.m_asset->m_definition)) LINE("") - LINE("if(m_asset_info == nullptr && *pAsset != nullptr)") + LINE("if (m_asset_info == nullptr && *pAsset != nullptr)") m_intendation++; - LINE("m_asset_info = reinterpret_castm_definition->GetFullName() << ">*>(GetAssetInfo(GetAssetName(*pAsset)));") + LINEF("m_asset_info = reinterpret_cast*>(GetAssetInfo(GetAssetName(*pAsset)));", m_env.m_asset->m_definition->GetFullName()) m_intendation--; LINE("") LINE("return m_asset_info;") @@ -1312,7 +1310,7 @@ namespace void PrintGetNameMethod() { - LINE("std::string " << LoaderClassName(m_env.m_asset) << "::GetAssetName(" << m_env.m_asset->m_definition->GetFullName() << "* pAsset)") + LINEF("std::string {0}::GetAssetName({1}* pAsset)", LoaderClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) LINE("{") m_intendation++; @@ -1321,23 +1319,23 @@ namespace LINE_START("return pAsset") auto first = true; - for (auto* member : m_env.m_asset->m_name_chain) + for (const auto* member : m_env.m_asset->m_name_chain) { if (first) { first = false; - LINE_MIDDLE("->" << member->m_member->m_name) + LINE_MIDDLEF("->{0}", member->m_member->m_name) } else { - LINE_MIDDLE("." << member->m_member->m_name) + LINE_MIDDLEF(".{0}", member->m_member->m_name) } } LINE_END(";") } else { - LINE("return \"" << m_env.m_asset->m_definition->m_name << "\";") + LINEF("return \"{0}\";", m_env.m_asset->m_definition->m_name) } m_intendation--; @@ -1354,17 +1352,8 @@ std::vector ZoneLoadTemplate::GetFilesToRender(RenderingContex for (auto& c : assetName) c = static_cast(tolower(c)); - { - std::ostringstream str; - str << assetName << '/' << assetName << "_load_db.h"; - files.emplace_back(str.str(), TAG_HEADER); - } - - { - std::ostringstream str; - str << assetName << '/' << assetName << "_load_db.cpp"; - files.emplace_back(str.str(), TAG_SOURCE); - } + files.emplace_back(std::format("{0}/{0}_load_db.h", assetName), TAG_HEADER); + files.emplace_back(std::format("{0}/{0}_load_db.cpp", assetName), TAG_SOURCE); return files; } diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp index e6d60d0d..688c44ee 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp @@ -11,8 +11,8 @@ namespace { - static constexpr int TAG_HEADER = 1; - static constexpr int TAG_SOURCE = 2; + constexpr int TAG_HEADER = 1; + constexpr int TAG_SOURCE = 2; class Template final : BaseTemplate { @@ -26,20 +26,21 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") LINE("#pragma once") LINE("") LINE("#include \"Loading/AssetMarker.h\"") - LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"") + LINEF("#include \"Game/{0}/{0}.h\"", m_env.m_game) + LINE("") LINE("#include ") LINE("") - LINE("namespace " << m_env.m_game) + LINEF("namespace {0}", m_env.m_game) LINE("{") m_intendation++; - LINE("class " << MarkerClassName(m_env.m_asset) << " final : public AssetMarker") + LINEF("class {0} final : public AssetMarker", MarkerClassName(m_env.m_asset)) LINE("{") m_intendation++; @@ -52,14 +53,14 @@ namespace m_intendation++; // Variable Declarations: type varType; - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { 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)) } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists && !type->m_is_context_asset) { @@ -70,14 +71,14 @@ namespace LINE("") // Method Declarations - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists && type->m_info->m_requires_marking) { PrintHeaderPtrArrayMarkMethodDeclaration(type->m_type); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_array_reference_exists && type->m_info && !type->m_info->m_is_leaf && type->m_info->m_requires_marking && type->m_non_runtime_reference_exists) @@ -111,11 +112,12 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") - LINE("#include \"" << Lower(m_env.m_asset->m_definition->m_name) << "_mark_db.h\"") + LINEF("#include \"{0}_mark_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) + LINE("") LINE("#include ") LINE("") @@ -124,11 +126,11 @@ namespace LINE("// Referenced Assets:") for (const auto* type : m_env.m_referenced_assets) { - LINE("#include \"../" << Lower(type->m_type->m_name) << "/" << Lower(type->m_type->m_name) << "_mark_db.h\"") + LINEF("#include \"../{0}/{0}_mark_db.h\"", Lower(type->m_type->m_name)) } LINE("") } - LINE("using namespace " << m_env.m_game << ";") + LINEF("using namespace {0};", m_env.m_game) LINE("") PrintConstructorMethod(); @@ -168,7 +170,7 @@ namespace } private: - enum class MemberLoadType + enum class MemberLoadType : std::uint8_t { ARRAY_POINTER, DYNAMIC_ARRAY, @@ -178,78 +180,72 @@ namespace SINGLE_POINTER }; - static std::string MarkerClassName(StructureInformation* asset) + static std::string MarkerClassName(const StructureInformation* asset) { - std::ostringstream str; - str << "Marker_" << asset->m_definition->m_name; - return str.str(); + return std::format("Marker_{0}", asset->m_definition->m_name); } static std::string VariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "* var" << MakeSafeTypeName(def) << ";"; - return str.str(); + return std::format("{0}* var{1};", def->GetFullName(), MakeSafeTypeName(def)); } static std::string PointerVariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "** var" << MakeSafeTypeName(def) << "Ptr;"; - return str.str(); + return std::format("{0}** var{1}Ptr;", def->GetFullName(), MakeSafeTypeName(def)); } void PrintHeaderPtrArrayMarkMethodDeclaration(const DataDefinition* def) const { - LINE("void MarkPtrArray_" << MakeSafeTypeName(def) << "(size_t count);") + LINEF("void MarkPtrArray_{0}(size_t count);", MakeSafeTypeName(def)) } void PrintHeaderArrayMarkMethodDeclaration(const DataDefinition* def) const { - LINE("void MarkArray_" << MakeSafeTypeName(def) << "(size_t count);") + LINEF("void MarkArray_{0}(size_t count);", MakeSafeTypeName(def)) } void PrintHeaderMarkMethodDeclaration(const StructureInformation* info) const { - LINE("void Mark_" << MakeSafeTypeName(info->m_definition) << "();") + LINEF("void Mark_{0}();", MakeSafeTypeName(info->m_definition)) } void PrintHeaderGetAssetInfoMethodDeclaration(const StructureInformation* info) const { - LINE("XAssetInfo<" << info->m_definition->GetFullName() << ">* GetAssetInfo(" << info->m_definition->GetFullName() << "* pAsset) const;") + LINEF("XAssetInfo<{0}>* GetAssetInfo({0}* pAsset) const;", info->m_definition->GetFullName()) } void PrintHeaderGetNameMethodDeclaration(const StructureInformation* info) const { - LINE("static std::string GetAssetName(" << info->m_definition->GetFullName() << "* pAsset);") + LINEF("static std::string GetAssetName({0}* pAsset);", info->m_definition->GetFullName()) } void PrintHeaderConstructor() const { - LINE(MarkerClassName(m_env.m_asset) << "(Zone* zone);") + LINEF("{0}(Zone* zone);", MarkerClassName(m_env.m_asset)) } void PrintHeaderMainMarkMethodDeclaration(const StructureInformation* info) const { - LINE("void Mark(" << info->m_definition->GetFullName() << "* pAsset);") + LINEF("void Mark({0}* pAsset);", info->m_definition->GetFullName()) } void PrintVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << " = nullptr;") + LINEF("var{0} = nullptr;", def->m_name) } void PrintPointerVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << "Ptr = nullptr;") + LINEF("var{0}Ptr = nullptr;", def->m_name) } void PrintConstructorMethod() { - LINE(MarkerClassName(m_env.m_asset) << "::" << MarkerClassName(m_env.m_asset) << "(Zone* zone)") + LINEF("{0}::{0}(Zone* zone)", MarkerClassName(m_env.m_asset)) m_intendation++; - LINE(": AssetMarker(" << m_env.m_asset->m_asset_enum_entry->m_name << ", zone)") + LINEF(": AssetMarker({0}, zone)", m_env.m_asset->m_asset_enum_entry->m_name) m_intendation--; LINE("{") @@ -282,20 +278,20 @@ namespace { if (info && !info->m_is_leaf) { - LINE(MakeTypeVarName(info->m_definition) << " = *" << MakeTypePtrVarName(def) << ";") - LINE("Mark_" << MakeSafeTypeName(def) << "();") + LINEF("{0} = *{1};", MakeTypeVarName(info->m_definition), MakeTypePtrVarName(def)) + LINEF("Mark_{0}();", MakeSafeTypeName(def)) } } void PrintMarkPtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("if (*" << MakeTypePtrVarName(def) << ")") + LINEF("if (*{0})", MakeTypePtrVarName(def)) LINE("{") m_intendation++; if (info && StructureComputations(info).IsAsset()) { - LINE("AddDependency(" << MarkerClassName(info) << "(m_zone).GetAssetInfo(*" << MakeTypePtrVarName(def) << "));") + LINEF("AddDependency({0}(m_zone).GetAssetInfo(*{1}));", MarkerClassName(info), MakeTypePtrVarName(def)) } else { @@ -308,19 +304,19 @@ namespace void PrintMarkPtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("void " << MarkerClassName(m_env.m_asset) << "::MarkPtrArray_" << MakeSafeTypeName(def) << "(const size_t count)") + LINEF("void {0}::MarkPtrArray_{1}(const size_t count)", MarkerClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypePtrVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypePtrVarName(def)) LINE("") - LINE(def->GetFullName() << "** var = " << MakeTypePtrVarName(def) << ";") - LINE("for(size_t index = 0; index < count; index++)") + LINEF("{0}** var = {1};", def->GetFullName(), MakeTypePtrVarName(def)) + LINE("for (size_t index = 0; index < count; index++)") LINE("{") m_intendation++; - LINE(MakeTypePtrVarName(def) << " = var;") + LINEF("{0} = var;", MakeTypePtrVarName(def)) PrintMarkPtrArrayMethod_PointerCheck(def, info, reusable); LINE("") LINE("var++;") @@ -333,20 +329,20 @@ namespace void PrintMarkArrayMethod(const DataDefinition* def, const StructureInformation* info) { - LINE("void " << MarkerClassName(m_env.m_asset) << "::MarkArray_" << MakeSafeTypeName(def) << "(const size_t count)") + LINEF("void {0}::MarkArray_{1}(const size_t count)", MarkerClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(def)) LINE("") - LINE(def->GetFullName() << "* var = " << MakeTypeVarName(def) << ";") - LINE("for(size_t index = 0; index < count; index++)") + LINEF("{0}* var = {1};", def->GetFullName(), MakeTypeVarName(def)) + LINE("for (size_t index = 0; index < count; index++)") LINE("{") m_intendation++; - LINE(MakeTypeVarName(info->m_definition) << " = var;") - LINE("Mark_" << info->m_definition->m_name << "();") + LINEF("{0} = var;", MakeTypeVarName(info->m_definition)) + LINEF("Mark_{0}();", info->m_definition->m_name) LINE("var++;") m_intendation--; @@ -356,34 +352,34 @@ namespace LINE("}") } - void MarkMember_ScriptString(StructureInformation* info, - MemberInformation* member, + void MarkMember_ScriptString(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { if (loadType == MemberLoadType::ARRAY_POINTER) { - LINE("MarkArray_ScriptString(" << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) - << ");") + LINEF("MarkArray_ScriptString({0}, {1});", MakeMemberAccess(info, member, modifier), MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } else if (loadType == MemberLoadType::EMBEDDED_ARRAY) { - LINE("MarkArray_ScriptString(" << MakeMemberAccess(info, member, modifier) << ", " - << MakeArrayCount(dynamic_cast(modifier.GetDeclarationModifier())) << ");") + LINEF("MarkArray_ScriptString({0}, {1});", + MakeMemberAccess(info, member, modifier), + MakeArrayCount(dynamic_cast(modifier.GetDeclarationModifier()))) } else if (loadType == MemberLoadType::EMBEDDED) { - LINE("Mark_ScriptString(" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("Mark_ScriptString({0});", MakeMemberAccess(info, member, modifier)) } else { assert(false); - LINE("#error unsupported loadType " << static_cast(loadType) << " for scriptstring") + LINEF("#error unsupported loadType {0} for script string", static_cast(loadType)) } } - void MarkMember_AssetRef(StructureInformation* info, - MemberInformation* member, + void MarkMember_AssetRef(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { @@ -391,34 +387,38 @@ namespace { if (modifier.IsArray()) { - LINE("MarkArray_IndirectAssetRef(" << member->m_asset_ref->m_name << ", " << MakeMemberAccess(info, member, modifier) << ", " - << modifier.GetArraySize() << ");") + LINEF("MarkArray_IndirectAssetRef({0}, {1}, {2});", + member->m_asset_ref->m_name, + MakeMemberAccess(info, member, modifier), + modifier.GetArraySize()) } else { - LINE("MarkArray_IndirectAssetRef(" << member->m_asset_ref->m_name << ", " << MakeMemberAccess(info, member, modifier) << ", " - << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("MarkArray_IndirectAssetRef({0}, {1}, {2});", + member->m_asset_ref->m_name, + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } else if (loadType == MemberLoadType::SINGLE_POINTER) { - LINE("Mark_IndirectAssetRef(" << member->m_asset_ref->m_name << ", " << MakeMemberAccess(info, member, modifier) << ");") + LINEF("Mark_IndirectAssetRef({0}, {1});", member->m_asset_ref->m_name, MakeMemberAccess(info, member, modifier)) } else { assert(false); - LINE("#error unsupported loadType " << static_cast(loadType) << " for scriptstring") + LINEF("#error unsupported loadType {0} for script string", static_cast(loadType)) } } - void MarkMember_Asset(StructureInformation* info, - MemberInformation* member, + void MarkMember_Asset(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { if (loadType == MemberLoadType::SINGLE_POINTER) { - LINE("AddDependency(" << MarkerClassName(member->m_type) << "(m_zone).GetAssetInfo(" << MakeMemberAccess(info, member, modifier) << "));") + LINEF("AddDependency({0}(m_zone).GetAssetInfo({1}));", MarkerClassName(member->m_type), MakeMemberAccess(info, member, modifier)) } else if (loadType == MemberLoadType::POINTER_ARRAY) { @@ -427,34 +427,35 @@ namespace else { assert(false); - LINE("#error unsupported loadType " << static_cast(loadType) << " for asset") + LINEF("#error unsupported loadType {0} for asset", static_cast(loadType)) } } - void MarkMember_ArrayPointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_ArrayPointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("MarkArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(" - << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("MarkArray_{0}({1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } - void MarkMember_PointerArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_PointerArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypePtrVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0} = {1};", MakeTypePtrVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) if (modifier.IsArray()) { - LINE("MarkPtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(" << modifier.GetArraySize() << ");") + LINEF("MarkPtrArray_{0}({1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), modifier.GetArraySize()) } else { - LINE("MarkPtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(" - << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("MarkPtrArray_{0}({1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } - void MarkMember_EmbeddedArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_EmbeddedArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - const MemberComputations computations(member); std::string arraySizeStr; if (modifier.HasDynamicArrayCount()) @@ -462,31 +463,31 @@ namespace else arraySizeStr = std::to_string(modifier.GetArraySize()); - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("MarkArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(" << arraySizeStr << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("MarkArray_{0}({1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), arraySizeStr) } - void MarkMember_DynamicArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_DynamicArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("MarkArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(" - << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF( + "MarkArray_{0}({1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), MakeEvaluation(modifier.GetDynamicArraySizeEvaluation())) } - void MarkMember_Embedded(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_Embedded(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = &" << MakeMemberAccess(info, member, modifier) << ";") - LINE("Mark_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "();") + LINEF("{0} = &{1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Mark_{0}();", MakeSafeTypeName(member->m_member->m_type_declaration->m_type)) } - void MarkMember_SinglePointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void MarkMember_SinglePointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("Mark_" << MakeSafeTypeName(member->m_type->m_definition) << "();") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Mark_{0}();", MakeSafeTypeName(member->m_type->m_definition)) } - void MarkMember_TypeCheck(StructureInformation* info, - MemberInformation* member, + void MarkMember_TypeCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) const { @@ -531,16 +532,13 @@ namespace break; default: - LINE("// t=" << static_cast(loadType)) + LINEF("// t={0}", static_cast(loadType)) break; } } } - static bool MarkMember_ShouldMakePointerCheck(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - MemberLoadType loadType) + static bool MarkMember_ShouldMakePointerCheck(const MemberInformation* member, const DeclarationModifierComputations& modifier, MemberLoadType loadType) { if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::POINTER_ARRAY && loadType != MemberLoadType::SINGLE_POINTER) { @@ -560,14 +558,14 @@ namespace return true; } - void MarkMember_PointerCheck(StructureInformation* info, - MemberInformation* member, + void MarkMember_PointerCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType) { - if (MarkMember_ShouldMakePointerCheck(info, member, modifier, loadType)) + if (MarkMember_ShouldMakePointerCheck(member, modifier, loadType)) { - LINE("if (" << MakeMemberAccess(info, member, modifier) << ")") + LINEF("if ({0})", MakeMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -582,7 +580,7 @@ namespace } } - void MarkMember_ReferenceArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) + void MarkMember_ReferenceArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { auto first = true; for (const auto& entry : modifier.GetArrayEntries()) @@ -600,7 +598,7 @@ namespace } } - void MarkMember_Reference(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) + void MarkMember_Reference(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { if (modifier.IsDynamicArray()) { @@ -633,16 +631,16 @@ namespace else { assert(false); - LINE("#error MarkMemberReference failed @ " << member->m_member->m_name) + LINEF("#error MarkMemberReference failed @ {0}", member->m_member->m_name) } } - void MarkMember_Condition_Struct(StructureInformation* info, MemberInformation* member) + void MarkMember_Condition_Struct(const StructureInformation* info, const MemberInformation* member) { LINE("") if (member->m_condition) { - LINE("if (" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -657,7 +655,7 @@ namespace } } - void MarkMember_Condition_Union(StructureInformation* info, MemberInformation* member) + void MarkMember_Condition_Union(const StructureInformation* info, const MemberInformation* member) { const MemberComputations computations(member); @@ -666,7 +664,7 @@ namespace LINE("") if (member->m_condition) { - LINE("if (" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -684,7 +682,7 @@ namespace { if (member->m_condition) { - LINE("else if (" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -709,7 +707,7 @@ namespace { if (member->m_condition) { - LINE("else if (" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -720,12 +718,12 @@ namespace } else { - LINE("#error Middle member of union must have condition (" << member->m_member->m_name << ")") + LINEF("#error Middle member of union must have condition ({0})", member->m_member->m_name) } } } - void PrintMarkMemberIfNeedsTreatment(StructureInformation* info, MemberInformation* member) + void PrintMarkMemberIfNeedsTreatment(const StructureInformation* info, const MemberInformation* member) { const MemberComputations computations(member); if (computations.ShouldIgnore() || computations.IsInRuntimeBlock()) @@ -741,14 +739,13 @@ namespace } } - void PrintMarkMethod(StructureInformation* info) + void PrintMarkMethod(const StructureInformation* info) { - const StructureComputations computations(info); - LINE("void " << MarkerClassName(m_env.m_asset) << "::Mark_" << info->m_definition->m_name << "()") + LINEF("void {0}::Mark_{1}()", MarkerClassName(m_env.m_asset), info->m_definition->m_name) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(info->m_definition)) for (const auto& member : info->m_ordered_members) { @@ -761,7 +758,7 @@ namespace void PrintGetNameMethod() { - LINE("std::string " << MarkerClassName(m_env.m_asset) << "::GetAssetName(" << m_env.m_asset->m_definition->GetFullName() << "* pAsset)") + LINEF("std::string {0}::GetAssetName({1}* pAsset)", MarkerClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) LINE("{") m_intendation++; @@ -775,18 +772,18 @@ namespace if (first) { first = false; - LINE_MIDDLE("->" << member->m_member->m_name) + LINE_MIDDLEF("->{0}", member->m_member->m_name) } else { - LINE_MIDDLE("." << member->m_member->m_name) + LINE_MIDDLEF(".{0}", member->m_member->m_name) } } LINE_END(";") } else { - LINE("return \"" << m_env.m_asset->m_definition->m_name << "\";") + LINEF("return \"{0}\";", m_env.m_asset->m_definition->m_name) } m_intendation--; @@ -795,12 +792,11 @@ namespace void PrintGetAssetInfoMethod() { - LINE("XAssetInfo<" << m_env.m_asset->m_definition->GetFullName() << ">* " << MarkerClassName(m_env.m_asset) << "::GetAssetInfo(" - << m_env.m_asset->m_definition->GetFullName() << "* pAsset) const") + LINEF("XAssetInfo<{0}>* {1}::GetAssetInfo({0}* pAsset) const", m_env.m_asset->m_definition->GetFullName(), MarkerClassName(m_env.m_asset)) LINE("{") m_intendation++; - LINE("return reinterpret_castm_definition->GetFullName() << ">*>(GetAssetInfoByName(GetAssetName(pAsset)));") + LINEF("return reinterpret_cast*>(GetAssetInfoByName(GetAssetName(pAsset)));", m_env.m_asset->m_definition->GetFullName()) m_intendation--; LINE("}") @@ -808,14 +804,14 @@ namespace void PrintMainMarkMethod() { - LINE("void " << MarkerClassName(m_env.m_asset) << "::Mark(" << m_env.m_asset->m_definition->GetFullName() << "* pAsset)") + LINEF("void {0}::Mark({1}* pAsset)", MarkerClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) LINE("{") m_intendation++; LINE("assert(pAsset != nullptr);") LINE("") - LINE(MakeTypeVarName(m_env.m_asset->m_definition) << " = pAsset;") - LINE("Mark_" << MakeSafeTypeName(m_env.m_asset->m_definition) << "();") + LINEF("{0} = pAsset;", MakeTypeVarName(m_env.m_asset->m_definition)) + LINEF("Mark_{0}();", MakeSafeTypeName(m_env.m_asset->m_definition)) m_intendation--; LINE("}") @@ -830,17 +826,8 @@ std::vector ZoneMarkTemplate::GetFilesToRender(RenderingContex auto assetName = context->m_asset->m_definition->m_name; utils::MakeStringLowerCase(assetName); - { - std::ostringstream str; - str << assetName << '/' << assetName << "_mark_db.h"; - files.emplace_back(str.str(), TAG_HEADER); - } - - { - std::ostringstream str; - str << assetName << '/' << assetName << "_mark_db.cpp"; - files.emplace_back(str.str(), TAG_SOURCE); - } + files.emplace_back(std::format("{0}/{0}_mark_db.h", assetName), TAG_HEADER); + files.emplace_back(std::format("{0}/{0}_mark_db.cpp", assetName), TAG_SOURCE); return files; } diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp index d0e7ec9f..0cc2a1cf 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp @@ -5,13 +5,12 @@ #include #include -#include #include namespace { - static constexpr int TAG_HEADER = 1; - static constexpr int TAG_SOURCE = 2; + constexpr int TAG_HEADER = 1; + constexpr int TAG_SOURCE = 2; class Template final : BaseTemplate { @@ -25,20 +24,20 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") LINE("#pragma once") LINE("") LINE("#include \"Writing/AssetWriter.h\"") - LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"") + LINEF("#include \"Game/{0}/{0}.h\"", m_env.m_game) LINE("#include ") LINE("") - LINE("namespace " << m_env.m_game) + LINEF("namespace {0}", m_env.m_game) LINE("{") m_intendation++; - LINE("class " << WriterClassName(m_env.m_asset) << " final : public AssetWriter") + LINEF("class {0} final : public AssetWriter", WriterClassName(m_env.m_asset)) LINE("{") m_intendation++; @@ -49,7 +48,7 @@ namespace LINE("") // Variable Declarations: type varType; - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_info && !type->m_info->m_definition->m_anonymous && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -57,7 +56,7 @@ namespace LINE(WrittenVariableDecl(type->m_type)) } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists && !type->m_is_context_asset) { @@ -69,21 +68,21 @@ namespace LINE("") // Method Declarations - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists) { PrintHeaderPtrArrayWriteMethodDeclaration(type->m_type); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_array_reference_exists && type->m_info && !type->m_info->m_is_leaf && type->m_non_runtime_reference_exists) { PrintHeaderArrayWriteMethodDeclaration(type->m_type); } } - for (auto* type : m_env.m_used_structures) + for (const auto* type : m_env.m_used_structures) { if (type->m_non_runtime_reference_exists && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -110,28 +109,28 @@ namespace { LINE("// ====================================================================") LINE("// This file has been generated by ZoneCodeGenerator.") - LINE("// Do not modify. ") + LINE("// Do not modify.") LINE("// Any changes will be discarded when regenerating.") LINE("// ====================================================================") LINE("") - LINE("#include \"" << Lower(m_env.m_asset->m_definition->m_name) << "_write_db.h\"") + LINEF("#include \"{0}_write_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) LINE("#include ") LINE("") if (!m_env.m_referenced_assets.empty()) { LINE("// Referenced Assets:") - for (auto* type : m_env.m_referenced_assets) + for (const auto* type : m_env.m_referenced_assets) { - LINE("#include \"../" << Lower(type->m_type->m_name) << "/" << Lower(type->m_type->m_name) << "_write_db.h\"") + LINEF("#include \"../{0}/{0}_write_db.h\"", Lower(type->m_type->m_name)) } LINE("") } - LINE("using namespace " << m_env.m_game << ";") + LINEF("using namespace {0};", m_env.m_game) LINE("") PrintConstructorMethod(); - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_pointer_array_reference_exists) { @@ -139,7 +138,7 @@ namespace PrintWritePtrArrayMethod(type->m_type, type->m_info, type->m_pointer_array_reference_is_reusable); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_array_reference_exists && type->m_info && !type->m_info->m_is_leaf && type->m_non_runtime_reference_exists) { @@ -147,7 +146,7 @@ namespace PrintWriteArrayMethod(type->m_type, type->m_info); } } - for (auto* type : m_env.m_used_structures) + for (const auto* type : m_env.m_used_structures) { if (type->m_non_runtime_reference_exists && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -176,106 +175,93 @@ namespace SINGLE_POINTER }; - static std::string WriterClassName(StructureInformation* asset) + static std::string WriterClassName(const StructureInformation* asset) { - std::ostringstream str; - str << "Writer_" << asset->m_definition->m_name; - return str.str(); + return std::format("Writer_{0}", asset->m_definition->m_name); } static std::string VariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "* var" << MakeSafeTypeName(def) << ";"; - return str.str(); + return std::format("{0}* var{1};", def->GetFullName(), MakeSafeTypeName(def)); } static std::string WrittenVariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "* var" << MakeSafeTypeName(def) << "Written;"; - return str.str(); + return std::format("{0}* var{1}Written;", def->GetFullName(), MakeSafeTypeName(def)); } static std::string PointerVariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "** var" << MakeSafeTypeName(def) << "Ptr;"; - return str.str(); + return std::format("{0}** var{1}Ptr;", def->GetFullName(), MakeSafeTypeName(def)); } static std::string WrittenPointerVariableDecl(const DataDefinition* def) { - std::ostringstream str; - str << def->GetFullName() << "** var" << MakeSafeTypeName(def) << "PtrWritten;"; - return str.str(); + return std::format("{0}** var{1}PtrWritten;", def->GetFullName(), MakeSafeTypeName(def)); } void PrintHeaderPtrArrayWriteMethodDeclaration(const DataDefinition* def) const { - LINE("void WritePtrArray_" << MakeSafeTypeName(def) << "(bool atStreamStart, size_t count);") + LINEF("void WritePtrArray_{0}(bool atStreamStart, size_t count);", MakeSafeTypeName(def)) } void PrintHeaderArrayWriteMethodDeclaration(const DataDefinition* def) const { - LINE("void WriteArray_" << MakeSafeTypeName(def) << "(bool atStreamStart, size_t count);") + LINEF("void WriteArray_{0}(bool atStreamStart, size_t count);", MakeSafeTypeName(def)) } void PrintHeaderWriteMethodDeclaration(const StructureInformation* info) const { - LINE("void Write_" << MakeSafeTypeName(info->m_definition) << "(bool atStreamStart);") + LINEF("void Write_{0}(bool atStreamStart);", MakeSafeTypeName(info->m_definition)) } void PrintHeaderTempPtrWriteMethodDeclaration(const StructureInformation* info) const { - LINE("void WritePtr_" << MakeSafeTypeName(info->m_definition) << "(bool atStreamStart);") + LINEF("void WritePtr_{0}(bool atStreamStart);", MakeSafeTypeName(info->m_definition)) } void PrintHeaderGetNameMethodDeclaration(const StructureInformation* info) const { - LINE("static std::string GetAssetName(" << info->m_definition->GetFullName() << "* pAsset);") + LINEF("static std::string GetAssetName({0}* pAsset);", info->m_definition->GetFullName()) } void PrintHeaderMainWriteMethodDeclaration(const StructureInformation* info) const { - LINE("void Write(" << info->m_definition->GetFullName() << "** pAsset);") + LINEF("void Write({0}** pAsset);", info->m_definition->GetFullName()) } void PrintHeaderConstructor() const { - LINE(WriterClassName(m_env.m_asset) << "(" << m_env.m_asset->m_definition->GetFullName() - << "* asset, const Zone& zone, IZoneOutputStream& stream);") + LINEF("{0}({1}* asset, const Zone& zone, IZoneOutputStream& stream);", WriterClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) } void PrintVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << " = nullptr;") + LINEF("var{0} = nullptr;", def->m_name) } void PrintWrittenVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << "Written = nullptr;") + LINEF("var{0}Written = nullptr;", def->m_name) } void PrintPointerVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << "Ptr = nullptr;") + LINEF("var{0}Ptr = nullptr;", def->m_name) } void PrintWrittenPointerVariableInitialization(const DataDefinition* def) const { - LINE("var" << def->m_name << "PtrWritten = nullptr;") + LINEF("var{0}PtrWritten = nullptr;", def->m_name) } void PrintConstructorMethod() { - LINE(WriterClassName(m_env.m_asset) << "::" << WriterClassName(m_env.m_asset) << "(" << m_env.m_asset->m_definition->GetFullName() - << "* asset, const Zone& zone, IZoneOutputStream& stream)") + LINEF( + "{0}::{0}({1}* asset, const Zone& zone, IZoneOutputStream& stream)", WriterClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) m_intendation++; - LINE_START(": AssetWriter(zone.m_pools->GetAssetOrAssetReference(" << m_env.m_asset->m_asset_enum_entry->m_name << ", GetAssetName(asset))" - << ", zone, stream)") - LINE_END("") + LINEF(": AssetWriter(zone.m_pools->GetAssetOrAssetReference({0}, GetAssetName(asset)), zone, stream)", m_env.m_asset->m_asset_enum_entry->m_name) m_intendation--; LINE("{") @@ -287,7 +273,7 @@ namespace PrintWrittenPointerVariableInitialization(m_env.m_asset->m_definition); LINE("") - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_info && !type->m_info->m_definition->m_anonymous && !type->m_info->m_is_leaf && !StructureComputations(type->m_info).IsAsset()) { @@ -295,7 +281,7 @@ namespace PrintWrittenVariableInitialization(type->m_type); } } - for (auto* type : m_env.m_used_types) + for (const auto* type : m_env.m_used_types) { if (type->m_info && type->m_pointer_array_reference_exists && !type->m_is_context_asset) { @@ -308,42 +294,42 @@ namespace LINE("}") } - void WriteMember_ScriptString(StructureInformation* info, - MemberInformation* member, + void WriteMember_ScriptString(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) const { if (writeType == MemberWriteType::ARRAY_POINTER) { - LINE("varScriptString = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");") - LINE("WriteScriptStringArray(true, " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");") + LINEF("varScriptString = {0};", MakeMemberAccess(info, member, modifier)) + LINEF("m_stream->MarkFollowing({0});", MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WriteScriptStringArray(true, {0});", MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } else if (writeType == MemberWriteType::EMBEDDED_ARRAY) { - LINE("varScriptStringWritten = " << MakeWrittenMemberAccess(info, member, modifier) << ";") - LINE("WriteScriptStringArray(false, " << MakeArrayCount(dynamic_cast(modifier.GetDeclarationModifier())) << ");") + LINEF("varScriptStringWritten = {0};", MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WriteScriptStringArray(false, {0});", MakeArrayCount(dynamic_cast(modifier.GetDeclarationModifier()))) } else if (writeType == MemberWriteType::EMBEDDED) { - LINE(MakeWrittenMemberAccess(info, member, modifier) << " = UseScriptString(" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("{0} = UseScriptString({1});", MakeWrittenMemberAccess(info, member, modifier), MakeMemberAccess(info, member, modifier)) } else { assert(false); - LINE("#error unsupported writeType " << static_cast(writeType) << " for scripstring") + LINEF("#error unsupported writeType {0} for script string", static_cast(writeType)) } } - void WriteMember_Asset(StructureInformation* info, - MemberInformation* member, + void WriteMember_Asset(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) const { if (writeType == MemberWriteType::SINGLE_POINTER) { - LINE(WriterClassName(member->m_type) << " writer(" << MakeMemberAccess(info, member, modifier) << ", m_zone, *m_stream);") - LINE("writer.Write(&" << MakeWrittenMemberAccess(info, member, modifier) << ");") + LINEF("{0} writer({1}, m_zone, *m_stream);", WriterClassName(member->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("writer.Write(&{0});", MakeWrittenMemberAccess(info, member, modifier)) } else if (writeType == MemberWriteType::POINTER_ARRAY) { @@ -352,12 +338,12 @@ namespace else { assert(false); - LINE("#error unsupported writeType " << static_cast(writeType) << " for asset") + LINEF("#error unsupported writeType {0} for asset", static_cast(writeType)) } } - void WriteMember_String(StructureInformation* info, - MemberInformation* member, + void WriteMember_String(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) const { @@ -365,11 +351,11 @@ namespace { if (member->m_member->m_type_declaration->m_is_const) { - LINE("varXStringWritten = &" << MakeWrittenMemberAccess(info, member, modifier) << ";") + LINEF("varXStringWritten = &{0};", MakeWrittenMemberAccess(info, member, modifier)) } else { - LINE("varXStringWritten = const_cast(&" << MakeWrittenMemberAccess(info, member, modifier) << ");") + LINEF("varXStringWritten = const_cast(&{0});", MakeWrittenMemberAccess(info, member, modifier)) } LINE("WriteXString(false);") } @@ -377,59 +363,62 @@ namespace { if (modifier.IsArray()) { - LINE("varXStringWritten = " << MakeWrittenMemberAccess(info, member, modifier) << ";") - LINE("WriteXStringArray(false, " << modifier.GetArraySize() << ");") + LINEF("varXStringWritten = {0};", MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WriteXStringArray(false, {0});", modifier.GetArraySize()) } else { - LINE("varXString = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");") - LINE("WriteXStringArray(true, " << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("varXString = {0};", MakeMemberAccess(info, member, modifier)) + LINEF("m_stream->MarkFollowing({0});", MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WriteXStringArray(true, {0});", MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } else { assert(false); - LINE("#error unsupported writeType " << static_cast(writeType) << " for string") + LINEF("#error unsupported writeType {0} for string", static_cast(writeType)) } } - void WriteMember_ArrayPointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_ArrayPointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); - LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->MarkFollowing({0});", MakeWrittenMemberAccess(info, member, modifier)) if (member->m_type && !member->m_type->m_is_leaf && !computations.IsInRuntimeBlock()) { - 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.GetArrayPointerCountEvaluation()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("WriteArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } else { - LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) - << ");") + LINEF("m_stream->Write<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } } - void WriteMember_PointerArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_PointerArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { - LINE(MakeTypePtrVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") + LINEF("{0} = {1};", 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() << ");") + LINEF("{0} = {1};", MakeTypeWrittenPtrVarName(member->m_member->m_type_declaration->m_type), MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WritePtrArray_{0}(false, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), modifier.GetArraySize()) } else { - LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");") - LINE("WritePtrArray_" << MakeSafeTypeName(member->m_member->m_type_declaration->m_type) << "(true, " - << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("m_stream->MarkFollowing({0});", MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WritePtrArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } } - void WriteMember_EmbeddedArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_EmbeddedArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); std::string arraySizeStr; @@ -443,42 +432,46 @@ namespace { if (computations.IsAfterPartialLoad()) { - 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 << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("WriteArray_{0}(true, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), 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 << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("{0} = {1};", MakeTypeWrittenVarName(member->m_member->m_type_declaration->m_type), MakeWrittenMemberAccess(info, member, modifier)) + LINEF("WriteArray_{0}(false, {1});", MakeSafeTypeName(member->m_member->m_type_declaration->m_type), arraySizeStr) } } else if (computations.IsAfterPartialLoad()) { - LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << arraySizeStr << ");") + LINEF("m_stream->Write<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + arraySizeStr) } } - void WriteMember_DynamicArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_DynamicArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { if (member->m_type && !member->m_type->m_is_leaf) { - 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()) << ");") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("WriteArray_{0}(true, {1});", + MakeSafeTypeName(member->m_member->m_type_declaration->m_type), + MakeEvaluation(modifier.GetDynamicArraySizeEvaluation())) } else { - LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ", " << MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()) << ");") + LINEF("m_stream->Write<{0}{1}>({2}, {3});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetDynamicArraySizeEvaluation())) } } - void WriteMember_Embedded(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_Embedded(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); @@ -486,44 +479,45 @@ namespace { if (computations.IsAfterPartialLoad()) { - 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);") + LINEF("{0} = &{1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Write_{0}(true);", MakeSafeTypeName(member->m_member->m_type_declaration->m_type)) } 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);") + LINEF("{0} = &{1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("{0} = &{1};", MakeTypeWrittenVarName(member->m_member->m_type_declaration->m_type), MakeWrittenMemberAccess(info, member, modifier)) + LINEF("Write_{0}(false);", MakeSafeTypeName(member->m_member->m_type_declaration->m_type)) } } else if (computations.IsAfterPartialLoad()) { - LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(&" - << MakeMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->Write<{0}{1}>(&{2});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier)) } } - void WriteMember_SinglePointer(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) const + void WriteMember_SinglePointer(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) const { const MemberComputations computations(member); - LINE("m_stream->MarkFollowing(" << MakeWrittenMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->MarkFollowing({0});", MakeWrittenMemberAccess(info, member, modifier)) if (member->m_type && !member->m_type->m_is_leaf && !computations.IsInRuntimeBlock()) { - LINE(MakeTypeVarName(member->m_member->m_type_declaration->m_type) << " = " << MakeMemberAccess(info, member, modifier) << ";") - LINE("Write_" << MakeSafeTypeName(member->m_type->m_definition) << "(true);") + LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Write_{0}(true);", MakeSafeTypeName(member->m_type->m_definition)) } else { - LINE("m_stream->Write<" << MakeTypeDecl(member->m_member->m_type_declaration.get()) - << MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()) << ">(" - << MakeMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->Write<{0}{1}>({2});", + MakeTypeDecl(member->m_member->m_type_declaration.get()), + MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()), + MakeMemberAccess(info, member, modifier)) } } - void WriteMember_TypeCheck(StructureInformation* info, - MemberInformation* member, + void WriteMember_TypeCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) const { @@ -568,16 +562,14 @@ namespace break; default: - LINE("// t=" << static_cast(writeType)) + LINEF("// t={0}", static_cast(writeType)) break; } } } - static bool WriteMember_ShouldMakeInsertReuse(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - const MemberWriteType writeType) + static bool + WriteMember_ShouldMakeInsertReuse(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { if (writeType != MemberWriteType::ARRAY_POINTER && writeType != MemberWriteType::SINGLE_POINTER && writeType != MemberWriteType::POINTER_ARRAY) { @@ -608,12 +600,12 @@ namespace return true; } - void WriteMember_InsertReuse(StructureInformation* info, - MemberInformation* member, + void WriteMember_InsertReuse(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, - const MemberWriteType writeType) + const MemberWriteType writeType) const { - if (!WriteMember_ShouldMakeInsertReuse(info, member, modifier, writeType)) + if (!WriteMember_ShouldMakeInsertReuse(member, modifier, writeType)) { WriteMember_TypeCheck(info, member, modifier, writeType); return; @@ -621,8 +613,9 @@ namespace if (writeType == MemberWriteType::ARRAY_POINTER) { - LINE("m_stream->ReusableAddOffset(" << MakeMemberAccess(info, member, modifier) << ", " - << MakeEvaluation(modifier.GetArrayPointerCountEvaluation()) << ");") + LINEF("m_stream->ReusableAddOffset({0}, {1});", + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetArrayPointerCountEvaluation())) } else if (writeType == MemberWriteType::POINTER_ARRAY) { @@ -630,26 +623,25 @@ namespace if (evaluation) { - LINE("m_stream->ReusableAddOffset(" << MakeMemberAccess(info, member, modifier) << ", " - << MakeEvaluation(modifier.GetPointerArrayCountEvaluation()) << ");") + LINEF("m_stream->ReusableAddOffset({0}, {1});", + MakeMemberAccess(info, member, modifier), + MakeEvaluation(modifier.GetPointerArrayCountEvaluation())) } else { - LINE("m_stream->ReusableAddOffset(" << MakeMemberAccess(info, member, modifier) << ", " << modifier.GetArraySize() << ");") + LINEF("m_stream->ReusableAddOffset({0}, {1});", MakeMemberAccess(info, member, modifier), modifier.GetArraySize()) } } else { - LINE("m_stream->ReusableAddOffset(" << MakeMemberAccess(info, member, modifier) << ");") + LINEF("m_stream->ReusableAddOffset({0});", MakeMemberAccess(info, member, modifier)) } WriteMember_TypeCheck(info, member, modifier, writeType); } - static bool WriteMember_ShouldMakeAlign(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - const MemberWriteType writeType) + static bool + WriteMember_ShouldMakeAlign(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { if (writeType != MemberWriteType::ARRAY_POINTER && writeType != MemberWriteType::POINTER_ARRAY && writeType != MemberWriteType::SINGLE_POINTER) { @@ -674,12 +666,12 @@ namespace return true; } - void WriteMember_Align(StructureInformation* info, - MemberInformation* member, + void WriteMember_Align(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, - const MemberWriteType writeType) + const MemberWriteType writeType) const { - if (!WriteMember_ShouldMakeAlign(info, member, modifier, writeType)) + if (!WriteMember_ShouldMakeAlign(member, modifier, writeType)) { WriteMember_InsertReuse(info, member, modifier, writeType); return; @@ -690,20 +682,18 @@ namespace if (member->m_alloc_alignment) { - LINE("m_stream->Align(" << MakeEvaluation(member->m_alloc_alignment.get()) << ");") + LINEF("m_stream->Align({0});", MakeEvaluation(member->m_alloc_alignment.get())) } else { - LINE("m_stream->Align(" << modifier.GetAlignment() << ");") + LINEF("m_stream->Align({0});", modifier.GetAlignment()) } WriteMember_InsertReuse(info, member, modifier, writeType); } - static bool WriteMember_ShouldMakeReuse(StructureInformation* info, - MemberInformation* member, - const DeclarationModifierComputations& modifier, - const MemberWriteType writeType) + static bool + WriteMember_ShouldMakeReuse(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { if (writeType != MemberWriteType::ARRAY_POINTER && writeType != MemberWriteType::SINGLE_POINTER && writeType != MemberWriteType::POINTER_ARRAY) { @@ -718,18 +708,18 @@ namespace return member->m_is_reusable; } - void WriteMember_Reuse(StructureInformation* info, - MemberInformation* member, + void WriteMember_Reuse(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { - if (!WriteMember_ShouldMakeReuse(info, member, modifier, writeType)) + if (!WriteMember_ShouldMakeReuse(member, modifier, writeType)) { WriteMember_Align(info, member, modifier, writeType); return; } - LINE("if(m_stream->ReusableShouldWrite(&" << MakeWrittenMemberAccess(info, member, modifier) << "))") + LINEF("if (m_stream->ReusableShouldWrite(&{0}))", MakeWrittenMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -739,8 +729,7 @@ namespace LINE("}") } - static bool WriteMember_ShouldMakePointerCheck(StructureInformation* info, - MemberInformation* member, + static bool WriteMember_ShouldMakePointerCheck(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { @@ -762,14 +751,14 @@ namespace return true; } - void WriteMember_PointerCheck(StructureInformation* info, - MemberInformation* member, + void WriteMember_PointerCheck(const StructureInformation* info, + const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberWriteType writeType) { - if (WriteMember_ShouldMakePointerCheck(info, member, modifier, writeType)) + if (WriteMember_ShouldMakePointerCheck(member, modifier, writeType)) { - LINE("if (" << MakeMemberAccess(info, member, modifier) << ")") + LINEF("if ({0})", MakeMemberAccess(info, member, modifier)) LINE("{") m_intendation++; @@ -784,15 +773,17 @@ namespace } } - void - WriteMember_Block(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier, MemberWriteType writeType) + void WriteMember_Block(const StructureInformation* info, + const MemberInformation* member, + const DeclarationModifierComputations& modifier, + const MemberWriteType writeType) { const MemberComputations computations(member); const auto notInDefaultNormalBlock = computations.IsNotInDefaultNormalBlock(); if (notInDefaultNormalBlock) { - LINE("m_stream->PushBlock(" << member->m_fast_file_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", member->m_fast_file_block->m_name) } WriteMember_PointerCheck(info, member, modifier, writeType); @@ -803,7 +794,7 @@ namespace } } - void WriteMember_ReferenceArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) + void WriteMember_ReferenceArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { auto first = true; for (const auto& entry : modifier.GetArrayEntries()) @@ -821,7 +812,7 @@ namespace } } - void WriteMember_Reference(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) + void WriteMember_Reference(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier) { if (modifier.IsDynamicArray()) { @@ -854,16 +845,16 @@ namespace else { assert(false); - LINE("#error WriteMemberReference failed @ " << member->m_member->m_name) + LINEF("#error WriteMemberReference failed @ {0}", member->m_member->m_name) } } - void WriteMember_Condition_Struct(StructureInformation* info, MemberInformation* member) + void WriteMember_Condition_Struct(const StructureInformation* info, const MemberInformation* member) { LINE("") if (member->m_condition) { - LINE("if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -878,7 +869,7 @@ namespace } } - void WriteMember_Condition_Union(StructureInformation* info, MemberInformation* member) + void WriteMember_Condition_Union(const StructureInformation* info, const MemberInformation* member) { const MemberComputations computations(member); @@ -887,7 +878,7 @@ namespace LINE("") if (member->m_condition) { - LINE("if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -905,7 +896,7 @@ namespace { if (member->m_condition) { - LINE("else if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -930,7 +921,7 @@ namespace { if (member->m_condition) { - LINE("else if(" << MakeEvaluation(member->m_condition.get()) << ")") + LINEF("else if ({0})", MakeEvaluation(member->m_condition.get())) LINE("{") m_intendation++; @@ -941,12 +932,12 @@ namespace } else { - LINE("#error Middle member of union must have condition (" << member->m_member->m_name << ")") + LINEF("#error Middle member of union must have condition ({0})", member->m_member->m_name) } } } - void PrintWriteMemberIfNeedsTreatment(StructureInformation* info, MemberInformation* member) + void PrintWriteMemberIfNeedsTreatment(const StructureInformation* info, const MemberInformation* member) { const MemberComputations computations(member); if (computations.ShouldIgnore()) @@ -962,38 +953,43 @@ namespace } } - void PrintWriteMethod(StructureInformation* info) + void PrintWriteMethod(const StructureInformation* info) { const StructureComputations computations(info); - LINE("void " << WriterClassName(m_env.m_asset) << "::Write_" << info->m_definition->m_name << "(const bool atStreamStart)") + LINEF("void {0}::Write_{1}(const bool atStreamStart)", WriterClassName(m_env.m_asset), info->m_definition->m_name) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(info->m_definition)) LINE("") - auto* dynamicMember = computations.GetDynamicMember(); + const auto* dynamicMember = computations.GetDynamicMember(); if (!(info->m_definition->GetType() == DataDefinitionType::UNION && dynamicMember)) { - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; if (dynamicMember == nullptr) { - LINE(MakeTypeWrittenVarName(info->m_definition) << " = m_stream->Write<" << info->m_definition->GetFullName() << ">(" - << MakeTypeVarName(info->m_definition) << "); // Size: " << info->m_definition->GetSize()) + LINEF("{0} = m_stream->Write<{1}>({2}); // Size: {3}", + MakeTypeWrittenVarName(info->m_definition), + info->m_definition->GetFullName(), + MakeTypeVarName(info->m_definition), + info->m_definition->GetSize()) } else { - 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 << "));") + LINEF("{0} = m_stream->WritePartial<{1}>({2}, offsetof({1}, {3}));", + MakeTypeWrittenVarName(info->m_definition), + info->m_definition->GetFullName(), + MakeTypeVarName(info->m_definition), + dynamicMember->m_member->m_name) } m_intendation--; LINE("") - LINE("assert(" << MakeTypeWrittenVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeWrittenVarName(info->m_definition)) } else { @@ -1003,12 +999,12 @@ namespace if (computations.IsAsset()) { LINE("") - LINE("m_stream->PushBlock(" << m_env.m_default_normal_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", m_env.m_default_normal_block->m_name) } else if (info->m_block) { LINE("") - LINE("m_stream->PushBlock(" << info->m_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", info->m_block->m_name) } for (const auto& member : info->m_ordered_members) @@ -1026,42 +1022,44 @@ namespace LINE("}") } - void PrintWritePtrMethod(StructureInformation* info) + void PrintWritePtrMethod(const StructureInformation* info) { const bool inTemp = info->m_block && info->m_block->m_type == FastFileBlockType::TEMP; - LINE("void " << WriterClassName(m_env.m_asset) << "::WritePtr_" << MakeSafeTypeName(info->m_definition) << "(const bool atStreamStart)") + LINEF("void {0}::WritePtr_{1}(const bool atStreamStart)", WriterClassName(m_env.m_asset), MakeSafeTypeName(info->m_definition)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypePtrVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypePtrVarName(info->m_definition)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE(MakeTypeWrittenPtrVarName(info->m_definition) - << " = m_stream->Write<" << info->m_definition->GetFullName() << "*>(" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("{0} = m_stream->Write<{1}*>({2});", + MakeTypeWrittenPtrVarName(info->m_definition), + info->m_definition->GetFullName(), + MakeTypePtrVarName(info->m_definition)) m_intendation--; LINE("") - LINE("assert(" << MakeTypeWrittenPtrVarName(info->m_definition) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeWrittenPtrVarName(info->m_definition)) LINE("") if (inTemp) { - LINE("m_stream->PushBlock(" << m_env.m_default_temp_block->m_name << ");") + LINEF("m_stream->PushBlock({0});", m_env.m_default_temp_block->m_name) LINE("") } - LINE("if(m_stream->ReusableShouldWrite(" << MakeTypeWrittenPtrVarName(info->m_definition) << "))") + LINEF("if (m_stream->ReusableShouldWrite({0}))", MakeTypeWrittenPtrVarName(info->m_definition)) LINE("{") m_intendation++; - LINE("m_stream->Align(" << info->m_definition->GetAlignment() << ");") - LINE("m_stream->ReusableAddOffset(*" << MakeTypePtrVarName(info->m_definition) << ");") + LINEF("m_stream->Align({0});", info->m_definition->GetAlignment()) + LINEF("m_stream->ReusableAddOffset(*{0});", MakeTypePtrVarName(info->m_definition)) LINE("") if (!info->m_is_leaf) { - LINE(MakeTypeVarName(info->m_definition) << " = *" << MakeTypePtrVarName(info->m_definition) << ";") - LINE("Write_" << MakeSafeTypeName(info->m_definition) << "(true);") + LINEF("{0} = *{1};", MakeTypeVarName(info->m_definition), MakeTypePtrVarName(info->m_definition)) + LINEF("Write_{0}(true);", MakeSafeTypeName(info->m_definition)) } else { @@ -1069,7 +1067,7 @@ namespace } LINE("") - LINE("m_stream->MarkFollowing(*" << MakeTypeWrittenPtrVarName(info->m_definition) << ");") + LINEF("m_stream->MarkFollowing(*{0});", MakeTypeWrittenPtrVarName(info->m_definition)) m_intendation--; LINE("}") @@ -1086,7 +1084,7 @@ namespace void PrintMainWriteMethod() { - LINE("void " << WriterClassName(m_env.m_asset) << "::Write(" << m_env.m_asset->m_definition->GetFullName() << "** pAsset)") + LINEF("void {0}::Write({1}** pAsset)", WriterClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) LINE("{") m_intendation++; @@ -1094,10 +1092,10 @@ namespace LINE("assert(m_asset != nullptr);") LINE("assert(m_asset->m_ptr != nullptr);") 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);") + LINEF("auto* zoneAsset = static_cast<{0}*>(m_asset->m_ptr);", m_env.m_asset->m_definition->GetFullName()) + LINEF("{0} = &zoneAsset;", MakeTypePtrVarName(m_env.m_asset->m_definition)) + LINEF("{0} = &zoneAsset;", MakeTypeWrittenPtrVarName(m_env.m_asset->m_definition)) + LINEF("WritePtr_{0}(false);", MakeSafeTypeName(m_env.m_asset->m_definition)) LINE("*pAsset = zoneAsset;") m_intendation--; @@ -1106,7 +1104,7 @@ namespace void PrintGetNameMethod() { - LINE("std::string " << WriterClassName(m_env.m_asset) << "::GetAssetName(" << m_env.m_asset->m_definition->GetFullName() << "* pAsset)") + LINEF("std::string {0}::GetAssetName({1}* pAsset)", WriterClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) LINE("{") m_intendation++; @@ -1115,66 +1113,66 @@ namespace LINE_START("return pAsset") auto first = true; - for (auto* member : m_env.m_asset->m_name_chain) + for (const auto* member : m_env.m_asset->m_name_chain) { if (first) { first = false; - LINE_MIDDLE("->" << member->m_member->m_name) + LINE_MIDDLEF("->{0}", member->m_member->m_name) } else { - LINE_MIDDLE("." << member->m_member->m_name) + LINE_MIDDLEF(".{0}", member->m_member->m_name) } } LINE_END(";") } else { - LINE("return \"" << m_env.m_asset->m_definition->m_name << "\";") + LINEF("return \"{0}\";", m_env.m_asset->m_definition->m_name) } m_intendation--; LINE("}") } - void PrintWritePtrArrayMethod_Loading(const DataDefinition* def, StructureInformation* info, const bool reusable) const + void PrintWritePtrArrayMethod_Loading(const DataDefinition* def, const StructureInformation* info, const bool reusable) const { - LINE("m_stream->Align(" << def->GetAlignment() << ");") + LINEF("m_stream->Align({0});", def->GetAlignment()) if (reusable) { - LINE("m_stream->ReusableAddOffset(*" << MakeTypePtrVarName(def) << ");") + LINEF("m_stream->ReusableAddOffset(*{0});", MakeTypePtrVarName(def)) } if (info && !info->m_is_leaf) { - LINE(MakeTypeVarName(info->m_definition) << " = *" << MakeTypePtrVarName(def) << ";") - LINE("Write_" << MakeSafeTypeName(def) << "(true);") + LINEF("{0} = *{1};", MakeTypeVarName(info->m_definition), MakeTypePtrVarName(def)) + LINEF("Write_{0}(true);", MakeSafeTypeName(def)) } else { - LINE("m_stream->Write<" << def->GetFullName() << ">(*" << MakeTypePtrVarName(def) << ");") + LINEF("m_stream->Write<{0}>(*{1});", def->GetFullName(), MakeTypePtrVarName(def)) } - LINE("m_stream->MarkFollowing(*" << MakeTypeWrittenPtrVarName(def) << ");") + LINEF("m_stream->MarkFollowing(*{0});", MakeTypeWrittenPtrVarName(def)) } void PrintWritePtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("if (*" << MakeTypePtrVarName(def) << ")") + LINEF("if (*{0})", MakeTypePtrVarName(def)) LINE("{") m_intendation++; if (info && StructureComputations(info).IsAsset()) { - LINE(WriterClassName(info) << " writer(*" << MakeTypePtrVarName(def) << ", m_zone, *m_stream);") - LINE("writer.Write(" << MakeTypeWrittenPtrVarName(def) << ");") + LINEF("{0} writer(*{1}, m_zone, *m_stream);", WriterClassName(info), MakeTypePtrVarName(def)) + LINEF("writer.Write({0});", MakeTypeWrittenPtrVarName(def)) } else { if (reusable) { - LINE("if(m_stream->ReusableShouldWrite(" << MakeTypeWrittenPtrVarName(def) << "))") + LINEF("if (m_stream->ReusableShouldWrite({0}))", MakeTypeWrittenPtrVarName(def)) LINE("{") m_intendation++; @@ -1195,30 +1193,30 @@ namespace void PrintWritePtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) { - LINE("void " << WriterClassName(m_env.m_asset) << "::WritePtrArray_" << MakeSafeTypeName(def) << "(const bool atStreamStart, const size_t count)") + LINEF("void {0}::WritePtrArray_{1}(const bool atStreamStart, const size_t count)", WriterClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypePtrVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypePtrVarName(def)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE(MakeTypeWrittenPtrVarName(def) << " = m_stream->Write<" << def->GetFullName() << "*>(" << MakeTypePtrVarName(def) << ", count);") + LINEF("{0} = m_stream->Write<{1}*>({2}, count);", MakeTypeWrittenPtrVarName(def), def->GetFullName(), MakeTypePtrVarName(def)) m_intendation--; LINE("") - LINE("assert(" << MakeTypeWrittenPtrVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeWrittenPtrVarName(def)) LINE("") - LINE(def->GetFullName() << "** var = " << MakeTypePtrVarName(def) << ";") - LINE(def->GetFullName() << "** varWritten = " << MakeTypeWrittenPtrVarName(def) << ";") - LINE("for(size_t index = 0; index < count; index++)") + LINEF("{0}** var = {1};", def->GetFullName(), MakeTypePtrVarName(def)) + LINEF("{0}** varWritten = {1};", def->GetFullName(), MakeTypeWrittenPtrVarName(def)) + LINE("for (size_t index = 0; index < count; index++)") LINE("{") m_intendation++; - LINE(MakeTypePtrVarName(def) << " = var;") - LINE(MakeTypeWrittenPtrVarName(def) << " = varWritten;") + LINEF("{0} = var;", MakeTypePtrVarName(def)) + LINEF("{0} = varWritten;", MakeTypeWrittenPtrVarName(def)) PrintWritePtrArrayMethod_PointerCheck(def, info, reusable); LINE("") LINE("var++;") @@ -1230,32 +1228,32 @@ namespace LINE("}") } - void PrintWriteArrayMethod(const DataDefinition* def, StructureInformation* info) + void PrintWriteArrayMethod(const DataDefinition* def, const StructureInformation* info) { - LINE("void " << WriterClassName(m_env.m_asset) << "::WriteArray_" << MakeSafeTypeName(def) << "(const bool atStreamStart, const size_t count)") + LINEF("void {0}::WriteArray_{1}(const bool atStreamStart, const size_t count)", WriterClassName(m_env.m_asset), MakeSafeTypeName(def)) LINE("{") m_intendation++; - LINE("assert(" << MakeTypeVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeVarName(def)) LINE("") - LINE("if(atStreamStart)") + LINE("if (atStreamStart)") m_intendation++; - LINE(MakeTypeWrittenVarName(def) << " = m_stream->Write<" << def->GetFullName() << ">(" << MakeTypeVarName(def) << ", count);") + LINEF("{0} = m_stream->Write<{1}>({2}, count);", MakeTypeWrittenVarName(def), def->GetFullName(), MakeTypeVarName(def)) m_intendation--; LINE("") - LINE("assert(" << MakeTypeWrittenVarName(def) << " != nullptr);") + LINEF("assert({0} != nullptr);", MakeTypeWrittenVarName(def)) LINE("") - LINE(def->GetFullName() << "* var = " << MakeTypeVarName(def) << ";") - LINE(def->GetFullName() << "* varWritten = " << MakeTypeWrittenVarName(def) << ";") - LINE("for(size_t index = 0; index < count; index++)") + LINEF("{0}* var = {1};", def->GetFullName(), MakeTypeVarName(def)) + LINEF("{0}* varWritten = {1};", def->GetFullName(), 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);") + LINEF("{0} = var;", MakeTypeVarName(info->m_definition)) + LINEF("{0} = varWritten;", MakeTypeWrittenVarName(info->m_definition)) + LINEF("Write_{0}(false);", info->m_definition->m_name) LINE("var++;") LINE("varWritten++;") @@ -1276,17 +1274,8 @@ std::vector ZoneWriteTemplate::GetFilesToRender(RenderingConte for (auto& c : assetName) c = static_cast(tolower(c)); - { - std::ostringstream str; - str << assetName << '/' << assetName << "_write_db.h"; - files.emplace_back(str.str(), TAG_HEADER); - } - - { - std::ostringstream str; - str << assetName << '/' << assetName << "_write_db.cpp"; - files.emplace_back(str.str(), TAG_SOURCE); - } + files.emplace_back(std::format("{0}/{0}_write_db.h", assetName), TAG_HEADER); + files.emplace_back(std::format("{0}/{0}_write_db.cpp", assetName), TAG_SOURCE); return files; }