From 6f0fc110e20be7f0dc263e1993a8049ff05af577 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Markus=20M=C3=BCtzel?= Date: Mon, 13 Jan 2025 17:45:24 +0100 Subject: [PATCH] vtk: update to 9.4.1 Remove patches that have been applied upstream. Fix compilation issues with `clang++` version 19. Fix new build issues with fmt 11. Cherry-pick patches from upstream VTK-m. Update patch to make it apply cleanly. Update DIY to version 3.6.0 to avoid compilation issue with C++ STL from LLVM 19 (`std::char_traits` can no longer be instantiated with arbitrary types). Add patch to fix compatibility with DIY 3. Add patch to fix build issue of the InfovisBoostGraphAlgorithms module that requires C++14 now. Add patch for the ANARI rendering module to fix an issue with undeclared type identifiers. Add optional dependencies for new Alembic and ANARI modules. --- mingw-w64-vtk/002-Fix-build-with-gcc-13.patch | 12 - mingw-w64-vtk/002-llvm-19-compatibility.patch | 14 + mingw-w64-vtk/003-fix-build-with-fmt-11.patch | 48 +- mingw-w64-vtk/005-opencascade-7.8.patch | 96 - ...remove-unused-method-from-mir-tables.patch | 31 + ...compile-error-for-contour-tree-print.patch | 37 + .../007-dll-export-some-functions.patch | 20 +- .../008-fix-vtkm_openmp-exported-target.patch | 46 - mingw-w64-vtk/008-update-to-diy-3.6.0.patch | 26339 ++++++++++++++++ mingw-w64-vtk/009-diy-3-compatibility.patch | 42 + .../010-boost-math-requires-cxx-14.patch | 14 + mingw-w64-vtk/011-anari-integer-types.patch | 226 + mingw-w64-vtk/PKGBUILD | 52 +- 13 files changed, 26764 insertions(+), 213 deletions(-) delete mode 100644 mingw-w64-vtk/002-Fix-build-with-gcc-13.patch create mode 100644 mingw-w64-vtk/002-llvm-19-compatibility.patch delete mode 100644 mingw-w64-vtk/005-opencascade-7.8.patch create mode 100644 mingw-w64-vtk/005-remove-unused-method-from-mir-tables.patch create mode 100644 mingw-w64-vtk/006-fix-compile-error-for-contour-tree-print.patch delete mode 100644 mingw-w64-vtk/008-fix-vtkm_openmp-exported-target.patch create mode 100644 mingw-w64-vtk/008-update-to-diy-3.6.0.patch create mode 100644 mingw-w64-vtk/009-diy-3-compatibility.patch create mode 100644 mingw-w64-vtk/010-boost-math-requires-cxx-14.patch create mode 100644 mingw-w64-vtk/011-anari-integer-types.patch diff --git a/mingw-w64-vtk/002-Fix-build-with-gcc-13.patch b/mingw-w64-vtk/002-Fix-build-with-gcc-13.patch deleted file mode 100644 index 2a8b19b720..0000000000 --- a/mingw-w64-vtk/002-Fix-build-with-gcc-13.patch +++ /dev/null @@ -1,12 +0,0 @@ ---- a/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/no-mpi.hpp -+++ b/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/no-mpi.hpp -@@ -1,9 +1,9 @@ - #ifndef VTKMDIY_MPI_NO_MPI_HPP - #define VTKMDIY_MPI_NO_MPI_HPP - -+#include // uintptr_t - #include // std::runtime_error - -- - static const int MPI_SUCCESS = 0; - static const int MPI_ANY_SOURCE = -1; diff --git a/mingw-w64-vtk/002-llvm-19-compatibility.patch b/mingw-w64-vtk/002-llvm-19-compatibility.patch new file mode 100644 index 0000000000..5807024cb8 --- /dev/null +++ b/mingw-w64-vtk/002-llvm-19-compatibility.patch @@ -0,0 +1,14 @@ +a template argument list is expected after a name prefixed by the template keyword + +diff -urN VTK-9.3.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/internal/VariantImplDetail.h.orig VTK-9.3.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/internal/VariantImplDetail.h +--- VTK-9.3.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/internal/VariantImplDetail.h.orig 2024-06-28 18:00:10.000000000 +0200 ++++ VTK-9.3.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/internal/VariantImplDetail.h 2025-01-13 15:35:29.812473900 +0100 +@@ -548,7 +548,7 @@ + // just the one that it currently holds. + return f(storage.V7, std::forward(args)...); + default: +- return VariantCases::template CastAndCall( ++ return VariantCases::template CastAndCall<>( + index - 8, std::forward(f), storage.Remaining, std::forward(args)...); + } + } diff --git a/mingw-w64-vtk/003-fix-build-with-fmt-11.patch b/mingw-w64-vtk/003-fix-build-with-fmt-11.patch index ef7e01be9f..372d82e203 100644 --- a/mingw-w64-vtk/003-fix-build-with-fmt-11.patch +++ b/mingw-w64-vtk/003-fix-build-with-fmt-11.patch @@ -1,40 +1,22 @@ ---- a/ThirdParty/ioss/vtkioss/Ioss_IOFactory.C -+++ b/ThirdParty/ioss/vtkioss/Ioss_IOFactory.C +diff -urN VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_Field.C.orig VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_Field.C +--- VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_Field.C.orig 2024-12-27 18:08:14.000000000 +0100 ++++ VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_Field.C 2025-01-13 16:46:04.272364200 +0100 @@ -12,6 +12,7 @@ - #include // for nullptr + #include #include "vtk_fmt.h" #include VTK_FMT(fmt/ostream.h) -+#include VTK_FMT(fmt/ranges.h) - #include // for _Rb_tree_iterator, etc - #include // for basic_ostream, etc - #include ---- a/ThirdParty/ioss/vtkioss/Ioss_StructuredBlock.C -+++ b/ThirdParty/ioss/vtkioss/Ioss_StructuredBlock.C -@@ -15,6 +15,7 @@ - #include - #include "vtk_fmt.h" - #include VTK_FMT(fmt/ostream.h) -+#include VTK_FMT(fmt/ranges.h) - - #include // for size_t - #include ---- a/ThirdParty/ioss/vtkioss/Ioss_Utils.C -+++ b/ThirdParty/ioss/vtkioss/Ioss_Utils.C -@@ -21,6 +21,7 @@ - #include VTK_FMT(fmt/chrono.h) ++#include VTK_FMT(fmt/xchar.h) + #include + #include + #include +diff -urN VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_VariableType.C.orig VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_VariableType.C +--- VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_VariableType.C.orig 2024-12-27 18:08:14.000000000 +0100 ++++ VTK-9.4.1/ThirdParty/ioss/vtkioss/Ioss_VariableType.C 2025-01-13 16:47:09.758522800 +0100 +@@ -19,6 +19,7 @@ + #include VTK_FMT(fmt/core.h) #include VTK_FMT(fmt/format.h) #include VTK_FMT(fmt/ostream.h) -+#include VTK_FMT(fmt/ranges.h) - #include ++#include VTK_FMT(fmt/xchar.h) + #include #include #include ---- a/ThirdParty/ioss/vtkioss/Ioss_ZoneConnectivity.C -+++ b/ThirdParty/ioss/vtkioss/Ioss_ZoneConnectivity.C -@@ -9,6 +9,7 @@ - #include // for size_t - #include "vtk_fmt.h" - #include VTK_FMT(fmt/ostream.h) -+#include VTK_FMT(fmt/ranges.h) - #include // for string - #include // for vector - diff --git a/mingw-w64-vtk/005-opencascade-7.8.patch b/mingw-w64-vtk/005-opencascade-7.8.patch deleted file mode 100644 index ff3cda4900..0000000000 --- a/mingw-w64-vtk/005-opencascade-7.8.patch +++ /dev/null @@ -1,96 +0,0 @@ -From 761aa1d15970fcb6aadb7d6152737fa9b2d4b0d0 Mon Sep 17 00:00:00 2001 -From: Lars Glud -Date: Fri, 24 May 2024 07:58:23 +0200 -Subject: [PATCH] Make compatible with opencascade 7.8.0. - ---- - IO/OCCT/CMakeLists.txt | 28 ++++++++++++++++++++-------- - IO/OCCT/vtkOCCTReader.cxx | 13 ++++++++++++- - 2 files changed, 32 insertions(+), 9 deletions(-) - -diff --git a/IO/OCCT/CMakeLists.txt b/IO/OCCT/CMakeLists.txt -index e81444ecebd..4baddeb719b 100644 ---- a/IO/OCCT/CMakeLists.txt -+++ b/IO/OCCT/CMakeLists.txt -@@ -4,12 +4,25 @@ vtk_module_find_package(PRIVATE_IF_SHARED - VERSION_VAR "@OpenCASCADE_MAJOR_VERSION@.@OpenCASCADE_MINOR_VERSION@.@OpenCASCADE_MAINTENANCE_VERSION@" - ) - --set(opencascade_req_targets -- TKSTEP -- TKIGES -- TKMesh -- TKXDESTEP -- TKXDEIGES) -+if (OpenCASCADE_VERSION VERSION_GREATER_EQUAL "7.8.0") -+ set(opencascade_req_targets -+ TKDESTEP -+ TKDEIGES -+ TKernel -+ TKMath -+ TKMesh -+ TKBRep -+ TKXSBase -+ TKLCAF -+ TKXCAF) -+else() -+ set(opencascade_req_targets -+ TKSTEP -+ TKIGES -+ TKMesh -+ TKXDESTEP -+ TKXDEIGES) -+endif() - set(opencascade_missing_targets) - foreach (opencascade_req_target IN LISTS opencascade_req_targets) - if (NOT TARGET "${opencascade_req_target}") -@@ -35,8 +48,7 @@ vtk_module_link(VTK::IOOCCT - ${opencascade_req_targets}) - - # OpenCASCADE started putting include directory usage requirements in 7.7.0. --set(OpenCASCADE_VERSION -- "${OpenCASCADE_MAJOR_VERSION}.${OpenCASCADE_MINOR_VERSION}.${OpenCASCADE_MAINTENANCE_VERSION}") -+ - if (OpenCASCADE_VERSION VERSION_LESS "7.7.0") - vtk_module_include(VTK::IOOCCT PRIVATE "${OpenCASCADE_INCLUDE_DIR}") - endif () -diff --git a/IO/OCCT/vtkOCCTReader.cxx b/IO/OCCT/vtkOCCTReader.cxx -index 52e76be72c1..5aca5c93c8c 100644 ---- a/IO/OCCT/vtkOCCTReader.cxx -+++ b/IO/OCCT/vtkOCCTReader.cxx -@@ -345,11 +345,19 @@ public: - } - - //---------------------------------------------------------------------------- -+#if VTK_OCCT_VERSION(7, 8, 0) <= OCC_VERSION_HEX -+ size_t GetHash(const TDF_Label& label) -+ { -+ TopoDS_Shape aShape; -+ return this->ShapeTool->GetShape(label, aShape) ? std::hash{}(aShape) : 0; -+ } -+#else - int GetHash(const TDF_Label& label) - { - TopoDS_Shape aShape; - return this->ShapeTool->GetShape(label, aShape) ? aShape.HashCode(INT_MAX) : 0; - } -+#endif - - //---------------------------------------------------------------------------- - static void GetMatrix(const TopLoc_Location& loc, vtkMatrix4x4* mat) -@@ -381,8 +389,11 @@ public: - GetMatrix(hLoc->Get(), location); - } - } -- -+#if VTK_OCCT_VERSION(7, 8, 0) <= OCC_VERSION_HEX -+ std::unordered_map> ShapeMap; -+#else - std::unordered_map> ShapeMap; -+#endif - Handle(XCAFDoc_ShapeTool) ShapeTool; - Handle(XCAFDoc_ColorTool) ColorTool; - --- -GitLab - diff --git a/mingw-w64-vtk/005-remove-unused-method-from-mir-tables.patch b/mingw-w64-vtk/005-remove-unused-method-from-mir-tables.patch new file mode 100644 index 0000000000..8731695cd2 --- /dev/null +++ b/mingw-w64-vtk/005-remove-unused-method-from-mir-tables.patch @@ -0,0 +1,31 @@ +From c805a6039ea500cb96158cfc11271987c9f67aa4 Mon Sep 17 00:00:00 2001 +From: Kenneth Moreland +Date: Tue, 15 Oct 2024 13:06:36 -0400 +Subject: [PATCH] Remove unused method from MIR tables + +The implementation of this method was incorrect as it referenced a class +member that does not exist. Many compilers allowed it in a templated +class when the method was never used, but other compilers attempt to +compile the inlined method regardless. + +Since the method clearly is not needed, the easy solution is to remove +it. +--- + vtkm/filter/contour/worklet/mir/MIRTables.h | 5 ----- + 1 file changed, 5 deletions(-) + +diff -urN VTK-9.4.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/contour/worklet/mir/MIRTables.h.orig VTK-9.4.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/contour/worklet/mir/MIRTables.h +--- VTK-9.4.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/contour/worklet/mir/MIRTables.h.orig 2024-12-27 18:08:14.000000000 +0100 ++++ VTK-9.4.1/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/contour/worklet/mir/MIRTables.h 2025-01-13 16:56:54.495714500 +0100 +@@ -11400,11 +11400,6 @@ + return FacesLookup[shape]; + } + +- VTKM_EXEC vtkm::UInt8 GetPoint(vtkm::Id pointIndex) const +- { +- return this->CellFacePortal.Get(pointIndex); +- } +- + private: + typename vtkm::cont::ArrayHandle::ReadPortalType MIRTablesDataPortal; + typename vtkm::cont::ArrayHandle::ReadPortalType MIRTablesIndicesPortal; diff --git a/mingw-w64-vtk/006-fix-compile-error-for-contour-tree-print.patch b/mingw-w64-vtk/006-fix-compile-error-for-contour-tree-print.patch new file mode 100644 index 0000000000..bcc8c7f211 --- /dev/null +++ b/mingw-w64-vtk/006-fix-compile-error-for-contour-tree-print.patch @@ -0,0 +1,37 @@ +From 48e385af319543800398656645327243a29babfb Mon Sep 17 00:00:00 2001 +From: Kenneth Moreland +Date: Tue, 15 Oct 2024 12:01:34 -0400 +Subject: [PATCH] Fix compile error for contour tree print + +A print for one of the contour tree objects was referencing members of +itself that don't seem to exist. This causes the Intel compiler to fail +to compile it. I'm at a loss about how any other compiler does not error +out, but at any rate this should be correct. +--- + .../worklet/contourtree_distributed/HierarchicalContourTree.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h b/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h +index a996d42928..e40d5f4f15 100644 +--- a/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h ++++ b/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h +@@ -663,7 +663,7 @@ std::string HierarchicalContourTree::PrintDotSuperStructure(const cha + auto hyperarcsPortal = this->Hyperarcs.ReadPortal(); + auto regularNodeGlobalIdsPortal = this->RegularNodeGlobalIds.ReadPortal(); + auto whichIterationPortal = this->WhichIteration.ReadPortal(); +- auto whichRoundPortal = this->whichRound.ReadPortal(); ++ auto whichRoundPortal = this->WhichRound.ReadPortal(); + auto superarcsPortal = this->Superarcs.ReadPortal(); + auto superparentsPortal = this->Superparents.ReadPortal(); + for (vtkm::Id supernode = 0; supernode < this->Supernodes.GetNumberOfValues(); supernode++) +@@ -708,7 +708,7 @@ std::string HierarchicalContourTree::PrintDotSuperStructure(const cha + if (contourtree_augmented::NoSuchElement(superarcTo)) + { // no superarc + // if it occurred on the final round, it's the global root and is shown as the NULL node +- if (whichRoundPortal.Get(superarcFrom) == this->NRounds) ++ if (whichRoundPortal.Get(superarcFrom) == this->NumRounds) + { // root node + outstream << "\tSN" << std::setw(1) << superarcFrom << " -> SA" << std::setw(1) << superarc + << " [label=\"S" << std::setw(1) << superarc << "\",style=dotted]\n"; +-- +GitLab diff --git a/mingw-w64-vtk/007-dll-export-some-functions.patch b/mingw-w64-vtk/007-dll-export-some-functions.patch index 6c0c6cacde..b36372aa39 100644 --- a/mingw-w64-vtk/007-dll-export-some-functions.patch +++ b/mingw-w64-vtk/007-dll-export-some-functions.patch @@ -40,20 +40,20 @@ /** * Get component @a comp of the tuple at @a tupleIdx. */ -- ValueType GetTypedComponent(vtkIdType tupleIdx, int comp) const VTK_EXPECTS(0 <= tupleIdx && -+ VTKCOMMONCORE_EXPORT ValueType GetTypedComponent(vtkIdType tupleIdx, int comp) const VTK_EXPECTS(0 <= tupleIdx && - tupleIdx < GetNumberOfTuples()) VTK_EXPECTS(0 <= comp && comp < GetNumberOfComponents()) +- ValueType GetTypedComponent(vtkIdType tupleIdx, int comp) const ++ VTKCOMMONCORE_EXPORT ValueType GetTypedComponent(vtkIdType tupleIdx, int comp) const + VTK_EXPECTS(0 <= tupleIdx && GetNumberOfComponents() * tupleIdx + comp < GetNumberOfValues()) + VTK_EXPECTS(0 <= comp && comp < GetNumberOfComponents()) { - return this->Buffer->GetBuffer()[this->NumberOfComponents * tupleIdx + comp]; @@ -116,7 +116,7 @@ /** * Set component @a comp of the tuple at @a tupleIdx to @a value. */ -- void SetTypedComponent(vtkIdType tupleIdx, int comp, ValueType value) VTK_EXPECTS(0 <= tupleIdx && -+ VTKCOMMONCORE_EXPORT void SetTypedComponent(vtkIdType tupleIdx, int comp, ValueType value) VTK_EXPECTS(0 <= tupleIdx && - tupleIdx < GetNumberOfTuples()) VTK_EXPECTS(0 <= comp && comp < GetNumberOfComponents()) +- void SetTypedComponent(vtkIdType tupleIdx, int comp, ValueType value) ++ VTKCOMMONCORE_EXPORT void SetTypedComponent(vtkIdType tupleIdx, int comp, ValueType value) + VTK_EXPECTS(0 <= tupleIdx && GetNumberOfComponents() * tupleIdx + comp < GetNumberOfValues()) + VTK_EXPECTS(0 <= comp && comp < GetNumberOfComponents()) { - const vtkIdType valueIdx = tupleIdx * this->NumberOfComponents + comp; @@ -260,11 +260,11 @@ vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) override; // MSVC doesn't like 'using' here (error C2487). Just forward instead: @@ -80,9 +80,9 @@ if (!strcmp(thisClassName, type)) \ { \ @@ -836,7 +836,7 @@ - return superclass::IsTypeOf(type); \ + { \ + return this->thisClass::IsTypeOf(type); \ } \ - vtkTypeBool IsA(const char* type) override { return this->thisClass::IsTypeOf(type); } \ - static thisClass* SafeDownCast(vtkObjectBase* o) \ + static VTKCOMMONCORE_EXPORT thisClass* SafeDownCast(vtkObjectBase* o) \ { \ diff --git a/mingw-w64-vtk/008-fix-vtkm_openmp-exported-target.patch b/mingw-w64-vtk/008-fix-vtkm_openmp-exported-target.patch deleted file mode 100644 index 0684fa3f7b..0000000000 --- a/mingw-w64-vtk/008-fix-vtkm_openmp-exported-target.patch +++ /dev/null @@ -1,46 +0,0 @@ ---- a/ThirdParty/vtkm/vtkvtkm/vtk-m/CMake/VTKmConfig.cmake.in -+++ b/ThirdParty/vtkm/vtkvtkm/vtk-m/CMake/VTKmConfig.cmake.in -@@ -105,6 +105,14 @@ if (VTKm_ENABLE_TBB) - endif() - endif() - -+if (VTKm_ENABLE_OPENMP) -+ find_dependency(OpenMP) -+ if (NOT OpenMP_FOUND) -+ set(VTKm_FOUND 0) -+ list(APPEND VTKm_NOT_FOUND_REASON "OpenMP not found: ${OpenMP_NOT_FOUND_MESSAGE}") -+ endif() -+endif() -+ - # Load the library exports, but only if not compiling VTK-m itself - set_and_check(VTKm_CONFIG_DIR "@PACKAGE_VTKm_INSTALL_CONFIG_DIR@") - set(VTKM_FROM_INSTALL_DIR FALSE) ---- a/ThirdParty/vtkm/vtkvtkm/vtk-m/CMake/VTKmDeviceAdapters.cmake -+++ b/ThirdParty/vtkm/vtkvtkm/vtk-m/CMake/VTKmDeviceAdapters.cmake -@@ -58,21 +58,13 @@ if(VTKm_ENABLE_OPENMP AND NOT (TARGET vtkm_openmp OR TARGET vtkm::openmp)) - find_package(OpenMP 4.0 REQUIRED COMPONENTS CXX QUIET) - - add_library(vtkm_openmp INTERFACE) -- set_target_properties(vtkm_openmp PROPERTIES EXPORT_NAME openmp) -- if(OpenMP_CXX_FLAGS) -- set_property(TARGET vtkm_openmp -- APPEND PROPERTY INTERFACE_COMPILE_OPTIONS $<$:${OpenMP_CXX_FLAGS}>) -- -- if(VTKm_ENABLE_CUDA) -- string(REPLACE ";" "," openmp_cuda_flags "-Xcompiler=${OpenMP_CXX_FLAGS}") -- set_property(TARGET vtkm_openmp -- APPEND PROPERTY INTERFACE_COMPILE_OPTIONS $<$:${openmp_cuda_flags}>) -- endif() -- endif() -- if(OpenMP_CXX_LIBRARIES) -- set_target_properties(vtkm_openmp PROPERTIES -- INTERFACE_LINK_LIBRARIES "${OpenMP_CXX_LIBRARIES}") -+ target_link_libraries(vtkm_openmp INTERFACE OpenMP::OpenMP_CXX) -+ target_compile_options(vtkm_openmp INTERFACE $<$:${OpenMP_CXX_FLAGS}>) -+ if(VTKm_ENABLE_CUDA) -+ string(REPLACE ";" "," openmp_cuda_flags "-Xcompiler=${OpenMP_CXX_FLAGS}") -+ target_compile_options(vtkm_openmp INTERFACE $<$:${openmp_cuda_flags}>) - endif() -+ set_target_properties(vtkm_openmp PROPERTIES EXPORT_NAME openmp) - install(TARGETS vtkm_openmp EXPORT ${VTKm_EXPORT_NAME}) - endif() diff --git a/mingw-w64-vtk/008-update-to-diy-3.6.0.patch b/mingw-w64-vtk/008-update-to-diy-3.6.0.patch new file mode 100644 index 0000000000..15a898b4c8 --- /dev/null +++ b/mingw-w64-vtk/008-update-to-diy-3.6.0.patch @@ -0,0 +1,26339 @@ +From 9fe7c3e59d6536ca90dc5b1bea3a2b0474052d7e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Markus=20M=C3=BCtzel?= +Date: Mon, 13 Jan 2025 15:04:26 +0100 +Subject: [PATCH] update to diy2 3.6.0 + +--- + ThirdParty/diy2/CMakeLists.txt | 4 +- + ThirdParty/diy2/vtk_diy2.h.in | 2 +- + .../vtkdiy2/include/vtkdiy2/algorithms.hpp | 8 +- + .../diy2/vtkdiy2/include/vtkdiy2/assigner.hpp | 4 +- + .../vtkdiy2/include/vtkdiy2/collection.hpp | 8 +- + .../include/vtkdiy2/critical-resource.hpp | 5 + + .../vtkdiy2/include/vtkdiy2/decomposition.hpp | 32 +- + .../detail/algorithms/kdtree-sampling.hpp | 14 +- + .../vtkdiy2/detail/algorithms/kdtree.hpp | 63 +- + .../vtkdiy2/detail/algorithms/sort.hpp | 18 +- + .../vtkdiy2/detail/master/collectives.hpp | 2 +- + .../vtkdiy2/detail/master/communication.hpp | 61 +- + .../vtkdiy2/detail/master/execution.hpp | 5 +- + .../detail/master/iexchange-collective.hpp | 16 +- + .../vtkdiy2/detail/master/iexchange-dud.hpp | 338 -- + .../vtkdiy2/detail/master/iexchange.hpp | 43 +- + .../vtkdiy2/detail/reduce/all-to-all.hpp | 31 +- + .../vtkdiy2/include/vtkdiy2/dynamic-point.hpp | 16 +- + .../diy2/vtkdiy2/include/vtkdiy2/factory.hpp | 20 +- + .../vtkdiy2/include/vtkdiy2/fmt/compile.h | 466 -- + .../diy2/vtkdiy2/include/vtkdiy2/fmt/core.h | 1420 ------ + .../vtkdiy2/include/vtkdiy2/fmt/format-inl.h | 1000 ----- + .../diy2/vtkdiy2/include/vtkdiy2/fmt/format.h | 3602 --------------- + .../diy2/vtkdiy2/include/vtkdiy2/fmt/locale.h | 77 - + .../diy2/vtkdiy2/include/vtkdiy2/grid.hpp | 23 +- + .../diy2/vtkdiy2/include/vtkdiy2/io/block.hpp | 7 +- + .../diy2/vtkdiy2/include/vtkdiy2/io/bov.hpp | 100 +- + .../diy2/vtkdiy2/include/vtkdiy2/io/numpy.hpp | 6 +- + .../vtkdiy2/include/vtkdiy2/io/shared.hpp | 6 +- + .../diy2/vtkdiy2/include/vtkdiy2/io/utils.hpp | 4 +- + .../diy2/vtkdiy2/include/vtkdiy2/link.hpp | 2 +- + .../diy2/vtkdiy2/include/vtkdiy2/log.hpp | 8 +- + .../diy2/vtkdiy2/include/vtkdiy2/master.hpp | 762 ++-- + .../diy2/vtkdiy2/include/vtkdiy2/mpi.hpp | 61 +- + .../include/vtkdiy2/mpi/collectives.cpp | 161 + + .../include/vtkdiy2/mpi/collectives.hpp | 337 +- + .../include/vtkdiy2/mpi/communicator.cpp | 130 + + .../include/vtkdiy2/mpi/communicator.hpp | 178 +- + .../vtkdiy2/include/vtkdiy2/mpi/config.hpp | 85 + + .../vtkdiy2/include/vtkdiy2/mpi/constants.hpp | 13 - + .../vtkdiy2/include/vtkdiy2/mpi/datatypes.cpp | 34 + + .../vtkdiy2/include/vtkdiy2/mpi/datatypes.hpp | 85 +- + .../include/vtkdiy2/mpi/diy-mpi-export.h | 49 + + .../include/vtkdiy2/mpi/environment.cpp | 62 + + .../include/vtkdiy2/mpi/environment.hpp | 35 + + .../diy2/vtkdiy2/include/vtkdiy2/mpi/io.cpp | 222 + + .../diy2/vtkdiy2/include/vtkdiy2/mpi/io.hpp | 195 +- + .../vtkdiy2/include/vtkdiy2/mpi/mpi_cast.hpp | 39 + + .../include/vtkdiy2/mpi/mpitypes.hpp.in | 80 + + .../vtkdiy2/include/vtkdiy2/mpi/no-mpi.hpp | 44 +- + .../include/vtkdiy2/mpi/operations.cpp | 33 + + .../include/vtkdiy2/mpi/operations.hpp | 55 +- + .../vtkdiy2/include/vtkdiy2/mpi/optional.hpp | 7 +- + .../include/vtkdiy2/mpi/point-to-point.cpp | 106 + + .../include/vtkdiy2/mpi/point-to-point.hpp | 191 +- + .../vtkdiy2/include/vtkdiy2/mpi/request.cpp | 45 + + .../vtkdiy2/include/vtkdiy2/mpi/request.hpp | 53 +- + .../vtkdiy2/include/vtkdiy2/mpi/status.cpp | 30 + + .../vtkdiy2/include/vtkdiy2/mpi/status.hpp | 61 +- + .../vtkdiy2/include/vtkdiy2/mpi/window.cpp | 226 + + .../vtkdiy2/include/vtkdiy2/mpi/window.hpp | 248 +- + .../vtkdiy2/include/vtkdiy2/no-thread.hpp | 7 + + .../diy2/vtkdiy2/include/vtkdiy2/proxy.hpp | 141 +- + .../diy2/vtkdiy2/include/vtkdiy2/reduce.hpp | 26 +- + .../diy2/vtkdiy2/include/vtkdiy2/resolve.hpp | 6 +- + .../vtkdiy2/include/vtkdiy2/serialization.hpp | 132 +- + .../diy2/vtkdiy2/include/vtkdiy2/stats.hpp | 6 +- + .../diy2/vtkdiy2/include/vtkdiy2/storage.hpp | 16 +- + .../vtkdiy2/{ => thirdparty}/fmt/chrono.h | 465 +- + .../vtkdiy2/{ => thirdparty}/fmt/color.h | 176 +- + .../include/vtkdiy2/thirdparty/fmt/compile.h | 701 +++ + .../include/vtkdiy2/thirdparty/fmt/core.h | 2122 +++++++++ + .../vtkdiy2/thirdparty/fmt/format-inl.h | 2801 ++++++++++++ + .../vtkdiy2/{ => thirdparty}/fmt/format.cc | 2 +- + .../include/vtkdiy2/thirdparty/fmt/format.h | 3962 +++++++++++++++++ + .../include/vtkdiy2/thirdparty/fmt/locale.h | 64 + + .../{fmt/posix.h => thirdparty/fmt/os.h} | 247 +- + .../vtkdiy2/{ => thirdparty}/fmt/ostream.h | 87 +- + .../vtkdiy2/{ => thirdparty}/fmt/posix.cc | 2 +- + .../include/vtkdiy2/thirdparty/fmt/posix.h | 2 + + .../vtkdiy2/{ => thirdparty}/fmt/printf.h | 240 +- + .../vtkdiy2/{ => thirdparty}/fmt/ranges.h | 186 +- + .../{ => thirdparty}/fmt/safe-duration-cast.h | 0 + .../{ => thirdparty}/itlib/small_vector.hpp | 0 + .../{ => thirdparty}/thread/fast_mutex.h | 0 + .../diy2/vtkdiy2/include/vtkdiy2/thread.hpp | 67 +- + .../diy2/vtkdiy2/include/vtkdiy2/time.hpp | 6 +- + .../diy2/vtkdiy2/include/vtkdiy2/types.hpp | 46 +- + 88 files changed, 13630 insertions(+), 8918 deletions(-) + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-dud.hpp + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/compile.h + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/core.h + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format-inl.h + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format.h + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/locale.h + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/collectives.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/communicator.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/config.hpp + delete mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/constants.hpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/datatypes.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/diy-mpi-export.h + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/environment.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/environment.hpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/io.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/mpi_cast.hpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/mpitypes.hpp.in + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/operations.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/point-to-point.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/request.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/status.cpp + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/mpi/window.cpp + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/chrono.h (60%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/color.h (81%) + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/compile.h + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/core.h + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/format-inl.h + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/format.cc (98%) + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/format.h + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/locale.h + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{fmt/posix.h => thirdparty/fmt/os.h} (55%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/ostream.h (55%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/posix.cc (99%) + create mode 100644 ThirdParty/diy2/vtkdiy2/include/vtkdiy2/thirdparty/fmt/posix.h + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/printf.h (71%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/ranges.h (58%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/fmt/safe-duration-cast.h (100%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/itlib/small_vector.hpp (100%) + rename ThirdParty/diy2/vtkdiy2/include/vtkdiy2/{ => thirdparty}/thread/fast_mutex.h (100%) + +diff --git a/ThirdParty/diy2/CMakeLists.txt b/ThirdParty/diy2/CMakeLists.txt +index eae3176494..e1c4df17f2 100644 +--- a/ThirdParty/diy2/CMakeLists.txt ++++ b/ThirdParty/diy2/CMakeLists.txt +@@ -18,9 +18,9 @@ if (TARGET VTK::mpi) + INTERFACE + VTK::mpi) + +- set(DIY_NO_MPI FALSE) ++ set(DIY_HAS_MPI TRUE) + else () +- set(DIY_NO_MPI TRUE) ++ set(DIY_HAS_MPI FALSE) + endif () + + configure_file( +diff --git a/ThirdParty/diy2/vtk_diy2.h.in b/ThirdParty/diy2/vtk_diy2.h.in +index c4030ba820..51acbde37c 100644 +--- a/ThirdParty/diy2/vtk_diy2.h.in ++++ b/ThirdParty/diy2/vtk_diy2.h.in +@@ -7,7 +7,7 @@ + #cmakedefine01 VTK_MODULE_USE_EXTERNAL_vtkdiy2 + + /* enable/disable DIY MPI */ +-#cmakedefine DIY_NO_MPI ++#cmakedefine01 DIY_HAS_MPI + + #if VTK_MODULE_USE_EXTERNAL_vtkdiy2 + # define VTK_DIY2(header)
+diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/algorithms.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/algorithms.hpp +index 13a9b0ee73..bdf3de9695 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/algorithms.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/algorithms.hpp +@@ -86,7 +86,7 @@ namespace diy + + typedef diy::RegularContinuousLink RCLink; + +- for (size_t i = 0; i < master.size(); ++i) ++ for (int i = 0; i < static_cast(master.size()); ++i) + { + RCLink* link = static_cast(master.link(i)); + *link = RCLink(dim, domain, domain); +@@ -122,7 +122,7 @@ namespace diy + + // update master.expected to match the links + int expected = 0; +- for (size_t i = 0; i < master.size(); ++i) ++ for (int i = 0; i < static_cast(master.size()); ++i) + expected += master.link(i)->size_unique(); + master.set_expected(expected); + } +@@ -146,7 +146,7 @@ namespace diy + + typedef diy::RegularContinuousLink RCLink; + +- for (size_t i = 0; i < master.size(); ++i) ++ for (int i = 0; i < static_cast(master.size()); ++i) + { + RCLink* link = static_cast(master.link(i)); + *link = RCLink(dim, domain, domain); +@@ -182,7 +182,7 @@ namespace diy + + // update master.expected to match the links + int expected = 0; +- for (size_t i = 0; i < master.size(); ++i) ++ for (int i = 0; i < static_cast(master.size()); ++i) + expected += master.link(i)->size_unique(); + master.set_expected(expected); + } +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/assigner.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/assigner.hpp +index 955a7a6f2f..d117919bae 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/assigner.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/assigner.hpp +@@ -109,7 +109,7 @@ namespace diy + Assigner(size__, nblocks__), + comm_(comm), + div_(nblocks__ / size__ + ((nblocks__ % size__) == 0 ? 0 : 1)), // NB: same size window everywhere means the last rank may allocate extra space +- rank_map_(comm_, div_) { rank_map_.lock_all(MPI_MODE_NOCHECK); } ++ rank_map_(comm_, div_) { rank_map_.lock_all(mpi::nocheck); } + ~DynamicAssigner() { rank_map_.unlock_all(); } + + inline +@@ -189,7 +189,7 @@ set_nblocks(int nblocks__) + + rank_map_.unlock_all(); + rank_map_ = mpi::window(comm_, div_); +- rank_map_.lock_all(MPI_MODE_NOCHECK); ++ rank_map_.lock_all(mpi::nocheck); + } + + std::tuple +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/collection.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/collection.hpp +index c327d7ab50..742ac94f8f 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/collection.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/collection.hpp +@@ -17,10 +17,10 @@ namespace diy + typedef std::vector Elements; + typedef critical_resource CInt; + +- typedef void* (*Create)(); +- typedef void (*Destroy)(void*); +- typedef detail::Save Save; +- typedef detail::Load Load; ++ using Create = std::function; ++ using Destroy = std::function; ++ using Save = detail::Save; ++ using Load = detail::Load; + + public: + Collection(Create create__, +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/critical-resource.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/critical-resource.hpp +index 45c5ccadc4..e6dd5047e1 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/critical-resource.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/critical-resource.hpp +@@ -17,6 +17,9 @@ namespace diy + const T& operator*() const { return x_; } + const T* operator->() const { return &x_; } + ++ void lock() { lock_.lock(); } ++ void unlock() { lock_.unlock(); } ++ + private: + T& x_; + lock_guard lock_; +@@ -33,6 +36,8 @@ namespace diy + critical_resource() {} + critical_resource(const T& x): + x_(x) {} ++ critical_resource(T&& x): ++ x_(std::move(x)) {} + + accessor access() { return accessor(x_, m_); } + const_accessor const_access() const { return const_accessor(x_, m_); } +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/decomposition.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/decomposition.hpp +index e1d624ca95..12f86437c5 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/decomposition.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/decomposition.hpp +@@ -63,8 +63,8 @@ namespace detail + static Coordinate from(int i, int n, Coordinate min, Coordinate max, bool) { return min + (max - min)/n * i; } + static Coordinate to (int i, int n, Coordinate min, Coordinate max, bool) { return min + (max - min)/n * (i+1); } + +- static int lower(Coordinate x, int n, Coordinate min, Coordinate max, bool) { Coordinate width = (max - min)/n; Coordinate res = std::floor((x - min)/width); if (min + res*width == x) return (res - 1); else return res; } +- static int upper(Coordinate x, int n, Coordinate min, Coordinate max, bool) { Coordinate width = (max - min)/n; Coordinate res = std::ceil ((x - min)/width); if (min + res*width == x) return (res + 1); else return res; } ++ static int lower(Coordinate x, int n, Coordinate min, Coordinate max, bool) { Coordinate width = (max - min)/n; auto res = static_cast(std::floor((x - min)/width)); if (min + res*width == x) return (res - 1); else return res; } ++ static int upper(Coordinate x, int n, Coordinate min, Coordinate max, bool) { Coordinate width = (max - min)/n; auto res = static_cast(std::ceil ((x - min)/width)); if (min + res*width == x) return (res + 1); else return res; } + }; + } + +@@ -123,6 +123,7 @@ namespace detail + template + int lowest_gid(const Point& p) const; + ++ DivisionsVector gid_to_coords(int gid) const { DivisionsVector coords; gid_to_coords(gid, coords); return coords; } + void gid_to_coords(int gid, DivisionsVector& coords) const { gid_to_coords(gid, coords, divisions); } + int coords_to_gid(const DivisionsVector& coords) const { return coords_to_gid(coords, divisions); } + void fill_divisions(std::vector& divisions) const; +@@ -131,8 +132,8 @@ namespace detail + void fill_bounds(Bounds& bounds, int gid, bool add_ghosts = false) const; + + static bool all(const std::vector& v, int x); +- static void gid_to_coords(int gid, DivisionsVector& coords, const DivisionsVector& divisions); +- static int coords_to_gid(const DivisionsVector& coords, const DivisionsVector& divisions); ++ static void gid_to_coords(int gid, DivisionsVector& coords, const DivisionsVector& divs); ++ static int coords_to_gid(const DivisionsVector& coords, const DivisionsVector& divs); + + static void factor(std::vector& factors, int n); + +@@ -409,25 +410,25 @@ all(const std::vector& v, int x) + template + void + diy::RegularDecomposer:: +-gid_to_coords(int gid, DivisionsVector& coords, const DivisionsVector& divisions) ++gid_to_coords(int gid, DivisionsVector& coords, const DivisionsVector& divs) + { +- int dim = static_cast(divisions.size()); +- for (int i = 0; i < dim; ++i) ++ coords.clear(); ++ for (int i = 0; i < static_cast(divs.size()); ++i) + { +- coords.push_back(gid % divisions[i]); +- gid /= divisions[i]; ++ coords.push_back(gid % divs[i]); ++ gid /= divs[i]; + } + } + + template + int + diy::RegularDecomposer:: +-coords_to_gid(const DivisionsVector& coords, const DivisionsVector& divisions) ++coords_to_gid(const DivisionsVector& coords, const DivisionsVector& divs) + { + int gid = 0; + for (int i = static_cast(coords.size()) - 1; i >= 0; --i) + { +- gid *= divisions[i]; ++ gid *= divs[i]; + gid += coords[i]; + } + return gid; +@@ -552,8 +553,7 @@ fill_divisions(std::vector& divisions_) const + } + + // iterate over factorization of number of blocks (factors are sorted smallest to largest) +- // NB: using int instead of size_t because must be negative in order to break out of loop +- for (int i = factors.size() - 1; i >= 0; --i) ++ for (auto f = factors.rbegin(); f != factors.rend(); ++f) + { + // fill in missing divs by dividing dimension w/ largest block size + // except when this would be illegal (resulting in bounds.max < bounds.min; +@@ -565,19 +565,19 @@ fill_divisions(std::vector& divisions_) const + // split the dimension with the largest block size (first element in vector) + Coordinate min = + detail::BoundsHelper::from(0, +- missing_divs[0].nb * factors[i], ++ missing_divs[0].nb * (*f), + domain.min[missing_divs[0].dim], + domain.max[missing_divs[0].dim], + share_face[missing_divs[0].dim]); + Coordinate max = + detail::BoundsHelper::to(0, +- missing_divs[0].nb * factors[i], ++ missing_divs[0].nb * (*f), + domain.min[missing_divs[0].dim], + domain.max[missing_divs[0].dim], + share_face[missing_divs[0].dim]); + if (max >= min) + { +- missing_divs[0].nb *= factors[i]; ++ missing_divs[0].nb *= (*f); + missing_divs[0].b_size = max - min; + } + else +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree-sampling.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree-sampling.hpp +index 2a99ced517..6b3cf38237 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree-sampling.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree-sampling.hpp +@@ -74,7 +74,7 @@ operator()(Block* b, const diy::ReduceProxy& srp, const KDTreePartners& partners + dim = partners.dim(srp.round() - 1); + + if (srp.round() == partners.rounds()) +- update_links(b, srp, dim, partners.sub_round(srp.round() - 2), partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round ++ update_links(b, srp, dim, partners.sub_round((int)srp.round() - 2), (int)partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round + else if (partners.swap_round(srp.round()) && partners.sub_round(srp.round()) < 0) // link round + { + dequeue_exchange(b, srp, dim); // from the swap round +@@ -92,7 +92,7 @@ operator()(Block* b, const diy::ReduceProxy& srp, const KDTreePartners& partners + int prev_dim = dim - 1; + if (prev_dim < 0) + prev_dim += dim_; +- update_links(b, srp, prev_dim, partners.sub_round(srp.round() - 2), partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round ++ update_links(b, srp, prev_dim, partners.sub_round((int)srp.round() - 2), (int)partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round + } + + compute_local_samples(b, srp, dim); +@@ -134,7 +134,7 @@ divide_gid(int gid, bool lower, int round, int rounds) const + template + void + diy::detail::KDTreeSamplingPartition:: +-update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const ++update_links(Block*, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const + { + auto log = get_logger(); + int gid = srp.gid(); +@@ -253,7 +253,7 @@ update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int roun + template + void + diy::detail::KDTreeSamplingPartition:: +-split_to_neighbors(Block* b, const diy::ReduceProxy& srp, int dim) const ++split_to_neighbors(Block*, const diy::ReduceProxy& srp, int) const + { + int lid = srp.master()->lid(srp.gid()); + RCLink* link = static_cast(srp.master()->link(lid)); +@@ -290,7 +290,7 @@ compute_local_samples(Block* b, const diy::ReduceProxy& srp, int dim) const + template + void + diy::detail::KDTreeSamplingPartition:: +-add_samples(Block* b, const diy::ReduceProxy& srp, Samples& samples) const ++add_samples(Block*, const diy::ReduceProxy& srp, Samples& samples) const + { + // dequeue and combine the samples + for (int i = 0; i < srp.in_link().size(); ++i) +@@ -307,7 +307,7 @@ add_samples(Block* b, const diy::ReduceProxy& srp, Samples& samples) const + template + void + diy::detail::KDTreeSamplingPartition:: +-receive_samples(Block* b, const diy::ReduceProxy& srp, Samples& samples) const ++receive_samples(Block*, const diy::ReduceProxy& srp, Samples& samples) const + { + srp.dequeue(srp.in_link().target(0).gid, samples); + } +@@ -315,7 +315,7 @@ receive_samples(Block* b, const diy::ReduceProxy& srp, Samples& samples) const + template + void + diy::detail::KDTreeSamplingPartition:: +-forward_samples(Block* b, const diy::ReduceProxy& srp, const Samples& samples) const ++forward_samples(Block*, const diy::ReduceProxy& srp, const Samples& samples) const + { + for (int i = 0; i < srp.out_link().size(); ++i) + srp.enqueue(srp.out_link().target(i), samples); +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree.hpp +index 2a46c40010..3754c868cb 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/kdtree.hpp +@@ -68,10 +68,10 @@ struct diy::detail::KDTreePartners + wrap(wrap_), + domain(domain_) + { +- for (unsigned i = 0; i < swap.rounds(); ++i) ++ for (int i = 0; i < swap.rounds(); ++i) + { + // fill histogram rounds +- for (unsigned j = 0; j < histogram.rounds(); ++j) ++ for (int j = 0; j < histogram.rounds(); ++j) + { + rounds_.push_back(std::make_pair(false, j)); + dim_.push_back(i % dim); +@@ -115,7 +115,7 @@ struct diy::detail::KDTreePartners + else if (swap_round(round) && sub_round(round) < 0) // link round + swap.incoming(sub_round(round - 1) + 1, gid, partners, m); + else if (swap_round(round)) +- histogram.incoming(histogram.rounds(), gid, partners, m); ++ histogram.incoming(static_cast(histogram.rounds()), gid, partners, m); + else + { + if (round > 0 && sub_round(round) == 0) +@@ -177,7 +177,7 @@ operator()(Block* b, const diy::ReduceProxy& srp, const KDTreePartners& partners + dim = partners.dim(srp.round() - 1); + + if (srp.round() == partners.rounds()) +- update_links(b, srp, dim, partners.sub_round(srp.round() - 2), partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round ++ update_links(b, srp, dim, partners.sub_round((int)srp.round() - 2), (int)partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round + else if (partners.swap_round(srp.round()) && partners.sub_round(srp.round()) < 0) // link round + { + dequeue_exchange(b, srp, dim); // from the swap round +@@ -195,7 +195,7 @@ operator()(Block* b, const diy::ReduceProxy& srp, const KDTreePartners& partners + int prev_dim = dim - 1; + if (prev_dim < 0) + prev_dim += dim_; +- update_links(b, srp, prev_dim, partners.sub_round(srp.round() - 2), partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round ++ update_links(b, srp, prev_dim, partners.sub_round((int)srp.round() - 2), (int)partners.swap_rounds(), partners.wrap, partners.domain); // -1 would be the "uninformative" link round + } + + compute_local_histogram(b, srp, dim); +@@ -229,7 +229,7 @@ divide_gid(int gid, bool lower, int round, int rounds) const + template + void + diy::detail::KDTreePartition:: +-update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const ++update_links(Block*, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const + { + int gid = srp.gid(); + int lid = srp.master()->lid(gid); +@@ -346,7 +346,7 @@ update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int roun + template + void + diy::detail::KDTreePartition:: +-split_to_neighbors(Block* b, const diy::ReduceProxy& srp, int dim) const ++split_to_neighbors(Block*, const diy::ReduceProxy& srp, int) const + { + int lid = srp.master()->lid(srp.gid()); + RCLink* link = static_cast(srp.master()->link(lid)); +@@ -366,20 +366,23 @@ void + diy::detail::KDTreePartition:: + compute_local_histogram(Block* b, const diy::ReduceProxy& srp, int dim) const + { ++ auto udim = static_cast(dim); + int lid = srp.master()->lid(srp.gid()); + RCLink* link = static_cast(srp.master()->link(lid)); + + // compute and enqueue local histogram + Histogram histogram(bins_); + +- float width = (link->core().max[dim] - link->core().min[dim])/bins_; ++ float width = (link->core().max[udim] - link->core().min[udim])/bins_; + for (size_t i = 0; i < (b->*points_).size(); ++i) + { +- float x = (b->*points_)[i][dim]; +- int loc = (x - link->core().min[dim]) / width; +- if (loc < 0) +- throw std::runtime_error(fmt::format("{} {} {}", loc, x, link->core().min[dim])); +- if (loc >= (int) bins_) ++ float x = (b->*points_)[i][udim]; ++ float floc = (x - link->core().min[udim]) / width; ++ if (floc < 0) ++ throw std::runtime_error(fmt::format("{} {} {}", floc, x, link->core().min[udim])); ++ ++ auto loc = static_cast(floc); ++ if (loc >= bins_) + loc = bins_ - 1; + ++(histogram[loc]); + } +@@ -390,7 +393,7 @@ compute_local_histogram(Block* b, const diy::ReduceProxy& srp, int dim) const + template + void + diy::detail::KDTreePartition:: +-add_histogram(Block* b, const diy::ReduceProxy& srp, Histogram& histogram) const ++add_histogram(Block*, const diy::ReduceProxy& srp, Histogram& histogram) const + { + // dequeue and add up the histograms + for (int i = 0; i < srp.in_link().size(); ++i) +@@ -407,7 +410,7 @@ add_histogram(Block* b, const diy::ReduceProxy& srp, Histogram& histogram) const + template + void + diy::detail::KDTreePartition:: +-receive_histogram(Block* b, const diy::ReduceProxy& srp, Histogram& histogram) const ++receive_histogram(Block*, const diy::ReduceProxy& srp, Histogram& histogram) const + { + srp.dequeue(srp.in_link().target(0).gid, histogram); + } +@@ -415,7 +418,7 @@ receive_histogram(Block* b, const diy::ReduceProxy& srp, Histogram& histogram) c + template + void + diy::detail::KDTreePartition:: +-forward_histogram(Block* b, const diy::ReduceProxy& srp, const Histogram& histogram) const ++forward_histogram(Block*, const diy::ReduceProxy& srp, const Histogram& histogram) const + { + for (int i = 0; i < srp.out_link().size(); ++i) + srp.enqueue(srp.out_link().target(i), histogram); +@@ -445,22 +448,26 @@ enqueue_exchange(Block* b, const diy::ReduceProxy& srp, int dim, const Histogram + size_t cur = 0; + float width = (link->core().max[dim] - link->core().min[dim])/bins_; + float split = 0; +- size_t i = 0; +- for (; i < histogram.size(); ++i) ++ ++ // scope-block for variable `i` + { +- if (cur + histogram[i] > total/2) +- break; +- cur += histogram[i]; ++ size_t i = 0; ++ for (; i < histogram.size(); ++i) ++ { ++ if (cur + histogram[i] > total/2) ++ break; ++ cur += histogram[i]; ++ } ++ if (i == 0) ++ ++i; ++ else if (i >= histogram.size() - 1) ++ i = histogram.size() - 2; ++ split = link->core().min[dim] + width*i; ++ log->trace("Found split: {} (dim={}) in {} - {}", split, dim, link->core().min[dim], link->core().max[dim]); + } +- if (i == 0) +- ++i; +- else if (i >= histogram.size() - 1) +- i = histogram.size() - 2; +- split = link->core().min[dim] + width*i; +- log->trace("Found split: {} (dim={}) in {} - {}", split, dim, link->core().min[dim], link->core().max[dim]); + + // subset and enqueue +- std::vector< std::vector > out_points(srp.out_link().size()); ++ std::vector< std::vector > out_points(static_cast(srp.out_link().size())); + for (size_t i = 0; i < (b->*points_).size(); ++i) + { + float x = (b->*points_)[i][dim]; +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/sort.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/sort.hpp +index 3e9ffd82f3..e1c83c7640 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/sort.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/algorithms/sort.hpp +@@ -85,29 +85,29 @@ struct SampleSort::Sampler + Sampler(ValuesVector values_, ValuesVector dividers_, const Cmp& cmp_, size_t num_samples_): + values(values_), dividers(dividers_), cmp(cmp_), num_samples(num_samples_) {} + +- void operator()(Block* b, const ReduceProxy& srp, const RegularSwapPartners& partners) const ++ void operator()(Block* b, const ReduceProxy& srp, const RegularSwapPartners&) const + { + int k_in = srp.in_link().size(); + int k_out = srp.out_link().size(); + +- std::vector samples; ++ std::vector samps; + + if (k_in == 0) + { + // draw random samples + for (size_t i = 0; i < num_samples; ++i) +- samples.push_back((b->*values)[std::rand() % (b->*values).size()]); ++ samps.push_back((b->*values)[std::rand() % (b->*values).size()]); + } else +- dequeue_values(samples, srp, false); ++ dequeue_values(samps, srp, false); + + if (k_out == 0) + { + // pick subsamples that separate quantiles +- std::sort(samples.begin(), samples.end(), cmp); ++ std::sort(samps.begin(), samps.end(), cmp); + std::vector subsamples(srp.nblocks() - 1); +- int step = samples.size() / srp.nblocks(); // NB: subsamples.size() + 1 ++ size_t step = samps.size() / srp.nblocks(); // NB: subsamples.size() + 1 + for (size_t i = 0; i < subsamples.size(); ++i) +- subsamples[i] = samples[(i+1)*step]; ++ subsamples[i] = samps[(i+1)*step]; + (b->*dividers).swap(subsamples); + } + else +@@ -115,7 +115,7 @@ struct SampleSort::Sampler + for (int i = 0; i < k_out; ++i) + { + MemoryBuffer& out = srp.outgoing(srp.out_link().target(i)); +- save(out, &samples[0], samples.size()); ++ save(out, &samps[0], samps.size()); + } + } + } +@@ -139,7 +139,7 @@ struct SampleSort::Exchanger + // enqueue values to the correct locations + for (size_t i = 0; i < (b->*values).size(); ++i) + { +- int to = std::lower_bound((b->*samples).begin(), (b->*samples).end(), (b->*values)[i], cmp) - (b->*samples).begin(); ++ int to = static_cast(std::lower_bound((b->*samples).begin(), (b->*samples).end(), (b->*values)[i], cmp) - (b->*samples).begin()); + rp.enqueue(rp.out_link().target(to), (b->*values)[i]); + } + (b->*values).clear(); +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/collectives.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/collectives.hpp +index 303ba74a6e..c98aef2a11 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/collectives.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/collectives.hpp +@@ -20,7 +20,7 @@ namespace diy + + void init() { out_ = in_; } + void update(const CollectiveOp& other) { out_ = op_(out_, static_cast(other).in_); } +- void global(const mpi::communicator& comm) { T res; mpi::all_reduce(comm, out_, res, op_); out_ = res; } ++ void global(const mpi::communicator& comm) { T res{}; mpi::all_reduce(comm, out_, res, op_); out_ = res; } + void copy_from(const CollectiveOp& other) { out_ = static_cast(other).out_; } + void result_out(void* dest) const { *reinterpret_cast(dest) = out_; } + +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/communication.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/communication.hpp +index 51cc435b28..1f6b0800fa 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/communication.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/communication.hpp +@@ -5,11 +5,13 @@ namespace diy + int from, to; + int nparts; + int round; ++ int nblobs; + }; + + struct Master::InFlightSend + { + std::shared_ptr message; ++ BinaryBlob blob; + mpi::request request; + + MessageInfo info; // for debug purposes +@@ -18,12 +20,18 @@ namespace diy + struct Master::InFlightRecv + { + MemoryBuffer message; +- MessageInfo info { -1, -1, -1, -1 }; ++ MessageInfo info { -1, -1, -1, -1, -1 }; + bool done = false; ++ MemoryManagement mem; + + inline bool recv(mpi::communicator& comm, const mpi::status& status); + inline void place(IncomingRound* in, bool unload, ExternalStorage* storage, IExchangeInfo* iexchange); +- void reset() { *this = InFlightRecv(); } ++ void reset() ++ { ++ MemoryManagement mem_ = mem; ++ *this = InFlightRecv(); ++ mem = mem_; ++ } + }; + + struct Master::InFlightRecvsMap: public std::map +@@ -63,7 +71,7 @@ namespace diy + struct mpi_datatype< diy::detail::VectorWindow > + { + using VecWin = diy::detail::VectorWindow; +- static MPI_Datatype datatype() { return get_mpi_datatype(); } ++ static diy::mpi::datatype datatype() { return get_mpi_datatype(); } + static const void* address(const VecWin& x) { return x.begin; } + static void* address(VecWin& x) { return x.begin; } + static int count(const VecWin& x) { return static_cast(x.count); } +@@ -111,7 +119,7 @@ recv(mpi::communicator& comm, const mpi::status& status) + + result = true; + } +- else ++ else if (info.nparts > 0) + { + size_t start_idx = message.buffer.size(); + size_t count = status.count(); +@@ -124,9 +132,24 @@ recv(mpi::communicator& comm, const mpi::status& status) + comm.recv(status.source(), status.tag(), window); + + info.nparts--; ++ } else if (info.nblobs > 0) ++ { ++ size_t count = status.count(); ++ detail::VectorWindow window; ++ ++ char* buffer = mem.allocate(info.to, count); ++ ++ window.begin = buffer; ++ window.count = count; ++ ++ comm.recv(status.source(), status.tag(), window); ++ ++ message.save_binary_blob(buffer, count, mem.deallocate); ++ ++ info.nblobs--; + } + +- if (info.nparts == 0) ++ if (info.nparts == 0 && info.nblobs == 0) + done = true; + + return result; +@@ -135,35 +158,21 @@ recv(mpi::communicator& comm, const mpi::status& status) + // once the InFlightRecv is done, place it either out of core or in the appropriate incoming queue + void + diy::Master::InFlightRecv:: +-place(IncomingRound* in, bool unload, ExternalStorage* storage, IExchangeInfo* iexchange) ++place(IncomingRound* in, bool unload, ExternalStorage* storage, IExchangeInfo*) + { +- size_t size = message.size(); + int from = info.from; + int to = info.to; +- int external = -1; ++ ++ message.reset(); ++ ++ auto access = in->map[to][from].access(); ++ access->emplace_back(std::move(message)); + + if (unload) + { + get_logger()->debug("Directly unloading queue {} <- {}", to, from); +- external = storage->put(message); // unload directly +- } +- else if (!iexchange) +- { +- in->map[to].queues[from].swap(message); +- in->map[to].queues[from].reset(); // buffer position = 0 +- } +- else // iexchange +- { +- auto log = get_logger(); +- log->debug("[{}] Received queue {} <- {}", iexchange->comm.rank(), to, from); +- +- iexchange->not_done(to); +- in->map[to].queues[from].append_binary(&message.buffer[0], message.size()); // append instead of overwrite +- +- iexchange->dec_work(); +- log->debug("[{}] Decrementing work after receiving\n", to); ++ access->back().unload(storage); + } +- in->map[to].records[from] = QueueRecord(size, external); + + ++(in->received); + } +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/execution.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/execution.hpp +index 8f9c0dbb8b..d74d25cc0f 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/execution.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/execution.hpp +@@ -1,3 +1,5 @@ ++#include ++ + struct diy::Master::ProcessBlock + { + ProcessBlock(Master& master_, +@@ -61,8 +63,7 @@ struct diy::Master::ProcessBlock + cmd->execute(skip ? 0 : master.block(i), master.proxy(i)); + + // no longer need them, so get rid of them +- current_incoming[gid].queues.clear(); +- current_incoming[gid].records.clear(); ++ current_incoming[gid].clear(); + } + + if (skip && master.block(i) == 0) +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-collective.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-collective.hpp +index 575519af72..ad7a9fb261 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-collective.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-collective.hpp +@@ -1,18 +1,26 @@ ++#include ++ + namespace diy + { + struct Master::IExchangeInfoCollective: public IExchangeInfo + { +- using IExchangeInfo::IExchangeInfo; ++ IExchangeInfoCollective(mpi::communicator c, stats::Profiler& p): ++ IExchangeInfo(c, p) ++ { ++ local_work_ = 0; ++ dirty = 0; ++ state = 0; ++ } + + inline bool all_done() override; // get global all done status + inline void add_work(int work) override; // add work to global work counter + inline void control() override; + +- int local_work_ = 0; +- int dirty = 0; ++ std::atomic local_work_; ++ std::atomic dirty; + int local_dirty, all_dirty; + +- int state = 0; ++ std::atomic state; + mpi::request r; + + // debug +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-dud.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-dud.hpp +deleted file mode 100644 +index 050c2e3a18..0000000000 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange-dud.hpp ++++ /dev/null +@@ -1,338 +0,0 @@ +-namespace diy +-{ +- struct Master::IExchangeInfoDUD: public IExchangeInfo +- { +- struct Message +- { +- std::array msg; +- mpi::request request; +- }; +- +- using IExchangeInfo::IExchangeInfo; +- +- inline bool all_done() override; // get global all done status +- inline void add_work(int work) override; // add work to global work counter +- inline void control() override; +- inline void update_subtree(int diff); +- inline bool process_work_update(); +- inline void check_for_abort(); +- inline void abort(int trial); +- inline void process_done(int source, int trial); +- inline void reset_child_confirmations(); +- int right_bit(int x) const { return ((x ^ (x-1)) + 1) >> 1; } +- +- void send(int rk, int type, int x) +- { +- inflight_.emplace_back(); +- Message& m = inflight_.back(); +- m.msg[0] = type; +- m.msg[1] = x; +- m.request = comm.issend(rk, tags::iexchange, m.msg); +- log->trace("[{}] Sending to {}, type = {}, x = {}", comm.rank(), rk, type, x); +- } +- void recv(int rk, int& type, int& x) +- { +- std::array msg; +- comm.recv(rk, tags::iexchange, msg); +- type = msg[0]; +- x = msg[1]; +- log->trace("[{}] Received from {}, type = {}, x = {}, msg = {}", comm.rank(), rk, type, x); +- } +- +- inline bool nudge(); +- int parent() const { return comm.rank() & (comm.rank() - 1); } // flip the last 1 to 0 +- inline void signal_children(int tag, int x); +- bool incomplete() const { return subtree_work_ > 0 || !inflight_.empty(); } +- bool stale() const { return subtree_work_ != last_subtree_work_message_ || local_work_ != last_local_work_message_; } +- +- struct type { enum { +- work_update = 0, +- done, +- abort +- }; }; +- std::unordered_map done; // gid -> done +- +- int local_work_ = 0, last_local_work_message_ = 0; +- int subtree_work_ = 0, last_subtree_work_message_ = 0; +- int down_up_down_ = 0; +- +- std::list inflight_; +- int last_trial_ = -1; +- int child_confirmations = -1; +- +- // debug +- bool first_dud = true; +- using IExchangeInfo::prof; +- }; +-} +- +- +-// get global all done status +-bool +-diy::Master::IExchangeInfoDUD:: +-all_done() +-{ +- if (down_up_down_ == 3) +- while (!inflight_.empty()) nudge(); // make sure that all the messages are propagated before we finish +- // if we've decided that we are done, the only outstanding messages +- // can be the done signals to children; nothing else should be in-flight +- +- return down_up_down_ == 3; +-} +- +-// add arbitrary units of work to global work counter +-void +-diy::Master::IExchangeInfoDUD:: +-add_work(int work) +-{ +- int cur_local_work = local_work_; +- local_work_ += work; +- assert(local_work_ >= 0); +- +- log->trace("[{}] Adding work: work = {}, local_work = {}, cur_local_work = {}", comm.rank(), work, local_work_, cur_local_work); +- +- if ((cur_local_work == 0) ^ (local_work_ == 0)) // changed from or to zero +- { +- int diff = (local_work_ - last_local_work_message_); +- update_subtree(diff); +- last_local_work_message_ = local_work_; +- } +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-update_subtree(int diff) +-{ +- int cur_subtree_work = subtree_work_; +- subtree_work_ += diff; +- log->debug("[{}] Updating subtree: diff = {}, subtree_work_ = {}", comm.rank(), diff, subtree_work_); +- assert(subtree_work_ >= 0); +- +- if ((cur_subtree_work == 0) ^ (subtree_work_ == 0)) // changed from or to zero +- { +- if (comm.rank() != 0) +- { +- int subtree_diff = (subtree_work_ - last_subtree_work_message_); +- log->debug("[{}] Sending subtree update: diff = {}, subtree_diff = {}", comm.rank(), diff, subtree_diff); +- send(parent(), type::work_update, subtree_diff); +- last_subtree_work_message_ = subtree_work_; +- if (down_up_down_ == 1) +- abort(last_trial_); +- else if (down_up_down_ == 2) +- log->warn("[{}] Enqueueing work update after finishing, diff = {}", comm.rank(), subtree_diff); +- // This is Ok in general: if this happens, somebody else must abort this trial. +- else if (down_up_down_ == 3) +- log->critical("[{}] Enqueueing work update after all done, diff = {}", comm.rank(), subtree_diff); +- } else +- { +- assert(down_up_down_ < 2); +- down_up_down_ = 0; // if we are updating work on the root, definitely abort the down-up-down protocol +- } +- } +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-control() +-{ +- mpi::optional ostatus = comm.iprobe(mpi::any_source, tags::iexchange); +- while(ostatus) +- { +- int t, x; +- recv(ostatus->source(), t, x); +- if (t == type::work_update) +- { +- // x = diff +- log->debug("[{}] subtree update request from {}, diff = {}", comm.rank(), ostatus->source(), x); +- update_subtree(x); // for now propagates up the tree verbatim +- } else if (t == type::abort) +- { +- // x = trial +- assert(x >= -1); +- abort(x); +- } else if (t == type::done) +- { +- process_done(ostatus->source(), x); +- } +- ostatus = comm.iprobe(mpi::any_source, tags::iexchange); +- } +- +- // initiate down-up-down protocol +- if (subtree_work_ == 0 && comm.rank() == 0 && down_up_down_ == 0) +- { +- // debug +- if (first_dud) +- { +- prof >> "iexchange-control"; // consensus-time cannot nest in iexchange-control +- prof << "consensus-time"; +- prof << "iexchange-control"; +- first_dud = false; +- } +- +- down_up_down_ = 1; +- reset_child_confirmations(); +- if (child_confirmations) +- { +- signal_children(type::done, ++last_trial_); +- log->info("Initiated down-up-down, trial = {}", last_trial_); +- } else // no children +- down_up_down_ = 3; +- } +- +- while(nudge()); +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-abort(int trial) +-{ +- if (down_up_down_ == 0) // already aborted +- return; +- +- if (trial != last_trial_) +- return; +- +- log->warn("[{}] aborting trial {}", comm.rank(), trial); +- assert(trial >= 0); +- +- down_up_down_ = 0; +- +- if (comm.rank() != 0) +- { +- send(parent(), type::abort, trial); // propagate abort +- if (down_up_down_ >= 2) +- log->critical("[{}] sending abort after done", comm.rank()); +- last_trial_ = -1; // all future aborts for this trial will be stale +- } +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-process_done(int source, int trial) +-{ +- if (trial < -1) +- { +- log->critical("[{}] done with source = {}, trial = {}", comm.rank(), source, trial); +- assert(trial >= -1); +- } +- +- while(nudge()); // clear up finished requests: this is necessary since requests may have been received; +- // we are now getting responses to them; but they are still listed in our inflight_ +- +- if (source == parent()) +- { +- if (trial == last_trial_) // confirmation that we are done +- { +- assert(down_up_down_ == 2); +- log->info("[{}] received done confirmation from parent, trial = {}; incomplete = {}, subtree = {}, stale = {}", +- comm.rank(), trial, incomplete(), subtree_work_, stale()); +- down_up_down_ = 3; +- assert(!incomplete() && !stale()); +- } else +- { +- last_trial_ = trial; +- down_up_down_ = 1; +- +- // check that there are no changes +- if (incomplete() || stale()) +- abort(trial); +- } +- +- // pass the message to children +- if (down_up_down_ > 0) +- { +- reset_child_confirmations(); +- if (child_confirmations) +- { +- log->info("[{}] signalling done to children, trial = {}", comm.rank(), trial); +- signal_children(type::done, trial); +- } +- else if (down_up_down_ < 2) // no children, signal back to parent right away, unless it was the final done +- { +- down_up_down_ = 2; +- log->info("[{}] signalling done to parent (1), trial = {}, incomplete = {}", comm.rank(), trial, incomplete()); +- send(parent(), type::done, trial); +- } +- } +- } else // signal from a child +- { +- if (trial == last_trial_) +- { +- int child_mask = right_bit(source); +- child_confirmations &= ~child_mask; +- if (child_confirmations == 0) // done +- { +- if (comm.rank() != 0) +- { +- if (incomplete() || stale()) // heard from all the children, but there is something incomplete +- abort(trial); +- else +- { +- down_up_down_ = 2; +- log->info("[{}] signalling done to parent (2), trial = {}, incomplete = {}", comm.rank(), trial, incomplete()); +- send(parent(), type::done, trial); +- } +- } +- else if (down_up_down_ == 1) +- { +- log->info("[{}] received done confirmation from children at root, trial = {}", comm.rank(), trial); +- // initiate final down +- down_up_down_ = 3; +- signal_children(type::done, trial); +- } +- } +- } // else stale trial confirmation, drop +- } +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-reset_child_confirmations() +-{ +- child_confirmations = 0; +- int child_mask = 1; +- int child = child_mask | comm.rank(); +- while (child != comm.rank() && child < comm.size()) +- { +- child_confirmations |= child_mask; +- +- child_mask <<= 1; +- child = child_mask | comm.rank(); +- } +-} +- +-void +-diy::Master::IExchangeInfoDUD:: +-signal_children(int tag, int x) +-{ +- int child_mask = 1; +- int child = child_mask | comm.rank(); +- while (child != comm.rank() && child < comm.size()) +- { +- send(child, tag, x); +- +- child_mask <<= 1; +- child = child_mask | comm.rank(); +- } +-} +- +-bool +-diy::Master::IExchangeInfoDUD:: +-nudge() +-{ +- bool success = false; +- for (auto it = inflight_.begin(); it != inflight_.end();) +- { +- mpi::optional ostatus = it->request.test(); +- if (ostatus) +- { +- success = true; +- it = inflight_.erase(it); +- } +- else +- ++it; +- } +- return success; +-} +- +- +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange.hpp +index 38fe255c72..1d10c1b728 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/master/iexchange.hpp +@@ -5,17 +5,11 @@ namespace diy + using Clock = std::chrono::high_resolution_clock; + using Time = Clock::time_point; + +- IExchangeInfo(mpi::communicator comm_, size_t min_queue_size, size_t max_hold_time, bool fine, stats::Profiler& prof_): +- comm(comm_), +- fine_(fine), +- min_queue_size_(min_queue_size), +- max_hold_time_(max_hold_time), +- prof(prof_) { time_stamp_send(); } ++ IExchangeInfo(mpi::communicator c, stats::Profiler& p): ++ comm(c), ++ prof(p) {} + virtual ~IExchangeInfo() {} + +- void not_done(int gid) { update_done(gid, false); } +- inline void update_done(int gid, bool done_); +- + virtual bool all_done() =0; // get global all done status + virtual void add_work(int work) =0; // add work to global work counter + virtual void control() =0; +@@ -23,43 +17,12 @@ namespace diy + void inc_work() { add_work(1); } // increment work counter + void dec_work() { add_work(-1); } // decremnent work counter + +- // shortcut +- void time_stamp_send() { time_last_send = Clock::now(); } +- bool hold(size_t queue_size) { return queue_size < min_queue_size_ && hold_time() < max_hold_time_; } +- size_t hold_time() { return std::chrono::duration_cast(Clock::now() - time_last_send).count(); } +- bool fine() const { return fine_; } +- + mpi::communicator comm; +- std::unordered_map done; // gid -> done +- +- bool fine_ = false; + + std::shared_ptr log = get_logger(); +- Time time_last_send; // time of last send from any queue in send_outgoing_queues() +- +- size_t min_queue_size_; // minimum short message size (bytes) +- size_t max_hold_time_; // maximum short message hold time (milliseconds) +- +- int from_gid = -1; // gid of current block, for shortcut sending of only this block's queues +- + stats::Profiler& prof; + }; + } + +-void +-diy::Master::IExchangeInfo:: +-update_done(int gid, bool done_) +-{ +- if (done[gid] != done_) +- { +- done[gid] = done_; +- if (done_) +- dec_work(); +- else +- inc_work(); +- } +-} +- + +-#include "iexchange-dud.hpp" + #include "iexchange-collective.hpp" +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/reduce/all-to-all.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/reduce/all-to-all.hpp +index 7e30825474..5c96de4450 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/reduce/all-to-all.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/detail/reduce/all-to-all.hpp +@@ -23,31 +23,38 @@ namespace detail + } + } + +- void operator()(Block* b, const ReduceProxy& srp, const RegularSwapPartners& partners) const ++ void operator()(Block* b, const ReduceProxy& srp, const RegularSwapPartners&) const + { + int k_in = srp.in_link().size(); + int k_out = srp.out_link().size(); + + if (k_in == 0 && k_out == 0) // special case of a single block + { +- ReduceProxy all_srp_out(srp, srp.block(), 0, srp.assigner(), empty_link, all_neighbors_link); +- ReduceProxy all_srp_in (srp, srp.block(), 1, srp.assigner(), all_neighbors_link, empty_link); ++ ReduceProxy all_srp(std::move(const_cast(srp)), srp.block(), 0, srp.assigner(), empty_link, all_neighbors_link); + +- op(b, all_srp_out); +- MemoryBuffer& in_queue = all_srp_in.incoming(all_srp_in.in_link().target(0).gid); +- in_queue.swap(all_srp_out.outgoing(all_srp_out.out_link().target(0))); ++ op(b, all_srp); ++ ++ MemoryBuffer& in_queue = all_srp.incoming(all_srp.in_link().target(0).gid); ++ in_queue.swap(all_srp.outgoing(all_srp.out_link().target(0))); + in_queue.reset(); ++ all_srp.outgoing()->clear(); ++ ++ // change to incoming proxy ++ all_srp.set_round(1); ++ auto& in_link = const_cast(all_srp.in_link()); ++ auto& out_link = const_cast(all_srp.out_link()); ++ in_link.swap(out_link); + +- op(b, all_srp_in); ++ op(b, all_srp); + return; + } + + if (k_in == 0) // initial round + { +- ReduceProxy all_srp(srp, srp.block(), 0, srp.assigner(), empty_link, all_neighbors_link); ++ ReduceProxy all_srp(std::move(const_cast(srp)), srp.block(), 0, srp.assigner(), empty_link, all_neighbors_link); + op(b, all_srp); + +- Master::OutgoingQueues all_queues; ++ Master::Proxy::OutgoingQueues all_queues; + all_queues.swap(*all_srp.outgoing()); // clears out the queues and stores them locally + + // enqueue outgoing +@@ -67,10 +74,10 @@ namespace detail + } else if (k_out == 0) // final round + { + // dequeue incoming + reorder into the correct order +- ReduceProxy all_srp(srp, srp.block(), 1, srp.assigner(), all_neighbors_link, empty_link); ++ ReduceProxy all_srp(std::move(const_cast(srp)), srp.block(), 1, srp.assigner(), all_neighbors_link, empty_link); + +- Master::IncomingQueues all_incoming; +- all_incoming.swap(*srp.incoming()); ++ Master::Proxy::IncomingQueues all_incoming; ++ all_incoming.swap(*all_srp.incoming()); + + std::pair range; // all the ranges should be the same + for (int i = 0; i < k_in; ++i) +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/dynamic-point.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/dynamic-point.hpp +index 67d52b458a..35dd4b6852 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/dynamic-point.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/dynamic-point.hpp +@@ -7,7 +7,7 @@ + #include + + #include "constants.h" +-#include "itlib/small_vector.hpp" ++#include "thirdparty/itlib/small_vector.hpp" + + namespace diy + { +@@ -23,10 +23,10 @@ class DynamicPoint: public itlib::small_vector + struct rebind { typedef DynamicPoint type; }; + + public: +- DynamicPoint(int dim, Coordinate x = 0): ++ DynamicPoint(size_t dim, Coordinate x = 0): + Parent(dim, x) {} + template DynamicPoint(const DynamicPoint& p) { for (size_t i = 0; i < dimension(); ++i) (*this)[i] = p[i]; } +- template DynamicPoint(const T* a, int dim) { for (size_t i = 0; i < static_cast(dim); ++i) (*this)[i] = a[i]; } ++ template DynamicPoint(const T* a, size_t dim) { for (size_t i = 0; i < dim; ++i) (*this)[i] = a[i]; } + template DynamicPoint(const std::vector& a): + Parent(a.begin(), a.end()) {} + DynamicPoint(std::initializer_list lst): +@@ -36,13 +36,13 @@ class DynamicPoint: public itlib::small_vector + DynamicPoint(const DynamicPoint&) =default; + DynamicPoint& operator=(const DynamicPoint&) =default; + +- unsigned dimension() const { return Parent::size(); } ++ unsigned dimension() const { return static_cast(Parent::size()); } + +- static DynamicPoint zero(int dim) { return DynamicPoint(dim, 0); } +- static DynamicPoint one(int dim) { return DynamicPoint(dim, 1); } ++ static DynamicPoint zero(size_t dim) { return DynamicPoint(dim, 0); } ++ static DynamicPoint one(size_t dim) { return DynamicPoint(dim, 1); } + +- DynamicPoint drop(int dim) const { DynamicPoint p(dimension() - 1); size_t c = 0; for (size_t i = 0; i < dimension(); ++i) { if (i == dim) continue; p[c++] = (*this)[i]; } return p; } +- DynamicPoint lift(int dim, Coordinate x) const { DynamicPoint p(dimension() + 1); for (size_t i = 0; i < dimension()+1; ++i) { if (i < dim) p[i] = (*this)[i]; else if (i == dim) p[i] = x; else if (i > dim) p[i] = (*this)[i-1]; } return p; } ++ DynamicPoint drop(size_t dim) const { DynamicPoint p(dimension() - 1); size_t c = 0; for (size_t i = 0; i < dimension(); ++i) { if (i == dim) continue; p[c++] = (*this)[i]; } return p; } ++ DynamicPoint lift(size_t dim, Coordinate x) const { DynamicPoint p(dimension() + 1); for (size_t i = 0; i < dimension()+1; ++i) { if (i < dim) p[i] = (*this)[i]; else if (i == dim) p[i] = x; else if (i > dim) p[i] = (*this)[i-1]; } return p; } + + using Parent::operator[]; + +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/factory.hpp b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/factory.hpp +index 90d4ff37ff..a89a1eb510 100644 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/factory.hpp ++++ b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/factory.hpp +@@ -26,8 +26,6 @@ class Factory + template + struct Registrar: Base + { +- friend T; +- + static bool registerT() + { + const auto name = typeid(T).name(); +@@ -37,17 +35,29 @@ class Factory + }; + return true; + } +- static bool registered; ++ static volatile bool registered; + + std::string id() const override { return typeid(T).name(); } + ++#if defined(__NVCC__) ++ protected: ++#else + private: ++ friend T; ++#endif ++#if defined(__INTEL_COMPILER) ++ __attribute__ ((used)) ++#endif + Registrar(): Base(Key{}) { (void)registered; } + }; + +- friend Base; + ++#if defined(__NVCC__) ++ protected: ++#else + private: ++ friend Base; ++#endif + class Key + { + Key(){}; +@@ -67,7 +77,7 @@ class Factory + + template + template +-bool Factory::Registrar::registered = Factory::Registrar::registerT(); ++volatile bool Factory::Registrar::registered = Factory::Registrar::registerT(); + + } + +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/compile.h b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/compile.h +deleted file mode 100644 +index 82625bbc65..0000000000 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/compile.h ++++ /dev/null +@@ -1,466 +0,0 @@ +-// Formatting library for C++ - experimental format string compilation +-// +-// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors +-// All rights reserved. +-// +-// For the license information refer to format.h. +- +-#ifndef FMT_COMPILE_H_ +-#define FMT_COMPILE_H_ +- +-#include +-#include "format.h" +- +-FMT_BEGIN_NAMESPACE +-namespace internal { +- +-template struct format_part { +- public: +- struct named_argument_id { +- FMT_CONSTEXPR named_argument_id(internal::string_view_metadata id) +- : id(id) {} +- internal::string_view_metadata id; +- }; +- +- struct argument_id { +- FMT_CONSTEXPR argument_id() : argument_id(0u) {} +- +- FMT_CONSTEXPR argument_id(unsigned id) +- : which(which_arg_id::index), val(id) {} +- +- FMT_CONSTEXPR argument_id(internal::string_view_metadata id) +- : which(which_arg_id::named_index), val(id) {} +- +- enum class which_arg_id { index, named_index }; +- +- which_arg_id which; +- +- union value { +- FMT_CONSTEXPR value() : index(0u) {} +- FMT_CONSTEXPR value(unsigned id) : index(id) {} +- FMT_CONSTEXPR value(internal::string_view_metadata id) +- : named_index(id) {} +- +- unsigned index; +- internal::string_view_metadata named_index; +- } val; +- }; +- +- struct specification { +- FMT_CONSTEXPR specification() : arg_id(0u) {} +- FMT_CONSTEXPR specification(unsigned id) : arg_id(id) {} +- +- FMT_CONSTEXPR specification(internal::string_view_metadata id) +- : arg_id(id) {} +- +- argument_id arg_id; +- internal::dynamic_format_specs parsed_specs; +- }; +- +- FMT_CONSTEXPR format_part() +- : which(kind::argument_id), end_of_argument_id(0u), val(0u) {} +- +- FMT_CONSTEXPR format_part(internal::string_view_metadata text) +- : which(kind::text), end_of_argument_id(0u), val(text) {} +- +- FMT_CONSTEXPR format_part(unsigned id) +- : which(kind::argument_id), end_of_argument_id(0u), val(id) {} +- +- FMT_CONSTEXPR format_part(named_argument_id arg_id) +- : which(kind::named_argument_id), end_of_argument_id(0u), val(arg_id) {} +- +- FMT_CONSTEXPR format_part(specification spec) +- : which(kind::specification), end_of_argument_id(0u), val(spec) {} +- +- enum class kind { argument_id, named_argument_id, text, specification }; +- +- kind which; +- std::size_t end_of_argument_id; +- union value { +- FMT_CONSTEXPR value() : arg_id(0u) {} +- FMT_CONSTEXPR value(unsigned id) : arg_id(id) {} +- FMT_CONSTEXPR value(named_argument_id named_id) +- : named_arg_id(named_id.id) {} +- FMT_CONSTEXPR value(internal::string_view_metadata t) : text(t) {} +- FMT_CONSTEXPR value(specification s) : spec(s) {} +- unsigned arg_id; +- internal::string_view_metadata named_arg_id; +- internal::string_view_metadata text; +- specification spec; +- } val; +-}; +- +-template +-class format_preparation_handler : public internal::error_handler { +- private: +- using part = format_part; +- +- public: +- using iterator = typename basic_string_view::iterator; +- +- FMT_CONSTEXPR format_preparation_handler(basic_string_view format, +- PartsContainer& parts) +- : parts_(parts), format_(format), parse_context_(format) {} +- +- FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { +- if (begin == end) return; +- const auto offset = begin - format_.data(); +- const auto size = end - begin; +- parts_.push_back(part(string_view_metadata(offset, size))); +- } +- +- FMT_CONSTEXPR void on_arg_id() { +- parts_.push_back(part(parse_context_.next_arg_id())); +- } +- +- FMT_CONSTEXPR void on_arg_id(unsigned id) { +- parse_context_.check_arg_id(id); +- parts_.push_back(part(id)); +- } +- +- FMT_CONSTEXPR void on_arg_id(basic_string_view id) { +- const auto view = string_view_metadata(format_, id); +- const auto arg_id = typename part::named_argument_id(view); +- parts_.push_back(part(arg_id)); +- } +- +- FMT_CONSTEXPR void on_replacement_field(const Char* ptr) { +- parts_.back().end_of_argument_id = ptr - format_.begin(); +- } +- +- FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, +- const Char* end) { +- const auto specs_offset = to_unsigned(begin - format_.begin()); +- +- using parse_context = basic_parse_context; +- internal::dynamic_format_specs parsed_specs; +- dynamic_specs_handler handler(parsed_specs, parse_context_); +- begin = parse_format_specs(begin, end, handler); +- +- if (*begin != '}') on_error("missing '}' in format string"); +- +- auto& last_part = parts_.back(); +- auto specs = last_part.which == part::kind::argument_id +- ? typename part::specification(last_part.val.arg_id) +- : typename part::specification(last_part.val.named_arg_id); +- specs.parsed_specs = parsed_specs; +- last_part = part(specs); +- last_part.end_of_argument_id = specs_offset; +- return begin; +- } +- +- private: +- PartsContainer& parts_; +- basic_string_view format_; +- basic_parse_context parse_context_; +-}; +- +-template +-class prepared_format { +- public: +- using char_type = char_t; +- using format_part_t = format_part; +- +- constexpr prepared_format(Format f) +- : format_(std::move(f)), parts_provider_(to_string_view(format_)) {} +- +- prepared_format() = delete; +- +- using context = buffer_context; +- +- template +- auto vformat_to(Range out, basic_format_args args) const -> +- typename Context::iterator { +- const auto format_view = internal::to_string_view(format_); +- basic_parse_context parse_ctx(format_view); +- Context ctx(out.begin(), args); +- +- const auto& parts = parts_provider_.parts(); +- for (auto part_it = parts.begin(); part_it != parts.end(); ++part_it) { +- const auto& part = *part_it; +- const auto& value = part.val; +- +- switch (part.which) { +- case format_part_t::kind::text: { +- const auto text = value.text.to_view(format_view.data()); +- auto output = ctx.out(); +- auto&& it = internal::reserve(output, text.size()); +- it = std::copy_n(text.begin(), text.size(), it); +- ctx.advance_to(output); +- } break; +- +- case format_part_t::kind::argument_id: { +- advance_parse_context_to_specification(parse_ctx, part); +- format_arg(parse_ctx, ctx, value.arg_id); +- } break; +- +- case format_part_t::kind::named_argument_id: { +- advance_parse_context_to_specification(parse_ctx, part); +- const auto named_arg_id = +- value.named_arg_id.to_view(format_view.data()); +- format_arg(parse_ctx, ctx, named_arg_id); +- } break; +- case format_part_t::kind::specification: { +- const auto& arg_id_value = value.spec.arg_id.val; +- const auto arg = value.spec.arg_id.which == +- format_part_t::argument_id::which_arg_id::index +- ? ctx.arg(arg_id_value.index) +- : ctx.arg(arg_id_value.named_index.to_view( +- to_string_view(format_).data())); +- +- auto specs = value.spec.parsed_specs; +- +- handle_dynamic_spec( +- specs.width, specs.width_ref, ctx, format_view.begin()); +- handle_dynamic_spec( +- specs.precision, specs.precision_ref, ctx, format_view.begin()); +- +- check_prepared_specs(specs, arg.type()); +- advance_parse_context_to_specification(parse_ctx, part); +- ctx.advance_to( +- visit_format_arg(arg_formatter(ctx, nullptr, &specs), arg)); +- } break; +- } +- } +- +- return ctx.out(); +- } +- +- private: +- void advance_parse_context_to_specification( +- basic_parse_context& parse_ctx, +- const format_part_t& part) const { +- const auto view = to_string_view(format_); +- const auto specification_begin = view.data() + part.end_of_argument_id; +- advance_to(parse_ctx, specification_begin); +- } +- +- template +- void format_arg(basic_parse_context& parse_ctx, Context& ctx, +- Id arg_id) const { +- parse_ctx.check_arg_id(arg_id); +- const auto stopped_at = +- visit_format_arg(arg_formatter(ctx), ctx.arg(arg_id)); +- ctx.advance_to(stopped_at); +- } +- +- template +- void check_prepared_specs(const basic_format_specs& specs, +- internal::type arg_type) const { +- internal::error_handler h; +- numeric_specs_checker checker(h, arg_type); +- if (specs.align == align::numeric) checker.require_numeric_argument(); +- if (specs.sign != sign::none) checker.check_sign(); +- if (specs.alt) checker.require_numeric_argument(); +- if (specs.precision >= 0) checker.check_precision(); +- } +- +- private: +- Format format_; +- PreparedPartsProvider parts_provider_; +-}; +- +-template struct part_counter { +- unsigned num_parts = 0; +- +- FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { +- if (begin != end) ++num_parts; +- } +- +- FMT_CONSTEXPR void on_arg_id() { ++num_parts; } +- FMT_CONSTEXPR void on_arg_id(unsigned) { ++num_parts; } +- FMT_CONSTEXPR void on_arg_id(basic_string_view) { ++num_parts; } +- +- FMT_CONSTEXPR void on_replacement_field(const Char*) {} +- +- FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, +- const Char* end) { +- // Find the matching brace. +- unsigned braces_counter = 0; +- for (; begin != end; ++begin) { +- if (*begin == '{') { +- ++braces_counter; +- } else if (*begin == '}') { +- if (braces_counter == 0u) break; +- --braces_counter; +- } +- } +- return begin; +- } +- +- FMT_CONSTEXPR void on_error(const char*) {} +-}; +- +-template class compiletime_prepared_parts_type_provider { +- private: +- using char_type = char_t; +- +- static FMT_CONSTEXPR unsigned count_parts() { +- FMT_CONSTEXPR_DECL const auto text = to_string_view(Format{}); +- part_counter counter; +- internal::parse_format_string(text, counter); +- return counter.num_parts; +- } +- +-// Workaround for old compilers. Compiletime parts preparation will not be +-// performed with them anyway. +-#if FMT_USE_CONSTEXPR +- static FMT_CONSTEXPR_DECL const unsigned number_of_format_parts = +- compiletime_prepared_parts_type_provider::count_parts(); +-#else +- static const unsigned number_of_format_parts = 0u; +-#endif +- +- public: +- template struct format_parts_array { +- using value_type = format_part; +- +- FMT_CONSTEXPR format_parts_array() : arr{} {} +- +- FMT_CONSTEXPR value_type& operator[](unsigned ind) { return arr[ind]; } +- +- FMT_CONSTEXPR const value_type* begin() const { return arr; } +- FMT_CONSTEXPR const value_type* end() const { return begin() + N; } +- +- private: +- value_type arr[N]; +- }; +- +- struct empty { +- // Parts preparator will search for it +- using value_type = format_part; +- }; +- +- using type = conditional_t, empty>; +-}; +- +-template class compiletime_prepared_parts_collector { +- private: +- using format_part = typename Parts::value_type; +- +- public: +- FMT_CONSTEXPR explicit compiletime_prepared_parts_collector(Parts& parts) +- : parts_{parts}, counter_{0u} {} +- +- FMT_CONSTEXPR void push_back(format_part part) { parts_[counter_++] = part; } +- +- FMT_CONSTEXPR format_part& back() { return parts_[counter_ - 1]; } +- +- private: +- Parts& parts_; +- unsigned counter_; +-}; +- +-template +-FMT_CONSTEXPR PartsContainer prepare_parts(basic_string_view format) { +- PartsContainer parts; +- internal::parse_format_string( +- format, format_preparation_handler(format, parts)); +- return parts; +-} +- +-template +-FMT_CONSTEXPR PartsContainer +-prepare_compiletime_parts(basic_string_view format) { +- using collector = compiletime_prepared_parts_collector; +- +- PartsContainer parts; +- collector c(parts); +- internal::parse_format_string( +- format, format_preparation_handler(format, c)); +- return parts; +-} +- +-template class runtime_parts_provider { +- public: +- runtime_parts_provider() = delete; +- template +- runtime_parts_provider(basic_string_view format) +- : parts_(prepare_parts(format)) {} +- +- const PartsContainer& parts() const { return parts_; } +- +- private: +- PartsContainer parts_; +-}; +- +-template +-struct compiletime_parts_provider { +- compiletime_parts_provider() = delete; +- template +- FMT_CONSTEXPR compiletime_parts_provider(basic_string_view) {} +- +- const PartsContainer& parts() const { +- static FMT_CONSTEXPR_DECL const PartsContainer prepared_parts = +- prepare_compiletime_parts( +- internal::to_string_view(Format{})); +- +- return prepared_parts; +- } +-}; +-} // namespace internal +- +-#if FMT_USE_CONSTEXPR +-template ::value)> +-FMT_CONSTEXPR auto compile(S format_str) -> internal::prepared_format< +- S, +- internal::compiletime_parts_provider< +- S, +- typename internal::compiletime_prepared_parts_type_provider::type>, +- Args...> { +- return format_str; +-} +-#endif +- +-template +-auto compile(const Char (&format_str)[N]) -> internal::prepared_format< +- std::basic_string, +- internal::runtime_parts_provider>>, +- Args...> { +- return std::basic_string(format_str, N - 1); +-} +- +-template +-std::basic_string format(const CompiledFormat& cf, const Args&... args) { +- basic_memory_buffer buffer; +- using range = internal::buffer_range; +- using context = buffer_context; +- cf.template vformat_to(range(buffer), +- {make_format_args(args...)}); +- return to_string(buffer); +-} +- +-template +-OutputIt format_to(OutputIt out, const CompiledFormat& cf, +- const Args&... args) { +- using char_type = typename CompiledFormat::char_type; +- using range = internal::output_range; +- using context = format_context_t; +- return cf.template vformat_to( +- range(out), {make_format_args(args...)}); +-} +- +-template ::value)> +-format_to_n_result format_to_n(OutputIt out, size_t n, +- const CompiledFormat& cf, +- const Args&... args) { +- auto it = +- format_to(internal::truncating_iterator(out, n), cf, args...); +- return {it.base(), it.count()}; +-} +- +-template +-std::size_t formatted_size(const CompiledFormat& cf, const Args&... args) { +- return fmt::format_to( +- internal::counting_iterator(), +- cf, args...) +- .count(); +-} +- +-FMT_END_NAMESPACE +- +-#endif // FMT_COMPILE_H_ +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/core.h b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/core.h +deleted file mode 100644 +index 2dc6ed552b..0000000000 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/core.h ++++ /dev/null +@@ -1,1420 +0,0 @@ +-// Formatting library for C++ - the core API +-// +-// Copyright (c) 2012 - present, Victor Zverovich +-// All rights reserved. +-// +-// For the license information refer to format.h. +- +-#ifndef FMT_CORE_H_ +-#define FMT_CORE_H_ +- +-#include +-#include // std::FILE +-#include +-#include +-#include +-#include +- +-// The fmt library version in the form major * 10000 + minor * 100 + patch. +-#define FMT_VERSION 60000 +- +-#ifdef __has_feature +-# define FMT_HAS_FEATURE(x) __has_feature(x) +-#else +-# define FMT_HAS_FEATURE(x) 0 +-#endif +- +-#if defined(__has_include) && !defined(__INTELLISENSE__) && \ +- !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600) +-# define FMT_HAS_INCLUDE(x) __has_include(x) +-#else +-# define FMT_HAS_INCLUDE(x) 0 +-#endif +- +-#ifdef __has_cpp_attribute +-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +-#else +-# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +-#endif +- +-#if defined(__GNUC__) && !defined(__clang__) +-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +-#else +-# define FMT_GCC_VERSION 0 +-#endif +- +-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) +-# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION +-#else +-# define FMT_HAS_GXX_CXX11 0 +-#endif +- +-#ifdef _MSC_VER +-# define FMT_MSC_VER _MSC_VER +-#else +-# define FMT_MSC_VER 0 +-#endif +- +-// Check if relaxed C++14 constexpr is supported. +-// GCC doesn't allow throw in constexpr until version 6 (bug 67371). +-#ifndef FMT_USE_CONSTEXPR +-# define FMT_USE_CONSTEXPR \ +- (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \ +- (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) +-#endif +-#if FMT_USE_CONSTEXPR +-# define FMT_CONSTEXPR constexpr +-# define FMT_CONSTEXPR_DECL constexpr +-#else +-# define FMT_CONSTEXPR inline +-# define FMT_CONSTEXPR_DECL +-#endif +- +-#ifndef FMT_OVERRIDE +-# if FMT_HAS_FEATURE(cxx_override) || \ +- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +-# define FMT_OVERRIDE override +-# else +-# define FMT_OVERRIDE +-# endif +-#endif +- +-// Check if exceptions are disabled. +-#ifndef FMT_EXCEPTIONS +-# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ +- FMT_MSC_VER && !_HAS_EXCEPTIONS +-# define FMT_EXCEPTIONS 0 +-# else +-# define FMT_EXCEPTIONS 1 +-# endif +-#endif +- +-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). +-#ifndef FMT_USE_NOEXCEPT +-# define FMT_USE_NOEXCEPT 0 +-#endif +- +-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \ +- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +-# define FMT_DETECTED_NOEXCEPT noexcept +-# define FMT_HAS_CXX11_NOEXCEPT 1 +-#else +-# define FMT_DETECTED_NOEXCEPT throw() +-# define FMT_HAS_CXX11_NOEXCEPT 0 +-#endif +- +-#ifndef FMT_NOEXCEPT +-# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT +-# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT +-# else +-# define FMT_NOEXCEPT +-# endif +-#endif +- +-// [[noreturn]] is disabled on MSVC because of bogus unreachable code warnings. +-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER +-# define FMT_NORETURN [[noreturn]] +-#else +-# define FMT_NORETURN +-#endif +- +-#ifndef FMT_DEPRECATED +-# if (FMT_HAS_CPP_ATTRIBUTE(deprecated) && __cplusplus >= 201402L) || \ +- FMT_MSC_VER >= 1900 +-# define FMT_DEPRECATED [[deprecated]] +-# else +-# if defined(__GNUC__) || defined(__clang__) +-# define FMT_DEPRECATED __attribute__((deprecated)) +-# elif FMT_MSC_VER +-# define FMT_DEPRECATED __declspec(deprecated) +-# else +-# define FMT_DEPRECATED /* deprecated */ +-# endif +-# endif +-#endif +-// Workaround broken [[deprecated]] in the Intel compiler. +-#ifdef __INTEL_COMPILER +-# define FMT_DEPRECATED_ALIAS +-#else +-# define FMT_DEPRECATED_ALIAS FMT_DEPRECATED +-#endif +- +-#ifndef FMT_BEGIN_NAMESPACE +-# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \ +- FMT_MSC_VER >= 1900 +-# define FMT_INLINE_NAMESPACE inline namespace +-# define FMT_END_NAMESPACE \ +- } \ +- } +-# else +-# define FMT_INLINE_NAMESPACE namespace +-# define FMT_END_NAMESPACE \ +- } \ +- using namespace v6; \ +- } +-# endif +-# define FMT_BEGIN_NAMESPACE \ +- namespace fmt { \ +- FMT_INLINE_NAMESPACE v6 { +-#endif +- +-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +-# ifdef FMT_EXPORT +-# define FMT_API __declspec(dllexport) +-# elif defined(FMT_SHARED) +-# define FMT_API __declspec(dllimport) +-# define FMT_EXTERN_TEMPLATE_API FMT_API +-# endif +-#endif +-#ifndef FMT_API +-# define FMT_API +-#endif +-#ifndef FMT_EXTERN_TEMPLATE_API +-# define FMT_EXTERN_TEMPLATE_API +-#endif +- +-#ifndef FMT_HEADER_ONLY +-# define FMT_EXTERN extern +-#else +-# define FMT_EXTERN +-#endif +- +-#ifndef FMT_ASSERT +-# define FMT_ASSERT(condition, message) assert((condition) && message) +-#endif +- +-// libc++ supports string_view in pre-c++17. +-#if (FMT_HAS_INCLUDE() && \ +- (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \ +- (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) +-# include +-# define FMT_USE_STRING_VIEW +-#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L +-# include +-# define FMT_USE_EXPERIMENTAL_STRING_VIEW +-#endif +- +-FMT_BEGIN_NAMESPACE +- +-// Implementations of enable_if_t and other types for pre-C++14 systems. +-template +-using enable_if_t = typename std::enable_if::type; +-template +-using conditional_t = typename std::conditional::type; +-template using bool_constant = std::integral_constant; +-template +-using remove_reference_t = typename std::remove_reference::type; +-template +-using remove_const_t = typename std::remove_const::type; +- +-struct monostate {}; +- +-// An enable_if helper to be used in template parameters which results in much +-// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed +-// to workaround a bug in MSVC 2019 (see #1140 and #1186). +-#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0 +- +-namespace internal { +- +-// A workaround for gcc 4.8 to make void_t work in a SFINAE context. +-template struct void_t_impl { using type = void; }; +- +-#if defined(FMT_USE_STRING_VIEW) +-template using std_string_view = std::basic_string_view; +-#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) +-template +-using std_string_view = std::experimental::basic_string_view; +-#else +-template struct std_string_view {}; +-#endif +- +-// Casts nonnegative integer to unsigned. +-template +-FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) { +- FMT_ASSERT(value >= 0, "negative value"); +- return static_cast::type>(value); +-} +-} // namespace internal +- +-template +-using void_t = typename internal::void_t_impl::type; +- +-/** +- An implementation of ``std::basic_string_view`` for pre-C++17. It provides a +- subset of the API. ``fmt::basic_string_view`` is used for format strings even +- if ``std::string_view`` is available to prevent issues when a library is +- compiled with a different ``-std`` option than the client code (which is not +- recommended). +- */ +-template class basic_string_view { +- private: +- const Char* data_; +- size_t size_; +- +- public: +- using char_type = Char; +- using iterator = const Char*; +- +- FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {} +- +- /** Constructs a string reference object from a C string and a size. */ +- FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT +- : data_(s), +- size_(count) {} +- +- /** +- \rst +- Constructs a string reference object from a C string computing +- the size with ``std::char_traits::length``. +- \endrst +- */ +- basic_string_view(const Char* s) +- : data_(s), size_(std::char_traits::length(s)) {} +- +- /** Constructs a string reference from a ``std::basic_string`` object. */ +- template +- FMT_CONSTEXPR basic_string_view(const std::basic_string& s) +- FMT_NOEXCEPT : data_(s.data()), +- size_(s.size()) {} +- +- template < +- typename S, +- FMT_ENABLE_IF(std::is_same>::value)> +- FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()), +- size_(s.size()) {} +- +- /** Returns a pointer to the string data. */ +- FMT_CONSTEXPR const Char* data() const { return data_; } +- +- /** Returns the string size. */ +- FMT_CONSTEXPR size_t size() const { return size_; } +- +- FMT_CONSTEXPR iterator begin() const { return data_; } +- FMT_CONSTEXPR iterator end() const { return data_ + size_; } +- +- FMT_CONSTEXPR void remove_prefix(size_t n) { +- data_ += n; +- size_ -= n; +- } +- +- // Lexicographically compare this string reference to other. +- int compare(basic_string_view other) const { +- size_t str_size = size_ < other.size_ ? size_ : other.size_; +- int result = std::char_traits::compare(data_, other.data_, str_size); +- if (result == 0) +- result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); +- return result; +- } +- +- friend bool operator==(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) == 0; +- } +- friend bool operator!=(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) != 0; +- } +- friend bool operator<(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) < 0; +- } +- friend bool operator<=(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) <= 0; +- } +- friend bool operator>(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) > 0; +- } +- friend bool operator>=(basic_string_view lhs, basic_string_view rhs) { +- return lhs.compare(rhs) >= 0; +- } +-}; +- +-using string_view = basic_string_view; +-using wstring_view = basic_string_view; +- +-#ifndef __cpp_char8_t +-// A UTF-8 code unit type. +-enum char8_t : unsigned char {}; +-#endif +- +-/** Specifies if ``T`` is a character type. Can be specialized by users. */ +-template struct is_char : std::false_type {}; +-template <> struct is_char : std::true_type {}; +-template <> struct is_char : std::true_type {}; +-template <> struct is_char : std::true_type {}; +-template <> struct is_char : std::true_type {}; +-template <> struct is_char : std::true_type {}; +- +-/** +- \rst +- Returns a string view of `s`. In order to add custom string type support to +- {fmt} provide an overload of `to_string_view` for it in the same namespace as +- the type for the argument-dependent lookup to work. +- +- **Example**:: +- +- namespace my_ns { +- inline string_view to_string_view(const my_string& s) { +- return {s.data(), s.length()}; +- } +- } +- std::string message = fmt::format(my_string("The answer is {}"), 42); +- \endrst +- */ +-template ::value)> +-inline basic_string_view to_string_view(const Char* s) { +- return s; +-} +- +-template +-inline basic_string_view to_string_view( +- const std::basic_string& s) { +- return {s.data(), s.size()}; +-} +- +-template +-inline basic_string_view to_string_view(basic_string_view s) { +- return s; +-} +- +-template >::value)> +-inline basic_string_view to_string_view( +- internal::std_string_view s) { +- return s; +-} +- +-// A base class for compile-time strings. It is defined in the fmt namespace to +-// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42). +-struct compile_string {}; +- +-template +-struct is_compile_string : std::is_base_of {}; +- +-template ::value)> +-constexpr basic_string_view to_string_view(const S& s) { +- return s; +-} +- +-namespace internal { +-void to_string_view(...); +-using fmt::v6::to_string_view; +- +-// Specifies whether S is a string type convertible to fmt::basic_string_view. +-// It should be a constexpr function but MSVC 2017 fails to compile it in +-// enable_if and MSVC 2015 fails to compile it as an alias template. +-template +-struct is_string : std::is_class()))> { +-}; +- +-template struct char_t_impl {}; +-template struct char_t_impl::value>> { +- using result = decltype(to_string_view(std::declval())); +- using type = typename result::char_type; +-}; +- +-struct error_handler { +- FMT_CONSTEXPR error_handler() {} +- FMT_CONSTEXPR error_handler(const error_handler&) {} +- +- // This function is intentionally not constexpr to give a compile-time error. +- FMT_NORETURN FMT_API void on_error(const char* message); +-}; +-} // namespace internal +- +-/** String's character type. */ +-template using char_t = typename internal::char_t_impl::type; +- +-// Parsing context consisting of a format string range being parsed and an +-// argument counter for automatic indexing. +-template +-class basic_parse_context : private ErrorHandler { +- private: +- basic_string_view format_str_; +- int next_arg_id_; +- +- public: +- using char_type = Char; +- using iterator = typename basic_string_view::iterator; +- +- explicit FMT_CONSTEXPR basic_parse_context(basic_string_view format_str, +- ErrorHandler eh = ErrorHandler()) +- : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {} +- +- // Returns an iterator to the beginning of the format string range being +- // parsed. +- FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT { +- return format_str_.begin(); +- } +- +- // Returns an iterator past the end of the format string range being parsed. +- FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); } +- +- // Advances the begin iterator to ``it``. +- FMT_CONSTEXPR void advance_to(iterator it) { +- format_str_.remove_prefix(internal::to_unsigned(it - begin())); +- } +- +- // Returns the next argument index. +- FMT_CONSTEXPR int next_arg_id() { +- if (next_arg_id_ >= 0) return next_arg_id_++; +- on_error("cannot switch from manual to automatic argument indexing"); +- return 0; +- } +- +- FMT_CONSTEXPR bool check_arg_id(int) { +- if (next_arg_id_ > 0) { +- on_error("cannot switch from automatic to manual argument indexing"); +- return false; +- } +- next_arg_id_ = -1; +- return true; +- } +- +- FMT_CONSTEXPR void check_arg_id(basic_string_view) {} +- +- FMT_CONSTEXPR void on_error(const char* message) { +- ErrorHandler::on_error(message); +- } +- +- FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; } +-}; +- +-using format_parse_context = basic_parse_context; +-using wformat_parse_context = basic_parse_context; +- +-using parse_context FMT_DEPRECATED_ALIAS = basic_parse_context; +-using wparse_context FMT_DEPRECATED_ALIAS = basic_parse_context; +- +-template class basic_format_arg; +-template class basic_format_args; +- +-// A formatter for objects of type T. +-template +-struct formatter { +- // A deleted default constructor indicates a disabled formatter. +- formatter() = delete; +-}; +- +-template +-struct FMT_DEPRECATED convert_to_int +- : bool_constant::value && +- std::is_convertible::value> {}; +- +-namespace internal { +- +-// Specifies if T has an enabled formatter specialization. A type can be +-// formattable even if it doesn't have a formatter e.g. via a conversion. +-template +-using has_formatter = +- std::is_constructible>; +- +-/** A contiguous memory buffer with an optional growing ability. */ +-template class buffer { +- private: +- buffer(const buffer&) = delete; +- void operator=(const buffer&) = delete; +- +- T* ptr_; +- std::size_t size_; +- std::size_t capacity_; +- +- protected: +- // Don't initialize ptr_ since it is not accessed to save a few cycles. +- buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {} +- +- buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT +- : ptr_(p), +- size_(sz), +- capacity_(cap) {} +- +- /** Sets the buffer data and capacity. */ +- void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT { +- ptr_ = buf_data; +- capacity_ = buf_capacity; +- } +- +- /** Increases the buffer capacity to hold at least *capacity* elements. */ +- virtual void grow(std::size_t capacity) = 0; +- +- public: +- using value_type = T; +- using const_reference = const T&; +- +- virtual ~buffer() {} +- +- T* begin() FMT_NOEXCEPT { return ptr_; } +- T* end() FMT_NOEXCEPT { return ptr_ + size_; } +- +- /** Returns the size of this buffer. */ +- std::size_t size() const FMT_NOEXCEPT { return size_; } +- +- /** Returns the capacity of this buffer. */ +- std::size_t capacity() const FMT_NOEXCEPT { return capacity_; } +- +- /** Returns a pointer to the buffer data. */ +- T* data() FMT_NOEXCEPT { return ptr_; } +- +- /** Returns a pointer to the buffer data. */ +- const T* data() const FMT_NOEXCEPT { return ptr_; } +- +- /** +- Resizes the buffer. If T is a POD type new elements may not be initialized. +- */ +- void resize(std::size_t new_size) { +- reserve(new_size); +- size_ = new_size; +- } +- +- /** Clears this buffer. */ +- void clear() { size_ = 0; } +- +- /** Reserves space to store at least *capacity* elements. */ +- void reserve(std::size_t new_capacity) { +- if (new_capacity > capacity_) grow(new_capacity); +- } +- +- void push_back(const T& value) { +- reserve(size_ + 1); +- ptr_[size_++] = value; +- } +- +- /** Appends data to the end of the buffer. */ +- template void append(const U* begin, const U* end); +- +- T& operator[](std::size_t index) { return ptr_[index]; } +- const T& operator[](std::size_t index) const { return ptr_[index]; } +-}; +- +-// A container-backed buffer. +-template +-class container_buffer : public buffer { +- private: +- Container& container_; +- +- protected: +- void grow(std::size_t capacity) FMT_OVERRIDE { +- container_.resize(capacity); +- this->set(&container_[0], capacity); +- } +- +- public: +- explicit container_buffer(Container& c) +- : buffer(c.size()), container_(c) {} +-}; +- +-// Extracts a reference to the container from back_insert_iterator. +-template +-inline Container& get_container(std::back_insert_iterator it) { +- using bi_iterator = std::back_insert_iterator; +- struct accessor : bi_iterator { +- accessor(bi_iterator iter) : bi_iterator(iter) {} +- using bi_iterator::container; +- }; +- return *accessor(it).container; +-} +- +-template +-struct fallback_formatter { +- fallback_formatter() = delete; +-}; +- +-// Specifies if T has an enabled fallback_formatter specialization. +-template +-using has_fallback_formatter = +- std::is_constructible>; +- +-template struct named_arg_base; +-template struct named_arg; +- +-enum type { +- none_type, +- named_arg_type, +- // Integer types should go first, +- int_type, +- uint_type, +- long_long_type, +- ulong_long_type, +- bool_type, +- char_type, +- last_integer_type = char_type, +- // followed by floating-point types. +- double_type, +- long_double_type, +- last_numeric_type = long_double_type, +- cstring_type, +- string_type, +- pointer_type, +- custom_type +-}; +- +-// Maps core type T to the corresponding type enum constant. +-template +-struct type_constant : std::integral_constant {}; +- +-#define FMT_TYPE_CONSTANT(Type, constant) \ +- template \ +- struct type_constant : std::integral_constant {} +- +-FMT_TYPE_CONSTANT(const named_arg_base&, named_arg_type); +-FMT_TYPE_CONSTANT(int, int_type); +-FMT_TYPE_CONSTANT(unsigned, uint_type); +-FMT_TYPE_CONSTANT(long long, long_long_type); +-FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); +-FMT_TYPE_CONSTANT(bool, bool_type); +-FMT_TYPE_CONSTANT(Char, char_type); +-FMT_TYPE_CONSTANT(double, double_type); +-FMT_TYPE_CONSTANT(long double, long_double_type); +-FMT_TYPE_CONSTANT(const Char*, cstring_type); +-FMT_TYPE_CONSTANT(basic_string_view, string_type); +-FMT_TYPE_CONSTANT(const void*, pointer_type); +- +-FMT_CONSTEXPR bool is_integral(type t) { +- FMT_ASSERT(t != named_arg_type, "invalid argument type"); +- return t > none_type && t <= last_integer_type; +-} +- +-FMT_CONSTEXPR bool is_arithmetic(type t) { +- FMT_ASSERT(t != named_arg_type, "invalid argument type"); +- return t > none_type && t <= last_numeric_type; +-} +- +-template struct string_value { +- const Char* data; +- std::size_t size; +-}; +- +-template struct custom_value { +- using parse_context = basic_parse_context; +- const void* value; +- void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx); +-}; +- +-// A formatting argument value. +-template class value { +- public: +- using char_type = typename Context::char_type; +- +- union { +- int int_value; +- unsigned uint_value; +- long long long_long_value; +- unsigned long long ulong_long_value; +- bool bool_value; +- char_type char_value; +- double double_value; +- long double long_double_value; +- const void* pointer; +- string_value string; +- custom_value custom; +- const named_arg_base* named_arg; +- }; +- +- FMT_CONSTEXPR value(int val = 0) : int_value(val) {} +- FMT_CONSTEXPR value(unsigned val) : uint_value(val) {} +- value(long long val) : long_long_value(val) {} +- value(unsigned long long val) : ulong_long_value(val) {} +- value(double val) : double_value(val) {} +- value(long double val) : long_double_value(val) {} +- value(bool val) : bool_value(val) {} +- value(char_type val) : char_value(val) {} +- value(const char_type* val) { string.data = val; } +- value(basic_string_view val) { +- string.data = val.data(); +- string.size = val.size(); +- } +- value(const void* val) : pointer(val) {} +- +- template value(const T& val) { +- custom.value = &val; +- // Get the formatter type through the context to allow different contexts +- // have different extension points, e.g. `formatter` for `format` and +- // `printf_formatter` for `printf`. +- custom.format = format_custom_arg< +- T, conditional_t::value, +- typename Context::template formatter_type, +- fallback_formatter>>; +- } +- +- value(const named_arg_base& val) { named_arg = &val; } +- +- private: +- // Formats an argument of a custom type, such as a user-defined class. +- template +- static void format_custom_arg(const void* arg, +- basic_parse_context& parse_ctx, +- Context& ctx) { +- Formatter f; +- parse_ctx.advance_to(f.parse(parse_ctx)); +- ctx.advance_to(f.format(*static_cast(arg), ctx)); +- } +-}; +- +-template +-FMT_CONSTEXPR basic_format_arg make_arg(const T& value); +- +-// To minimize the number of types we need to deal with, long is translated +-// either to int or to long long depending on its size. +-enum { long_short = sizeof(long) == sizeof(int) }; +-using long_type = conditional_t; +-using ulong_type = conditional_t; +- +-// Maps formatting arguments to core types. +-template struct arg_mapper { +- using char_type = typename Context::char_type; +- +- FMT_CONSTEXPR int map(signed char val) { return val; } +- FMT_CONSTEXPR unsigned map(unsigned char val) { return val; } +- FMT_CONSTEXPR int map(short val) { return val; } +- FMT_CONSTEXPR unsigned map(unsigned short val) { return val; } +- FMT_CONSTEXPR int map(int val) { return val; } +- FMT_CONSTEXPR unsigned map(unsigned val) { return val; } +- FMT_CONSTEXPR long_type map(long val) { return val; } +- FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; } +- FMT_CONSTEXPR long long map(long long val) { return val; } +- FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; } +- FMT_CONSTEXPR bool map(bool val) { return val; } +- +- template ::value)> +- FMT_CONSTEXPR char_type map(T val) { +- static_assert( +- std::is_same::value || std::is_same::value, +- "mixing character types is disallowed"); +- return val; +- } +- +- FMT_CONSTEXPR double map(float val) { return static_cast(val); } +- FMT_CONSTEXPR double map(double val) { return val; } +- FMT_CONSTEXPR long double map(long double val) { return val; } +- +- FMT_CONSTEXPR const char_type* map(char_type* val) { return val; } +- FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; } +- template ::value)> +- FMT_CONSTEXPR basic_string_view map(const T& val) { +- static_assert(std::is_same>::value, +- "mixing character types is disallowed"); +- return to_string_view(val); +- } +- template , T>::value && +- !is_string::value)> +- FMT_CONSTEXPR basic_string_view map(const T& val) { +- return basic_string_view(val); +- } +- FMT_CONSTEXPR const char* map(const signed char* val) { +- static_assert(std::is_same::value, "invalid string type"); +- return reinterpret_cast(val); +- } +- FMT_CONSTEXPR const char* map(const unsigned char* val) { +- static_assert(std::is_same::value, "invalid string type"); +- return reinterpret_cast(val); +- } +- +- FMT_CONSTEXPR const void* map(void* val) { return val; } +- FMT_CONSTEXPR const void* map(const void* val) { return val; } +- FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; } +- template FMT_CONSTEXPR int map(const T*) { +- // Formatting of arbitrary pointers is disallowed. If you want to output +- // a pointer cast it to "void *" or "const void *". In particular, this +- // forbids formatting of "[const] volatile char *" which is printed as bool +- // by iostreams. +- static_assert(!sizeof(T), "formatting of non-void pointers is disallowed"); +- return 0; +- } +- +- template ::value && +- !has_formatter::value && +- !has_fallback_formatter::value)> +- FMT_CONSTEXPR int map(const T& val) { +- return static_cast(val); +- } +- template ::value && !is_char::value && +- (has_formatter::value || +- has_fallback_formatter::value))> +- FMT_CONSTEXPR const T& map(const T& val) { +- return val; +- } +- +- template +- FMT_CONSTEXPR const named_arg_base& map( +- const named_arg& val) { +- auto arg = make_arg(val.value); +- std::memcpy(val.data, &arg, sizeof(arg)); +- return val; +- } +-}; +- +-// A type constant after applying arg_mapper. +-template +-using mapped_type_constant = +- type_constant().map(std::declval())), +- typename Context::char_type>; +- +-// Maximum number of arguments with packed types. +-enum { max_packed_args = 15 }; +-enum : unsigned long long { is_unpacked_bit = 1ull << 63 }; +- +-template class arg_map; +-} // namespace internal +- +-// A formatting argument. It is a trivially copyable/constructible type to +-// allow storage in basic_memory_buffer. +-template class basic_format_arg { +- private: +- internal::value value_; +- internal::type type_; +- +- template +- friend FMT_CONSTEXPR basic_format_arg internal::make_arg( +- const T& value); +- +- template +- friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, +- const basic_format_arg& arg) +- -> decltype(vis(0)); +- +- friend class basic_format_args; +- friend class internal::arg_map; +- +- using char_type = typename Context::char_type; +- +- public: +- class handle { +- public: +- explicit handle(internal::custom_value custom) : custom_(custom) {} +- +- void format(basic_parse_context& parse_ctx, Context& ctx) const { +- custom_.format(custom_.value, parse_ctx, ctx); +- } +- +- private: +- internal::custom_value custom_; +- }; +- +- FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {} +- +- FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT { +- return type_ != internal::none_type; +- } +- +- internal::type type() const { return type_; } +- +- bool is_integral() const { return internal::is_integral(type_); } +- bool is_arithmetic() const { return internal::is_arithmetic(type_); } +-}; +- +-/** +- \rst +- Visits an argument dispatching to the appropriate visit method based on +- the argument type. For example, if the argument type is ``double`` then +- ``vis(value)`` will be called with the value of type ``double``. +- \endrst +- */ +-template +-FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, +- const basic_format_arg& arg) +- -> decltype(vis(0)) { +- using char_type = typename Context::char_type; +- switch (arg.type_) { +- case internal::none_type: +- break; +- case internal::named_arg_type: +- FMT_ASSERT(false, "invalid argument type"); +- break; +- case internal::int_type: +- return vis(arg.value_.int_value); +- case internal::uint_type: +- return vis(arg.value_.uint_value); +- case internal::long_long_type: +- return vis(arg.value_.long_long_value); +- case internal::ulong_long_type: +- return vis(arg.value_.ulong_long_value); +- case internal::bool_type: +- return vis(arg.value_.bool_value); +- case internal::char_type: +- return vis(arg.value_.char_value); +- case internal::double_type: +- return vis(arg.value_.double_value); +- case internal::long_double_type: +- return vis(arg.value_.long_double_value); +- case internal::cstring_type: +- return vis(arg.value_.string.data); +- case internal::string_type: +- return vis(basic_string_view(arg.value_.string.data, +- arg.value_.string.size)); +- case internal::pointer_type: +- return vis(arg.value_.pointer); +- case internal::custom_type: +- return vis(typename basic_format_arg::handle(arg.value_.custom)); +- } +- return vis(monostate()); +-} +- +-namespace internal { +-// A map from argument names to their values for named arguments. +-template class arg_map { +- private: +- arg_map(const arg_map&) = delete; +- void operator=(const arg_map&) = delete; +- +- using char_type = typename Context::char_type; +- +- struct entry { +- basic_string_view name; +- basic_format_arg arg; +- }; +- +- entry* map_; +- unsigned size_; +- +- void push_back(value val) { +- const auto& named = *val.named_arg; +- map_[size_] = {named.name, named.template deserialize()}; +- ++size_; +- } +- +- public: +- arg_map() : map_(nullptr), size_(0) {} +- void init(const basic_format_args& args); +- ~arg_map() { delete[] map_; } +- +- basic_format_arg find(basic_string_view name) const { +- // The list is unsorted, so just return the first matching name. +- for (entry *it = map_, *end = map_ + size_; it != end; ++it) { +- if (it->name == name) return it->arg; +- } +- return {}; +- } +-}; +- +-// A type-erased reference to an std::locale to avoid heavy include. +-class locale_ref { +- private: +- const void* locale_; // A type-erased pointer to std::locale. +- +- public: +- locale_ref() : locale_(nullptr) {} +- template explicit locale_ref(const Locale& loc); +- +- template Locale get() const; +-}; +- +-template constexpr unsigned long long encode_types() { return 0; } +- +-template +-constexpr unsigned long long encode_types() { +- return mapped_type_constant::value | +- (encode_types() << 4); +-} +- +-template +-FMT_CONSTEXPR basic_format_arg make_arg(const T& value) { +- basic_format_arg arg; +- arg.type_ = mapped_type_constant::value; +- arg.value_ = arg_mapper().map(value); +- return arg; +-} +- +-template +-inline value make_arg(const T& val) { +- return arg_mapper().map(val); +-} +- +-template +-inline basic_format_arg make_arg(const T& value) { +- return make_arg(value); +-} +-} // namespace internal +- +-// Formatting context. +-template class basic_format_context { +- public: +- /** The character type for the output. */ +- using char_type = Char; +- +- private: +- OutputIt out_; +- basic_format_args args_; +- internal::arg_map map_; +- internal::locale_ref loc_; +- +- basic_format_context(const basic_format_context&) = delete; +- void operator=(const basic_format_context&) = delete; +- +- public: +- using iterator = OutputIt; +- using format_arg = basic_format_arg; +- template using formatter_type = formatter; +- +- /** +- Constructs a ``basic_format_context`` object. References to the arguments are +- stored in the object so make sure they have appropriate lifetimes. +- */ +- basic_format_context(OutputIt out, +- basic_format_args ctx_args, +- internal::locale_ref loc = internal::locale_ref()) +- : out_(out), args_(ctx_args), loc_(loc) {} +- +- format_arg arg(int id) const { return args_.get(id); } +- +- // Checks if manual indexing is used and returns the argument with the +- // specified name. +- format_arg arg(basic_string_view name); +- +- internal::error_handler error_handler() { return {}; } +- void on_error(const char* message) { error_handler().on_error(message); } +- +- // Returns an iterator to the beginning of the output range. +- iterator out() { return out_; } +- +- // Advances the begin iterator to ``it``. +- void advance_to(iterator it) { out_ = it; } +- +- internal::locale_ref locale() { return loc_; } +-}; +- +-template +-using buffer_context = +- basic_format_context>, +- Char>; +-using format_context = buffer_context; +-using wformat_context = buffer_context; +- +-/** +- \rst +- An array of references to arguments. It can be implicitly converted into +- `~fmt::basic_format_args` for passing into type-erased formatting functions +- such as `~fmt::vformat`. +- \endrst +- */ +-template class format_arg_store { +- private: +- static const size_t num_args = sizeof...(Args); +- static const bool is_packed = num_args < internal::max_packed_args; +- +- using value_type = conditional_t, +- basic_format_arg>; +- +- // If the arguments are not packed, add one more element to mark the end. +- value_type data_[num_args + (num_args == 0 ? 1 : 0)]; +- +- friend class basic_format_args; +- +- public: +- static constexpr unsigned long long types = +- is_packed ? internal::encode_types() +- : internal::is_unpacked_bit | num_args; +- FMT_DEPRECATED static constexpr unsigned long long TYPES = types; +- +- format_arg_store(const Args&... args) +- : data_{internal::make_arg(args)...} {} +-}; +- +-/** +- \rst +- Constructs an `~fmt::format_arg_store` object that contains references to +- arguments and can be implicitly converted to `~fmt::format_args`. `Context` +- can be omitted in which case it defaults to `~fmt::context`. +- See `~fmt::arg` for lifetime considerations. +- \endrst +- */ +-template +-inline format_arg_store make_format_args( +- const Args&... args) { +- return {args...}; +-} +- +-/** Formatting arguments. */ +-template class basic_format_args { +- public: +- using size_type = int; +- using format_arg = basic_format_arg; +- +- private: +- // To reduce compiled code size per formatting function call, types of first +- // max_packed_args arguments are passed in the types_ field. +- unsigned long long types_; +- union { +- // If the number of arguments is less than max_packed_args, the argument +- // values are stored in values_, otherwise they are stored in args_. +- // This is done to reduce compiled code size as storing larger objects +- // may require more code (at least on x86-64) even if the same amount of +- // data is actually copied to stack. It saves ~10% on the bloat test. +- const internal::value* values_; +- const format_arg* args_; +- }; +- +- bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; } +- +- internal::type type(int index) const { +- int shift = index * 4; +- return static_cast((types_ & (0xfull << shift)) >> shift); +- } +- +- friend class internal::arg_map; +- +- void set_data(const internal::value* values) { values_ = values; } +- void set_data(const format_arg* args) { args_ = args; } +- +- format_arg do_get(int index) const { +- format_arg arg; +- if (!is_packed()) { +- auto num_args = max_size(); +- if (index < num_args) arg = args_[index]; +- return arg; +- } +- if (index > internal::max_packed_args) return arg; +- arg.type_ = type(index); +- if (arg.type_ == internal::none_type) return arg; +- internal::value& val = arg.value_; +- val = values_[index]; +- return arg; +- } +- +- public: +- basic_format_args() : types_(0) {} +- +- /** +- \rst +- Constructs a `basic_format_args` object from `~fmt::format_arg_store`. +- \endrst +- */ +- template +- basic_format_args(const format_arg_store& store) +- : types_(static_cast(store.types)) { +- set_data(store.data_); +- } +- +- /** +- \rst +- Constructs a `basic_format_args` object from a dynamic set of arguments. +- \endrst +- */ +- basic_format_args(const format_arg* args, int count) +- : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) { +- set_data(args); +- } +- +- /** Returns the argument at specified index. */ +- format_arg get(int index) const { +- format_arg arg = do_get(index); +- if (arg.type_ == internal::named_arg_type) +- arg = arg.value_.named_arg->template deserialize(); +- return arg; +- } +- +- int max_size() const { +- unsigned long long max_packed = internal::max_packed_args; +- return static_cast(is_packed() ? max_packed +- : types_ & ~internal::is_unpacked_bit); +- } +-}; +- +-/** An alias to ``basic_format_args``. */ +-// It is a separate type rather than an alias to make symbols readable. +-struct format_args : basic_format_args { +- template +- format_args(Args&&... args) +- : basic_format_args(std::forward(args)...) {} +-}; +-struct wformat_args : basic_format_args { +- template +- wformat_args(Args&&... args) +- : basic_format_args(std::forward(args)...) {} +-}; +- +-template struct is_contiguous : std::false_type {}; +- +-template +-struct is_contiguous> : std::true_type {}; +- +-template +-struct is_contiguous> : std::true_type {}; +- +-namespace internal { +- +-template +-struct is_contiguous_back_insert_iterator : std::false_type {}; +-template +-struct is_contiguous_back_insert_iterator> +- : is_contiguous {}; +- +-template struct named_arg_base { +- basic_string_view name; +- +- // Serialized value. +- mutable char data[sizeof(basic_format_arg>)]; +- +- named_arg_base(basic_string_view nm) : name(nm) {} +- +- template basic_format_arg deserialize() const { +- basic_format_arg arg; +- std::memcpy(&arg, data, sizeof(basic_format_arg)); +- return arg; +- } +-}; +- +-template struct named_arg : named_arg_base { +- const T& value; +- +- named_arg(basic_string_view name, const T& val) +- : named_arg_base(name), value(val) {} +-}; +- +-template ::value)> +-inline void check_format_string(const S&) { +-#if defined(FMT_ENFORCE_COMPILE_STRING) +- static_assert(is_compile_string::value, +- "FMT_ENFORCE_COMPILE_STRING requires all format strings to " +- "utilize FMT_STRING() or fmt()."); +-#endif +-} +-template ::value)> +-void check_format_string(S); +- +-struct view {}; +-template struct bool_pack; +-template +-using all_true = +- std::is_same, bool_pack>; +- +-template > +-inline format_arg_store, remove_reference_t...> +-make_args_checked(const S& format_str, +- const remove_reference_t&... args) { +- static_assert(all_true<(!std::is_base_of>() || +- !std::is_reference())...>::value, +- "passing views as lvalues is disallowed"); +- check_format_string>...>(format_str); +- return {args...}; +-} +- +-template +-std::basic_string vformat(basic_string_view format_str, +- basic_format_args> args); +- +-template +-typename buffer_context::iterator vformat_to( +- buffer& buf, basic_string_view format_str, +- basic_format_args> args); +-} // namespace internal +- +-/** +- \rst +- Returns a named argument to be used in a formatting function. +- +- The named argument holds a reference and does not extend the lifetime +- of its arguments. +- Consequently, a dangling reference can accidentally be created. +- The user should take care to only pass this function temporaries when +- the named argument is itself a temporary, as per the following example. +- +- **Example**:: +- +- fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); +- \endrst +- */ +-template > +-inline internal::named_arg arg(const S& name, const T& arg) { +- static_assert(internal::is_string::value, ""); +- return {name, arg}; +-} +- +-// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``. +-template +-void arg(S, internal::named_arg) = delete; +- +-/** Formats a string and writes the output to ``out``. */ +-// GCC 8 and earlier cannot handle std::back_insert_iterator with +-// vformat_to(...) overload, so SFINAE on iterator type instead. +-template , +- FMT_ENABLE_IF( +- internal::is_contiguous_back_insert_iterator::value)> +-OutputIt vformat_to(OutputIt out, const S& format_str, +- basic_format_args> args) { +- using container = remove_reference_t; +- internal::container_buffer buf((internal::get_container(out))); +- internal::vformat_to(buf, to_string_view(format_str), args); +- return out; +-} +- +-template ::value&& internal::is_string::value)> +-inline std::back_insert_iterator format_to( +- std::back_insert_iterator out, const S& format_str, +- Args&&... args) { +- return vformat_to( +- out, to_string_view(format_str), +- {internal::make_args_checked(format_str, args...)}); +-} +- +-template > +-inline std::basic_string vformat( +- const S& format_str, basic_format_args> args) { +- return internal::vformat(to_string_view(format_str), args); +-} +- +-/** +- \rst +- Formats arguments and returns the result as a string. +- +- **Example**:: +- +- #include +- std::string message = fmt::format("The answer is {}", 42); +- \endrst +-*/ +-// Pass char_t as a default template parameter instead of using +-// std::basic_string> to reduce the symbol size. +-template > +-inline std::basic_string format(const S& format_str, Args&&... args) { +- return internal::vformat( +- to_string_view(format_str), +- {internal::make_args_checked(format_str, args...)}); +-} +- +-FMT_API void vprint(std::FILE* f, string_view format_str, format_args args); +-FMT_API void vprint(std::FILE* f, wstring_view format_str, wformat_args args); +- +-/** +- \rst +- Prints formatted data to the file *f*. For wide format strings, +- *f* should be in wide-oriented mode set via ``fwide(f, 1)`` or +- ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows. +- +- **Example**:: +- +- fmt::print(stderr, "Don't {}!", "panic"); +- \endrst +- */ +-template ::value)> +-inline void print(std::FILE* f, const S& format_str, Args&&... args) { +- vprint(f, to_string_view(format_str), +- internal::make_args_checked(format_str, args...)); +-} +- +-FMT_API void vprint(string_view format_str, format_args args); +-FMT_API void vprint(wstring_view format_str, wformat_args args); +- +-/** +- \rst +- Prints formatted data to ``stdout``. +- +- **Example**:: +- +- fmt::print("Elapsed time: {0:.2f} seconds", 1.23); +- \endrst +- */ +-template ::value)> +-inline void print(const S& format_str, Args&&... args) { +- vprint(to_string_view(format_str), +- internal::make_args_checked(format_str, args...)); +-} +-FMT_END_NAMESPACE +- +-#endif // FMT_CORE_H_ +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format-inl.h b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format-inl.h +deleted file mode 100644 +index 147062fe5d..0000000000 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format-inl.h ++++ /dev/null +@@ -1,1000 +0,0 @@ +-// Formatting library for C++ +-// +-// Copyright (c) 2012 - 2016, Victor Zverovich +-// All rights reserved. +-// +-// For the license information refer to format.h. +- +-#ifndef FMT_FORMAT_INL_H_ +-#define FMT_FORMAT_INL_H_ +- +-#include "format.h" +- +-#include +- +-#include +-#include +-#include +-#include +-#include +-#include // for std::ptrdiff_t +-#include // for std::memmove +-#include +-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) +-# include +-#endif +- +-#if FMT_USE_WINDOWS_H +-# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) +-# define WIN32_LEAN_AND_MEAN +-# endif +-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) +-# include +-# else +-# define NOMINMAX +-# include +-# undef NOMINMAX +-# endif +-#endif +- +-#if FMT_EXCEPTIONS +-# define FMT_TRY try +-# define FMT_CATCH(x) catch (x) +-#else +-# define FMT_TRY if (true) +-# define FMT_CATCH(x) if (false) +-#endif +- +-#ifdef _MSC_VER +-# pragma warning(push) +-# pragma warning(disable : 4127) // conditional expression is constant +-# pragma warning(disable : 4702) // unreachable code +-// Disable deprecation warning for strerror. The latter is not called but +-// MSVC fails to detect it. +-# pragma warning(disable : 4996) +-#endif +- +-// Dummy implementations of strerror_r and strerror_s called if corresponding +-// system functions are not available. +-inline fmt::internal::null<> strerror_r(int, char*, ...) { +- return fmt::internal::null<>(); +-} +-inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { +- return fmt::internal::null<>(); +-} +- +-FMT_BEGIN_NAMESPACE +-namespace internal { +- +-#ifndef _MSC_VER +-# define FMT_SNPRINTF snprintf +-#else // _MSC_VER +-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) { +- va_list args; +- va_start(args, format); +- int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); +- va_end(args); +- return result; +-} +-# define FMT_SNPRINTF fmt_snprintf +-#endif // _MSC_VER +- +-using format_func = void (*)(internal::buffer&, int, string_view); +- +-// Portable thread-safe version of strerror. +-// Sets buffer to point to a string describing the error code. +-// This can be either a pointer to a string stored in buffer, +-// or a pointer to some static immutable string. +-// Returns one of the following values: +-// 0 - success +-// ERANGE - buffer is not large enough to store the error message +-// other - failure +-// Buffer should be at least of size 1. +-FMT_FUNC int safe_strerror(int error_code, char*& buffer, +- std::size_t buffer_size) FMT_NOEXCEPT { +- FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer"); +- +- class dispatcher { +- private: +- int error_code_; +- char*& buffer_; +- std::size_t buffer_size_; +- +- // A noop assignment operator to avoid bogus warnings. +- void operator=(const dispatcher&) {} +- +- // Handle the result of XSI-compliant version of strerror_r. +- int handle(int result) { +- // glibc versions before 2.13 return result in errno. +- return result == -1 ? errno : result; +- } +- +- // Handle the result of GNU-specific version of strerror_r. +- int handle(char* message) { +- // If the buffer is full then the message is probably truncated. +- if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) +- return ERANGE; +- buffer_ = message; +- return 0; +- } +- +- // Handle the case when strerror_r is not available. +- int handle(internal::null<>) { +- return fallback(strerror_s(buffer_, buffer_size_, error_code_)); +- } +- +- // Fallback to strerror_s when strerror_r is not available. +- int fallback(int result) { +- // If the buffer is full then the message is probably truncated. +- return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE +- : result; +- } +- +-#if !FMT_MSC_VER +- // Fallback to strerror if strerror_r and strerror_s are not available. +- int fallback(internal::null<>) { +- errno = 0; +- buffer_ = strerror(error_code_); +- return errno; +- } +-#endif +- +- public: +- dispatcher(int err_code, char*& buf, std::size_t buf_size) +- : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} +- +- int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); } +- }; +- return dispatcher(error_code, buffer, buffer_size).run(); +-} +- +-FMT_FUNC void format_error_code(internal::buffer& out, int error_code, +- string_view message) FMT_NOEXCEPT { +- // Report error code making sure that the output fits into +- // inline_buffer_size to avoid dynamic memory allocation and potential +- // bad_alloc. +- out.resize(0); +- static const char SEP[] = ": "; +- static const char ERROR_STR[] = "error "; +- // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. +- std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; +- auto abs_value = static_cast>(error_code); +- if (internal::is_negative(error_code)) { +- abs_value = 0 - abs_value; +- ++error_code_size; +- } +- error_code_size += internal::to_unsigned(internal::count_digits(abs_value)); +- internal::writer w(out); +- if (message.size() <= inline_buffer_size - error_code_size) { +- w.write(message); +- w.write(SEP); +- } +- w.write(ERROR_STR); +- w.write(error_code); +- assert(out.size() <= inline_buffer_size); +-} +- +-// A wrapper around fwrite that throws on error. +-FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count, +- FILE* stream) { +- size_t written = std::fwrite(ptr, size, count, stream); +- if (written < count) { +- FMT_THROW(system_error(errno, "cannot write to file")); +- } +-} +- +-FMT_FUNC void report_error(format_func func, int error_code, +- string_view message) FMT_NOEXCEPT { +- memory_buffer full_message; +- func(full_message, error_code, message); +- // Don't use fwrite_fully because the latter may throw. +- (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr); +- std::fputc('\n', stderr); +-} +-} // namespace internal +- +-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) +-namespace internal { +- +-template +-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { +- static_assert(std::is_same::value, ""); +-} +- +-template Locale locale_ref::get() const { +- static_assert(std::is_same::value, ""); +- return locale_ ? *static_cast(locale_) : std::locale(); +-} +- +-template FMT_FUNC Char thousands_sep_impl(locale_ref loc) { +- return std::use_facet>(loc.get()) +- .thousands_sep(); +-} +-template FMT_FUNC Char decimal_point_impl(locale_ref loc) { +- return std::use_facet>(loc.get()) +- .decimal_point(); +-} +-} // namespace internal +-#else +-template +-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) { +- return FMT_STATIC_THOUSANDS_SEPARATOR; +-} +-template +-FMT_FUNC Char internal::decimal_point_impl(locale_ref) { +- return '.'; +-} +-#endif +- +-FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT {} +-FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT {} +- +-FMT_FUNC void system_error::init(int err_code, string_view format_str, +- format_args args) { +- error_code_ = err_code; +- memory_buffer buffer; +- format_system_error(buffer, err_code, vformat(format_str, args)); +- std::runtime_error& base = *this; +- base = std::runtime_error(to_string(buffer)); +-} +- +-namespace internal { +- +-template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) { +- // Assume little endian; pointer formatting is implementation-defined anyway. +- int i = static_cast(sizeof(void*)) - 1; +- while (i > 0 && n.value[i] == 0) --i; +- auto char_digits = std::numeric_limits::digits / 4; +- return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1; +-} +- +-template +-int format_float(char* buf, std::size_t size, const char* format, int precision, +- T value) { +-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +- if (precision > 100000) +- throw std::runtime_error( +- "fuzz mode - avoid large allocation inside snprintf"); +-#endif +- // Suppress the warning about nonliteral format string. +- auto snprintf_ptr = FMT_SNPRINTF; +- return precision < 0 ? snprintf_ptr(buf, size, format, value) +- : snprintf_ptr(buf, size, format, precision, value); +-} +- +-template +-const char basic_data::digits[] = +- "0001020304050607080910111213141516171819" +- "2021222324252627282930313233343536373839" +- "4041424344454647484950515253545556575859" +- "6061626364656667686970717273747576777879" +- "8081828384858687888990919293949596979899"; +- +-template +-const char basic_data::hex_digits[] = "0123456789abcdef"; +- +-#define FMT_POWERS_OF_10(factor) \ +- factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \ +- factor * 1000000, factor * 10000000, factor * 100000000, \ +- factor * 1000000000 +- +-template +-const uint64_t basic_data::powers_of_10_64[] = { +- 1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), +- 10000000000000000000ull}; +- +-template +-const uint32_t basic_data::zero_or_powers_of_10_32[] = {0, +- FMT_POWERS_OF_10(1)}; +- +-template +-const uint64_t basic_data::zero_or_powers_of_10_64[] = { +- 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), +- 10000000000000000000ull}; +- +-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. +-// These are generated by support/compute-powers.py. +-template +-const uint64_t basic_data::pow10_significands[] = { +- 0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, +- 0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, +- 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, +- 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, +- 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, +- 0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7, +- 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, +- 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, +- 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, +- 0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053, +- 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, +- 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, +- 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, +- 0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb, +- 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, +- 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984, +- 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, +- 0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, +- 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, +- 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85, +- 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, +- 0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25, +- 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, +- 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a, +- 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, +- 0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129, +- 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, +- 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, +- 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b, +-}; +- +-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding +-// to significands above. +-template +-const int16_t basic_data::pow10_exponents[] = { +- -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, +- -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661, +- -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, +- -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77, +- -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, +- 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508, +- 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, +- 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; +- +-template +-const char basic_data::foreground_color[] = "\x1b[38;2;"; +-template +-const char basic_data::background_color[] = "\x1b[48;2;"; +-template const char basic_data::reset_color[] = "\x1b[0m"; +-template const wchar_t basic_data::wreset_color[] = L"\x1b[0m"; +- +-template struct bits { +- static FMT_CONSTEXPR_DECL const int value = +- static_cast(sizeof(T) * std::numeric_limits::digits); +-}; +- +-// A handmade floating-point number f * pow(2, e). +-class fp { +- private: +- using significand_type = uint64_t; +- +- // All sizes are in bits. +- // Subtract 1 to account for an implicit most significant bit in the +- // normalized form. +- static FMT_CONSTEXPR_DECL const int double_significand_size = +- std::numeric_limits::digits - 1; +- static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = +- 1ull << double_significand_size; +- +- public: +- significand_type f; +- int e; +- +- static FMT_CONSTEXPR_DECL const int significand_size = +- bits::value; +- +- fp() : f(0), e(0) {} +- fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} +- +- // Constructs fp from an IEEE754 double. It is a template to prevent compile +- // errors on platforms where double is not IEEE754. +- template explicit fp(Double d) { +- // Assume double is in the format [sign][exponent][significand]. +- using limits = std::numeric_limits; +- const int exponent_size = +- bits::value - double_significand_size - 1; // -1 for sign +- const uint64_t significand_mask = implicit_bit - 1; +- const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask; +- const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1; +- auto u = bit_cast(d); +- auto biased_e = (u & exponent_mask) >> double_significand_size; +- f = u & significand_mask; +- if (biased_e != 0) +- f += implicit_bit; +- else +- biased_e = 1; // Subnormals use biased exponent 1 (min exponent). +- e = static_cast(biased_e - exponent_bias - double_significand_size); +- } +- +- // Normalizes the value converted from double and multiplied by (1 << SHIFT). +- template void normalize() { +- // Handle subnormals. +- auto shifted_implicit_bit = implicit_bit << SHIFT; +- while ((f & shifted_implicit_bit) == 0) { +- f <<= 1; +- --e; +- } +- // Subtract 1 to account for hidden bit. +- auto offset = significand_size - double_significand_size - SHIFT - 1; +- f <<= offset; +- e -= offset; +- } +- +- // Compute lower and upper boundaries (m^- and m^+ in the Grisu paper), where +- // a boundary is a value half way between the number and its predecessor +- // (lower) or successor (upper). The upper boundary is normalized and lower +- // has the same exponent but may be not normalized. +- void compute_boundaries(fp& lower, fp& upper) const { +- lower = +- f == implicit_bit ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1); +- upper = fp((f << 1) + 1, e - 1); +- upper.normalize<1>(); // 1 is to account for the exponent shift above. +- lower.f <<= lower.e - upper.e; +- lower.e = upper.e; +- } +-}; +- +-// Returns an fp number representing x - y. Result may not be normalized. +-inline fp operator-(fp x, fp y) { +- FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands"); +- return fp(x.f - y.f, x.e); +-} +- +-// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest +-// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be +-// normalized. +-FMT_FUNC fp operator*(fp x, fp y) { +- int exp = x.e + y.e + 64; +-#if FMT_USE_INT128 +- auto product = static_cast<__uint128_t>(x.f) * y.f; +- auto f = static_cast(product >> 64); +- if ((static_cast(product) & (1ULL << 63)) != 0) ++f; +- return fp(f, exp); +-#else +- // Multiply 32-bit parts of significands. +- uint64_t mask = (1ULL << 32) - 1; +- uint64_t a = x.f >> 32, b = x.f & mask; +- uint64_t c = y.f >> 32, d = y.f & mask; +- uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; +- // Compute mid 64-bit of result and round. +- uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); +- return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), exp); +-#endif +-} +- +-// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its +-// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 28. +-FMT_FUNC fp get_cached_power(int min_exponent, int& pow10_exponent) { +- const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10) +- int index = static_cast( +- std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10)); +- // Decimal exponent of the first (smallest) cached power of 10. +- const int first_dec_exp = -348; +- // Difference between 2 consecutive decimal exponents in cached powers of 10. +- const int dec_exp_step = 8; +- index = (index - first_dec_exp - 1) / dec_exp_step + 1; +- pow10_exponent = first_dec_exp + index * dec_exp_step; +- return fp(data::pow10_significands[index], data::pow10_exponents[index]); +-} +- +-enum round_direction { unknown, up, down }; +- +-// Given the divisor (normally a power of 10), the remainder = v % divisor for +-// some number v and the error, returns whether v should be rounded up, down, or +-// whether the rounding direction can't be determined due to error. +-// error should be less than divisor / 2. +-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder, +- uint64_t error) { +- FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow. +- FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow. +- FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow. +- // Round down if (remainder + error) * 2 <= divisor. +- if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2) +- return down; +- // Round up if (remainder - error) * 2 >= divisor. +- if (remainder >= error && +- remainder - error >= divisor - (remainder - error)) { +- return up; +- } +- return unknown; +-} +- +-namespace digits { +-enum result { +- more, // Generate more digits. +- done, // Done generating digits. +- error // Digit generation cancelled due to an error. +-}; +-} +- +-// Generates output using the Grisu digit-gen algorithm. +-// error: the size of the region (lower, upper) outside of which numbers +-// definitely do not round to value (Delta in Grisu3). +-template +-digits::result grisu_gen_digits(fp value, uint64_t error, int& exp, +- Handler& handler) { +- fp one(1ull << -value.e, value.e); +- // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be +- // zero because it contains a product of two 64-bit numbers with MSB set (due +- // to normalization) - 1, shifted right by at most 60 bits. +- uint32_t integral = static_cast(value.f >> -one.e); +- FMT_ASSERT(integral != 0, ""); +- FMT_ASSERT(integral == value.f >> -one.e, ""); +- // The fractional part of scaled value (p2 in Grisu) c = value % one. +- uint64_t fractional = value.f & (one.f - 1); +- exp = count_digits(integral); // kappa in Grisu. +- // Divide by 10 to prevent overflow. +- auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e, +- value.f / 10, error * 10, exp); +- if (result != digits::more) return result; +- // Generate digits for the integral part. This can produce up to 10 digits. +- do { +- uint32_t digit = 0; +- // This optimization by miloyip reduces the number of integer divisions by +- // one per iteration. +- switch (exp) { +- case 10: +- digit = integral / 1000000000; +- integral %= 1000000000; +- break; +- case 9: +- digit = integral / 100000000; +- integral %= 100000000; +- break; +- case 8: +- digit = integral / 10000000; +- integral %= 10000000; +- break; +- case 7: +- digit = integral / 1000000; +- integral %= 1000000; +- break; +- case 6: +- digit = integral / 100000; +- integral %= 100000; +- break; +- case 5: +- digit = integral / 10000; +- integral %= 10000; +- break; +- case 4: +- digit = integral / 1000; +- integral %= 1000; +- break; +- case 3: +- digit = integral / 100; +- integral %= 100; +- break; +- case 2: +- digit = integral / 10; +- integral %= 10; +- break; +- case 1: +- digit = integral; +- integral = 0; +- break; +- default: +- FMT_ASSERT(false, "invalid number of digits"); +- } +- --exp; +- uint64_t remainder = +- (static_cast(integral) << -one.e) + fractional; +- result = handler.on_digit(static_cast('0' + digit), +- data::powers_of_10_64[exp] << -one.e, remainder, +- error, exp, true); +- if (result != digits::more) return result; +- } while (exp > 0); +- // Generate digits for the fractional part. +- for (;;) { +- fractional *= 10; +- error *= 10; +- char digit = +- static_cast('0' + static_cast(fractional >> -one.e)); +- fractional &= one.f - 1; +- --exp; +- result = handler.on_digit(digit, one.f, fractional, error, exp, false); +- if (result != digits::more) return result; +- } +-} +- +-// The fixed precision digit handler. +-struct fixed_handler { +- char* buf; +- int size; +- int precision; +- int exp10; +- bool fixed; +- +- digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, +- int& exp) { +- // Non-fixed formats require at least one digit and no precision adjustment. +- if (!fixed) return digits::more; +- // Adjust fixed precision by exponent because it is relative to decimal +- // point. +- precision += exp + exp10; +- // Check if precision is satisfied just by leading zeros, e.g. +- // format("{:.2f}", 0.001) gives "0.00" without generating any digits. +- if (precision > 0) return digits::more; +- if (precision < 0) return digits::done; +- auto dir = get_round_direction(divisor, remainder, error); +- if (dir == unknown) return digits::error; +- buf[size++] = dir == up ? '1' : '0'; +- return digits::done; +- } +- +- digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, +- uint64_t error, int, bool integral) { +- FMT_ASSERT(remainder < divisor, ""); +- buf[size++] = digit; +- if (size < precision) return digits::more; +- if (!integral) { +- // Check if error * 2 < divisor with overflow prevention. +- // The check is not needed for the integral part because error = 1 +- // and divisor > (1 << 32) there. +- if (error >= divisor || error >= divisor - error) return digits::error; +- } else { +- FMT_ASSERT(error == 1 && divisor > 2, ""); +- } +- auto dir = get_round_direction(divisor, remainder, error); +- if (dir != up) return dir == down ? digits::done : digits::error; +- ++buf[size - 1]; +- for (int i = size - 1; i > 0 && buf[i] > '9'; --i) { +- buf[i] = '0'; +- ++buf[i - 1]; +- } +- if (buf[0] > '9') { +- buf[0] = '1'; +- buf[size++] = '0'; +- } +- return digits::done; +- } +-}; +- +-// The shortest representation digit handler. +-template struct grisu_shortest_handler { +- char* buf; +- int size; +- // Distance between scaled value and upper bound (wp_W in Grisu3). +- uint64_t diff; +- +- digits::result on_start(uint64_t, uint64_t, uint64_t, int&) { +- return digits::more; +- } +- +- // Decrement the generated number approaching value from above. +- void round(uint64_t d, uint64_t divisor, uint64_t& remainder, +- uint64_t error) { +- while ( +- remainder < d && error - remainder >= divisor && +- (remainder + divisor < d || d - remainder >= remainder + divisor - d)) { +- --buf[size - 1]; +- remainder += divisor; +- } +- } +- +- // Implements Grisu's round_weed. +- digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, +- uint64_t error, int exp, bool integral) { +- buf[size++] = digit; +- if (remainder >= error) return digits::more; +- if (GRISU_VERSION != 3) { +- uint64_t d = integral ? diff : diff * data::powers_of_10_64[-exp]; +- round(d, divisor, remainder, error); +- return digits::done; +- } +- uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp]; +- uint64_t up = (diff - 1) * unit; // wp_Wup +- round(up, divisor, remainder, error); +- uint64_t down = (diff + 1) * unit; // wp_Wdown +- if (remainder < down && error - remainder >= divisor && +- (remainder + divisor < down || +- down - remainder > remainder + divisor - down)) { +- return digits::error; +- } +- return 2 * unit <= remainder && remainder <= error - 4 * unit +- ? digits::done +- : digits::error; +- } +-}; +- +-template > +-FMT_API bool grisu_format(Double value, buffer& buf, int precision, +- unsigned options, int& exp) { +- FMT_ASSERT(value >= 0, "value is negative"); +- bool fixed = (options & grisu_options::fixed) != 0; +- if (value <= 0) { // <= instead of == to silence a warning. +- if (precision <= 0 || !fixed) { +- exp = 0; +- buf.push_back('0'); +- } else { +- exp = -precision; +- buf.resize(precision); +- std::uninitialized_fill_n(buf.data(), precision, '0'); +- } +- return true; +- } +- +- fp fp_value(value); +- const int min_exp = -60; // alpha in Grisu. +- int cached_exp10 = 0; // K in Grisu. +- if (precision != -1) { +- if (precision > 17) return false; +- fp_value.normalize(); +- auto cached_pow = get_cached_power( +- min_exp - (fp_value.e + fp::significand_size), cached_exp10); +- fp_value = fp_value * cached_pow; +- fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed}; +- if (grisu_gen_digits(fp_value, 1, exp, handler) == digits::error) +- return false; +- buf.resize(to_unsigned(handler.size)); +- } else { +- fp lower, upper; // w^- and w^+ in the Grisu paper. +- fp_value.compute_boundaries(lower, upper); +- // Find a cached power of 10 such that multiplying upper by it will bring +- // the exponent in the range [min_exp, -32]. +- auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu. +- min_exp - (upper.e + fp::significand_size), cached_exp10); +- fp_value.normalize(); +- fp_value = fp_value * cached_pow; +- lower = lower * cached_pow; // \tilde{M}^- in Grisu. +- upper = upper * cached_pow; // \tilde{M}^+ in Grisu. +- assert(min_exp <= upper.e && upper.e <= -32); +- auto result = digits::result(); +- int size = 0; +- if ((options & grisu_options::grisu3) != 0) { +- --lower.f; // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}. +- ++upper.f; // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}. +- // Numbers outside of (lower, upper) definitely do not round to value. +- grisu_shortest_handler<3> handler{buf.data(), 0, (upper - fp_value).f}; +- result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler); +- size = handler.size; +- } else { +- ++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}. +- --upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}. +- grisu_shortest_handler<2> handler{buf.data(), 0, (upper - fp_value).f}; +- result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler); +- size = handler.size; +- } +- if (result == digits::error) return false; +- buf.resize(to_unsigned(size)); +- } +- exp -= cached_exp10; +- return true; +-} +- +-template +-char* sprintf_format(Double value, internal::buffer& buf, +- sprintf_specs specs) { +- // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. +- FMT_ASSERT(buf.capacity() != 0, "empty buffer"); +- +- // Build format string. +- enum { max_format_size = 10 }; // longest format: %#-*.*Lg +- char format[max_format_size]; +- char* format_ptr = format; +- *format_ptr++ = '%'; +- if (specs.alt || !specs.type) *format_ptr++ = '#'; +- if (specs.precision >= 0) { +- *format_ptr++ = '.'; +- *format_ptr++ = '*'; +- } +- if (std::is_same::value) *format_ptr++ = 'L'; +- +- char type = specs.type; +- +- if (type == '%') +- type = 'f'; +- else if (type == 0 || type == 'n') +- type = 'g'; +-#if FMT_MSC_VER +- if (type == 'F') { +- // MSVC's printf doesn't support 'F'. +- type = 'f'; +- } +-#endif +- *format_ptr++ = type; +- *format_ptr = '\0'; +- +- // Format using snprintf. +- char* start = nullptr; +- char* decimal_point_pos = nullptr; +- for (;;) { +- std::size_t buffer_size = buf.capacity(); +- start = &buf[0]; +- int result = +- format_float(start, buffer_size, format, specs.precision, value); +- if (result >= 0) { +- unsigned n = internal::to_unsigned(result); +- if (n < buf.capacity()) { +- // Find the decimal point. +- auto p = buf.data(), end = p + n; +- if (*p == '+' || *p == '-') ++p; +- if (specs.type != 'a' && specs.type != 'A') { +- while (p < end && *p >= '0' && *p <= '9') ++p; +- if (p < end && *p != 'e' && *p != 'E') { +- decimal_point_pos = p; +- if (!specs.type) { +- // Keep only one trailing zero after the decimal point. +- ++p; +- if (*p == '0') ++p; +- while (p != end && *p >= '1' && *p <= '9') ++p; +- char* where = p; +- while (p != end && *p == '0') ++p; +- if (p == end || *p < '0' || *p > '9') { +- if (p != end) std::memmove(where, p, to_unsigned(end - p)); +- n -= static_cast(p - where); +- } +- } +- } +- } +- buf.resize(n); +- break; // The buffer is large enough - continue with formatting. +- } +- buf.reserve(n + 1); +- } else { +- // If result is negative we ask to increase the capacity by at least 1, +- // but as std::vector, the buffer grows exponentially. +- buf.reserve(buf.capacity() + 1); +- } +- } +- return decimal_point_pos; +-} +-} // namespace internal +- +-#if FMT_USE_WINDOWS_H +- +-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) { +- static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; +- if (s.size() > INT_MAX) +- FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG)); +- int s_size = static_cast(s.size()); +- if (s_size == 0) { +- // MultiByteToWideChar does not support zero length, handle separately. +- buffer_.resize(1); +- buffer_[0] = 0; +- return; +- } +- +- int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), +- s_size, nullptr, 0); +- if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); +- buffer_.resize(length + 1); +- length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, +- &buffer_[0], length); +- if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); +- buffer_[length] = 0; +-} +- +-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) { +- if (int error_code = convert(s)) { +- FMT_THROW(windows_error(error_code, +- "cannot convert string from UTF-16 to UTF-8")); +- } +-} +- +-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) { +- if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER; +- int s_size = static_cast(s.size()); +- if (s_size == 0) { +- // WideCharToMultiByte does not support zero length, handle separately. +- buffer_.resize(1); +- buffer_[0] = 0; +- return 0; +- } +- +- int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0, +- nullptr, nullptr); +- if (length == 0) return GetLastError(); +- buffer_.resize(length + 1); +- length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], +- length, nullptr, nullptr); +- if (length == 0) return GetLastError(); +- buffer_[length] = 0; +- return 0; +-} +- +-FMT_FUNC void windows_error::init(int err_code, string_view format_str, +- format_args args) { +- error_code_ = err_code; +- memory_buffer buffer; +- internal::format_windows_error(buffer, err_code, vformat(format_str, args)); +- std::runtime_error& base = *this; +- base = std::runtime_error(to_string(buffer)); +-} +- +-FMT_FUNC void internal::format_windows_error(internal::buffer& out, +- int error_code, +- string_view message) FMT_NOEXCEPT { +- FMT_TRY { +- wmemory_buffer buf; +- buf.resize(inline_buffer_size); +- for (;;) { +- wchar_t* system_message = &buf[0]; +- int result = FormatMessageW( +- FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, +- error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, +- static_cast(buf.size()), nullptr); +- if (result != 0) { +- utf16_to_utf8 utf8_message; +- if (utf8_message.convert(system_message) == ERROR_SUCCESS) { +- internal::writer w(out); +- w.write(message); +- w.write(": "); +- w.write(utf8_message); +- return; +- } +- break; +- } +- if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) +- break; // Can't get error message, report error code instead. +- buf.resize(buf.size() * 2); +- } +- } +- FMT_CATCH(...) {} +- format_error_code(out, error_code, message); +-} +- +-#endif // FMT_USE_WINDOWS_H +- +-FMT_FUNC void format_system_error(internal::buffer& out, int error_code, +- string_view message) FMT_NOEXCEPT { +- FMT_TRY { +- memory_buffer buf; +- buf.resize(inline_buffer_size); +- for (;;) { +- char* system_message = &buf[0]; +- int result = +- internal::safe_strerror(error_code, system_message, buf.size()); +- if (result == 0) { +- internal::writer w(out); +- w.write(message); +- w.write(": "); +- w.write(system_message); +- return; +- } +- if (result != ERANGE) +- break; // Can't get error message, report error code instead. +- buf.resize(buf.size() * 2); +- } +- } +- FMT_CATCH(...) {} +- format_error_code(out, error_code, message); +-} +- +-FMT_FUNC void internal::error_handler::on_error(const char* message) { +- FMT_THROW(format_error(message)); +-} +- +-FMT_FUNC void report_system_error(int error_code, +- fmt::string_view message) FMT_NOEXCEPT { +- report_error(format_system_error, error_code, message); +-} +- +-#if FMT_USE_WINDOWS_H +-FMT_FUNC void report_windows_error(int error_code, +- fmt::string_view message) FMT_NOEXCEPT { +- report_error(internal::format_windows_error, error_code, message); +-} +-#endif +- +-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) { +- memory_buffer buffer; +- internal::vformat_to(buffer, format_str, +- basic_format_args>(args)); +- internal::fwrite_fully(buffer.data(), 1, buffer.size(), f); +-} +- +-FMT_FUNC void vprint(std::FILE* f, wstring_view format_str, wformat_args args) { +- wmemory_buffer buffer; +- internal::vformat_to(buffer, format_str, args); +- buffer.push_back(L'\0'); +- if (std::fputws(buffer.data(), f) == -1) { +- FMT_THROW(system_error(errno, "cannot write to file")); +- } +-} +- +-FMT_FUNC void vprint(string_view format_str, format_args args) { +- vprint(stdout, format_str, args); +-} +- +-FMT_FUNC void vprint(wstring_view format_str, wformat_args args) { +- vprint(stdout, format_str, args); +-} +- +-FMT_END_NAMESPACE +- +-#ifdef _MSC_VER +-# pragma warning(pop) +-#endif +- +-#endif // FMT_FORMAT_INL_H_ +diff --git a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format.h b/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format.h +deleted file mode 100644 +index dcf4a39981..0000000000 +--- a/ThirdParty/diy2/vtkdiy2/include/vtkdiy2/fmt/format.h ++++ /dev/null +@@ -1,3602 +0,0 @@ +-/* +- Formatting library for C++ +- +- Copyright (c) 2012 - present, Victor Zverovich +- +- Permission is hereby granted, free of charge, to any person obtaining +- a copy of this software and associated documentation files (the +- "Software"), to deal in the Software without restriction, including +- without limitation the rights to use, copy, modify, merge, publish, +- distribute, sublicense, and/or sell copies of the Software, and to +- permit persons to whom the Software is furnished to do so, subject to +- the following conditions: +- +- The above copyright notice and this permission notice shall be +- included in all copies or substantial portions of the Software. +- +- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +- +- --- Optional exception to the license --- +- +- As an exception, if, as a result of your compiling your source code, portions +- of this Software are embedded into a machine-executable object form of such +- source code, you may redistribute such embedded portions in such object form +- without including the above copyright and permission notices. +- */ +- +-#ifndef FMT_FORMAT_H_ +-#define FMT_FORMAT_H_ +- +-#define FMT_HEADER_ONLY // Added by diy for header-only usage +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#include "core.h" +- +-#ifdef __clang__ +-# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +-#else +-# define FMT_CLANG_VERSION 0 +-#endif +- +-#ifdef __INTEL_COMPILER +-# define FMT_ICC_VERSION __INTEL_COMPILER +-#elif defined(__ICL) +-# define FMT_ICC_VERSION __ICL +-#else +-# define FMT_ICC_VERSION 0 +-#endif +- +-#ifdef __NVCC__ +-# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__) +-#else +-# define FMT_CUDA_VERSION 0 +-#endif +- +-#ifdef __has_builtin +-# define FMT_HAS_BUILTIN(x) __has_builtin(x) +-#else +-# define FMT_HAS_BUILTIN(x) 0 +-#endif +- +-#ifndef FMT_THROW +-# if FMT_EXCEPTIONS +-# if FMT_MSC_VER +-FMT_BEGIN_NAMESPACE +-namespace internal { +-template inline void do_throw(const Exception& x) { +- // Silence unreachable code warnings in MSVC because these are nearly +- // impossible to fix in a generic code. +- volatile bool b = true; +- if (b) throw x; +-} +-} // namespace internal +-FMT_END_NAMESPACE +-# define FMT_THROW(x) fmt::internal::do_throw(x) +-# else +-# define FMT_THROW(x) throw x +-# endif +-# else +-# define FMT_THROW(x) \ +- do { \ +- static_cast(sizeof(x)); \ +- assert(false); \ +- } while (false) +-# endif +-#endif +- +-#ifndef FMT_USE_USER_DEFINED_LITERALS +-// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs. +-# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \ +- FMT_MSC_VER >= 1900) && \ +- (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \ +- FMT_CUDA_VERSION >= 700) +-# define FMT_USE_USER_DEFINED_LITERALS 1 +-# else +-# define FMT_USE_USER_DEFINED_LITERALS 0 +-# endif +-#endif +- +-#ifndef FMT_USE_UDL_TEMPLATE +-// EDG front end based compilers (icc, nvcc) do not support UDL templates yet +-// and GCC 9 warns about them. +-# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \ +- FMT_CUDA_VERSION == 0 && \ +- ((FMT_GCC_VERSION >= 600 && FMT_GCC_VERSION <= 900 && \ +- __cplusplus >= 201402L) || \ +- FMT_CLANG_VERSION >= 304) +-# define FMT_USE_UDL_TEMPLATE 1 +-# else +-# define FMT_USE_UDL_TEMPLATE 0 +-# endif +-#endif +- +-#ifdef FMT_USE_INT128 +-// Do nothing. +-#elif defined(__SIZEOF_INT128__) +-# define FMT_USE_INT128 1 +-#else +-# define FMT_USE_INT128 0 +-#endif +- +-// __builtin_clz is broken in clang with Microsoft CodeGen: +-// https://github.com/fmtlib/fmt/issues/519 +-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER +-# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +-#endif +-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER +-# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +-#endif +- +-// Some compilers masquerade as both MSVC and GCC-likes or otherwise support +-// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the +-// MSVC intrinsics if the clz and clzll builtins are not available. +-#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) +-# include // _BitScanReverse, _BitScanReverse64 +- +-FMT_BEGIN_NAMESPACE +-namespace internal { +-// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. +-# ifndef __clang__ +-# pragma intrinsic(_BitScanReverse) +-# endif +-inline uint32_t clz(uint32_t x) { +- unsigned long r = 0; +- _BitScanReverse(&r, x); +- +- assert(x != 0); +- // Static analysis complains about using uninitialized data +- // "r", but the only way that can happen is if "x" is 0, +- // which the callers guarantee to not happen. +-# pragma warning(suppress : 6102) +- return 31 - r; +-} +-# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) +- +-# if defined(_WIN64) && !defined(__clang__) +-# pragma intrinsic(_BitScanReverse64) +-# endif +- +-inline uint32_t clzll(uint64_t x) { +- unsigned long r = 0; +-# ifdef _WIN64 +- _BitScanReverse64(&r, x); +-# else +- // Scan the high 32 bits. +- if (_BitScanReverse(&r, static_cast(x >> 32))) return 63 - (r + 32); +- +- // Scan the low 32 bits. +- _BitScanReverse(&r, static_cast(x)); +-# endif +- +- assert(x != 0); +- // Static analysis complains about using uninitialized data +- // "r", but the only way that can happen is if "x" is 0, +- // which the callers guarantee to not happen. +-# pragma warning(suppress : 6102) +- return 63 - r; +-} +-# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) +-} // namespace internal +-FMT_END_NAMESPACE +-#endif +- +-FMT_BEGIN_NAMESPACE +-namespace internal { +- +-// A fallback implementation of uintptr_t for systems that lack it. +-struct fallback_uintptr { +- unsigned char value[sizeof(void*)]; +-}; +-#ifdef UINTPTR_MAX +-using uintptr_t = ::uintptr_t; +-#else +-using uintptr_t = fallback_uintptr; +-#endif +- +-// An equivalent of `*reinterpret_cast(&source)` that doesn't produce +-// undefined behavior (e.g. due to type aliasing). +-// Example: uint64_t d = bit_cast(2.718); +-template +-inline Dest bit_cast(const Source& source) { +- static_assert(sizeof(Dest) == sizeof(Source), "size mismatch"); +- Dest dest; +- std::memcpy(&dest, &source, sizeof(dest)); +- return dest; +-} +- +-// An approximation of iterator_t for pre-C++20 systems. +-template +-using iterator_t = decltype(std::begin(std::declval())); +- +-// Detect the iterator category of *any* given type in a SFINAE-friendly way. +-// Unfortunately, older implementations of std::iterator_traits are not safe +-// for use in a SFINAE-context. +-template +-struct iterator_category : std::false_type {}; +- +-template struct iterator_category { +- using type = std::random_access_iterator_tag; +-}; +- +-template +-struct iterator_category> { +- using type = typename It::iterator_category; +-}; +- +-// Detect if *any* given type models the OutputIterator concept. +-template class is_output_iterator { +- // Check for mutability because all iterator categories derived from +- // std::input_iterator_tag *may* also meet the requirements of an +- // OutputIterator, thereby falling into the category of 'mutable iterators' +- // [iterator.requirements.general] clause 4. The compiler reveals this +- // property only at the point of *actually dereferencing* the iterator! +- template +- static decltype(*(std::declval())) test(std::input_iterator_tag); +- template static char& test(std::output_iterator_tag); +- template static const char& test(...); +- +- using type = decltype(test(typename iterator_category::type{})); +- +- public: +- static const bool value = !std::is_const>::value; +-}; +- +-// A workaround for std::string not having mutable data() until C++17. +-template inline Char* get_data(std::basic_string& s) { +- return &s[0]; +-} +-template +-inline typename Container::value_type* get_data(Container& c) { +- return c.data(); +-} +- +-#ifdef _SECURE_SCL +-// Make a checked iterator to avoid MSVC warnings. +-template using checked_ptr = stdext::checked_array_iterator; +-template checked_ptr make_checked(T* p, std::size_t size) { +- return {p, size}; +-} +-#else +-template using checked_ptr = T*; +-template inline T* make_checked(T* p, std::size_t) { return p; } +-#endif +- +-template ::value)> +-inline checked_ptr reserve( +- std::back_insert_iterator& it, std::size_t n) { +- Container& c = get_container(it); +- std::size_t size = c.size(); +- c.resize(size + n); +- return make_checked(get_data(c) + size, n); +-} +- +-template +-inline Iterator& reserve(Iterator& it, std::size_t) { +- return it; +-} +- +-// An output iterator that counts the number of objects written to it and +-// discards them. +-template class counting_iterator { +- private: +- std::size_t count_; +- mutable T blackhole_; +- +- public: +- using iterator_category = std::output_iterator_tag; +- using value_type = T; +- using difference_type = std::ptrdiff_t; +- using pointer = T*; +- using reference = T&; +- using _Unchecked_type = counting_iterator; // Mark iterator as checked. +- +- counting_iterator() : count_(0) {} +- +- std::size_t count() const { return count_; } +- +- counting_iterator& operator++() { +- ++count_; +- return *this; +- } +- +- counting_iterator operator++(int) { +- auto it = *this; +- ++*this; +- return it; +- } +- +- T& operator*() const { return blackhole_; } +-}; +- +-template class truncating_iterator_base { +- protected: +- OutputIt out_; +- std::size_t limit_; +- std::size_t count_; +- +- truncating_iterator_base(OutputIt out, std::size_t limit) +- : out_(out), limit_(limit), count_(0) {} +- +- public: +- using iterator_category = std::output_iterator_tag; +- using difference_type = void; +- using pointer = void; +- using reference = void; +- using _Unchecked_type = +- truncating_iterator_base; // Mark iterator as checked. +- +- OutputIt base() const { return out_; } +- std::size_t count() const { return count_; } +-}; +- +-// An output iterator that truncates the output and counts the number of objects +-// written to it. +-template ::value_type>::type> +-class truncating_iterator; +- +-template +-class truncating_iterator +- : public truncating_iterator_base { +- using traits = std::iterator_traits; +- +- mutable typename traits::value_type blackhole_; +- +- public: +- using value_type = typename traits::value_type; +- +- truncating_iterator(OutputIt out, std::size_t limit) +- : truncating_iterator_base(out, limit) {} +- +- truncating_iterator& operator++() { +- if (this->count_++ < this->limit_) ++this->out_; +- return *this; +- } +- +- truncating_iterator operator++(int) { +- auto it = *this; +- ++*this; +- return it; +- } +- +- value_type& operator*() const { +- return this->count_ < this->limit_ ? *this->out_ : blackhole_; +- } +-}; +- +-template +-class truncating_iterator +- : public truncating_iterator_base { +- public: +- using value_type = typename OutputIt::container_type::value_type; +- +- truncating_iterator(OutputIt out, std::size_t limit) +- : truncating_iterator_base(out, limit) {} +- +- truncating_iterator& operator=(value_type val) { +- if (this->count_++ < this->limit_) this->out_ = val; +- return *this; +- } +- +- truncating_iterator& operator++() { return *this; } +- truncating_iterator& operator++(int) { return *this; } +- truncating_iterator& operator*() { return *this; } +-}; +- +-// A range with the specified output iterator and value type. +-template +-class output_range { +- private: +- OutputIt it_; +- +- public: +- using value_type = T; +- using iterator = OutputIt; +- struct sentinel {}; +- +- explicit output_range(OutputIt it) : it_(it) {} +- OutputIt begin() const { return it_; } +- sentinel end() const { return {}; } // Sentinel is not used yet. +-}; +- +-// A range with an iterator appending to a buffer. +-template +-class buffer_range +- : public output_range>, T> { +- public: +- using iterator = std::back_insert_iterator>; +- using output_range::output_range; +- buffer_range(buffer& buf) +- : output_range(std::back_inserter(buf)) {} +-}; +- +-template +-inline size_t count_code_points(basic_string_view s) { +- return s.size(); +-} +- +-// Counts the number of code points in a UTF-8 string. +-inline size_t count_code_points(basic_string_view s) { +- const char8_t* data = s.data(); +- size_t num_code_points = 0; +- for (size_t i = 0, size = s.size(); i != size; ++i) { +- if ((data[i] & 0xc0) != 0x80) ++num_code_points; +- } +- return num_code_points; +-} +- +-inline char8_t to_char8_t(char c) { return static_cast(c); } +- +-template +-using needs_conversion = bool_constant< +- std::is_same::value_type, +- char>::value && +- std::is_same::value>; +- +-template ::value)> +-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) { +- return std::copy(begin, end, it); +-} +- +-template ::value)> +-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) { +- return std::transform(begin, end, it, to_char8_t); +-} +- +-#ifndef FMT_USE_GRISU +-# define FMT_USE_GRISU 0 +-#endif +- +-template constexpr bool use_grisu() { +- return FMT_USE_GRISU && std::numeric_limits::is_iec559 && +- sizeof(T) <= sizeof(double); +-} +- +-template +-template +-void buffer::append(const U* begin, const U* end) { +- std::size_t new_size = size_ + to_unsigned(end - begin); +- reserve(new_size); +- std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_); +- size_ = new_size; +-} +-} // namespace internal +- +-// A UTF-8 string view. +-class u8string_view : public basic_string_view { +- public: +- u8string_view(const char* s) +- : basic_string_view(reinterpret_cast(s)) {} +- u8string_view(const char* s, size_t count) FMT_NOEXCEPT +- : basic_string_view(reinterpret_cast(s), count) { +- } +-}; +- +-#if FMT_USE_USER_DEFINED_LITERALS +-inline namespace literals { +-inline u8string_view operator"" _u(const char* s, std::size_t n) { +- return {s, n}; +-} +-} // namespace literals +-#endif +- +-// The number of characters to store in the basic_memory_buffer object itself +-// to avoid dynamic memory allocation. +-enum { inline_buffer_size = 500 }; +- +-/** +- \rst +- A dynamically growing memory buffer for trivially copyable/constructible types +- with the first ``SIZE`` elements stored in the object itself. +- +- You can use one of the following type aliases for common character types: +- +- +----------------+------------------------------+ +- | Type | Definition | +- +================+==============================+ +- | memory_buffer | basic_memory_buffer | +- +----------------+------------------------------+ +- | wmemory_buffer | basic_memory_buffer | +- +----------------+------------------------------+ +- +- **Example**:: +- +- fmt::memory_buffer out; +- format_to(out, "The answer is {}.", 42); +- +- This will append the following output to the ``out`` object: +- +- .. code-block:: none +- +- The answer is 42. +- +- The output can be converted to an ``std::string`` with ``to_string(out)``. +- \endrst +- */ +-template > +-class basic_memory_buffer : private Allocator, public internal::buffer { +- private: +- T store_[SIZE]; +- +- // Deallocate memory allocated by the buffer. +- void deallocate() { +- T* data = this->data(); +- if (data != store_) Allocator::deallocate(data, this->capacity()); +- } +- +- protected: +- void grow(std::size_t size) FMT_OVERRIDE; +- +- public: +- using value_type = T; +- using const_reference = const T&; +- +- explicit basic_memory_buffer(const Allocator& alloc = Allocator()) +- : Allocator(alloc) { +- this->set(store_, SIZE); +- } +- ~basic_memory_buffer() { deallocate(); } +- +- private: +- // Move data from other to this buffer. +- void move(basic_memory_buffer& other) { +- Allocator &this_alloc = *this, &other_alloc = other; +- this_alloc = std::move(other_alloc); +- T* data = other.data(); +- std::size_t size = other.size(), capacity = other.capacity(); +- if (data == other.store_) { +- this->set(store_, capacity); +- std::uninitialized_copy(other.store_, other.store_ + size, +- internal::make_checked(store_, capacity)); +- } else { +- this->set(data, capacity); +- // Set pointer to the inline array so that delete is not called +- // when deallocating. +- other.set(other.store_, 0); +- } +- this->resize(size); +- } +- +- public: +- /** +- \rst +- Constructs a :class:`fmt::basic_memory_buffer` object moving the content +- of the other object to it. +- \endrst +- */ +- basic_memory_buffer(basic_memory_buffer&& other) { move(other); } +- +- /** +- \rst +- Moves the content of the other ``basic_memory_buffer`` object to this one. +- \endrst +- */ +- basic_memory_buffer& operator=(basic_memory_buffer&& other) { +- assert(this != &other); +- deallocate(); +- move(other); +- return *this; +- } +- +- // Returns a copy of the allocator associated with this buffer. +- Allocator get_allocator() const { return *this; } +-}; +- +-template +-void basic_memory_buffer::grow(std::size_t size) { +-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +- if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much"); +-#endif +- std::size_t old_capacity = this->capacity(); +- std::size_t new_capacity = old_capacity + old_capacity / 2; +- if (size > new_capacity) new_capacity = size; +- T* old_data = this->data(); +- T* new_data = std::allocator_traits::allocate(*this, new_capacity); +- // The following code doesn't throw, so the raw pointer above doesn't leak. +- std::uninitialized_copy(old_data, old_data + this->size(), +- internal::make_checked(new_data, new_capacity)); +- this->set(new_data, new_capacity); +- // deallocate must not throw according to the standard, but even if it does, +- // the buffer already uses the new storage and will deallocate it in +- // destructor. +- if (old_data != store_) Allocator::deallocate(old_data, old_capacity); +-} +- +-using memory_buffer = basic_memory_buffer; +-using wmemory_buffer = basic_memory_buffer; +- +-/** A formatting error such as invalid format string. */ +-class FMT_API format_error : public std::runtime_error { +- public: +- explicit format_error(const char* message) : std::runtime_error(message) {} +- explicit format_error(const std::string& message) +- : std::runtime_error(message) {} +- ~format_error() FMT_NOEXCEPT; +-}; +- +-namespace internal { +- +-// Returns true if value is negative, false otherwise. +-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type. +-template ::is_signed)> +-FMT_CONSTEXPR bool is_negative(T value) { +- return value < 0; +-} +-template ::is_signed)> +-FMT_CONSTEXPR bool is_negative(T) { +- return false; +-} +- +-// Smallest of uint32_t and uint64_t that is large enough to represent all +-// values of T. +-template +-using uint32_or_64_t = +- conditional_t::digits <= 32, uint32_t, uint64_t>; +- +-// Static data is placed in this class template for the header-only config. +-template struct FMT_EXTERN_TEMPLATE_API basic_data { +- static const uint64_t powers_of_10_64[]; +- static const uint32_t zero_or_powers_of_10_32[]; +- static const uint64_t zero_or_powers_of_10_64[]; +- static const uint64_t pow10_significands[]; +- static const int16_t pow10_exponents[]; +- static const char digits[]; +- static const char hex_digits[]; +- static const char foreground_color[]; +- static const char background_color[]; +- static const char reset_color[5]; +- static const wchar_t wreset_color[5]; +-}; +- +-FMT_EXTERN template struct basic_data; +- +-// This is a struct rather than an alias to avoid shadowing warnings in gcc. +-struct data : basic_data<> {}; +- +-#ifdef FMT_BUILTIN_CLZLL +-// Returns the number of decimal digits in n. Leading zeros are not counted +-// except for n == 0 in which case count_digits returns 1. +-inline int count_digits(uint64_t n) { +- // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 +- // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. +- int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; +- return t - (n < data::zero_or_powers_of_10_64[t]) + 1; +-} +-#else +-// Fallback version of count_digits used when __builtin_clz is not available. +-inline int count_digits(uint64_t n) { +- int count = 1; +- for (;;) { +- // Integer division is slow so do it for a group of four digits instead +- // of for every digit. The idea comes from the talk by Alexandrescu +- // "Three Optimization Tips for C++". See speed-test for a comparison. +- if (n < 10) return count; +- if (n < 100) return count + 1; +- if (n < 1000) return count + 2; +- if (n < 10000) return count + 3; +- n /= 10000u; +- count += 4; +- } +-} +-#endif +- +-// Counts the number of digits in n. BITS = log2(radix). +-template inline int count_digits(UInt n) { +- int num_digits = 0; +- do { +- ++num_digits; +- } while ((n >>= BITS) != 0); +- return num_digits; +-} +- +-template <> int count_digits<4>(internal::fallback_uintptr n); +- +-#if FMT_HAS_CPP_ATTRIBUTE(always_inline) +-# define FMT_ALWAYS_INLINE __attribute__((always_inline)) +-#else +-# define FMT_ALWAYS_INLINE +-#endif +- +-template +-inline char* lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE; +- +-// Computes g = floor(log10(n)) and calls h.on(n); +-template inline char* lg(uint32_t n, Handler h) { +- return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n) +- : n < 1000000 +- ? n < 10000 ? n < 1000 ? h.template on<2>(n) +- : h.template on<3>(n) +- : n < 100000 ? h.template on<4>(n) +- : h.template on<5>(n) +- : n < 100000000 ? n < 10000000 ? h.template on<6>(n) +- : h.template on<7>(n) +- : n < 1000000000 ? h.template on<8>(n) +- : h.template on<9>(n); +-} +- +-// An lg handler that formats a decimal number. +-// Usage: lg(n, decimal_formatter(buffer)); +-class decimal_formatter { +- private: +- char* buffer_; +- +- void write_pair(unsigned N, uint32_t index) { +- std::memcpy(buffer_ + N, data::digits + index * 2, 2); +- } +- +- public: +- explicit decimal_formatter(char* buf) : buffer_(buf) {} +- +- template char* on(uint32_t u) { +- if (N == 0) { +- *buffer_ = static_cast(u) + '0'; +- } else if (N == 1) { +- write_pair(0, u); +- } else { +- // The idea of using 4.32 fixed-point numbers is based on +- // https://github.com/jeaiii/itoa +- unsigned n = N - 1; +- unsigned a = n / 5 * n * 53 / 16; +- uint64_t t = +- ((1ULL << (32 + a)) / data::zero_or_powers_of_10_32[n] + 1 - n / 9); +- t = ((t * u) >> a) + n / 5 * 4; +- write_pair(0, t >> 32); +- for (unsigned i = 2; i < N; i += 2) { +- t = 100ULL * static_cast(t); +- write_pair(i, t >> 32); +- } +- if (N % 2 == 0) { +- buffer_[N] = +- static_cast((10ULL * static_cast(t)) >> 32) + '0'; +- } +- } +- return buffer_ += N + 1; +- } +-}; +- +-#ifdef FMT_BUILTIN_CLZ +-// Optional version of count_digits for better performance on 32-bit platforms. +-inline int count_digits(uint32_t n) { +- int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; +- return t - (n < data::zero_or_powers_of_10_32[t]) + 1; +-} +-#endif +- +-template FMT_API Char thousands_sep_impl(locale_ref loc); +-template inline Char thousands_sep(locale_ref loc) { +- return Char(thousands_sep_impl(loc)); +-} +-template <> inline wchar_t thousands_sep(locale_ref loc) { +- return thousands_sep_impl(loc); +-} +- +-template FMT_API Char decimal_point_impl(locale_ref loc); +-template inline Char decimal_point(locale_ref loc) { +- return Char(decimal_point_impl(loc)); +-} +-template <> inline wchar_t decimal_point(locale_ref loc) { +- return decimal_point_impl(loc); +-} +- +-// Formats a decimal unsigned integer value writing into buffer. +-// add_thousands_sep is called after writing each char to add a thousands +-// separator if necessary. +-template +-inline Char* format_decimal(Char* buffer, UInt value, int num_digits, +- F add_thousands_sep) { +- FMT_ASSERT(num_digits >= 0, "invalid digit count"); +- buffer += num_digits; +- Char* end = buffer; +- while (value >= 100) { +- // Integer division is slow so do it for a group of two digits instead +- // of for every digit. The idea comes from the talk by Alexandrescu +- // "Three Optimization Tips for C++". See speed-test for a comparison. +- unsigned index = static_cast((value % 100) * 2); +- value /= 100; +- *--buffer = static_cast(data::digits[index + 1]); +- add_thousands_sep(buffer); +- *--buffer = static_cast(data::digits[index]); +- add_thousands_sep(buffer); +- } +- if (value < 10) { +- *--buffer = static_cast('0' + value); +- return end; +- } +- unsigned index = static_cast(value * 2); +- *--buffer = static_cast(data::digits[index + 1]); +- add_thousands_sep(buffer); +- *--buffer = static_cast(data::digits[index]); +- return end; +-} +- +-template +-inline Iterator format_decimal(Iterator out, UInt value, int num_digits, +- F add_thousands_sep) { +- FMT_ASSERT(num_digits >= 0, "invalid digit count"); +- // Buffer should be large enough to hold all digits (<= digits10 + 1). +- enum { max_size = std::numeric_limits::digits10 + 1 }; +- Char buffer[max_size + max_size / 3]; +- auto end = format_decimal(buffer, value, num_digits, add_thousands_sep); +- return internal::copy_str(buffer, end, out); +-} +- +-template +-inline It format_decimal(It out, UInt value, int num_digits) { +- return format_decimal(out, value, num_digits, [](Char*) {}); +-} +- +-template +-inline Char* format_uint(Char* buffer, UInt value, int num_digits, +- bool upper = false) { +- buffer += num_digits; +- Char* end = buffer; +- do { +- const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits; +- unsigned digit = (value & ((1 << BASE_BITS) - 1)); +- *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) +- : digits[digit]); +- } while ((value >>= BASE_BITS) != 0); +- return end; +-} +- +-template +-Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits, +- bool = false) { +- auto char_digits = std::numeric_limits::digits / 4; +- int start = (num_digits + char_digits - 1) / char_digits - 1; +- if (int start_digits = num_digits % char_digits) { +- unsigned value = n.value[start--]; +- buffer = format_uint(buffer, value, start_digits); +- } +- for (; start >= 0; --start) { +- unsigned value = n.value[start]; +- buffer += char_digits; +- auto p = buffer; +- for (int i = 0; i < char_digits; ++i) { +- unsigned digit = (value & ((1 << BASE_BITS) - 1)); +- *--p = static_cast(data::hex_digits[digit]); +- value >>= BASE_BITS; +- } +- } +- return buffer; +-} +- +-template +-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) { +- // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). +- char buffer[std::numeric_limits::digits / BASE_BITS + 1]; +- format_uint(buffer, value, num_digits, upper); +- return internal::copy_str(buffer, buffer + num_digits, out); +-} +- +-#ifndef _WIN32 +-# define FMT_USE_WINDOWS_H 0 +-#elif !defined(FMT_USE_WINDOWS_H) +-# define FMT_USE_WINDOWS_H 1 +-#endif +- +-// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h. +-// All the functionality that relies on it will be disabled too. +-#if FMT_USE_WINDOWS_H +-// A converter from UTF-8 to UTF-16. +-// It is only provided for Windows since other systems support UTF-8 natively. +-class utf8_to_utf16 { +- private: +- wmemory_buffer buffer_; +- +- public: +- FMT_API explicit utf8_to_utf16(string_view s); +- operator wstring_view() const { return wstring_view(&buffer_[0], size()); } +- size_t size() const { return buffer_.size() - 1; } +- const wchar_t* c_str() const { return &buffer_[0]; } +- std::wstring str() const { return std::wstring(&buffer_[0], size()); } +-}; +- +-// A converter from UTF-16 to UTF-8. +-// It is only provided for Windows since other systems support UTF-8 natively. +-class utf16_to_utf8 { +- private: +- memory_buffer buffer_; +- +- public: +- utf16_to_utf8() {} +- FMT_API explicit utf16_to_utf8(wstring_view s); +- operator string_view() const { return string_view(&buffer_[0], size()); } +- size_t size() const { return buffer_.size() - 1; } +- const char* c_str() const { return &buffer_[0]; } +- std::string str() const { return std::string(&buffer_[0], size()); } +- +- // Performs conversion returning a system error code instead of +- // throwing exception on conversion error. This method may still throw +- // in case of memory allocation error. +- FMT_API int convert(wstring_view s); +-}; +- +-FMT_API void format_windows_error(fmt::internal::buffer& out, +- int error_code, +- fmt::string_view message) FMT_NOEXCEPT; +-#endif +- +-template struct null {}; +- +-// Workaround an array initialization issue in gcc 4.8. +-template struct fill_t { +- private: +- Char data_[6]; +- +- public: +- FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; } +- FMT_CONSTEXPR const Char& operator[](size_t index) const { +- return data_[index]; +- } +- +- static FMT_CONSTEXPR fill_t make() { +- auto fill = fill_t(); +- fill[0] = Char(' '); +- return fill; +- } +-}; +-} // namespace internal +- +-// We cannot use enum classes as bit fields because of a gcc bug +-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414. +-namespace align { +-enum type { none, left, right, center, numeric }; +-} +-using align_t = align::type; +- +-namespace sign { +-enum type { none, minus, plus, space }; +-} +-using sign_t = sign::type; +- +-// Format specifiers for built-in and string types. +-template struct basic_format_specs { +- int width; +- int precision; +- char type; +- align_t align : 4; +- sign_t sign : 3; +- bool alt : 1; // Alternate form ('#'). +- internal::fill_t fill; +- +- constexpr basic_format_specs() +- : width(0), +- precision(-1), +- type(0), +- align(align::none), +- sign(sign::none), +- alt(false), +- fill(internal::fill_t::make()) {} +-}; +- +-using format_specs = basic_format_specs; +- +-namespace internal { +- +-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer. +-template It write_exponent(int exp, It it) { +- FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range"); +- if (exp < 0) { +- *it++ = static_cast('-'); +- exp = -exp; +- } else { +- *it++ = static_cast('+'); +- } +- if (exp >= 100) { +- *it++ = static_cast(static_cast('0' + exp / 100)); +- exp %= 100; +- } +- const char* d = data::digits + exp * 2; +- *it++ = static_cast(d[0]); +- *it++ = static_cast(d[1]); +- return it; +-} +- +-struct gen_digits_params { +- int num_digits; +- bool fixed; +- bool upper; +- bool trailing_zeros; +-}; +- +-// The number is given as v = digits * pow(10, exp). +-template +-It grisu_prettify(const char* digits, int size, int exp, It it, +- gen_digits_params params, Char decimal_point) { +- // pow(10, full_exp - 1) <= v <= pow(10, full_exp). +- int full_exp = size + exp; +- if (!params.fixed) { +- // Insert a decimal point after the first digit and add an exponent. +- *it++ = static_cast(*digits); +- if (size > 1) *it++ = decimal_point; +- exp += size - 1; +- it = copy_str(digits + 1, digits + size, it); +- if (size < params.num_digits) +- it = std::fill_n(it, params.num_digits - size, static_cast('0')); +- *it++ = static_cast(params.upper ? 'E' : 'e'); +- return write_exponent(exp, it); +- } +- if (size <= full_exp) { +- // 1234e7 -> 12340000000[.0+] +- it = copy_str(digits, digits + size, it); +- it = std::fill_n(it, full_exp - size, static_cast('0')); +- int num_zeros = (std::max)(params.num_digits - full_exp, 1); +- if (params.trailing_zeros) { +- *it++ = decimal_point; +-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +- if (num_zeros > 1000) +- throw std::runtime_error("fuzz mode - avoiding excessive cpu use"); +-#endif +- it = std::fill_n(it, num_zeros, static_cast('0')); +- } +- } else if (full_exp > 0) { +- // 1234e-2 -> 12.34[0+] +- it = copy_str(digits, digits + full_exp, it); +- if (!params.trailing_zeros) { +- // Remove trailing zeros. +- while (size > full_exp && digits[size - 1] == '0') --size; +- if (size != full_exp) *it++ = decimal_point; +- return copy_str(digits + full_exp, digits + size, it); +- } +- *it++ = decimal_point; +- it = copy_str(digits + full_exp, digits + size, it); +- if (params.num_digits > size) { +- // Add trailing zeros. +- int num_zeros = params.num_digits - size; +- it = std::fill_n(it, num_zeros, static_cast('0')); +- } +- } else { +- // 1234e-6 -> 0.001234 +- *it++ = static_cast('0'); +- int num_zeros = -full_exp; +- if (params.num_digits >= 0 && params.num_digits < num_zeros) +- num_zeros = params.num_digits; +- if (!params.trailing_zeros) +- while (size > 0 && digits[size - 1] == '0') --size; +- if (num_zeros != 0 || size != 0) { +- *it++ = decimal_point; +- it = std::fill_n(it, num_zeros, static_cast('0')); +- it = copy_str(digits, digits + size, it); +- } +- } +- return it; +-} +- +-namespace grisu_options { +-enum { fixed = 1, grisu3 = 2 }; +-} +- +-// Formats value using the Grisu algorithm: +-// https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf +-template +-FMT_API bool grisu_format(Double, buffer&, int, unsigned, int&); +-template +-inline bool grisu_format(Double, buffer&, int, unsigned, int&) { +- return false; +-} +- +-struct sprintf_specs { +- int precision; +- char type; +- bool alt : 1; +- +- template +- constexpr sprintf_specs(basic_format_specs specs) +- : precision(specs.precision), type(specs.type), alt(specs.alt) {} +- +- constexpr bool has_precision() const { return precision >= 0; } +-}; +- +-template +-char* sprintf_format(Double, internal::buffer&, sprintf_specs); +- +-template +-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) { +- switch (spec) { +- case 0: +- case 'd': +- handler.on_dec(); +- break; +- case 'x': +- case 'X': +- handler.on_hex(); +- break; +- case 'b': +- case 'B': +- handler.on_bin(); +- break; +- case 'o': +- handler.on_oct(); +- break; +- case 'n': +- handler.on_num(); +- break; +- default: +- handler.on_error(); +- } +-} +- +-template +-FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler&& handler) { +- switch (spec) { +- case 0: +- case 'g': +- case 'G': +- handler.on_general(); +- break; +- case 'e': +- case 'E': +- handler.on_exp(); +- break; +- case 'f': +- case 'F': +- handler.on_fixed(); +- break; +- case '%': +- handler.on_percent(); +- break; +- case 'a': +- case 'A': +- handler.on_hex(); +- break; +- case 'n': +- handler.on_num(); +- break; +- default: +- handler.on_error(); +- break; +- } +-} +- +-template +-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs* specs, +- Handler&& handler) { +- if (!specs) return handler.on_char(); +- if (specs->type && specs->type != 'c') return handler.on_int(); +- if (specs->align == align::numeric || specs->sign != sign::none || specs->alt) +- handler.on_error("invalid format specifier for char"); +- handler.on_char(); +-} +- +-template +-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) { +- if (spec == 0 || spec == 's') +- handler.on_string(); +- else if (spec == 'p') +- handler.on_pointer(); +- else +- handler.on_error("invalid type specifier"); +-} +- +-template +-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) { +- if (spec != 0 && spec != 's') eh.on_error("invalid type specifier"); +-} +- +-template +-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) { +- if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier"); +-} +- +-template class int_type_checker : private ErrorHandler { +- public: +- FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {} +- +- FMT_CONSTEXPR void on_dec() {} +- FMT_CONSTEXPR void on_hex() {} +- FMT_CONSTEXPR void on_bin() {} +- FMT_CONSTEXPR void on_oct() {} +- FMT_CONSTEXPR void on_num() {} +- +- FMT_CONSTEXPR void on_error() { +- ErrorHandler::on_error("invalid type specifier"); +- } +-}; +- +-template +-class float_type_checker : private ErrorHandler { +- public: +- FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) +- : ErrorHandler(eh) {} +- +- FMT_CONSTEXPR void on_general() {} +- FMT_CONSTEXPR void on_exp() {} +- FMT_CONSTEXPR void on_fixed() {} +- FMT_CONSTEXPR void on_percent() {} +- FMT_CONSTEXPR void on_hex() {} +- FMT_CONSTEXPR void on_num() {} +- +- FMT_CONSTEXPR void on_error() { +- ErrorHandler::on_error("invalid type specifier"); +- } +-}; +- +-template +-class char_specs_checker : public ErrorHandler { +- private: +- char type_; +- +- public: +- FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh) +- : ErrorHandler(eh), type_(type) {} +- +- FMT_CONSTEXPR void on_int() { +- handle_int_type_spec(type_, int_type_checker(*this)); +- } +- FMT_CONSTEXPR void on_char() {} +-}; +- +-template +-class cstring_type_checker : public ErrorHandler { +- public: +- FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) +- : ErrorHandler(eh) {} +- +- FMT_CONSTEXPR void on_string() {} +- FMT_CONSTEXPR void on_pointer() {} +-}; +- +-template +-void arg_map::init(const basic_format_args& args) { +- if (map_) return; +- map_ = new entry[internal::to_unsigned(args.max_size())]; +- if (args.is_packed()) { +- for (int i = 0;; ++i) { +- internal::type arg_type = args.type(i); +- if (arg_type == internal::none_type) return; +- if (arg_type == internal::named_arg_type) push_back(args.values_[i]); +- } +- } +- for (int i = 0, n = args.max_size(); i < n; ++i) { +- auto type = args.args_[i].type_; +- if (type == internal::named_arg_type) push_back(args.args_[i].value_); +- } +-} +- +-// This template provides operations for formatting and writing data into a +-// character range. +-template class basic_writer { +- public: +- using char_type = typename Range::value_type; +- using iterator = typename Range::iterator; +- using format_specs = basic_format_specs; +- +- private: +- iterator out_; // Output iterator. +- internal::locale_ref locale_; +- +- // Attempts to reserve space for n extra characters in the output range. +- // Returns a pointer to the reserved range or a reference to out_. +- auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) { +- return internal::reserve(out_, n); +- } +- +- template struct padded_int_writer { +- size_t size_; +- string_view prefix; +- char_type fill; +- std::size_t padding; +- F f; +- +- size_t size() const { return size_; } +- size_t width() const { return size_; } +- +- template void operator()(It&& it) const { +- if (prefix.size() != 0) +- it = internal::copy_str(prefix.begin(), prefix.end(), it); +- it = std::fill_n(it, padding, fill); +- f(it); +- } +- }; +- +- // Writes an integer in the format +- // +- // where are written by f(it). +- template +- void write_int(int num_digits, string_view prefix, format_specs specs, F f) { +- std::size_t size = prefix.size() + internal::to_unsigned(num_digits); +- char_type fill = specs.fill[0]; +- std::size_t padding = 0; +- if (specs.align == align::numeric) { +- auto unsiged_width = internal::to_unsigned(specs.width); +- if (unsiged_width > size) { +- padding = unsiged_width - size; +- size = unsiged_width; +- } +- } else if (specs.precision > num_digits) { +- size = prefix.size() + internal::to_unsigned(specs.precision); +- padding = internal::to_unsigned(specs.precision - num_digits); +- fill = static_cast('0'); +- } +- if (specs.align == align::none) specs.align = align::right; +- write_padded(specs, padded_int_writer{size, prefix, fill, padding, f}); +- } +- +- // Writes a decimal integer. +- template void write_decimal(Int value) { +- auto abs_value = static_cast>(value); +- bool is_negative = internal::is_negative(value); +- if (is_negative) abs_value = 0 - abs_value; +- int num_digits = internal::count_digits(abs_value); +- auto&& it = +- reserve((is_negative ? 1 : 0) + static_cast(num_digits)); +- if (is_negative) *it++ = static_cast('-'); +- it = internal::format_decimal(it, abs_value, num_digits); +- } +- +- // The handle_int_type_spec handler that writes an integer. +- template struct int_writer { +- using unsigned_type = uint32_or_64_t; +- +- basic_writer& writer; +- const Specs& specs; +- unsigned_type abs_value; +- char prefix[4]; +- unsigned prefix_size; +- +- string_view get_prefix() const { return string_view(prefix, prefix_size); } +- +- int_writer(basic_writer& w, Int value, const Specs& s) +- : writer(w), +- specs(s), +- abs_value(static_cast(value)), +- prefix_size(0) { +- if (internal::is_negative(value)) { +- prefix[0] = '-'; +- ++prefix_size; +- abs_value = 0 - abs_value; +- } else if (specs.sign != sign::none && specs.sign != sign::minus) { +- prefix[0] = specs.sign == sign::plus ? '+' : ' '; +- ++prefix_size; +- } +- } +- +- struct dec_writer { +- unsigned_type abs_value; +- int num_digits; +- +- template void operator()(It&& it) const { +- it = internal::format_decimal(it, abs_value, num_digits); +- } +- }; +- +- void on_dec() { +- int num_digits = internal::count_digits(abs_value); +- writer.write_int(num_digits, get_prefix(), specs, +- dec_writer{abs_value, num_digits}); +- } +- +- struct hex_writer { +- int_writer& self; +- int num_digits; +- +- template void operator()(It&& it) const { +- it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits, +- self.specs.type != 'x'); +- } +- }; +- +- void on_hex() { +- if (specs.alt) { +- prefix[prefix_size++] = '0'; +- prefix[prefix_size++] = specs.type; +- } +- int num_digits = internal::count_digits<4>(abs_value); +- writer.write_int(num_digits, get_prefix(), specs, +- hex_writer{*this, num_digits}); +- } +- +- template struct bin_writer { +- unsigned_type abs_value; +- int num_digits; +- +- template void operator()(It&& it) const { +- it = internal::format_uint(it, abs_value, num_digits); +- } +- }; +- +- void on_bin() { +- if (specs.alt) { +- prefix[prefix_size++] = '0'; +- prefix[prefix_size++] = static_cast(specs.type); +- } +- int num_digits = internal::count_digits<1>(abs_value); +- writer.write_int(num_digits, get_prefix(), specs, +- bin_writer<1>{abs_value, num_digits}); +- } +- +- void on_oct() { +- int num_digits = internal::count_digits<3>(abs_value); +- if (specs.alt && specs.precision <= num_digits) { +- // Octal prefix '0' is counted as a digit, so only add it if precision +- // is not greater than the number of digits. +- prefix[prefix_size++] = '0'; +- } +- writer.write_int(num_digits, get_prefix(), specs, +- bin_writer<3>{abs_value, num_digits}); +- } +- +- enum { sep_size = 1 }; +- +- struct num_writer { +- unsigned_type abs_value; +- int size; +- char_type sep; +- +- template void operator()(It&& it) const { +- basic_string_view s(&sep, sep_size); +- // Index of a decimal digit with the least significant digit having +- // index 0. +- unsigned digit_index = 0; +- it = internal::format_decimal( +- it, abs_value, size, [s, &digit_index](char_type*& buffer) { +- if (++digit_index % 3 != 0) return; +- buffer -= s.size(); +- std::uninitialized_copy(s.data(), s.data() + s.size(), +- internal::make_checked(buffer, s.size())); +- }); +- } +- }; +- +- void on_num() { +- char_type sep = internal::thousands_sep(writer.locale_); +- if (!sep) return on_dec(); +- int num_digits = internal::count_digits(abs_value); +- int size = num_digits + sep_size * ((num_digits - 1) / 3); +- writer.write_int(size, get_prefix(), specs, +- num_writer{abs_value, size, sep}); +- } +- +- FMT_NORETURN void on_error() { +- FMT_THROW(format_error("invalid type specifier")); +- } +- }; +- +- enum { inf_size = 3 }; // This is an enum to workaround a bug in MSVC. +- +- struct inf_or_nan_writer { +- char sign; +- bool as_percentage; +- const char* str; +- +- size_t size() const { +- return static_cast(inf_size + (sign ? 1 : 0) + +- (as_percentage ? 1 : 0)); +- } +- size_t width() const { return size(); } +- +- template void operator()(It&& it) const { +- if (sign) *it++ = static_cast(sign); +- it = internal::copy_str( +- str, str + static_cast(inf_size), it); +- if (as_percentage) *it++ = static_cast('%'); +- } +- }; +- +- struct double_writer { +- char sign; +- internal::buffer& buffer; +- char* decimal_point_pos; +- char_type decimal_point; +- +- size_t size() const { return buffer.size() + (sign ? 1 : 0); } +- size_t width() const { return size(); } +- +- template void operator()(It&& it) { +- if (sign) *it++ = static_cast(sign); +- auto begin = buffer.begin(); +- if (decimal_point_pos) { +- it = internal::copy_str(begin, decimal_point_pos, it); +- *it++ = decimal_point; +- begin = decimal_point_pos + 1; +- } +- it = internal::copy_str(begin, buffer.end(), it); +- } +- }; +- +- class grisu_writer { +- private: +- internal::buffer& digits_; +- size_t size_; +- char sign_; +- int exp_; +- internal::gen_digits_params params_; +- char_type decimal_point_; +- +- public: +- grisu_writer(char sign, internal::buffer& digits, int exp, +- const internal::gen_digits_params& params, +- char_type decimal_point) +- : digits_(digits), +- sign_(sign), +- exp_(exp), +- params_(params), +- decimal_point_(decimal_point) { +- int num_digits = static_cast(digits.size()); +- int full_exp = num_digits + exp - 1; +- int precision = params.num_digits > 0 ? params.num_digits : 11; +- params_.fixed |= full_exp >= -4 && full_exp < precision; +- auto it = internal::grisu_prettify( +- digits.data(), num_digits, exp, internal::counting_iterator(), +- params_, '.'); +- size_ = it.count(); +- } +- +- size_t size() const { return size_ + (sign_ ? 1 : 0); } +- size_t width() const { return size(); } +- +- template void operator()(It&& it) { +- if (sign_) *it++ = static_cast(sign_); +- int num_digits = static_cast(digits_.size()); +- it = internal::grisu_prettify(digits_.data(), num_digits, exp_, +- it, params_, decimal_point_); +- } +- }; +- +- template struct str_writer { +- const Char* s; +- size_t size_; +- +- size_t size() const { return size_; } +- size_t width() const { +- return internal::count_code_points(basic_string_view(s, size_)); +- } +- +- template void operator()(It&& it) const { +- it = internal::copy_str(s, s + size_, it); +- } +- }; +- +- template struct pointer_writer { +- UIntPtr value; +- int num_digits; +- +- size_t size() const { return to_unsigned(num_digits) + 2; } +- size_t width() const { return size(); } +- +- template void operator()(It&& it) const { +- *it++ = static_cast('0'); +- *it++ = static_cast('x'); +- it = internal::format_uint<4, char_type>(it, value, num_digits); +- } +- }; +- +- public: +- /** Constructs a ``basic_writer`` object. */ +- explicit basic_writer(Range out, +- internal::locale_ref loc = internal::locale_ref()) +- : out_(out.begin()), locale_(loc) {} +- +- iterator out() const { return out_; } +- +- // Writes a value in the format +- // +- // where is written by f(it). +- template void write_padded(const format_specs& specs, F&& f) { +- // User-perceived width (in code points). +- unsigned width = to_unsigned(specs.width); +- size_t size = f.size(); // The number of code units. +- size_t num_code_points = width != 0 ? f.width() : size; +- if (width <= num_code_points) return f(reserve(size)); +- auto&& it = reserve(width + (size - num_code_points)); +- char_type fill = specs.fill[0]; +- std::size_t padding = width - num_code_points; +- if (specs.align == align::right) { +- it = std::fill_n(it, padding, fill); +- f(it); +- } else if (specs.align == align::center) { +- std::size_t left_padding = padding / 2; +- it = std::fill_n(it, left_padding, fill); +- f(it); +- it = std::fill_n(it, padding - left_padding, fill); +- } else { +- f(it); +- it = std::fill_n(it, padding, fill); +- } +- } +- +- void write(int value) { write_decimal(value); } +- void write(long value) { write_decimal(value); } +- void write(long long value) { write_decimal(value); } +- +- void write(unsigned value) { write_decimal(value); } +- void write(unsigned long value) { write_decimal(value); } +- void write(unsigned long long value) { write_decimal(value); } +- +- // Writes a formatted integer. +- template +- void write_int(T value, const Spec& spec) { +- internal::handle_int_type_spec(spec.type, +- int_writer(*this, value, spec)); +- } +- +- void write(double value, const format_specs& specs = format_specs()) { +- write_double(value, specs); +- } +- +- /** +- \rst +- Formats *value* using the general format for floating-point numbers +- (``'g'``) and writes it to the buffer. +- \endrst +- */ +- void write(long double value, const format_specs& specs = format_specs()) { +- write_double(value, specs); +- } +- +- // Formats a floating-point number (double or long double). +- template ()> +- void write_double(T value, const format_specs& specs); +- +- /** Writes a character to the buffer. */ +- void write(char value) { +- auto&& it = reserve(1); +- *it++ = value; +- } +- +- template ::value)> +- void write(Char value) { +- auto&& it = reserve(1); +- *it++ = value; +- } +- +- /** +- \rst +- Writes *value* to the buffer. +- \endrst +- */ +- void write(string_view value) { +- auto&& it = reserve(value.size()); +- it = internal::copy_str(value.begin(), value.end(), it); +- } +- void write(wstring_view value) { +- static_assert(std::is_same::value, ""); +- auto&& it = reserve(value.size()); +- it = std::copy(value.begin(), value.end(), it); +- } +- +- // Writes a formatted string. +- template +- void write(const Char* s, std::size_t size, const format_specs& specs) { +- write_padded(specs, str_writer{s, size}); +- } +- +- template +- void write(basic_string_view s, +- const format_specs& specs = format_specs()) { +- const Char* data = s.data(); +- std::size_t size = s.size(); +- if (specs.precision >= 0 && internal::to_unsigned(specs.precision) < size) +- size = internal::to_unsigned(specs.precision); +- write(data, size, specs); +- } +- +- template +- void write_pointer(UIntPtr value, const format_specs* specs) { +- int num_digits = internal::count_digits<4>(value); +- auto pw = pointer_writer{value, num_digits}; +- if (!specs) return pw(reserve(to_unsigned(num_digits) + 2)); +- format_specs specs_copy = *specs; +- if (specs_copy.align == align::none) specs_copy.align = align::right; +- write_padded(specs_copy, pw); +- } +-}; +- +-using writer = basic_writer>; +- +-template +-class arg_formatter_base { +- public: +- using char_type = typename Range::value_type; +- using iterator = typename Range::iterator; +- using format_specs = basic_format_specs; +- +- private: +- using writer_type = basic_writer; +- writer_type writer_; +- format_specs* specs_; +- +- struct char_writer { +- char_type value; +- +- size_t size() const { return 1; } +- size_t width() const { return 1; } +- +- template void operator()(It&& it) const { *it++ = value; } +- }; +- +- void write_char(char_type value) { +- if (specs_) +- writer_.write_padded(*specs_, char_writer{value}); +- else +- writer_.write(value); +- } +- +- void write_pointer(const void* p) { +- writer_.write_pointer(internal::bit_cast(p), specs_); +- } +- +- protected: +- writer_type& writer() { return writer_; } +- FMT_DEPRECATED format_specs* spec() { return specs_; } +- format_specs* specs() { return specs_; } +- iterator out() { return writer_.out(); } +- +- void write(bool value) { +- string_view sv(value ? "true" : "false"); +- specs_ ? writer_.write(sv, *specs_) : writer_.write(sv); +- } +- +- void write(const char_type* value) { +- if (!value) { +- FMT_THROW(format_error("string pointer is null")); +- } else { +- auto length = std::char_traits::length(value); +- basic_string_view sv(value, length); +- specs_ ? writer_.write(sv, *specs_) : writer_.write(sv); +- } +- } +- +- public: +- arg_formatter_base(Range r, format_specs* s, locale_ref loc) +- : writer_(r, loc), specs_(s) {} +- +- iterator operator()(monostate) { +- FMT_ASSERT(false, "invalid argument type"); +- return out(); +- } +- +- template ::value)> +- iterator operator()(T value) { +- if (specs_) +- writer_.write_int(value, *specs_); +- else +- writer_.write(value); +- return out(); +- } +- +- iterator operator()(char_type value) { +- internal::handle_char_specs( +- specs_, char_spec_handler(*this, static_cast(value))); +- return out(); +- } +- +- iterator operator()(bool value) { +- if (specs_ && specs_->type) return (*this)(value ? 1 : 0); +- write(value != 0); +- return out(); +- } +- +- template ::value)> +- iterator operator()(T value) { +- writer_.write_double(value, specs_ ? *specs_ : format_specs()); +- return out(); +- } +- +- struct char_spec_handler : ErrorHandler { +- arg_formatter_base& formatter; +- char_type value; +- +- char_spec_handler(arg_formatter_base& f, char_type val) +- : formatter(f), value(val) {} +- +- void on_int() { +- if (formatter.specs_) +- formatter.writer_.write_int(value, *formatter.specs_); +- else +- formatter.writer_.write(value); +- } +- void on_char() { formatter.write_char(value); } +- }; +- +- struct cstring_spec_handler : internal::error_handler { +- arg_formatter_base& formatter; +- const char_type* value; +- +- cstring_spec_handler(arg_formatter_base& f, const char_type* val) +- : formatter(f), value(val) {} +- +- void on_string() { formatter.write(value); } +- void on_pointer() { formatter.write_pointer(value); } +- }; +- +- iterator operator()(const char_type* value) { +- if (!specs_) return write(value), out(); +- internal::handle_cstring_type_spec(specs_->type, +- cstring_spec_handler(*this, value)); +- return out(); +- } +- +- iterator operator()(basic_string_view value) { +- if (specs_) { +- internal::check_string_type_spec(specs_->type, internal::error_handler()); +- writer_.write(value, *specs_); +- } else { +- writer_.write(value); +- } +- return out(); +- } +- +- iterator operator()(const void* value) { +- if (specs_) +- check_pointer_type_spec(specs_->type, internal::error_handler()); +- write_pointer(value); +- return out(); +- } +-}; +- +-template FMT_CONSTEXPR bool is_name_start(Char c) { +- return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +-} +- +-// Parses the range [begin, end) as an unsigned integer. This function assumes +-// that the range is non-empty and the first character is a digit. +-template +-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end, +- ErrorHandler&& eh) { +- assert(begin != end && '0' <= *begin && *begin <= '9'); +- if (*begin == '0') { +- ++begin; +- return 0; +- } +- unsigned value = 0; +- // Convert to unsigned to prevent a warning. +- constexpr unsigned max_int = (std::numeric_limits::max)(); +- unsigned big = max_int / 10; +- do { +- // Check for overflow. +- if (value > big) { +- value = max_int + 1; +- break; +- } +- value = value * 10 + unsigned(*begin - '0'); +- ++begin; +- } while (begin != end && '0' <= *begin && *begin <= '9'); +- if (value > max_int) eh.on_error("number is too big"); +- return static_cast(value); +-} +- +-template class custom_formatter { +- private: +- using char_type = typename Context::char_type; +- +- basic_parse_context& parse_ctx_; +- Context& ctx_; +- +- public: +- explicit custom_formatter(basic_parse_context& parse_ctx, +- Context& ctx) +- : parse_ctx_(parse_ctx), ctx_(ctx) {} +- +- bool operator()(typename basic_format_arg::handle h) const { +- h.format(parse_ctx_, ctx_); +- return true; +- } +- +- template bool operator()(T) const { return false; } +-}; +- +-template +-using is_integer = +- bool_constant::value && !std::is_same::value && +- !std::is_same::value && +- !std::is_same::value>; +- +-template class width_checker { +- public: +- explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {} +- +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T value) { +- if (is_negative(value)) handler_.on_error("negative width"); +- return static_cast(value); +- } +- +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T) { +- handler_.on_error("width is not integer"); +- return 0; +- } +- +- private: +- ErrorHandler& handler_; +-}; +- +-template class precision_checker { +- public: +- explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {} +- +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T value) { +- if (is_negative(value)) handler_.on_error("negative precision"); +- return static_cast(value); +- } +- +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T) { +- handler_.on_error("precision is not integer"); +- return 0; +- } +- +- private: +- ErrorHandler& handler_; +-}; +- +-// A format specifier handler that sets fields in basic_format_specs. +-template class specs_setter { +- public: +- explicit FMT_CONSTEXPR specs_setter(basic_format_specs& specs) +- : specs_(specs) {} +- +- FMT_CONSTEXPR specs_setter(const specs_setter& other) +- : specs_(other.specs_) {} +- +- FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; } +- FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; } +- FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; } +- FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; } +- FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; } +- FMT_CONSTEXPR void on_hash() { specs_.alt = true; } +- +- FMT_CONSTEXPR void on_zero() { +- specs_.align = align::numeric; +- specs_.fill[0] = Char('0'); +- } +- +- FMT_CONSTEXPR void on_width(int width) { specs_.width = width; } +- FMT_CONSTEXPR void on_precision(int precision) { +- specs_.precision = precision; +- } +- FMT_CONSTEXPR void end_precision() {} +- +- FMT_CONSTEXPR void on_type(Char type) { +- specs_.type = static_cast(type); +- } +- +- protected: +- basic_format_specs& specs_; +-}; +- +-template class numeric_specs_checker { +- public: +- FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type) +- : error_handler_(eh), arg_type_(arg_type) {} +- +- FMT_CONSTEXPR void require_numeric_argument() { +- if (!is_arithmetic(arg_type_)) +- error_handler_.on_error("format specifier requires numeric argument"); +- } +- +- FMT_CONSTEXPR void check_sign() { +- require_numeric_argument(); +- if (is_integral(arg_type_) && arg_type_ != int_type && +- arg_type_ != long_long_type && arg_type_ != internal::char_type) { +- error_handler_.on_error("format specifier requires signed argument"); +- } +- } +- +- FMT_CONSTEXPR void check_precision() { +- if (is_integral(arg_type_) || arg_type_ == internal::pointer_type) +- error_handler_.on_error("precision not allowed for this argument type"); +- } +- +- private: +- ErrorHandler& error_handler_; +- internal::type arg_type_; +-}; +- +-// A format specifier handler that checks if specifiers are consistent with the +-// argument type. +-template class specs_checker : public Handler { +- public: +- FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type) +- : Handler(handler), checker_(*this, arg_type) {} +- +- FMT_CONSTEXPR specs_checker(const specs_checker& other) +- : Handler(other), checker_(*this, other.arg_type_) {} +- +- FMT_CONSTEXPR void on_align(align_t align) { +- if (align == align::numeric) checker_.require_numeric_argument(); +- Handler::on_align(align); +- } +- +- FMT_CONSTEXPR void on_plus() { +- checker_.check_sign(); +- Handler::on_plus(); +- } +- +- FMT_CONSTEXPR void on_minus() { +- checker_.check_sign(); +- Handler::on_minus(); +- } +- +- FMT_CONSTEXPR void on_space() { +- checker_.check_sign(); +- Handler::on_space(); +- } +- +- FMT_CONSTEXPR void on_hash() { +- checker_.require_numeric_argument(); +- Handler::on_hash(); +- } +- +- FMT_CONSTEXPR void on_zero() { +- checker_.require_numeric_argument(); +- Handler::on_zero(); +- } +- +- FMT_CONSTEXPR void end_precision() { checker_.check_precision(); } +- +- private: +- numeric_specs_checker checker_; +-}; +- +-template