Index index by Group index by Distribution index by Vendor index by creation date index by Name Mirrors Help Search

libfmt8-8.0.1-150400.1.8 RPM for ppc64le

From OpenSuSE Leap 15.4 for ppc64le

Name: libfmt8 Distribution: SUSE Linux Enterprise 15
Version: 8.0.1 Vendor: SUSE LLC <>
Release: 150400.1.8 Build date: Sun May 8 00:29:35 2022
Group: Unspecified Build host: ibs-power9-14
Size: 200168 Source RPM: fmt-8.0.1-150400.1.8.src.rpm
Summary: A formatting library for C++
Shared library for fmt, a formatting library for C++.






* Sat Jul 03 2021
  - Update to version 8.0.1
    * Fixed the version number in the inline namespace.
    * Added a missing presentation type check for std::string.
    * Fixed a linkage error when mixing code built with clang and
    * Fixed documentation issues.
    * Removed dead code in FP formatter.
    * Fixed various warnings and compilation issues.
* Mon Jun 21 2021
  - Update to version 8.0.0
    * Enabled compile-time format string check by default.
    * Added compile-time formatting.
    * Optimized handling of format specifiers during format string
    * Added the ``_cf`` user-defined literal to represent a
      compiled format string. It can be used instead of the
      ``FMT_COMPILE`` macro.
    * Format string compilation now requires ``format`` functions
      of ``formatter`` specializations for user-defined types to
      be ``const``.
    * Added UDL-based named argument support to format string
    * Added format string compilation support to ``fmt::print``.
    * Added initial support for compiling {fmt} as a C++20 module.
    * Made symbols private by default reducing shared library size
    * Optimized includes making the result of preprocessing
    * Added support of ranges with non-const ``begin`` / ``end``
    * Added support of ``std::byte`` and other formattable types
      to ``fmt::join``.
    * Implemented the default format for
    * Made more chrono specifiers locale independent by default.
      Use the ``'L'`` specifier to get localized formatting.
    * Improved locale handling in chrono formatting.
    * Deprecated ``fmt/locale.h`` moving the formatting functions
      that take a locale to ``fmt/format.h`` (``char``) and
      ``fmt/xchar`` (other overloads). This doesn't introduce a
      dependency on ``<locale>`` so there is virtually no compile
      time effect.
    * Made parameter order in ``vformat_to`` consistent with
    * Added support for time points with arbitrary durations.
    * Formatting floating-point numbers no longer produces
      trailing zeros by default.
      for consistency with ``std::format``.
    * Dropped a limit on the number of elements in a range and
      replaced ``{}`` with ``[]`` as range delimiters for
      consistency with Python's ``str.format``.
    * The ``'L'`` specifier for locale-specific numeric formatting
      can now be combined with presentation specifiers as in
    * Made the ``0`` specifier ignored for infinity and NaN.
    * Made the hexfloat formatting use the right alignment by
    * Removed the deprecated numeric alignment (``'='``). Use the
      ``'0'`` specifier instead.
    * Removed the deprecated ``fmt/posix.h`` header that has been
      replaced with ``fmt/os.h``.
    * Removed the deprecated ``format_to_n_context``,
      ``format_to_n_args`` and ``make_format_to_n_args``. They
      have been replaced with ``format_context``, ``format_args`
      and ``make_format_args`` respectively.
    * Moved ``wchar_t``-specific functions and types to
      ``fmt/wchar.h``. You can define
      ``FMT_DEPRECATED_INCLUDE_WCHAR`` to automatically include
      ``fmt/wchar.h`` from ``fmt/format.h`` but this will be
      disabled in the next major release.
    * Fixed handling of the ``'+'`` specifier in localized
    * Added support for the ``'s'`` format specifier that gives
      textual representation of ``bool``.
    * Made ``fmt::ptr`` work with function pointers.
    * Fixed ``fmt::formatted_size`` with format string compilation
    * Fixed handling of empty format strings during format string
    * Fixed handling of enums in ``fmt::to_string``.
    * Improved width computation.
    * The experimental fast output stream (``fmt::ostream``) is
      now truncated by default for consistency with ``fopen``.
    * Fixed moving of ``fmt::ostream`` that holds buffered data
    * Replaced the ``fmt::system_error`` exception with a function
      of the same name that constructs ``std::system_error``.
    * Replaced the ``fmt::windows_error`` exception with a
      function of the same name that constructs
      ``std::system_error`` with the category returned by
    * Replaced ``fmt::error_code`` with ``std::error_code`` and
      made it formattable.
    * Added speech synthesis support.
    * Made ``format_to`` work with a memory buffer that has a
      custom allocator.
    * Added ``Allocator::max_size`` support to
    * Added wide string support to ``fmt::join``
    * Made iterators passed to ``formatter`` specializations via a
      format context satisfy C++20 ``std::output_iterator``
    * Optimized the ``printf`` implementation.
    * Improved detection of ``constexpr`` ``char_traits``.
    * Fixed exception propagation from iterators.
    * Improved ``strftime`` error handling.
    * Stopped using deprecated GCC UDL template extension.
    * Added ``fmt/args.h`` to the install target.
    * Error messages are now passed to assert when exceptions are
    * Added the ``FMT_MASTER_PROJECT`` CMake option to control
      build and install targets when {fmt} is included via
    * Improved build configuration.
    * Fixed various warnings and compilation issues.
    * Improved documentation.
    * Continuous integration and test improvements.
  - Bump soversion to 8
* Wed Nov 25 2020
  - Update to version 7.1.3
    * Fixed handling of buffer boundaries in format_to_n
    * Fixed linkage errors when linking with a shared library
    * Reintroduced ostream support to range formatters
    * Worked around an issue with mixing std versions in gcc
* Wed Nov 04 2020
  - Update to version 7.1.2
    * Fixed floating point formatting with large precision
* Mon Nov 02 2020
  - Update to version 7.1.1
    * Fixed ABI compatibility with 7.0.x
    * Added the FMT_ARM_ABI_COMPATIBILITY macro to work around
      ABI incompatibility between GCC and Clang on ARM
    * Worked around a SFINAE bug in GCC 8
    * Fixed linkage errors when building with GCC's LTO
    * Fixed a compilation error when building without
      __builtin_clz or equivalent
    * Fixed a sign conversion warning
  - Dropped fmt-7.1.0-LTO.patch (merged upstream)
* Mon Oct 26 2020
  - Update to version 7.1.0
    * Switched from Grisu3 to Dragonbox for the default
      floating-point formatting which gives the shortest decimal
      representation with round-trip guarantee and correct rounding.
      This makes {fmt} up to 20-30x faster than common
      implementations of std::ostringstream and sprintf on
      dtoa-benchmark and faster than double-conversion and Ryƫ. It
      is possible to get even better performance at the cost of
      larger binary size by compiling with the
      FMT_USE_FULL_CACHE_DRAGONBOX macro set to 1.
    * Added an experimental unsynchronized file output API which,
      together with format string compilation can give 5-9 times
      speed up compared to fprintf on common platforms.
    * Added a formatter for std::chrono::time_point<system_clock>
    * Added support for ranges with non-const begin/end to fmt::join
    * Added a memory_buffer::append overload that takes a range.
    * Improved handling of single code units in FMT_COMPILE.
    * Added dynamic width support to format string compilation.
    * Improved error reporting for unformattable types: now you'll
      get the type name directly in the error message instead of
      the note.
    * Added the make_args_checked function template that allows
      you to write formatting functions with compile-time format
      string checks and avoid binary code bloat.
    * Replaced snprintf fallback with a faster internal IEEE 754
      float and double formatter for arbitrary precision.
    * Made format_to_n and formatted_size part of the core API.
    * Added fmt::format_to_n overload with format string
    * Added fmt::format_to overload that take text_style.
    * Made the # specifier emit trailing zeros in addition to the
      decimal point.
    * Changed the default floating point format to not include .0
      for consistency with std::format and std::to_chars. It is
      possible to get the decimal point and trailing zero with the
      [#] specifier.
    * Fixed an issue with floating-point formatting that could
      result in addition of a non-significant trailing zero in
      rare cases e.g. 1.00e-34 instead of 1.0e-34.
    * Made fmt::to_string fallback on ostream insertion operator
      if the formatter specialization is not provided.
    * Added support for the append mode to the experimental file
      API and improved fcntl.h detection.
    * Fixed handling of types that have both an implicit
      conversion operator and an overloaded ostream insertion
    * Fixed a slicing issue in an internal iterator type.
    * Fixed an issue in locale-specific integer formatting.
    * Fixed handling of exotic code unit types.
    * Improved FMT_ALWAYS_INLINE.
    * Improved documentation.
    * Added the FMT_REDUCE_INT_INSTANTIATIONS CMake option that
      reduces the binary code size at the cost of some integer
      formatting performance. This can be useful for extremely
      memory-constrained embedded systems.
    * Added the FMT_USE_INLINE_NAMESPACES macro to control usage
      of inline namespaces.
    * Improved build configuration.
    * Fixed various warnings and compilation issues.
  - Add fmt-7.1.0-LTO.patch
* Fri Aug 07 2020
  - Update to version 7.0.3
    * Worked around broken ``numeric_limits`` for 128-bit integers
    * Added error reporting on missing named arguments
    * Stopped using 128-bit integers with clang-cl
    * Fixed issues in locale-specific integer formatting
* Wed Jul 29 2020
  - Update to version 7.0.2
    * Worked around broken ``numeric_limits`` for 128-bit integers
    * Fixed compatibility with CMake 3.4
    * Fixed handling of digit separators in locale-specific
* Tue Jul 07 2020
  - Update to version 7.0.1
    * Updated the inline version namespace name.
    * Worked around a gcc bug in mangling of alias templates
    * Fixed minor issues with the documentation.
* Mon Jul 06 2020
  - Update to version 7.0.0
    * Reduced the library size.
    * Added a simpler and more efficient format string compilation
      API. The old fmt::compile API is now deprecated.
    * Optimized integer formatting: format_to with format string
      compilation and a stack-allocated buffer is now faster than
      to_chars on both libc++ and libstdc++.
    * Optimized handling of small format strings.
    * Applied extern templates to improve compile times when using
      the core API and fmt/format.h. It is still recommended to use
      fmt/core.h instead of fmt/format.h but the compile time
      difference is now smaller.
    * Named arguments are now stored on stack (no dynamic memory
      allocations) and the compiled code is more compact and
    * Implemented compile-time checks for dynamic width and
    * Added sentinel support to fmt::join.
    * Added support for named args, clear and reserve to
    * Added support for the 'c' format specifier to integral types
      for compatibility with std::format.
    * Replaced the 'n' format specifier with 'L' for compatibility
      with std::format. The 'n' specifier can be enabled via the
    * The '=' format specifier is now disabled by default for
      compatibility with std::format. It can be enabled via the
    * Removed the following deprecated APIs:
      + FMT_STRING_ALIAS and fmt macros - replaced by
      + fmt::basic_string_view::char_type - replaced by
      + convert_to_int
      + format_arg_store::types
      + *parse_context - replaced by *format_parse_context
      + FMT_DEPRECATED_PERCENT - incompatible with
      + *writer - replaced by compiled format API
    * Renamed the internal namespace to detail. The former is
      still provided as an alias if the FMT_USE_INTERNAL macro is
    * Improved compatibility between fmt::printf with the standard
    * Fixed handling of operator<< overloads that use copyfmt.
    * Added the FMT_OS CMake option to control inclusion of
      OS-specific APIs in the fmt target. This can be useful for
      embedded platforms.
      FMT_FUZZ macro to prevent interferring with fuzzing of
      projects using {fmt}.
    * Fixed compatibility with emscripten.
    * Improved documentation.
    * Implemented various build configuration fixes and
    * Fixed various warnings and compilation issues.
  - Drop fmt-6.2.1-fix_pkgconfig_paths.patch
  - Bump sover to 7
* Tue Jun 23 2020
  - Add fmt-6.2.1-fix_pkgconfig_paths.patch (fix for boo#1173270)
* Sat May 09 2020
  - Update to version 6.2.1
    * Fixed ostream support in ``sprintf``
      (`#1631 <>`_).
    * Fixed type detection when using implicit conversion to
      ``string_view`` and ostream ``operator<<`` inconsistently
      (`#1662 <>`_).
  - Drop 7d01859ef16e6b65bc023ad8bebfedecb088bf81.patch (no longer
  - Spec cleanup
* Tue Apr 14 2020
  - Apply 7d01859ef16e6b65bc023ad8bebfedecb088bf81.patch
    to fix kodi compilation and probably others:
* Mon Apr 06 2020
  - Update to version 6.2.0
    * Improved error reporting when trying to format an object of
      a non-formattable type:
    * Reduced library size by ~10%.
    * Always print decimal point if # is specified (#1476, #1498):
    * Implemented the 'L' specifier for locale-specific numeric
      formatting to improve compatibility with std::format. The 'n'
      specifier is now deprecated and will be removed in the next
      major release.
    * Moved OS-specific APIs such as windows_error from
      fmt/format.h to fmt/os.h. You can define
      FMT_DEPRECATED_INCLUDE_OS to automatically include fmt/os.h from
      fmt/format.h for compatibility but this will be disabled in the
      next major release.
    * Added precision overflow detection in floating-point
    * Implemented detection of invalid use of fmt::arg.
    * Used type_identity to block unnecessary template argument
    * Improved UTF-8 handling (#1109):
    * Added experimental dynamic argument storage (#1170, #1584):
    * Made fmt::join accept initializer_list (#1591).
    * Fixed handling of empty tuples (#1588).
    * Fixed handling of output iterators in format_to_n (#1506).
    * Fixed formatting of std::chrono::duration types to wide
      output (#1533).
    * Added const begin and end overload to buffers (#1553).
    * Added the ability to disable floating-point formatting via
      extremely memory-constrained embedded system (#1590).
    * Made FMT_STRING work with constexpr string_view (#1589).
    * Implemented a minor optimization in the format string parser
    * Improved attribute detection (#1469, #1475, #1576).
    * Improved documentation (#1481, #1523).
    * Fixed symbol visibility on Linux when compiling with
    - fvisibility=hidden (#1535).
    * Implemented various build configuration fixes and
      improvements (#1264, #1460, #1534, #1536, #1545, #1546, #1566,
      [#1582], #1597, #1598).
    * Fixed various warnings and compilation issues
  - Dropped Group tag
* Wed Dec 11 2019
  - Update to version 6.1.2
    * Fixed ABI compatibility with (#1471).
    * Fixed handling types convertible to std::string_view (#1451).
      Thanks @denizevrenci (Deniz Evrenci).
    * Made CUDA test an opt-in enabled via the FMT_CUDA_TEST CMake
    * Fixed sign conversion warnings (#1440). Thanks @0x8000-0000
      (Florin Iucha).
* Thu Dec 05 2019
  - Update to version 6.1.1
    * Added a missing decimal point in exponent notation with
      trailing zeros.
    * Removed deprecated format_arg_store::TYPES.
* Wed Dec 04 2019
  - Update to version 6.1.0
    * {fmt} now formats IEEE 754 ``float`` and ``double`` using
      the shortest decimal representation with correct rounding by
      .. code:: c++
      [#]include <cmath>
      [#]include <fmt/core.h>
      int main() {
      fmt::print("{}", M_PI);
      prints ``3.141592653589793``.
    * Made the fast binary to decimal floating-point formatter the
      default, simplified it and improved performance. {fmt} is now
      15 times faster than libc++'s ``std::ostringstream``, 11
      times faster than ``printf`` and 10% faster than
      double-conversion on `dtoa-benchmark
      ==================  =========  =======
      Function            Time (ns)  Speedup
      ==================  =========  =======
      ostringstream        1,346.30    1.00x
      ostrstream           1,195.74    1.13x
      sprintf                995.08    1.35x
      doubleconv              99.10   13.59x
      fmt                     88.34   15.24x
      ==================  =========  =======
    * {fmt} no longer converts ``float`` arguments to ``double``.
      In particular this improves the default (shortest)
      representation of floats and makes
      ``fmt::format`` consistent with ``std::format`` specs
      (#1336, #1353, #1360, #1361)
      .. code:: c++
      fmt::print("{}", 0.1f);
      prints ``0.1`` instead of ``0.10000000149011612``.
    * Made floating-point formatting output consistent with
      ``printf``/iostreams (#1376, #1417)
    * Added support for 128-bit integers (#1287)
      .. code:: c++
      fmt::print("{}", std::numeric_limits<__int128_t>::max());
      prints ``170141183460469231731687303715884105727``.
    * The overload of ``print`` that takes ``text_style`` is now
      atomic, i.e. the output from different threads doesn't
      interleave (#1351)
    * Made compile time in the header-only mode ~20% faster by
      reducing the number of template instantiations. ``wchar_t``
      overload of ``vprint`` was moved from
      ``fmt/core.h`` to ``fmt/format.h``.
    * Added an overload of ``fmt::join`` that works with tuples
      (#1322, #1330)
      .. code:: c++
      [#]include <tuple>
      [#]include <fmt/ranges.h>
      int main() {
      std::tuple<char, int, float> t{'a', 1, 2.0f};
      fmt::print("{}", t);
      prints ``('a', 1, 2.0)``.
    * Changed formatting of octal zero with prefix from "0o0" to
      .. code:: c++
      fmt::print("{:#o}", 0);
      prints ``0``.
    * The locale is now passed to ostream insertion (``<<``)
      operators (#1406)
      .. code:: c++
      [#]include <fmt/locale.h>
      [#]include <fmt/ostream.h>
      struct S {
      double value;
      std::ostream& operator<<(std::ostream& os, S s) {
      return os << s.value;
      int main() {
      auto s = fmt::format(std::locale("fr_FR.UTF-8"), "{}", S{0.42});
      // s == "0,42"
    * Locale-specific number formatting now uses grouping (#1393,
    * Fixed handling of types with deleted implicit rvalue
      conversion to ``const char**`` (#1421)
      .. code:: c++
      struct mystring {
      operator const char*() const&;
      operator const char*() &;
      operator const char*() const&& = delete;
      operator const char*() && = delete;
      mystring str;
      fmt::print("{}", str); // now compiles
    * Enums are now mapped to correct underlying types instead of
      ``int`` (#1286)
    * Enum classes are no longer implicitly converted to ``int``
    * Added ``basic_format_parse_context`` for consistency with
      C++20 ``std::format`` and deprecated ``basic_parse_context``.
    * Fixed handling of UTF-8 in precision (#1389, #1390)
    * Added a CUDA test (#1285, #1317)
    * Improved documentation (#1276, #1291, #1296, #1315, #1332,
      [#1337], #1395, #1418)
    * Various code improvements (#1358, #1407)
    * Fixed compile-time format string checks for user-defined
      types (#1292)
    * Worked around a false positive in
      ``unsigned-integer-overflow`` sanitizer (#1377)
    * Fixed various warnings and compilation issues (#1273, #1278,
      [#1280], #1281, #1288, #1290, #1301, #1305, #1306, #1309,
      [#1312], #1313, #1316, #1319, #1320, #1326, #1328, #1344,
      [#1345], #1347, #1349, #1354, #1362, #1366, #1364, #1370,
      [#1371], #1385, #1388, #1397, #1414, #1416, #1422, #1427,
      [#1431], #1433)
  - Dropped fmt-bigendian_1.patch, fmt-bigendian_2.patch,
    fmt-bigendian_3.patch and fmt-bigendian_4.patch (merged
* Sun Dec 01 2019
  - Added fmt-bigendian_1.patch, fmt-bigendian_2.patch,
    fmt-bigendian_3.patch and fmt-bigendian_4.patch to fix tests
    on big endian targets
* Fri Nov 29 2019
  - Update to version 6.0.0
    (too many changes to list, see ChangeLog.rst)
  - Dropped 0001-install-pkg-config-file-into-libdir.patch (no
    longer necessary)
  - Switched to MIT license
  - Increased SOVERSION to 6
* Mon Mar 25 2019
  - Install fmt.pc into libdir with
* Sat Jan 12 2019
  - Update to version 5.3.0:
    * Introduced experimental chrono formatting support
    * Added experimental support for emphasis
    (bold, italic, underline, strikethrough), colored output to a
    file stream, and improved colored formatting API
    * Added support for 4-bit terminal colors
    * Made std::string_view work as a format string
    * Added wide string support to compile-time format string checks
    * Made colored print functions work with wide strings
    * Introduced experimental Unicode support
    * Removed undocumented basic_fixed_buffer which has been
    superseded by the iterator-based API
    * Disallowed repeated leading zeros in an argument ID
    * Deprecated fmt::visit, parse_context, and wparse_context.
    Use fmt::visit_format_arg, format_parse_context, and
    wformat_parse_context instead.
  - Removed upstream merged fix-fmt_pc.patch
* Thu Dec 06 2018
  - Do without em dashes in summaries.
* Thu Dec 06 2018
  - Added baselibs.conf as source
* Fri Nov 09 2018
  - initial package for version 5.2.1



Generated by rpm2html 1.8.1

Fabrice Bellet, Fri Feb 9 16:48:35 2024