From 5bd7da2cadee9dae44ce14f35a4fb72323c0b98e Mon Sep 17 00:00:00 2001 From: Wouter Deconinck Date: Wed, 15 May 2024 14:35:10 -0500 Subject: [PATCH] audit: github.com/o/r/pull/n/commits/sha.patch -> sha.patch --- ...c176a7a8c512b3f37d079dec8c25ac1b7389.patch | 35 + .../builtin/packages/dla-future/package.py | 4 +- ...a1ff89f8fb596b4a6a4c70aa7d557803db87.patch | 22 + .../builtin/packages/miopen-hip/package.py | 4 +- ...96e51a6771d5d2b43f22b0d2a9a91785e533.patch | 24 + .../repos/builtin/packages/mlpack/package.py | 4 +- ...20a3b7b787c960a7e414ba26ab5497817d40.patch | 284 + .../packages/openscenegraph/package.py | 4 +- ...f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch | 50 + .../builtin/packages/protobuf/package.py | 4 +- ...9dac4eb832e58ab2109db84508b294ba366d.patch | 97 + .../builtin/packages/py-astor/package.py | 4 +- ...d1d6078f6d9523b7ad0886ffa053644569d5.patch | 6932 +++++++++++++++++ ...0aa1f7a01a917c3b7ac618e8a9e44a10fd25.patch | 141 + .../repos/builtin/packages/umpire/package.py | 8 +- ...4e03575da65f254917ef5d8eb39074abd3fc.patch | 60 + ...d9192f7f91967147e50f5bc8b9e49310cf98.patch | 31 + .../repos/builtin/packages/wrf/package.py | 8 +- 18 files changed, 7696 insertions(+), 20 deletions(-) create mode 100644 var/spack/repos/builtin/packages/dla-future/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch create mode 100644 var/spack/repos/builtin/packages/miopen-hip/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch create mode 100644 var/spack/repos/builtin/packages/mlpack/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch create mode 100644 var/spack/repos/builtin/packages/openscenegraph/759620a3b7b787c960a7e414ba26ab5497817d40.patch create mode 100644 var/spack/repos/builtin/packages/protobuf/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch create mode 100644 var/spack/repos/builtin/packages/py-astor/30059dac4eb832e58ab2109db84508b294ba366d.patch create mode 100644 var/spack/repos/builtin/packages/umpire/2292d1d6078f6d9523b7ad0886ffa053644569d5.patch create mode 100644 var/spack/repos/builtin/packages/umpire/47ff0aa1f7a01a917c3b7ac618e8a9e44a10fd25.patch create mode 100644 var/spack/repos/builtin/packages/wrf/4a084e03575da65f254917ef5d8eb39074abd3fc.patch create mode 100644 var/spack/repos/builtin/packages/wrf/6087d9192f7f91967147e50f5bc8b9e49310cf98.patch diff --git a/var/spack/repos/builtin/packages/dla-future/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch b/var/spack/repos/builtin/packages/dla-future/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch new file mode 100644 index 00000000000..780403182d5 --- /dev/null +++ b/var/spack/repos/builtin/packages/dla-future/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch @@ -0,0 +1,35 @@ +From efc9c176a7a8c512b3f37d079dec8c25ac1b7389 Mon Sep 17 00:00:00 2001 +From: Mikael Simberg +Date: Mon, 4 Dec 2023 09:24:14 +0100 +Subject: [PATCH] Add missing cstdint includes to scal.{cpp,h} + +--- + include/dlaf/blas/scal.h | 1 + + src/blas/scal.cpp | 2 ++ + 2 files changed, 3 insertions(+) + +diff --git a/include/dlaf/blas/scal.h b/include/dlaf/blas/scal.h +index 028480482a..a4aac4cce6 100644 +--- a/include/dlaf/blas/scal.h ++++ b/include/dlaf/blas/scal.h +@@ -11,6 +11,7 @@ + #pragma once + + #include ++#include + + /// @file + /// Provides overloads for mixed real complex variants of scal missing in blaspp. +diff --git a/src/blas/scal.cpp b/src/blas/scal.cpp +index 16ac5d1d60..9074a07718 100644 +--- a/src/blas/scal.cpp ++++ b/src/blas/scal.cpp +@@ -8,6 +8,8 @@ + // SPDX-License-Identifier: BSD-3-Clause + // + ++#include ++ + #include + #include + diff --git a/var/spack/repos/builtin/packages/dla-future/package.py b/var/spack/repos/builtin/packages/dla-future/package.py index 05a25abc61d..4dd97125112 100644 --- a/var/spack/repos/builtin/packages/dla-future/package.py +++ b/var/spack/repos/builtin/packages/dla-future/package.py @@ -127,9 +127,9 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage): depends_on(f"pika cuda_arch={arch}", when=f"cuda_arch={arch}") depends_on(f"umpire cuda_arch={arch}", when=f"cuda_arch={arch}") + # https://github.com/eth-cscs/DLA-Future/pull/1063/commits/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch patch( - "https://github.com/eth-cscs/DLA-Future/pull/1063/commits/efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch?full_index=1", - sha256="7f382c872d89f22da1ad499e85ffe9881cc7404c8465e42877a210a09382e2ea", + "efc9c176a7a8c512b3f37d079dec8c25ac1b7389.patch", when="@:0.3 %gcc@13:", ) # https://github.com/spack/spack/issues/41511 diff --git a/var/spack/repos/builtin/packages/miopen-hip/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch b/var/spack/repos/builtin/packages/miopen-hip/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch new file mode 100644 index 00000000000..a70330432da --- /dev/null +++ b/var/spack/repos/builtin/packages/miopen-hip/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch @@ -0,0 +1,22 @@ +From f60aa1ff89f8fb596b4a6a4c70aa7d557803db87 Mon Sep 17 00:00:00 2001 +From: Tal Ben-Nun +Date: Wed, 26 Jul 2023 13:31:56 -0700 +Subject: [PATCH] Fix CMake search for unzipper + +--- + CMakeLists.txt | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index b45cb6d2b2..3d2d760443 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -470,7 +470,7 @@ endif() + function(unpack_db db_bzip2_file) + set(KERNELS_DIR "${CMAKE_SOURCE_DIR}/src/kernels") + STRING(REPLACE ".bz2" "" db_file "${db_bzip2_file}") +- find_program(UNZIPPER lbunzip2 bunzip2) ++ find_program(UNZIPPER NAMES lbunzip2 bunzip2) + if(EXISTS "${db_file}") + message(STATUS "WARNING: ${db_file} already exists and will be overwritten") + endif() diff --git a/var/spack/repos/builtin/packages/miopen-hip/package.py b/var/spack/repos/builtin/packages/miopen-hip/package.py index 5a9c1136e1c..9e8dab88959 100644 --- a/var/spack/repos/builtin/packages/miopen-hip/package.py +++ b/var/spack/repos/builtin/packages/miopen-hip/package.py @@ -57,9 +57,9 @@ class MiopenHip(CMakePackage): patch("miopen-hip-include-nlohmann-include-directory.patch", when="@5.4.0:5.7") patch("0002-add-include-dir-miopen-hip-6.0.0.patch", when="@6.0") patch("0002-add-include-dir-miopen-hip-6.1.0.patch", when="@6.1") + # https://github.com/ROCm/MIOpen/pull/2276/commits/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch patch( - "https://github.com/ROCm/MIOpen/pull/2276/commits/f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch?full_index=1", - sha256="c777d9f4cd2bbfec632b38620c0f70bb0cce8da1", + "f60aa1ff89f8fb596b4a6a4c70aa7d557803db87.patch", when="@5.7", ) diff --git a/var/spack/repos/builtin/packages/mlpack/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch b/var/spack/repos/builtin/packages/mlpack/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch new file mode 100644 index 00000000000..2a9ec64178c --- /dev/null +++ b/var/spack/repos/builtin/packages/mlpack/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch @@ -0,0 +1,24 @@ +From 183396e51a6771d5d2b43f22b0d2a9a91785e533 Mon Sep 17 00:00:00 2001 +From: Wouter Deconinck +Date: Thu, 22 Jun 2023 11:29:03 -0500 +Subject: [PATCH] fix: append existing PYTHONPATH to CMAKE_PYTHON_PATH + +This addresses #3500. It approaches it slightly differently than the code included there, in order to behave correctly when `PYTHONPATH` is not set and to remain within the CMake version 3.6 minimum (prevents `JOIN`). +--- + src/mlpack/bindings/python/CMakeLists.txt | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/src/mlpack/bindings/python/CMakeLists.txt b/src/mlpack/bindings/python/CMakeLists.txt +index e4b34744748..971cf727d88 100644 +--- a/src/mlpack/bindings/python/CMakeLists.txt ++++ b/src/mlpack/bindings/python/CMakeLists.txt +@@ -203,6 +203,9 @@ execute_process(COMMAND ${PYTHON_EXECUTABLE} + "${PYTHON_INSTALL_PREFIX}" + OUTPUT_VARIABLE CMAKE_PYTHON_PATH) + string(STRIP "${CMAKE_PYTHON_PATH}" CMAKE_PYTHON_PATH) ++if (DEFINED ENV{PYTHONPATH}) ++ string(APPEND CMAKE_PYTHON_PATH : $ENV{PYTHONPATH}) ++endif () + install(CODE "set(ENV{PYTHONPATH} ${CMAKE_PYTHON_PATH})") + install(CODE "set(PYTHON_EXECUTABLE \"${PYTHON_EXECUTABLE}\")") + install(CODE "set(CMAKE_BINARY_DIR \"${CMAKE_BINARY_DIR}\")") diff --git a/var/spack/repos/builtin/packages/mlpack/package.py b/var/spack/repos/builtin/packages/mlpack/package.py index d84fdc3bc18..e667668d3a2 100644 --- a/var/spack/repos/builtin/packages/mlpack/package.py +++ b/var/spack/repos/builtin/packages/mlpack/package.py @@ -63,9 +63,9 @@ class Mlpack(CMakePackage): depends_on("r-testthat") depends_on("r-pkgbuild") + # https://github.com/mlpack/mlpack/pull/3502/commits/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch patch( - "https://github.com/mlpack/mlpack/pull/3502/commits/183396e51a6771d5d2b43f22b0d2a9a91785e533.patch?full_index=1", - sha256="eaa1791ca874201cca5fb661f44e0038f9996b2d02dac6c71d42935eac56a2b4", + "183396e51a6771d5d2b43f22b0d2a9a91785e533.patch", when="@4:4.2.0", ) diff --git a/var/spack/repos/builtin/packages/openscenegraph/759620a3b7b787c960a7e414ba26ab5497817d40.patch b/var/spack/repos/builtin/packages/openscenegraph/759620a3b7b787c960a7e414ba26ab5497817d40.patch new file mode 100644 index 00000000000..9b049c3e45f --- /dev/null +++ b/var/spack/repos/builtin/packages/openscenegraph/759620a3b7b787c960a7e414ba26ab5497817d40.patch @@ -0,0 +1,284 @@ +From 759620a3b7b787c960a7e414ba26ab5497817d40 Mon Sep 17 00:00:00 2001 +From: Pei Jia +Date: Sat, 9 Dec 2023 23:52:07 -0800 +Subject: [PATCH] It looks ffmpeg is a must for OSG? Now, compatible with + ffmpeg-6.0.1 + +--- + .../OpenCASCADE/ReaderWriterOpenCASCADE.cpp | 2 +- + src/osgPlugins/ffmpeg/FFmpegDecoder.cpp | 8 +++---- + src/osgPlugins/ffmpeg/FFmpegDecoderAudio.cpp | 14 ++++++----- + src/osgPlugins/ffmpeg/FFmpegDecoderAudio.hpp | 1 + + src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp | 23 +++++++++++-------- + src/osgPlugins/ffmpeg/FFmpegDecoderVideo.hpp | 7 +++--- + src/osgPlugins/ffmpeg/FFmpegHeaders.hpp | 1 + + src/osgPlugins/ffmpeg/FFmpegPacket.hpp | 2 +- + src/osgPlugins/ffmpeg/FFmpegParameters.hpp | 4 ++-- + src/osgPlugins/ffmpeg/ReaderWriterFFmpeg.cpp | 3 ++- + 10 files changed, 37 insertions(+), 28 deletions(-) + +diff --git a/src/osgPlugins/OpenCASCADE/ReaderWriterOpenCASCADE.cpp b/src/osgPlugins/OpenCASCADE/ReaderWriterOpenCASCADE.cpp +index 91a14220016..a43ca5d511e 100644 +--- a/src/osgPlugins/OpenCASCADE/ReaderWriterOpenCASCADE.cpp ++++ b/src/osgPlugins/OpenCASCADE/ReaderWriterOpenCASCADE.cpp +@@ -211,7 +211,7 @@ osg::ref_ptr ReaderWritterOpenCASCADE::OCCTKReader::_createGeomet + { + // populate vertex list + // Ref: http://www.opencascade.org/org/forum/thread_16694/?forum=3 +- gp_Pnt pt = (triangulation->Nodes())(j).Transformed(transformation * location.Transformation()); ++ gp_Pnt pt = (triangulation->Node(j)).Transformed(transformation * location.Transformation()); + vertexList->push_back(osg::Vec3(pt.X(), pt.Y(), pt.Z())); + + // populate color list +diff --git a/src/osgPlugins/ffmpeg/FFmpegDecoder.cpp b/src/osgPlugins/ffmpeg/FFmpegDecoder.cpp +index 4de143d2279..dd58b662b5f 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegDecoder.cpp ++++ b/src/osgPlugins/ffmpeg/FFmpegDecoder.cpp +@@ -62,7 +62,7 @@ bool FFmpegDecoder::open(const std::string & filename, FFmpegParameters* paramet + { + // Open video file + AVFormatContext * p_format_context = 0; +- AVInputFormat *iformat = 0; ++ const AVInputFormat *iformat = 0; + + if (filename.compare(0, 5, "/dev/")==0) + { +@@ -304,9 +304,9 @@ bool FFmpegDecoder::readNextPacketNormal() + else + { + // Make the packet data available beyond av_read_frame() logical scope. +- if ((error = av_dup_packet(&packet)) < 0) { +- OSG_FATAL << "av_dup_packet() returned " << AvStrError(error) << std::endl; +- throw std::runtime_error("av_dup_packet() failed"); ++ if ((error = av_packet_make_refcounted(&packet)) < 0) { ++ OSG_FATAL << "av_packet_make_refcounted() returned " << AvStrError(error) << std::endl; ++ throw std::runtime_error("av_packet_make_refcounted() failed"); + } + + m_pending_packet = FFmpegPacket(packet); +diff --git a/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.cpp b/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.cpp +index 636bddd2546..5e8db3dc0ba 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.cpp ++++ b/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.cpp +@@ -40,17 +40,17 @@ static int decode_audio(AVCodecContext *avctx, int16_t *samples, + avpkt.size = buf_size; + + AVFrame *frame = av_frame_alloc(); +- int ret, got_frame = 0; ++ int ret; + + if (!frame) + return AVERROR(ENOMEM); + +- ret = avcodec_decode_audio4(avctx, frame, &got_frame, &avpkt); ++ ret = avcodec_receive_frame(avctx, frame); + + #ifdef USE_AVRESAMPLE // libav's AVFrame structure does not contain a 'channels' field +- if (ret >= 0 && got_frame) { ++ if (ret >= 0) { + #else +- if (ret >= 0 && got_frame && av_frame_get_channels(frame)>0) { ++ if (ret >= 0 && frame->channels>0) { + #endif + int ch, plane_size; + int planar = av_sample_fmt_is_planar(avctx->sample_fmt); +@@ -151,7 +151,9 @@ void FFmpegDecoderAudio::open(AVStream * const stream, FFmpegParameters* paramet + return; + + m_stream = stream; +- m_context = stream->codec; ++ m_codecpar = stream->codecpar; ++ const AVCodec* p_codec = avcodec_find_decoder(m_codecpar->codec_id); ++ m_context = avcodec_alloc_context3(p_codec); + + m_in_sample_rate = m_context->sample_rate; + m_in_nb_channels = m_context->channels; +@@ -214,7 +216,7 @@ printf("### CONVERTING from sample format %s TO %s\n\t\tFROM %d TO %d channels\n + throw std::runtime_error("invalid audio codec");; + + // Find the decoder for the audio stream +- AVCodec * const p_codec = avcodec_find_decoder(m_context->codec_id); ++ p_codec = avcodec_find_decoder(m_context->codec_id); + + if (p_codec == 0) + throw std::runtime_error("avcodec_find_decoder() failed"); +diff --git a/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.hpp b/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.hpp +index 9f1b968ccbd..f2f9b3407fb 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.hpp ++++ b/src/osgPlugins/ffmpeg/FFmpegDecoderAudio.hpp +@@ -59,6 +59,7 @@ class FFmpegDecoderAudio : public OpenThreads::Thread + PacketQueue & m_packets; + FFmpegClocks & m_clocks; + AVStream * m_stream; ++ AVCodecParameters * m_codecpar; + AVCodecContext * m_context; + FFmpegPacket m_packet; + const uint8_t * m_packet_data; +diff --git a/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp b/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp +index 25df979a045..b5214e11f00 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp ++++ b/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp +@@ -62,7 +62,9 @@ FFmpegDecoderVideo::~FFmpegDecoderVideo() + void FFmpegDecoderVideo::open(AVStream * const stream) + { + m_stream = stream; +- m_context = stream->codec; ++ m_codecpar = stream->codecpar; ++ const AVCodec* p_codec = avcodec_find_decoder(m_codecpar->codec_id); ++ m_context = avcodec_alloc_context3(p_codec); + + // Trust the video size given at this point + // (avcodec_open seems to sometimes return a 0x0 size) +@@ -99,11 +101,12 @@ void FFmpegDecoderVideo::open(AVStream * const stream) + + // Allocate converted RGB frame + m_frame_rgba.reset(av_frame_alloc()); +- m_buffer_rgba[0].resize(avpicture_get_size(AV_PIX_FMT_RGB24, width(), height())); ++ m_buffer_rgba[0].resize(av_image_get_buffer_size(AV_PIX_FMT_RGB24, width(), height(), 1)); + m_buffer_rgba[1].resize(m_buffer_rgba[0].size()); + + // Assign appropriate parts of the buffer to image planes in m_frame_rgba +- avpicture_fill((AVPicture *) (m_frame_rgba).get(), &(m_buffer_rgba[0])[0], AV_PIX_FMT_RGB24, width(), height()); ++ AVFrame *avf = m_frame_rgba.get(); ++ av_image_fill_arrays(avf->data, avf->linesize, &(m_buffer_rgba[0])[0], AV_PIX_FMT_RGB24, width(), height(), 1); + + // Override get_buffer()/release_buffer() from codec context in order to retrieve the PTS of each frame. + m_context->opaque = this; +@@ -169,7 +172,7 @@ void FFmpegDecoderVideo::decodeLoop() + int frame_finished = 0; + + // We want to use the entire packet since some codecs will require extra information for decoding +- const int bytes_decoded = avcodec_decode_video2(m_context, m_frame.get(), &frame_finished, &(packet.packet)); ++ const int bytes_decoded = avcodec_receive_frame(m_context, m_frame.get()); + + if (bytes_decoded < 0) + throw std::runtime_error("avcodec_decode_video failed()"); +@@ -283,7 +286,7 @@ void FFmpegDecoderVideo::findAspectRatio() + m_pixel_aspect_ratio = ratio; + } + +-int FFmpegDecoderVideo::convert(AVPicture *dst, int dst_pix_fmt, AVPicture *src, ++int FFmpegDecoderVideo::convert(AVFrame *dst, int dst_pix_fmt, AVFrame *src, + int src_pix_fmt, int src_width, int src_height) + { + osg::Timer_t startTick = osg::Timer::instance()->tick(); +@@ -334,11 +337,11 @@ void FFmpegDecoderVideo::publishFrame(const double delay, bool audio_disabled) + return; + #endif + +- AVPicture * const src = (AVPicture *) m_frame.get(); +- AVPicture * const dst = (AVPicture *) m_frame_rgba.get(); ++ AVFrame * const src = (AVFrame *) m_frame.get(); ++ AVFrame * const dst = (AVFrame *) m_frame_rgba.get(); + +- // Assign appropriate parts of the buffer to image planes in m_frame_rgba +- avpicture_fill((AVPicture *) (m_frame_rgba).get(), &(m_buffer_rgba[m_writeBuffer])[0], AV_PIX_FMT_RGB24, width(), height()); ++ // Assign appropriate parts of the buffer to image planes in m_frame_rgba ++ av_image_fill_arrays(dst->data, dst->linesize, &(m_buffer_rgba[m_writeBuffer])[0], AV_PIX_FMT_RGB24, width(), height(), 1); + + // Convert YUVA420p (i.e. YUV420p plus alpha channel) using our own routine + +@@ -370,7 +373,7 @@ void FFmpegDecoderVideo::publishFrame(const double delay, bool audio_disabled) + + + +-void FFmpegDecoderVideo::yuva420pToRgba(AVPicture * const dst, AVPicture * const src, int width, int height) ++void FFmpegDecoderVideo::yuva420pToRgba(AVFrame * const dst, AVFrame * const src, int width, int height) + { + convert(dst, AV_PIX_FMT_RGB24, src, m_context->pix_fmt, width, height); + +diff --git a/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.hpp b/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.hpp +index 778c1a9b8cb..ffbfaaf6a36 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.hpp ++++ b/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.hpp +@@ -88,9 +88,9 @@ class FFmpegDecoderVideo : public OpenThreads::Thread + void findAspectRatio(); + void publishFrame(double delay, bool audio_disabled); + double synchronizeVideo(double pts); +- void yuva420pToRgba(AVPicture *dst, AVPicture *src, int width, int height); ++ void yuva420pToRgba(AVFrame *dst, AVFrame *src, int width, int height); + +- int convert(AVPicture *dst, int dst_pix_fmt, AVPicture *src, ++ int convert(AVFrame *dst, int dst_pix_fmt, AVFrame *src, + int src_pix_fmt, int src_width, int src_height); + + +@@ -100,8 +100,9 @@ class FFmpegDecoderVideo : public OpenThreads::Thread + PacketQueue & m_packets; + FFmpegClocks & m_clocks; + AVStream * m_stream; ++ AVCodecParameters * m_codecpar; + AVCodecContext * m_context; +- AVCodec * m_codec; ++ const AVCodec * m_codec; + const uint8_t * m_packet_data; + int m_bytes_remaining; + int64_t m_packet_pts; +diff --git a/src/osgPlugins/ffmpeg/FFmpegHeaders.hpp b/src/osgPlugins/ffmpeg/FFmpegHeaders.hpp +index fd9bd2c923d..4c107093106 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegHeaders.hpp ++++ b/src/osgPlugins/ffmpeg/FFmpegHeaders.hpp +@@ -44,6 +44,7 @@ extern "C" + #endif + + #include ++#include + + #ifdef USE_SWSCALE + #include +diff --git a/src/osgPlugins/ffmpeg/FFmpegPacket.hpp b/src/osgPlugins/ffmpeg/FFmpegPacket.hpp +index e06bd8bb6d3..94cc13b1b6b 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegPacket.hpp ++++ b/src/osgPlugins/ffmpeg/FFmpegPacket.hpp +@@ -42,7 +42,7 @@ namespace osgFFmpeg + void clear() + { + if (packet.data != 0) +- av_free_packet(&packet); ++ av_packet_unref(&packet); + + release(); + } +diff --git a/src/osgPlugins/ffmpeg/FFmpegParameters.hpp b/src/osgPlugins/ffmpeg/FFmpegParameters.hpp +index ebfc17f6b6d..1b8dd287eb5 100644 +--- a/src/osgPlugins/ffmpeg/FFmpegParameters.hpp ++++ b/src/osgPlugins/ffmpeg/FFmpegParameters.hpp +@@ -20,7 +20,7 @@ class FFmpegParameters : public osg::Referenced + + bool isFormatAvailable() const { return m_format!=NULL; } + +- AVInputFormat* getFormat() { return m_format; } ++ const AVInputFormat* getFormat() { return m_format; } + AVDictionary** getOptions() { return &m_options; } + void setContext(AVIOContext* context) { m_context = context; } + AVIOContext* getContext() { return m_context; } +@@ -29,7 +29,7 @@ class FFmpegParameters : public osg::Referenced + + protected: + +- AVInputFormat* m_format; ++ const AVInputFormat* m_format; + AVIOContext* m_context; + AVDictionary* m_options; + }; +diff --git a/src/osgPlugins/ffmpeg/ReaderWriterFFmpeg.cpp b/src/osgPlugins/ffmpeg/ReaderWriterFFmpeg.cpp +index f468ee81f27..2041bb55068 100644 +--- a/src/osgPlugins/ffmpeg/ReaderWriterFFmpeg.cpp ++++ b/src/osgPlugins/ffmpeg/ReaderWriterFFmpeg.cpp +@@ -25,6 +25,7 @@ + (LIBAVCODEC_VERSION_MAJOR==52 && LIBAVCODEC_VERSION_MINOR==20 && LIBAVCODEC_VERSION_MICRO >= 1) + #define USE_AV_LOCK_MANAGER + #endif ++#undef USE_AV_LOCK_MANAGER + + extern "C" { + +@@ -118,7 +119,7 @@ class ReaderWriterFFmpeg : public osgDB::ReaderWriter + av_lockmgr_register(&lockMgr); + #endif + // Register all FFmpeg formats/codecs +- av_register_all(); ++ // av_register_all(); // Omit after ffmpeg 4.0 + + avformat_network_init(); + } diff --git a/var/spack/repos/builtin/packages/openscenegraph/package.py b/var/spack/repos/builtin/packages/openscenegraph/package.py index c1ec2f50106..3fe8d5dfdd1 100644 --- a/var/spack/repos/builtin/packages/openscenegraph/package.py +++ b/var/spack/repos/builtin/packages/openscenegraph/package.py @@ -82,9 +82,9 @@ class Openscenegraph(CMakePackage): # patch submitted for inclusion in OpenSceneGraph for extending compatibility # with ffmpeg from versions up to 4 to versions 5 & 6 + # https://github.com/openscenegraph/OpenSceneGraph/pull/1281/commits/759620a3b7b787c960a7e414ba26ab5497817d40.patch patch( - "https://github.com/openscenegraph/OpenSceneGraph/pull/1281/commits/759620a3b7b787c960a7e414ba26ab5497817d40.patch?full_index=1", - sha256="b8f588d1fba9361127a7d5127e0720a4d64f44ef021515d1d67d77dcacdef8fd", + "759620a3b7b787c960a7e414ba26ab5497817d40.patch", when="@3.6:", ) patch("glibc-jasper.patch", when="@3.4%gcc") diff --git a/var/spack/repos/builtin/packages/protobuf/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch b/var/spack/repos/builtin/packages/protobuf/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch new file mode 100644 index 00000000000..2a0e9f6d0c3 --- /dev/null +++ b/var/spack/repos/builtin/packages/protobuf/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch @@ -0,0 +1,50 @@ +From 3039f932aaf212bcf2f14a3f2fd00dbfb881e46b Mon Sep 17 00:00:00 2001 +From: Lourens Veen +Date: Mon, 21 Nov 2022 09:15:34 +0100 +Subject: [PATCH] Fix shared object ABI exports (#5144) + +--- + src/libprotobuf-lite.map | 2 ++ + src/libprotobuf.map | 2 ++ + src/libprotoc.map | 2 ++ + 3 files changed, 6 insertions(+) + +diff --git a/src/libprotobuf-lite.map b/src/libprotobuf-lite.map +index 391554669481..a1853ca6cbf2 100644 +--- a/src/libprotobuf-lite.map ++++ b/src/libprotobuf-lite.map +@@ -3,6 +3,8 @@ + extern "C++" { + *google*; + }; ++ scc_info_*; ++ descriptor_table_*; + + local: + *; +diff --git a/src/libprotobuf.map b/src/libprotobuf.map +index 391554669481..a1853ca6cbf2 100644 +--- a/src/libprotobuf.map ++++ b/src/libprotobuf.map +@@ -3,6 +3,8 @@ + extern "C++" { + *google*; + }; ++ scc_info_*; ++ descriptor_table_*; + + local: + *; +diff --git a/src/libprotoc.map b/src/libprotoc.map +index 391554669481..a1853ca6cbf2 100644 +--- a/src/libprotoc.map ++++ b/src/libprotoc.map +@@ -3,6 +3,8 @@ + extern "C++" { + *google*; + }; ++ scc_info_*; ++ descriptor_table_*; + + local: + *; diff --git a/var/spack/repos/builtin/packages/protobuf/package.py b/var/spack/repos/builtin/packages/protobuf/package.py index 035eab572a9..49ab8d0576b 100644 --- a/var/spack/repos/builtin/packages/protobuf/package.py +++ b/var/spack/repos/builtin/packages/protobuf/package.py @@ -109,10 +109,10 @@ class Protobuf(CMakePackage): ) # fix build on Centos 8, see also https://github.com/protocolbuffers/protobuf/issues/5144 + # https://github.com/protocolbuffers/protobuf/pull/11032/commits/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch patch( - "https://github.com/protocolbuffers/protobuf/pull/11032/commits/3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch?full_index=1", + "3039f932aaf212bcf2f14a3f2fd00dbfb881e46b.patch", when="@3.4:3.21", - sha256="cefc4bf4aadf9ca33a336b2aa6d0d82006b6563e85122ae8cfb70345f85321dd", ) patch("msvc-abseil-target-namespace.patch", when="@3.22 %msvc") diff --git a/var/spack/repos/builtin/packages/py-astor/30059dac4eb832e58ab2109db84508b294ba366d.patch b/var/spack/repos/builtin/packages/py-astor/30059dac4eb832e58ab2109db84508b294ba366d.patch new file mode 100644 index 00000000000..63f57e407ff --- /dev/null +++ b/var/spack/repos/builtin/packages/py-astor/30059dac4eb832e58ab2109db84508b294ba366d.patch @@ -0,0 +1,97 @@ +From 30059dac4eb832e58ab2109db84508b294ba366d Mon Sep 17 00:00:00 2001 +From: Jonathan Ringer +Date: Thu, 17 Oct 2019 16:54:16 -0700 +Subject: [PATCH] Fix packaging for setuptools>=41.4 + +--- + MANIFEST.in | 1 + + astor/VERSION | 1 + + astor/__init__.py | 5 ++++- + setup.cfg | 3 ++- + setup.py | 16 +--------------- + 5 files changed, 9 insertions(+), 17 deletions(-) + create mode 100644 astor/VERSION + +diff --git a/MANIFEST.in b/MANIFEST.in +index b12a6fe..81e72d5 100644 +--- a/MANIFEST.in ++++ b/MANIFEST.in +@@ -1,3 +1,4 @@ + include README.rst AUTHORS LICENSE CHANGES + include setuputils.py ++include astor/VERSION + recursive-include tests *.py +diff --git a/astor/VERSION b/astor/VERSION +new file mode 100644 +index 0000000..a3df0a6 +--- /dev/null ++++ b/astor/VERSION +@@ -0,0 +1 @@ ++0.8.0 +diff --git a/astor/__init__.py b/astor/__init__.py +index 3b02983..bdedaef 100644 +--- a/astor/__init__.py ++++ b/astor/__init__.py +@@ -9,6 +9,7 @@ + + """ + ++import os + import warnings + + from .code_gen import SourceGenerator, to_source # NOQA +@@ -19,7 +20,9 @@ + from .op_util import symbol_data # NOQA + from .tree_walk import TreeWalk # NOQA + +-__version__ = '0.8.0' ++ROOT = os.path.dirname(__file__) ++with open(os.path.join(ROOT, 'VERSION')) as version_file: ++ __version__ = version_file.read().strip() + + parse_file = code_to_ast.parse_file + +diff --git a/setup.cfg b/setup.cfg +index 1baf6fc..a43634f 100644 +--- a/setup.cfg ++++ b/setup.cfg +@@ -2,6 +2,7 @@ + name = astor + description = Read/rewrite/write Python ASTs + long_description = file:README.rst ++version = file: astor/VERSION + author = Patrick Maupin + author_email = pmaupin@gmail.com + platforms = Independent +@@ -40,7 +41,7 @@ test_suite = nose.collector + [options.packages.find] + exclude = tests + +-[wheel] ++[bdist_wheel] + universal = 1 + + [build-system] +diff --git a/setup.py b/setup.py +index 4a111b5..6068493 100644 +--- a/setup.py ++++ b/setup.py +@@ -1,17 +1,3 @@ +-import os +-import sys +- + from setuptools import setup +-from setuptools.config import read_configuration +- +-from setuputils import find_version +- +- +-def here(*paths): +- return os.path.join(os.path.dirname(__file__), *paths) +- +-config = read_configuration(here('setup.cfg')) +-config['metadata']['version'] = find_version(here('astor', '__init__.py')) +-config['options'].update(config['metadata']) + +-setup(**config['options']) ++setup() diff --git a/var/spack/repos/builtin/packages/py-astor/package.py b/var/spack/repos/builtin/packages/py-astor/package.py index 8b7703fc7eb..0c679579cf2 100644 --- a/var/spack/repos/builtin/packages/py-astor/package.py +++ b/var/spack/repos/builtin/packages/py-astor/package.py @@ -24,8 +24,8 @@ class PyAstor(PythonPackage): # Build fails with newer versions of setuptools # https://github.com/berkerpeksag/astor/issues/162 # https://github.com/berkerpeksag/astor/pull/163 + # https://github.com/berkerpeksag/astor/pull/163/commits/30059dac4eb832e58ab2109db84508b294ba366d.patch patch( - "https://github.com/berkerpeksag/astor/pull/163/commits/30059dac4eb832e58ab2109db84508b294ba366d.patch?full_index=1", - sha256="edc5eeddabe153b08e938f52edaeb2d880ee3128082967f310db0f98510fe6e0", + "30059dac4eb832e58ab2109db84508b294ba366d.patch", when="@0.8.0", ) diff --git a/var/spack/repos/builtin/packages/umpire/2292d1d6078f6d9523b7ad0886ffa053644569d5.patch b/var/spack/repos/builtin/packages/umpire/2292d1d6078f6d9523b7ad0886ffa053644569d5.patch new file mode 100644 index 00000000000..72ef82a081d --- /dev/null +++ b/var/spack/repos/builtin/packages/umpire/2292d1d6078f6d9523b7ad0886ffa053644569d5.patch @@ -0,0 +1,6932 @@ +From 2292d1d6078f6d9523b7ad0886ffa053644569d5 Mon Sep 17 00:00:00 2001 +From: Alan Dayton +Date: Tue, 14 Feb 2023 16:06:35 -0800 +Subject: [PATCH] Prefix fmt macros to avoid conflicts + +--- + src/tpl/umpire/fmt/args.h | 18 +- + src/tpl/umpire/fmt/chrono.h | 228 ++++----- + src/tpl/umpire/fmt/color.h | 132 ++--- + src/tpl/umpire/fmt/compile.h | 124 ++--- + src/tpl/umpire/fmt/core.h | 604 +++++++++++------------ + src/tpl/umpire/fmt/fmt.hpp | 6 +- + src/tpl/umpire/fmt/format-inl.h | 330 ++++++------- + src/tpl/umpire/fmt/format.h | 842 ++++++++++++++++---------------- + src/tpl/umpire/fmt/locale.h | 12 +- + src/tpl/umpire/fmt/os.h | 134 ++--- + src/tpl/umpire/fmt/ostream.h | 22 +- + src/tpl/umpire/fmt/printf.h | 50 +- + src/tpl/umpire/fmt/ranges.h | 74 +-- + 13 files changed, 1288 insertions(+), 1288 deletions(-) + +diff --git a/src/tpl/umpire/fmt/args.h b/src/tpl/umpire/fmt/args.h +index 24dbec930..33fa9fc5c 100644 +--- a/src/tpl/umpire/fmt/args.h ++++ b/src/tpl/umpire/fmt/args.h +@@ -5,8 +5,8 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_ARGS_H_ +-#define FMT_ARGS_H_ ++#ifndef UMPIRE_FMT_ARGS_H_ ++#define UMPIRE_FMT_ARGS_H_ + + #include // std::reference_wrapper + #include // std::unique_ptr +@@ -14,7 +14,7 @@ + + #include "core.h" + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + + namespace detail { + +@@ -40,10 +40,10 @@ class dynamic_arg_list { + T value; + + template +- FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} ++ UMPIRE_FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} + + template +- FMT_CONSTEXPR typed_node(const basic_string_view& arg) ++ UMPIRE_FMT_CONSTEXPR typed_node(const basic_string_view& arg) + : value(arg.data(), arg.size()) {} + }; + +@@ -72,7 +72,7 @@ class dynamic_arg_list { + */ + template + class dynamic_format_arg_store +-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 ++#if UMPIRE_FMT_GCC_VERSION && UMPIRE_FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args + #endif +@@ -220,13 +220,13 @@ class dynamic_format_arg_store + \endrst + */ + void reserve(size_t new_cap, size_t new_cap_named) { +- FMT_ASSERT(new_cap >= new_cap_named, ++ UMPIRE_FMT_ASSERT(new_cap >= new_cap_named, + "Set of arguments includes set of named arguments"); + data_.reserve(new_cap); + named_info_.reserve(new_cap_named); + } + }; + +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_ARGS_H_ ++#endif // UMPIRE_FMT_ARGS_H_ +diff --git a/src/tpl/umpire/fmt/chrono.h b/src/tpl/umpire/fmt/chrono.h +index e7909e7b5..7772d9aae 100644 +--- a/src/tpl/umpire/fmt/chrono.h ++++ b/src/tpl/umpire/fmt/chrono.h +@@ -5,8 +5,8 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_CHRONO_H_ +-#define FMT_CHRONO_H_ ++#ifndef UMPIRE_FMT_CHRONO_H_ ++#define UMPIRE_FMT_CHRONO_H_ + + #include + #include +@@ -17,13 +17,13 @@ + #include "format.h" + #include "locale.h" + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + + // Enable safe chrono durations, unless explicitly disabled. +-#ifndef FMT_SAFE_DURATION_CAST +-# define FMT_SAFE_DURATION_CAST 1 ++#ifndef UMPIRE_FMT_SAFE_DURATION_CAST ++# define UMPIRE_FMT_SAFE_DURATION_CAST 1 + #endif +-#if FMT_SAFE_DURATION_CAST ++#if UMPIRE_FMT_SAFE_DURATION_CAST + + // For conversion between std::chrono::durations without undefined + // behaviour or erroneous results. +@@ -34,10 +34,10 @@ FMT_BEGIN_NAMESPACE + namespace safe_duration_cast { + + template ::value && ++ UMPIRE_FMT_ENABLE_IF(!std::is_same::value && + std::numeric_limits::is_signed == + std::numeric_limits::is_signed)> +-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { ++UMPIRE_FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; +@@ -63,10 +63,10 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + * can't be converted to To without loss, ec is set. + */ + template ::value && ++ UMPIRE_FMT_ENABLE_IF(!std::is_same::value && + std::numeric_limits::is_signed != + std::numeric_limits::is_signed)> +-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { ++UMPIRE_FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; +@@ -96,8 +96,8 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + } + + template ::value)> +-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { ++ UMPIRE_FMT_ENABLE_IF(std::is_same::value)> ++UMPIRE_FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + return from; + } // function +@@ -117,8 +117,8 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + */ + // clang-format on + template ::value)> +-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { ++ UMPIRE_FMT_ENABLE_IF(!std::is_same::value)> ++UMPIRE_FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + ec = 0; + using T = std::numeric_limits; + static_assert(std::is_floating_point::value, "From must be floating"); +@@ -139,8 +139,8 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + } // function + + template ::value)> +-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { ++ UMPIRE_FMT_ENABLE_IF(std::is_same::value)> ++UMPIRE_FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + ec = 0; + static_assert(std::is_floating_point::value, "From must be floating"); + return from; +@@ -150,8 +150,8 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + * safe duration cast between integral durations + */ + template ::value), +- FMT_ENABLE_IF(std::is_integral::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_integral::value), ++ UMPIRE_FMT_ENABLE_IF(std::is_integral::value)> + To safe_duration_cast(std::chrono::duration from, + int& ec) { + using From = std::chrono::duration; +@@ -201,8 +201,8 @@ To safe_duration_cast(std::chrono::duration from, + * safe duration_cast between floating point durations + */ + template ::value), +- FMT_ENABLE_IF(std::is_floating_point::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value), ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value)> + To safe_duration_cast(std::chrono::duration from, + int& ec) { + using From = std::chrono::duration; +@@ -279,11 +279,11 @@ To safe_duration_cast(std::chrono::duration from, + #endif + + // Prevents expansion of a preceding token as a function-style macro. +-// Usage: f FMT_NOMACRO() +-#define FMT_NOMACRO ++// Usage: f UMPIRE_FMT_NOMACRO() ++#define UMPIRE_FMT_NOMACRO + + namespace detail { +-inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); } ++inline null<> localtime_r UMPIRE_FMT_NOMACRO(...) { return null<>(); } + inline null<> localtime_s(...) { return null<>(); } + inline null<> gmtime_r(...) { return null<>(); } + inline null<> gmtime_s(...) { return null<>(); } +@@ -315,7 +315,7 @@ inline std::tm localtime(std::time_t time) { + + bool fallback(int res) { return res == 0; } + +-#if !FMT_MSC_VER ++#if !UMPIRE_FMT_MSC_VER + bool fallback(detail::null<>) { + using namespace umpire::fmt::detail; + std::tm* tm = std::localtime(&time_); +@@ -326,7 +326,7 @@ inline std::tm localtime(std::time_t time) { + }; + dispatcher lt(time); + // Too big time values may be unsupported. +- if (!lt.run()) FMT_THROW(format_error("time_t value out of range")); ++ if (!lt.run()) UMPIRE_FMT_THROW(format_error("time_t value out of range")); + return lt.tm_; + } + +@@ -361,7 +361,7 @@ inline std::tm gmtime(std::time_t time) { + + bool fallback(int res) { return res == 0; } + +-#if !FMT_MSC_VER ++#if !UMPIRE_FMT_MSC_VER + bool fallback(detail::null<>) { + std::tm* tm = std::gmtime(&time_); + if (tm) tm_ = *tm; +@@ -371,7 +371,7 @@ inline std::tm gmtime(std::time_t time) { + }; + dispatcher gt(time); + // Too big time values may be unsupported. +- if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); ++ if (!gt.run()) UMPIRE_FMT_THROW(format_error("time_t value out of range")); + return gt.tm_; + } + +@@ -414,7 +414,7 @@ struct formatter, Char> + + template struct formatter { + template +- FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { ++ UMPIRE_FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + auto it = ctx.begin(); + if (it != ctx.end() && *it == ':') ++it; + auto end = it; +@@ -455,64 +455,64 @@ template struct formatter { + }; + + namespace detail { +-template FMT_CONSTEXPR const char* get_units() { ++template UMPIRE_FMT_CONSTEXPR const char* get_units() { + return nullptr; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "as"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "fs"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "ps"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "ns"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "µs"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "ms"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "cs"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "ds"; + } +-template <> FMT_CONSTEXPR inline const char* get_units>() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units>() { + return "s"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "das"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "hs"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "ks"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "Ms"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "Gs"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "Ts"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "Ps"; + } +-template <> FMT_CONSTEXPR inline const char* get_units() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units() { + return "Es"; + } +-template <> FMT_CONSTEXPR inline const char* get_units>() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units>() { + return "m"; + } +-template <> FMT_CONSTEXPR inline const char* get_units>() { ++template <> UMPIRE_FMT_CONSTEXPR inline const char* get_units>() { + return "h"; + } + +@@ -524,7 +524,7 @@ enum class numeric_system { + + // Parses a put_time-like format string and invokes handler actions. + template +-FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, ++UMPIRE_FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + const Char* end, + Handler&& handler) { + auto ptr = begin; +@@ -537,7 +537,7 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + } + if (begin != ptr) handler.on_text(begin, ptr); + ++ptr; // consume '%' +- if (ptr == end) FMT_THROW(format_error("invalid format")); ++ if (ptr == end) UMPIRE_FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case '%': +@@ -628,7 +628,7 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + break; + // Alternative representation: + case 'E': { +- if (ptr == end) FMT_THROW(format_error("invalid format")); ++ if (ptr == end) UMPIRE_FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'c': +@@ -641,12 +641,12 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + handler.on_loc_time(numeric_system::alternative); + break; + default: +- FMT_THROW(format_error("invalid format")); ++ UMPIRE_FMT_THROW(format_error("invalid format")); + } + break; + } + case 'O': +- if (ptr == end) FMT_THROW(format_error("invalid format")); ++ if (ptr == end) UMPIRE_FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'w': +@@ -668,11 +668,11 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + handler.on_second(numeric_system::alternative); + break; + default: +- FMT_THROW(format_error("invalid format")); ++ UMPIRE_FMT_THROW(format_error("invalid format")); + } + break; + default: +- FMT_THROW(format_error("invalid format")); ++ UMPIRE_FMT_THROW(format_error("invalid format")); + } + begin = ptr; + } +@@ -681,75 +681,75 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + } + + struct chrono_format_checker { +- FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); } ++ UMPIRE_FMT_NORETURN void report_no_date() { UMPIRE_FMT_THROW(format_error("no date")); } + + template +- FMT_CONSTEXPR void on_text(const Char*, const Char*) {} +- FMT_NORETURN void on_abbr_weekday() { report_no_date(); } +- FMT_NORETURN void on_full_weekday() { report_no_date(); } +- FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); } +- FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); } +- FMT_NORETURN void on_abbr_month() { report_no_date(); } +- FMT_NORETURN void on_full_month() { report_no_date(); } +- FMT_CONSTEXPR void on_24_hour(numeric_system) {} +- FMT_CONSTEXPR void on_12_hour(numeric_system) {} +- FMT_CONSTEXPR void on_minute(numeric_system) {} +- FMT_CONSTEXPR void on_second(numeric_system) {} +- FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); } +- FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); } +- FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); } +- FMT_NORETURN void on_us_date() { report_no_date(); } +- FMT_NORETURN void on_iso_date() { report_no_date(); } +- FMT_CONSTEXPR void on_12_hour_time() {} +- FMT_CONSTEXPR void on_24_hour_time() {} +- FMT_CONSTEXPR void on_iso_time() {} +- FMT_CONSTEXPR void on_am_pm() {} +- FMT_CONSTEXPR void on_duration_value() {} +- FMT_CONSTEXPR void on_duration_unit() {} +- FMT_NORETURN void on_utc_offset() { report_no_date(); } +- FMT_NORETURN void on_tz_name() { report_no_date(); } ++ UMPIRE_FMT_CONSTEXPR void on_text(const Char*, const Char*) {} ++ UMPIRE_FMT_NORETURN void on_abbr_weekday() { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_full_weekday() { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_abbr_month() { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_full_month() { report_no_date(); } ++ UMPIRE_FMT_CONSTEXPR void on_24_hour(numeric_system) {} ++ UMPIRE_FMT_CONSTEXPR void on_12_hour(numeric_system) {} ++ UMPIRE_FMT_CONSTEXPR void on_minute(numeric_system) {} ++ UMPIRE_FMT_CONSTEXPR void on_second(numeric_system) {} ++ UMPIRE_FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_us_date() { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_iso_date() { report_no_date(); } ++ UMPIRE_FMT_CONSTEXPR void on_12_hour_time() {} ++ UMPIRE_FMT_CONSTEXPR void on_24_hour_time() {} ++ UMPIRE_FMT_CONSTEXPR void on_iso_time() {} ++ UMPIRE_FMT_CONSTEXPR void on_am_pm() {} ++ UMPIRE_FMT_CONSTEXPR void on_duration_value() {} ++ UMPIRE_FMT_CONSTEXPR void on_duration_unit() {} ++ UMPIRE_FMT_NORETURN void on_utc_offset() { report_no_date(); } ++ UMPIRE_FMT_NORETURN void on_tz_name() { report_no_date(); } + }; + +-template ::value)> ++template ::value)> + inline bool isnan(T) { + return false; + } +-template ::value)> ++template ::value)> + inline bool isnan(T value) { + return std::isnan(value); + } + +-template ::value)> ++template ::value)> + inline bool isfinite(T) { + return true; + } +-template ::value)> ++template ::value)> + inline bool isfinite(T value) { + return std::isfinite(value); + } + + // Converts value to int and checks that it's in the range [0, upper). +-template ::value)> ++template ::value)> + inline int to_nonnegative_int(T value, int upper) { +- FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper), ++ UMPIRE_FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper), + "invalid value"); + (void)upper; + return static_cast(value); + } +-template ::value)> ++template ::value)> + inline int to_nonnegative_int(T value, int upper) { +- FMT_ASSERT( ++ UMPIRE_FMT_ASSERT( + std::isnan(value) || (value >= 0 && value <= static_cast(upper)), + "invalid value"); + (void)upper; + return static_cast(value); + } + +-template ::value)> ++template ::value)> + inline T mod(T x, int y) { + return x % static_cast(y); + } +-template ::value)> ++template ::value)> + inline T mod(T x, int y) { + return std::fmod(x, static_cast(y)); + } +@@ -765,24 +765,24 @@ template struct make_unsigned_or_unchanged { + using type = typename std::make_unsigned::type; + }; + +-#if FMT_SAFE_DURATION_CAST ++#if UMPIRE_FMT_SAFE_DURATION_CAST + // throwing version of safe_duration_cast + template + To fmt_safe_duration_cast(std::chrono::duration from) { + int ec; + To to = safe_duration_cast::safe_duration_cast(from, ec); +- if (ec) FMT_THROW(format_error("cannot format duration")); ++ if (ec) UMPIRE_FMT_THROW(format_error("cannot format duration")); + return to; + } + #endif + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_integral::value)> + inline std::chrono::duration get_milliseconds( + std::chrono::duration d) { + // this may overflow and/or the result may not fit in the + // target type. +-#if FMT_SAFE_DURATION_CAST ++#if UMPIRE_FMT_SAFE_DURATION_CAST + using CommonSecondsType = + typename std::common_type::type; + const auto d_as_common = fmt_safe_duration_cast(d); +@@ -800,7 +800,7 @@ inline std::chrono::duration get_milliseconds( + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value)> + inline std::chrono::duration get_milliseconds( + std::chrono::duration d) { + using common_type = typename std::common_type::type; +@@ -811,13 +811,13 @@ inline std::chrono::duration get_milliseconds( + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_integral::value)> + OutputIt format_duration_value(OutputIt out, Rep val, int) { + return write(out, val); + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value)> + OutputIt format_duration_value(OutputIt out, Rep val, int precision) { + auto specs = basic_format_specs(); + specs.precision = precision; +@@ -884,7 +884,7 @@ struct chrono_formatter { + + // this may overflow and/or the result may not fit in the + // target type. +-#if FMT_SAFE_DURATION_CAST ++#if UMPIRE_FMT_SAFE_DURATION_CAST + // might need checked conversion (rep!=Rep) + auto tmpval = std::chrono::duration(val); + s = fmt_safe_duration_cast(tmpval); +@@ -1013,7 +1013,7 @@ struct chrono_formatter { + + if (ns == numeric_system::standard) { + write(second(), 2); +-#if FMT_SAFE_DURATION_CAST ++#if UMPIRE_FMT_SAFE_DURATION_CAST + // convert rep->Rep + using duration_rep = std::chrono::duration; + using duration_Rep = std::chrono::duration; +@@ -1090,36 +1090,36 @@ struct formatter, Char> { + basic_format_parse_context& context; + basic_string_view format_str; + +- template FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) { ++ template UMPIRE_FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) { + context.check_arg_id(arg_id); + return arg_ref_type(arg_id); + } + +- FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view arg_id) { ++ UMPIRE_FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view arg_id) { + context.check_arg_id(arg_id); + return arg_ref_type(arg_id); + } + +- FMT_CONSTEXPR arg_ref_type make_arg_ref(detail::auto_id) { ++ UMPIRE_FMT_CONSTEXPR arg_ref_type make_arg_ref(detail::auto_id) { + return arg_ref_type(context.next_arg_id()); + } + +- void on_error(const char* msg) { FMT_THROW(format_error(msg)); } +- FMT_CONSTEXPR void on_fill(basic_string_view fill) { ++ void on_error(const char* msg) { UMPIRE_FMT_THROW(format_error(msg)); } ++ UMPIRE_FMT_CONSTEXPR void on_fill(basic_string_view fill) { + f.specs.fill = fill; + } +- FMT_CONSTEXPR void on_align(align_t align) { f.specs.align = align; } +- FMT_CONSTEXPR void on_width(int width) { f.specs.width = width; } +- FMT_CONSTEXPR void on_precision(int _precision) { ++ UMPIRE_FMT_CONSTEXPR void on_align(align_t align) { f.specs.align = align; } ++ UMPIRE_FMT_CONSTEXPR void on_width(int width) { f.specs.width = width; } ++ UMPIRE_FMT_CONSTEXPR void on_precision(int _precision) { + f.precision = _precision; + } +- FMT_CONSTEXPR void end_precision() {} ++ UMPIRE_FMT_CONSTEXPR void end_precision() {} + +- template FMT_CONSTEXPR void on_dynamic_width(Id arg_id) { ++ template UMPIRE_FMT_CONSTEXPR void on_dynamic_width(Id arg_id) { + f.width_ref = make_arg_ref(arg_id); + } + +- template FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) { ++ template UMPIRE_FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) { + f.precision_ref = make_arg_ref(arg_id); + } + }; +@@ -1130,7 +1130,7 @@ struct formatter, Char> { + iterator end; + }; + +- FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context& ctx) { ++ UMPIRE_FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context& ctx) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin == end || *begin == '}') return {begin, begin}; + spec_handler handler{*this, ctx, format_str}; +@@ -1149,7 +1149,7 @@ struct formatter, Char> { + } + + public: +- FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) ++ UMPIRE_FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto range = do_parse(ctx); + format_str = basic_string_view( +@@ -1185,6 +1185,6 @@ struct formatter, Char> { + } + }; + +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_CHRONO_H_ ++#endif // UMPIRE_FMT_CHRONO_H_ +diff --git a/src/tpl/umpire/fmt/color.h b/src/tpl/umpire/fmt/color.h +index 73e62b855..21037c37d 100644 +--- a/src/tpl/umpire/fmt/color.h ++++ b/src/tpl/umpire/fmt/color.h +@@ -5,19 +5,19 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_COLOR_H_ +-#define FMT_COLOR_H_ ++#ifndef UMPIRE_FMT_COLOR_H_ ++#define UMPIRE_FMT_COLOR_H_ + + #include "format.h" + + // __declspec(deprecated) is broken in some MSVC versions. +-#if FMT_MSC_VER +-# define FMT_DEPRECATED_NONMSVC ++#if UMPIRE_FMT_MSC_VER ++# define UMPIRE_FMT_DEPRECATED_NONMSVC + #else +-# define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED ++# define UMPIRE_FMT_DEPRECATED_NONMSVC UMPIRE_FMT_DEPRECATED + #endif + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + + enum class color : uint32_t { + alice_blue = 0xF0F8FF, // rgb(240,248,255) +@@ -192,11 +192,11 @@ enum class emphasis : uint8_t { + // rgb is a struct for red, green and blue colors. + // Using the name "rgb" makes some editors show the color in a tooltip. + struct rgb { +- FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} +- FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} +- FMT_CONSTEXPR rgb(uint32_t hex) ++ UMPIRE_FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} ++ UMPIRE_FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} ++ UMPIRE_FMT_CONSTEXPR rgb(uint32_t hex) + : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} +- FMT_CONSTEXPR rgb(color hex) ++ UMPIRE_FMT_CONSTEXPR rgb(color hex) + : r((uint32_t(hex) >> 16) & 0xFF), + g((uint32_t(hex) >> 8) & 0xFF), + b(uint32_t(hex) & 0xFF) {} +@@ -209,16 +209,16 @@ namespace detail { + + // color is a struct of either a rgb color or a terminal color. + struct color_type { +- FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {} +- FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true), ++ UMPIRE_FMT_CONSTEXPR color_type() UMPIRE_FMT_NOEXCEPT : is_rgb(), value{} {} ++ UMPIRE_FMT_CONSTEXPR color_type(color rgb_color) UMPIRE_FMT_NOEXCEPT : is_rgb(true), + value{} { + value.rgb_color = static_cast(rgb_color); + } +- FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} { ++ UMPIRE_FMT_CONSTEXPR color_type(rgb rgb_color) UMPIRE_FMT_NOEXCEPT : is_rgb(true), value{} { + value.rgb_color = (static_cast(rgb_color.r) << 16) | + (static_cast(rgb_color.g) << 8) | rgb_color.b; + } +- FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(), ++ UMPIRE_FMT_CONSTEXPR color_type(terminal_color term_color) UMPIRE_FMT_NOEXCEPT : is_rgb(), + value{} { + value.term_color = static_cast(term_color); + } +@@ -233,18 +233,18 @@ struct color_type { + /** A text style consisting of foreground and background colors and emphasis. */ + class text_style { + public: +- FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT ++ UMPIRE_FMT_CONSTEXPR text_style(emphasis em = emphasis()) UMPIRE_FMT_NOEXCEPT + : set_foreground_color(), + set_background_color(), + ems(em) {} + +- FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { ++ UMPIRE_FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { + if (!set_foreground_color) { + set_foreground_color = rhs.set_foreground_color; + foreground_color = rhs.foreground_color; + } else if (rhs.set_foreground_color) { + if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) +- FMT_THROW(format_error("can't OR a terminal color")); ++ UMPIRE_FMT_THROW(format_error("can't OR a terminal color")); + foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; + } + +@@ -253,7 +253,7 @@ class text_style { + background_color = rhs.background_color; + } else if (rhs.set_background_color) { + if (!background_color.is_rgb || !rhs.background_color.is_rgb) +- FMT_THROW(format_error("can't OR a terminal color")); ++ UMPIRE_FMT_THROW(format_error("can't OR a terminal color")); + background_color.value.rgb_color |= rhs.background_color.value.rgb_color; + } + +@@ -262,46 +262,46 @@ class text_style { + return *this; + } + +- friend FMT_CONSTEXPR text_style operator|(text_style lhs, ++ friend UMPIRE_FMT_CONSTEXPR text_style operator|(text_style lhs, + const text_style& rhs) { + return lhs |= rhs; + } + +- FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=( ++ UMPIRE_FMT_DEPRECATED_NONMSVC UMPIRE_FMT_CONSTEXPR text_style& operator&=( + const text_style& rhs) { + return and_assign(rhs); + } + +- FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style ++ UMPIRE_FMT_DEPRECATED_NONMSVC friend UMPIRE_FMT_CONSTEXPR text_style + operator&(text_style lhs, const text_style& rhs) { + return lhs.and_assign(rhs); + } + +- FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR bool has_foreground() const UMPIRE_FMT_NOEXCEPT { + return set_foreground_color; + } +- FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR bool has_background() const UMPIRE_FMT_NOEXCEPT { + return set_background_color; + } +- FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR bool has_emphasis() const UMPIRE_FMT_NOEXCEPT { + return static_cast(ems) != 0; + } +- FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT { +- FMT_ASSERT(has_foreground(), "no foreground specified for this style"); ++ UMPIRE_FMT_CONSTEXPR detail::color_type get_foreground() const UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(has_foreground(), "no foreground specified for this style"); + return foreground_color; + } +- FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT { +- FMT_ASSERT(has_background(), "no background specified for this style"); ++ UMPIRE_FMT_CONSTEXPR detail::color_type get_background() const UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(has_background(), "no background specified for this style"); + return background_color; + } +- FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT { +- FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); ++ UMPIRE_FMT_CONSTEXPR emphasis get_emphasis() const UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); + return ems; + } + + private: +- FMT_CONSTEXPR text_style(bool is_foreground, +- detail::color_type text_color) FMT_NOEXCEPT ++ UMPIRE_FMT_CONSTEXPR text_style(bool is_foreground, ++ detail::color_type text_color) UMPIRE_FMT_NOEXCEPT + : set_foreground_color(), + set_background_color(), + ems() { +@@ -315,13 +315,13 @@ class text_style { + } + + // DEPRECATED! +- FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) { ++ UMPIRE_FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) { + if (!set_foreground_color) { + set_foreground_color = rhs.set_foreground_color; + foreground_color = rhs.foreground_color; + } else if (rhs.set_foreground_color) { + if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) +- FMT_THROW(format_error("can't AND a terminal color")); ++ UMPIRE_FMT_THROW(format_error("can't AND a terminal color")); + foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color; + } + +@@ -330,7 +330,7 @@ class text_style { + background_color = rhs.background_color; + } else if (rhs.set_background_color) { + if (!background_color.is_rgb || !rhs.background_color.is_rgb) +- FMT_THROW(format_error("can't AND a terminal color")); ++ UMPIRE_FMT_THROW(format_error("can't AND a terminal color")); + background_color.value.rgb_color &= rhs.background_color.value.rgb_color; + } + +@@ -339,11 +339,11 @@ class text_style { + return *this; + } + +- friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground) +- FMT_NOEXCEPT; ++ friend UMPIRE_FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground) ++ UMPIRE_FMT_NOEXCEPT; + +- friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background) +- FMT_NOEXCEPT; ++ friend UMPIRE_FMT_CONSTEXPR_DECL text_style bg(detail::color_type background) ++ UMPIRE_FMT_NOEXCEPT; + + detail::color_type foreground_color; + detail::color_type background_color; +@@ -353,25 +353,25 @@ class text_style { + }; + + /** Creates a text style from the foreground (text) color. */ +-FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) UMPIRE_FMT_NOEXCEPT { + return text_style(true, foreground); + } + + /** Creates a text style from the background color. */ +-FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR inline text_style bg(detail::color_type background) UMPIRE_FMT_NOEXCEPT { + return text_style(false, background); + } + +-FMT_CONSTEXPR inline text_style operator|(emphasis lhs, +- emphasis rhs) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR inline text_style operator|(emphasis lhs, ++ emphasis rhs) UMPIRE_FMT_NOEXCEPT { + return text_style(lhs) | rhs; + } + + namespace detail { + + template struct ansi_color_escape { +- FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, +- const char* esc) FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, ++ const char* esc) UMPIRE_FMT_NOEXCEPT { + // If we have a terminal color, we need to output another escape code + // sequence. + if (!text_color.is_rgb) { +@@ -406,7 +406,7 @@ template struct ansi_color_escape { + to_esc(color.b, buffer + 15, 'm'); + buffer[19] = static_cast(0); + } +- FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR ansi_color_escape(emphasis em) UMPIRE_FMT_NOEXCEPT { + uint8_t em_codes[4] = {}; + uint8_t em_bits = static_cast(em); + if (em_bits & static_cast(emphasis::bold)) em_codes[0] = 1; +@@ -425,18 +425,18 @@ template struct ansi_color_escape { + } + buffer[index++] = static_cast(0); + } +- FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; } ++ UMPIRE_FMT_CONSTEXPR operator const Char*() const UMPIRE_FMT_NOEXCEPT { return buffer; } + +- FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; } +- FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT { ++ UMPIRE_FMT_CONSTEXPR const Char* begin() const UMPIRE_FMT_NOEXCEPT { return buffer; } ++ UMPIRE_FMT_CONSTEXPR const Char* end() const UMPIRE_FMT_NOEXCEPT { + return buffer + std::char_traits::length(buffer); + } + + private: + Char buffer[7u + 3u * 4u + 1u]; + +- static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, +- char delimiter) FMT_NOEXCEPT { ++ static UMPIRE_FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, ++ char delimiter) UMPIRE_FMT_NOEXCEPT { + out[0] = static_cast('0' + c / 100); + out[1] = static_cast('0' + c / 10 % 10); + out[2] = static_cast('0' + c % 10); +@@ -445,42 +445,42 @@ template struct ansi_color_escape { + }; + + template +-FMT_CONSTEXPR ansi_color_escape make_foreground_color( +- detail::color_type foreground) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR ansi_color_escape make_foreground_color( ++ detail::color_type foreground) UMPIRE_FMT_NOEXCEPT { + return ansi_color_escape(foreground, detail::data::foreground_color); + } + + template +-FMT_CONSTEXPR ansi_color_escape make_background_color( +- detail::color_type background) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR ansi_color_escape make_background_color( ++ detail::color_type background) UMPIRE_FMT_NOEXCEPT { + return ansi_color_escape(background, detail::data::background_color); + } + + template +-FMT_CONSTEXPR ansi_color_escape make_emphasis(emphasis em) FMT_NOEXCEPT { ++UMPIRE_FMT_CONSTEXPR ansi_color_escape make_emphasis(emphasis em) UMPIRE_FMT_NOEXCEPT { + return ansi_color_escape(em); + } + + template +-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT { ++inline void fputs(const Char* chars, FILE* stream) UMPIRE_FMT_NOEXCEPT { + std::fputs(chars, stream); + } + + template <> +-inline void fputs(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT { ++inline void fputs(const wchar_t* chars, FILE* stream) UMPIRE_FMT_NOEXCEPT { + std::fputws(chars, stream); + } + +-template inline void reset_color(FILE* stream) FMT_NOEXCEPT { ++template inline void reset_color(FILE* stream) UMPIRE_FMT_NOEXCEPT { + fputs(detail::data::reset_color, stream); + } + +-template <> inline void reset_color(FILE* stream) FMT_NOEXCEPT { ++template <> inline void reset_color(FILE* stream) UMPIRE_FMT_NOEXCEPT { + fputs(detail::data::wreset_color, stream); + } + + template +-inline void reset_color(buffer& buffer) FMT_NOEXCEPT { ++inline void reset_color(buffer& buffer) UMPIRE_FMT_NOEXCEPT { + const char* begin = data::reset_color; + const char* end = begin + sizeof(data::reset_color) - 1; + buffer.append(begin, end); +@@ -532,7 +532,7 @@ void vprint(std::FILE* f, const text_style& ts, const S& format, + \endrst + */ + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_string::value)> + void print(std::FILE* f, const text_style& ts, const S& format_str, + const Args&... args) { + vprint(f, ts, format_str, +@@ -551,7 +551,7 @@ void print(std::FILE* f, const text_style& ts, const S& format_str, + \endrst + */ + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_string::value)> + void print(const text_style& ts, const S& format_str, const Args&... args) { + return print(stdout, ts, format_str, args...); + } +@@ -588,7 +588,7 @@ inline std::basic_string format(const text_style& ts, const S& format_str, + Formats a string with the given text_style and writes the output to ``out``. + */ + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_output_iterator::value)> + OutputIt vformat_to( + OutputIt out, const text_style& ts, basic_string_view format_str, + basic_format_args>> args) { +@@ -619,6 +619,6 @@ inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, + umpire::fmt::make_args_checked(format_str, args...)); + } + +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_COLOR_H_ ++#endif // UMPIRE_FMT_COLOR_H_ +diff --git a/src/tpl/umpire/fmt/compile.h b/src/tpl/umpire/fmt/compile.h +index 3bcad028d..f9ef346c0 100644 +--- a/src/tpl/umpire/fmt/compile.h ++++ b/src/tpl/umpire/fmt/compile.h +@@ -5,24 +5,24 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_COMPILE_H_ +-#define FMT_COMPILE_H_ ++#ifndef UMPIRE_FMT_COMPILE_H_ ++#define UMPIRE_FMT_COMPILE_H_ + + #include + #include + + #include "format.h" + +-#ifndef FMT_USE_NONTYPE_TEMPLATE_PARAMETERS ++#ifndef UMPIRE_FMT_USE_NONTYPE_TEMPLATE_PARAMETERS + # if defined(__cpp_nontype_template_parameter_class) && \ +- (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 903) +-# define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 1 ++ (!UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_GCC_VERSION >= 903) ++# define UMPIRE_FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 1 + # else +-# define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 0 ++# define UMPIRE_FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 0 + # endif + #endif + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + namespace detail { + + template class truncating_iterator_base { +@@ -120,12 +120,12 @@ struct is_compiled_string : std::is_base_of {}; + + // Converts 42 into std::string using the most efficient method and no + // runtime format string processing. +- std::string s = umpire::fmt::format(FMT_COMPILE("{}"), 42); ++ std::string s = umpire::fmt::format(UMPIRE_FMT_COMPILE("{}"), 42); + \endrst + */ +-#define FMT_COMPILE(s) FMT_STRING_IMPL(s, umpire::fmt::detail::compiled_string) ++#define UMPIRE_FMT_COMPILE(s) UMPIRE_FMT_STRING_IMPL(s, umpire::fmt::detail::compiled_string) + +-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS ++#if UMPIRE_FMT_USE_NONTYPE_TEMPLATE_PARAMETERS + template struct fixed_string { + constexpr fixed_string(const Char (&str)[N]) { + copy_str(static_cast(str), str + N, +@@ -164,26 +164,26 @@ template struct format_part { + basic_string_view str; + replacement repl; + +- FMT_CONSTEXPR value(int index = 0) : arg_index(index) {} +- FMT_CONSTEXPR value(basic_string_view s) : str(s) {} +- FMT_CONSTEXPR value(replacement r) : repl(r) {} ++ UMPIRE_FMT_CONSTEXPR value(int index = 0) : arg_index(index) {} ++ UMPIRE_FMT_CONSTEXPR value(basic_string_view s) : str(s) {} ++ UMPIRE_FMT_CONSTEXPR value(replacement r) : repl(r) {} + } val; + // Position past the end of the argument id. + const Char* arg_id_end = nullptr; + +- FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {}) ++ UMPIRE_FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {}) + : part_kind(k), val(v) {} + +- static FMT_CONSTEXPR format_part make_arg_index(int index) { ++ static UMPIRE_FMT_CONSTEXPR format_part make_arg_index(int index) { + return format_part(kind::arg_index, index); + } +- static FMT_CONSTEXPR format_part make_arg_name(basic_string_view name) { ++ static UMPIRE_FMT_CONSTEXPR format_part make_arg_name(basic_string_view name) { + return format_part(kind::arg_name, name); + } +- static FMT_CONSTEXPR format_part make_text(basic_string_view text) { ++ static UMPIRE_FMT_CONSTEXPR format_part make_text(basic_string_view text) { + return format_part(kind::text, text); + } +- static FMT_CONSTEXPR format_part make_replacement(replacement repl) { ++ static UMPIRE_FMT_CONSTEXPR format_part make_replacement(replacement repl) { + return format_part(kind::replacement, repl); + } + }; +@@ -191,19 +191,19 @@ template struct format_part { + template struct part_counter { + unsigned num_parts = 0; + +- FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { ++ UMPIRE_FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { + if (begin != end) ++num_parts; + } + +- FMT_CONSTEXPR int on_arg_id() { return ++num_parts, 0; } +- FMT_CONSTEXPR int on_arg_id(int) { return ++num_parts, 0; } +- FMT_CONSTEXPR int on_arg_id(basic_string_view) { ++ UMPIRE_FMT_CONSTEXPR int on_arg_id() { return ++num_parts, 0; } ++ UMPIRE_FMT_CONSTEXPR int on_arg_id(int) { return ++num_parts, 0; } ++ UMPIRE_FMT_CONSTEXPR int on_arg_id(basic_string_view) { + return ++num_parts, 0; + } + +- FMT_CONSTEXPR void on_replacement_field(int, const Char*) {} ++ UMPIRE_FMT_CONSTEXPR void on_replacement_field(int, const Char*) {} + +- FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin, ++ UMPIRE_FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin, + const Char* end) { + // Find the matching brace. + unsigned brace_counter = 0; +@@ -218,12 +218,12 @@ template struct part_counter { + return begin; + } + +- FMT_CONSTEXPR void on_error(const char*) {} ++ UMPIRE_FMT_CONSTEXPR void on_error(const char*) {} + }; + + // Counts the number of parts in a format string. + template +-FMT_CONSTEXPR unsigned count_parts(basic_string_view format_str) { ++UMPIRE_FMT_CONSTEXPR unsigned count_parts(basic_string_view format_str) { + part_counter counter; + parse_format_string(format_str, counter); + return counter.num_parts; +@@ -240,39 +240,39 @@ class format_string_compiler : public error_handler { + basic_format_parse_context parse_context_; + + public: +- FMT_CONSTEXPR format_string_compiler(basic_string_view format_str, ++ UMPIRE_FMT_CONSTEXPR format_string_compiler(basic_string_view format_str, + PartHandler handler) + : handler_(handler), + format_str_(format_str), + parse_context_(format_str) {} + +- FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { ++ UMPIRE_FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { + if (begin != end) + handler_(part::make_text({begin, to_unsigned(end - begin)})); + } + +- FMT_CONSTEXPR int on_arg_id() { ++ UMPIRE_FMT_CONSTEXPR int on_arg_id() { + part_ = part::make_arg_index(parse_context_.next_arg_id()); + return 0; + } + +- FMT_CONSTEXPR int on_arg_id(int id) { ++ UMPIRE_FMT_CONSTEXPR int on_arg_id(int id) { + parse_context_.check_arg_id(id); + part_ = part::make_arg_index(id); + return 0; + } + +- FMT_CONSTEXPR int on_arg_id(basic_string_view id) { ++ UMPIRE_FMT_CONSTEXPR int on_arg_id(basic_string_view id) { + part_ = part::make_arg_name(id); + return 0; + } + +- FMT_CONSTEXPR void on_replacement_field(int, const Char* ptr) { ++ UMPIRE_FMT_CONSTEXPR void on_replacement_field(int, const Char* ptr) { + part_.arg_id_end = ptr; + handler_(part_); + } + +- FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin, ++ UMPIRE_FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin, + const Char* end) { + auto repl = typename part::replacement(); + dynamic_specs_handler> handler( +@@ -291,7 +291,7 @@ class format_string_compiler : public error_handler { + + // Compiles a format string and invokes handler(part) for each parsed part. + template +-FMT_CONSTEXPR void compile_format_string(basic_string_view format_str, ++UMPIRE_FMT_CONSTEXPR void compile_format_string(basic_string_view format_str, + PartHandler handler) { + parse_format_string( + format_str, +@@ -402,11 +402,11 @@ struct compiled_format_base : basic_compiled_format { + + template struct format_part_array { + format_part data[N] = {}; +- FMT_CONSTEXPR format_part_array() = default; ++ UMPIRE_FMT_CONSTEXPR format_part_array() = default; + }; + + template +-FMT_CONSTEXPR format_part_array compile_to_parts( ++UMPIRE_FMT_CONSTEXPR format_part_array compile_to_parts( + basic_string_view format_str) { + format_part_array parts; + unsigned counter = 0; +@@ -414,7 +414,7 @@ FMT_CONSTEXPR format_part_array compile_to_parts( + struct { + format_part* parts; + unsigned* counter; +- FMT_CONSTEXPR void operator()(const format_part& part) { ++ UMPIRE_FMT_CONSTEXPR void operator()(const format_part& part) { + parts[(*counter)++] = part; + } + } collector{parts.data, &counter}; +@@ -435,12 +435,12 @@ struct compiled_format_base::value>> + : basic_compiled_format { + using char_type = char_t; + +- FMT_CONSTEXPR explicit compiled_format_base(basic_string_view) {} ++ UMPIRE_FMT_CONSTEXPR explicit compiled_format_base(basic_string_view) {} + + // Workaround for old compilers. Format string compilation will not be + // performed there anyway. +-#if FMT_USE_CONSTEXPR +- static FMT_CONSTEXPR_DECL const unsigned num_format_parts = ++#if UMPIRE_FMT_USE_CONSTEXPR ++ static UMPIRE_FMT_CONSTEXPR_DECL const unsigned num_format_parts = + constexpr_max(count_parts(to_string_view(S())), 1u); + #else + static const unsigned num_format_parts = 1; +@@ -449,7 +449,7 @@ struct compiled_format_base::value>> + using parts_container = format_part[num_format_parts]; + + const parts_container& parts() const { +- static FMT_CONSTEXPR_DECL const auto compiled_parts = ++ static UMPIRE_FMT_CONSTEXPR_DECL const auto compiled_parts = + compile_to_parts( + detail::to_string_view(S())); + return compiled_parts.data; +@@ -676,7 +676,7 @@ template struct arg_id_handler { + constexpr void on_error(const char* message) { throw format_error(message); } + + constexpr int on_arg_id() { +- FMT_ASSERT(false, "handler cannot be used with automatic indexing"); ++ UMPIRE_FMT_ASSERT(false, "handler cannot be used with automatic indexing"); + return 0; + } + +@@ -781,7 +781,7 @@ constexpr auto compile_format_string(S format_str) { + } + + template ::value || ++ UMPIRE_FMT_ENABLE_IF(is_compile_string::value || + detail::is_compiled_string::value)> + constexpr auto compile(S format_str) { + constexpr basic_string_view str = format_str; +@@ -796,7 +796,7 @@ constexpr auto compile(S format_str) { + } + #else + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(is_compile_string::value)> + constexpr auto compile(S format_str) -> detail::compiled_format { + return detail::compiled_format(to_string_view(format_str)); + } +@@ -813,20 +813,20 @@ auto compile(const Char (&format_str)[N]) + } + } // namespace detail + +-// DEPRECATED! use FMT_COMPILE instead. ++// DEPRECATED! use UMPIRE_FMT_COMPILE instead. + template +-FMT_DEPRECATED auto compile(const Args&... args) ++UMPIRE_FMT_DEPRECATED auto compile(const Args&... args) + -> decltype(detail::compile(args...)) { + return detail::compile(args...); + } + +-#if FMT_USE_CONSTEXPR ++#if UMPIRE_FMT_USE_CONSTEXPR + # ifdef __cpp_if_constexpr + + template ::value)> +-FMT_INLINE std::basic_string format(const CompiledFormat& cf, ++ UMPIRE_FMT_ENABLE_IF(detail::is_compiled_format::value)> ++UMPIRE_FMT_INLINE std::basic_string format(const CompiledFormat& cf, + const Args&... args) { + basic_memory_buffer buffer; + cf.format(detail::buffer_appender(buffer), args...); +@@ -834,17 +834,17 @@ FMT_INLINE std::basic_string format(const CompiledFormat& cf, + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_compiled_format::value)> + constexpr OutputIt format_to(OutputIt out, const CompiledFormat& cf, + const Args&... args) { + return cf.format(out, args...); + } + # endif // __cpp_if_constexpr +-#endif // FMT_USE_CONSTEXPR ++#endif // UMPIRE_FMT_USE_CONSTEXPR + + template ::value)> + std::basic_string format(const CompiledFormat& cf, const Args&... args) { + basic_memory_buffer buffer; +@@ -855,8 +855,8 @@ std::basic_string format(const CompiledFormat& cf, const Args&... args) { + } + + template ::value)> +-FMT_INLINE std::basic_string format(const S&, ++ UMPIRE_FMT_ENABLE_IF(detail::is_compiled_string::value)> ++UMPIRE_FMT_INLINE std::basic_string format(const S&, + Args&&... args) { + #ifdef __cpp_if_constexpr + if constexpr (std::is_same::value) { +@@ -887,7 +887,7 @@ FMT_INLINE std::basic_string format(const S&, + } + + template ::value)> + constexpr OutputIt format_to(OutputIt out, const CompiledFormat& cf, + const Args&... args) { +@@ -898,8 +898,8 @@ constexpr OutputIt format_to(OutputIt out, const CompiledFormat& cf, + } + + template ::value)> +-FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { ++ UMPIRE_FMT_ENABLE_IF(detail::is_compiled_string::value)> ++UMPIRE_FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { + constexpr auto compiled = detail::compile(S()); + #ifdef __cpp_if_constexpr + if constexpr (std::is_same, +@@ -930,7 +930,7 @@ auto format_to_n(OutputIt out, size_t n, const CompiledFormat& cf, + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_compiled_string::value)> + format_to_n_result format_to_n(OutputIt out, size_t n, const S&, + Args&&... args) { + auto it = format_to(detail::truncating_iterator(out, n), S(), +@@ -939,14 +939,14 @@ format_to_n_result format_to_n(OutputIt out, size_t n, const S&, + } + + template ::value || + detail::is_compiled_string::value)> + size_t formatted_size(const CompiledFormat& cf, const Args&... args) { + return format_to(detail::counting_iterator(), cf, args...).count(); + } + +-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS ++#if UMPIRE_FMT_USE_NONTYPE_TEMPLATE_PARAMETERS + inline namespace literals { + template + constexpr detail::udl_compiled_string, +@@ -957,6 +957,6 @@ operator""_cf() { + } // namespace literals + #endif + +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_COMPILE_H_ ++#endif // UMPIRE_FMT_COMPILE_H_ +diff --git a/src/tpl/umpire/fmt/core.h b/src/tpl/umpire/fmt/core.h +index 14530ede0..cbf228bfc 100644 +--- a/src/tpl/umpire/fmt/core.h ++++ b/src/tpl/umpire/fmt/core.h +@@ -5,8 +5,8 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_CORE_H_ +-#define FMT_CORE_H_ ++#ifndef UMPIRE_FMT_CORE_H_ ++#define UMPIRE_FMT_CORE_H_ + + #include // std::FILE + #include +@@ -15,245 +15,245 @@ + #include + + // The fmt library version in the form major * 10000 + minor * 100 + patch. +-#define FMT_VERSION 70103 ++#define UMPIRE_FMT_VERSION 70103 + + #ifdef __clang__ +-# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) ++# define UMPIRE_FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) + #else +-# define FMT_CLANG_VERSION 0 ++# define UMPIRE_FMT_CLANG_VERSION 0 + #endif + + #if defined(__GNUC__) && !defined(__clang__) +-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) ++# define UMPIRE_FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) + #else +-# define FMT_GCC_VERSION 0 ++# define UMPIRE_FMT_GCC_VERSION 0 + #endif + + #if defined(__INTEL_COMPILER) +-# define FMT_ICC_VERSION __INTEL_COMPILER ++# define UMPIRE_FMT_ICC_VERSION __INTEL_COMPILER + #else +-# define FMT_ICC_VERSION 0 ++# define UMPIRE_FMT_ICC_VERSION 0 + #endif + + #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) +-# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION ++# define UMPIRE_FMT_HAS_GXX_CXX11 UMPIRE_FMT_GCC_VERSION + #else +-# define FMT_HAS_GXX_CXX11 0 ++# define UMPIRE_FMT_HAS_GXX_CXX11 0 + #endif + + #ifdef __NVCC__ +-# define FMT_NVCC __NVCC__ ++# define UMPIRE_FMT_NVCC __NVCC__ + #else +-# define FMT_NVCC 0 ++# define UMPIRE_FMT_NVCC 0 + #endif + + #ifdef _MSC_VER +-# define FMT_MSC_VER _MSC_VER +-# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) ++# define UMPIRE_FMT_MSC_VER _MSC_VER ++# define UMPIRE_FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) + #else +-# define FMT_MSC_VER 0 +-# define FMT_MSC_WARNING(...) ++# define UMPIRE_FMT_MSC_VER 0 ++# define UMPIRE_FMT_MSC_WARNING(...) + #endif + + #ifdef __has_feature +-# define FMT_HAS_FEATURE(x) __has_feature(x) ++# define UMPIRE_FMT_HAS_FEATURE(x) __has_feature(x) + #else +-# define FMT_HAS_FEATURE(x) 0 ++# define UMPIRE_FMT_HAS_FEATURE(x) 0 + #endif + + #if defined(__has_include) && !defined(__INTELLISENSE__) && \ +- (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1600) +-# define FMT_HAS_INCLUDE(x) __has_include(x) ++ (!UMPIRE_FMT_ICC_VERSION || UMPIRE_FMT_ICC_VERSION >= 1600) ++# define UMPIRE_FMT_HAS_INCLUDE(x) __has_include(x) + #else +-# define FMT_HAS_INCLUDE(x) 0 ++# define UMPIRE_FMT_HAS_INCLUDE(x) 0 + #endif + + #ifdef __has_cpp_attribute +-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) ++# define UMPIRE_FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) + #else +-# define FMT_HAS_CPP_ATTRIBUTE(x) 0 ++# define UMPIRE_FMT_HAS_CPP_ATTRIBUTE(x) 0 + #endif + +-#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ +- (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) ++#define UMPIRE_FMT_HAS_CPP14_ATTRIBUTE(attribute) \ ++ (__cplusplus >= 201402L && UMPIRE_FMT_HAS_CPP_ATTRIBUTE(attribute)) + +-#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ +- (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) ++#define UMPIRE_FMT_HAS_CPP17_ATTRIBUTE(attribute) \ ++ (__cplusplus >= 201703L && UMPIRE_FMT_HAS_CPP_ATTRIBUTE(attribute)) + + // 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)) && \ +- !FMT_NVCC && !FMT_ICC_VERSION ++#ifndef UMPIRE_FMT_USE_CONSTEXPR ++# define UMPIRE_FMT_USE_CONSTEXPR \ ++ (UMPIRE_FMT_HAS_FEATURE(cxx_relaxed_constexpr) || UMPIRE_FMT_MSC_VER >= 1910 || \ ++ (UMPIRE_FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) && \ ++ !UMPIRE_FMT_NVCC && !UMPIRE_FMT_ICC_VERSION + #endif +-#if FMT_USE_CONSTEXPR +-# define FMT_CONSTEXPR constexpr +-# define FMT_CONSTEXPR_DECL constexpr ++#if UMPIRE_FMT_USE_CONSTEXPR ++# define UMPIRE_FMT_CONSTEXPR constexpr ++# define UMPIRE_FMT_CONSTEXPR_DECL constexpr + #else +-# define FMT_CONSTEXPR +-# define FMT_CONSTEXPR_DECL ++# define UMPIRE_FMT_CONSTEXPR ++# define UMPIRE_FMT_CONSTEXPR_DECL + #endif + +-#ifndef FMT_OVERRIDE +-# if FMT_HAS_FEATURE(cxx_override_control) || \ +- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +-# define FMT_OVERRIDE override ++#ifndef UMPIRE_FMT_OVERRIDE ++# if UMPIRE_FMT_HAS_FEATURE(cxx_override_control) || \ ++ (UMPIRE_FMT_GCC_VERSION >= 408 && UMPIRE_FMT_HAS_GXX_CXX11) || UMPIRE_FMT_MSC_VER >= 1900 ++# define UMPIRE_FMT_OVERRIDE override + # else +-# define FMT_OVERRIDE ++# define UMPIRE_FMT_OVERRIDE + # endif + #endif + + // Check if exceptions are disabled. +-#ifndef FMT_EXCEPTIONS ++#ifndef UMPIRE_FMT_EXCEPTIONS + # if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ +- FMT_MSC_VER && !_HAS_EXCEPTIONS +-# define FMT_EXCEPTIONS 0 ++ UMPIRE_FMT_MSC_VER && !_HAS_EXCEPTIONS ++# define UMPIRE_FMT_EXCEPTIONS 0 + # else +-# define FMT_EXCEPTIONS 1 ++# define UMPIRE_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 ++// Define UMPIRE_FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). ++#ifndef UMPIRE_FMT_USE_NOEXCEPT ++# define UMPIRE_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 ++#if UMPIRE_FMT_USE_NOEXCEPT || UMPIRE_FMT_HAS_FEATURE(cxx_noexcept) || \ ++ (UMPIRE_FMT_GCC_VERSION >= 408 && UMPIRE_FMT_HAS_GXX_CXX11) || UMPIRE_FMT_MSC_VER >= 1900 ++# define UMPIRE_FMT_DETECTED_NOEXCEPT noexcept ++# define UMPIRE_FMT_HAS_CXX11_NOEXCEPT 1 + #else +-# define FMT_DETECTED_NOEXCEPT throw() +-# define FMT_HAS_CXX11_NOEXCEPT 0 ++# define UMPIRE_FMT_DETECTED_NOEXCEPT throw() ++# define UMPIRE_FMT_HAS_CXX11_NOEXCEPT 0 + #endif + +-#ifndef FMT_NOEXCEPT +-# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT +-# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT ++#ifndef UMPIRE_FMT_NOEXCEPT ++# if UMPIRE_FMT_EXCEPTIONS || UMPIRE_FMT_HAS_CXX11_NOEXCEPT ++# define UMPIRE_FMT_NOEXCEPT UMPIRE_FMT_DETECTED_NOEXCEPT + # else +-# define FMT_NOEXCEPT ++# define UMPIRE_FMT_NOEXCEPT + # endif + #endif + + // [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code + // warnings. +-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \ +- !FMT_NVCC +-# define FMT_NORETURN [[noreturn]] ++#if UMPIRE_FMT_EXCEPTIONS && UMPIRE_FMT_HAS_CPP_ATTRIBUTE(noreturn) && !UMPIRE_FMT_MSC_VER && \ ++ !UMPIRE_FMT_NVCC ++# define UMPIRE_FMT_NORETURN [[noreturn]] + #else +-# define FMT_NORETURN ++# define UMPIRE_FMT_NORETURN + #endif + +-#ifndef FMT_DEPRECATED +-# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900 +-# define FMT_DEPRECATED [[deprecated]] ++#ifndef UMPIRE_FMT_DEPRECATED ++# if UMPIRE_FMT_HAS_CPP14_ATTRIBUTE(deprecated) || UMPIRE_FMT_MSC_VER >= 1900 ++# define UMPIRE_FMT_DEPRECATED [[deprecated]] + # else + # if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) +-# define FMT_DEPRECATED __attribute__((deprecated)) +-# elif FMT_MSC_VER +-# define FMT_DEPRECATED __declspec(deprecated) ++# define UMPIRE_FMT_DEPRECATED __attribute__((deprecated)) ++# elif UMPIRE_FMT_MSC_VER ++# define UMPIRE_FMT_DEPRECATED __declspec(deprecated) + # else +-# define FMT_DEPRECATED /* deprecated */ ++# define UMPIRE_FMT_DEPRECATED /* deprecated */ + # endif + # endif + #endif + + // Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers. +-#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC +-# define FMT_DEPRECATED_ALIAS ++#if UMPIRE_FMT_ICC_VERSION || defined(__PGI) || UMPIRE_FMT_NVCC ++# define UMPIRE_FMT_DEPRECATED_ALIAS + #else +-# define FMT_DEPRECATED_ALIAS FMT_DEPRECATED ++# define UMPIRE_FMT_DEPRECATED_ALIAS UMPIRE_FMT_DEPRECATED + #endif + +-#ifndef FMT_INLINE +-# if FMT_GCC_VERSION || FMT_CLANG_VERSION +-# define FMT_INLINE inline __attribute__((always_inline)) ++#ifndef UMPIRE_FMT_INLINE ++# if UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_CLANG_VERSION ++# define UMPIRE_FMT_INLINE inline __attribute__((always_inline)) + # else +-# define FMT_INLINE inline ++# define UMPIRE_FMT_INLINE inline + # endif + #endif + +-#ifndef FMT_USE_INLINE_NAMESPACES +-# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \ +- (FMT_MSC_VER >= 1900 && (!defined(_MANAGED) || !_MANAGED)) +-# define FMT_USE_INLINE_NAMESPACES 1 ++#ifndef UMPIRE_FMT_USE_INLINE_NAMESPACES ++# if UMPIRE_FMT_HAS_FEATURE(cxx_inline_namespaces) || UMPIRE_FMT_GCC_VERSION >= 404 || \ ++ (UMPIRE_FMT_MSC_VER >= 1900 && (!defined(_MANAGED) || !_MANAGED)) ++# define UMPIRE_FMT_USE_INLINE_NAMESPACES 1 + # else +-# define FMT_USE_INLINE_NAMESPACES 0 ++# define UMPIRE_FMT_USE_INLINE_NAMESPACES 0 + # endif + #endif + +-#ifndef FMT_BEGIN_NAMESPACE +-# if FMT_USE_INLINE_NAMESPACES +-# define FMT_INLINE_NAMESPACE inline namespace +-# define FMT_END_NAMESPACE \ ++#ifndef UMPIRE_FMT_BEGIN_NAMESPACE ++# if UMPIRE_FMT_USE_INLINE_NAMESPACES ++# define UMPIRE_FMT_INLINE_NAMESPACE inline namespace ++# define UMPIRE_FMT_END_NAMESPACE \ + } \ + } \ + } + # else +-# define FMT_INLINE_NAMESPACE namespace +-# define FMT_END_NAMESPACE \ ++# define UMPIRE_FMT_INLINE_NAMESPACE namespace ++# define UMPIRE_FMT_END_NAMESPACE \ + } \ + using namespace v7; \ + } \ + } + # endif +-# define FMT_BEGIN_NAMESPACE \ ++# define UMPIRE_FMT_BEGIN_NAMESPACE \ + namespace umpire { \ + namespace fmt { \ +- FMT_INLINE_NAMESPACE v7 { ++ UMPIRE_FMT_INLINE_NAMESPACE v7 { + #endif + +-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +-# define FMT_CLASS_API FMT_MSC_WARNING(suppress : 4275) +-# ifdef FMT_EXPORT +-# define FMT_API __declspec(dllexport) +-# define FMT_EXTERN_TEMPLATE_API FMT_API +-# define FMT_EXPORTED +-# elif defined(FMT_SHARED) +-# define FMT_API __declspec(dllimport) +-# define FMT_EXTERN_TEMPLATE_API FMT_API ++#if !defined(UMPIRE_FMT_HEADER_ONLY) && defined(_WIN32) ++# define UMPIRE_FMT_CLASS_API UMPIRE_FMT_MSC_WARNING(suppress : 4275) ++# ifdef UMPIRE_FMT_EXPORT ++# define UMPIRE_FMT_API __declspec(dllexport) ++# define UMPIRE_FMT_EXTERN_TEMPLATE_API UMPIRE_FMT_API ++# define UMPIRE_FMT_EXPORTED ++# elif defined(UMPIRE_FMT_SHARED) ++# define UMPIRE_FMT_API __declspec(dllimport) ++# define UMPIRE_FMT_EXTERN_TEMPLATE_API UMPIRE_FMT_API + # endif + #else +-# define FMT_CLASS_API ++# define UMPIRE_FMT_CLASS_API + #endif +-#ifndef FMT_API +-# define FMT_API ++#ifndef UMPIRE_FMT_API ++# define UMPIRE_FMT_API + #endif +-#ifndef FMT_EXTERN_TEMPLATE_API +-# define FMT_EXTERN_TEMPLATE_API ++#ifndef UMPIRE_FMT_EXTERN_TEMPLATE_API ++# define UMPIRE_FMT_EXTERN_TEMPLATE_API + #endif +-#ifndef FMT_INSTANTIATION_DEF_API +-# define FMT_INSTANTIATION_DEF_API FMT_API ++#ifndef UMPIRE_FMT_INSTANTIATION_DEF_API ++# define UMPIRE_FMT_INSTANTIATION_DEF_API UMPIRE_FMT_API + #endif + +-#ifndef FMT_HEADER_ONLY +-# define FMT_EXTERN extern ++#ifndef UMPIRE_FMT_HEADER_ONLY ++# define UMPIRE_FMT_EXTERN extern + #else +-# define FMT_EXTERN ++# define UMPIRE_FMT_EXTERN + #endif + + // libc++ supports string_view in pre-c++17. +-#if (FMT_HAS_INCLUDE() && \ ++#if (UMPIRE_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 ++# define UMPIRE_FMT_USE_STRING_VIEW ++#elif UMPIRE_FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L + # include +-# define FMT_USE_EXPERIMENTAL_STRING_VIEW ++# define UMPIRE_FMT_USE_EXPERIMENTAL_STRING_VIEW + #endif + +-#ifndef FMT_UNICODE +-# define FMT_UNICODE !FMT_MSC_VER ++#ifndef UMPIRE_FMT_UNICODE ++# define UMPIRE_FMT_UNICODE !UMPIRE_FMT_MSC_VER + #endif + +-#ifndef FMT_COMPILE_TIME_CHECKS +-# define FMT_COMPILE_TIME_CHECKS 0 ++#ifndef UMPIRE_FMT_COMPILE_TIME_CHECKS ++# define UMPIRE_FMT_COMPILE_TIME_CHECKS 0 + #endif + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + + // Implementations of enable_if_t and other metafunctions for older systems. + template +@@ -275,15 +275,15 @@ 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). +-#ifdef FMT_DOC +-# define FMT_ENABLE_IF(...) ++#ifdef UMPIRE_FMT_DOC ++# define UMPIRE_FMT_ENABLE_IF(...) + #else +-# define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0 ++# define UMPIRE_FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0 + #endif + + namespace detail { + +-constexpr bool is_constant_evaluated() FMT_NOEXCEPT { ++constexpr bool is_constant_evaluated() UMPIRE_FMT_NOEXCEPT { + #ifdef __cpp_lib_is_constant_evaluated + return std::is_constant_evaluated(); + #else +@@ -294,56 +294,56 @@ constexpr bool is_constant_evaluated() FMT_NOEXCEPT { + // A helper function to suppress "conditional expression is constant" warnings. + template constexpr T const_check(T value) { return value; } + +-FMT_NORETURN FMT_API void assert_fail(const char* file, int line, ++UMPIRE_FMT_NORETURN UMPIRE_FMT_API void assert_fail(const char* file, int line, + const char* message); + +-#ifndef FMT_ASSERT ++#ifndef UMPIRE_FMT_ASSERT + # ifdef NDEBUG +-// FMT_ASSERT is not empty to avoid -Werror=empty-body. +-# define FMT_ASSERT(condition, message) ((void)0) ++// UMPIRE_FMT_ASSERT is not empty to avoid -Werror=empty-body. ++# define UMPIRE_FMT_ASSERT(condition, message) ((void)0) + # else +-# define FMT_ASSERT(condition, message) \ ++# define UMPIRE_FMT_ASSERT(condition, message) \ + ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ + ? (void)0 \ + : ::umpire::fmt::detail::assert_fail(__FILE__, __LINE__, (message))) + # endif + #endif + +-#if defined(FMT_USE_STRING_VIEW) ++#if defined(UMPIRE_FMT_USE_STRING_VIEW) + template using std_string_view = std::basic_string_view; +-#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) ++#elif defined(UMPIRE_FMT_USE_EXPERIMENTAL_STRING_VIEW) + template + using std_string_view = std::experimental::basic_string_view; + #else + template struct std_string_view {}; + #endif + +-#ifdef FMT_USE_INT128 ++#ifdef UMPIRE_FMT_USE_INT128 + // Do nothing. +-#elif defined(__SIZEOF_INT128__) && !FMT_NVCC && \ +- !(FMT_CLANG_VERSION && FMT_MSC_VER) +-# define FMT_USE_INT128 1 ++#elif defined(__SIZEOF_INT128__) && !UMPIRE_FMT_NVCC && \ ++ !(UMPIRE_FMT_CLANG_VERSION && UMPIRE_FMT_MSC_VER) ++# define UMPIRE_FMT_USE_INT128 1 + using int128_t = __int128_t; + using uint128_t = __uint128_t; + #else +-# define FMT_USE_INT128 0 ++# define UMPIRE_FMT_USE_INT128 0 + #endif +-#if !FMT_USE_INT128 ++#if !UMPIRE_FMT_USE_INT128 + struct int128_t {}; + struct uint128_t {}; + #endif + + // Casts a nonnegative integer to unsigned. + template +-FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) { +- FMT_ASSERT(value >= 0, "negative value"); ++UMPIRE_FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) { ++ UMPIRE_FMT_ASSERT(value >= 0, "negative value"); + return static_cast::type>(value); + } + +-FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5"; ++UMPIRE_FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5"; + + template constexpr bool is_unicode() { +- return FMT_UNICODE || sizeof(Char) != 1 || ++ return UMPIRE_FMT_UNICODE || sizeof(Char) != 1 || + (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5); + } + +@@ -354,7 +354,7 @@ enum char8_type : unsigned char {}; + #endif + } // namespace detail + +-#ifdef FMT_USE_INTERNAL ++#ifdef UMPIRE_FMT_USE_INTERNAL + namespace internal = detail; // DEPRECATED + #endif + +@@ -374,10 +374,10 @@ template class basic_string_view { + using value_type = Char; + using iterator = const Char*; + +- constexpr basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {} ++ constexpr basic_string_view() UMPIRE_FMT_NOEXCEPT : data_(nullptr), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ +- constexpr basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT ++ constexpr basic_string_view(const Char* s, size_t count) UMPIRE_FMT_NOEXCEPT + : data_(s), + size_(count) {} + +@@ -388,21 +388,21 @@ template class basic_string_view { + \endrst + */ + #if __cplusplus >= 201703L // C++17's char_traits::length() is constexpr. +- FMT_CONSTEXPR ++ UMPIRE_FMT_CONSTEXPR + #endif + 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 ++ UMPIRE_FMT_CONSTEXPR basic_string_view( ++ const std::basic_string& s) UMPIRE_FMT_NOEXCEPT + : data_(s.data()), + size_(s.size()) {} + +- template >::value)> +- FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()), ++ UMPIRE_FMT_CONSTEXPR basic_string_view(S s) UMPIRE_FMT_NOEXCEPT : data_(s.data()), + size_(s.size()) {} + + /** Returns a pointer to the string data. */ +@@ -416,7 +416,7 @@ template class basic_string_view { + + constexpr const Char& operator[](size_t pos) const { return data_[pos]; } + +- FMT_CONSTEXPR void remove_prefix(size_t n) { ++ UMPIRE_FMT_CONSTEXPR void remove_prefix(size_t n) { + data_ += n; + size_ -= n; + } +@@ -477,7 +477,7 @@ template <> struct is_char : std::true_type {}; + std::string message = umpire::fmt::format(my_string("The answer is {}"), 42); + \endrst + */ +-template ::value)> ++template ::value)> + inline basic_string_view to_string_view(const Char* s) { + return s; + } +@@ -494,19 +494,19 @@ constexpr basic_string_view to_string_view(basic_string_view s) { + } + + template >::value)> ++ UMPIRE_FMT_ENABLE_IF(!std::is_empty>::value)> + inline basic_string_view to_string_view(detail::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_STRING("{}"), 42). ++// make formatting functions visible via ADL, e.g. format(UMPIRE_FMT_STRING("{}"), 42). + struct compile_string {}; + + template + struct is_compile_string : std::is_base_of {}; + +-template ::value)> ++template ::value)> + constexpr basic_string_view to_string_view(const S& s) { + return s; + } +@@ -529,15 +529,15 @@ template struct char_t_impl::value>> { + }; + + // Reports a compile-time error if S is not a valid format string. +-template ::value)> +-FMT_INLINE void check_format_string(const S&) { +-#ifdef FMT_ENFORCE_COMPILE_STRING ++template ::value)> ++UMPIRE_FMT_INLINE void check_format_string(const S&) { ++#ifdef UMPIRE_FMT_ENFORCE_COMPILE_STRING + static_assert(is_compile_string::value, +- "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " +- "FMT_STRING."); ++ "UMPIRE_FMT_ENFORCE_COMPILE_STRING requires all format strings to use " ++ "UMPIRE_FMT_STRING."); + #endif + } +-template ::value)> ++template ::value)> + void check_format_string(S); + + struct error_handler { +@@ -545,7 +545,7 @@ struct error_handler { + constexpr error_handler(const error_handler&) = default; + + // This function is intentionally not constexpr to give a compile-time error. +- FMT_NORETURN FMT_API void on_error(const char* message); ++ UMPIRE_FMT_NORETURN UMPIRE_FMT_API void on_error(const char* message); + }; + } // namespace detail + +@@ -587,15 +587,15 @@ class basic_format_parse_context : private ErrorHandler { + Returns an iterator to the beginning of the format string range being + parsed. + */ +- constexpr iterator begin() const FMT_NOEXCEPT { return format_str_.begin(); } ++ constexpr iterator begin() const UMPIRE_FMT_NOEXCEPT { return format_str_.begin(); } + + /** + Returns an iterator past the end of the format string range being parsed. + */ +- constexpr iterator end() const FMT_NOEXCEPT { return format_str_.end(); } ++ constexpr iterator end() const UMPIRE_FMT_NOEXCEPT { return format_str_.end(); } + + /** Advances the begin iterator to ``it``. */ +- FMT_CONSTEXPR void advance_to(iterator it) { ++ UMPIRE_FMT_CONSTEXPR void advance_to(iterator it) { + format_str_.remove_prefix(detail::to_unsigned(it - begin())); + } + +@@ -603,7 +603,7 @@ class basic_format_parse_context : private ErrorHandler { + Reports an error if using the manual argument indexing; otherwise returns + the next argument index and switches to the automatic indexing. + */ +- FMT_CONSTEXPR int next_arg_id() { ++ UMPIRE_FMT_CONSTEXPR int next_arg_id() { + // Don't check if the argument id is valid to avoid overhead and because it + // will be checked during formatting anyway. + if (next_arg_id_ >= 0) return next_arg_id_++; +@@ -615,16 +615,16 @@ class basic_format_parse_context : private ErrorHandler { + Reports an error if using the automatic argument indexing; otherwise + switches to the manual indexing. + */ +- FMT_CONSTEXPR void check_arg_id(int) { ++ UMPIRE_FMT_CONSTEXPR void check_arg_id(int) { + if (next_arg_id_ > 0) + on_error("cannot switch from automatic to manual argument indexing"); + else + next_arg_id_ = -1; + } + +- FMT_CONSTEXPR void check_arg_id(basic_string_view) {} ++ UMPIRE_FMT_CONSTEXPR void check_arg_id(basic_string_view) {} + +- FMT_CONSTEXPR void on_error(const char* message) { ++ UMPIRE_FMT_CONSTEXPR void on_error(const char* message) { + ErrorHandler::on_error(message); + } + +@@ -683,10 +683,10 @@ template class buffer { + + protected: + // Don't initialize ptr_ since it is not accessed to save a few cycles. +- FMT_MSC_WARNING(suppress : 26495) +- buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {} ++ UMPIRE_FMT_MSC_WARNING(suppress : 26495) ++ buffer(size_t sz) UMPIRE_FMT_NOEXCEPT : size_(sz), capacity_(sz) {} + +- buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) FMT_NOEXCEPT ++ buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) UMPIRE_FMT_NOEXCEPT + : ptr_(p), + size_(sz), + capacity_(cap) {} +@@ -694,7 +694,7 @@ template class buffer { + ~buffer() = default; + + /** Sets the buffer data and capacity. */ +- void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT { ++ void set(T* buf_data, size_t buf_capacity) UMPIRE_FMT_NOEXCEPT { + ptr_ = buf_data; + capacity_ = buf_capacity; + } +@@ -709,23 +709,23 @@ template class buffer { + buffer(const buffer&) = delete; + void operator=(const buffer&) = delete; + +- T* begin() FMT_NOEXCEPT { return ptr_; } +- T* end() FMT_NOEXCEPT { return ptr_ + size_; } ++ T* begin() UMPIRE_FMT_NOEXCEPT { return ptr_; } ++ T* end() UMPIRE_FMT_NOEXCEPT { return ptr_ + size_; } + +- const T* begin() const FMT_NOEXCEPT { return ptr_; } +- const T* end() const FMT_NOEXCEPT { return ptr_ + size_; } ++ const T* begin() const UMPIRE_FMT_NOEXCEPT { return ptr_; } ++ const T* end() const UMPIRE_FMT_NOEXCEPT { return ptr_ + size_; } + + /** Returns the size of this buffer. */ +- size_t size() const FMT_NOEXCEPT { return size_; } ++ size_t size() const UMPIRE_FMT_NOEXCEPT { return size_; } + + /** Returns the capacity of this buffer. */ +- size_t capacity() const FMT_NOEXCEPT { return capacity_; } ++ size_t capacity() const UMPIRE_FMT_NOEXCEPT { return capacity_; } + + /** Returns a pointer to the buffer data. */ +- T* data() FMT_NOEXCEPT { return ptr_; } ++ T* data() UMPIRE_FMT_NOEXCEPT { return ptr_; } + + /** Returns a pointer to the buffer data. */ +- const T* data() const FMT_NOEXCEPT { return ptr_; } ++ const T* data() const UMPIRE_FMT_NOEXCEPT { return ptr_; } + + /** Clears this buffer. */ + void clear() { size_ = 0; } +@@ -789,7 +789,7 @@ class iterator_buffer final : public Traits, public buffer { + T data_[buffer_size]; + + protected: +- void grow(size_t) final FMT_OVERRIDE { ++ void grow(size_t) final UMPIRE_FMT_OVERRIDE { + if (this->size() == buffer_size) flush(); + } + void flush(); +@@ -808,7 +808,7 @@ class iterator_buffer final : public Traits, public buffer { + + template class iterator_buffer final : public buffer { + protected: +- void grow(size_t) final FMT_OVERRIDE {} ++ void grow(size_t) final UMPIRE_FMT_OVERRIDE {} + + public: + explicit iterator_buffer(T* out, size_t = 0) : buffer(out, 0, ~size_t()) {} +@@ -826,7 +826,7 @@ class iterator_buffer, + Container& container_; + + protected: +- void grow(size_t capacity) final FMT_OVERRIDE { ++ void grow(size_t capacity) final UMPIRE_FMT_OVERRIDE { + container_.resize(capacity); + this->set(&container_[0], capacity); + } +@@ -849,7 +849,7 @@ template class counting_buffer final : public buffer { + size_t count_ = 0; + + protected: +- void grow(size_t) final FMT_OVERRIDE { ++ void grow(size_t) final UMPIRE_FMT_OVERRIDE { + if (this->size() != buffer_size) return; + count_ += this->size(); + this->clear(); +@@ -946,9 +946,9 @@ struct arg_data { + T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; + + template +- FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} +- FMT_CONSTEXPR FMT_INLINE const T* args() const { return args_; } +- FMT_CONSTEXPR FMT_INLINE std::nullptr_t named_args() { return nullptr; } ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE arg_data(const U&... init) : args_{init...} {} ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE const T* args() const { return args_; } ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE std::nullptr_t named_args() { return nullptr; } + }; + + template +@@ -969,7 +969,7 @@ void init_named_args(named_arg_info* named_args, int arg_count, + } + + template +-FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, ++UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE void init_named_args(std::nullptr_t, int, int, + const Args&...) {} + + template struct is_named_arg : std::false_type {}; +@@ -1013,25 +1013,25 @@ enum class type { + template + struct type_constant : std::integral_constant {}; + +-#define FMT_TYPE_CONSTANT(Type, constant) \ ++#define UMPIRE_FMT_TYPE_CONSTANT(Type, constant) \ + template \ + struct type_constant \ + : std::integral_constant {} + +-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(int128_t, int128_type); +-FMT_TYPE_CONSTANT(uint128_t, uint128_type); +-FMT_TYPE_CONSTANT(bool, bool_type); +-FMT_TYPE_CONSTANT(Char, char_type); +-FMT_TYPE_CONSTANT(float, float_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); ++UMPIRE_FMT_TYPE_CONSTANT(int, int_type); ++UMPIRE_FMT_TYPE_CONSTANT(unsigned, uint_type); ++UMPIRE_FMT_TYPE_CONSTANT(long long, long_long_type); ++UMPIRE_FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); ++UMPIRE_FMT_TYPE_CONSTANT(int128_t, int128_type); ++UMPIRE_FMT_TYPE_CONSTANT(uint128_t, uint128_type); ++UMPIRE_FMT_TYPE_CONSTANT(bool, bool_type); ++UMPIRE_FMT_TYPE_CONSTANT(Char, char_type); ++UMPIRE_FMT_TYPE_CONSTANT(float, float_type); ++UMPIRE_FMT_TYPE_CONSTANT(double, double_type); ++UMPIRE_FMT_TYPE_CONSTANT(long double, long_double_type); ++UMPIRE_FMT_TYPE_CONSTANT(const Char*, cstring_type); ++UMPIRE_FMT_TYPE_CONSTANT(basic_string_view, string_type); ++UMPIRE_FMT_TYPE_CONSTANT(const void*, pointer_type); + + constexpr bool is_integral_type(type t) { + return t > type::none_type && t <= type::last_integer_type; +@@ -1080,30 +1080,30 @@ template class value { + named_arg_value named_args; + }; + +- constexpr FMT_INLINE value(int val = 0) : int_value(val) {} +- constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} +- constexpr FMT_INLINE value(long long val) : long_long_value(val) {} +- constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} +- FMT_INLINE value(int128_t val) : int128_value(val) {} +- FMT_INLINE value(uint128_t val) : uint128_value(val) {} +- FMT_INLINE value(float val) : float_value(val) {} +- FMT_INLINE value(double val) : double_value(val) {} +- FMT_INLINE value(long double val) : long_double_value(val) {} +- constexpr FMT_INLINE value(bool val) : bool_value(val) {} +- constexpr FMT_INLINE value(char_type val) : char_value(val) {} +- FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { ++ constexpr UMPIRE_FMT_INLINE value(int val = 0) : int_value(val) {} ++ constexpr UMPIRE_FMT_INLINE value(unsigned val) : uint_value(val) {} ++ constexpr UMPIRE_FMT_INLINE value(long long val) : long_long_value(val) {} ++ constexpr UMPIRE_FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} ++ UMPIRE_FMT_INLINE value(int128_t val) : int128_value(val) {} ++ UMPIRE_FMT_INLINE value(uint128_t val) : uint128_value(val) {} ++ UMPIRE_FMT_INLINE value(float val) : float_value(val) {} ++ UMPIRE_FMT_INLINE value(double val) : double_value(val) {} ++ UMPIRE_FMT_INLINE value(long double val) : long_double_value(val) {} ++ constexpr UMPIRE_FMT_INLINE value(bool val) : bool_value(val) {} ++ constexpr UMPIRE_FMT_INLINE value(char_type val) : char_value(val) {} ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE value(const char_type* val) { + string.data = val; + if (is_constant_evaluated()) string.size = {}; + } +- FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) { ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE value(basic_string_view val) { + string.data = val.data(); + string.size = val.size(); + } +- FMT_INLINE value(const void* val) : pointer(val) {} +- FMT_INLINE value(const named_arg_info* args, size_t size) ++ UMPIRE_FMT_INLINE value(const void* val) : pointer(val) {} ++ UMPIRE_FMT_INLINE value(const named_arg_info* args, size_t size) + : named_args{args, size} {} + +- template FMT_INLINE value(const T& val) { ++ template UMPIRE_FMT_INLINE 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 +@@ -1127,7 +1127,7 @@ template class value { + }; + + template +-FMT_CONSTEXPR basic_format_arg make_arg(const T& value); ++UMPIRE_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. +@@ -1141,83 +1141,83 @@ struct unformattable {}; + 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 int128_t map(int128_t val) { return val; } +- FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; } +- FMT_CONSTEXPR bool map(bool val) { return val; } +- +- template ::value)> +- FMT_CONSTEXPR char_type map(T val) { ++ UMPIRE_FMT_CONSTEXPR int map(signed char val) { return val; } ++ UMPIRE_FMT_CONSTEXPR unsigned map(unsigned char val) { return val; } ++ UMPIRE_FMT_CONSTEXPR int map(short val) { return val; } ++ UMPIRE_FMT_CONSTEXPR unsigned map(unsigned short val) { return val; } ++ UMPIRE_FMT_CONSTEXPR int map(int val) { return val; } ++ UMPIRE_FMT_CONSTEXPR unsigned map(unsigned val) { return val; } ++ UMPIRE_FMT_CONSTEXPR long_type map(long val) { return val; } ++ UMPIRE_FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; } ++ UMPIRE_FMT_CONSTEXPR long long map(long long val) { return val; } ++ UMPIRE_FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; } ++ UMPIRE_FMT_CONSTEXPR int128_t map(int128_t val) { return val; } ++ UMPIRE_FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; } ++ UMPIRE_FMT_CONSTEXPR bool map(bool val) { return val; } ++ ++ template ::value)> ++ UMPIRE_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 float map(float val) { return val; } +- FMT_CONSTEXPR double map(double val) { return val; } +- FMT_CONSTEXPR long double map(long double val) { return val; } ++ UMPIRE_FMT_CONSTEXPR float map(float val) { return val; } ++ UMPIRE_FMT_CONSTEXPR double map(double val) { return val; } ++ UMPIRE_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) { ++ UMPIRE_FMT_CONSTEXPR const char_type* map(char_type* val) { return val; } ++ UMPIRE_FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; } ++ template ::value)> ++ UMPIRE_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 && !has_formatter::value && + !has_fallback_formatter::value)> +- FMT_CONSTEXPR basic_string_view map(const T& val) { ++ UMPIRE_FMT_CONSTEXPR basic_string_view map(const T& val) { + return basic_string_view(val); + } + template < + typename T, +- FMT_ENABLE_IF( ++ UMPIRE_FMT_ENABLE_IF( + std::is_constructible, T>::value && + !std::is_constructible, T>::value && + !is_string::value && !has_formatter::value && + !has_fallback_formatter::value)> +- FMT_CONSTEXPR basic_string_view map(const T& val) { ++ UMPIRE_FMT_CONSTEXPR basic_string_view map(const T& val) { + return std_string_view(val); + } +- FMT_CONSTEXPR const char* map(const signed char* val) { ++ UMPIRE_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) { ++ UMPIRE_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 char* map(signed char* val) { ++ UMPIRE_FMT_CONSTEXPR const char* map(signed char* val) { + const auto* const_val = val; + return map(const_val); + } +- FMT_CONSTEXPR const char* map(unsigned char* val) { ++ UMPIRE_FMT_CONSTEXPR const char* map(unsigned char* val) { + const auto* const_val = val; + return map(const_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; } ++ UMPIRE_FMT_CONSTEXPR const void* map(void* val) { return val; } ++ UMPIRE_FMT_CONSTEXPR const void* map(const void* val) { return val; } ++ UMPIRE_FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; } + + // We use SFINAE instead of a const T* parameter to avoid conflicting with + // the C array overload. + template +- FMT_CONSTEXPR auto map(T) -> enable_if_t::value, int> { ++ UMPIRE_FMT_CONSTEXPR auto map(T) -> enable_if_t::value, int> { + // 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 +@@ -1227,29 +1227,29 @@ template struct arg_mapper { + } + + template +- FMT_CONSTEXPR auto map(const T (&values)[N]) -> const T (&)[N] { ++ UMPIRE_FMT_CONSTEXPR auto map(const T (&values)[N]) -> const T (&)[N] { + return values; + } + + template ::value && ++ UMPIRE_FMT_ENABLE_IF(std::is_enum::value && + !has_formatter::value && + !has_fallback_formatter::value)> +- FMT_CONSTEXPR auto map(const T& val) ++ UMPIRE_FMT_CONSTEXPR auto map(const T& val) + -> decltype(std::declval().map( + static_cast::type>(val))) { + return map(static_cast::type>(val)); + } + template ::value && !is_char::value && ++ UMPIRE_FMT_ENABLE_IF(!is_string::value && !is_char::value && + (has_formatter::value || + has_fallback_formatter::value))> +- FMT_CONSTEXPR const T& map(const T& val) { ++ UMPIRE_FMT_CONSTEXPR const T& map(const T& val) { + return val; + } + + template +- FMT_CONSTEXPR auto map(const named_arg& val) ++ UMPIRE_FMT_CONSTEXPR auto map(const named_arg& val) + -> decltype(std::declval().map(val.value)) { + return map(val.value); + } +@@ -1278,11 +1278,11 @@ template class basic_format_arg { + detail::type type_; + + template +- friend FMT_CONSTEXPR basic_format_arg detail::make_arg( ++ friend UMPIRE_FMT_CONSTEXPR basic_format_arg detail::make_arg( + const T& value); + + template +- friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, ++ friend UMPIRE_FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, + const basic_format_arg& arg) + -> decltype(vis(0)); + +@@ -1313,7 +1313,7 @@ template class basic_format_arg { + + constexpr basic_format_arg() : type_(detail::type::none_type) {} + +- constexpr explicit operator bool() const FMT_NOEXCEPT { ++ constexpr explicit operator bool() const UMPIRE_FMT_NOEXCEPT { + return type_ != detail::type::none_type; + } + +@@ -1331,7 +1331,7 @@ template class basic_format_arg { + \endrst + */ + template +-FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg( ++UMPIRE_FMT_CONSTEXPR_DECL UMPIRE_FMT_INLINE auto visit_format_arg( + Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { + using char_type = typename Context::char_type; + switch (arg.type_) { +@@ -1345,7 +1345,7 @@ FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg( + return vis(arg.value_.long_long_value); + case detail::type::ulong_long_type: + return vis(arg.value_.ulong_long_value); +-#if FMT_USE_INT128 ++#if UMPIRE_FMT_USE_INT128 + case detail::type::int128_type: + return vis(arg.value_.int128_value); + case detail::type::uint128_type: +@@ -1382,7 +1382,7 @@ template struct formattable : std::false_type {}; + + namespace detail { + +-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 ++#if UMPIRE_FMT_GCC_VERSION && UMPIRE_FMT_GCC_VERSION < 500 + // A workaround for gcc 4.8 to make void_t work in a SFINAE context. + template struct void_t_impl { using type = void; }; + template +@@ -1425,7 +1425,7 @@ class locale_ref { + constexpr locale_ref() : locale_(nullptr) {} + template explicit locale_ref(const Locale& loc); + +- explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; } ++ explicit operator bool() const UMPIRE_FMT_NOEXCEPT { return locale_ != nullptr; } + + template Locale get() const; + }; +@@ -1439,7 +1439,7 @@ constexpr unsigned long long encode_types() { + } + + template +-FMT_CONSTEXPR basic_format_arg make_arg(const T& value) { ++UMPIRE_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); +@@ -1461,13 +1461,13 @@ template constexpr const U& check(const U& val) { + // a fallback formatter in one translation unit and an implicit conversion in + // another (not recommended). + template ++ UMPIRE_FMT_ENABLE_IF(IS_PACKED)> + constexpr value make_arg(const T& val) { + return detail::check(arg_mapper().map(val)); + } + + template ++ UMPIRE_FMT_ENABLE_IF(!IS_PACKED)> + inline basic_format_arg make_arg(const T& value) { + return make_arg(value); + } +@@ -1502,24 +1502,24 @@ template class basic_format_context { + : out_(out), args_(ctx_args), loc_(loc) {} + + constexpr format_arg arg(int id) const { return args_.get(id); } +- FMT_CONSTEXPR format_arg arg(basic_string_view name) { ++ UMPIRE_FMT_CONSTEXPR format_arg arg(basic_string_view name) { + return args_.get(name); + } + int arg_id(basic_string_view name) { return args_.get_id(name); } + const basic_format_args& args() const { return args_; } + +- FMT_CONSTEXPR detail::error_handler error_handler() { return {}; } ++ UMPIRE_FMT_CONSTEXPR detail::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. +- FMT_CONSTEXPR iterator out() { return out_; } ++ UMPIRE_FMT_CONSTEXPR iterator out() { return out_; } + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) { + if (!detail::is_back_insert_iterator()) out_ = it; + } + +- FMT_CONSTEXPR detail::locale_ref locale() { return loc_; } ++ UMPIRE_FMT_CONSTEXPR detail::locale_ref locale() { return loc_; } + }; + + template +@@ -1529,7 +1529,7 @@ using format_context = buffer_context; + using wformat_context = buffer_context; + + // Workaround an alias issue: https://stackoverflow.com/q/62767544/471164. +-#define FMT_BUFFER_CONTEXT(Char) \ ++#define UMPIRE_FMT_BUFFER_CONTEXT(Char) \ + basic_format_context, Char> + + template +@@ -1546,7 +1546,7 @@ using is_formattable = bool_constant + class format_arg_store +-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 ++#if UMPIRE_FMT_GCC_VERSION && UMPIRE_FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args + #endif +@@ -1573,9 +1573,9 @@ class format_arg_store + : 0); + + public: +- FMT_CONSTEXPR format_arg_store(const Args&... args) ++ UMPIRE_FMT_CONSTEXPR format_arg_store(const Args&... args) + : +-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 ++#if UMPIRE_FMT_GCC_VERSION && UMPIRE_FMT_GCC_VERSION < 409 + basic_format_args(*this), + #endif + data_{detail::make_arg< +@@ -1675,7 +1675,7 @@ template class basic_format_args { + return (desc_ & detail::has_named_args_bit) != 0; + } + +- FMT_CONSTEXPR detail::type type(int index) const { ++ UMPIRE_FMT_CONSTEXPR detail::type type(int index) const { + int shift = index * detail::packed_arg_bits; + unsigned int mask = (1 << detail::packed_arg_bits) - 1; + return static_cast((desc_ >> shift) & mask); +@@ -1696,7 +1696,7 @@ template class basic_format_args { + \endrst + */ + template +- constexpr FMT_INLINE basic_format_args( ++ constexpr UMPIRE_FMT_INLINE basic_format_args( + const format_arg_store& store) + : basic_format_args(format_arg_store::desc, + store.data_.args()) {} +@@ -1707,7 +1707,7 @@ template class basic_format_args { + `~umpire::fmt::dynamic_format_arg_store`. + \endrst + */ +- constexpr FMT_INLINE basic_format_args( ++ constexpr UMPIRE_FMT_INLINE basic_format_args( + const dynamic_format_arg_store& store) + : basic_format_args(store.get_types(), store.data()) {} + +@@ -1721,7 +1721,7 @@ template class basic_format_args { + args) {} + + /** Returns the argument with the specified id. */ +- FMT_CONSTEXPR format_arg get(int id) const { ++ UMPIRE_FMT_CONSTEXPR format_arg get(int id) const { + format_arg arg; + if (!is_packed()) { + if (id < max_size()) arg = args_[id]; +@@ -1756,7 +1756,7 @@ template class basic_format_args { + } + }; + +-#ifdef FMT_ARM_ABI_COMPATIBILITY ++#ifdef UMPIRE_FMT_ARM_ABI_COMPATIBILITY + /** An alias to ``basic_format_args``. */ + // Separate types would result in shorter symbols but break ABI compatibility + // between clang and gcc on ARM (#1919). +@@ -1767,7 +1767,7 @@ using wformat_args = basic_format_args; + // It is a separate type rather than an alias to make symbols readable. + struct format_args : basic_format_args { + template +- FMT_INLINE format_args(const Args&... args) : basic_format_args(args...) {} ++ UMPIRE_FMT_INLINE format_args(const Args&... args) : basic_format_args(args...) {} + }; + struct wformat_args : basic_format_args { + using basic_format_args::basic_format_args; +@@ -1776,24 +1776,24 @@ struct wformat_args : basic_format_args { + + namespace detail { + +-template ::value)> ++template ::value)> + std::basic_string vformat( + basic_string_view format_str, + basic_format_args>> args); + +-FMT_API std::string vformat(string_view format_str, format_args args); ++UMPIRE_FMT_API std::string vformat(string_view format_str, format_args args); + + template + void vformat_to( + buffer& buf, basic_string_view format_str, +- basic_format_args)> args, ++ basic_format_args)> args, + detail::locale_ref loc = {}); + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(!std::is_same::value)> + inline void vprint_mojibake(std::FILE*, basic_string_view, const Args&) {} + +-FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); ++UMPIRE_FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); + #ifndef _WIN32 + inline void vprint_mojibake(std::FILE*, string_view, format_args) {} + #endif +@@ -1823,7 +1823,7 @@ auto vformat_to(OutputIt out, const S& format_str, + umpire::fmt::format_to(std::back_inserter(out), "{}", 42); + \endrst + */ +-// We cannot use FMT_ENABLE_IF because of a bug in gcc 8.3. ++// We cannot use UMPIRE_FMT_ENABLE_IF because of a bug in gcc 8.3. + template >::value> + inline auto format_to(OutputIt out, const S& format_str, Args&&... args) -> +@@ -1840,7 +1840,7 @@ template struct format_to_n_result { + }; + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(detail::is_output_iterator::value)> + inline format_to_n_result vformat_to_n( + OutputIt out, size_t n, basic_string_view format_str, + basic_format_args>> args) { +@@ -1879,7 +1879,7 @@ inline size_t formatted_size(const S& format_str, Args&&... args) { + } + + template > +-FMT_INLINE std::basic_string vformat( ++UMPIRE_FMT_INLINE std::basic_string vformat( + const S& format_str, + basic_format_args>> args) { + return detail::vformat(to_string_view(format_str), args); +@@ -1898,21 +1898,21 @@ FMT_INLINE std::basic_string vformat( + // Pass char_t as a default template parameter instead of using + // std::basic_string> to reduce the symbol size. + template , +- FMT_ENABLE_IF(!FMT_COMPILE_TIME_CHECKS || ++ UMPIRE_FMT_ENABLE_IF(!UMPIRE_FMT_COMPILE_TIME_CHECKS || + !std::is_same::value)> +-FMT_INLINE std::basic_string format(const S& format_str, Args&&... args) { ++UMPIRE_FMT_INLINE std::basic_string format(const S& format_str, Args&&... args) { + const auto& vargs = umpire::fmt::make_args_checked(format_str, args...); + return detail::vformat(to_string_view(format_str), vargs); + } + +-FMT_API void vprint(string_view, format_args); +-FMT_API void vprint(std::FILE*, string_view, format_args); ++UMPIRE_FMT_API void vprint(string_view, format_args); ++UMPIRE_FMT_API void vprint(std::FILE*, string_view, format_args); + + /** + \rst + Formats ``args`` according to specifications in ``format_str`` and writes the + output to the file ``f``. Strings are assumed to be Unicode-encoded unless the +- ``FMT_UNICODE`` macro is set to 0. ++ ``UMPIRE_FMT_UNICODE`` macro is set to 0. + + **Example**:: + +@@ -1931,7 +1931,7 @@ inline void print(std::FILE* f, const S& format_str, Args&&... args) { + \rst + Formats ``args`` according to specifications in ``format_str`` and writes + the output to ``stdout``. Strings are assumed to be Unicode-encoded unless +- the ``FMT_UNICODE`` macro is set to 0. ++ the ``UMPIRE_FMT_UNICODE`` macro is set to 0. + + **Example**:: + +@@ -1946,12 +1946,12 @@ inline void print(const S& format_str, Args&&... args) { + : detail::vprint_mojibake(stdout, to_string_view(format_str), + vargs); + } +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_CORE_H_ ++#endif // UMPIRE_FMT_CORE_H_ + +-// Define FMT_DYNAMIC_ARGS to make core.h provide dynamic_format_arg_store ++// Define UMPIRE_FMT_DYNAMIC_ARGS to make core.h provide dynamic_format_arg_store + // DEPRECATED! Include fmt/args.h directly instead. +-#ifdef FMT_DYNAMIC_ARGS ++#ifdef UMPIRE_FMT_DYNAMIC_ARGS + #include "args.h" + #endif +diff --git a/src/tpl/umpire/fmt/fmt.hpp b/src/tpl/umpire/fmt/fmt.hpp +index 6a9e70f42..a1d92bb63 100644 +--- a/src/tpl/umpire/fmt/fmt.hpp ++++ b/src/tpl/umpire/fmt/fmt.hpp +@@ -6,9 +6,9 @@ + #ifndef UMPIRE_fmt_HPP + #define UMPIRE_fmt_HPP + +-#define FMT_EXCEPTIONS 0 +-#define FMT_HEADER_ONLY 1 +-#define FMT_DEPRECATED ++#define UMPIRE_FMT_EXCEPTIONS 0 ++#define UMPIRE_FMT_HEADER_ONLY 1 ++#define UMPIRE_FMT_DEPRECATED + + #include "args.h" + #include "chrono.h" +diff --git a/src/tpl/umpire/fmt/format-inl.h b/src/tpl/umpire/fmt/format-inl.h +index 568f17db5..0a76aa784 100644 +--- a/src/tpl/umpire/fmt/format-inl.h ++++ b/src/tpl/umpire/fmt/format-inl.h +@@ -5,8 +5,8 @@ + // + // For the license information refer to format.h. + +-#ifndef FMT_FORMAT_INL_H_ +-#define FMT_FORMAT_INL_H_ ++#ifndef UMPIRE_FMT_FORMAT_INL_H_ ++#define UMPIRE_FMT_FORMAT_INL_H_ + + #include + #include +@@ -17,7 +17,7 @@ + #include + #include + +-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR ++#ifndef UMPIRE_FMT_STATIC_THOUSANDS_SEPARATOR + # include + #endif + +@@ -32,10 +32,10 @@ + inline umpire::fmt::detail::null<> strerror_r(int, char*, ...) { return {}; } + inline umpire::fmt::detail::null<> strerror_s(char*, size_t, ...) { return {}; } + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + namespace detail { + +-FMT_FUNC void assert_fail(const char* file, int line, const char* message) { ++UMPIRE_FMT_FUNC void assert_fail(const char* file, int line, const char* message) { + // Use unchecked std::fprintf to avoid triggering another assertion when + // writing to stderr fails + std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); +@@ -45,7 +45,7 @@ FMT_FUNC void assert_fail(const char* file, int line, const char* message) { + } + + #ifndef _MSC_VER +-# define FMT_SNPRINTF snprintf ++# define UMPIRE_FMT_SNPRINTF snprintf + #else // _MSC_VER + inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) { + va_list args; +@@ -54,7 +54,7 @@ inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) { + va_end(args); + return result; + } +-# define FMT_SNPRINTF fmt_snprintf ++# define UMPIRE_FMT_SNPRINTF fmt_snprintf + #endif // _MSC_VER + + // A portable thread-safe version of strerror. +@@ -67,8 +67,8 @@ inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) { + // other - failure + // Buffer should be at least of size 1. + inline int safe_strerror(int error_code, char*& buffer, +- size_t buffer_size) FMT_NOEXCEPT { +- FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer"); ++ size_t buffer_size) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer"); + + class dispatcher { + private: +@@ -86,7 +86,7 @@ inline int safe_strerror(int error_code, char*& buffer, + } + + // Handle the result of GNU-specific version of strerror_r. +- FMT_MAYBE_UNUSED ++ UMPIRE_FMT_MAYBE_UNUSED + int handle(char* message) { + // If the buffer is full then the message is probably truncated. + if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) +@@ -96,20 +96,20 @@ inline int safe_strerror(int error_code, char*& buffer, + } + + // Handle the case when strerror_r is not available. +- FMT_MAYBE_UNUSED ++ UMPIRE_FMT_MAYBE_UNUSED + int handle(detail::null<>) { + return fallback(strerror_s(buffer_, buffer_size_, error_code_)); + } + + // Fallback to strerror_s when strerror_r is not available. +- FMT_MAYBE_UNUSED ++ UMPIRE_FMT_MAYBE_UNUSED + 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 ++#if !UMPIRE_FMT_MSC_VER + // Fallback to strerror if strerror_r and strerror_s are not available. + int fallback(detail::null<>) { + errno = 0; +@@ -127,8 +127,8 @@ inline int safe_strerror(int error_code, char*& buffer, + return dispatcher(error_code, buffer, buffer_size).run(); + } + +-FMT_FUNC void format_error_code(detail::buffer& out, int error_code, +- string_view message) FMT_NOEXCEPT { ++UMPIRE_FMT_FUNC void format_error_code(detail::buffer& out, int error_code, ++ string_view message) UMPIRE_FMT_NOEXCEPT { + // Report error code making sure that the output fits into + // inline_buffer_size to avoid dynamic memory allocation and potential + // bad_alloc. +@@ -145,13 +145,13 @@ FMT_FUNC void format_error_code(detail::buffer& out, int error_code, + error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); + auto it = buffer_appender(out); + if (message.size() <= inline_buffer_size - error_code_size) +- format_to(it, FMT_STRING("{}{}"), message, SEP); +- format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); +- FMT_ASSERT(out.size() <= inline_buffer_size, ""); ++ format_to(it, UMPIRE_FMT_STRING("{}{}"), message, SEP); ++ format_to(it, UMPIRE_FMT_STRING("{}{}"), ERROR_STR, error_code); ++ UMPIRE_FMT_ASSERT(out.size() <= inline_buffer_size, ""); + } + +-FMT_FUNC void report_error(format_func func, int error_code, +- string_view message) FMT_NOEXCEPT { ++UMPIRE_FMT_FUNC void report_error(format_func func, int error_code, ++ string_view message) UMPIRE_FMT_NOEXCEPT { + memory_buffer full_message; + func(full_message, error_code, message); + // Don't use fwrite_fully because the latter may throw. +@@ -163,10 +163,10 @@ FMT_FUNC void report_error(format_func func, int error_code, + inline 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")); ++ if (written < count) UMPIRE_FMT_THROW(system_error(errno, "cannot write to file")); + } + +-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR ++#ifndef UMPIRE_FMT_STATIC_THOUSANDS_SEPARATOR + template + locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { + static_assert(std::is_same::value, ""); +@@ -177,34 +177,34 @@ template Locale locale_ref::get() const { + return locale_ ? *static_cast(locale_) : std::locale(); + } + +-template FMT_FUNC std::string grouping_impl(locale_ref loc) { ++template UMPIRE_FMT_FUNC std::string grouping_impl(locale_ref loc) { + return std::use_facet>(loc.get()).grouping(); + } +-template FMT_FUNC Char thousands_sep_impl(locale_ref loc) { ++template UMPIRE_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) { ++template UMPIRE_FMT_FUNC Char decimal_point_impl(locale_ref loc) { + return std::use_facet>(loc.get()) + .decimal_point(); + } + #else +-template FMT_FUNC std::string grouping_impl(locale_ref) { ++template UMPIRE_FMT_FUNC std::string grouping_impl(locale_ref) { + return "\03"; + } +-template FMT_FUNC Char thousands_sep_impl(locale_ref) { +- return FMT_STATIC_THOUSANDS_SEPARATOR; ++template UMPIRE_FMT_FUNC Char thousands_sep_impl(locale_ref) { ++ return UMPIRE_FMT_STATIC_THOUSANDS_SEPARATOR; + } +-template FMT_FUNC Char decimal_point_impl(locale_ref) { ++template UMPIRE_FMT_FUNC Char decimal_point_impl(locale_ref) { + return '.'; + } + #endif + } // namespace detail + +-FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default; +-FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default; ++UMPIRE_FMT_API UMPIRE_FMT_FUNC format_error::~format_error() UMPIRE_FMT_NOEXCEPT = default; ++UMPIRE_FMT_API UMPIRE_FMT_FUNC system_error::~system_error() UMPIRE_FMT_NOEXCEPT = default; + +-FMT_FUNC void system_error::init(int err_code, string_view format_str, ++UMPIRE_FMT_FUNC void system_error::init(int err_code, string_view format_str, + format_args args) { + error_code_ = err_code; + memory_buffer buffer; +@@ -215,7 +215,7 @@ FMT_FUNC void system_error::init(int err_code, string_view format_str, + + namespace detail { + +-template <> FMT_FUNC int count_digits<4>(detail::fallback_uintptr n) { ++template <> UMPIRE_FMT_FUNC int count_digits<4>(detail::fallback_uintptr n) { + // fallback_uintptr is always stored in little endian. + int i = static_cast(sizeof(void*)) - 1; + while (i > 0 && n.value[i] == 0) --i; +@@ -243,31 +243,31 @@ const typename basic_data::digit_pair basic_data::digits[] = { + {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'}, + {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}}; + +-#define FMT_POWERS_OF_10(factor) \ ++#define UMPIRE_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), ++ 1, UMPIRE_FMT_POWERS_OF_10(1), UMPIRE_FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + + template + const uint32_t basic_data::zero_or_powers_of_10_32[] = {0, +- FMT_POWERS_OF_10(1)}; ++ UMPIRE_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), ++ 0, UMPIRE_FMT_POWERS_OF_10(1), UMPIRE_FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + + template + const uint32_t basic_data::zero_or_powers_of_10_32_new[] = { +- 0, 0, FMT_POWERS_OF_10(1)}; ++ 0, 0, UMPIRE_FMT_POWERS_OF_10(1)}; + + template + const uint64_t basic_data::zero_or_powers_of_10_64_new[] = { +- 0, 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL), ++ 0, 0, UMPIRE_FMT_POWERS_OF_10(1), UMPIRE_FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + + // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. +@@ -385,7 +385,7 @@ const uint64_t basic_data::dragonbox_pow10_significands_64[] = { + + template + const uint128_wrapper basic_data::dragonbox_pow10_significands_128[] = { +-#if FMT_USE_FULL_CACHE_DRAGONBOX ++#if UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX + {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, + {0x9faacf3df73609b1, 0x77b191618c54e9ad}, + {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, +@@ -1032,7 +1032,7 @@ const uint128_wrapper basic_data::dragonbox_pow10_significands_128[] = { + #endif + }; + +-#if !FMT_USE_FULL_CACHE_DRAGONBOX ++#if !UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX + template + const uint64_t basic_data::powers_of_5_64[] = { + 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, +@@ -1073,7 +1073,7 @@ constexpr const char basic_data::right_padding_shifts[]; + #endif + + template struct bits { +- static FMT_CONSTEXPR_DECL const int value = ++ static UMPIRE_FMT_CONSTEXPR_DECL const int value = + static_cast(sizeof(T) * std::numeric_limits::digits); + }; + +@@ -1104,11 +1104,11 @@ class fp { + // 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 = ++ static UMPIRE_FMT_CONSTEXPR_DECL const int double_significand_size = + std::numeric_limits::digits - 1; +- static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = ++ static UMPIRE_FMT_CONSTEXPR_DECL const uint64_t implicit_bit = + 1ULL << double_significand_size; +- static FMT_CONSTEXPR_DECL const int significand_size = ++ static UMPIRE_FMT_CONSTEXPR_DECL const int significand_size = + bits::value; + + fp() : f(0), e(0) {} +@@ -1119,7 +1119,7 @@ class fp { + template explicit fp(Double d) { assign(d); } + + // Assigns d to this and return true iff predecessor is closer than successor. +- template ::value)> ++ template ::value)> + bool assign(Float d) { + // Assume float is in the format [sign][exponent][significand]. + using limits = std::numeric_limits; +@@ -1146,7 +1146,7 @@ class fp { + return is_predecessor_closer; + } + +- template ::value)> ++ template ::value)> + bool assign(Float) { + *this = fp(); + return false; +@@ -1173,7 +1173,7 @@ inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; } + + // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. + inline uint64_t multiply(uint64_t lhs, uint64_t rhs) { +-#if FMT_USE_INT128 ++#if UMPIRE_FMT_USE_INT128 + auto product = static_cast<__uint128_t>(lhs) * rhs; + auto f = static_cast(product >> 64); + return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; +@@ -1225,7 +1225,7 @@ struct accumulator { + if (lower < n) ++upper; + } + void operator>>=(int shift) { +- FMT_ASSERT(shift == 32, ""); ++ UMPIRE_FMT_ASSERT(shift == 32, ""); + (void)shift; + lower = (upper << 32) | (lower >> 32); + upper >>= 32; +@@ -1245,7 +1245,7 @@ class bigint { + bigit operator[](int index) const { return bigits_[to_unsigned(index)]; } + bigit& operator[](int index) { return bigits_[to_unsigned(index)]; } + +- static FMT_CONSTEXPR_DECL const int bigit_bits = bits::value; ++ static UMPIRE_FMT_CONSTEXPR_DECL const int bigit_bits = bits::value; + + friend struct formatter; + +@@ -1263,8 +1263,8 @@ class bigint { + + // Computes *this -= other assuming aligned bigints and *this >= other. + void subtract_aligned(const bigint& other) { +- FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); +- FMT_ASSERT(compare(*this, other) >= 0, ""); ++ UMPIRE_FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); ++ UMPIRE_FMT_ASSERT(compare(*this, other) >= 0, ""); + bigit borrow = 0; + int i = other.exp_ - exp_; + for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) +@@ -1304,7 +1304,7 @@ class bigint { + public: + bigint() : exp_(0) {} + explicit bigint(uint64_t n) { assign(n); } +- ~bigint() { FMT_ASSERT(bigits_.capacity() <= bigits_capacity, ""); } ++ ~bigint() { UMPIRE_FMT_ASSERT(bigits_.capacity() <= bigits_capacity, ""); } + + bigint(const bigint&) = delete; + void operator=(const bigint&) = delete; +@@ -1329,8 +1329,8 @@ class bigint { + + int num_bigits() const { return static_cast(bigits_.size()) + exp_; } + +- FMT_NOINLINE bigint& operator<<=(int shift) { +- FMT_ASSERT(shift >= 0, ""); ++ UMPIRE_FMT_NOINLINE bigint& operator<<=(int shift) { ++ UMPIRE_FMT_ASSERT(shift >= 0, ""); + exp_ += shift / bigit_bits; + shift %= bigit_bits; + if (shift == 0) return *this; +@@ -1345,7 +1345,7 @@ class bigint { + } + + template bigint& operator*=(Int value) { +- FMT_ASSERT(value > 0, ""); ++ UMPIRE_FMT_ASSERT(value > 0, ""); + multiply(uint32_or_64_or_128_t(value)); + return *this; + } +@@ -1392,7 +1392,7 @@ class bigint { + + // Assigns pow(10, exp) to this bigint. + void assign_pow10(int exp) { +- FMT_ASSERT(exp >= 0, ""); ++ UMPIRE_FMT_ASSERT(exp >= 0, ""); + if (exp == 0) return assign(1); + // Find the top bit. + int bitmask = 1; +@@ -1415,7 +1415,7 @@ class bigint { + int num_bigits = static_cast(bigits_.size()); + int num_result_bigits = 2 * num_bigits; + bigits_.resize(to_unsigned(num_result_bigits)); +- using accumulator_t = conditional_t; ++ using accumulator_t = conditional_t; + auto sum = accumulator_t(); + for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { + // Compute bigit at position bigit_index of the result by adding +@@ -1456,9 +1456,9 @@ class bigint { + // Divides this bignum by divisor, assigning the remainder to this and + // returning the quotient. + int divmod_assign(const bigint& divisor) { +- FMT_ASSERT(this != &divisor, ""); ++ UMPIRE_FMT_ASSERT(this != &divisor, ""); + if (compare(*this, divisor) < 0) return 0; +- FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); ++ UMPIRE_FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); + align(divisor); + int quotient = 0; + do { +@@ -1477,9 +1477,9 @@ enum class round_direction { unknown, up, down }; + // 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. ++ UMPIRE_FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow. ++ UMPIRE_FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow. ++ UMPIRE_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 round_direction::down; +@@ -1503,15 +1503,15 @@ enum result { + // error: the size of the region (lower, upper) outside of which numbers + // definitely do not round to value (Delta in Grisu3). + template +-FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, ++UMPIRE_FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, + int& exp, Handler& handler) { + const 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. + auto integral = static_cast(value.f >> -one.e); +- FMT_ASSERT(integral != 0, ""); +- FMT_ASSERT(integral == value.f >> -one.e, ""); ++ UMPIRE_FMT_ASSERT(integral != 0, ""); ++ UMPIRE_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. +@@ -1561,7 +1561,7 @@ FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, + integral = 0; + break; + default: +- FMT_ASSERT(false, "invalid number of digits"); ++ UMPIRE_FMT_ASSERT(false, "invalid number of digits"); + } + --exp; + auto remainder = (static_cast(integral) << -one.e) + fractional; +@@ -1609,7 +1609,7 @@ struct fixed_handler { + + digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, + uint64_t error, int, bool integral) { +- FMT_ASSERT(remainder < divisor, ""); ++ UMPIRE_FMT_ASSERT(remainder < divisor, ""); + buf[size++] = digit; + if (!integral && error >= remainder) return digits::error; + if (size < precision) return digits::more; +@@ -1619,7 +1619,7 @@ struct fixed_handler { + // and divisor > (1 << 32) there. + if (error >= divisor || error >= divisor - error) return digits::error; + } else { +- FMT_ASSERT(error == 1 && divisor > 2, ""); ++ UMPIRE_FMT_ASSERT(error == 1 && divisor > 2, ""); + } + auto dir = get_round_direction(divisor, remainder, error); + if (dir != round_direction::up) +@@ -1643,8 +1643,8 @@ struct fixed_handler { + // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. + namespace dragonbox { + // Computes 128-bit result of multiplication of two 64-bit unsigned integers. +-inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT { +-#if FMT_USE_INT128 ++inline uint128_wrapper umul128(uint64_t x, uint64_t y) UMPIRE_FMT_NOEXCEPT { ++#if UMPIRE_FMT_USE_INT128 + return static_cast(x) * static_cast(y); + #elif defined(_MSC_VER) && defined(_M_X64) + uint128_wrapper result; +@@ -1671,8 +1671,8 @@ inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT { + } + + // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. +-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT { +-#if FMT_USE_INT128 ++inline uint64_t umul128_upper64(uint64_t x, uint64_t y) UMPIRE_FMT_NOEXCEPT { ++#if UMPIRE_FMT_USE_INT128 + auto p = static_cast(x) * static_cast(y); + return static_cast(p >> 64); + #elif defined(_MSC_VER) && defined(_M_X64) +@@ -1684,7 +1684,7 @@ inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT { + + // Computes upper 64 bits of multiplication of a 64-bit unsigned integer and a + // 128-bit unsigned integer. +-inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT { ++inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) UMPIRE_FMT_NOEXCEPT { + uint128_wrapper g0 = umul128(x, y.high()); + g0 += umul128_upper64(x, y.low()); + return g0.high(); +@@ -1692,13 +1692,13 @@ inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT { + + // Computes upper 32 bits of multiplication of a 32-bit unsigned integer and a + // 64-bit unsigned integer. +-inline uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT { ++inline uint32_t umul96_upper32(uint32_t x, uint64_t y) UMPIRE_FMT_NOEXCEPT { + return static_cast(umul128_upper64(x, y)); + } + + // Computes middle 64 bits of multiplication of a 64-bit unsigned integer and a + // 128-bit unsigned integer. +-inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT { ++inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) UMPIRE_FMT_NOEXCEPT { + uint64_t g01 = x * y.high(); + uint64_t g10 = umul128_upper64(x, y.low()); + return g01 + g10; +@@ -1706,22 +1706,22 @@ inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT { + + // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a + // 64-bit unsigned integer. +-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT { ++inline uint64_t umul96_lower64(uint32_t x, uint64_t y) UMPIRE_FMT_NOEXCEPT { + return x * y; + } + + // Computes floor(log10(pow(2, e))) for e in [-1700, 1700] using the method from + // https://fmt.dev/papers/Grisu-Exact.pdf#page=5, section 3.4. +-inline int floor_log10_pow2(int e) FMT_NOEXCEPT { +- FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent"); ++inline int floor_log10_pow2(int e) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent"); + const int shift = 22; + return (e * static_cast(data::log10_2_significand >> (64 - shift))) >> + shift; + } + + // Various fast log computations. +-inline int floor_log2_pow10(int e) FMT_NOEXCEPT { +- FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); ++inline int floor_log2_pow10(int e) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); + const uint64_t log2_10_integer_part = 3; + const uint64_t log2_10_fractional_digits = 0x5269e12f346e2bf9; + const int shift_amount = 19; +@@ -1730,8 +1730,8 @@ inline int floor_log2_pow10(int e) FMT_NOEXCEPT { + (log2_10_fractional_digits >> (64 - shift_amount)))) >> + shift_amount; + } +-inline int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT { +- FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent"); ++inline int floor_log10_pow2_minus_log10_4_over_3(int e) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent"); + const uint64_t log10_4_over_3_fractional_digits = 0x1ffbfc2bbc780375; + const int shift_amount = 22; + return (e * static_cast(data::log10_2_significand >> +@@ -1742,33 +1742,33 @@ inline int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT { + } + + // Returns true iff x is divisible by pow(2, exp). +-inline bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT { +- FMT_ASSERT(exp >= 1, ""); +- FMT_ASSERT(x != 0, ""); +-#ifdef FMT_BUILTIN_CTZ +- return FMT_BUILTIN_CTZ(x) >= exp; ++inline bool divisible_by_power_of_2(uint32_t x, int exp) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(exp >= 1, ""); ++ UMPIRE_FMT_ASSERT(x != 0, ""); ++#ifdef UMPIRE_FMT_BUILTIN_CTZ ++ return UMPIRE_FMT_BUILTIN_CTZ(x) >= exp; + #else + return exp < num_bits() && x == ((x >> exp) << exp); + #endif + } +-inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT { +- FMT_ASSERT(exp >= 1, ""); +- FMT_ASSERT(x != 0, ""); +-#ifdef FMT_BUILTIN_CTZLL +- return FMT_BUILTIN_CTZLL(x) >= exp; ++inline bool divisible_by_power_of_2(uint64_t x, int exp) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(exp >= 1, ""); ++ UMPIRE_FMT_ASSERT(x != 0, ""); ++#ifdef UMPIRE_FMT_BUILTIN_CTZLL ++ return UMPIRE_FMT_BUILTIN_CTZLL(x) >= exp; + #else + return exp < num_bits() && x == ((x >> exp) << exp); + #endif + } + + // Returns true iff x is divisible by pow(5, exp). +-inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT { +- FMT_ASSERT(exp <= 10, "too large exponent"); ++inline bool divisible_by_power_of_5(uint32_t x, int exp) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(exp <= 10, "too large exponent"); + return x * data::divtest_table_for_pow5_32[exp].mod_inv <= + data::divtest_table_for_pow5_32[exp].max_quotient; + } +-inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT { +- FMT_ASSERT(exp <= 23, "too large exponent"); ++inline bool divisible_by_power_of_5(uint64_t x, int exp) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(exp <= 23, "too large exponent"); + return x * data::divtest_table_for_pow5_64[exp].mod_inv <= + data::divtest_table_for_pow5_64[exp].max_quotient; + } +@@ -1777,7 +1777,7 @@ inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT { + // divisible by pow(5, N). + // Precondition: n <= 2 * pow(5, N + 1). + template +-bool check_divisibility_and_divide_by_pow5(uint32_t& n) FMT_NOEXCEPT { ++bool check_divisibility_and_divide_by_pow5(uint32_t& n) UMPIRE_FMT_NOEXCEPT { + static constexpr struct { + uint32_t magic_number; + int bits_for_comparison; +@@ -1794,23 +1794,23 @@ bool check_divisibility_and_divide_by_pow5(uint32_t& n) FMT_NOEXCEPT { + + // Computes floor(n / pow(10, N)) for small n and N. + // Precondition: n <= pow(10, N + 1). +-template uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT { ++template uint32_t small_division_by_pow10(uint32_t n) UMPIRE_FMT_NOEXCEPT { + static constexpr struct { + uint32_t magic_number; + int shift_amount; + uint32_t divisor_times_10; + } infos[] = {{0xcccd, 19, 100}, {0xa3d8, 22, 1000}}; + constexpr auto info = infos[N - 1]; +- FMT_ASSERT(n <= info.divisor_times_10, "n is too large"); ++ UMPIRE_FMT_ASSERT(n <= info.divisor_times_10, "n is too large"); + return n * info.magic_number >> info.shift_amount; + } + + // Computes floor(n / 10^(kappa + 1)) (float) +-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT { ++inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) UMPIRE_FMT_NOEXCEPT { + return n / float_info::big_divisor; + } + // Computes floor(n / 10^(kappa + 1)) (double) +-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) FMT_NOEXCEPT { ++inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) UMPIRE_FMT_NOEXCEPT { + return umul128_upper64(n, 0x83126e978d4fdf3c) >> 9; + } + +@@ -1821,47 +1821,47 @@ template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint64_t; + +- static uint64_t get_cached_power(int k) FMT_NOEXCEPT { +- FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, ++ static uint64_t get_cached_power(int k) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + return data::dragonbox_pow10_significands_64[k - float_info::min_k]; + } + + static carrier_uint compute_mul(carrier_uint u, +- const cache_entry_type& cache) FMT_NOEXCEPT { ++ const cache_entry_type& cache) UMPIRE_FMT_NOEXCEPT { + return umul96_upper32(u, cache); + } + + static uint32_t compute_delta(const cache_entry_type& cache, +- int beta_minus_1) FMT_NOEXCEPT { ++ int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return static_cast(cache >> (64 - 1 - beta_minus_1)); + } + + static bool compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, +- int beta_minus_1) FMT_NOEXCEPT { +- FMT_ASSERT(beta_minus_1 >= 1, ""); +- FMT_ASSERT(beta_minus_1 < 64, ""); ++ int beta_minus_1) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(beta_minus_1 >= 1, ""); ++ UMPIRE_FMT_ASSERT(beta_minus_1 < 64, ""); + + return ((umul96_lower64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0; + } + + static carrier_uint compute_left_endpoint_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return static_cast( + (cache - (cache >> (float_info::significand_bits + 2))) >> + (64 - float_info::significand_bits - 1 - beta_minus_1)); + } + + static carrier_uint compute_right_endpoint_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return static_cast( + (cache + (cache >> (float_info::significand_bits + 1))) >> + (64 - float_info::significand_bits - 1 - beta_minus_1)); + } + + static carrier_uint compute_round_up_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return (static_cast( + cache >> + (64 - float_info::significand_bits - 2 - beta_minus_1)) + +@@ -1874,11 +1874,11 @@ template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint128_wrapper; + +- static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT { +- FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, ++ static uint128_wrapper get_cached_power(int k) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + +-#if FMT_USE_FULL_CACHE_DRAGONBOX ++#if UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX + return data::dragonbox_pow10_significands_128[k - + float_info::min_k]; + #else +@@ -1896,7 +1896,7 @@ template <> struct cache_accessor { + + // Compute the required amount of bit-shift. + int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; +- FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); ++ UMPIRE_FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); + + // Try to recover the real cache. + uint64_t pow5 = data::powers_of_5_64[offset]; +@@ -1922,46 +1922,46 @@ template <> struct cache_accessor { + 0x3; + + // Add the error back. +- FMT_ASSERT(recovered_cache.low() + error >= recovered_cache.low(), ""); ++ UMPIRE_FMT_ASSERT(recovered_cache.low() + error >= recovered_cache.low(), ""); + return {recovered_cache.high(), recovered_cache.low() + error}; + #endif + } + + static carrier_uint compute_mul(carrier_uint u, +- const cache_entry_type& cache) FMT_NOEXCEPT { ++ const cache_entry_type& cache) UMPIRE_FMT_NOEXCEPT { + return umul192_upper64(u, cache); + } + + static uint32_t compute_delta(cache_entry_type const& cache, +- int beta_minus_1) FMT_NOEXCEPT { ++ int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return static_cast(cache.high() >> (64 - 1 - beta_minus_1)); + } + + static bool compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, +- int beta_minus_1) FMT_NOEXCEPT { +- FMT_ASSERT(beta_minus_1 >= 1, ""); +- FMT_ASSERT(beta_minus_1 < 64, ""); ++ int beta_minus_1) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(beta_minus_1 >= 1, ""); ++ UMPIRE_FMT_ASSERT(beta_minus_1 < 64, ""); + + return ((umul192_middle64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0; + } + + static carrier_uint compute_left_endpoint_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return (cache.high() - + (cache.high() >> (float_info::significand_bits + 2))) >> + (64 - float_info::significand_bits - 1 - beta_minus_1); + } + + static carrier_uint compute_right_endpoint_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return (cache.high() + + (cache.high() >> (float_info::significand_bits + 1))) >> + (64 - float_info::significand_bits - 1 - beta_minus_1); + } + + static carrier_uint compute_round_up_for_shorter_interval_case( +- const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT { ++ const cache_entry_type& cache, int beta_minus_1) UMPIRE_FMT_NOEXCEPT { + return ((cache.high() >> + (64 - float_info::significand_bits - 2 - beta_minus_1)) + + 1) / +@@ -1971,7 +1971,7 @@ template <> struct cache_accessor { + + // Various integer checks + template +-bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT { ++bool is_left_endpoint_integer_shorter_interval(int exponent) UMPIRE_FMT_NOEXCEPT { + return exponent >= + float_info< + T>::case_shorter_interval_left_endpoint_lower_threshold && +@@ -1980,7 +1980,7 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT { + } + template + bool is_endpoint_integer(typename float_info::carrier_uint two_f, +- int exponent, int minus_k) FMT_NOEXCEPT { ++ int exponent, int minus_k) UMPIRE_FMT_NOEXCEPT { + if (exponent < float_info::case_fc_pm_half_lower_threshold) return false; + // For k >= 0. + if (exponent <= float_info::case_fc_pm_half_upper_threshold) return true; +@@ -1991,7 +1991,7 @@ bool is_endpoint_integer(typename float_info::carrier_uint two_f, + + template + bool is_center_integer(typename float_info::carrier_uint two_f, int exponent, +- int minus_k) FMT_NOEXCEPT { ++ int minus_k) UMPIRE_FMT_NOEXCEPT { + // Exponent for 5 is negative. + if (exponent > float_info::divisibility_check_by_5_threshold) return false; + if (exponent > float_info::case_fc_upper_threshold) +@@ -2003,9 +2003,9 @@ bool is_center_integer(typename float_info::carrier_uint two_f, int exponent, + } + + // Remove trailing zeros from n and return the number of zeros removed (float) +-FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT { +-#ifdef FMT_BUILTIN_CTZ +- int t = FMT_BUILTIN_CTZ(n); ++UMPIRE_FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t& n) UMPIRE_FMT_NOEXCEPT { ++#ifdef UMPIRE_FMT_BUILTIN_CTZ ++ int t = UMPIRE_FMT_BUILTIN_CTZ(n); + #else + int t = ctz(n); + #endif +@@ -2031,9 +2031,9 @@ FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT { + } + + // Removes trailing zeros and returns the number of zeros removed (double) +-FMT_ALWAYS_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT { +-#ifdef FMT_BUILTIN_CTZLL +- int t = FMT_BUILTIN_CTZLL(n); ++UMPIRE_FMT_ALWAYS_INLINE int remove_trailing_zeros(uint64_t& n) UMPIRE_FMT_NOEXCEPT { ++#ifdef UMPIRE_FMT_BUILTIN_CTZLL ++ int t = UMPIRE_FMT_BUILTIN_CTZLL(n); + #else + int t = ctzll(n); + #endif +@@ -2117,8 +2117,8 @@ FMT_ALWAYS_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT { + + // The main algorithm for shorter interval case + template +-FMT_ALWAYS_INLINE decimal_fp shorter_interval_case(int exponent) +- FMT_NOEXCEPT { ++UMPIRE_FMT_ALWAYS_INLINE decimal_fp shorter_interval_case(int exponent) ++ UMPIRE_FMT_NOEXCEPT { + decimal_fp ret_value; + // Compute k and beta + const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); +@@ -2164,7 +2164,7 @@ FMT_ALWAYS_INLINE decimal_fp shorter_interval_case(int exponent) + return ret_value; + } + +-template decimal_fp to_decimal(T x) FMT_NOEXCEPT { ++template decimal_fp to_decimal(T x) UMPIRE_FMT_NOEXCEPT { + // Step 1: integer promotion & Schubfach multiplier calculation. + + using carrier_uint = typename float_info::carrier_uint; +@@ -2421,7 +2421,7 @@ void fallback_format(Double d, int num_digits, bool binary32, buffer& buf, + template + int format_float(T value, int precision, float_specs specs, buffer& buf) { + static_assert(!std::is_same::value, ""); +- FMT_ASSERT(value >= 0, "value is negative"); ++ UMPIRE_FMT_ASSERT(value >= 0, "value is negative"); + + const bool fixed = specs.format == float_format::fixed; + if (value <= 0) { // <= instead of == to silence a warning. +@@ -2485,7 +2485,7 @@ template + int snprintf_float(T value, int precision, float_specs specs, + buffer& buf) { + // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. +- FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer"); ++ UMPIRE_FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer"); + static_assert(!std::is_same::value, ""); + + // Subtract 1 to account for the difference in precision since we use %e for +@@ -2515,14 +2515,14 @@ int snprintf_float(T value, int precision, float_specs specs, + for (;;) { + auto begin = buf.data() + offset; + auto capacity = buf.capacity() - offset; +-#ifdef FMT_FUZZ ++#ifdef UMPIRE_FMT_FUZZ + if (precision > 100000) + throw std::runtime_error( + "fuzz mode - avoid large allocation inside snprintf"); + #endif + // Suppress the warning about a nonliteral format string. + // Cannot use auto because of a bug in MinGW (#1532). +- int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF; ++ int (*snprintf_ptr)(char*, size_t, const char*, ...) = UMPIRE_FMT_SNPRINTF; + int result = precision >= 0 + ? snprintf_ptr(begin, capacity, format, precision, value) + : snprintf_ptr(begin, capacity, format, value); +@@ -2563,11 +2563,11 @@ int snprintf_float(T value, int precision, float_specs specs, + --exp_pos; + } while (*exp_pos != 'e'); + char sign = exp_pos[1]; +- FMT_ASSERT(sign == '+' || sign == '-', ""); ++ UMPIRE_FMT_ASSERT(sign == '+' || sign == '-', ""); + int exp = 0; + auto p = exp_pos + 2; // Skip 'e' and sign. + do { +- FMT_ASSERT(is_digit(*p), ""); ++ UMPIRE_FMT_ASSERT(is_digit(*p), ""); + exp = exp * 10 + (*p++ - '0'); + } while (p != end); + if (sign == '-') exp = -exp; +@@ -2586,7 +2586,7 @@ int snprintf_float(T value, int precision, float_specs specs, + } + + struct stringifier { +- template FMT_INLINE std::string operator()(T value) const { ++ template UMPIRE_FMT_INLINE std::string operator()(T value) const { + return to_string(value); + } + std::string operator()(basic_format_arg::handle h) const { +@@ -2600,7 +2600,7 @@ struct stringifier { + } // namespace detail + + template <> struct formatter { +- FMT_CONSTEXPR format_parse_context::iterator parse( ++ UMPIRE_FMT_CONSTEXPR format_parse_context::iterator parse( + format_parse_context& ctx) { + return ctx.begin(); + } +@@ -2612,22 +2612,22 @@ template <> struct formatter { + for (auto i = n.bigits_.size(); i > 0; --i) { + auto value = n.bigits_[i - 1u]; + if (first) { +- out = format_to(out, FMT_STRING("{:x}"), value); ++ out = format_to(out, UMPIRE_FMT_STRING("{:x}"), value); + first = false; + continue; + } +- out = format_to(out, FMT_STRING("{:08x}"), value); ++ out = format_to(out, UMPIRE_FMT_STRING("{:08x}"), value); + } + if (n.exp_ > 0) +- out = format_to(out, FMT_STRING("p{}"), ++ out = format_to(out, UMPIRE_FMT_STRING("p{}"), + n.exp_ * detail::bigint::bigit_bits); + return out; + } + }; + +-FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { ++UMPIRE_FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { + for_each_codepoint(s, [this](uint32_t cp, int error) { +- if (error != 0) FMT_THROW(std::runtime_error("invalid utf8")); ++ if (error != 0) UMPIRE_FMT_THROW(std::runtime_error("invalid utf8")); + if (cp <= 0xFFFF) { + buffer_.push_back(static_cast(cp)); + } else { +@@ -2639,9 +2639,9 @@ FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { + buffer_.push_back(0); + } + +-FMT_FUNC void format_system_error(detail::buffer& out, int error_code, +- string_view message) FMT_NOEXCEPT { +- FMT_TRY { ++UMPIRE_FMT_FUNC void format_system_error(detail::buffer& out, int error_code, ++ string_view message) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_TRY { + memory_buffer buf; + buf.resize(inline_buffer_size); + for (;;) { +@@ -2649,7 +2649,7 @@ FMT_FUNC void format_system_error(detail::buffer& out, int error_code, + int result = + detail::safe_strerror(error_code, system_message, buf.size()); + if (result == 0) { +- format_to(detail::buffer_appender(out), FMT_STRING("{}: {}"), ++ format_to(detail::buffer_appender(out), UMPIRE_FMT_STRING("{}: {}"), + message, system_message); + return; + } +@@ -2658,20 +2658,20 @@ FMT_FUNC void format_system_error(detail::buffer& out, int error_code, + buf.resize(buf.size() * 2); + } + } +- FMT_CATCH(...) {} ++ UMPIRE_FMT_CATCH(...) {} + format_error_code(out, error_code, message); + } + +-FMT_FUNC void detail::error_handler::on_error(const char* message) { +- FMT_THROW(format_error(message)); ++UMPIRE_FMT_FUNC void detail::error_handler::on_error(const char* message) { ++ UMPIRE_FMT_THROW(format_error(message)); + } + +-FMT_FUNC void report_system_error(int error_code, +- umpire::fmt::string_view message) FMT_NOEXCEPT { ++UMPIRE_FMT_FUNC void report_system_error(int error_code, ++ umpire::fmt::string_view message) UMPIRE_FMT_NOEXCEPT { + report_error(format_system_error, error_code, message); + } + +-FMT_FUNC std::string detail::vformat(string_view format_str, format_args args) { ++UMPIRE_FMT_FUNC std::string detail::vformat(string_view format_str, format_args args) { + if (format_str.size() == 2 && equal2(format_str.data(), "{}")) { + auto arg = args.get(0); + if (!arg) error_handler().on_error("argument not found"); +@@ -2690,7 +2690,7 @@ extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // + } // namespace detail + #endif + +-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) { ++UMPIRE_FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) { + memory_buffer buffer; + detail::vformat_to(buffer, format_str, + basic_format_args>(args)); +@@ -2713,7 +2713,7 @@ FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) { + + #ifdef _WIN32 + // Print assuming legacy (non-Unicode) encoding. +-FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str, ++UMPIRE_FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str, + format_args args) { + memory_buffer buffer; + detail::vformat_to(buffer, format_str, +@@ -2722,10 +2722,10 @@ FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str, + } + #endif + +-FMT_FUNC void vprint(string_view format_str, format_args args) { ++UMPIRE_FMT_FUNC void vprint(string_view format_str, format_args args) { + vprint(stdout, format_str, args); + } + +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + +-#endif // FMT_FORMAT_INL_H_ ++#endif // UMPIRE_FMT_FORMAT_INL_H_ +diff --git a/src/tpl/umpire/fmt/format.h b/src/tpl/umpire/fmt/format.h +index 8cceae731..4717a682f 100644 +--- a/src/tpl/umpire/fmt/format.h ++++ b/src/tpl/umpire/fmt/format.h +@@ -30,8 +30,8 @@ + without including the above copyright and permission notices. + */ + +-#ifndef FMT_FORMAT_H_ +-#define FMT_FORMAT_H_ ++#ifndef UMPIRE_FMT_FORMAT_H_ ++#define UMPIRE_FMT_FORMAT_H_ + + #include + #include +@@ -46,67 +46,67 @@ + #include "core.h" + + #ifdef __INTEL_COMPILER +-# define FMT_ICC_VERSION __INTEL_COMPILER ++# define UMPIRE_FMT_ICC_VERSION __INTEL_COMPILER + #elif defined(__ICL) +-# define FMT_ICC_VERSION __ICL ++# define UMPIRE_FMT_ICC_VERSION __ICL + #else +-# define FMT_ICC_VERSION 0 ++# define UMPIRE_FMT_ICC_VERSION 0 + #endif + + #ifdef __NVCC__ +-# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__) ++# define UMPIRE_FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__) + #else +-# define FMT_CUDA_VERSION 0 ++# define UMPIRE_FMT_CUDA_VERSION 0 + #endif + + #ifdef __has_builtin +-# define FMT_HAS_BUILTIN(x) __has_builtin(x) ++# define UMPIRE_FMT_HAS_BUILTIN(x) __has_builtin(x) + #else +-# define FMT_HAS_BUILTIN(x) 0 ++# define UMPIRE_FMT_HAS_BUILTIN(x) 0 + #endif + +-#if FMT_GCC_VERSION || FMT_CLANG_VERSION +-# define FMT_NOINLINE __attribute__((noinline)) ++#if UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_CLANG_VERSION ++# define UMPIRE_FMT_NOINLINE __attribute__((noinline)) + #else +-# define FMT_NOINLINE ++# define UMPIRE_FMT_NOINLINE + #endif + +-#if FMT_GCC_VERSION +-# define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) ++#if UMPIRE_FMT_GCC_VERSION ++# define UMPIRE_FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) + #else +-# define FMT_GCC_VISIBILITY_HIDDEN ++# define UMPIRE_FMT_GCC_VISIBILITY_HIDDEN + #endif + + #if __cplusplus == 201103L || __cplusplus == 201402L + # if defined(__INTEL_COMPILER) || defined(__PGI) +-# define FMT_FALLTHROUGH ++# define UMPIRE_FMT_FALLTHROUGH + # elif defined(__clang__) +-# define FMT_FALLTHROUGH [[clang::fallthrough]] +-# elif FMT_GCC_VERSION >= 700 && \ ++# define UMPIRE_FMT_FALLTHROUGH [[clang::fallthrough]] ++# elif UMPIRE_FMT_GCC_VERSION >= 700 && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) +-# define FMT_FALLTHROUGH [[gnu::fallthrough]] ++# define UMPIRE_FMT_FALLTHROUGH [[gnu::fallthrough]] + # else +-# define FMT_FALLTHROUGH ++# define UMPIRE_FMT_FALLTHROUGH + # endif +-#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \ ++#elif UMPIRE_FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \ + (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +-# define FMT_FALLTHROUGH [[fallthrough]] ++# define UMPIRE_FMT_FALLTHROUGH [[fallthrough]] + #else +-# define FMT_FALLTHROUGH ++# define UMPIRE_FMT_FALLTHROUGH + #endif + +-#ifndef FMT_MAYBE_UNUSED +-# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) +-# define FMT_MAYBE_UNUSED [[maybe_unused]] ++#ifndef UMPIRE_FMT_MAYBE_UNUSED ++# if UMPIRE_FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) ++# define UMPIRE_FMT_MAYBE_UNUSED [[maybe_unused]] + # else +-# define FMT_MAYBE_UNUSED ++# define UMPIRE_FMT_MAYBE_UNUSED + # endif + #endif + +-#ifndef FMT_THROW +-# if FMT_EXCEPTIONS +-# if FMT_MSC_VER || FMT_NVCC +-FMT_BEGIN_NAMESPACE ++#ifndef UMPIRE_FMT_THROW ++# if UMPIRE_FMT_EXCEPTIONS ++# if UMPIRE_FMT_MSC_VER || UMPIRE_FMT_NVCC ++UMPIRE_FMT_BEGIN_NAMESPACE + namespace detail { + template inline void do_throw(const Exception& x) { + // Silence unreachable code warnings in MSVC and NVCC because these +@@ -115,82 +115,82 @@ template inline void do_throw(const Exception& x) { + if (b) throw x; + } + } // namespace detail +-FMT_END_NAMESPACE +-# define FMT_THROW(x) detail::do_throw(x) ++UMPIRE_FMT_END_NAMESPACE ++# define UMPIRE_FMT_THROW(x) detail::do_throw(x) + # else +-# define FMT_THROW(x) throw x ++# define UMPIRE_FMT_THROW(x) throw x + # endif + # else +-# define FMT_THROW(x) \ ++# define UMPIRE_FMT_THROW(x) \ + do { \ +- FMT_ASSERT(false, (x).what()); \ ++ UMPIRE_FMT_ASSERT(false, (x).what()); \ + } while (false) + # endif + #endif + +-#if FMT_EXCEPTIONS +-# define FMT_TRY try +-# define FMT_CATCH(x) catch (x) ++#if UMPIRE_FMT_EXCEPTIONS ++# define UMPIRE_FMT_TRY try ++# define UMPIRE_FMT_CATCH(x) catch (x) + #else +-# define FMT_TRY if (true) +-# define FMT_CATCH(x) if (false) ++# define UMPIRE_FMT_TRY if (true) ++# define UMPIRE_FMT_CATCH(x) if (false) + #endif + +-#ifndef FMT_USE_USER_DEFINED_LITERALS ++#ifndef UMPIRE_FMT_USE_USER_DEFINED_LITERALS + // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs. +-# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \ +- FMT_MSC_VER >= 1900) && \ ++# if (UMPIRE_FMT_HAS_FEATURE(cxx_user_literals) || UMPIRE_FMT_GCC_VERSION >= 407 || \ ++ UMPIRE_FMT_MSC_VER >= 1900) && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) +-# define FMT_USE_USER_DEFINED_LITERALS 1 ++# define UMPIRE_FMT_USE_USER_DEFINED_LITERALS 1 + # else +-# define FMT_USE_USER_DEFINED_LITERALS 0 ++# define UMPIRE_FMT_USE_USER_DEFINED_LITERALS 0 + # endif + #endif + +-#ifndef FMT_USE_FLOAT +-# define FMT_USE_FLOAT 1 ++#ifndef UMPIRE_FMT_USE_FLOAT ++# define UMPIRE_FMT_USE_FLOAT 1 + #endif + +-#ifndef FMT_USE_DOUBLE +-# define FMT_USE_DOUBLE 1 ++#ifndef UMPIRE_FMT_USE_DOUBLE ++# define UMPIRE_FMT_USE_DOUBLE 1 + #endif + +-#ifndef FMT_USE_LONG_DOUBLE +-# define FMT_USE_LONG_DOUBLE 1 ++#ifndef UMPIRE_FMT_USE_LONG_DOUBLE ++# define UMPIRE_FMT_USE_LONG_DOUBLE 1 + #endif + +-// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of ++// Defining UMPIRE_FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of + // integer formatter template instantiations to just one by only using the + // largest integer type. This results in a reduction in binary size but will + // cause a decrease in integer formatting performance. +-#if !defined(FMT_REDUCE_INT_INSTANTIATIONS) +-# define FMT_REDUCE_INT_INSTANTIATIONS 0 ++#if !defined(UMPIRE_FMT_REDUCE_INT_INSTANTIATIONS) ++# define UMPIRE_FMT_REDUCE_INT_INSTANTIATIONS 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) ++#if (UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_HAS_BUILTIN(__builtin_clz)) && !UMPIRE_FMT_MSC_VER ++# define UMPIRE_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) ++#if (UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_HAS_BUILTIN(__builtin_clzll)) && !UMPIRE_FMT_MSC_VER ++# define UMPIRE_FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) + #endif +-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctz)) +-# define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) ++#if (UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_HAS_BUILTIN(__builtin_ctz)) ++# define UMPIRE_FMT_BUILTIN_CTZ(n) __builtin_ctz(n) + #endif +-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctzll)) +-# define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) ++#if (UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_HAS_BUILTIN(__builtin_ctzll)) ++# define UMPIRE_FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) + #endif + +-#if FMT_MSC_VER ++#if UMPIRE_FMT_MSC_VER + # include // _BitScanReverse[64], _BitScanForward[64], _umul128 + #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 ++// __builtin_clz and __builtin_clzll, so only define UMPIRE_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(FMT_BUILTIN_CTZLL) +-FMT_BEGIN_NAMESPACE ++#if UMPIRE_FMT_MSC_VER && !defined(UMPIRE_FMT_BUILTIN_CLZLL) && !defined(UMPIRE_FMT_BUILTIN_CTZLL) ++UMPIRE_FMT_BEGIN_NAMESPACE + namespace detail { + // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. + # if !defined(__clang__) +@@ -206,14 +206,14 @@ namespace detail { + inline int clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); +- FMT_ASSERT(x != 0, ""); ++ UMPIRE_FMT_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. +- FMT_MSC_WARNING(suppress : 6102) ++ UMPIRE_FMT_MSC_WARNING(suppress : 6102) + return 31 ^ static_cast(r); + } +-# define FMT_BUILTIN_CLZ(n) detail::clz(n) ++# define UMPIRE_FMT_BUILTIN_CLZ(n) detail::clz(n) + + inline int clzll(uint64_t x) { + unsigned long r = 0; +@@ -225,25 +225,25 @@ inline int clzll(uint64_t x) { + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); + # endif +- FMT_ASSERT(x != 0, ""); +- FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. ++ UMPIRE_FMT_ASSERT(x != 0, ""); ++ UMPIRE_FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return 63 ^ static_cast(r); + } +-# define FMT_BUILTIN_CLZLL(n) detail::clzll(n) ++# define UMPIRE_FMT_BUILTIN_CLZLL(n) detail::clzll(n) + + inline int ctz(uint32_t x) { + unsigned long r = 0; + _BitScanForward(&r, x); +- FMT_ASSERT(x != 0, ""); +- FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. ++ UMPIRE_FMT_ASSERT(x != 0, ""); ++ UMPIRE_FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return static_cast(r); + } +-# define FMT_BUILTIN_CTZ(n) detail::ctz(n) ++# define UMPIRE_FMT_BUILTIN_CTZ(n) detail::ctz(n) + + inline int ctzll(uint64_t x) { + unsigned long r = 0; +- FMT_ASSERT(x != 0, ""); +- FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. ++ UMPIRE_FMT_ASSERT(x != 0, ""); ++ UMPIRE_FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + # ifdef _WIN64 + _BitScanForward64(&r, x); + # else +@@ -255,27 +255,27 @@ inline int ctzll(uint64_t x) { + # endif + return static_cast(r); + } +-# define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) ++# define UMPIRE_FMT_BUILTIN_CTZLL(n) detail::ctzll(n) + # if !defined(__clang__) + # pragma managed(pop) + # endif + } // namespace detail +-FMT_END_NAMESPACE ++UMPIRE_FMT_END_NAMESPACE + #endif + + // Enable the deprecated numeric alignment. +-#ifndef FMT_DEPRECATED_NUMERIC_ALIGN +-# define FMT_DEPRECATED_NUMERIC_ALIGN 0 ++#ifndef UMPIRE_FMT_DEPRECATED_NUMERIC_ALIGN ++# define UMPIRE_FMT_DEPRECATED_NUMERIC_ALIGN 0 + #endif + +-FMT_BEGIN_NAMESPACE ++UMPIRE_FMT_BEGIN_NAMESPACE + namespace detail { + + #if __cplusplus >= 202002L || \ +- (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002) +-# define FMT_CONSTEXPR20 constexpr ++ (__cplusplus >= 201709L && UMPIRE_FMT_GCC_VERSION >= 1002) ++# define UMPIRE_FMT_CONSTEXPR20 constexpr + #else +-# define FMT_CONSTEXPR20 ++# define UMPIRE_FMT_CONSTEXPR20 + #endif + + // An equivalent of `*reinterpret_cast(&source)` that doesn't have +@@ -336,9 +336,9 @@ template <> constexpr int num_bits() { + std::numeric_limits::digits); + } + +-FMT_INLINE void assume(bool condition) { ++UMPIRE_FMT_INLINE void assume(bool condition) { + (void)condition; +-#if FMT_HAS_BUILTIN(__builtin_assume) ++#if UMPIRE_FMT_HAS_BUILTIN(__builtin_assume) + __builtin_assume(condition); + #endif + } +@@ -368,8 +368,8 @@ template using checked_ptr = T*; + template inline T* make_checked(T* p, size_t) { return p; } + #endif + +-template ::value)> +-#if FMT_CLANG_VERSION >= 307 ++template ::value)> ++#if UMPIRE_FMT_CLANG_VERSION >= 307 + __attribute__((no_sanitize("undefined"))) + #endif + inline checked_ptr +@@ -407,7 +407,7 @@ template T* to_pointer(buffer_appender it, size_t n) { + return buf.data() + size; + } + +-template ::value)> ++template ::value)> + inline std::back_insert_iterator base_iterator( + std::back_insert_iterator& it, + checked_ptr) { +@@ -461,12 +461,12 @@ class counting_iterator { + // is spectacularly slow to compile in C++20 so use a simple fill_n + // instead (#1998). + template +-FMT_CONSTEXPR OutputIt fill_n(OutputIt out, Size count, const T& value) { ++UMPIRE_FMT_CONSTEXPR OutputIt fill_n(OutputIt out, Size count, const T& value) { + for (Size i = 0; i < count; ++i) *out++ = value; + return out; + } + template +-FMT_CONSTEXPR20 T* fill_n(T* out, Size count, char value) { ++UMPIRE_FMT_CONSTEXPR20 T* fill_n(T* out, Size count, char value) { + if (is_constant_evaluated()) { + return fill_n(out, count, value); + } +@@ -481,15 +481,15 @@ using needs_conversion = bool_constant< + std::is_same::value>; + + template ::value)> +-FMT_CONSTEXPR OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) { ++ UMPIRE_FMT_ENABLE_IF(!needs_conversion::value)> ++UMPIRE_FMT_CONSTEXPR OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) { + while (begin != end) *it++ = *begin++; + return it; + } + + template ::value)> +-FMT_CONSTEXPR20 OutChar* copy_str(InputIt begin, InputIt end, OutChar* out) { ++ UMPIRE_FMT_ENABLE_IF(!needs_conversion::value)> ++UMPIRE_FMT_CONSTEXPR20 OutChar* copy_str(InputIt begin, InputIt end, OutChar* out) { + if (is_constant_evaluated()) { + return copy_str(begin, end, out); + } +@@ -497,14 +497,14 @@ FMT_CONSTEXPR20 OutChar* copy_str(InputIt begin, InputIt end, OutChar* out) { + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(needs_conversion::value)> + OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) { + while (begin != end) *it++ = static_cast(*begin++); + return it; + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(!needs_conversion::value)> + buffer_appender copy_str(InputIt begin, InputIt end, + buffer_appender out) { + get_container(out).append(begin, end); +@@ -518,7 +518,7 @@ inline counting_iterator copy_str(InputIt begin, InputIt end, + } + + template +-FMT_CONSTEXPR int code_point_length(const Char* begin) { ++UMPIRE_FMT_CONSTEXPR int code_point_length(const Char* begin) { + if (const_check(sizeof(Char) != 1)) return 1; + constexpr char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 3, 3, 4, 0}; +@@ -547,7 +547,7 @@ FMT_CONSTEXPR int code_point_length(const Char* begin) { + * occurs, this pointer will be a guess that depends on the particular + * error, but it will always advance at least one byte. + */ +-FMT_CONSTEXPR inline const char* utf8_decode(const char* s, uint32_t* c, ++UMPIRE_FMT_CONSTEXPR inline const char* utf8_decode(const char* s, uint32_t* c, + int* e) { + constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; + constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; +@@ -580,7 +580,7 @@ FMT_CONSTEXPR inline const char* utf8_decode(const char* s, uint32_t* c, + } + + template +-FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { ++UMPIRE_FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { + auto decode = [f](const char* p) { + auto cp = uint32_t(); + auto error = 0; +@@ -609,12 +609,12 @@ inline size_t compute_width(basic_string_view s) { + } + + // Computes approximate display width of a UTF-8 string. +-FMT_CONSTEXPR inline size_t compute_width(string_view s) { ++UMPIRE_FMT_CONSTEXPR inline size_t compute_width(string_view s) { + size_t num_code_points = 0; + // It is not a lambda for compatibility with C++14. + struct count_code_points { + size_t* count; +- FMT_CONSTEXPR void operator()(uint32_t cp, int error) const { ++ UMPIRE_FMT_CONSTEXPR void operator()(uint32_t cp, int error) const { + *count += + 1 + + (error == 0 && cp >= 0x1100 && +@@ -666,8 +666,8 @@ template + using is_fast_float = bool_constant::is_iec559 && + sizeof(T) <= sizeof(double)>; + +-#ifndef FMT_USE_FULL_CACHE_DRAGONBOX +-# define FMT_USE_FULL_CACHE_DRAGONBOX 0 ++#ifndef UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX ++# define UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX 0 + #endif + + template +@@ -741,7 +741,7 @@ class basic_memory_buffer final : public detail::buffer { + } + + protected: +- void grow(size_t size) final FMT_OVERRIDE; ++ void grow(size_t size) final UMPIRE_FMT_OVERRIDE; + + public: + using value_type = T; +@@ -779,15 +779,15 @@ class basic_memory_buffer final : public detail::buffer { + of the other object to it. + \endrst + */ +- basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); } ++ basic_memory_buffer(basic_memory_buffer&& other) UMPIRE_FMT_NOEXCEPT { 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) FMT_NOEXCEPT { +- FMT_ASSERT(this != &other, ""); ++ basic_memory_buffer& operator=(basic_memory_buffer&& other) UMPIRE_FMT_NOEXCEPT { ++ UMPIRE_FMT_ASSERT(this != &other, ""); + deallocate(); + move(other); + return *this; +@@ -815,7 +815,7 @@ class basic_memory_buffer final : public detail::buffer { + + template + void basic_memory_buffer::grow(size_t size) { +-#ifdef FMT_FUZZ ++#ifdef UMPIRE_FMT_FUZZ + if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much"); + #endif + const size_t max_size = std::allocator_traits::max_size(alloc_); +@@ -846,8 +846,8 @@ struct is_contiguous> : std::true_type { + }; + + /** A formatting error such as invalid format string. */ +-FMT_CLASS_API +-class FMT_API format_error : public std::runtime_error { ++UMPIRE_FMT_CLASS_API ++class UMPIRE_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) +@@ -856,7 +856,7 @@ class FMT_API format_error : public std::runtime_error { + format_error& operator=(const format_error&) = default; + format_error(format_error&&) = default; + format_error& operator=(format_error&&) = default; +- ~format_error() FMT_NOEXCEPT FMT_OVERRIDE; ++ ~format_error() UMPIRE_FMT_NOEXCEPT UMPIRE_FMT_OVERRIDE; + }; + + namespace detail { +@@ -868,49 +868,49 @@ using is_signed = + + // Returns true if value is negative, false otherwise. + // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. +-template ::value)> +-FMT_CONSTEXPR bool is_negative(T value) { ++template ::value)> ++UMPIRE_FMT_CONSTEXPR bool is_negative(T value) { + return value < 0; + } +-template ::value)> +-FMT_CONSTEXPR bool is_negative(T) { ++template ::value)> ++UMPIRE_FMT_CONSTEXPR bool is_negative(T) { + return false; + } + +-template ::value)> +-FMT_CONSTEXPR bool is_supported_floating_point(T) { +- return (std::is_same::value && FMT_USE_FLOAT) || +- (std::is_same::value && FMT_USE_DOUBLE) || +- (std::is_same::value && FMT_USE_LONG_DOUBLE); ++template ::value)> ++UMPIRE_FMT_CONSTEXPR bool is_supported_floating_point(T) { ++ return (std::is_same::value && UMPIRE_FMT_USE_FLOAT) || ++ (std::is_same::value && UMPIRE_FMT_USE_DOUBLE) || ++ (std::is_same::value && UMPIRE_FMT_USE_LONG_DOUBLE); + } + + // Smallest of uint32_t, uint64_t, uint128_t that is large enough to + // represent all values of an integral type T. + template + using uint32_or_64_or_128_t = +- conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, ++ conditional_t() <= 32 && !UMPIRE_FMT_REDUCE_INT_INSTANTIATIONS, + uint32_t, + conditional_t() <= 64, uint64_t, uint128_t>>; + template + using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; + + // 128-bit integer type used internally +-struct FMT_EXTERN_TEMPLATE_API uint128_wrapper { ++struct UMPIRE_FMT_EXTERN_TEMPLATE_API uint128_wrapper { + uint128_wrapper() = default; + +-#if FMT_USE_INT128 ++#if UMPIRE_FMT_USE_INT128 + uint128_t internal_; + +- uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT ++ uint128_wrapper(uint64_t high, uint64_t low) UMPIRE_FMT_NOEXCEPT + : internal_{static_cast(low) | + (static_cast(high) << 64)} {} + + uint128_wrapper(uint128_t u) : internal_{u} {} + +- uint64_t high() const FMT_NOEXCEPT { return uint64_t(internal_ >> 64); } +- uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); } ++ uint64_t high() const UMPIRE_FMT_NOEXCEPT { return uint64_t(internal_ >> 64); } ++ uint64_t low() const UMPIRE_FMT_NOEXCEPT { return uint64_t(internal_); } + +- uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT { ++ uint128_wrapper& operator+=(uint64_t n) UMPIRE_FMT_NOEXCEPT { + internal_ += n; + return *this; + } +@@ -918,13 +918,13 @@ struct FMT_EXTERN_TEMPLATE_API uint128_wrapper { + uint64_t high_; + uint64_t low_; + +- uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT : high_{high}, ++ uint128_wrapper(uint64_t high, uint64_t low) UMPIRE_FMT_NOEXCEPT : high_{high}, + low_{low} {} + +- uint64_t high() const FMT_NOEXCEPT { return high_; } +- uint64_t low() const FMT_NOEXCEPT { return low_; } ++ uint64_t high() const UMPIRE_FMT_NOEXCEPT { return high_; } ++ uint64_t low() const UMPIRE_FMT_NOEXCEPT { return low_; } + +- uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT { ++ uint128_wrapper& operator+=(uint64_t n) UMPIRE_FMT_NOEXCEPT { + # if defined(_MSC_VER) && defined(_M_X64) + unsigned char carry = _addcarry_u64(0, low_, n, &low_); + _addcarry_u64(carry, high_, 0, &high_); +@@ -940,13 +940,13 @@ struct FMT_EXTERN_TEMPLATE_API uint128_wrapper { + }; + + // Table entry type for divisibility test used internally +-template struct FMT_EXTERN_TEMPLATE_API divtest_table_entry { ++template struct UMPIRE_FMT_EXTERN_TEMPLATE_API divtest_table_entry { + T mod_inv; + T max_quotient; + }; + + // Static data is placed in this class template for the header-only config. +-template struct FMT_EXTERN_TEMPLATE_API basic_data { ++template struct UMPIRE_FMT_EXTERN_TEMPLATE_API basic_data { + static const uint64_t powers_of_10_64[]; + static const uint32_t zero_or_powers_of_10_32_new[]; + static const uint64_t zero_or_powers_of_10_64_new[]; +@@ -958,7 +958,7 @@ template struct FMT_EXTERN_TEMPLATE_API basic_data { + static const uint128_wrapper dragonbox_pow10_significands_128[]; + // log10(2) = 0x0.4d104d427de7fbcc... + static const uint64_t log10_2_significand = 0x4d104d427de7fbcc; +-#if !FMT_USE_FULL_CACHE_DRAGONBOX ++#if !UMPIRE_FMT_USE_FULL_CACHE_DRAGONBOX + static const uint64_t powers_of_5_64[]; + static const uint32_t dragonbox_pow10_recovery_errors[]; + #endif +@@ -983,7 +983,7 @@ template struct FMT_EXTERN_TEMPLATE_API basic_data { + + // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). + // This is a function instead of an array to workaround a bug in GCC10 (#1810). +-FMT_INLINE uint16_t bsr2log10(int bsr) { ++UMPIRE_FMT_INLINE uint16_t bsr2log10(int bsr) { + static constexpr uint16_t data[] = { + 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, + 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, +@@ -992,14 +992,14 @@ FMT_INLINE uint16_t bsr2log10(int bsr) { + return data[bsr]; + } + +-#ifndef FMT_EXPORTED +-FMT_EXTERN template struct basic_data; ++#ifndef UMPIRE_FMT_EXPORTED ++UMPIRE_FMT_EXTERN template struct basic_data; + #endif + + // This is a struct rather than an alias to avoid shadowing warnings in gcc. + struct data : basic_data<> {}; + +-template FMT_CONSTEXPR int count_digits_fallback(T n) { ++template UMPIRE_FMT_CONSTEXPR int count_digits_fallback(T n) { + int count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead +@@ -1013,21 +1013,21 @@ template FMT_CONSTEXPR int count_digits_fallback(T n) { + count += 4; + } + } +-#if FMT_USE_INT128 +-FMT_CONSTEXPR inline int count_digits(uint128_t n) { ++#if UMPIRE_FMT_USE_INT128 ++UMPIRE_FMT_CONSTEXPR inline int count_digits(uint128_t n) { + return count_digits_fallback(n); + } + #endif + + // Returns the number of decimal digits in n. Leading zeros are not counted + // except for n == 0 in which case count_digits returns 1. +-FMT_CONSTEXPR20 inline int count_digits(uint64_t n) { ++UMPIRE_FMT_CONSTEXPR20 inline int count_digits(uint64_t n) { + if (is_constant_evaluated()) { + return count_digits_fallback(n); + } +-#ifdef FMT_BUILTIN_CLZLL ++#ifdef UMPIRE_FMT_BUILTIN_CLZLL + // https://github.com/fmtlib/format-benchmark/blob/master/digits10 +- auto t = bsr2log10(FMT_BUILTIN_CLZLL(n | 1) ^ 63); ++ auto t = bsr2log10(UMPIRE_FMT_BUILTIN_CLZLL(n | 1) ^ 63); + return t - (n < data::zero_or_powers_of_10_64_new[t]); + #else + return count_digits_fallback(n); +@@ -1035,10 +1035,10 @@ FMT_CONSTEXPR20 inline int count_digits(uint64_t n) { + } + + // Counts the number of digits in n. BITS = log2(radix). +-template FMT_CONSTEXPR int count_digits(UInt n) { +-#ifdef FMT_BUILTIN_CLZ ++template UMPIRE_FMT_CONSTEXPR int count_digits(UInt n) { ++#ifdef UMPIRE_FMT_BUILTIN_CLZ + if (num_bits() == 32) +- return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; ++ return (UMPIRE_FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; + #endif + int num_digits = 0; + do { +@@ -1049,33 +1049,33 @@ template FMT_CONSTEXPR int count_digits(UInt n) { + + template <> int count_digits<4>(detail::fallback_uintptr n); + +-#if FMT_GCC_VERSION || FMT_CLANG_VERSION +-# define FMT_ALWAYS_INLINE inline __attribute__((always_inline)) +-#elif FMT_MSC_VER +-# define FMT_ALWAYS_INLINE __forceinline ++#if UMPIRE_FMT_GCC_VERSION || UMPIRE_FMT_CLANG_VERSION ++# define UMPIRE_FMT_ALWAYS_INLINE inline __attribute__((always_inline)) ++#elif UMPIRE_FMT_MSC_VER ++# define UMPIRE_FMT_ALWAYS_INLINE __forceinline + #else +-# define FMT_ALWAYS_INLINE inline ++# define UMPIRE_FMT_ALWAYS_INLINE inline + #endif + +-#ifdef FMT_BUILTIN_CLZ ++#ifdef UMPIRE_FMT_BUILTIN_CLZ + // Optional version of count_digits for better performance on 32-bit platforms. +-FMT_CONSTEXPR20 inline int count_digits(uint32_t n) { ++UMPIRE_FMT_CONSTEXPR20 inline int count_digits(uint32_t n) { + if (is_constant_evaluated()) { + return count_digits_fallback(n); + } +- auto t = bsr2log10(FMT_BUILTIN_CLZ(n | 1) ^ 31); ++ auto t = bsr2log10(UMPIRE_FMT_BUILTIN_CLZ(n | 1) ^ 31); + return t - (n < data::zero_or_powers_of_10_32_new[t]); + } + #endif + +-template constexpr int digits10() FMT_NOEXCEPT { ++template constexpr int digits10() UMPIRE_FMT_NOEXCEPT { + return std::numeric_limits::digits10; + } +-template <> constexpr int digits10() FMT_NOEXCEPT { return 38; } +-template <> constexpr int digits10() FMT_NOEXCEPT { return 38; } ++template <> constexpr int digits10() UMPIRE_FMT_NOEXCEPT { return 38; } ++template <> constexpr int digits10() UMPIRE_FMT_NOEXCEPT { return 38; } + + // DEPRECATED! grouping will be merged into thousands_sep. +-template FMT_API std::string grouping_impl(locale_ref loc); ++template UMPIRE_FMT_API std::string grouping_impl(locale_ref loc); + template inline std::string grouping(locale_ref loc) { + return grouping_impl(loc); + } +@@ -1083,7 +1083,7 @@ template <> inline std::string grouping(locale_ref loc) { + return grouping_impl(loc); + } + +-template FMT_API Char thousands_sep_impl(locale_ref loc); ++template UMPIRE_FMT_API Char thousands_sep_impl(locale_ref loc); + template inline Char thousands_sep(locale_ref loc) { + return Char(thousands_sep_impl(loc)); + } +@@ -1091,7 +1091,7 @@ 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 UMPIRE_FMT_API Char decimal_point_impl(locale_ref loc); + template inline Char decimal_point(locale_ref loc) { + return Char(decimal_point_impl(loc)); + } +@@ -1112,7 +1112,7 @@ template void copy2(Char* dst, const char* src) { + *dst++ = static_cast(*src++); + *dst = static_cast(*src); + } +-FMT_INLINE void copy2(char* dst, const char* src) { memcpy(dst, src, 2); } ++UMPIRE_FMT_INLINE void copy2(char* dst, const char* src) { memcpy(dst, src, 2); } + + template struct format_decimal_result { + Iterator begin; +@@ -1123,10 +1123,10 @@ template struct format_decimal_result { + // buffer of specified size. The caller must ensure that the buffer is large + // enough. + template +-FMT_CONSTEXPR20 format_decimal_result format_decimal(Char* out, ++UMPIRE_FMT_CONSTEXPR20 format_decimal_result format_decimal(Char* out, + UInt value, + int size) { +- FMT_ASSERT(size >= count_digits(value), "invalid digit count"); ++ UMPIRE_FMT_ASSERT(size >= count_digits(value), "invalid digit count"); + out += size; + Char* end = out; + if (is_constant_evaluated()) { +@@ -1155,7 +1155,7 @@ FMT_CONSTEXPR20 format_decimal_result format_decimal(Char* out, + } + + template >::value)> ++ UMPIRE_FMT_ENABLE_IF(!std::is_pointer>::value)> + inline format_decimal_result format_decimal(Iterator out, UInt value, + int size) { + // Buffer is large enough to hold all digits (digits10 + 1). +@@ -1165,7 +1165,7 @@ inline format_decimal_result format_decimal(Iterator out, UInt value, + } + + template +-FMT_CONSTEXPR Char* format_uint(Char* buffer, UInt value, int num_digits, ++UMPIRE_FMT_CONSTEXPR Char* format_uint(Char* buffer, UInt value, int num_digits, + bool upper = false) { + buffer += num_digits; + Char* end = buffer; +@@ -1218,7 +1218,7 @@ class utf8_to_utf16 { + wmemory_buffer buffer_; + + public: +- FMT_API explicit utf8_to_utf16(string_view s); ++ UMPIRE_FMT_API explicit utf8_to_utf16(string_view s); + operator wstring_view() const { return {&buffer_[0], size()}; } + size_t size() const { return buffer_.size() - 1; } + const wchar_t* c_str() const { return &buffer_[0]; } +@@ -1235,10 +1235,10 @@ template struct fill_t { + unsigned char size_ = 1; + + public: +- FMT_CONSTEXPR void operator=(basic_string_view s) { ++ UMPIRE_FMT_CONSTEXPR void operator=(basic_string_view s) { + auto size = s.size(); + if (size > max_size) { +- FMT_THROW(format_error("invalid fill")); ++ UMPIRE_FMT_THROW(format_error("invalid fill")); + return; + } + for (size_t i = 0; i < size; ++i) data_[i] = s[i]; +@@ -1248,8 +1248,8 @@ template struct fill_t { + constexpr size_t size() const { return size_; } + constexpr const Char* data() const { return data_; } + +- FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; } +- FMT_CONSTEXPR const Char& operator[](size_t index) const { ++ UMPIRE_FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; } ++ UMPIRE_FMT_CONSTEXPR const Char& operator[](size_t index) const { + return data_[index]; + } + }; +@@ -1354,7 +1354,7 @@ template struct decimal_fp { + int exponent; + }; + +-template FMT_API decimal_fp to_decimal(T x) FMT_NOEXCEPT; ++template UMPIRE_FMT_API decimal_fp to_decimal(T x) UMPIRE_FMT_NOEXCEPT; + } // namespace dragonbox + + template +@@ -1385,7 +1385,7 @@ struct float_specs { + + // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. + template It write_exponent(int exp, It it) { +- FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); ++ UMPIRE_FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); + if (exp < 0) { + *it++ = static_cast('-'); + exp = -exp; +@@ -1416,7 +1416,7 @@ template T promote_float(T value) { return value; } + inline double promote_float(float value) { return static_cast(value); } + + template +-FMT_CONSTEXPR float_specs parse_float_type_spec( ++UMPIRE_FMT_CONSTEXPR float_specs parse_float_type_spec( + const basic_format_specs& specs, ErrorHandler&& eh = {}) { + auto result = float_specs(); + result.showpoint = specs.alt; +@@ -1427,31 +1427,31 @@ FMT_CONSTEXPR float_specs parse_float_type_spec( + break; + case 'G': + result.upper = true; +- FMT_FALLTHROUGH; ++ UMPIRE_FMT_FALLTHROUGH; + case 'g': + result.format = float_format::general; + break; + case 'E': + result.upper = true; +- FMT_FALLTHROUGH; ++ UMPIRE_FMT_FALLTHROUGH; + case 'e': + result.format = float_format::exp; + result.showpoint |= specs.precision != 0; + break; + case 'F': + result.upper = true; +- FMT_FALLTHROUGH; ++ UMPIRE_FMT_FALLTHROUGH; + case 'f': + result.format = float_format::fixed; + result.showpoint |= specs.precision != 0; + break; + case 'A': + result.upper = true; +- FMT_FALLTHROUGH; ++ UMPIRE_FMT_FALLTHROUGH; + case 'a': + result.format = float_format::hex; + break; +-#ifdef FMT_DEPRECATED_N_SPECIFIER ++#ifdef UMPIRE_FMT_DEPRECATED_N_SPECIFIER + case 'n': + result.locale = true; + break; +@@ -1464,7 +1464,7 @@ FMT_CONSTEXPR float_specs parse_float_type_spec( + } + + template +-FMT_CONSTEXPR void check_int_type_spec(char spec, ErrorHandler&& eh) { ++UMPIRE_FMT_CONSTEXPR void check_int_type_spec(char spec, ErrorHandler&& eh) { + switch (spec) { + case 0: + case 'd': +@@ -1473,7 +1473,7 @@ FMT_CONSTEXPR void check_int_type_spec(char spec, ErrorHandler&& eh) { + case 'b': + case 'B': + case 'o': +-#ifdef FMT_DEPRECATED_N_SPECIFIER ++#ifdef UMPIRE_FMT_DEPRECATED_N_SPECIFIER + case 'n': + #endif + case 'c': +@@ -1485,7 +1485,7 @@ FMT_CONSTEXPR void check_int_type_spec(char spec, ErrorHandler&& eh) { + } + + template +-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs& specs, ++UMPIRE_FMT_CONSTEXPR void handle_char_specs(const basic_format_specs& specs, + Handler&& handler) { + if (specs.type && specs.type != 'c') return handler.on_int(); + if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) +@@ -1494,7 +1494,7 @@ FMT_CONSTEXPR void handle_char_specs(const basic_format_specs& specs, + } + + template +-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) { ++UMPIRE_FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) { + if (spec == 0 || spec == 's') + handler.on_string(); + else if (spec == 'p') +@@ -1504,12 +1504,12 @@ FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) { + } + + template +-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) { ++UMPIRE_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) { ++UMPIRE_FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) { + if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier"); + } + +@@ -1519,25 +1519,25 @@ class char_specs_checker : public ErrorHandler { + char type_; + + public: +- FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh) ++ UMPIRE_FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh) + : ErrorHandler(eh), type_(type) {} + +- FMT_CONSTEXPR void on_int() { check_int_type_spec(type_, *this); } +- FMT_CONSTEXPR void on_char() {} ++ UMPIRE_FMT_CONSTEXPR void on_int() { check_int_type_spec(type_, *this); } ++ UMPIRE_FMT_CONSTEXPR void on_char() {} + }; + + template + class cstring_type_checker : public ErrorHandler { + public: +- FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) ++ UMPIRE_FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) + : ErrorHandler(eh) {} + +- FMT_CONSTEXPR void on_string() {} +- FMT_CONSTEXPR void on_pointer() {} ++ UMPIRE_FMT_CONSTEXPR void on_string() {} ++ UMPIRE_FMT_CONSTEXPR void on_pointer() {} + }; + + template +-FMT_NOINLINE FMT_CONSTEXPR OutputIt fill(OutputIt it, size_t n, ++UMPIRE_FMT_NOINLINE UMPIRE_FMT_CONSTEXPR OutputIt fill(OutputIt it, size_t n, + const fill_t& fill) { + auto fill_size = fill.size(); + if (fill_size == 1) return detail::fill_n(it, n, fill[0]); +@@ -1552,7 +1552,7 @@ FMT_NOINLINE FMT_CONSTEXPR OutputIt fill(OutputIt it, size_t n, + // width: output display width in (terminal) column positions. + template +-FMT_CONSTEXPR OutputIt write_padded(OutputIt out, ++UMPIRE_FMT_CONSTEXPR OutputIt write_padded(OutputIt out, + const basic_format_specs& specs, + size_t size, size_t width, F&& f) { + static_assert(align == align::left || align == align::right, ""); +@@ -1602,7 +1602,7 @@ template struct write_int_data { + size_t size; + size_t padding; + +- FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, ++ UMPIRE_FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, + const basic_format_specs& specs) + : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { + if (specs.align == align::numeric) { +@@ -1623,7 +1623,7 @@ template struct write_int_data { + // where are written by write_digits(it). + // prefix contains chars in three lower bytes and the size in the fourth byte. + template +-FMT_CONSTEXPR FMT_INLINE OutputIt ++UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE OutputIt + write_int(OutputIt out, int num_digits, unsigned prefix, + const basic_format_specs& specs, W write_digits) { + // Slightly faster check for specs.width == 0 && specs.precision == -1. +@@ -1699,13 +1699,13 @@ bool write_int_localized(OutputIt& out, UInt value, unsigned prefix, + return true; + } + +-FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { ++UMPIRE_FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { + prefix |= prefix != 0 ? value << 8 : value; + prefix += (1u + (value > 0xff ? 1 : 0)) << 24; + } + + template +-FMT_CONSTEXPR OutputIt write_int(OutputIt out, T value, ++UMPIRE_FMT_CONSTEXPR OutputIt write_int(OutputIt out, T value, + const basic_format_specs& specs, + locale_ref loc) { + auto prefix = 0u; +@@ -1762,20 +1762,20 @@ FMT_CONSTEXPR OutputIt write_int(OutputIt out, T value, + return format_uint<3, Char>(it, abs_value, num_digits); + }); + } +-#ifdef FMT_DEPRECATED_N_SPECIFIER ++#ifdef UMPIRE_FMT_DEPRECATED_N_SPECIFIER + case 'n': + return write_int_localized(out, abs_value, prefix, specs, loc); + #endif + case 'c': + return write_char(out, static_cast(abs_value), specs); + default: +- FMT_THROW(format_error("invalid type specifier")); ++ UMPIRE_FMT_THROW(format_error("invalid type specifier")); + } + return out; + } + + template +-FMT_CONSTEXPR OutputIt write(OutputIt out, basic_string_view s, ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, basic_string_view s, + const basic_format_specs& specs) { + auto data = s.data(); + auto size = s.size(); +@@ -1832,7 +1832,7 @@ inline OutputIt write_significand(OutputIt out, UInt significand, + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_integral::value)> + inline Char* write_significand(Char* out, UInt significand, + int significand_size, int integral_size, + Char decimal_point) { +@@ -1848,7 +1848,7 @@ inline Char* write_significand(Char* out, UInt significand, + } + + template >::value)> ++ UMPIRE_FMT_ENABLE_IF(!std::is_pointer>::value)> + inline OutputIt write_significand(OutputIt out, UInt significand, + int significand_size, int integral_size, + Char decimal_point) { +@@ -1924,7 +1924,7 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp, + // 1234e5 -> 123400000[.0+] + size += to_unsigned(fp.exponent); + int num_zeros = fspecs.precision - exp; +-#ifdef FMT_FUZZ ++#ifdef UMPIRE_FMT_FUZZ + if (num_zeros > 5000) + throw std::runtime_error("fuzz mode - avoiding excessive cpu use"); + #endif +@@ -1970,7 +1970,7 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp, + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value)> + OutputIt write(OutputIt out, T value, basic_format_specs specs, + locale_ref loc = {}) { + if (const_check(!is_supported_floating_point(value))) return out; +@@ -2003,7 +2003,7 @@ OutputIt write(OutputIt out, T value, basic_format_specs specs, + int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6; + if (fspecs.format == float_format::exp) { + if (precision == max_value()) +- FMT_THROW(format_error("number is too big")); ++ UMPIRE_FMT_THROW(format_error("number is too big")); + else + ++precision; + } +@@ -2018,7 +2018,7 @@ OutputIt write(OutputIt out, T value, basic_format_specs specs, + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(is_fast_float::value)> + OutputIt write(OutputIt out, T value) { + if (const_check(!is_supported_floating_point(value))) return out; + +@@ -2043,7 +2043,7 @@ OutputIt write(OutputIt out, T value) { + } + + template ::value && ++ UMPIRE_FMT_ENABLE_IF(std::is_floating_point::value && + !is_fast_float::value)> + inline OutputIt write(OutputIt out, T value) { + return write(out, value, basic_format_specs()); +@@ -2069,12 +2069,12 @@ template <> struct is_integral : std::true_type {}; + + template + OutputIt write(OutputIt out, monostate) { +- FMT_ASSERT(false, ""); ++ UMPIRE_FMT_ASSERT(false, ""); + return out; + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(!std::is_same::value)> + OutputIt write(OutputIt out, string_view value) { + auto it = reserve(out, value.size()); + it = copy_str(value.begin(), value.end(), it); +@@ -2082,23 +2082,23 @@ OutputIt write(OutputIt out, string_view value) { + } + + template +-FMT_CONSTEXPR OutputIt write(OutputIt out, basic_string_view value) { ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, basic_string_view value) { + auto it = reserve(out, value.size()); + it = copy_str(value.begin(), value.end(), it); + return base_iterator(out, it); + } + + template ::value)> ++ UMPIRE_FMT_ENABLE_IF(is_string::value)> + constexpr OutputIt write(OutputIt out, const T& value) { + return write(out, to_string_view(value)); + } + + template ::value && ++ UMPIRE_FMT_ENABLE_IF(is_integral::value && + !std::is_same::value && + !std::is_same::value)> +-FMT_CONSTEXPR OutputIt write(OutputIt out, T value) { ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, T value) { + auto abs_value = static_cast>(value); + bool negative = is_negative(value); + // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. +@@ -2116,15 +2116,15 @@ FMT_CONSTEXPR OutputIt write(OutputIt out, T value) { + return base_iterator(out, it); + } + +-// FMT_ENABLE_IF() condition separated to workaround MSVC bug ++// UMPIRE_FMT_ENABLE_IF() condition separated to workaround MSVC bug + template < + typename Char, typename OutputIt, typename T, + bool check = + std::is_enum::value && !std::is_same::value && + mapped_type_constant>::value != + type::custom_type, +- FMT_ENABLE_IF(check)> +-FMT_CONSTEXPR OutputIt write(OutputIt out, T value) { ++ UMPIRE_FMT_ENABLE_IF(check)> ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, T value) { + return write( + out, static_cast::type>(value)); + } +@@ -2135,16 +2135,16 @@ constexpr OutputIt write(OutputIt out, bool value) { + } + + template +-FMT_CONSTEXPR OutputIt write(OutputIt out, Char value) { ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, Char value) { + auto it = reserve(out, 1); + *it++ = value; + return base_iterator(out, it); + } + + template +-FMT_CONSTEXPR OutputIt write(OutputIt out, const Char* value) { ++UMPIRE_FMT_CONSTEXPR OutputIt write(OutputIt out, const Char* value) { + if (!value) { +- FMT_THROW(format_error("string pointer is null")); ++ UMPIRE_FMT_THROW(format_error("string pointer is null")); + } else { + auto length = std::char_traits::length(value); + out = write(out, basic_string_view(value, length)); +@@ -2216,7 +2216,7 @@ class arg_formatter_base { + *it++ = value; + } + +- template ::value)> ++ template ::value)> + void write(Ch value) { + out_ = detail::write(out_, value); + } +@@ -2242,7 +2242,7 @@ class arg_formatter_base { + } + + template +- FMT_CONSTEXPR void write(basic_string_view s, ++ UMPIRE_FMT_CONSTEXPR void write(basic_string_view s, + const format_specs& specs = {}) { + out_ = detail::write(out_, s, specs); + } +@@ -2258,13 +2258,13 @@ class arg_formatter_base { + constexpr char_spec_handler(arg_formatter_base& f, Char val) + : formatter(f), value(val) {} + +- FMT_CONSTEXPR void on_int() { ++ UMPIRE_FMT_CONSTEXPR void on_int() { + // char is only formatted as int if there are specs. + formatter.out_ = + detail::write_int(formatter.out_, static_cast(value), + formatter.specs_, formatter.locale_); + } +- FMT_CONSTEXPR void on_char() { ++ UMPIRE_FMT_CONSTEXPR void on_char() { + formatter.out_ = write_char(formatter.out_, value, formatter.specs_); + } + }; +@@ -2284,7 +2284,7 @@ class arg_formatter_base { + iterator out() { return out_; } + const format_specs& specs() { return specs_; } + +- FMT_CONSTEXPR void write(bool value) { ++ UMPIRE_FMT_CONSTEXPR void write(bool value) { + write(string_view(value ? "true" : "false"), specs_); + } + +@@ -2292,7 +2292,7 @@ class arg_formatter_base { + if (value) + write(basic_string_view(value), specs_); + else +- FMT_THROW(format_error("string pointer is null")); ++ UMPIRE_FMT_THROW(format_error("string pointer is null")); + } + + public: +@@ -2300,33 +2300,33 @@ class arg_formatter_base { + : out_(out), specs_(s), locale_(loc) {} + + iterator operator()(monostate) { +- FMT_ASSERT(false, "invalid argument type"); ++ UMPIRE_FMT_ASSERT(false, "invalid argument type"); + return out_; + } + +- template ::value)> +- FMT_CONSTEXPR FMT_INLINE iterator operator()(T value) { ++ template ::value)> ++ UMPIRE_FMT_CONSTEXPR UMPIRE_FMT_INLINE iterator operator()(T value) { + return out_ = detail::write_int(out_, value, specs_, locale_); + } + +- FMT_CONSTEXPR iterator operator()(Char value) { ++ UMPIRE_FMT_CONSTEXPR iterator operator()(Char value) { + handle_char_specs(specs_, + char_spec_handler(*this, static_cast(value))); + return out_; + } + +- FMT_CONSTEXPR iterator operator()(bool value) { ++ UMPIRE_FMT_CONSTEXPR iterator operator()(bool value) { + if (specs_.type && specs_.type != 's') return (*this)(value ? 1 : 0); + write(value != 0); + return out_; + } + +- template ::value)> ++ template ::value)> + iterator operator()(T value) { + if (const_check(is_supported_floating_point(value))) + out_ = detail::write(out_, value, specs_, locale_); + else +- FMT_ASSERT(false, "unsupported float argument type"); ++ UMPIRE_FMT_ASSERT(false, "unsupported float argument type"); + return out_; + } + +@@ -2335,7 +2335,7 @@ class arg_formatter_base { + return out_; + } + +- FMT_CONSTEXPR iterator operator()(basic_string_view value) { ++ UMPIRE_FMT_CONSTEXPR iterator operator()(basic_string_view value) { + check_string_type_spec(specs_.type, error_handler()); + write(value, specs_); + return out_; +@@ -2381,16 +2381,16 @@ class arg_formatter : public arg_formatter_base { + } + }; + +-template FMT_CONSTEXPR bool is_name_start(Char c) { ++template UMPIRE_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, ++UMPIRE_FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end, + ErrorHandler&& eh) { +- FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); ++ UMPIRE_FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); + unsigned value = 0; + // Convert to unsigned to prevent a warning. + constexpr unsigned max_int = max_value(); +@@ -2435,16 +2435,16 @@ using is_integer = + + template class width_checker { + public: +- explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {} ++ explicit UMPIRE_FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {} + +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T value) { ++ template ::value)> ++ UMPIRE_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) { ++ template ::value)> ++ UMPIRE_FMT_CONSTEXPR unsigned long long operator()(T) { + handler_.on_error("width is not integer"); + return 0; + } +@@ -2455,16 +2455,16 @@ template class width_checker { + + template class precision_checker { + public: +- explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {} ++ explicit UMPIRE_FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {} + +- template ::value)> +- FMT_CONSTEXPR unsigned long long operator()(T value) { ++ template ::value)> ++ UMPIRE_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) { ++ template ::value)> ++ UMPIRE_FMT_CONSTEXPR unsigned long long operator()(T) { + handler_.on_error("precision is not integer"); + return 0; + } +@@ -2476,34 +2476,34 @@ template class precision_checker { + // 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) ++ explicit UMPIRE_FMT_CONSTEXPR specs_setter(basic_format_specs& specs) + : specs_(specs) {} + +- FMT_CONSTEXPR specs_setter(const specs_setter& other) ++ UMPIRE_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(basic_string_view fill) { ++ UMPIRE_FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; } ++ UMPIRE_FMT_CONSTEXPR void on_fill(basic_string_view fill) { + specs_.fill = 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_localized() { specs_.localized = true; } ++ UMPIRE_FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; } ++ UMPIRE_FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; } ++ UMPIRE_FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; } ++ UMPIRE_FMT_CONSTEXPR void on_hash() { specs_.alt = true; } ++ UMPIRE_FMT_CONSTEXPR void on_localized() { specs_.localized = true; } + +- FMT_CONSTEXPR void on_zero() { ++ UMPIRE_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) { ++ UMPIRE_FMT_CONSTEXPR void on_width(int width) { specs_.width = width; } ++ UMPIRE_FMT_CONSTEXPR void on_precision(int precision) { + specs_.precision = precision; + } +- FMT_CONSTEXPR void end_precision() {} ++ UMPIRE_FMT_CONSTEXPR void end_precision() {} + +- FMT_CONSTEXPR void on_type(Char type) { ++ UMPIRE_FMT_CONSTEXPR void on_type(Char type) { + specs_.type = static_cast(type); + } + +@@ -2513,15 +2513,15 @@ template class specs_setter { + + template class numeric_specs_checker { + public: +- FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, detail::type arg_type) ++ UMPIRE_FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, detail::type arg_type) + : error_handler_(eh), arg_type_(arg_type) {} + +- FMT_CONSTEXPR void require_numeric_argument() { ++ UMPIRE_FMT_CONSTEXPR void require_numeric_argument() { + if (!is_arithmetic_type(arg_type_)) + error_handler_.on_error("format specifier requires numeric argument"); + } + +- FMT_CONSTEXPR void check_sign() { ++ UMPIRE_FMT_CONSTEXPR void check_sign() { + require_numeric_argument(); + if (is_integral_type(arg_type_) && arg_type_ != type::int_type && + arg_type_ != type::long_long_type && arg_type_ != type::char_type) { +@@ -2529,7 +2529,7 @@ template class numeric_specs_checker { + } + } + +- FMT_CONSTEXPR void check_precision() { ++ UMPIRE_FMT_CONSTEXPR void check_precision() { + if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type) + error_handler_.on_error("precision not allowed for this argument type"); + } +@@ -2546,56 +2546,56 @@ template class specs_checker : public Handler { + numeric_specs_checker checker_; + + // Suppress an MSVC warning about using this in initializer list. +- FMT_CONSTEXPR Handler& error_handler() { return *this; } ++ UMPIRE_FMT_CONSTEXPR Handler& error_handler() { return *this; } + + public: +- FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type) ++ UMPIRE_FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type) + : Handler(handler), checker_(error_handler(), arg_type) {} + +- FMT_CONSTEXPR specs_checker(const specs_checker& other) ++ UMPIRE_FMT_CONSTEXPR specs_checker(const specs_checker& other) + : Handler(other), checker_(error_handler(), other.arg_type_) {} + +- FMT_CONSTEXPR void on_align(align_t align) { ++ UMPIRE_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() { ++ UMPIRE_FMT_CONSTEXPR void on_plus() { + checker_.check_sign(); + Handler::on_plus(); + } + +- FMT_CONSTEXPR void on_minus() { ++ UMPIRE_FMT_CONSTEXPR void on_minus() { + checker_.check_sign(); + Handler::on_minus(); + } + +- FMT_CONSTEXPR void on_space() { ++ UMPIRE_FMT_CONSTEXPR void on_space() { + checker_.check_sign(); + Handler::on_space(); + } + +- FMT_CONSTEXPR void on_hash() { ++ UMPIRE_FMT_CONSTEXPR void on_hash() { + checker_.require_numeric_argument(); + Handler::on_hash(); + } + +- FMT_CONSTEXPR void on_localized() { ++ UMPIRE_FMT_CONSTEXPR void on_localized() { + checker_.require_numeric_argument(); + Handler::on_localized(); + } + +- FMT_CONSTEXPR void on_zero() { ++ UMPIRE_FMT_CONSTEXPR void on_zero() { + checker_.require_numeric_argument(); + Handler::on_zero(); + } + +- FMT_CONSTEXPR void end_precision() { checker_.check_precision(); } ++ UMPIRE_FMT_CONSTEXPR void end_precision() { checker_.check_precision(); } + }; + + template