From 6bbc3fa37ec0f76ba05b2eb2dbc9c370721a3509 Mon Sep 17 00:00:00 2001 From: Jan Date: Mon, 21 Apr 2025 10:38:55 +0200 Subject: [PATCH] wip: use std::format for zcg templates --- src/Linker/LinkerPaths.cpp | 4 +- src/Unlinker/UnlinkerArgs.cpp | 2 +- .../Templates/Internal/BaseTemplate.cpp | 13 +- .../Templates/Internal/BaseTemplate.h | 31 +- .../Generating/Templates/ZoneLoadTemplate.cpp | 471 +++++++++--------- src/ZoneLoading/Game/IW4/ContentLoaderIW4.h | 14 +- .../Zone/Stream/IZoneInputStream.h | 2 +- 7 files changed, 274 insertions(+), 263 deletions(-) diff --git a/src/Linker/LinkerPaths.cpp b/src/Linker/LinkerPaths.cpp index 7142259e..f72d48cb 100644 --- a/src/Linker/LinkerPaths.cpp +++ b/src/Linker/LinkerPaths.cpp @@ -56,8 +56,8 @@ namespace void CreateFromString(const std::string& templateString) { const auto templateStringLength = templateString.size(); - auto partStart = 0u; - for (auto i = 0u; i < templateStringLength; i++) + auto partStart = 0uz; + for (auto i = 0uz; i < templateStringLength; i++) { if (templateString[i] != '?') continue; diff --git a/src/Unlinker/UnlinkerArgs.cpp b/src/Unlinker/UnlinkerArgs.cpp index 3d492667..5d9964df 100644 --- a/src/Unlinker/UnlinkerArgs.cpp +++ b/src/Unlinker/UnlinkerArgs.cpp @@ -245,7 +245,7 @@ void UnlinkerArgs::AddSpecifiedAssetType(std::string value) void UnlinkerArgs::ParseCommaSeparatedAssetTypeString(const std::string& input) { - auto currentPos = 0u; + auto currentPos = 0uz; size_t endPos; std::string lowerInput(input); 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..d687c519 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,32 +25,31 @@ 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)) @@ -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<{0}{1}>({2});", + 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<{0}{1}>({2});", 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/ZoneLoading/Game/IW4/ContentLoaderIW4.h b/src/ZoneLoading/Game/IW4/ContentLoaderIW4.h index 4ba9f1b8..8a3fd944 100644 --- a/src/ZoneLoading/Game/IW4/ContentLoaderIW4.h +++ b/src/ZoneLoading/Game/IW4/ContentLoaderIW4.h @@ -1,4 +1,5 @@ #pragma once + #include "Game/IW4/IW4.h" #include "Loading/ContentLoaderBase.h" #include "Loading/IContentLoadingEntryPoint.h" @@ -7,17 +8,18 @@ namespace IW4 { class ContentLoader final : public ContentLoaderBase, public IContentLoadingEntryPoint { - XAsset* varXAsset; - ScriptStringList* varScriptStringList; + public: + ContentLoader(); + void Load(Zone* zone, IZoneInputStream* stream) override; + + private: void LoadScriptStringList(bool atStreamStart); void LoadXAsset(bool atStreamStart) const; void LoadXAssetArray(bool atStreamStart, size_t count); - public: - ContentLoader(); - - void Load(Zone* zone, IZoneInputStream* stream) override; + XAsset* varXAsset; + ScriptStringList* varScriptStringList; }; } // namespace IW4 diff --git a/src/ZoneLoading/Zone/Stream/IZoneInputStream.h b/src/ZoneLoading/Zone/Stream/IZoneInputStream.h index b1158e17..c363b759 100644 --- a/src/ZoneLoading/Zone/Stream/IZoneInputStream.h +++ b/src/ZoneLoading/Zone/Stream/IZoneInputStream.h @@ -25,7 +25,7 @@ public: LoadDataInBlock(const_cast(reinterpret_cast(dst)), sizeof(T)); } - template void Load(T* dst, const uint32_t count) + template void Load(T* dst, const size_t count) { LoadDataInBlock(const_cast(reinterpret_cast(dst)), count * sizeof(T)); }