Update version

By default the cmake files are installed to "<prefix>/lib/cmake/cppformat".
This can now be customized using the `FMT_CMAKE_DIR` cache variable.
Valid paths are documented in the cmake manual [1].

e.g., install the cmake files to "<prefix>/share/cmake/cppformat"
```
cmake -DFMT_CMAKE_DIR=share/cmake/cppformat <path-to-source>
```

Tip: Try `make package` to examine the result.

[1] https://cmake.org/cmake/help/v3.0/command/find_package.html

.gitignore

@@ -1,34 +1,18 @@
-.vscode/
-
-*.iml
-.idea/
-.externalNativeBuild/
-.gradle/
-gradle/
-gradlew*
-local.properties
-build/
-
 bin/
 /_CPack_Packages
-/CMakeScripts
 /doc/doxyxml
 /doc/html
-virtualenv
+/doc/virtualenv
 /Testing
 /install_manifest.txt
 *~
 *.a
 *.so*
-*.xcodeproj
 *.zip
 cmake_install.cmake
-CPack*.cmake
-fmt-*.cmake
+CPack*Config.cmake
 CTestTestfile.cmake
 CMakeCache.txt
 CMakeFiles
-FMT.build
 Makefile
 run-msbuild.bat
-fmt.pc

.travis.yml

@@ -1,128 +1,31 @@
 language: cpp
-dist: trusty
-sudo: false
-
-os: linux
-
-git:
-  depth: 1
 
+os:
+  - linux
+  - osx
 
 env:
   global:
     - secure: |-
-        a1eovNn4uol9won7ghr67eD3/59oeESN+G9bWE+ecI1V6yRseG9whniGhIpC/YfMW/Qz5I
-        5sxSmFjaw9bxCISNwUIrL1O5x2AmRYTnFcXk4dFsUvlZg+WeF/aKyBYCNRM8C2ndbBmtAO
-        o1F2EwFbiso0EmtzhAPs19ujiVxkLn4=
+        Gsnp9ERFnXt+diCfc7Vb72g+7HDn1MCHvw4zfUDdoBh9bxxFlLQRlzZZfwWhzni57lflrt
+        0QHXafu+oBVOJuNv6WauV3+ZyuWIQRmNGjZFNLvZsXHK/dyad2vGQBPvEkb+8l/aCyTpbr
+        6pxmyzLHSn1ZR7OX5rfPvwM3tOyZ3H0=
+  matrix:
+    - BUILD=Doc
+    - BUILD=Debug
+    - BUILD=Release
 
 matrix:
-  include:
-      # Documentation
-    - env: BUILD=Doc
-      sudo: required
-      # g++ 6 on Linux with C++14
-    - env: COMPILER=g++-6 BUILD=Debug STANDARD=14
-      compiler: gcc
-      addons:
-        apt:
-          update: true
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-    - env: COMPILER=g++-6 BUILD=Release STANDARD=14
-      compiler: gcc
-      addons:
-        apt:
-          update: true
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      # Apple clang on OS X with C++14
-    - env: BUILD=Debug STANDARD=14
-      compiler: clang
-      os: osx
-    - env: BUILD=Release STANDARD=14
-      compiler: clang
-      os: osx
-      # clang 6.0 on Linux with C++14
-    - env: COMPILER=clang++-6.0 BUILD=Debug STANDARD=14
-      compiler: clang
-      addons:
-        apt:
-          update: true
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty
-            - llvm-toolchain-trusty-6.0
-      # clang 4.0 on Linux with C++14
-    - env: COMPILER=clang++-4.0 BUILD=Debug STANDARD=11
-      compiler: clang
-      addons:
-        apt:
-          update: true
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty
-            - llvm-toolchain-trusty-4.0
-      # g++ 4.8 on Linux with C++11
-    - env: COMPILER=g++-4.8 BUILD=Debug STANDARD=11
-      compiler: gcc
-      # g++ 4.4 on Linux with C++11
-    - env: COMPILER=g++-4.4 BUILD=Debug STANDARD=11
-      compiler: gcc
-      addons:
-        apt:
-          update: true
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-      # Android
-    - language: android
-      addons:
-        apt:
-          update: true
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - wget
-            - unzip
-            - tree
-      android:
-        components:
-          - tools
-          - platform-tools
-          - android-21
-      env:
-        - ANDROID=true
-      before_install:
-        # Download/Install Gradle 
-        - wget https://services.gradle.org/distributions/gradle-4.10.2-bin.zip
-        - mkdir -p gradle
-        - unzip -q -d ./gradle gradle-4.10.2-bin.zip
-        - export GRADLE=gradle/gradle-4.10.2/bin/gradle
-        - bash $GRADLE --version
-      install:
-        # Accept SDK Licenses + Install NDK
-        - yes | sdkmanager --update > /dev/null 2>&1
-        - sdkmanager ndk-bundle > /dev/null 2>&1
-      before_script:
-        - pushd ./support
-      script:
-        - bash ../$GRADLE clean assemble
-      after_success:
-        - popd;
-        - tree ./libs
+  exclude:
+    - os: osx
+      env: BUILD=Doc
 
-before_script:
-  - if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then export CXX=${COMPILER}; fi
-  - if [[ "${BUILD}" != "Doc" ]]; then ${CXX} --version; fi
+addons:
+  apt:
+    sources:
+      - kubuntu-backports # cmake 2.8.12
+    packages:
+      - cmake
 
 script:
   - support/travis-build.py

Android.mk

@@ -1,10 +1,10 @@
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
-LOCAL_MODULE := fmt_static
-LOCAL_MODULE_FILENAME := libfmt
+LOCAL_MODULE := cppformat_static
+LOCAL_MODULE_FILENAME := libcppformat
 
-LOCAL_SRC_FILES := ../src/format.cc
+LOCAL_SRC_FILES := cppformat/format.cc
 
 LOCAL_C_INCLUDES := $(LOCAL_PATH)
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)

CMakeLists.txt

@@ -1,60 +1,40 @@
-cmake_minimum_required(VERSION 3.1.0)
+message(STATUS "CMake version: ${CMAKE_VERSION}")
 
-# Use newer policies if available, up to most recent tested version of CMake.
-if(${CMAKE_VERSION} VERSION_LESS 3.11)
-  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-  cmake_policy(VERSION 3.11)
-endif()
+cmake_minimum_required(VERSION 2.8.12)
 
-# Determine if fmt is built as a subproject (using add_subdirectory)
-# or if it is the master project.
+# determine if cppformat is built as sub project (using add_subdirectory)
+# or if it is the master project
 set(MASTER_PROJECT OFF)
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   set(MASTER_PROJECT ON)
-  message(STATUS "CMake version: ${CMAKE_VERSION}")
 endif ()
 
-# Joins arguments and places the results in ${result_var}.
-function(join result_var)
-  set(result )
-  foreach (arg ${ARGN})
-    set(result "${result}${arg}")
-  endforeach ()
-  set(${result_var} "${result}" PARENT_SCOPE)
-endfunction()
-
 # Set the default CMAKE_BUILD_TYPE to Release.
 # This should be done before the project command since the latter can set
 # CMAKE_BUILD_TYPE itself (it does so for nmake).
 if (NOT CMAKE_BUILD_TYPE)
-  join(doc "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
-           "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING ${doc})
+  set(CMAKE_BUILD_TYPE Release CACHE STRING
+    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
 endif ()
 
 option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
-option(FMT_WERROR "Halt the compilation with an error on compiler warnings." OFF)
 
 # Options that control generation of various targets.
 option(FMT_DOC "Generate the doc target." ${MASTER_PROJECT})
 option(FMT_INSTALL "Generate the install target." ${MASTER_PROJECT})
 option(FMT_TEST "Generate the test target." ${MASTER_PROJECT})
+option(FMT_USE_CPP11 "Enable the addition of C++11 compiler flags." ON)
 
-project(FMT)
+project(FORMAT)
 
-# Get version from core.h
-file(READ include/fmt/core.h core_h)
-if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
-  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
+# starting with cmake 3.0 VERSION is part of the project command
+set(CPPFORMAT_VERSION 2.1.1)
+if (NOT CPPFORMAT_VERSION MATCHES "^([0-9]+).([0-9]+).([0-9]+)$")
+  message(FATAL_ERROR "Invalid version format ${CPPFORMAT_VERSION}.")
 endif ()
-# Use math to skip leading zeros if any.
-math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
-math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
-math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
-join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
-                 ${CPACK_PACKAGE_VERSION_PATCH})
-message(STATUS "Version: ${FMT_VERSION}")
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
 
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 
@@ -63,53 +43,15 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
 
-include(cxx14)
-include(CheckCXXCompilerFlag)
+include(testCxx11)
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
-      -Wold-style-cast -Wundef
-      -Wredundant-decls -Wwrite-strings -Wpointer-arith
-      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
-      -Wcast-align -Wnon-virtual-dtor
-      -Wctor-dtor-privacy -Wdisabled-optimization
-      -Winvalid-pch -Woverloaded-virtual
-      -Wconversion
-      -Wno-ctor-dtor-privacy -Wno-format-nonliteral -Wno-shadow)
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wnoexcept
-         -Wno-dangling-else -Wno-unused-local-typedefs)
-  endif ()
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
-          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
-          -Wvector-operation-performance -Wsized-deallocation)
-  endif ()
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
-          -Wnull-dereference -Wduplicated-cond)
-  endif ()
-  set(WERROR_FLAG -Werror)
-endif ()
-
-if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wno-sign-conversion)
-  check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
-  if (HAS_NULLPTR_WARNING)
-    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
-        -Wzero-as-null-pointer-constant)
-  endif ()
-  set(WERROR_FLAG -Werror)
-endif ()
-
-if (MSVC)
-  set(PEDANTIC_COMPILE_FLAGS /W3)
-  set(WERROR_FLAG /WX)
+if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -Wshadow -pedantic)
 endif ()
 
 if (MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
   # If Microsoft SDK is installed create script run-msbuild.bat that
-  # calls SetEnv.cmd to set up build environment and runs msbuild.
+  # calls SetEnv.cmd to to set up build environment and runs msbuild.
   # It is useful when building Visual Studio projects with the SDK
   # toolchain rather than Visual Studio.
   include(FindSetEnv)
@@ -130,117 +72,7 @@ else ()
   check_symbol_exists(open fcntl.h HAVE_OPEN)
 endif ()
 
-function(add_headers VAR)
-  set(headers ${${VAR}})
-  foreach (header ${ARGN})
-    set(headers ${headers} include/fmt/${header})
-  endforeach()
-  set(${VAR} ${headers} PARENT_SCOPE)
-endfunction()
-
-# Define the fmt library, its includes and the needed defines.
-add_headers(FMT_HEADERS chrono.h color.h core.h format.h format-inl.h locale.h
-                        ostream.h printf.h time.h ranges.h)
-set(FMT_SOURCES src/format.cc)
-if (HAVE_OPEN)
-  add_headers(FMT_HEADERS posix.h)
-  set(FMT_SOURCES ${FMT_SOURCES} src/posix.cc)
-endif ()
-
-add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS} README.rst ChangeLog.rst)
-add_library(fmt::fmt ALIAS fmt)
-
-if (FMT_WERROR)
-  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
-endif ()
-if (FMT_PEDANTIC)
-  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-endif ()
-
-target_include_directories(fmt PUBLIC
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-  $<INSTALL_INTERFACE:include>)
-
-set_target_properties(fmt PROPERTIES
-  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
-  DEBUG_POSTFIX d)
-
-if (BUILD_SHARED_LIBS)
-  if (UNIX AND NOT APPLE)
-    # Fix rpmlint warning:
-    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
-    target_link_libraries(fmt -Wl,--as-needed)
-  endif ()
-  target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
-endif ()
-
-add_library(fmt-header-only INTERFACE)
-add_library(fmt::fmt-header-only ALIAS fmt-header-only)
-
-target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
-
-target_include_directories(fmt-header-only INTERFACE
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-  $<INSTALL_INTERFACE:include>)
-
-# Install targets.
-if (FMT_INSTALL)
-  include(GNUInstallDirs)
-  include(CMakePackageConfigHelpers)
-  set(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
-    "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
-  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
-  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
-  set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
-  set(targets_export_name fmt-targets)
-
-  set (INSTALL_TARGETS fmt)
-  if (TARGET fmt-header-only)
-    set(INSTALL_TARGETS ${INSTALL_TARGETS} fmt-header-only)
-  endif ()
-
-  set(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
-      "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-  set(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/fmt CACHE STRING
-      "Installation directory for include files, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-  set(FMT_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH
-    "Installation directory for pkgconfig (.pc) files, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-  # Generate the version, config and target files into the build directory.
-  write_basic_package_version_file(
-    ${version_config}
-    VERSION ${FMT_VERSION}
-    COMPATIBILITY AnyNewerVersion)
-  configure_file(
-    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
-    "${pkgconfig}"
-    @ONLY)
-  configure_package_config_file(
-    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
-    ${project_config}
-    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
-  # Use a namespace because CMake provides better diagnostics for namespaced
-  # imported targets.
-  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
-         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
-
-  # Install version, config and target files.
-  install(
-    FILES ${project_config} ${version_config}
-    DESTINATION ${FMT_CMAKE_DIR})
-  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
-          NAMESPACE fmt::)
-
-  # Install the library and headers.
-  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
-          DESTINATION ${FMT_LIB_DIR})
-
-  install(FILES $<TARGET_PDB_FILE:${INSTALL_TARGETS}> DESTINATION ${FMT_LIB_DIR} OPTIONAL)
-  install(FILES ${FMT_HEADERS} DESTINATION ${FMT_INC_DIR})
-  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
-endif ()
+add_subdirectory(cppformat)
 
 if (FMT_DOC)
   add_subdirectory(doc)
@@ -266,8 +98,8 @@ if (MASTER_PROJECT AND EXISTS ${gitignore})
 
   set(CPACK_SOURCE_GENERATOR ZIP)
   set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
-  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
-  set(CPACK_PACKAGE_NAME fmt)
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME cppformat-${CPPFORMAT_VERSION})
+  set(CPACK_PACKAGE_NAME cppformat)
   set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.rst)
   include(CPack)
 endif ()

CONTRIBUTING.rst

@@ -1,12 +0,0 @@
-Contributing to fmt
-===================
-
-All C++ code must adhere to `Google C++ Style Guide
-<https://google.github.io/styleguide/cppguide.html>`_ with the following
-exceptions:
-
-* Exceptions are permitted
-* snake_case should be used instead of UpperCamelCase for function and type
-  names
-
-Thanks for contributing!

LICENSE.rst

@@ -1,4 +1,4 @@
-Copyright (c) 2012 - 2016, Victor Zverovich
+Copyright (c) 2012 - 2015, Victor Zverovich
 
 All rights reserved.
 

README.rst

@@ -1,62 +1,62 @@
-{fmt}
-=====
+C++ Format
+==========
 
-.. image:: https://travis-ci.org/fmtlib/fmt.png?branch=master
-   :target: https://travis-ci.org/fmtlib/fmt
+.. image:: https://travis-ci.org/cppformat/cppformat.png?branch=master
+   :target: https://travis-ci.org/cppformat/cppformat
 
-.. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v
-   :target: https://ci.appveyor.com/project/vitaut/fmt
+.. image:: https://ci.appveyor.com/api/projects/status/qk0bhyhqp1ekpat8
+   :target: https://ci.appveyor.com/project/vitaut/cppformat
    
 .. image:: https://badges.gitter.im/Join%20Chat.svg
-   :alt: Join the chat at https://gitter.im/fmtlib/fmt
-   :target: https://gitter.im/fmtlib/fmt
+   :alt: Join the chat at https://gitter.im/cppformat/cppformat
+   :target: https://gitter.im/cppformat/cppformat?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
-**{fmt}** is an open-source formatting library for C++.
-It can be used as a safe and fast alternative to (s)printf and IOStreams.
+C++ Format is an open-source formatting library for C++.
+It can be used as a safe alternative to printf or as a fast
+alternative to IOStreams.
 
-`Documentation <http://fmtlib.net/latest/>`__
-
-This is a development branch that implements the C++ standards proposal `P0645
-Text Formatting <http://fmtlib.net/Text%20Formatting.html>`__.
-Released versions are available from the `Releases page
-<https://github.com/fmtlib/fmt/releases>`__.
+`Documentation <http://cppformat.github.io/latest/>`_
 
 Features
 --------
 
-* Replacement-based `format API <http://fmtlib.net/dev/api.html>`_ with
-  positional arguments for localization.
-* `Format string syntax <http://fmtlib.net/dev/syntax.html>`_ similar to the one
-  of `str.format <https://docs.python.org/2/library/stdtypes.html#str.format>`_
-  in Python.
+* Two APIs: faster concatenation-based write API and slower (but still
+  very fast) replacement-based format API with positional arguments for
+  localization.
+* Write API similar to the one used by IOStreams but stateless allowing
+  faster implementation.
+* Format API with `format string syntax
+  <http://cppformat.github.io/latest/syntax.html>`_
+  similar to the one used by `str.format
+  <https://docs.python.org/2/library/stdtypes.html#str.format>`_ in Python.
 * Safe `printf implementation
-  <http://fmtlib.net/latest/api.html#printf-formatting>`_ including
-  the POSIX extension for positional arguments.
+  <http://cppformat.github.io/latest/api.html#printf-formatting-functions>`_
+  including the POSIX extension for positional arguments.
 * Support for user-defined types.
-* High speed: performance of the format API is close to that of glibc's `printf
-  <http://en.cppreference.com/w/cpp/io/c/fprintf>`_ and better than the
-  performance of IOStreams. See `Speed tests`_ and
+* High speed: performance of the format API is close to that of
+  glibc's `printf <http://en.cppreference.com/w/cpp/io/c/fprintf>`_
+  and better than performance of IOStreams. See `Speed tests`_ and
   `Fast integer to string conversion in C++
   <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
-* Small code size both in terms of source code (the minimum configuration
-  consists of just three header files, ``core.h``, ``format.h`` and
-  ``format-inl.h``) and compiled code. See `Compile time and code bloat`_.
+* Small code size both in terms of source code (format consists of a single
+  header file and a single source file) and compiled code.
+  See `Compile time and code bloat`_.
 * Reliability: the library has an extensive set of `unit tests
-  <https://github.com/fmtlib/fmt/tree/master/test>`_.
-* Safety: the library is fully type safe, errors in format strings can be
-  reported at compile time, automatic memory management prevents buffer overflow
-  errors.
+  <https://github.com/cppformat/cppformat/tree/master/test>`_.
+* Safety: the library is fully type safe, errors in format strings are
+  reported using exceptions, automatic memory management prevents buffer
+  overflow errors.
 * Ease of use: small self-contained code base, no external dependencies,
   permissive BSD `license
-  <https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_
-* `Portability <http://fmtlib.net/latest/index.html#portability>`_ with
-  consistent output across platforms and support for older compilers.
+  <https://github.com/cppformat/cppformat/blob/master/LICENSE.rst>`_
+* `Portability <http://cppformat.github.io#portability>`_ with consistent output
+  across platforms and support for older compilers.
 * Clean warning-free codebase even on high warning levels
-  (``-Wall -Wextra -pedantic``).
+  (-Wall -Wextra -pedantic).
 * Support for wide strings.
 * Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro.
 
-See the `documentation <http://fmtlib.net/latest/>`_ for more details.
+See the `documentation <http://cppformat.github.io/latest/>`_ for more details.
 
 Examples
 --------
@@ -75,144 +75,78 @@ Arguments can be accessed by position and arguments' indices can be repeated:
     std::string s = fmt::format("{0}{1}{0}", "abra", "cad");
     // s == "abracadabra"
 
-Format strings can be checked at compile time:
+C++ Format can be used as a safe portable replacement for ``itoa``:
 
 .. code:: c++
 
-    // test.cc
-    #define FMT_STRING_ALIAS 1
-    #include <fmt/format.h>
-    std::string s = format(fmt("{2}"), 42);
+    fmt::MemoryWriter w;
+    w << 42;           // replaces itoa(42, buffer, 10)
+    w << fmt::hex(42); // replaces itoa(42, buffer, 16)
+    // access the string using w.str() or w.c_str()
 
-.. code::
-
-    $ c++ -Iinclude -std=c++14 test.cc
-    ...
-    test.cc:4:17: note: in instantiation of function template specialization 'fmt::v5::format<S, int>' requested here
-    std::string s = format(fmt("{2}"), 42);
-                    ^
-    include/fmt/core.h:778:19: note: non-constexpr function 'on_error' cannot be used in a constant expression
-        ErrorHandler::on_error(message);
-                      ^
-    include/fmt/format.h:2226:16: note: in call to '&checker.context_->on_error(&"argument index out of range"[0])'
-          context_.on_error("argument index out of range");
-                   ^
-
-{fmt} can be used as a safe portable replacement for ``itoa``
-(`godbolt <https://godbolt.org/g/NXmpU4>`_):
+An object of any user-defined type for which there is an overloaded
+:code:`std::ostream` insertion operator (``operator<<``) can be formatted:
 
 .. code:: c++
 
-    fmt::memory_buffer buf;
-    format_to(buf, "{}", 42);    // replaces itoa(42, buffer, 10)
-    format_to(buf, "{:x}", 42);  // replaces itoa(42, buffer, 16)
-    // access the string using to_string(buf) or buf.data()
+    class Date {
+      int year_, month_, day_;
+     public:
+      Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
 
-Formatting of user-defined types is supported via a simple
-`extension API <http://fmtlib.net/latest/api.html#formatting-user-defined-types>`_:
-
-.. code:: c++
-
-    #include "fmt/format.h"
-
-    struct date {
-      int year, month, day;
-    };
-
-    template <>
-    struct fmt::formatter<date> {
-      template <typename ParseContext>
-      constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
-
-      template <typename FormatContext>
-      auto format(const date &d, FormatContext &ctx) {
-        return format_to(ctx.out(), "{}-{}-{}", d.year, d.month, d.day);
+      friend std::ostream &operator<<(std::ostream &os, const Date &d) {
+        return os << d.year_ << '-' << d.month_ << '-' << d.day_;
       }
     };
 
-    std::string s = fmt::format("The date is {}", date{2012, 12, 9});
+    std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
     // s == "The date is 2012-12-9"
 
-You can create your own functions similar to `format
-<http://fmtlib.net/latest/api.html#format>`_ and
-`print <http://fmtlib.net/latest/api.html#print>`_
-which take arbitrary arguments (`godbolt <https://godbolt.org/g/MHjHVf>`_):
+You can use the `FMT_VARIADIC
+<http://cppformat.github.io/latest/api.html#utilities>`_
+macro to create your own functions similar to `format
+<http://cppformat.github.io/latest/api.html#format>`_ and
+`print <http://cppformat.github.io/latest/api.html#print>`_
+which take arbitrary arguments:
 
 .. code:: c++
 
     // Prints formatted error message.
-    void vreport_error(const char *format, fmt::format_args args) {
+    void report_error(const char *format, fmt::ArgList args) {
       fmt::print("Error: ");
-      fmt::vprint(format, args);
-    }
-    template <typename... Args>
-    void report_error(const char *format, const Args & ... args) {
-      vreport_error(format, fmt::make_format_args(args...));
+      fmt::print(format, args);
     }
+    FMT_VARIADIC(void, report_error, const char *)
 
     report_error("file not found: {}", path);
 
-Note that ``vreport_error`` is not parameterized on argument types which can
-improve compile times and reduce code size compared to fully parameterized
-version.
+Note that you only need to define one function that takes ``fmt::ArgList``
+argument. ``FMT_VARIADIC`` automatically defines necessary wrappers that
+accept variable number of arguments.
 
 Projects using this library
 ---------------------------
 
-* `0 A.D. <http://play0ad.com/>`_: A free, open-source, cross-platform real-time
-  strategy game
+* `0 A.D. <http://play0ad.com/>`_: A free, open-source, cross-platform real-time strategy game
 
 * `AMPL/MP <https://github.com/ampl/mp>`_:
   An open-source library for mathematical programming
-  
-* `AvioBook <https://www.aviobook.aero/en>`_: A comprehensive aircraft
-  operations suite
-  
-* `Celestia <https://celestia.space/>`_: Real-time 3D visualization of space
-
-* `Ceph <https://ceph.com/>`_: A scalable distributed storage system
-
-* `CUAUV <http://cuauv.org/>`_: Cornell University's autonomous underwater
-  vehicle
 
 * `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_:
   Player vs Player Gaming Network with tweaks
 
 * `KBEngine <http://kbengine.org/>`_: An open-source MMOG server engine
 
-* `Keypirinha <http://keypirinha.com/>`_: A semantic launcher for Windows
-
-* `Kodi <https://kodi.tv/>`_ (formerly xbmc): Home theater software
-
 * `Lifeline <https://github.com/peter-clark/lifeline>`_: A 2D game
 
-* `Drake <http://drake.mit.edu/>`_: A planning, control, and analysis toolbox
-  for nonlinear dynamical systems (MIT)
-
-* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus
-  (Lyft)
-
-* `FiveM <https://fivem.net/>`_: a modification framework for GTA V
-
-* `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: A small tool to
-  generate randomized datasets
-
-* `OpenSpace <http://openspaceproject.com/>`_: An open-source astrovisualization
-  framework
-
 * `PenUltima Online (POL) <http://www.polserver.com/>`_:
   An MMO server, compatible with most Ultima Online clients
 
-* `quasardb <https://www.quasardb.net/>`_: A distributed, high-performance,
-  associative database
+* `quasardb <https://www.quasardb.net/>`_: A distributed, high-performance, associative database
 
 * `readpe <https://bitbucket.org/sys_dev/readpe>`_: Read Portable Executable
 
-* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: A Redis cluster
-  proxy
-
-* `rpclib <http://rpclib.net/>`_: A modern C++ msgpack-RPC server and client
-  library
+* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: A Redis cluster proxy
 
 * `Saddy <https://github.com/mamontov-cpp/saddy-graphics-engine-2d>`_:
   Small crossplatform 2D graphic engine
@@ -220,26 +154,19 @@ Projects using this library
 * `Salesforce Analytics Cloud <http://www.salesforce.com/analytics-cloud/overview/>`_:
   Business intelligence software
 
-* `Scylla <http://www.scylladb.com/>`_: A Cassandra-compatible NoSQL data store
-  that can handle 1 million transactions per second on a single server
-
-* `Seastar <http://www.seastar-project.org/>`_: An advanced, open-source C++
-  framework for high-performance server applications on modern hardware
-
 * `spdlog <https://github.com/gabime/spdlog>`_: Super fast C++ logging library
 
 * `Stellar <https://www.stellar.org/>`_: Financial platform
 
 * `Touch Surgery <https://www.touchsurgery.com/>`_: Surgery simulator
 
-* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: Open-source
-  MMORPG framework
+* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: Open-source MMORPG framework
 
 `More... <https://github.com/search?q=cppformat&type=Code>`_
 
 If you are aware of other projects using this library, please let me know
 by `email <mailto:victor.zverovich@gmail.com>`_ or by submitting an
-`issue <https://github.com/fmtlib/fmt/issues>`_.
+`issue <https://github.com/cppformat/cppformat/issues>`_.
 
 Motivation
 ----------
@@ -291,7 +218,7 @@ Boost Format library
 ~~~~~~~~~~~~~~~~~~~~
 
 This is a very powerful library which supports both printf-like format
-strings and positional arguments. Its main drawback is performance.
+strings and positional arguments. The main its drawback is performance.
 According to various benchmarks it is much slower than other methods
 considered here. Boost Format also has excessive build times and severe
 code bloat issues (see `Benchmarks`_).
@@ -350,24 +277,23 @@ The following speed tests results were generated by building
 runs.  In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"`` or
 equivalent is filled 2000000 times with output sent to ``/dev/null``; for
 further details see the `source
-<https://github.com/fmtlib/format-benchmark/blob/master/tinyformat_test.cpp>`_.
+<https://github.com/cppformat/format-benchmark/blob/master/tinyformat_test.cpp>`_.
 
 ================= ============= ===========
 Library           Method        Run Time, s
 ================= ============= ===========
-libc              printf          1.35
-libc++            std::ostream    3.42
-fmt 534bff7       fmt::print      1.56
-tinyformat 2.0.1  tfm::printf     3.73
-Boost Format 1.54 boost::format   8.44
-Folly Format      folly::format   2.54
+EGLIBC 2.19       printf          1.30
+libstdc++ 4.8.2   std::ostream    1.85
+C++ Format 1.0    fmt::print      1.42
+tinyformat 2.0.1  tfm::printf     2.25
+Boost Format 1.54 boost::format   9.94
 ================= ============= ===========
 
 As you can see ``boost::format`` is much slower than the alternative methods; this
 is confirmed by `other tests <http://accu.org/index.php/journals/1539>`_.
 Tinyformat is quite good coming close to IOStreams.  Unfortunately tinyformat
 cannot be faster than the IOStreams because it uses them internally.
-Performance of fmt is close to that of printf, being `faster than printf on integer
+Performance of cppformat is close to that of printf, being `faster than printf on integer
 formatting <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_,
 but slower on floating-point formatting which dominates this benchmark.
 
@@ -375,50 +301,43 @@ Compile time and code bloat
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The script `bloat-test.py
-<https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py>`_
-from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_
+<https://github.com/cppformat/format-benchmark/blob/master/bloat-test.py>`_
+from `format-benchmark <https://github.com/cppformat/format-benchmark>`_
 tests compile time and code bloat for nontrivial projects.
 It generates 100 translation units and uses ``printf()`` or its alternative
 five times in each to simulate a medium sized project.  The resulting
-executable size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42),
-macOS Sierra, best of three) is shown in the following tables.
+executable size and compile time (g++-4.8.1, Ubuntu GNU/Linux 13.10,
+best of three) is shown in the following tables.
 
 **Optimized build (-O3)**
 
-============= =============== ==================== ==================
-Method        Compile Time, s Executable size, KiB Stripped size, KiB
-============= =============== ==================== ==================
-printf                    2.6                   29                 26
-printf+string            16.4                   29                 26
-IOStreams                31.1                   59                 55
-fmt                      19.0                   37                 34
-tinyformat               44.0                  103                 97
-Boost Format             91.9                  226                203
-Folly Format            115.7                  101                 88
-============= =============== ==================== ==================
+============ =============== ==================== ==================
+Method       Compile Time, s Executable size, KiB Stripped size, KiB
+============ =============== ==================== ==================
+printf                   2.6                   41                 30
+IOStreams               19.4                   92                 70
+C++ Format              46.8                   46                 34
+tinyformat              64.6                  418                386
+Boost Format           222.8                  990                923
+============ =============== ==================== ==================
 
-As you can see, fmt has 60% less overhead in terms of resulting binary code
-size compared to IOStreams and comes pretty close to ``printf``. Boost Format
-and Folly Format have the largest overheads.
-
-``printf+string`` is the same as ``printf`` but with extra ``<string>``
-include to measure the overhead of the latter.
+As you can see, C++ Format has two times less overhead in terms of resulting
+code size compared to IOStreams and comes pretty close to ``printf``.
+Boost Format has by far the largest overheads.
 
 **Non-optimized build**
 
-============= =============== ==================== ==================
-Method        Compile Time, s Executable size, KiB Stripped size, KiB
-============= =============== ==================== ==================
-printf                    2.2                   33                 30
-printf+string            16.0                   33                 30
-IOStreams                28.3                   56                 52
-fmt                      18.2                   59                 50
-tinyformat               32.6                   88                 82
-Boost Format             54.1                  365                303
-Folly Format             79.9                  445                430
-============= =============== ==================== ==================
+============ =============== ==================== ==================
+Method       Compile Time, s Executable size, KiB Stripped size, KiB
+============ =============== ==================== ==================
+printf                   2.1                   41                 30
+IOStreams               19.7                   86                 62
+C++ Format              47.9                  108                 86
+tinyformat              27.7                  234                190
+Boost Format           122.6                  884                763
+============ =============== ==================== ==================
 
-``libc``, ``lib(std)c++`` and ``libfmt`` are all linked as shared
+``libc``, ``libstdc++`` and ``libformat`` are all linked as shared
 libraries to compare formatting function overhead only. Boost Format
 and tinyformat are header-only libraries so they don't provide any
 linkage options.
@@ -429,14 +348,14 @@ Running the tests
 Please refer to `Building the library`__ for the instructions on how to build
 the library and run the unit tests.
 
-__ http://fmtlib.net/latest/usage.html#building-the-library
+__ http://cppformat.github.io/latest/usage.html#building-the-library
 
 Benchmarks reside in a separate repository,
-`format-benchmarks <https://github.com/fmtlib/format-benchmark>`_,
+`format-benchmarks <https://github.com/cppformat/format-benchmark>`_,
 so to run the benchmarks you first need to clone this repository and
 generate Makefiles with CMake::
 
-    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
+    $ git clone --recursive https://github.com/cppformat/format-benchmark.git
     $ cd format-benchmark
     $ cmake .
 
@@ -448,56 +367,30 @@ or the bloat test::
 
     $ make bloat-test
 
-FAQ
----
-
-Q: how can I capture formatting arguments and format them later?
-
-A: use ``std::tuple``:
-
-.. code:: c++
-
-   template <typename... Args>
-   auto capture(const Args&... args) {
-     return std::make_tuple(args...);
-   }
-
-   auto print_message = [](const auto&... args) {
-     fmt::print(args...);
-   };
-
-   // Capture and store arguments:
-   auto args = capture("{} {}", 42, "foo");
-   // Do formatting:
-   std::apply(print_message, args);
-
 License
 -------
 
-fmt is distributed under the BSD `license
-<https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_.
+C++ Format is distributed under the BSD `license
+<https://github.com/cppformat/cppformat/blob/master/LICENSE.rst>`_.
 
 The `Format String Syntax
-<http://fmtlib.net/latest/syntax.html>`_
+<http://cppformat.github.io/latest/syntax.html>`_
 section in the documentation is based on the one from Python `string module
 documentation <https://docs.python.org/3/library/string.html#module-string>`_
 adapted for the current library. For this reason the documentation is
 distributed under the Python Software Foundation license available in
 `doc/python-license.txt
-<https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_.
-It only applies if you distribute the documentation of fmt.
+<https://raw.github.com/cppformat/cppformat/master/doc/python-license.txt>`_.
+It only applies if you distribute the documentation of C++ Format.
+
+Links
+-----
+
+`API changes/compatibility report <http://upstream-tracker.org/versions/cppformat.html>`_
 
 Acknowledgments
 ---------------
 
-The fmt library is maintained by Victor Zverovich (`vitaut
-<https://github.com/vitaut>`_) and Jonathan Müller (`foonathan
-<https://github.com/foonathan>`_) with contributions from many other people.
-See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and
-`Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names.
-Let us know if your contribution is not listed or mentioned incorrectly and
-we'll make it right.
-
 The benchmark section of this readme file and the performance tests are taken
 from the excellent `tinyformat <https://github.com/c42f/tinyformat>`_ library
 written by Chris Foster.  Boost Format library is acknowledged transitively
@@ -516,4 +409,4 @@ formatting. Thanks `Ruslan Baratov <https://github.com/ruslo>`_ for comprehensiv
 and useful comments regarding performance, `Boris Kaul <https://github.com/localvoid>`_ for
 `C++ counting digits benchmark <https://github.com/localvoid/cxx-benchmark-count-digits>`_.
 Thanks to `CarterLi <https://github.com/CarterLi>`_ for contributing various
-improvements to the code.
+improvements to the code.

cppformat/CMakeLists.txt

@@ -0,0 +1,82 @@
+# Define the cppformat library, its includes and the needed defines.
+# format.cc is added to FMT_HEADERS for the header-only configuration.
+set(FMT_HEADERS format.h format.cc)
+if (HAVE_OPEN)
+  set(FMT_HEADERS ${FMT_HEADERS} posix.h)
+  set(FMT_SOURCES ${FMT_SOURCES} posix.cc)
+endif ()
+
+add_library(cppformat ${FMT_SOURCES} ${FMT_HEADERS})
+
+# Starting with cmake 3.1 the CXX_STANDARD property can be used instead.
+target_compile_options(cppformat PUBLIC ${CPP11_FLAG})
+if (FMT_PEDANTIC)
+  target_compile_options(cppformat PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+endif ()
+
+target_include_directories(cppformat INTERFACE
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+  $<INSTALL_INTERFACE:include>)
+
+set_target_properties(cppformat PROPERTIES
+  VERSION ${CPPFORMAT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR})
+
+if (BUILD_SHARED_LIBS)
+  if (UNIX AND NOT APPLE)
+    # Fix rpmlint warning:
+    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
+    target_link_libraries(cppformat -Wl,--as-needed)
+  endif ()
+  target_compile_definitions(cppformat PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
+endif ()
+
+#------------------------------------------------------------------------------
+# additionally define a header only library when cmake is new enough
+if (CMAKE_VERSION VERSION_GREATER 3.1.0 OR CMAKE_VERSION VERSION_EQUAL 3.1.0)
+  add_library(cppformat-header-only INTERFACE)
+
+  target_compile_definitions(cppformat-header-only INTERFACE FMT_HEADER_ONLY=1)
+
+  target_include_directories(cppformat-header-only INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>)
+endif ()
+
+# Install targets.
+if (FMT_INSTALL)
+  include(CMakePackageConfigHelpers)
+  set(FMT_CMAKE_DIR lib/cmake/cppformat CACHE STRING
+    "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
+  set(version_config ${PROJECT_BINARY_DIR}/cppformat-config-version.cmake)
+  set(project_config ${PROJECT_BINARY_DIR}/cppformat-config.cmake)
+  set(targets_export_name cppformat-targets)
+
+  set (INSTALL_TARGETS cppformat)
+  if (TARGET cppformat-header-only)
+    set(INSTALL_TARGETS ${INSTALL_TARGETS} cppformat-header-only)
+  endif ()
+
+  set(FMT_LIB_DIR lib CACHE STRING
+    "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.")
+
+  # Generate the version, config and target files into the build directory.
+  write_basic_package_version_file(
+    ${version_config}
+    VERSION ${CPPFORMAT_VERSION}
+    COMPATIBILITY AnyNewerVersion)
+  configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/support/cmake/cppformat-config.cmake.in
+    ${project_config}
+    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
+  export(TARGETS ${INSTALL_TARGETS} FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+
+  # Install version, config and target files.
+  install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${FMT_CMAKE_DIR})
+  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR})
+
+  # Install the library and headers.
+  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name} DESTINATION ${FMT_LIB_DIR})
+  install(FILES ${FMT_HEADERS} DESTINATION include/cppformat)
+endif ()

cppformat/posix.cc

@@ -1,16 +1,36 @@
-// A C++ interface to POSIX functions.
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ A C++ interface to POSIX functions.
+
+ Copyright (c) 2014 - 2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 // Disable bogus MSVC warnings.
-#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#ifndef _CRT_SECURE_NO_WARNINGS
 # define _CRT_SECURE_NO_WARNINGS
 #endif
 
-#include "fmt/posix.h"
+#include "posix.h"
 
 #include <limits.h>
 #include <sys/types.h>
@@ -19,9 +39,6 @@
 #ifndef _WIN32
 # include <unistd.h>
 #else
-# ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-# endif
 # include <windows.h>
 # include <io.h>
 
@@ -64,40 +81,38 @@ inline std::size_t convert_rwcount(std::size_t count) { return count; }
 #endif
 }
 
-FMT_BEGIN_NAMESPACE
-
-buffered_file::~buffered_file() FMT_NOEXCEPT {
+fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
   if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
-    report_system_error(errno, "cannot close file");
+    fmt::report_system_error(errno, "cannot close file");
 }
 
-buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
-  FMT_RETRY_VAL(file_,
-                FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), FMT_NULL);
+fmt::BufferedFile::BufferedFile(
+    fmt::CStringRef filename, fmt::CStringRef mode) {
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
   if (!file_)
-    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+    throw SystemError(errno, "cannot open file {}", filename);
 }
 
-void buffered_file::close() {
+void fmt::BufferedFile::close() {
   if (!file_)
     return;
   int result = FMT_SYSTEM(fclose(file_));
-  file_ = FMT_NULL;
+  file_ = 0;
   if (result != 0)
-    FMT_THROW(system_error(errno, "cannot close file"));
+    throw SystemError(errno, "cannot close file");
 }
 
 // A macro used to prevent expansion of fileno on broken versions of MinGW.
 #define FMT_ARGS
 
-int buffered_file::fileno() const {
+int fmt::BufferedFile::fileno() const {
   int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
   if (fd == -1)
-    FMT_THROW(system_error(errno, "cannot get file descriptor"));
+    throw SystemError(errno, "cannot get file descriptor");
   return fd;
 }
 
-file::file(cstring_view path, int oflag) {
+fmt::File::File(fmt::CStringRef path, int oflag) {
   int mode = S_IRUSR | S_IWUSR;
 #if defined(_WIN32) && !defined(__MINGW32__)
   fd_ = -1;
@@ -106,17 +121,17 @@ file::file(cstring_view path, int oflag) {
   FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
 #endif
   if (fd_ == -1)
-    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
+    throw SystemError(errno, "cannot open file {}", path);
 }
 
-file::~file() FMT_NOEXCEPT {
+fmt::File::~File() FMT_NOEXCEPT {
   // Don't retry close in case of EINTR!
   // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
   if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
-    report_system_error(errno, "cannot close file");
+    fmt::report_system_error(errno, "cannot close file");
 }
 
-void file::close() {
+void fmt::File::close() {
   if (fd_ == -1)
     return;
   // Don't retry close in case of EINTR!
@@ -124,10 +139,10 @@ void file::close() {
   int result = FMT_POSIX_CALL(close(fd_));
   fd_ = -1;
   if (result != 0)
-    FMT_THROW(system_error(errno, "cannot close file"));
+    throw SystemError(errno, "cannot close file");
 }
 
-long long file::size() const {
+fmt::LongLong fmt::File::size() const {
 #ifdef _WIN32
   // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
   // is less than 0x0500 as is the case with some default MinGW builds.
@@ -138,63 +153,63 @@ long long file::size() const {
   if (size_lower == INVALID_FILE_SIZE) {
     DWORD error = GetLastError();
     if (error != NO_ERROR)
-      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
+      throw WindowsError(GetLastError(), "cannot get file size");
   }
-  unsigned long long long_size = size_upper;
+  fmt::ULongLong long_size = size_upper;
   return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
 #else
   typedef struct stat Stat;
   Stat file_stat = Stat();
   if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
-    FMT_THROW(system_error(errno, "cannot get file attributes"));
-  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
-      "return type of file::size is not large enough");
+    throw SystemError(errno, "cannot get file attributes");
+  FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size),
+      "return type of File::size is not large enough");
   return file_stat.st_size;
 #endif
 }
 
-std::size_t file::read(void *buffer, std::size_t count) {
+std::size_t fmt::File::read(void *buffer, std::size_t count) {
   RWResult result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
   if (result < 0)
-    FMT_THROW(system_error(errno, "cannot read from file"));
-  return internal::to_unsigned(result);
+    throw SystemError(errno, "cannot read from file");
+  return result;
 }
 
-std::size_t file::write(const void *buffer, std::size_t count) {
+std::size_t fmt::File::write(const void *buffer, std::size_t count) {
   RWResult result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
   if (result < 0)
-    FMT_THROW(system_error(errno, "cannot write to file"));
-  return internal::to_unsigned(result);
+    throw SystemError(errno, "cannot write to file");
+  return result;
 }
 
-file file::dup(int fd) {
+fmt::File fmt::File::dup(int fd) {
   // Don't retry as dup doesn't return EINTR.
   // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
   int new_fd = FMT_POSIX_CALL(dup(fd));
   if (new_fd == -1)
-    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
-  return file(new_fd);
+    throw SystemError(errno, "cannot duplicate file descriptor {}", fd);
+  return File(new_fd);
 }
 
-void file::dup2(int fd) {
+void fmt::File::dup2(int fd) {
   int result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
   if (result == -1) {
-    FMT_THROW(system_error(errno,
-      "cannot duplicate file descriptor {} to {}", fd_, fd));
+    throw SystemError(errno,
+      "cannot duplicate file descriptor {} to {}", fd_, fd);
   }
 }
 
-void file::dup2(int fd, error_code &ec) FMT_NOEXCEPT {
+void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT {
   int result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
   if (result == -1)
-    ec = error_code(errno);
+    ec = ErrorCode(errno);
 }
 
-void file::pipe(file &read_end, file &write_end) {
+void fmt::File::pipe(File &read_end, File &write_end) {
   // Close the descriptors first to make sure that assignments don't throw
   // and there are no leaks.
   read_end.close();
@@ -210,25 +225,24 @@ void file::pipe(file &read_end, file &write_end) {
   int result = FMT_POSIX_CALL(pipe(fds));
 #endif
   if (result != 0)
-    FMT_THROW(system_error(errno, "cannot create pipe"));
+    throw SystemError(errno, "cannot create pipe");
   // The following assignments don't throw because read_fd and write_fd
   // are closed.
-  read_end = file(fds[0]);
-  write_end = file(fds[1]);
+  read_end = File(fds[0]);
+  write_end = File(fds[1]);
 }
 
-buffered_file file::fdopen(const char *mode) {
+fmt::BufferedFile fmt::File::fdopen(const char *mode) {
   // Don't retry as fdopen doesn't return EINTR.
   FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
   if (!f)
-    FMT_THROW(system_error(errno,
-                           "cannot associate stream with file descriptor"));
-  buffered_file bf(f);
+    throw SystemError(errno, "cannot associate stream with file descriptor");
+  BufferedFile file(f);
   fd_ = -1;
-  return bf;
+  return file;
 }
 
-long getpagesize() {
+long fmt::getpagesize() {
 #ifdef _WIN32
   SYSTEM_INFO si;
   GetSystemInfo(&si);
@@ -236,9 +250,7 @@ long getpagesize() {
 #else
   long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
   if (size < 0)
-    FMT_THROW(system_error(errno, "cannot get memory page size"));
+    throw SystemError(errno, "cannot get memory page size");
   return size;
 #endif
 }
-FMT_END_NAMESPACE
-

cppformat/posix.h

@@ -0,0 +1,344 @@
+/*
+ A C++ interface to POSIX functions.
+
+ Copyright (c) 2014 - 2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FMT_POSIX_H_
+#define FMT_POSIX_H_
+
+#ifdef __MINGW32__
+// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
+# undef __STRICT_ANSI__
+#endif
+
+#include <errno.h>
+#include <fcntl.h>  // for O_RDONLY
+#include <stdio.h>
+
+#include <cstddef>
+
+#include "format.h"
+
+#ifndef FMT_POSIX
+# if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#  define FMT_POSIX(call) _##call
+# else
+#  define FMT_POSIX(call) call
+# endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+# define FMT_SYSTEM(call) call
+# ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#  define FMT_POSIX_CALL(call) ::_##call
+# else
+#  define FMT_POSIX_CALL(call) ::call
+# endif
+#endif
+
+#if FMT_GCC_VERSION >= 407
+# define FMT_UNUSED __attribute__((unused))
+#else
+# define FMT_UNUSED
+#endif
+
+#ifndef FMT_USE_STATIC_ASSERT
+# define FMT_USE_STATIC_ASSERT 0
+#endif
+
+#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
+  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
+# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
+#else
+# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
+# define FMT_STATIC_ASSERT(cond, message) \
+  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+# define FMT_RETRY_VAL(result, expression, error_result) \
+  do { \
+    result = (expression); \
+  } while (result == error_result && errno == EINTR)
+#else
+# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+namespace fmt {
+
+// An error code.
+class ErrorCode {
+ private:
+  int value_;
+
+ public:
+  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
+
+  int get() const FMT_NOEXCEPT { return value_; }
+};
+
+// A buffered file.
+class BufferedFile {
+ private:
+  FILE *file_;
+
+  friend class File;
+
+  explicit BufferedFile(FILE *f) : file_(f) {}
+
+ public:
+  // Constructs a BufferedFile object which doesn't represent any file.
+  BufferedFile() FMT_NOEXCEPT : file_(0) {}
+
+  // Destroys the object closing the file it represents if any.
+  ~BufferedFile() FMT_NOEXCEPT;
+
+#if !FMT_USE_RVALUE_REFERENCES
+  // Emulate a move constructor and a move assignment operator if rvalue
+  // references are not supported.
+
+ private:
+  // A proxy object to emulate a move constructor.
+  // It is private to make it impossible call operator Proxy directly.
+  struct Proxy {
+    FILE *file;
+  };
+
+public:
+  // A "move constructor" for moving from a temporary.
+  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+
+  // A "move constructor" for for moving from an lvalue.
+  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
+    f.file_ = 0;
+  }
+
+  // A "move assignment operator" for moving from a temporary.
+  BufferedFile &operator=(Proxy p) {
+    close();
+    file_ = p.file;
+    return *this;
+  }
+
+  // A "move assignment operator" for moving from an lvalue.
+  BufferedFile &operator=(BufferedFile &other) {
+    close();
+    file_ = other.file_;
+    other.file_ = 0;
+    return *this;
+  }
+
+  // Returns a proxy object for moving from a temporary:
+  //   BufferedFile file = BufferedFile(...);
+  operator Proxy() FMT_NOEXCEPT {
+    Proxy p = {file_};
+    file_ = 0;
+    return p;
+  }
+
+#else
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
+
+ public:
+  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = 0;
+  }
+
+  BufferedFile& operator=(BufferedFile &&other) {
+    close();
+    file_ = other.file_;
+    other.file_ = 0;
+    return *this;
+  }
+#endif
+
+  // Opens a file.
+  BufferedFile(CStringRef filename, CStringRef mode);
+
+  // Closes the file.
+  void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  FILE *get() const FMT_NOEXCEPT { return file_; }
+
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  int (fileno)() const;
+
+  void print(CStringRef format_str, const ArgList &args) {
+    fmt::print(file_, format_str, args);
+  }
+  FMT_VARIADIC(void, print, CStringRef)
+};
+
+// A file. Closed file is represented by a File object with descriptor -1.
+// Methods that are not declared with FMT_NOEXCEPT may throw
+// fmt::SystemError in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class File {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a File object with a given descriptor.
+  explicit File(int fd) : fd_(fd) {}
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
+    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
+  };
+
+  // Constructs a File object which doesn't represent any file.
+  File() FMT_NOEXCEPT : fd_(-1) {}
+
+  // Opens a file and constructs a File object representing this file.
+  File(CStringRef path, int oflag);
+
+#if !FMT_USE_RVALUE_REFERENCES
+  // Emulate a move constructor and a move assignment operator if rvalue
+  // references are not supported.
+
+ private:
+  // A proxy object to emulate a move constructor.
+  // It is private to make it impossible call operator Proxy directly.
+  struct Proxy {
+    int fd;
+  };
+
+ public:
+  // A "move constructor" for moving from a temporary.
+  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
+
+  // A "move constructor" for for moving from an lvalue.
+  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
+    other.fd_ = -1;
+  }
+
+  // A "move assignment operator" for moving from a temporary.
+  File &operator=(Proxy p) {
+    close();
+    fd_ = p.fd;
+    return *this;
+  }
+
+  // A "move assignment operator" for moving from an lvalue.
+  File &operator=(File &other) {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+
+  // Returns a proxy object for moving from a temporary:
+  //   File file = File(...);
+  operator Proxy() FMT_NOEXCEPT {
+    Proxy p = {fd_};
+    fd_ = -1;
+    return p;
+  }
+
+#else
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(File);
+
+ public:
+  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
+    other.fd_ = -1;
+  }
+
+  File& operator=(File &&other) {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+#endif
+
+  // Destroys the object closing the file it represents if any.
+  ~File() FMT_NOEXCEPT;
+
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
+
+  // Closes the file.
+  void close();
+
+  // Returns the file size.
+  LongLong size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  std::size_t read(void *buffer, std::size_t count);
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  std::size_t write(const void *buffer, std::size_t count);
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  static File dup(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  void dup2(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  static void pipe(File &read_end, File &write_end);
+
+  // Creates a BufferedFile object associated with this file and detaches
+  // this File object from the file.
+  BufferedFile fdopen(const char *mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+}  // namespace fmt
+
+#if !FMT_USE_RVALUE_REFERENCES
+namespace std {
+// For compatibility with C++98.
+inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
+inline fmt::File &move(fmt::File &f) { return f; }
+}
+#endif
+
+#endif  // FMT_POSIX_H_

doc/CMakeLists.txt

@@ -5,8 +5,7 @@ if (NOT DOXYGEN)
 endif ()
 
 add_custom_target(doc
-  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build.py ${FMT_VERSION}
-  SOURCES api.rst syntax.rst build.py conf.py _templates/layout.html)
+  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build.py ${CPPFORMAT_VERSION})
 
 install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
-        DESTINATION share/doc/fmt OPTIONAL)
+        DESTINATION share/doc/cppformat)

doc/_templates/layout.html

@@ -1,28 +1,25 @@
 {% extends "!layout.html" %}
 
 {% block extrahead %}
-<meta name="description" content="Small, safe and fast formatting library">
+<meta name="description" content="Small, safe and fast formatting library for C++">
 <meta name="keywords" content="C++, formatting, printf, string, library">
 <meta name="author" content="Victor Zverovich">
-<link rel="stylesheet" href="_static/fmt.css">
+<link rel="stylesheet" href="_static/cppformat.css">
 {# Google Analytics #}
 <script>
   (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();
-    a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;
-    a.src=g;m.parentNode.insertBefore(a,m)
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+    m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
   })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
-  ga('create', 'UA-20116650-4', 'fmtlib.net');
+  ga('create', 'UA-20116650-4', 'cppformat.github.io');
   ga('send', 'pageview');
 </script>
 {% endblock %}
 
 {%- macro searchform(classes, button) %}
-<form class="{{classes}}" role="search" action="{{ pathto('search') }}"
-      method="get">
+<form class="{{classes}}" role="search" action="{{ pathto('search') }}" method="get">
   <div class="form-group">
-    <input type="text" name="q" class="form-control"
-           {{ 'placeholder="Search"' if not button }} >
+    <input type="text" name="q" class="form-control" {{ 'placeholder="Search"' if not button }} >
   </div>
   <input type="hidden" name="check_keywords" value="yes" />
   <input type="hidden" name="area" value="default" />
@@ -39,33 +36,31 @@
       <div class="navbar-content">
         {# Brand and toggle get grouped for better mobile display #}
         <div class="navbar-header">
-          <button type="button" class="navbar-toggle collapsed"
-                  data-toggle="collapse" data-target=".navbar-collapse">
+          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target=".navbar-collapse">
             <span class="sr-only">Toggle navigation</span>
             <span class="icon-bar"></span>
             <span class="icon-bar"></span>
             <span class="icon-bar"></span>
           </button>
-          <a class="navbar-brand" href="index.html">{fmt}</a>
+          <a class="navbar-brand" href="index.html">C++ Format</a>
         </div>
 
         {# Collect the nav links, forms, and other content for toggling #}
         <div class="collapse navbar-collapse">
           <ul class="nav navbar-nav">
             <li class="dropdown">
-              <a href="#" class="dropdown-toggle" data-toggle="dropdown"
-                 role="button" aria-expanded="false">{{ version }}
-                <span class="caret"></span></a>
+              {# TODO: update versions automatically #}
+              <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button"
+                 aria-expanded="false">{{ version }} <span class="caret"></span></a>
               <ul class="dropdown-menu" role="menu">
-                {% for v in versions.split(',') %}
-                <li><a href="http://fmtlib.net/{{v}}">{{v}}</a></li>
-                {% endfor %}
+                <li><a href="http://cppformat.github.io/2.0.0/">2.0.0</a></li>
+                <li><a href="http://cppformat.github.io/1.1.0/">1.1.0</a></li>
+                <li><a href="http://cppformat.github.io/1.0.0/">1.0.0</a></li>
               </ul>
             </li>
             {% for name in ['Contents', 'Usage', 'API', 'Syntax'] %}
               {% if pagename == name.lower() %}
-              <li class="active"><a href="{{name.lower()}}.html">{{name}}
-                <span class="sr-only">(current)</span></a></li>
+              <li class="active"><a href="{{name.lower()}}.html">{{name}} <span class="sr-only">(current)</span></a></li>
               {%else%}
               <li><a href="{{name.lower()}}.html">{{name}}</a></li>
               {%endif%}
@@ -80,25 +75,20 @@
   </div> {# /.tb-container #}
 </nav>
 {% if pagename == "index" %}
-{% set download_url = 'https://github.com/fmtlib/fmt/releases/download' %}
 <div class="jumbotron">
   <div class="tb-container">
-    <h1>{fmt}</h1>
-    <p class="lead">Small, safe and fast formatting library</p>
+    <h1>C++ Format</h1>
+    <p class="lead">Small, safe and fast formatting library for C++</p>
     <div class="btn-group" role="group">
-      {% set name = 'fmt' if version.split('.')[0]|int >= 3 else 'cppformat' %}
       <a class="btn btn-success"
-         href="{{download_url}}/{{version}}/{{name}}-{{version}}.zip">
-           <span class="glyphicon glyphicon-download"></span> Download
+          href="https://github.com/cppformat/cppformat/releases/download/2.0.0/cppformat-2.0.0.zip">
+            <span class="glyphicon glyphicon-download"></span> Download
       </a>
-      <button type="button" class="btn btn-success dropdown-toggle"
-        data-toggle="dropdown"><span class="caret"></span></button>
+      <button type="button" class="btn btn-success dropdown-toggle" data-toggle="dropdown"><span class="caret"></span></button>
       <ul class="dropdown-menu">
-      {% for v in versions.split(',') %}
-      {% set name = 'fmt' if v.split('.')[0]|int >= 3 else 'cppformat' %}
-        <li><a href="{{download_url}}/{{v}}/{{name}}-{{v}}.zip">Version {{v}}
-          </a></li>
-      {% endfor %}
+        <li><a href="https://github.com/cppformat/cppformat/releases/download/2.0.0/cppformat-2.0.0.zip">Version 2.0.0</a></li>
+        <li><a href="https://github.com/cppformat/cppformat/releases/download/1.1.0/cppformat-1.1.0.zip">Version 1.1.0</a></li>
+        <li><a href="https://github.com/cppformat/cppformat/releases/download/1.0.0/cppformat-1.0.0.zip">Version 1.0.0</a></li>
       </ul>
     </div>
   </div>
@@ -115,15 +105,14 @@
 {% block content %}
 <div class="tb-container">
   <div class="row">
-    {# Sidebar is currently disabled.
+    {# TODO: integrate sidebar
     <div class="bs-sidebar">
       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
         <div class="sphinxsidebarwrapper">
           {%- block sidebarlogo %}
           {%- if logo %}
             <p class="logo"><a href="{{ pathto(master_doc) }}">
-              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}"
-                   alt="Logo"/>
+              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
             </a></p>
           {%- endif %}
           {%- endblock %}

doc/api.rst

@@ -4,372 +4,131 @@
 API Reference
 *************
 
-The {fmt} library API consists of the following parts:
-
-* :ref:`fmt/core.h <core-api>`: the core API providing argument handling
-  facilities and a lightweight subset of formatting functions
-* :ref:`fmt/format.h <format-api>`: the full format API providing compile-time
-  format string checks, output iterator and user-defined type support
-* :ref:`fmt/time.h <time-api>`: date and time formatting
-* :ref:`fmt/ostream.h <ostream-api>`: ``std::ostream`` support
-* :ref:`fmt/printf.h <printf-api>`: ``printf`` formatting
-
-All functions and types provided by the library reside in namespace ``fmt`` and
-macros have prefix ``FMT_`` or ``fmt``.
-
-.. _core-api:
-
-Core API
-========
-
-``fmt/core.h`` defines the core API which provides argument handling facilities
-and a lightweight subset of formatting functions.
-
-The following functions use :ref:`format string syntax <syntax>`
-similar to that of Python's `str.format
-<http://docs.python.org/3/library/stdtypes.html#str.format>`_.
-They take *format_str* and *args* as arguments.
-
-*format_str* is a format string that contains literal text and replacement
-fields surrounded by braces ``{}``. The fields are replaced with formatted
-arguments in the resulting string. A function taking *format_str* doesn't
-participate in an overload resolution if the latter is not a string.
-
-*args* is an argument list representing objects to be formatted.
-
-.. _format:
-
-.. doxygenfunction:: format(const S&, const Args&...)
-.. doxygenfunction:: vformat(const S&, basic_format_args<typename buffer_context<Char>::type>)
-
-.. _print:
-
-.. doxygenfunction:: print(const S&, const Args&...)
-.. doxygenfunction:: vprint(string_view, format_args)
-
-.. doxygenfunction:: print(std::FILE *, const S&, const Args&...)
-.. doxygenfunction:: vprint(std::FILE *, string_view, format_args)
-.. doxygenfunction:: vprint(std::FILE *, wstring_view, wformat_args)
-
-Named arguments
----------------
-
-.. doxygenfunction:: fmt::arg(string_view, const T&)
-
-Argument lists
---------------
-
-.. doxygenfunction:: fmt::make_format_args(const Args&...)
-
-.. doxygenclass:: fmt::format_arg_store
-   :members:
-
-.. doxygenclass:: fmt::basic_format_args
-   :members:
-
-.. doxygenstruct:: fmt::format_args
-
-.. doxygenclass:: fmt::basic_format_arg
-   :members:
-
-Compatibility
--------------
-
-.. doxygenclass:: fmt::basic_string_view
-   :members:
-
-.. doxygentypedef:: fmt::string_view
-.. doxygentypedef:: fmt::wstring_view
-
-.. _format-api:
+All functions and classes provided by the C++ Format library reside
+in namespace ``fmt`` and macros have prefix ``FMT_``. For brevity the
+namespace is usually omitted in examples.
 
 Format API
 ==========
 
-``fmt/format.h`` defines the full format API providing compile-time format
-string checks, output iterator and user-defined type support.
+The following functions use :ref:`format string syntax <syntax>` similar
+to the one used by Python's `str.format
+<http://docs.python.org/3/library/stdtypes.html#str.format>`_ function.
+They take *format_str* and *args* as arguments.
 
-Compile-time format string checks
----------------------------------
+*format_str* is a format string that contains literal text and replacement
+fields surrounded by braces ``{}``. The fields are replaced with formatted
+arguments in the resulting string.
 
-.. doxygendefine:: fmt
+*args* is an argument list representing arbitrary arguments.
 
-Formatting user-defined types
------------------------------
+.. _format:
 
-To make a user-defined type formattable, specialize the ``formatter<T>`` struct
-template and implement ``parse`` and ``format`` methods::
-
-  #include <fmt/format.h>
-
-  struct point { double x, y; };
-
-  namespace fmt {
-  template <>
-  struct formatter<point> {
-    template <typename ParseContext>
-    constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
-
-    template <typename FormatContext>
-    auto format(const point &p, FormatContext &ctx) {
-      return format_to(ctx.begin(), "({:.1f}, {:.1f})", p.x, p.y);
-    }
-  };
-  }
-
-Then you can pass objects of type ``point`` to any formatting function::
-
-  point p = {1, 2};
-  std::string s = fmt::format("{}", p);
-  // s == "(1.0, 2.0)"
-
-In the example above the ``formatter<point>::parse`` function ignores the
-contents of the format string referred to by ``ctx.begin()`` so the object will
-always be formatted in the same way. See ``formatter<tm>::parse`` in
-:file:`fmt/time.h` for an advanced example of how to parse the format string and
-customize the formatted output.
-
-You can also reuse existing formatters, for example::
-
-  enum class color {red, green, blue};
-
-  template <>
-  struct fmt::formatter<color>: formatter<string_view> {
-    // parse is inherited from formatter<string_view>.
-    template <typename FormatContext>
-    auto format(color c, FormatContext &ctx) {
-      string_view name = "unknown";
-      switch (c) {
-      case color::red:   name = "red"; break;
-      case color::green: name = "green"; break;
-      case color::blue:  name = "blue"; break;
-      }
-      return formatter<string_view>::format(name, ctx);
-    }
-  };
-
-You can also write a formatter for a hierarchy of classes::
-
-  #include <type_traits>
-  #include <fmt/format.h>
-
-  struct A {
-    virtual ~A() {}
-    virtual std::string name() const { return "A"; }
-  };
-
-  struct B : A {
-    virtual std::string name() const { return "B"; }
-  };
-
-  template <typename T>
-  struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> :
-      fmt::formatter<std::string> {
-    template <typename FormatCtx>
-    auto format(const A& a, FormatCtx& ctx) {
-      return fmt::formatter<std::string>::format(a.name(), ctx);
-    }
-  };
-
-  int main() {
-    B b;
-    A& a = b;
-    fmt::print("{}", a); // prints "B"
-  }
-
-This section shows how to define a custom format function for a user-defined
-type. The next section describes how to get ``fmt`` to use a conventional stream
-output ``operator<<`` when one is defined for a user-defined type.
-
-Output iterator support
------------------------
-
-.. doxygenfunction:: fmt::format_to(OutputIt, const S&, const Args&...)
-.. doxygenfunction:: fmt::format_to_n(OutputIt, std::size_t, string_view, const Args&...)
-.. doxygenstruct:: fmt::format_to_n_result
-   :members:
-
-Literal-based API
------------------
-
-The following user-defined literals are defined in ``fmt/format.h``.
+.. doxygenfunction:: format(CStringRef, ArgList)
 
 .. doxygenfunction:: operator""_format(const char *, std::size_t)
 
-.. doxygenfunction:: operator""_a(const char *, std::size_t)
+.. _print:
+
+.. doxygenfunction:: print(CStringRef, ArgList)
+
+.. doxygenfunction:: print(std::FILE *, CStringRef, ArgList)
+
+.. doxygenfunction:: print(std::ostream&, CStringRef, ArgList)
+
+.. doxygenclass:: fmt::BasicFormatter
+   :members:
+
+Printf formatting functions
+---------------------------
+
+The following functions use `printf format string syntax
+<http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
+a POSIX extension for positional arguments.
+
+.. doxygenfunction:: printf(CStringRef, ArgList)
+
+.. doxygenfunction:: fprintf(std::FILE *, CStringRef, ArgList)
+
+.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
+
+.. doxygenfunction:: sprintf(CStringRef, ArgList)
+
+Write API
+=========
+
+.. doxygenclass:: fmt::BasicWriter
+   :members:
+
+.. doxygenclass:: fmt::BasicMemoryWriter
+   :members:
+
+.. doxygenclass:: fmt::BasicArrayWriter
+   :members:
+
+.. doxygenfunction:: bin(int)
+
+.. doxygenfunction:: oct(int)
+
+.. doxygenfunction:: hex(int)
+
+.. doxygenfunction:: hexu(int)
+
+.. doxygenfunction:: pad(int, unsigned, Char)
 
 Utilities
----------
+=========
 
-.. doxygentypedef:: fmt::char_t
+.. doxygenfunction:: fmt::arg(StringRef, const T&)
 
-.. doxygenfunction:: fmt::formatted_size(string_view, const Args&...)
+.. doxygenfunction:: operator""_a(const char *, std::size_t)
 
-.. doxygenfunction:: fmt::to_string(const T&)
+.. doxygendefine:: FMT_CAPTURE
 
-.. doxygenfunction:: fmt::to_wstring(const T&)
+.. doxygendefine:: FMT_VARIADIC
 
-.. doxygenfunction:: fmt::to_string_view(basic_string_view<Char>)
+.. doxygenclass:: fmt::ArgList
+   :members:
 
-.. doxygenclass:: fmt::basic_memory_buffer
+.. doxygenclass:: fmt::BasicStringRef
+   :members:
+
+.. doxygenclass:: fmt::BasicCStringRef
+   :members:
+
+.. doxygenclass:: fmt::Buffer
    :protected-members:
    :members:
 
-System errors
--------------
+System Errors
+=============
 
-fmt does not use ``errno`` to communicate errors to the user, but it may call
-system functions which set ``errno``. Users should not make any assumptions about
-the value of ``errno`` being preserved by library functions.
-
-.. doxygenclass:: fmt::system_error
+.. doxygenclass:: fmt::SystemError
    :members:
 
-.. doxygenfunction:: fmt::format_system_error
-
-.. doxygenclass:: fmt::windows_error
+.. doxygenclass:: fmt::WindowsError
    :members:
 
 .. _formatstrings:
 
 Custom allocators
------------------
+=================
 
-The {fmt} library supports custom dynamic memory allocators.
+The C++ Format library supports custom dynamic memory allocators.
 A custom allocator class can be specified as a template argument to
-:class:`fmt::basic_memory_buffer`::
+:class:`fmt::BasicMemoryWriter`::
 
-    using custom_memory_buffer = 
-      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
+    typedef fmt::BasicMemoryWriter<char, CustomAllocator> CustomMemoryWriter;
 
 It is also possible to write a formatting function that uses a custom
 allocator::
 
-    using custom_string =
-      std::basic_string<char, std::char_traits<char>, custom_allocator>;
+    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator> CustomString;
 
-    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
-                          fmt::format_args args) {
-      custom_memory_buffer buf(alloc);
-      fmt::vformat_to(buf, format_str, args);
-      return custom_string(buf.data(), buf.size(), alloc);
+    CustomString format(CustomAllocator alloc, fmt::CStringRef format_str,
+                        fmt::ArgList args) {
+      CustomMemoryWriter writer(alloc);
+      writer.write(format_str, args);
+      return CustomString(writer.data(), writer.size(), alloc);
     }
-
-    template <typename ...Args>
-    inline custom_string format(custom_allocator alloc,
-                                fmt::string_view format_str,
-                                const Args & ... args) {
-      return vformat(alloc, format_str, fmt::make_format_args(args...));
-    }
-
-The allocator will be used for the output container only. If you are using named
-arguments, the container that stores pointers to them will be allocated using
-the default allocator. Also floating-point formatting falls back on ``sprintf``
-which may do allocations.
-
-Custom formatting of built-in types
------------------------------------
-
-It is possible to change the way arguments are formatted by providing a
-custom argument formatter class::
-
-  using arg_formatter =
-    fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>>;
-
-  // A custom argument formatter that formats negative integers as unsigned
-  // with the ``x`` format specifier.
-  class custom_arg_formatter : public arg_formatter {
-   public:
-    custom_arg_formatter(fmt::format_context &ctx,
-                         fmt::format_specs *spec = nullptr)
-      : arg_formatter(ctx, spec) {}
-
-    using arg_formatter::operator();
-
-    auto operator()(int value) {
-      if (spec().type() == 'x')
-        return (*this)(static_cast<unsigned>(value)); // convert to unsigned and format
-      return arg_formatter::operator()(value);
-    }
-  };
-
-  std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
-    fmt::memory_buffer buffer;
-    // Pass custom argument formatter as a template arg to vformat_to.
-    fmt::vformat_to<custom_arg_formatter>(buffer, format_str, args);
-    return fmt::to_string(buffer);
-  }
-
-  template <typename ...Args>
-  inline std::string custom_format(
-      fmt::string_view format_str, const Args &... args) {
-    return custom_vformat(format_str, fmt::make_format_args(args...));
-  }
-
-  std::string s = custom_format("{:x}", -42); // s == "ffffffd6"
-
-.. doxygenclass:: fmt::arg_formatter
-   :members:
-
-.. _time-api:
-
-Date and time formatting
-========================
-
-The library supports `strftime
-<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
-formatting::
-
-  #include <fmt/time.h>
-
-  std::time_t t = std::time(nullptr);
-  // Prints "The date is 2016-04-29." (with the current date)
-  fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));
-
-The format string syntax is described in the documentation of
-`strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
-
-.. _ostream-api:
-
-``std::ostream`` support
-========================
-
-``fmt/ostream.h`` provides ``std::ostream`` support including formatting of
-user-defined types that have overloaded ``operator<<``::
-
-  #include <fmt/ostream.h>
-
-  class date {
-    int year_, month_, day_;
-  public:
-    date(int year, int month, int day): year_(year), month_(month), day_(day) {}
-
-    friend std::ostream &operator<<(std::ostream &os, const date &d) {
-      return os << d.year_ << '-' << d.month_ << '-' << d.day_;
-    }
-  };
-
-  std::string s = fmt::format("The date is {}", date(2012, 12, 9));
-  // s == "The date is 2012-12-9"
-
-.. doxygenfunction:: print(std::basic_ostream<fmt::char_t<S>>&, const S&, const Args&...)
-
-.. _printf-api:
-
-``printf`` formatting
-=====================
-
-The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
-The following functions use `printf format string syntax
-<http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
-the POSIX extension for positional arguments. Unlike their standard
-counterparts, the ``fmt`` functions are type-safe and throw an exception if an
-argument type doesn't match its format specification.
-
-.. doxygenfunction:: printf(const S&, const Args&...)
-
-.. doxygenfunction:: fprintf(std::FILE *, const S&, const Args&...)
-
-.. doxygenfunction:: fprintf(std::basic_ostream<fmt::char_t<S>>&, const S&, const Args&...)
-
-.. doxygenfunction:: sprintf(const S&, const Args&...)
+    FMT_VARIADIC(CustomString, format, CustomAllocator, fmt::CStringRef)

doc/basic-bootstrap/layout.html

@@ -90,8 +90,7 @@
         VERSION:     '{{ release|e }}',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
-        HAS_SOURCE:  {{ has_source|lower }},
-        SOURCELINK_SUFFIX:  '{{ sourcelink_suffix }}'
+        HAS_SOURCE:  {{ has_source|lower }}
       };
     </script>
     {%- for scriptfile in script_files %}

doc/build.py

@@ -6,39 +6,32 @@ import errno, os, shutil, sys, tempfile
 from subprocess import check_call, check_output, CalledProcessError, Popen, PIPE
 from distutils.version import LooseVersion
 
-versions = ['1.0.0', '1.1.0', '2.0.0', '3.0.2', '4.0.0', '4.1.0', '5.0.0', '5.1.0', '5.2.0', '5.2.1', '5.3.0']
-
 def pip_install(package, commit=None, **kwargs):
   "Install package using pip."
-  min_version = kwargs.get('min_version')
-  if min_version:
-    from pkg_resources import get_distribution, DistributionNotFound
-    try:
-      installed_version = get_distribution(os.path.basename(package)).version
-      if LooseVersion(installed_version) >= min_version:
-        print('{} {} already installed'.format(package, min_version))
-        return
-    except DistributionNotFound:
-      pass
   if commit:
-    package = 'git+https://github.com/{0}.git@{1}'.format(package, commit)
-  print('Installing {0}'.format(package))
-  check_call(['pip', 'install', package])
+    check_version = kwargs.get('check_version', '')
+    #output = check_output(['pip', 'show', package.split('/')[1]])
+    #if check_version in output:
+    #  print('{} already installed'.format(package))
+    #  return
+    package = 'git+git://github.com/{0}.git@{1}'.format(package, commit)
+  print('Installing {}'.format(package))
+  check_call(['pip', 'install', '--upgrade', package])
 
-def create_build_env(dirname='virtualenv'):
+def build_docs(version='dev'):
   # Create virtualenv.
-  if not os.path.exists(dirname):
-    check_call(['virtualenv', dirname])
+  doc_dir = os.path.dirname(os.path.realpath(__file__))
+  virtualenv_dir = 'virtualenv'
+  check_call(['virtualenv', virtualenv_dir])
   import sysconfig
   scripts_dir = os.path.basename(sysconfig.get_path('scripts'))
-  activate_this_file = os.path.join(dirname, scripts_dir, 'activate_this.py')
+  activate_this_file = os.path.join(virtualenv_dir, scripts_dir,
+                                    'activate_this.py')
   with open(activate_this_file) as f:
     exec(f.read(), dict(__file__=activate_this_file))
-  # Import get_distribution after activating virtualenv to get info about
-  # the correct packages.
-  from pkg_resources import get_distribution, DistributionNotFound
   # Upgrade pip because installation of sphinx with pip 1.1 available on Travis
   # is broken (see #207) and it doesn't support the show command.
+  from pkg_resources import get_distribution, DistributionNotFound
   pip_version = get_distribution('pip').version
   if LooseVersion(pip_version) < LooseVersion('1.5.4'):
     print("Updating pip")
@@ -53,35 +46,27 @@ def create_build_env(dirname='virtualenv'):
   except DistributionNotFound:
     pass
   # Install Sphinx and Breathe.
-  pip_install('sphinx-doc/sphinx', '12b83372ac9316e8cbe86e7fed889296a4cc29ee',
-              min_version='1.4.1.dev20160531')
+  pip_install('cppformat/sphinx',
+              '12dde8afdb0a7bb5576e2656692c3478c69d8cc3',
+              check_version='1.4a0.dev-20151013')
   pip_install('michaeljones/breathe',
-              '129222318f7c8f865d2631e7da7b033567e7f56a',
-              min_version='4.2.0')
-
-def build_docs(version='dev', **kwargs):
-  doc_dir = kwargs.get('doc_dir', os.path.dirname(os.path.realpath(__file__)))
-  work_dir = kwargs.get('work_dir', '.')
-  include_dir = kwargs.get(
-      'include_dir', os.path.join(os.path.dirname(doc_dir), 'include', 'fmt'))
+              '1c9d7f80378a92cffa755084823a78bb38ee4acc')
   # Build docs.
   cmd = ['doxygen', '-']
   p = Popen(cmd, stdin=PIPE)
-  doxyxml_dir = os.path.join(work_dir, 'doxyxml')
   p.communicate(input=r'''
-      PROJECT_NAME      = fmt
+      PROJECT_NAME      = C++ Format
       GENERATE_LATEX    = NO
       GENERATE_MAN      = NO
       GENERATE_RTF      = NO
       CASE_SENSE_NAMES  = NO
-      INPUT             = {0}/core.h {0}/format.h {0}/ostream.h \
-                          {0}/printf.h {0}/time.h
+      INPUT             = {0}/format.h
       QUIET             = YES
       JAVADOC_AUTOBRIEF = YES
       AUTOLINK_SUPPORT  = NO
       GENERATE_HTML     = NO
       GENERATE_XML      = YES
-      XML_OUTPUT        = {1}
+      XML_OUTPUT        = doxyxml
       ALIASES           = "rst=\verbatim embed:rst"
       ALIASES          += "endrst=\endverbatim"
       MACRO_EXPANSION   = YES
@@ -89,36 +74,26 @@ def build_docs(version='dev', **kwargs):
                           FMT_USE_VARIADIC_TEMPLATES=1 \
                           FMT_USE_RVALUE_REFERENCES=1 \
                           FMT_USE_USER_DEFINED_LITERALS=1 \
-                          FMT_USE_ALIAS_TEMPLATES=1 \
-                          FMT_API= \
-                          "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
-                          "FMT_END_NAMESPACE=}}" \
-                          "FMT_STRING_ALIAS=1" \
-                          "FMT_ENABLE_IF_T(B, T)=T"
+                          FMT_API=
       EXCLUDE_SYMBOLS   = fmt::internal::* StringValue write_str
-    '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
+    '''.format(os.path.join(os.path.dirname(doc_dir), 'cppformat')).encode('UTF-8'))
   if p.returncode != 0:
     raise CalledProcessError(p.returncode, cmd)
-  html_dir = os.path.join(work_dir, 'html')
-  main_versions = reversed(versions[-3:])
   check_call(['sphinx-build',
-              '-Dbreathe_projects.format=' + os.path.abspath(doxyxml_dir),
-              '-Dversion=' + version, '-Drelease=' + version,
-              '-Aversion=' + version, '-Aversions=' + ','.join(main_versions),
-              '-b', 'html', doc_dir, html_dir])
+              '-Dbreathe_projects.format=' + os.path.join(os.getcwd(), 'doxyxml'),
+              '-Dversion=' + version, '-Drelease=' + version, '-Aversion=' + version,
+              '-b', 'html', doc_dir, 'html'])
   try:
     check_call(['lessc', '--clean-css',
                 '--include-path=' + os.path.join(doc_dir, 'bootstrap'),
-                os.path.join(doc_dir, 'fmt.less'),
-                os.path.join(html_dir, '_static', 'fmt.css')])
+                os.path.join(doc_dir, 'cppformat.less'),
+                'html/_static/cppformat.css'])
   except OSError as e:
     if e.errno != errno.ENOENT:
       raise
-    print('lessc not found; make sure that Less (http://lesscss.org/) ' +
-          'is installed')
+    print('lessc not found; make sure that Less (http://lesscss.org/) is installed')
     sys.exit(1)
-  return html_dir
+  return 'html'
 
 if __name__ == '__main__':
-  create_build_env()
   build_docs(sys.argv[1])

doc/conf.py

@@ -46,8 +46,8 @@ source_suffix = '.rst'
 #master_doc = 'contents'
 
 # General information about the project.
-project = u'fmt'
-copyright = u'2012-present, Victor Zverovich'
+project = u'C++ Format'
+copyright = u'2012-2015, Victor Zverovich'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -76,7 +76,7 @@ copyright = u'2012-present, Victor Zverovich'
 exclude_patterns = ['virtualenv']
 
 # The reST default role (used for this markup: `text`) to use for all documents.
-default_role = 'cpp:any'
+#default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
@@ -198,7 +198,7 @@ latex_elements = {
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'format.tex', u'fmt documentation',
+  ('index', 'format.tex', u'C++ Format Documentation',
    u'Victor Zverovich', 'manual'),
 ]
 
@@ -228,7 +228,8 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'fmt', u'fmt documentation', [u'Victor Zverovich'], 1)
+    ('index', 'format', u'format Documentation',
+     [u'Victor Zverovich'], 1)
 ]
 
 # If true, show URL addresses after external links.
@@ -241,8 +242,8 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'fmt', u'fmt documentation',
-   u'Victor Zverovich', 'fmt', 'One line description of project.',
+  ('index', 'format', u'format Documentation',
+   u'Victor Zverovich', 'format', 'One line description of project.',
    'Miscellaneous'),
 ]
 

doc/index.rst

@@ -1,21 +1,22 @@
 Overview
 ========
 
-**fmt** (formerly cppformat) is an open-source formatting library.
-It can be used as a fast and safe alternative to printf and IOStreams.
+C++ Format (cppformat) is an open-source formatting library for C++.
+It can be used as a safe alternative to printf or as a fast
+alternative to IOStreams.
 
 .. raw:: html
 
    <div class="panel panel-default">
      <div class="panel-heading">What users say:</div>
      <div class="panel-body">
-       Thanks for creating this library. It’s been a hole in C++ for a long
-       time. I’ve used both boost::format and loki::SPrintf, and neither felt
-       like the right answer. This does.
+       Thanks for creating this library. It’s been a hole in C++ for a long time.
+       I’ve used both boost::format and loki::SPrintf, and neither felt like the
+       right answer. This does.
      </div>
    </div>
 
-.. _format-api-intro:
+.. _format-api:
 
 Format API
 ----------
@@ -23,24 +24,24 @@ Format API
 The replacement-based Format API provides a safe alternative to ``printf``,
 ``sprintf`` and friends with comparable or `better performance
 <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
-The `format string syntax <syntax.html>`_ is similar to the one used by
-`str.format <http://docs.python.org/3/library/stdtypes.html#str.format>`_
+The `format string syntax <doc/latest/index.html#format-string-syntax>`_ is similar
+to the one used by `str.format <http://docs.python.org/2/library/stdtypes.html#str.format>`_
 in Python:
 
 .. code:: c++
 
-  fmt::format("The answer is {}.", 42);
+  fmt::format("The answer is {}", 42);
   
-The ``fmt::format`` function returns a string "The answer is 42.". You can use
-``fmt::memory_buffer`` to avoid constructing ``std::string``:
+The ``fmt::format`` function returns a string "The answer is 42". You can use
+``fmt::MemoryWriter`` to avoid constructing ``std::string``:
 
 .. code:: c++
 
-  fmt::memory_buffer out;
-  format_to(out, "For a moment, {} happened.", "nothing");
-  out.data(); // returns a pointer to the formatted data
+  fmt::MemoryWriter w;
+  w.write("Look, a {} string", 'C');
+  w.c_str(); // returns a C string (const char*)
 
-The ``fmt::print`` function performs formatting and writes the result to a stream:
+The ``fmt::print`` function performs formatting and writes the result to a file:
 
 .. code:: c++
 
@@ -53,6 +54,11 @@ The file argument can be omitted in which case the function prints to
 
   fmt::print("Don't {}\n", "panic");
 
+If your compiler supports C++11, then the formatting functions are implemented
+with variadic templates. Otherwise variadic functions are emulated by generating
+a set of lightweight wrappers. This ensures compatibility with older compilers
+while providing a natural API.
+
 The Format API also supports positional arguments useful for localization:
 
 .. code:: c++
@@ -87,31 +93,38 @@ literal operators, they must be made visible with the directive
 ``using namespace fmt::literals;``. Note that this brings in only ``_a`` and 
 ``_format`` but nothing else from the ``fmt`` namespace.
 
+.. _write-api:
+  
+Write API
+---------
+
+The concatenation-based Write API (experimental) provides a
+`fast <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_
+stateless alternative to IOStreams:
+
+.. code:: c++
+
+  fmt::MemoryWriter out;
+  out << "The answer in hexadecimal is " << hex(42);
+
 .. _safety:
 
 Safety
 ------
 
-The library is fully type safe, automatic memory management prevents buffer
-overflow, errors in format strings are reported using exceptions or at compile
-time. For example, the code
+The library is fully type safe, automatic memory management prevents buffer overflow,
+errors in format strings are reported using exceptions. For example, the code
 
 .. code:: c++
 
   fmt::format("The answer is {:d}", "forty-two");
 
-throws a ``format_error`` exception with description "unknown format code 'd' for
-string", because the argument ``"forty-two"`` is a string while the format code
-``d`` only applies to integers, while
+throws a ``FormatError`` exception with description
+"unknown format code 'd' for string", because the argument
+``"forty-two"`` is a string while the format code ``d``
+only applies to integers.
 
-.. code:: c++
-
-  format(fmt("The answer is {:d}"), "forty-two");
-
-reports a compile-time error for the same reason on compilers that support
-relaxed ``constexpr``.
-
-The following code
+Where possible, errors are caught at compile time. For example, the code
 
 .. code:: c++
 
@@ -125,64 +138,44 @@ formatted into a narrow string. You can use a wide format string instead:
   fmt::format(L"Cyrillic letter {}", L'\x42e');
 
 For comparison, writing a wide character to ``std::ostream`` results in
-its numeric value being written to the stream (i.e. 1070 instead of letter 'ю'
-which is represented by ``L'\x42e'`` if we use Unicode) which is rarely what is
-needed.
-
-Compact binary code
--------------------
-
-The library is designed to produce compact per-call compiled code. For example
-(`godbolt <https://godbolt.org/g/TZU4KF>`_),
-
-.. code:: c++
-
-   #include <fmt/core.h>
-
-   int main() {
-     fmt::print("The answer is {}.", 42);
-   }
-
-compiles to just
-
-.. code:: asm
-
-   main: # @main
-     sub rsp, 24
-     mov qword ptr [rsp], 42
-     mov rcx, rsp
-     mov edi, offset .L.str
-     mov esi, 17
-     mov edx, 2
-     call fmt::v5::vprint(fmt::v5::basic_string_view<char>, fmt::v5::format_args)
-     xor eax, eax
-     add rsp, 24
-     ret
-   .L.str:
-     .asciz "The answer is {}."
+its numeric value being written to the stream (i.e. 1070 instead of letter 'ю' which
+is represented by ``L'\x42e'`` if we use Unicode) which is rarely what is needed.
 
 .. _portability:
 
 Portability
 -----------
 
-The library is highly portable and relies only on a small set of C++11 features:
+C++ Format is highly portable. Here is an incomplete list of operating systems and
+compilers where it has been tested and known to work:
 
-* variadic templates
-* type traits
-* rvalue references
-* decltype
-* trailing return types
-* deleted functions
+* 64-bit (amd64) GNU/Linux with GCC 4.4.3, `4.6.3 <https://travis-ci.org/cppformat/cppformat>`_,
+  4.7.2, 4.8.1 and Intel C++ Compiler (ICC) 14.0.2
 
-These are available since GCC 4.4, Clang 2.9 and MSVC 18.0 (2013). For older
-compilers use fmt `version 4.x
-<https://github.com/fmtlib/fmt/releases/tag/4.1.0>`_ which continues to be
-maintained and only requires C++98.
+* 32-bit (i386) GNU/Linux with GCC 4.4.3, 4.6.3
 
-The output of all formatting functions is consistent across platforms. In
-particular, formatting a floating-point infinity always gives ``inf`` while the
-output of ``printf`` is platform-dependent in this case. For example,
+* Mac OS X with GCC 4.2.1 and Clang 4.2, 5.1.0
+
+* 64-bit Windows with Visual C++ 2010, 2013 and
+  `2015 <https://ci.appveyor.com/project/vitaut/cppformat>`_
+
+* 32-bit Windows with Visual C++ 2010
+
+Although the library uses C++11 features when available, it also works with older
+compilers and standard library implementations. The only thing to keep in mind 
+for C++98 portability:
+
+* Variadic templates: minimum GCC 4.4, Clang 2.9 or VS2013. This feature allows 
+  the Format API to accept an unlimited number of arguments. With older compilers
+  the maximum is 15.
+
+* User-defined literals: minimum GCC 4.7, Clang 3.1 or VS2015. The suffixes 
+  ``_format`` and ``_a`` are functionally equivalent to the functions 
+  ``fmt::format`` and ``fmt::arg``.
+
+The output of all formatting functions is consistent across platforms. In particular,
+formatting a floating-point infinity always gives ``inf`` while the output
+of ``printf`` is platform-dependent in this case. For example,
 
 .. code::
 
@@ -195,16 +188,16 @@ always prints ``inf``.
 Ease of Use
 -----------
 
-fmt has a small self-contained code base with the core library consisting of
-just three header files and no external dependencies.
-A permissive BSD `license <https://github.com/fmtlib/fmt#license>`_ allows
-using the library both in open-source and commercial projects.
+C++ Format has small self-contained code base consisting of a single header file
+and a single source file and no external dependencies. A permissive BSD `license
+<https://github.com/cppformat/cppformat#license>`_ allows using the library both
+in open-source and commercial projects.
 
 .. raw:: html
 
-  <a class="btn btn-success" href="https://github.com/fmtlib/fmt">GitHub Repository</a>
+  <a class="btn btn-success" href="https://github.com/cppformat/cppformat">GitHub Repository</a>
 
   <div class="section footer">
-    <iframe src="http://ghbtns.com/github-btn.html?user=fmtlib&amp;repo=fmt&amp;type=watch&amp;count=true"
+    <iframe src="http://ghbtns.com/github-btn.html?user=cppformat&amp;repo=cppformat&amp;type=watch&amp;count=true"
             class="github-btn" width="100" height="20"></iframe>
   </div>

doc/syntax.rst

@@ -4,9 +4,8 @@
 Format String Syntax
 ********************
 
-Formatting functions such as :ref:`fmt::format() <format>` and
-:ref:`fmt::print() <print>` use the same format string syntax described in this
-section.
+Formatting functions such as :ref:`fmt::format() <format>` and :ref:`fmt::print() <print>`
+use the same format string syntax described in this section.
 
 Format strings contain "replacement fields" surrounded by curly braces ``{}``.
 Anything that is not contained in braces is considered literal text, which is
@@ -36,8 +35,6 @@ If the numerical arg_ids in a format string are 0, 1, 2, ... in sequence,
 they can all be omitted (not just some) and the numbers 0, 1, 2, ... will be
 automatically inserted in that order.
 
-Named arguments can be referred to by their names or indices.
-
 Some simple format string examples::
 
    "First, thou shalt count to {0}" // References the first argument
@@ -52,10 +49,12 @@ mini-language" or interpretation of the *format_spec*.
 Most built-in types support a common formatting mini-language, which is
 described in the next section.
 
-A *format_spec* field can also include nested replacement fields in certain
-positions within it. These nested replacement fields can contain only an
-argument id; format specifications are not allowed. This allows the formatting
-of a value to be dynamically specified.
+A *format_spec* field can also include nested replacement fields within it.
+These nested replacement fields can contain only an argument index;
+format specifications are not allowed.  Formatting is performed as if the
+replacement fields within the format_spec are substituted before the
+*format_spec* string is interpreted.  This allows the formatting of a value
+to be dynamically specified.
 
 See the :ref:`formatexamples` section for some examples.
 
@@ -76,19 +75,19 @@ The general form of a *standard format specifier* is:
 
 .. productionlist:: sf
    format_spec: [[`fill`]`align`][`sign`]["#"]["0"][`width`]["." `precision`][`type`]
-   fill: <a character other than '{', '}' or '\0'>
+   fill: <a character other than '{' or '}'>
    align: "<" | ">" | "=" | "^"
    sign: "+" | "-" | " "
    width: `integer` | "{" `arg_id` "}"
    precision: `integer` | "{" `arg_id` "}"
-   type: `int_type` | "a" | "A" | "c" | "e" | "E" | "f" | "F" | "g" | "G" | "p" | "s"
-   int_type: "b" | "B" | "d" | "n" | "o" | "x" | "X"
+   type: `int_type` | "c" | "e" | "E" | "f" | "F" | "g" | "G" | "p" | "s"
+   int_type: "b" | "B" | "d" | "o" | "x" | "X"
 
-The *fill* character can be any character other than '{', '}' or '\\0'. The
-presence of a fill character is signaled by the character following it, which
-must be one of the alignment options.  If the second character of *format_spec*
-is not a valid alignment option, then it is assumed that both the fill character
-and the alignment option are absent.
+The *fill* character can be any character other than '{' or '}'.  The presence
+of a fill character is signaled by the character following it, which must be
+one of the alignment options.  If the second character of *format_spec* is not
+a valid alignment option, then it is assumed that both the fill character and
+the alignment option are absent.
 
 The meaning of the various alignment options is as follows:
 
@@ -217,10 +216,6 @@ The available integer presentation types are:
 |         | ``'#'`` option with this type adds the prefix ``"0X"``   |
 |         | to the output value.                                     |
 +---------+----------------------------------------------------------+
-| ``'n'`` | Number. This is the same as ``'d'``, except that it uses |
-|         | the current locale setting to insert the appropriate     |
-|         | number separator characters.                             |
-+---------+----------------------------------------------------------+
 | none    | The same as ``'d'``.                                     |
 +---------+----------------------------------------------------------+
 
@@ -235,7 +230,7 @@ The available presentation types for floating-point values are:
 +=========+==========================================================+
 | ``'a'`` | Hexadecimal floating point format. Prints the number in  |
 |         | base 16 with prefix ``"0x"`` and lower-case letters for  |
-|         | digits above 9. Uses ``'p'`` to indicate the exponent.   |
+|         | digits above 9. Uses 'p' to indicate the exponent.       |
 +---------+----------------------------------------------------------+
 | ``'A'`` | Same as ``'a'`` except it uses upper-case letters for    |
 |         | the prefix, digits above 9 and to indicate the exponent. |
@@ -267,8 +262,6 @@ The available presentation types for floating-point values are:
 | none    | The same as ``'g'``.                                     |
 +---------+----------------------------------------------------------+
 
-Floating-point formatting is locale-dependent.
-
 .. ifconfig:: False
 
    +---------+----------------------------------------------------------+
@@ -338,16 +331,6 @@ Aligning the text and specifying a width::
    format("{:*^30}", "centered");  // use '*' as a fill char
    // Result: "***********centered***********"
 
-Dynamic width::
-
-   format("{:<{}}", "left aligned", 30);
-   // Result: "left aligned                  "
-
-Dynamic precision::
-
-   format("{:.{}f}", 3.14, 1);
-   // Result: "3.1"
-
 Replacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign::
 
    format("{:+f}; {:+f}", 3.14, -3.14);  // show it always
@@ -365,11 +348,6 @@ Replacing ``%x`` and ``%o`` and converting the value to different bases::
    format("int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}", 42);
    // Result: "int: 42;  hex: 0x2a;  oct: 052;  bin: 0b101010"
 
-Padded hex byte with prefix and always prints both hex characters::
-
-   format("{:#04x}", 0);
-   // Result: "0x00"
-
 .. ifconfig:: False
 
    Using the comma as a thousands separator::
@@ -377,6 +355,13 @@ Padded hex byte with prefix and always prints both hex characters::
       format("{:,}", 1234567890);
       '1,234,567,890'
 
+   Expressing a percentage::
+
+      >>> points = 19
+      >>> total = 22
+      Format("Correct answers: {:.2%}") << points/total)
+      'Correct answers: 86.36%'
+
    Using type-specific formatting::
 
       >>> import datetime

doc/usage.rst

@@ -2,9 +2,9 @@
 Usage
 *****
 
-To use the fmt library, add :file:`format.h` and :file:`format.cc` from
-a `release archive <https://github.com/fmtlib/fmt/releases/latest>`_
-or the `Git repository <https://github.com/fmtlib/fmt>`_ to your project.
+To use the C++ Format library, add :file:`format.h` and :file:`format.cc` from
+a `release archive <https://github.com/cppformat/cppformat/releases/latest>`_
+or the `Git repository <https://github.com/cppformat/cppformat>`_ to your project.
 Alternatively, you can :ref:`build the library with CMake <building>`.
 
 If you are using Visual C++ with precompiled headers, you might need to add
@@ -19,33 +19,29 @@ before other includes in :file:`format.cc`.
 Building the library
 ====================
 
-The included `CMake build script`__ can be used to build the fmt
+The included `CMake build script`__ can be used to build the C++ Format
 library on a wide range of platforms. CMake is freely available for
 download from http://www.cmake.org/download/.
 
-__ https://github.com/fmtlib/fmt/blob/master/CMakeLists.txt
+__ https://github.com/cppformat/cppformat/blob/master/CMakeLists.txt
 
 CMake works by generating native makefiles or project files that can
 be used in the compiler environment of your choice. The typical
 workflow starts with::
 
-  mkdir build          # Create a directory to hold the build output.
+  mkdir build                # Create a directory to hold the build output.
   cd build
-  cmake <path/to/fmt>  # Generate native build scripts.
+  cmake <path/to/cppformat>  # Generate native build scripts.
 
-where :file:`{<path/to/fmt>}` is a path to the ``fmt`` repository.
+where :file:`{<path/to/cppformat>}` is a path to the ``cppformat`` repository.
 
 If you are on a \*nix system, you should now see a Makefile in the
-current directory. Now you can build the library by running :command:`make`.
+current directory. Now you can build C++ Format by running :command:`make`.
 
 Once the library has been built you can invoke :command:`make test` to run
 the tests.
 
-You can control generation of the make ``test`` target with the ``FMT_TEST``
-CMake option. This can be useful if you include fmt as a subdirectory in
-your project but don't want to add fmt's tests to your ``test`` target.
-
-If you use Windows and have Visual Studio installed, a :file:`FMT.sln`
+If you use Windows and have Visual Studio installed, a :file:`FORMAT.sln`
 file and several :file:`.vcproj` files will be created. You can then build them
 using Visual Studio or msbuild.
 
@@ -58,31 +54,6 @@ To build a `shared library`__ set the ``BUILD_SHARED_LIBS`` CMake variable to
 
 __ http://en.wikipedia.org/wiki/Library_%28computing%29#Shared_libraries
 
-Header-only usage with CMake
-============================
-
-You can add the ``fmt`` library directory into your project and include it in
-your ``CMakeLists.txt`` file::
-
-   add_subdirectory(fmt)
-
-or
-
-::
-
-   add_subdirectory(fmt EXCLUDE_FROM_ALL)
-
-to exclude it from ``make``, ``make all``, or ``cmake --build .``.
-
-You can detect and use an installed version of {fmt} as follows::
-
-   find_package(fmt)
-   target_link_libraries(<your-target> fmt::fmt)
-
-Setting up your target to use a header-only version of ``fmt`` is equaly easy::
-
-   target_link_libraries(<your-target> PRIVATE fmt-header-only)
-
 Building the documentation
 ==========================
 
@@ -91,33 +62,29 @@ system:
 
 * `Python <https://www.python.org/>`_ with pip and virtualenv
 * `Doxygen <http://www.stack.nl/~dimitri/doxygen/>`_
-* `Less <http://lesscss.org/>`_ with ``less-plugin-clean-css``.
-  Ubuntu doesn't package the ``clean-css`` plugin so you should use ``npm``
-  instead of ``apt`` to install both ``less`` and the plugin::
-
-    sudo npm install -g less less-plugin-clean-css.
+* `Less <http://lesscss.org/>`_ with less-plugin-clean-css
 
 First generate makefiles or project files using CMake as described in
 the previous section. Then compile the ``doc`` target/project, for example::
 
   make doc
 
-This will generate the HTML documentation in ``doc/html``.
+This will generate the HTML documenation in ``doc/html``.
   
 Android NDK
 ===========
 
-fmt provides `Android.mk file`__ that can be used to build the library
+C++ Format provides `Android.mk file`__ that can be used to build the library
 with `Android NDK <https://developer.android.com/tools/sdk/ndk/index.html>`_.
-For an example of using fmt with Android NDK, see the
-`android-ndk-example <https://github.com/fmtlib/android-ndk-example>`_
+For an example of using C++ Format with Android NDK, see the
+`android-ndk-example <https://github.com/cppformat/android-ndk-example>`_
 repository.
 
-__ https://github.com/fmtlib/fmt/blob/master/Android.mk
+__ https://github.com/cppformat/cppformat/blob/master/Android.mk
 
 Homebrew
 ========
 
-fmt can be installed on OS X using `Homebrew <http://brew.sh/>`_::
+C++ Format can be installed on OS X using `Homebrew <http://brew.sh/>`_::
 
-  brew install fmt
+  brew install cppformat

format.h

@@ -0,0 +1,2 @@
+#include "cppformat/format.h"
+#warning Including format.h from the top-level directory is deprecated.

include/fmt/chrono.h

@@ -1,452 +0,0 @@
-// Formatting library for C++ - chrono support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_CHRONO_H_
-#define FMT_CHRONO_H_
-
-#include "format.h"
-#include "locale.h"
-
-#include <chrono>
-#include <ctime>
-#include <locale>
-#include <sstream>
-
-FMT_BEGIN_NAMESPACE
-
-namespace internal{
-
-enum class numeric_system {
-  standard,
-  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
-  alternative
-};
-
-// Parses a put_time-like format string and invokes handler actions.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char *parse_chrono_format(
-    const Char *begin, const Char *end, Handler &&handler) {
-  auto ptr = begin;
-  while (ptr != end) {
-    auto c = *ptr;
-    if (c == '}') break;
-    if (c != '%') {
-      ++ptr;
-      continue;
-    }
-    if (begin != ptr)
-      handler.on_text(begin, ptr);
-    ++ptr; // consume '%'
-    if (ptr == end)
-      throw format_error("invalid format");
-    c = *ptr++;
-    switch (c) {
-    case '%':
-      handler.on_text(ptr - 1, ptr);
-      break;
-    case 'n': {
-      const char newline[] = "\n";
-      handler.on_text(newline, newline + 1);
-      break;
-    }
-    case 't': {
-      const char tab[] = "\t";
-      handler.on_text(tab, tab + 1);
-      break;
-    }
-    // Day of the week:
-    case 'a':
-      handler.on_abbr_weekday();
-      break;
-    case 'A':
-      handler.on_full_weekday();
-      break;
-    case 'w':
-      handler.on_dec0_weekday(numeric_system::standard);
-      break;
-    case 'u':
-      handler.on_dec1_weekday(numeric_system::standard);
-      break;
-    // Month:
-    case 'b':
-      handler.on_abbr_month();
-      break;
-    case 'B':
-      handler.on_full_month();
-      break;
-    // Hour, minute, second:
-    case 'H':
-      handler.on_24_hour(numeric_system::standard);
-      break;
-    case 'I':
-      handler.on_12_hour(numeric_system::standard);
-      break;
-    case 'M':
-      handler.on_minute(numeric_system::standard);
-      break;
-    case 'S':
-      handler.on_second(numeric_system::standard);
-      break;
-    // Other:
-    case 'c':
-      handler.on_datetime(numeric_system::standard);
-      break;
-    case 'x':
-      handler.on_loc_date(numeric_system::standard);
-      break;
-    case 'X':
-      handler.on_loc_time(numeric_system::standard);
-      break;
-    case 'D':
-      handler.on_us_date();
-      break;
-    case 'F':
-      handler.on_iso_date();
-      break;
-    case 'r':
-      handler.on_12_hour_time();
-      break;
-    case 'R':
-      handler.on_24_hour_time();
-      break;
-    case 'T':
-      handler.on_iso_time();
-      break;
-    case 'p':
-      handler.on_am_pm();
-      break;
-    case 'z':
-      handler.on_utc_offset();
-      break;
-    case 'Z':
-      handler.on_tz_name();
-      break;
-    // Alternative representation:
-    case 'E': {
-      if (ptr == end)
-        throw format_error("invalid format");
-      c = *ptr++;
-      switch (c) {
-      case 'c':
-        handler.on_datetime(numeric_system::alternative);
-        break;
-      case 'x':
-        handler.on_loc_date(numeric_system::alternative);
-        break;
-      case 'X':
-        handler.on_loc_time(numeric_system::alternative);
-        break;
-      default:
-        throw format_error("invalid format");
-      }
-      break;
-    }
-    case 'O':
-      if (ptr == end)
-        throw format_error("invalid format");
-      c = *ptr++;
-      switch (c) {
-      case 'w':
-        handler.on_dec0_weekday(numeric_system::alternative);
-        break;
-      case 'u':
-        handler.on_dec1_weekday(numeric_system::alternative);
-        break;
-      case 'H':
-        handler.on_24_hour(numeric_system::alternative);
-        break;
-      case 'I':
-        handler.on_12_hour(numeric_system::alternative);
-        break;
-      case 'M':
-        handler.on_minute(numeric_system::alternative);
-        break;
-      case 'S':
-        handler.on_second(numeric_system::alternative);
-        break;
-      default:
-        throw format_error("invalid format");
-      }
-      break;
-    default:
-      throw format_error("invalid format");
-    }
-    begin = ptr;
-  }
-  if (begin != ptr)
-    handler.on_text(begin, ptr);
-  return ptr;
-}
-
-struct chrono_format_checker {
-  void report_no_date() { throw format_error("no date"); }
-
-  template <typename Char>
-  void on_text(const Char *, const Char *) {}
-  void on_abbr_weekday() { report_no_date(); }
-  void on_full_weekday() { report_no_date(); }
-  void on_dec0_weekday(numeric_system) { report_no_date(); }
-  void on_dec1_weekday(numeric_system) { report_no_date(); }
-  void on_abbr_month() { report_no_date(); }
-  void on_full_month() { report_no_date(); }
-  void on_24_hour(numeric_system) {}
-  void on_12_hour(numeric_system) {}
-  void on_minute(numeric_system) {}
-  void on_second(numeric_system) {}
-  void on_datetime(numeric_system) { report_no_date(); }
-  void on_loc_date(numeric_system) { report_no_date(); }
-  void on_loc_time(numeric_system) { report_no_date(); }
-  void on_us_date() { report_no_date(); }
-  void on_iso_date() { report_no_date(); }
-  void on_12_hour_time() {}
-  void on_24_hour_time() {}
-  void on_iso_time() {}
-  void on_am_pm() {}
-  void on_utc_offset() { report_no_date(); }
-  void on_tz_name() { report_no_date(); }
-};
-
-template <typename Int>
-inline int to_int(Int value) {
-  FMT_ASSERT(value >= (std::numeric_limits<int>::min)() &&
-             value <= (std::numeric_limits<int>::max)(), "invalid value");
-  return static_cast<int>(value);
-}
-
-template <typename FormatContext, typename OutputIt>
-struct chrono_formatter {
-  FormatContext &context;
-  OutputIt out;
-  std::chrono::seconds s;
-  std::chrono::milliseconds ms;
-
-  typedef typename FormatContext::char_type char_type;
-
-  explicit chrono_formatter(FormatContext &ctx, OutputIt o)
-    : context(ctx), out(o) {}
-
-  int hour() const { return to_int((s.count() / 3600) % 24); }
-
-  int hour12() const {
-    auto hour = to_int((s.count() / 3600) % 12);
-    return hour > 0 ? hour : 12;
-  }
-
-  int minute() const { return to_int((s.count() / 60) % 60); }
-  int second() const { return to_int(s.count() % 60); }
-
-  std::tm time() const {
-    auto time = std::tm();
-    time.tm_hour = hour();
-    time.tm_min = minute();
-    time.tm_sec = second();
-    return time;
-  }
-
-  void write(int value, int width) {
-    typedef typename int_traits<int>::main_type main_type;
-    main_type n = to_unsigned(value);
-    int num_digits = internal::count_digits(n);
-    if (width > num_digits)
-      out = std::fill_n(out, width - num_digits, '0');
-    out = format_decimal<char_type>(out, n, num_digits);
-  }
-
-  void format_localized(const tm &time, const char *format) {
-    auto locale = context.locale().template get<std::locale>();
-    auto &facet = std::use_facet<std::time_put<char_type>>(locale);
-    std::basic_ostringstream<char_type> os;
-    os.imbue(locale);
-    facet.put(os, os, ' ', &time, format, format + std::strlen(format));
-    auto str = os.str();
-    std::copy(str.begin(), str.end(), out);
-  }
-
-  void on_text(const char_type *begin, const char_type *end) {
-    std::copy(begin, end, out);
-  }
-
-  // These are not implemented because durations don't have date information.
-  void on_abbr_weekday() {}
-  void on_full_weekday() {}
-  void on_dec0_weekday(numeric_system) {}
-  void on_dec1_weekday(numeric_system) {}
-  void on_abbr_month() {}
-  void on_full_month() {}
-  void on_datetime(numeric_system) {}
-  void on_loc_date(numeric_system) {}
-  void on_loc_time(numeric_system) {}
-  void on_us_date() {}
-  void on_iso_date() {}
-  void on_utc_offset() {}
-  void on_tz_name() {}
-
-  void on_24_hour(numeric_system ns) {
-    if (ns == numeric_system::standard)
-      return write(hour(), 2);
-    auto time = tm();
-    time.tm_hour = hour();
-    format_localized(time, "%OH");
-  }
-
-  void on_12_hour(numeric_system ns) {
-    if (ns == numeric_system::standard)
-      return write(hour12(), 2);
-    auto time = tm();
-    time.tm_hour = hour();
-    format_localized(time, "%OI");
-  }
-
-  void on_minute(numeric_system ns) {
-    if (ns == numeric_system::standard)
-      return write(minute(), 2);
-    auto time = tm();
-    time.tm_min = minute();
-    format_localized(time, "%OM");
-  }
-
-  void on_second(numeric_system ns) {
-    if (ns == numeric_system::standard) {
-      write(second(), 2);
-      if (ms != std::chrono::milliseconds(0)) {
-        *out++ = '.';
-        write(to_int(ms.count()), 3);
-      }
-      return;
-    }
-    auto time = tm();
-    time.tm_sec = second();
-    format_localized(time, "%OS");
-  }
-
-  void on_12_hour_time() { format_localized(time(), "%r"); }
-
-  void on_24_hour_time() {
-    write(hour(), 2);
-    *out++ = ':';
-    write(minute(), 2);
-  }
-
-  void on_iso_time() {
-    on_24_hour_time();
-    *out++ = ':';
-    write(second(), 2);
-  }
-
-  void on_am_pm() { format_localized(time(), "%p"); }
-};
-}  // namespace internal
-
-template <typename Period> FMT_CONSTEXPR const char *get_units() {
-  return FMT_NULL;
-}
-template <> FMT_CONSTEXPR const char *get_units<std::atto>() { return "as"; }
-template <> FMT_CONSTEXPR const char *get_units<std::femto>() { return "fs"; }
-template <> FMT_CONSTEXPR const char *get_units<std::pico>() { return "ps"; }
-template <> FMT_CONSTEXPR const char *get_units<std::nano>() { return "ns"; }
-template <> FMT_CONSTEXPR const char *get_units<std::micro>() { return "µs"; }
-template <> FMT_CONSTEXPR const char *get_units<std::milli>() { return "ms"; }
-template <> FMT_CONSTEXPR const char *get_units<std::centi>() { return "cs"; }
-template <> FMT_CONSTEXPR const char *get_units<std::deci>() { return "ds"; }
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<1>>() { return "s"; }
-template <> FMT_CONSTEXPR const char *get_units<std::deca>() { return "das"; }
-template <> FMT_CONSTEXPR const char *get_units<std::hecto>() { return "hs"; }
-template <> FMT_CONSTEXPR const char *get_units<std::kilo>() { return "ks"; }
-template <> FMT_CONSTEXPR const char *get_units<std::mega>() { return "Ms"; }
-template <> FMT_CONSTEXPR const char *get_units<std::giga>() { return "Gs"; }
-template <> FMT_CONSTEXPR const char *get_units<std::tera>() { return "Ts"; }
-template <> FMT_CONSTEXPR const char *get_units<std::peta>() { return "Ps"; }
-template <> FMT_CONSTEXPR const char *get_units<std::exa>() { return "Es"; }
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<60>>() {
-  return "m";
-}
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
-  return "h";
-}
-
-template <typename Rep, typename Period, typename Char>
-struct formatter<std::chrono::duration<Rep, Period>, Char> {
- private:
-  align_spec spec;
-  internal::arg_ref<Char> width_ref;
-  mutable basic_string_view<Char> format_str;
-  typedef std::chrono::duration<Rep, Period> duration;
-
-  struct spec_handler {
-    formatter &f;
-    basic_parse_context<Char> &context;
-
-    typedef internal::arg_ref<Char> arg_ref_type;
-
-    template <typename Id>
-    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(internal::auto_id) {
-      return arg_ref_type(context.next_arg_id());
-    }
-
-    void on_error(const char *msg) { throw format_error(msg); }
-    void on_fill(Char fill) { f.spec.fill_ = fill; }
-    void on_align(alignment align) { f.spec.align_ = align; }
-    void on_width(unsigned width) { f.spec.width_ = width; }
-
-    template <typename Id>
-    void on_dynamic_width(Id arg_id) {
-      f.width_ref = make_arg_ref(arg_id);
-    }
-  };
-
- public:
-  formatter() : spec() {}
-
-  FMT_CONSTEXPR auto parse(basic_parse_context<Char> &ctx)
-      -> decltype(ctx.begin()) {
-    auto begin = ctx.begin(), end = ctx.end();
-    if (begin == end) return begin;
-    spec_handler handler{*this, ctx};
-    begin = internal::parse_align(begin, end, handler);
-    if (begin == end) return begin;
-    begin = internal::parse_width(begin, end, handler);
-    end = parse_chrono_format(begin, end, internal::chrono_format_checker());
-    format_str = basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin));
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(const duration &d, FormatContext &ctx)
-      -> decltype(ctx.out()) {
-    auto begin = format_str.begin(), end = format_str.end();
-    memory_buffer buf;
-    typedef output_range<decltype(ctx.out()), Char> range;
-    basic_writer<range> w(range(ctx.out()));
-    if (begin == end || *begin == '}') {
-      if (const char *unit = get_units<Period>())
-        format_to(buf, "{}{}", d.count(), unit);
-      else if (Period::den == 1)
-        format_to(buf, "{}[{}]s", d.count(), Period::num);
-      else
-        format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den);
-      internal::handle_dynamic_spec<internal::width_checker>(
-        spec.width_, width_ref, ctx);
-    } else {
-      auto out = std::back_inserter(buf);
-      internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out);
-      f.s = std::chrono::duration_cast<std::chrono::seconds>(d);
-      f.ms = std::chrono::duration_cast<std::chrono::milliseconds>(d - f.s);
-      parse_chrono_format(begin, end, f);
-    }
-    w.write(buf.data(), buf.size(), spec);
-    return w.out();
-  }
-};
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_CHRONO_H_

include/fmt/color.h

@@ -1,577 +0,0 @@
-// Formatting library for C++ - color support
-//
-// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_COLOR_H_
-#define FMT_COLOR_H_
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-#ifdef FMT_DEPRECATED_COLORS
-
-// color and (v)print_colored are deprecated.
-enum color { black, red, green, yellow, blue, magenta, cyan, white };
-FMT_API void vprint_colored(color c, string_view format, format_args args);
-FMT_API void vprint_colored(color c, wstring_view format, wformat_args args);
-template <typename... Args>
-inline void print_colored(color c, string_view format_str,
-                          const Args & ... args) {
-  vprint_colored(c, format_str, make_format_args(args...));
-}
-template <typename... Args>
-inline void print_colored(color c, wstring_view format_str,
-                          const Args & ... args) {
-  vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
-}
-
-inline void vprint_colored(color c, string_view format, format_args args) {
-  char escape[] = "\x1b[30m";
-  escape[3] = static_cast<char>('0' + c);
-  std::fputs(escape, stdout);
-  vprint(format, args);
-  std::fputs(internal::data::RESET_COLOR, stdout);
-}
-
-inline void vprint_colored(color c, wstring_view format, wformat_args args) {
-  wchar_t escape[] = L"\x1b[30m";
-  escape[3] = static_cast<wchar_t>('0' + c);
-  std::fputws(escape, stdout);
-  vprint(format, args);
-  std::fputws(internal::data::WRESET_COLOR, stdout);
-}
-
-#else
-
-enum class color : uint32_t {
-  alice_blue              = 0xF0F8FF, // rgb(240,248,255)
-  antique_white           = 0xFAEBD7, // rgb(250,235,215)
-  aqua                    = 0x00FFFF, // rgb(0,255,255)
-  aquamarine              = 0x7FFFD4, // rgb(127,255,212)
-  azure                   = 0xF0FFFF, // rgb(240,255,255)
-  beige                   = 0xF5F5DC, // rgb(245,245,220)
-  bisque                  = 0xFFE4C4, // rgb(255,228,196)
-  black                   = 0x000000, // rgb(0,0,0)
-  blanched_almond         = 0xFFEBCD, // rgb(255,235,205)
-  blue                    = 0x0000FF, // rgb(0,0,255)
-  blue_violet             = 0x8A2BE2, // rgb(138,43,226)
-  brown                   = 0xA52A2A, // rgb(165,42,42)
-  burly_wood              = 0xDEB887, // rgb(222,184,135)
-  cadet_blue              = 0x5F9EA0, // rgb(95,158,160)
-  chartreuse              = 0x7FFF00, // rgb(127,255,0)
-  chocolate               = 0xD2691E, // rgb(210,105,30)
-  coral                   = 0xFF7F50, // rgb(255,127,80)
-  cornflower_blue         = 0x6495ED, // rgb(100,149,237)
-  cornsilk                = 0xFFF8DC, // rgb(255,248,220)
-  crimson                 = 0xDC143C, // rgb(220,20,60)
-  cyan                    = 0x00FFFF, // rgb(0,255,255)
-  dark_blue               = 0x00008B, // rgb(0,0,139)
-  dark_cyan               = 0x008B8B, // rgb(0,139,139)
-  dark_golden_rod         = 0xB8860B, // rgb(184,134,11)
-  dark_gray               = 0xA9A9A9, // rgb(169,169,169)
-  dark_green              = 0x006400, // rgb(0,100,0)
-  dark_khaki              = 0xBDB76B, // rgb(189,183,107)
-  dark_magenta            = 0x8B008B, // rgb(139,0,139)
-  dark_olive_green        = 0x556B2F, // rgb(85,107,47)
-  dark_orange             = 0xFF8C00, // rgb(255,140,0)
-  dark_orchid             = 0x9932CC, // rgb(153,50,204)
-  dark_red                = 0x8B0000, // rgb(139,0,0)
-  dark_salmon             = 0xE9967A, // rgb(233,150,122)
-  dark_sea_green          = 0x8FBC8F, // rgb(143,188,143)
-  dark_slate_blue         = 0x483D8B, // rgb(72,61,139)
-  dark_slate_gray         = 0x2F4F4F, // rgb(47,79,79)
-  dark_turquoise          = 0x00CED1, // rgb(0,206,209)
-  dark_violet             = 0x9400D3, // rgb(148,0,211)
-  deep_pink               = 0xFF1493, // rgb(255,20,147)
-  deep_sky_blue           = 0x00BFFF, // rgb(0,191,255)
-  dim_gray                = 0x696969, // rgb(105,105,105)
-  dodger_blue             = 0x1E90FF, // rgb(30,144,255)
-  fire_brick              = 0xB22222, // rgb(178,34,34)
-  floral_white            = 0xFFFAF0, // rgb(255,250,240)
-  forest_green            = 0x228B22, // rgb(34,139,34)
-  fuchsia                 = 0xFF00FF, // rgb(255,0,255)
-  gainsboro               = 0xDCDCDC, // rgb(220,220,220)
-  ghost_white             = 0xF8F8FF, // rgb(248,248,255)
-  gold                    = 0xFFD700, // rgb(255,215,0)
-  golden_rod              = 0xDAA520, // rgb(218,165,32)
-  gray                    = 0x808080, // rgb(128,128,128)
-  green                   = 0x008000, // rgb(0,128,0)
-  green_yellow            = 0xADFF2F, // rgb(173,255,47)
-  honey_dew               = 0xF0FFF0, // rgb(240,255,240)
-  hot_pink                = 0xFF69B4, // rgb(255,105,180)
-  indian_red              = 0xCD5C5C, // rgb(205,92,92)
-  indigo                  = 0x4B0082, // rgb(75,0,130)
-  ivory                   = 0xFFFFF0, // rgb(255,255,240)
-  khaki                   = 0xF0E68C, // rgb(240,230,140)
-  lavender                = 0xE6E6FA, // rgb(230,230,250)
-  lavender_blush          = 0xFFF0F5, // rgb(255,240,245)
-  lawn_green              = 0x7CFC00, // rgb(124,252,0)
-  lemon_chiffon           = 0xFFFACD, // rgb(255,250,205)
-  light_blue              = 0xADD8E6, // rgb(173,216,230)
-  light_coral             = 0xF08080, // rgb(240,128,128)
-  light_cyan              = 0xE0FFFF, // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
-  light_gray              = 0xD3D3D3, // rgb(211,211,211)
-  light_green             = 0x90EE90, // rgb(144,238,144)
-  light_pink              = 0xFFB6C1, // rgb(255,182,193)
-  light_salmon            = 0xFFA07A, // rgb(255,160,122)
-  light_sea_green         = 0x20B2AA, // rgb(32,178,170)
-  light_sky_blue          = 0x87CEFA, // rgb(135,206,250)
-  light_slate_gray        = 0x778899, // rgb(119,136,153)
-  light_steel_blue        = 0xB0C4DE, // rgb(176,196,222)
-  light_yellow            = 0xFFFFE0, // rgb(255,255,224)
-  lime                    = 0x00FF00, // rgb(0,255,0)
-  lime_green              = 0x32CD32, // rgb(50,205,50)
-  linen                   = 0xFAF0E6, // rgb(250,240,230)
-  magenta                 = 0xFF00FF, // rgb(255,0,255)
-  maroon                  = 0x800000, // rgb(128,0,0)
-  medium_aquamarine       = 0x66CDAA, // rgb(102,205,170)
-  medium_blue             = 0x0000CD, // rgb(0,0,205)
-  medium_orchid           = 0xBA55D3, // rgb(186,85,211)
-  medium_purple           = 0x9370DB, // rgb(147,112,219)
-  medium_sea_green        = 0x3CB371, // rgb(60,179,113)
-  medium_slate_blue       = 0x7B68EE, // rgb(123,104,238)
-  medium_spring_green     = 0x00FA9A, // rgb(0,250,154)
-  medium_turquoise        = 0x48D1CC, // rgb(72,209,204)
-  medium_violet_red       = 0xC71585, // rgb(199,21,133)
-  midnight_blue           = 0x191970, // rgb(25,25,112)
-  mint_cream              = 0xF5FFFA, // rgb(245,255,250)
-  misty_rose              = 0xFFE4E1, // rgb(255,228,225)
-  moccasin                = 0xFFE4B5, // rgb(255,228,181)
-  navajo_white            = 0xFFDEAD, // rgb(255,222,173)
-  navy                    = 0x000080, // rgb(0,0,128)
-  old_lace                = 0xFDF5E6, // rgb(253,245,230)
-  olive                   = 0x808000, // rgb(128,128,0)
-  olive_drab              = 0x6B8E23, // rgb(107,142,35)
-  orange                  = 0xFFA500, // rgb(255,165,0)
-  orange_red              = 0xFF4500, // rgb(255,69,0)
-  orchid                  = 0xDA70D6, // rgb(218,112,214)
-  pale_golden_rod         = 0xEEE8AA, // rgb(238,232,170)
-  pale_green              = 0x98FB98, // rgb(152,251,152)
-  pale_turquoise          = 0xAFEEEE, // rgb(175,238,238)
-  pale_violet_red         = 0xDB7093, // rgb(219,112,147)
-  papaya_whip             = 0xFFEFD5, // rgb(255,239,213)
-  peach_puff              = 0xFFDAB9, // rgb(255,218,185)
-  peru                    = 0xCD853F, // rgb(205,133,63)
-  pink                    = 0xFFC0CB, // rgb(255,192,203)
-  plum                    = 0xDDA0DD, // rgb(221,160,221)
-  powder_blue             = 0xB0E0E6, // rgb(176,224,230)
-  purple                  = 0x800080, // rgb(128,0,128)
-  rebecca_purple          = 0x663399, // rgb(102,51,153)
-  red                     = 0xFF0000, // rgb(255,0,0)
-  rosy_brown              = 0xBC8F8F, // rgb(188,143,143)
-  royal_blue              = 0x4169E1, // rgb(65,105,225)
-  saddle_brown            = 0x8B4513, // rgb(139,69,19)
-  salmon                  = 0xFA8072, // rgb(250,128,114)
-  sandy_brown             = 0xF4A460, // rgb(244,164,96)
-  sea_green               = 0x2E8B57, // rgb(46,139,87)
-  sea_shell               = 0xFFF5EE, // rgb(255,245,238)
-  sienna                  = 0xA0522D, // rgb(160,82,45)
-  silver                  = 0xC0C0C0, // rgb(192,192,192)
-  sky_blue                = 0x87CEEB, // rgb(135,206,235)
-  slate_blue              = 0x6A5ACD, // rgb(106,90,205)
-  slate_gray              = 0x708090, // rgb(112,128,144)
-  snow                    = 0xFFFAFA, // rgb(255,250,250)
-  spring_green            = 0x00FF7F, // rgb(0,255,127)
-  steel_blue              = 0x4682B4, // rgb(70,130,180)
-  tan                     = 0xD2B48C, // rgb(210,180,140)
-  teal                    = 0x008080, // rgb(0,128,128)
-  thistle                 = 0xD8BFD8, // rgb(216,191,216)
-  tomato                  = 0xFF6347, // rgb(255,99,71)
-  turquoise               = 0x40E0D0, // rgb(64,224,208)
-  violet                  = 0xEE82EE, // rgb(238,130,238)
-  wheat                   = 0xF5DEB3, // rgb(245,222,179)
-  white                   = 0xFFFFFF, // rgb(255,255,255)
-  white_smoke             = 0xF5F5F5, // rgb(245,245,245)
-  yellow                  = 0xFFFF00, // rgb(255,255,0)
-  yellow_green            = 0x9ACD32  // rgb(154,205,50)
-};  // enum class color
-
-enum class terminal_color : uint8_t {
-  black = 30,
-  red,
-  green,
-  yellow,
-  blue,
-  magenta,
-  cyan,
-  white,
-  bright_black = 90,
-  bright_red,
-  bright_green,
-  bright_yellow,
-  bright_blue,
-  bright_magenta,
-  bright_cyan,
-  bright_white
-};  // enum class terminal_color
-
-enum class emphasis : uint8_t {
-  bold = 1,
-  italic = 1 << 1,
-  underline = 1 << 2,
-  strikethrough = 1 << 3
-};  // enum class emphasis
-
-// rgb is a struct for red, green and blue colors.
-// We use rgb as name because some editors will show it as color direct in the
-// editor.
-struct rgb {
-  FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
-  FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
-    : r(r_), g(g_), b(b_) {}
-  FMT_CONSTEXPR_DECL rgb(uint32_t hex)
-    : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {}
-  FMT_CONSTEXPR_DECL rgb(color hex)
-    : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
-      b(uint32_t(hex) & 0xFF) {}
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
-};
-
-namespace internal {
-
-// 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), value{} {
-    value.rgb_color = static_cast<uint32_t>(rgb_color);
-  }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT
-    : is_rgb(true), value{} {
-    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16)
-       | (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
-  }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT
-    : is_rgb(), value{} {
-    value.term_color = static_cast<uint8_t>(term_color);
-  }
-  bool is_rgb;
-  union color_union {
-    uint8_t term_color;
-    uint32_t rgb_color;
-  } value;
-};
-} // namespace internal
-
-// Experimental text formatting support.
-class text_style {
- public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(), set_background_color(), ems(em) {}
-
-  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)
-        throw format_error("can't OR a terminal color");
-      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
-    }
-
-    if (!set_background_color) {
-      set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        throw format_error("can't OR a terminal color");
-      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR
-  text_style operator|(text_style lhs, const text_style &rhs) {
-    return lhs |= rhs;
-  }
-
-  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)
-        throw format_error("can't AND a terminal color");
-      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
-    }
-
-    if (!set_background_color) {
-      set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        throw format_error("can't AND a terminal color");
-      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR
-  text_style operator&(text_style lhs, const text_style &rhs) {
-    return lhs &= rhs;
-  }
-
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
-    return set_foreground_color;
-  }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
-    return set_background_color;
-  }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
-    return static_cast<uint8_t>(ems) != 0;
-  }
-  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
-    assert(has_foreground() && "no foreground specified for this style");
-    return foreground_color;
-  }
-  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
-    assert(has_background() && "no background specified for this style");
-    return background_color;
-  }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
-    assert(has_emphasis() && "no emphasis specified for this style");
-    return ems;
-  }
-
-private:
- FMT_CONSTEXPR text_style(bool is_foreground,
-                          internal::color_type text_color) FMT_NOEXCEPT
-     : set_foreground_color(),
-       set_background_color(),
-       ems() {
-   if (is_foreground) {
-     foreground_color = text_color;
-     set_foreground_color = true;
-   } else {
-     background_color = text_color;
-     set_background_color = true;
-   }
- }
-
-  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
-      FMT_NOEXCEPT;
-  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
-      FMT_NOEXCEPT;
-
-  internal::color_type foreground_color;
-  internal::color_type background_color;
-  bool set_foreground_color;
-  bool set_background_color;
-  emphasis ems;
-};
-
-FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
-  return text_style(/*is_foreground=*/true, foreground);
-}
-
-FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
-  return text_style(/*is_foreground=*/false, background);
-}
-
-FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
-  return text_style(lhs) | rhs;
-}
-
-namespace internal {
-
-template <typename Char>
-struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
-                                  const char * esc) FMT_NOEXCEPT {
-    // If we have a terminal color, we need to output another escape code
-    // sequence.
-    if (!text_color.is_rgb) {
-      bool is_background = esc == internal::data::BACKGROUND_COLOR;
-      uint32_t value = text_color.value.term_color;
-      // Background ASCII codes are the same as the foreground ones but with
-      // 10 more.
-      if (is_background)
-        value += 10u;
-
-      std::size_t index = 0;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-
-      if (value >= 100u) {
-        buffer[index++] = static_cast<Char>('1');
-        value %= 100u;
-      }
-      buffer[index++] = static_cast<Char>('0' + value / 10u);
-      buffer[index++] = static_cast<Char>('0' + value % 10u);
-
-      buffer[index++] = static_cast<Char>('m');
-      buffer[index++] = static_cast<Char>('\0');
-      return;
-    }
-
-    for (int i = 0; i < 7; i++) {
-      buffer[i] = static_cast<Char>(esc[i]);
-    }
-    rgb color(text_color.value.rgb_color);
-    to_esc(color.r, buffer +  7, ';');
-    to_esc(color.g, buffer + 11, ';');
-    to_esc(color.b, buffer + 15, 'm');
-    buffer[19] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
-    uint8_t em_codes[4] = {};
-    uint8_t em_bits = static_cast<uint8_t>(em);
-    if (em_bits & static_cast<uint8_t>(emphasis::bold))
-      em_codes[0] = 1;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic))
-      em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline))
-      em_codes[2] = 4;
-    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
-      em_codes[3] = 9;
-
-    std::size_t index = 0;
-    for (int i = 0; i < 4; ++i) {
-      if (!em_codes[i])
-        continue;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
-      buffer[index++] = static_cast<Char>('m');
-    }
-    buffer[index++] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; }
-
-private:
-  Char buffer[7u + 3u * 4u + 1u];
-
-  static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out,
-                                   char delimiter) FMT_NOEXCEPT {
-    out[0] = static_cast<Char>('0' + c / 100);
-    out[1] = static_cast<Char>('0' + c / 10 % 10);
-    out[2] = static_cast<Char>('0' + c % 10);
-    out[3] = static_cast<Char>(delimiter);
-  }
-};
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
-make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
-make_background_color(internal::color_type background) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
-make_emphasis(emphasis em) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(em);
-}
-
-template <typename Char>
-inline void fputs(const Char *chars, FILE *stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
-}
-
-template <>
-inline void fputs<wchar_t>(const wchar_t *chars, FILE *stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
-}
-
-template <typename Char>
-inline void reset_color(FILE *stream) FMT_NOEXCEPT {
-  fputs(internal::data::RESET_COLOR, stream);
-}
-
-template <>
-inline void reset_color<wchar_t>(FILE *stream) FMT_NOEXCEPT {
-  fputs(internal::data::WRESET_COLOR, stream);
-}
-
-// The following specialiazation disables using std::FILE as a character type,
-// which is needed because or else
-//   fmt::print(stderr, fmt::emphasis::bold, "");
-// would take stderr (a std::FILE *) as the format string.
-template <>
-struct is_string<std::FILE *> : std::false_type {};
-template <>
-struct is_string<const std::FILE *> : std::false_type {};
-} // namespace internal
-
-template <
-  typename S, typename Char = typename internal::char_t<S>::type>
-void vprint(std::FILE *f, const text_style &ts, const S &format,
-            basic_format_args<typename buffer_context<Char>::type> args) {
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    internal::fputs<Char>(
-          internal::make_emphasis<Char>(ts.get_emphasis()), f);
-  }
-  if (ts.has_foreground()) {
-    has_style = true;
-    internal::fputs<Char>(
-          internal::make_foreground_color<Char>(ts.get_foreground()), f);
-  }
-  if (ts.has_background()) {
-    has_style = true;
-    internal::fputs<Char>(
-        internal::make_background_color<Char>(ts.get_background()), f);
-  }
-  vprint(f, format, args);
-  if (has_style) {
-    internal::reset_color<Char>(f);
-  }
-}
-
-/**
-  Formats a string and prints it to the specified file stream using ANSI
-  escape sequences to specify text formatting.
-  Example:
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
- */
-template <typename String, typename... Args>
-typename std::enable_if<internal::is_string<String>::value>::type print(
-    std::FILE *f, const text_style &ts, const String &format_str,
-    const Args &... args) {
-  internal::check_format_string<Args...>(format_str);
-  typedef typename internal::char_t<String>::type char_t;
-  typedef typename buffer_context<char_t>::type context_t;
-  format_arg_store<context_t, Args...> as{args...};
-  vprint(f, ts, format_str, basic_format_args<context_t>(as));
-}
-
-/**
-  Formats a string and prints it to stdout using ANSI escape sequences to
-  specify text formatting.
-  Example:
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
- */
-template <typename String, typename... Args>
-typename std::enable_if<internal::is_string<String>::value>::type print(
-    const text_style &ts, const String &format_str,
-    const Args &... args) {
-  return print(stdout, ts, format_str, args...);
-}
-
-#endif
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_COLOR_H_

include/fmt/format-inl.h

@@ -1,972 +0,0 @@
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_FORMAT_INL_H_
-#define FMT_FORMAT_INL_H_
-
-#include "format.h"
-
-#include <string.h>
-
-#include <cctype>
-#include <cerrno>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-#include <cstring>  // for std::memmove
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-# include <locale>
-#endif
-
-#if FMT_USE_WINDOWS_H
-# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#  define WIN32_LEAN_AND_MEAN
-# endif
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#  include <windows.h>
-# else
-#  define NOMINMAX
-#  include <windows.h>
-#  undef NOMINMAX
-# endif
-#endif
-
-#if FMT_EXCEPTIONS
-# define FMT_TRY try
-# define FMT_CATCH(x) catch (x)
-#else
-# define FMT_TRY if (true)
-# define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127)  // conditional expression is constant
-# pragma warning(disable: 4702)  // unreachable code
-// Disable deprecation warning for strerror. The latter is not called but
-// MSVC fails to detect it.
-# pragma warning(disable: 4996)
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char *, ...) {
-  return fmt::internal::null<>();
-}
-inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
-  return fmt::internal::null<>();
-}
-
-FMT_BEGIN_NAMESPACE
-
-namespace {
-
-#ifndef _MSC_VER
-# define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-# define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-# define FMT_SWPRINTF snwprintf
-#else
-# define FMT_SWPRINTF swprintf
-#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-
-typedef void (*FormatFunc)(internal::buffer &, int, string_view);
-
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-int safe_strerror(
-    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char *&buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher &) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char *message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
-
-    // Handle the case when strerror_r is not available.
-    int handle(internal::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
-
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
-            ERANGE : result;
-    }
-
-#if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
-#endif
-
-   public:
-    dispatcher(int err_code, char *&buf, std::size_t buf_size)
-      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() {
-      return handle(strerror_r(error_code_, buffer_, buffer_size_));
-    }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
-
-void format_error_code(internal::buffer &out, int error_code,
-                       string_view message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  typedef internal::int_traits<int>::main_type main_type;
-  main_type abs_value = static_cast<main_type>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
-  writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
-  }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
-}
-
-void report_error(FormatFunc func, int error_code,
-                  string_view message) FMT_NOEXCEPT {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  // Use Writer::data instead of Writer::c_str to avoid potential memory
-  // allocation.
-  std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-}
-}  // namespace
-
-FMT_FUNC size_t internal::count_code_points(basic_string_view<char8_t> s) {
-  const char8_t *data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80)
-      ++num_code_points;
-  }
-  return num_code_points;
-}
-
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-namespace internal {
-
-template <typename Locale>
-locale_ref::locale_ref(const Locale &loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
-
-template <typename Locale>
-Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
-
-template <typename Char>
-FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char> >(
-    loc.get<std::locale>()).thousands_sep();
-}
-}
-#else
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
-  return FMT_STATIC_THOUSANDS_SEPARATOR;
-}
-#endif
-
-FMT_FUNC void system_error::init(
-    int err_code, string_view format_str, format_args args) {
-  error_code_ = err_code;
-  memory_buffer buffer;
-  format_system_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(to_string(buffer));
-}
-
-namespace internal {
-template <typename T>
-int char_traits<char>::format_float(
-    char *buf, std::size_t size, const char *format, int precision, T value) {
-  return precision < 0 ?
-      FMT_SNPRINTF(buf, size, format, value) :
-      FMT_SNPRINTF(buf, size, format, precision, value);
-}
-
-template <typename T>
-int char_traits<wchar_t>::format_float(
-    wchar_t *buf, std::size_t size, const wchar_t *format, int precision,
-    T value) {
-  return precision < 0 ?
-      FMT_SWPRINTF(buf, size, format, value) :
-      FMT_SWPRINTF(buf, size, format, precision, value);
-}
-
-template <typename T>
-const char basic_data<T>::DIGITS[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-#define FMT_POWERS_OF_10(factor) \
-  factor * 10, \
-  factor * 100, \
-  factor * 1000, \
-  factor * 10000, \
-  factor * 100000, \
-  factor * 1000000, \
-  factor * 10000000, \
-  factor * 100000000, \
-  factor * 1000000000
-
-template <typename T>
-const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
-  1, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {
-  0, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = {
-  0,
-  FMT_POWERS_OF_10(1),
-  FMT_POWERS_OF_10(1000000000ull),
-  10000000000000000000ull
-};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
-  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-  0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-  0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-  0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-  0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-  0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-  0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-  0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-  0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-  0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-  0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-  0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-  0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-  0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-  0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-  0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-  0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-  0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-  0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-  0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-  0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-  0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
-
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::POW10_EXPONENTS[] = {
-  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,  -954,
-   -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,
-   -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396,  -369,
-   -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103,   -77,
-    -50,   -24,     3,    30,    56,    83,   109,   136,   162,   189,   216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,   508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,   800,
-    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
-};
-
-template <typename T> const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
-template <typename T> const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
-
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  typedef uint64_t significand_type;
-
-  // All sizes are in bits.
-  static FMT_CONSTEXPR_DECL const int char_size =
-    std::numeric_limits<unsigned char>::digits;
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-    std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-    1ull << double_significand_size;
-
- public:
-  significand_type f;
-  int e;
-
-  static FMT_CONSTEXPR_DECL const int significand_size =
-    sizeof(significand_type) * char_size;
-
-  fp(): f(0), e(0) {}
-  fp(uint64_t f_val, int e_val): f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double>
-  explicit fp(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    typedef std::numeric_limits<Double> limits;
-    const int double_size = static_cast<int>(sizeof(Double) * char_size);
-    const int exponent_size =
-      double_size - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    f = u & significand_mask;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-  }
-
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT = 0>
-  void normalize() {
-    // Handle subnormals.
-    auto shifted_implicit_bit = implicit_bit << SHIFT;
-    while ((f & shifted_implicit_bit) == 0) {
-      f <<= 1;
-      --e;
-    }
-    // Subtract 1 to account for hidden bit.
-    auto offset = significand_size - double_significand_size - SHIFT - 1;
-    f <<= offset;
-    e -= offset;
-  }
-
-  // Compute lower and upper boundaries (m^- and m^+ in the Grisu paper), where
-  // a boundary is a value half way between the number and its predecessor
-  // (lower) or successor (upper). The upper boundary is normalized and lower
-  // has the same exponent but may be not normalized.
-  void compute_boundaries(fp &lower, fp &upper) const {
-    lower = f == implicit_bit ?
-          fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
-    upper = fp((f << 1) + 1, e - 1);
-    upper.normalize<1>();  // 1 is to account for the exponent shift above.
-    lower.f <<= lower.e - upper.e;
-    lower.e = upper.e;
-  }
-};
-
-// Returns an fp number representing x - y. Result may not be normalized.
-inline fp operator-(fp x, fp y) {
-  FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
-  return fp(x.f - y.f, x.e);
-}
-
-// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
-// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be normalized.
-FMT_API fp operator*(fp x, fp y);
-
-// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
-// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3.
-FMT_API fp get_cached_power(int min_exponent, int &pow10_exponent);
-
-FMT_FUNC fp operator*(fp x, fp y) {
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = x.f >> 32, b = x.f & mask;
-  uint64_t c = y.f >> 32, d = y.f & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
-}
-
-FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
-  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-  int index = static_cast<int>(std::ceil(
-        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
-}
-
-FMT_FUNC bool grisu2_round(
-    char *buf, int &size, int max_digits, uint64_t delta,
-    uint64_t remainder, uint64_t exp, uint64_t diff, int &exp10) {
-  while (remainder < diff && delta - remainder >= exp &&
-        (remainder + exp < diff || diff - remainder > remainder + exp - diff)) {
-    --buf[size - 1];
-    remainder += exp;
-  }
-  if (size > max_digits) {
-    --size;
-    ++exp10;
-    if (buf[size] >= '5')
-      return false;
-  }
-  return true;
-}
-
-// Generates output using Grisu2 digit-gen algorithm.
-FMT_FUNC bool grisu2_gen_digits(
-    char *buf, int &size, uint32_t hi, uint64_t lo, int &exp,
-    uint64_t delta, const fp &one, const fp &diff, int max_digits) {
-  // Generate digits for the most significant part (hi).
-  while (exp > 0) {
-    uint32_t digit = 0;
-    // This optimization by miloyip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10: digit = hi / 1000000000; hi %= 1000000000; break;
-    case  9: digit = hi /  100000000; hi %=  100000000; break;
-    case  8: digit = hi /   10000000; hi %=   10000000; break;
-    case  7: digit = hi /    1000000; hi %=    1000000; break;
-    case  6: digit = hi /     100000; hi %=     100000; break;
-    case  5: digit = hi /      10000; hi %=      10000; break;
-    case  4: digit = hi /       1000; hi %=       1000; break;
-    case  3: digit = hi /        100; hi %=        100; break;
-    case  2: digit = hi /         10; hi %=         10; break;
-    case  1: digit = hi;              hi =           0; break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    if (digit != 0 || size != 0)
-      buf[size++] = static_cast<char>('0' + digit);
-    --exp;
-    uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo;
-    if (remainder <= delta || size > max_digits) {
-      return grisu2_round(
-            buf, size, max_digits, delta, remainder,
-            static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e,
-            diff.f, exp);
-    }
-  }
-  // Generate digits for the least significant part (lo).
-  for (;;) {
-    lo *= 10;
-    delta *= 10;
-    char digit = static_cast<char>(lo >> -one.e);
-    if (digit != 0 || size != 0)
-      buf[size++] = static_cast<char>('0' + digit);
-    lo &= one.f - 1;
-    --exp;
-    if (lo < delta || size > max_digits) {
-      return grisu2_round(buf, size, max_digits, delta, lo, one.f,
-                          diff.f * data::POWERS_OF_10_32[-exp], exp);
-    }
-  }
-}
-
-#if FMT_CLANG_VERSION
-# define FMT_FALLTHROUGH [[clang::fallthrough]];
-#elif FMT_GCC_VERSION >= 700
-# define FMT_FALLTHROUGH [[gnu::fallthrough]];
-#else
-# define FMT_FALLTHROUGH
-#endif
-
-struct gen_digits_params {
-  int num_digits;
-  bool fixed;
-  bool upper;
-  bool trailing_zeros;
-};
-
-struct prettify_handler {
-  char *data;
-  ptrdiff_t size;
-  buffer &buf;
-
-  explicit prettify_handler(buffer &b, ptrdiff_t n)
-    : data(b.data()), size(n), buf(b) {}
-  ~prettify_handler() {
-    assert(buf.size() >= to_unsigned(size));
-    buf.resize(to_unsigned(size));
-  }
-
-  template <typename F>
-  void insert(ptrdiff_t pos, ptrdiff_t n, F f) {
-    std::memmove(data + pos + n, data + pos, to_unsigned(size - pos));
-    f(data + pos);
-    size += n;
-  }
-
-  void insert(ptrdiff_t pos, char c) {
-    std::memmove(data + pos + 1, data + pos, to_unsigned(size - pos));
-    data[pos] = c;
-    ++size;
-  }
-
-  void append(ptrdiff_t n, char c) {
-    std::uninitialized_fill_n(data + size, n, c);
-    size += n;
-  }
-
-  void append(char c) { data[size++] = c; }
-
-  void remove_trailing(char c) {
-    while (data[size - 1] == c) --size;
-  }
-};
-
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Handler>
-FMT_FUNC void write_exponent(int exp, Handler &&h) {
-  FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
-  if (exp < 0) {
-    h.append('-');
-    exp = -exp;
-  } else {
-    h.append('+');
-  }
-  if (exp >= 100) {
-    h.append(static_cast<char>('0' + exp / 100));
-    exp %= 100;
-    const char *d = data::DIGITS + exp * 2;
-    h.append(d[0]);
-    h.append(d[1]);
-  } else {
-    const char *d = data::DIGITS + exp * 2;
-    h.append(d[0]);
-    h.append(d[1]);
-  }
-}
-
-struct fill {
-  size_t n;
-  void operator()(char *buf) const {
-    buf[0] = '0';
-    buf[1] = '.';
-    std::uninitialized_fill_n(buf + 2, n, '0');
-  }
-};
-
-// The number is given as v = f * pow(10, exp), where f has size digits.
-template <typename Handler>
-FMT_FUNC void grisu2_prettify(const gen_digits_params &params,
-                              int size, int exp, Handler &&handler) {
-  if (!params.fixed) {
-    // Insert a decimal point after the first digit and add an exponent.
-    handler.insert(1, '.');
-    exp += size - 1;
-    if (size < params.num_digits)
-      handler.append(params.num_digits - size, '0');
-    handler.append(params.upper ? 'E' : 'e');
-    write_exponent(exp, handler);
-    return;
-  }
-  // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
-  int full_exp = size + exp;
-  const int exp_threshold = 21;
-  if (size <= full_exp && full_exp <= exp_threshold) {
-    // 1234e7 -> 12340000000[.0+]
-    handler.append(full_exp - size, '0');
-    int num_zeros = params.num_digits - full_exp;
-    if (num_zeros > 0 && params.trailing_zeros) {
-      handler.append('.');
-      handler.append(num_zeros, '0');
-    }
-  } else if (full_exp > 0) {
-    // 1234e-2 -> 12.34[0+]
-    handler.insert(full_exp, '.');
-    if (!params.trailing_zeros) {
-      // Remove trailing zeros.
-      handler.remove_trailing('0');
-    } else if (params.num_digits > size) {
-      // Add trailing zeros.
-      ptrdiff_t num_zeros = params.num_digits - size;
-      handler.append(num_zeros, '0');
-    }
-  } else {
-    // 1234e-6 -> 0.001234
-    handler.insert(0, 2 - full_exp, fill{to_unsigned(-full_exp)});
-  }
-}
-
-struct char_counter {
-  ptrdiff_t size;
-
-  template <typename F>
-  void insert(ptrdiff_t, ptrdiff_t n, F) { size += n; }
-  void insert(ptrdiff_t, char) { ++size; }
-  void append(ptrdiff_t n, char) { size += n; }
-  void append(char) { ++size; }
-  void remove_trailing(char) {}
-};
-
-// Converts format specifiers into parameters for digit generation and computes
-// output buffer size for a number in the range [pow(10, exp - 1), pow(10, exp)
-// or 0 if exp == 1.
-FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
-                                         int exp, buffer &buf) {
-  auto params = gen_digits_params();
-  int num_digits = specs.precision >= 0 ? specs.precision : 6;
-  switch (specs.type) {
-  case 'G':
-    params.upper = true;
-    FMT_FALLTHROUGH
-  case '\0': case 'g':
-    params.trailing_zeros = (specs.flags & HASH_FLAG) != 0;
-    if (-4 <= exp && exp < num_digits + 1) {
-      params.fixed = true;
-      if (!specs.type && params.trailing_zeros && exp >= 0)
-        num_digits = exp + 1;
-    }
-    break;
-  case 'F':
-    params.upper = true;
-    FMT_FALLTHROUGH
-  case 'f': {
-    params.fixed = true;
-    params.trailing_zeros = true;
-    int adjusted_min_digits = num_digits + exp;
-    if (adjusted_min_digits > 0)
-      num_digits = adjusted_min_digits;
-    break;
-  }
-  case 'E':
-    params.upper = true;
-    FMT_FALLTHROUGH
-  case 'e':
-    ++num_digits;
-    break;
-  }
-  params.num_digits = num_digits;
-  char_counter counter{num_digits};
-  grisu2_prettify(params, params.num_digits, exp - num_digits, counter);
-  buf.resize(to_unsigned(counter.size));
-  return params;
-}
-
-template <typename Double>
-FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type
-    grisu2_format(Double value, buffer &buf, core_format_specs specs) {
-  FMT_ASSERT(value >= 0, "value is negative");
-  if (value == 0) {
-    gen_digits_params params = process_specs(specs, 1, buf);
-    const size_t size = 1;
-    buf[0] = '0';
-    grisu2_prettify(params, size, 0, prettify_handler(buf, size));
-    return true;
-  }
-
-  fp fp_value(value);
-  fp lower, upper;  // w^- and w^+ in the Grisu paper.
-  fp_value.compute_boundaries(lower, upper);
-
-  // Find a cached power of 10 close to 1 / upper and use it to scale upper.
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp = 0;  // K in Grisu.
-  auto cached_pow = get_cached_power(  // \tilde{c}_{-k} in Grisu.
-      min_exp - (upper.e + fp::significand_size), cached_exp);
-  cached_exp = -cached_exp;
-  upper = upper * cached_pow;  // \tilde{M}^+ in Grisu.
-  --upper.f;  // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
-  fp one(1ull << -upper.e, upper.e);
-  // hi (p1 in Grisu) contains the most significant digits of scaled_upper.
-  // hi = floor(upper / one).
-  uint32_t hi = static_cast<uint32_t>(upper.f >> -one.e);
-  int exp = count_digits(hi);  // kappa in Grisu.
-  gen_digits_params params = process_specs(specs, cached_exp + exp, buf);
-  fp_value.normalize();
-  fp scaled_value = fp_value * cached_pow;
-  lower = lower * cached_pow;  // \tilde{M}^- in Grisu.
-  ++lower.f;  // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
-  uint64_t delta = upper.f - lower.f;
-  fp diff = upper - scaled_value; // wp_w in Grisu.
-  // lo (p2 in Grisu) contains the least significants digits of scaled_upper.
-  // lo = supper % one.
-  uint64_t lo = upper.f & (one.f - 1);
-  int size = 0;
-  if (!grisu2_gen_digits(buf.data(), size, hi, lo, exp, delta, one, diff,
-                         params.num_digits)) {
-    buf.clear();
-    return false;
-  }
-  grisu2_prettify(params, size, cached_exp + exp, prettify_handler(buf, size));
-  return true;
-}
-
-template <typename Double>
-void sprintf_format(Double value, internal::buffer &buf,
-                    core_format_specs spec) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
-
-  // Build format string.
-  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
-  char format[MAX_FORMAT_SIZE];
-  char *format_ptr = format;
-  *format_ptr++ = '%';
-  if (spec.has(HASH_FLAG))
-    *format_ptr++ = '#';
-  if (spec.precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<Double, long double>::value)
-    *format_ptr++ = 'L';
-  *format_ptr++ = spec.type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char *start = FMT_NULL;
-  for (;;) {
-    std::size_t buffer_size = buf.capacity();
-    start = &buf[0];
-    int result = internal::char_traits<char>::format_float(
-        start, buffer_size, format, spec.precision, value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buf.capacity()) {
-        buf.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
-      }
-      buf.reserve(n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buf.reserve(buf.capacity() + 1);
-    }
-  }
-}
-}  // namespace internal
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
-  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-  if (s.size() > INT_MAX)
-    FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
-  int s_size = static_cast<int>(s.size());
-  if (s_size == 0) {
-    // MultiByteToWideChar does not support zero length, handle separately.
-    buffer_.resize(1);
-    buffer_[0] = 0;
-    return;
-  }
-
-  int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
-  if (length == 0)
-    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
-  buffer_.resize(length + 1);
-  length = MultiByteToWideChar(
-    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
-  if (length == 0)
-    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
-  buffer_[length] = 0;
-}
-
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
-  if (int error_code = convert(s)) {
-    FMT_THROW(windows_error(error_code,
-        "cannot convert string from UTF-16 to UTF-8"));
-  }
-}
-
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-  if (s.size() > INT_MAX)
-    return ERROR_INVALID_PARAMETER;
-  int s_size = static_cast<int>(s.size());
-  if (s_size == 0) {
-    // WideCharToMultiByte does not support zero length, handle separately.
-    buffer_.resize(1);
-    buffer_[0] = 0;
-    return 0;
-  }
-
-  int length = WideCharToMultiByte(
-        CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
-  if (length == 0)
-    return GetLastError();
-  buffer_.resize(length + 1);
-  length = WideCharToMultiByte(
-    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
-  if (length == 0)
-    return GetLastError();
-  buffer_[length] = 0;
-  return 0;
-}
-
-FMT_FUNC void windows_error::init(
-    int err_code, string_view format_str, format_args args) {
-  error_code_ = err_code;
-  memory_buffer buffer;
-  internal::format_windows_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(to_string(buffer));
-}
-
-FMT_FUNC void internal::format_windows_error(
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
-    wmemory_buffer buf;
-    buf.resize(inline_buffer_size);
-    for (;;) {
-      wchar_t *system_message = &buf[0];
-      int result = FormatMessageW(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
-      if (result != 0) {
-        utf16_to_utf8 utf8_message;
-        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
-          writer w(out);
-          w.write(message);
-          w.write(": ");
-          w.write(utf8_message);
-          return;
-        }
-        break;
-      }
-      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-        break;  // Can't get error message, report error code instead.
-      buf.resize(buf.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  format_error_code(out, error_code, message);
-}
-
-#endif  // FMT_USE_WINDOWS_H
-
-FMT_FUNC void format_system_error(
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
-    memory_buffer buf;
-    buf.resize(inline_buffer_size);
-    for (;;) {
-      char *system_message = &buf[0];
-      int result = safe_strerror(error_code, system_message, buf.size());
-      if (result == 0) {
-        writer w(out);
-        w.write(message);
-        w.write(": ");
-        w.write(system_message);
-        return;
-      }
-      if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
-      buf.resize(buf.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  format_error_code(out, error_code, message);
-}
-
-FMT_FUNC void internal::error_handler::on_error(const char *message) {
-  FMT_THROW(format_error(message));
-}
-
-FMT_FUNC void report_system_error(
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
-  report_error(format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
-  report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
-  memory_buffer buffer;
-  internal::vformat_to(buffer, format_str,
-                       basic_format_args<buffer_context<char>::type>(args));
-  std::fwrite(buffer.data(), 1, buffer.size(), f);
-}
-
-FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
-  wmemory_buffer buffer;
-  internal::vformat_to(buffer, format_str, args);
-  std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
-}
-
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
-}
-
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
-  vprint(stdout, format_str, args);
-}
-
-FMT_END_NAMESPACE
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif  // FMT_FORMAT_INL_H_

include/fmt/locale.h

@@ -1,77 +0,0 @@
-// Formatting library for C++ - std::locale support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_LOCALE_H_
-#define FMT_LOCALE_H_
-
-#include "format.h"
-#include <locale>
-
-FMT_BEGIN_NAMESPACE
-
-namespace internal {
-template <typename Char>
-typename buffer_context<Char>::type::iterator vformat_to(
-    const std::locale &loc, basic_buffer<Char> &buf,
-    basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
-  typedef back_insert_range<basic_buffer<Char> > range;
-  return vformat_to<arg_formatter<range>>(
-    buf, to_string_view(format_str), args, internal::locale_ref(loc));
-}
-
-template <typename Char>
-std::basic_string<Char> vformat(
-    const std::locale &loc, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(loc, buffer, format_str, args);
-  return fmt::to_string(buffer);
-}
-}
-
-template <typename S, typename Char = FMT_CHAR(S)>
-inline std::basic_string<Char> vformat(
-    const std::locale &loc, const S &format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
-  return internal::vformat(loc, to_string_view(format_str), args);
-}
-
-template <typename S, typename... Args>
-inline std::basic_string<FMT_CHAR(S)> format(
-    const std::locale &loc, const S &format_str, const Args &... args) {
-  return internal::vformat(
-    loc, to_string_view(format_str),
-    *internal::checked_args<S, Args...>(format_str, args...));
-}
-
-template <typename String, typename OutputIt, typename... Args>
-inline typename std::enable_if<internal::is_output_iterator<OutputIt>::value,
-                               OutputIt>::type
-    vformat_to(OutputIt out, const std::locale &loc, const String &format_str,
-               typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) {
-  typedef output_range<OutputIt, FMT_CHAR(String)> range;
-  return vformat_to<arg_formatter<range>>(
-    range(out), to_string_view(format_str), args, internal::locale_ref(loc));
-}
-
-template <typename OutputIt, typename S, typename... Args>
-inline typename std::enable_if<
-    internal::is_string<S>::value &&
-    internal::is_output_iterator<OutputIt>::value, OutputIt>::type
-    format_to(OutputIt out, const std::locale &loc, const S &format_str,
-              const Args &... args) {
-  internal::check_format_string<Args...>(format_str);
-  typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
-  format_arg_store<context, Args...> as{args...};
-  return vformat_to(out, loc, to_string_view(format_str),
-                    basic_format_args<context>(as));
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_LOCALE_H_

include/fmt/ostream.h

@@ -1,153 +0,0 @@
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#include "format.h"
-#include <ostream>
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-template <class Char>
-class formatbuf : public std::basic_streambuf<Char> {
- private:
-  typedef typename std::basic_streambuf<Char>::int_type int_type;
-  typedef typename std::basic_streambuf<Char>::traits_type traits_type;
-
-  basic_buffer<Char> &buffer_;
-
- public:
-  formatbuf(basic_buffer<Char> &buffer) : buffer_(buffer) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
-
-  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
-template <typename Char>
-struct test_stream : std::basic_ostream<Char> {
- private:
-  struct null;
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void operator<<(null);
-};
-
-// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
-template <typename T, typename Char>
-class is_streamable {
- private:
-  template <typename U>
-  static decltype(
-    internal::declval<test_stream<Char>&>()
-      << internal::declval<U>(), std::true_type()) test(int);
-
-  template <typename>
-  static std::false_type test(...);
-
-  typedef decltype(test<T>(0)) result;
-
- public:
-  static const bool value = result::value;
-};
-
-// Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
-  const Char *data = buf.data();
-  typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
-  UnsignedStreamSize size = buf.size();
-  UnsignedStreamSize max_size =
-      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
-    UnsignedStreamSize n = size <= max_size ? size : max_size;
-    os.write(data, static_cast<std::streamsize>(n));
-    data += n;
-    size -= n;
-  } while (size != 0);
-}
-
-template <typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value) {
-  internal::formatbuf<Char> format_buf(buffer);
-  std::basic_ostream<Char> output(&format_buf);
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buffer.resize(buffer.size());
-}
-}  // namespace internal
-
-// Disable conversion to int if T has an overloaded operator<< which is a free
-// function (not a member of std::ostream).
-template <typename T, typename Char>
-struct convert_to_int<T, Char, void> {
-  static const bool value =
-    convert_to_int<T, Char, int>::value &&
-    !internal::is_streamable<T, Char>::value;
-};
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct formatter<T, Char,
-    typename std::enable_if<
-      internal::is_streamable<T, Char>::value &&
-      !internal::format_type<
-        typename buffer_context<Char>::type, T>::value>::type>
-    : formatter<basic_string_view<Char>, Char> {
-
-  template <typename Context>
-  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    internal::format_value(buffer, value);
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-};
-
-template <typename Char>
-inline void vprint(std::basic_ostream<Char> &os,
-                   basic_string_view<Char> format_str,
-                   basic_format_args<typename buffer_context<Char>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(buffer, format_str, args);
-  internal::write(os, buffer);
-}
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename S, typename... Args>
-inline typename std::enable_if<internal::is_string<S>::value>::type
-print(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
-      const Args & ... args) {
-  internal::checked_args<S, Args...> ca(format_str, args...);
-  vprint(os, to_string_view(format_str), *ca);
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_OSTREAM_H_

include/fmt/posix.h

@@ -1,324 +0,0 @@
-// A C++ interface to POSIX functions.
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_POSIX_H_
-#define FMT_POSIX_H_
-
-#if defined(__MINGW32__) || defined(__CYGWIN__)
-// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-# undef __STRICT_ANSI__
-#endif
-
-#include <errno.h>
-#include <fcntl.h>   // for O_RDONLY
-#include <locale.h>  // for locale_t
-#include <stdio.h>
-#include <stdlib.h>  // for strtod_l
-
-#include <cstddef>
-
-#if defined __APPLE__ || defined(__FreeBSD__)
-# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
-#endif
-
-#include "format.h"
-
-#ifndef FMT_POSIX
-# if defined(_WIN32) && !defined(__MINGW32__)
-// Fix warnings about deprecated symbols.
-#  define FMT_POSIX(call) _##call
-# else
-#  define FMT_POSIX(call) call
-# endif
-#endif
-
-// Calls to system functions are wrapped in FMT_SYSTEM for testability.
-#ifdef FMT_SYSTEM
-# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
-#else
-# define FMT_SYSTEM(call) call
-# ifdef _WIN32
-// Fix warnings about deprecated symbols.
-#  define FMT_POSIX_CALL(call) ::_##call
-# else
-#  define FMT_POSIX_CALL(call) ::call
-# endif
-#endif
-
-// Retries the expression while it evaluates to error_result and errno
-// equals to EINTR.
-#ifndef _WIN32
-# define FMT_RETRY_VAL(result, expression, error_result) \
-  do { \
-    result = (expression); \
-  } while (result == error_result && errno == EINTR)
-#else
-# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
-#endif
-
-#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
-
-FMT_BEGIN_NAMESPACE
-
-/**
-  \rst
-  A reference to a null-terminated string. It can be constructed from a C
-  string or ``std::string``.
-
-  You can use one of the following typedefs for common character types:
-
-  +---------------+-----------------------------+
-  | Type          | Definition                  |
-  +===============+=============================+
-  | cstring_view  | basic_cstring_view<char>    |
-  +---------------+-----------------------------+
-  | wcstring_view | basic_cstring_view<wchar_t> |
-  +---------------+-----------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(cstring_view format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
-template <typename Char>
-class basic_cstring_view {
- private:
-  const Char *data_;
-
- public:
-  /** Constructs a string reference object from a C string. */
-  basic_cstring_view(const Char *s) : data_(s) {}
-
-  /**
-    \rst
-    Constructs a string reference from an ``std::string`` object.
-    \endrst
-   */
-  basic_cstring_view(const std::basic_string<Char> &s) : data_(s.c_str()) {}
-
-  /** Returns the pointer to a C string. */
-  const Char *c_str() const { return data_; }
-};
-
-typedef basic_cstring_view<char> cstring_view;
-typedef basic_cstring_view<wchar_t> wcstring_view;
-
-// An error code.
-class error_code {
- private:
-  int value_;
-
- public:
-  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
-
-  int get() const FMT_NOEXCEPT { return value_; }
-};
-
-// A buffered file.
-class buffered_file {
- private:
-  FILE *file_;
-
-  friend class file;
-
-  explicit buffered_file(FILE *f) : file_(f) {}
-
- public:
-  // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
-
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() FMT_NOEXCEPT;
-
- private:
-  buffered_file(const buffered_file &) = delete;
-  void operator=(const buffered_file &) = delete;
-
-
- public:
-  buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
-    other.file_ = FMT_NULL;
-  }
-
-  buffered_file& operator=(buffered_file &&other) {
-    close();
-    file_ = other.file_;
-    other.file_ = FMT_NULL;
-    return *this;
-  }
-
-  // Opens a file.
-  FMT_API buffered_file(cstring_view filename, cstring_view mode);
-
-  // Closes the file.
-  FMT_API void close();
-
-  // Returns the pointer to a FILE object representing this file.
-  FILE *get() const FMT_NOEXCEPT { return file_; }
-
-  // We place parentheses around fileno to workaround a bug in some versions
-  // of MinGW that define fileno as a macro.
-  FMT_API int (fileno)() const;
-
-  void vprint(string_view format_str, format_args args) {
-    fmt::vprint(file_, format_str, args);
-  }
-
-  template <typename... Args>
-  inline void print(string_view format_str, const Args & ... args) {
-    vprint(format_str, make_format_args(args...));
-  }
-};
-
-// A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
-// fmt::system_error in case of failure. Note that some errors such as
-// closing the file multiple times will cause a crash on Windows rather
-// than an exception. You can get standard behavior by overriding the
-// invalid parameter handler with _set_invalid_parameter_handler.
-class file {
- private:
-  int fd_;  // File descriptor.
-
-  // Constructs a file object with a given descriptor.
-  explicit file(int fd) : fd_(fd) {}
-
- public:
-  // Possible values for the oflag argument to the constructor.
-  enum {
-    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
-    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
-    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
-  };
-
-  // Constructs a file object which doesn't represent any file.
-  file() FMT_NOEXCEPT : fd_(-1) {}
-
-  // Opens a file and constructs a file object representing this file.
-  FMT_API file(cstring_view path, int oflag);
-
- private:
-  file(const file &) = delete;
-  void operator=(const file &) = delete;
-
- public:
-  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
-    other.fd_ = -1;
-  }
-
-  file& operator=(file &&other) {
-    close();
-    fd_ = other.fd_;
-    other.fd_ = -1;
-    return *this;
-  }
-
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~file() FMT_NOEXCEPT;
-
-  // Returns the file descriptor.
-  int descriptor() const FMT_NOEXCEPT { return fd_; }
-
-  // Closes the file.
-  FMT_API void close();
-
-  // Returns the file size. The size has signed type for consistency with
-  // stat::st_size.
-  FMT_API long long size() const;
-
-  // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API std::size_t read(void *buffer, std::size_t count);
-
-  // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API std::size_t write(const void *buffer, std::size_t count);
-
-  // Duplicates a file descriptor with the dup function and returns
-  // the duplicate as a file object.
-  FMT_API static file dup(int fd);
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  FMT_API void dup2(int fd);
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
-
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  FMT_API static void pipe(file &read_end, file &write_end);
-
-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  FMT_API buffered_file fdopen(const char *mode);
-};
-
-// Returns the memory page size.
-long getpagesize();
-
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
-    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) && \
-    !defined(__NEWLIB_H__)
-# define FMT_LOCALE
-#endif
-
-#ifdef FMT_LOCALE
-// A "C" numeric locale.
-class Locale {
- private:
-# ifdef _MSC_VER
-  typedef _locale_t locale_t;
-
-  enum { LC_NUMERIC_MASK = LC_NUMERIC };
-
-  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
-    return _create_locale(category_mask, locale);
-  }
-
-  static void freelocale(locale_t locale) {
-    _free_locale(locale);
-  }
-
-  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
-    return _strtod_l(nptr, endptr, locale);
-  }
-# endif
-
-  locale_t locale_;
-
-  Locale(const Locale &) = delete;
-  void operator=(const Locale &) = delete;
-
- public:
-  typedef locale_t Type;
-
-  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
-    if (!locale_)
-      FMT_THROW(system_error(errno, "cannot create locale"));
-  }
-  ~Locale() { freelocale(locale_); }
-
-  Type get() const { return locale_; }
-
-  // Converts string to floating-point number and advances str past the end
-  // of the parsed input.
-  double strtod(const char *&str) const {
-    char *end = FMT_NULL;
-    double result = strtod_l(str, &end, locale_);
-    str = end;
-    return result;
-  }
-};
-#endif  // FMT_LOCALE
-FMT_END_NAMESPACE
-
-#endif  // FMT_POSIX_H_

include/fmt/printf.h

@@ -1,855 +0,0 @@
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_PRINTF_H_
-#define FMT_PRINTF_H_
-
-#include <algorithm>  // std::fill_n
-#include <limits>     // std::numeric_limits
-
-#include "ostream.h"
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-// An iterator that produces a null terminator on *end. This simplifies parsing
-// and allows comparing the performance of processing a null-terminated string
-// vs string_view.
-template <typename Char>
-class null_terminating_iterator {
- public:
-  typedef std::ptrdiff_t difference_type;
-  typedef Char value_type;
-  typedef const Char* pointer;
-  typedef const Char& reference;
-  typedef std::random_access_iterator_tag iterator_category;
-
-  null_terminating_iterator() : ptr_(0), end_(0) {}
-
-  FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
-    : ptr_(ptr), end_(end) {}
-
-  template <typename Range>
-  FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
-    : ptr_(r.begin()), end_(r.end()) {}
-
-  FMT_CONSTEXPR null_terminating_iterator &operator=(const Char *ptr) {
-    assert(ptr <= end_);
-    ptr_ = ptr;
-    return *this;
-  }
-
-  FMT_CONSTEXPR Char operator*() const {
-    return ptr_ != end_ ? *ptr_ : Char();
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator++() {
-    ++ptr_;
-    return *this;
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator++(int) {
-    null_terminating_iterator result(*this);
-    ++ptr_;
-    return result;
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator--() {
-    --ptr_;
-    return *this;
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) {
-    return null_terminating_iterator(ptr_ + n, end_);
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) {
-    return null_terminating_iterator(ptr_ - n, end_);
-  }
-
-  FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) {
-    ptr_ += n;
-    return *this;
-  }
-
-  FMT_CONSTEXPR difference_type operator-(
-      null_terminating_iterator other) const {
-    return ptr_ - other.ptr_;
-  }
-
-  FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const {
-    return ptr_ != other.ptr_;
-  }
-
-  bool operator>=(null_terminating_iterator other) const {
-    return ptr_ >= other.ptr_;
-  }
-
-  // This should be a friend specialization pointer_from<Char> but the latter
-  // doesn't compile by gcc 5.1 due to a compiler bug.
-  template <typename CharT>
-  friend FMT_CONSTEXPR_DECL const CharT *pointer_from(
-      null_terminating_iterator<CharT> it);
-
- private:
-  const Char *ptr_;
-  const Char *end_;
-};
-
-template <typename T>
-FMT_CONSTEXPR const T *pointer_from(const T *p) { return p; }
-
-template <typename Char>
-FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) {
-  return it.ptr_;
-}
-
-// DEPRECATED: Parses the input as an unsigned integer. This function assumes
-// that the first character is a digit and presence of a non-digit character at
-// the end.
-// it: an iterator pointing to the beginning of the input range.
-template <typename Iterator, typename ErrorHandler>
-FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
-  assert('0' <= *it && *it <= '9');
-  if (*it == '0') {
-    ++it;
-    return 0;
-  }
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  unsigned max_int = (std::numeric_limits<int>::max)();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
-    }
-    value = value * 10 + unsigned(*it - '0');
-    // Workaround for MSVC "setup_exception stack overflow" error:
-    auto next = it;
-    ++next;
-    it = next;
-  } while ('0' <= *it && *it <= '9');
-  if (value > max_int)
-    eh.on_error("number is too big");
-  return value;
-}
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned>
-struct int_checker {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    unsigned max = std::numeric_limits<int>::max();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <>
-struct int_checker<true> {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= std::numeric_limits<int>::max();
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-class printf_precision_handler: public function<int> {
- public:
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, int>::type
-      operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
-    return static_cast<int>(value);
-  }
-
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
-    FMT_THROW(format_error("precision is not integer"));
-    return 0;
-  }
-};
-
-// An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int: public function<bool> {
- public:
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, bool>::type
-      operator()(T value) { return value == 0; }
-
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, bool>::type
-      operator()(T) { return false; }
-};
-
-template <typename T>
-struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <>
-struct make_unsigned_or_bool<bool> {
-  typedef bool type;
-};
-
-template <typename T, typename Context>
-class arg_converter: public function<void> {
- private:
-  typedef typename Context::char_type Char;
-
-  basic_format_arg<Context> &arg_;
-  typename Context::char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context> &arg, Char type)
-    : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's')
-      operator()<bool>(value);
-  }
-
-  template <typename U>
-  typename std::enable_if<std::is_integral<U>::value>::type
-      operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    typedef typename std::conditional<
-        std::is_same<T, void>::value, U, T>::type TargetType;
-    if (const_check(sizeof(TargetType) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-          static_cast<int>(static_cast<TargetType>(value)));
-      } else {
-        typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
-        arg_ = internal::make_arg<Context>(
-          static_cast<unsigned>(static_cast<Unsigned>(value)));
-      }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-          static_cast<typename make_unsigned_or_bool<U>::type>(value));
-      }
-    }
-  }
-
-  template <typename U>
-  typename std::enable_if<!std::is_integral<U>::value>::type operator()(U) {
-    // No coversion needed for non-integral types.
-  }
-};
-
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context> &arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
-
-// Converts an integer argument to char for printf.
-template <typename Context>
-class char_converter: public function<void> {
- private:
-  basic_format_arg<Context> &arg_;
-
- public:
-  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value>::type
-      operator()(T value) {
-    typedef typename Context::char_type Char;
-    arg_ = internal::make_arg<Context>(static_cast<Char>(value));
-  }
-
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value>::type operator()(T) {
-    // No coversion needed for non-integral types.
-  }
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char>
-class printf_width_handler: public function<unsigned> {
- private:
-  typedef basic_format_specs<Char> format_specs;
-
-  format_specs &spec_;
-
- public:
-  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, unsigned>::type
-      operator()(T value) {
-    typedef typename internal::int_traits<T>::main_type UnsignedType;
-    UnsignedType width = static_cast<UnsignedType>(value);
-    if (internal::is_negative(value)) {
-      spec_.align_ = ALIGN_LEFT;
-      width = 0 - width;
-    }
-    unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max)
-      FMT_THROW(format_error("number is too big"));
-    return static_cast<unsigned>(width);
-  }
-
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
-      operator()(T) {
-    FMT_THROW(format_error("width is not integer"));
-    return 0;
-  }
-};
-
-template <typename Char, typename Context>
-void printf(basic_buffer<Char> &buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
-}
-}  // namespace internal
-
-using internal::printf;  // For printing into memory_buffer.
-
-template <typename Range>
-class printf_arg_formatter;
-
-template <
-    typename OutputIt, typename Char,
-    typename ArgFormatter =
-      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
-class basic_printf_context;
-
-/**
-  \rst
-  The ``printf`` argument formatter.
-  \endrst
- */
-template <typename Range>
-class printf_arg_formatter:
-  public internal::function<
-    typename internal::arg_formatter_base<Range>::iterator>,
-  public internal::arg_formatter_base<Range> {
- private:
-  typedef typename Range::value_type char_type;
-  typedef decltype(internal::declval<Range>().begin()) iterator;
-  typedef internal::arg_formatter_base<Range> base;
-  typedef basic_printf_context<iterator, char_type> context_type;
-
-  context_type &context_;
-
-  void write_null_pointer(char) {
-    this->spec()->type = 0;
-    this->write("(nil)");
-  }
-
-  void write_null_pointer(wchar_t) {
-    this->spec()->type = 0;
-    this->write(L"(nil)");
-  }
-
- public:
-  typedef typename base::format_specs format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *buffer* is a reference to the output buffer and *spec* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
-                       format_specs &spec, context_type &ctx)
-    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), &spec,
-           ctx.locale()),
-      context_(ctx) {}
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, iterator>::type
-      operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      format_specs &fmt_spec = *this->spec();
-      if (fmt_spec.type != 's')
-        return base::operator()(value ? 1 : 0);
-      fmt_spec.type = 0;
-      this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs &fmt_spec = *this->spec();
-      if (fmt_spec.type && fmt_spec.type != 'c')
-        return (*this)(static_cast<int>(value));
-      fmt_spec.flags = 0;
-      fmt_spec.align_ = ALIGN_RIGHT;
-      return base::operator()(value);
-    } else {
-      return base::operator()(value);
-    }
-    return this->out();
-  }
-
-  template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
-      operator()(T value) {
-    return base::operator()(value);
-  }
-
-  /** Formats a null-terminated C string. */
-  iterator operator()(const char *value) {
-    if (value)
-      base::operator()(value);
-    else if (this->spec()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write("(null)");
-    return this->out();
-  }
-
-  /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t *value) {
-    if (value)
-      base::operator()(value);
-    else if (this->spec()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write(L"(null)");
-    return this->out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
-
-  iterator operator()(monostate value) {
-    return base::operator()(value);
-  }
-
-  /** Formats a pointer. */
-  iterator operator()(const void *value) {
-    if (value)
-      return base::operator()(value);
-    this->spec()->type = 0;
-    write_null_pointer(char_type());
-    return this->out();
-  }
-
-  /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(context_);
-    return this->out();
-  }
-};
-
-template <typename T>
-struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
-
-  template <typename FormatContext>
-  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
-    internal::format_value(internal::get_container(ctx.out()), value);
-    return ctx.out();
-  }
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char, typename ArgFormatter>
-class basic_printf_context :
-  // Inherit publicly as a workaround for the icc bug
-  // https://software.intel.com/en-us/forums/intel-c-compiler/topic/783476.
-  public internal::context_base<
-    OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
- public:
-  /** The character type for the output. */
-  typedef Char char_type;
-
-  template <typename T>
-  struct formatter_type { typedef printf_formatter<T> type; };
-
- private:
-  typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
-  typedef typename base::format_arg format_arg;
-  typedef basic_format_specs<char_type> format_specs;
-  typedef internal::null_terminating_iterator<char_type> iterator;
-
-  void parse_flags(format_specs &spec, iterator &it);
-
-  // Returns the argument with specified index or, if arg_index is equal
-  // to the maximum unsigned value, the next argument.
-  format_arg get_arg(
-      iterator it,
-      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-
-  // Parses argument index, flags and width and returns the argument index.
-  unsigned parse_header(iterator &it, format_specs &spec);
-
- public:
-  /**
-   \rst
-   Constructs a ``printf_context`` object. References to the arguments and
-   the writer are stored in the context object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-                       basic_format_args<basic_printf_context> args)
-    : base(out, format_str, args) {}
-
-  using base::parse_context;
-  using base::out;
-  using base::advance_to;
-
-  /** Formats stored arguments and writes the output to the range. */
-  void format();
-};
-
-template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::parse_flags(
-    format_specs &spec, iterator &it) {
-  for (;;) {
-    switch (*it++) {
-      case '-':
-        spec.align_ = ALIGN_LEFT;
-        break;
-      case '+':
-        spec.flags |= SIGN_FLAG | PLUS_FLAG;
-        break;
-      case '0':
-        spec.fill_ = '0';
-        break;
-      case ' ':
-        spec.flags |= SIGN_FLAG;
-        break;
-      case '#':
-        spec.flags |= HASH_FLAG;
-        break;
-      default:
-        --it;
-        return;
-    }
-  }
-}
-
-template <typename OutputIt, typename Char, typename AF>
-typename basic_printf_context<OutputIt, Char, AF>::format_arg
-  basic_printf_context<OutputIt, Char, AF>::get_arg(
-    iterator it, unsigned arg_index) {
-  (void)it;
-  if (arg_index == std::numeric_limits<unsigned>::max())
-    return this->do_get_arg(this->parse_context().next_arg_id());
-  return base::get_arg(arg_index - 1);
-}
-
-template <typename OutputIt, typename Char, typename AF>
-unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
-  iterator &it, format_specs &spec) {
-  unsigned arg_index = std::numeric_limits<unsigned>::max();
-  char_type c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    internal::error_handler eh;
-    unsigned value = parse_nonnegative_int(it, eh);
-    if (*it == '$') {  // value is an argument index
-      ++it;
-      arg_index = value;
-    } else {
-      if (c == '0')
-        spec.fill_ = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        spec.width_ = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(spec, it);
-  // Parse width.
-  if (*it >= '0' && *it <= '9') {
-    internal::error_handler eh;
-    spec.width_ = parse_nonnegative_int(it, eh);
-  } else if (*it == '*') {
-    ++it;
-    spec.width_ = visit_format_arg(
-          internal::printf_width_handler<char_type>(spec), get_arg(it));
-  }
-  return arg_index;
-}
-
-template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::format() {
-  auto &buffer = internal::get_container(this->out());
-  auto start = iterator(this->parse_context());
-  auto it = start;
-  using internal::pointer_from;
-  while (*it) {
-    char_type c = *it++;
-    if (c != '%') continue;
-    if (*it == c) {
-      buffer.append(pointer_from(start), pointer_from(it));
-      start = ++it;
-      continue;
-    }
-    buffer.append(pointer_from(start), pointer_from(it) - 1);
-
-    format_specs spec;
-    spec.align_ = ALIGN_RIGHT;
-
-    // Parse argument index, flags and width.
-    unsigned arg_index = parse_header(it, spec);
-
-    // Parse precision.
-    if (*it == '.') {
-      ++it;
-      if ('0' <= *it && *it <= '9') {
-        internal::error_handler eh;
-        spec.precision = static_cast<int>(parse_nonnegative_int(it, eh));
-      } else if (*it == '*') {
-        ++it;
-        spec.precision =
-            visit_format_arg(internal::printf_precision_handler(), get_arg(it));
-      } else {
-        spec.precision = 0;
-      }
-    }
-
-    format_arg arg = get_arg(it, arg_index);
-    if (spec.has(HASH_FLAG) && visit_format_arg(internal::is_zero_int(), arg))
-      spec.flags = static_cast<uint_least8_t>(spec.flags & (~internal::to_unsigned<int>(HASH_FLAG)));
-    if (spec.fill_ == '0') {
-      if (arg.is_arithmetic())
-        spec.align_ = ALIGN_NUMERIC;
-      else
-        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    using internal::convert_arg;
-    switch (*it++) {
-    case 'h':
-      if (*it == 'h')
-        convert_arg<signed char>(arg, *++it);
-      else
-        convert_arg<short>(arg, *it);
-      break;
-    case 'l':
-      if (*it == 'l')
-        convert_arg<long long>(arg, *++it);
-      else
-        convert_arg<long>(arg, *it);
-      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, *it);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(arg, *it);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, *it);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --it;
-      convert_arg<void>(arg, *it);
-    }
-
-    // Parse type.
-    if (!*it)
-      FMT_THROW(format_error("invalid format string"));
-    spec.type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
-      // Normalize type.
-      switch (spec.type) {
-      case 'i': case 'u':
-        spec.type = 'd';
-        break;
-      case 'c':
-        // TODO: handle wchar_t better?
-        visit_format_arg(
-              internal::char_converter<basic_printf_context>(arg), arg);
-        break;
-      }
-    }
-
-    start = it;
-
-    // Format argument.
-    visit_format_arg(AF(buffer, spec, *this), arg);
-  }
-  buffer.append(pointer_from(start), pointer_from(it));
-}
-
-template <typename Buffer>
-struct basic_printf_context_t {
-  typedef basic_printf_context<
-    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
-};
-
-typedef basic_printf_context_t<internal::buffer>::type printf_context;
-typedef basic_printf_context_t<internal::wbuffer>::type wprintf_context;
-
-typedef basic_format_args<printf_context> printf_args;
-typedef basic_format_args<wprintf_context> wprintf_args;
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::printf_args`. 
-  \endrst
- */
-template<typename... Args>
-inline format_arg_store<printf_context, Args...>
-  make_printf_args(const Args &... args) { return {args...}; }
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::wprintf_args`. 
-  \endrst
- */
-template<typename... Args>
-inline format_arg_store<wprintf_context, Args...>
-  make_wprintf_args(const Args &... args) { return {args...}; }
-
-template <typename S, typename Char = FMT_CHAR(S)>
-inline std::basic_string<Char>
-vsprintf(const S &format,
-         basic_format_args<typename basic_printf_context_t<
-           internal::basic_buffer<Char>>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  return to_string(buffer);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
-*/
-template <typename S, typename... Args>
-inline FMT_ENABLE_IF_T(
-    internal::is_string<S>::value, std::basic_string<FMT_CHAR(S)>)
-    sprintf(const S &format, const Args & ... args) {
-  internal::check_format_string<Args...>(format);
-  typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
-  format_arg_store<context, Args...> as{ args... };
-  return vsprintf(to_string_view(format),
-                  basic_format_args<context>(as));
-}
-
-template <typename S, typename Char = FMT_CHAR(S)>
-inline int vfprintf(std::FILE *f, const S &format,
-                    basic_format_args<typename basic_printf_context_t<
-                      internal::basic_buffer<Char>>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  std::size_t size = buffer.size();
-  return std::fwrite(
-    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args>
-inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
-    fprintf(std::FILE *f, const S &format, const Args & ... args) {
-  internal::check_format_string<Args...>(format);
-  typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
-  format_arg_store<context, Args...> as{ args... };
-  return vfprintf(f, to_string_view(format),
-                  basic_format_args<context>(as));
-}
-
-template <typename S, typename Char = FMT_CHAR(S)>
-inline int vprintf(const S &format,
-                   basic_format_args<typename basic_printf_context_t<
-                    internal::basic_buffer<Char>>::type> args) {
-  return vfprintf(stdout, to_string_view(format), args);
-}
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-template <typename S, typename... Args>
-inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
-    printf(const S &format_str, const Args & ... args) {
-  internal::check_format_string<Args...>(format_str);
-  typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
-  format_arg_store<context, Args...> as{ args... };
-  return vprintf(to_string_view(format_str),
-                 basic_format_args<context>(as));
-}
-
-template <typename S, typename Char = FMT_CHAR(S)>
-inline int vfprintf(std::basic_ostream<Char> &os,
-                    const S &format,
-                    basic_format_args<typename basic_printf_context_t<
-                      internal::basic_buffer<Char>>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  internal::write(os, buffer);
-  return static_cast<int>(buffer.size());
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args>
-inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
-    fprintf(std::basic_ostream<FMT_CHAR(S)> &os,
-            const S &format_str, const Args & ... args) {
-  internal::check_format_string<Args...>(format_str);
-  typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
-  format_arg_store<context, Args...> as{ args... };
-  return vfprintf(os, to_string_view(format_str),
-                  basic_format_args<context>(as));
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_PRINTF_H_

include/fmt/ranges.h

@@ -1,308 +0,0 @@
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for ranges, containers and types tuple interface.
-
-#ifndef FMT_RANGES_H_
-#define FMT_RANGES_H_
-
-#include "format.h"
-#include <type_traits>
-
-// output only up to N items from the range.
-#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
-#endif
-
-FMT_BEGIN_NAMESPACE
-
-template <typename Char>
-struct formatting_base {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-};
-
-template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char> {
-  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
-};
-
-template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char> {
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
-};
-
-namespace internal {
-
-template <typename RangeT, typename OutputIterator>
-void copy(const RangeT &range, OutputIterator out) {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-}
-
-template <typename OutputIterator>
-void copy(const char *str, OutputIterator out) {
-  const char *p_curr = str;
-  while (*p_curr) {
-    *out++ = *p_curr++;
-  }
-}
-
-template <typename OutputIterator>
-void copy(char ch, OutputIterator out) {
-  *out++ = ch;
-}
-
-/// Return true value if T has std::string interface, like std::string_view.
-template <typename T>
-class is_like_std_string {
-  template <typename U>
-  static auto check(U *p) ->
-    decltype(p->find('a'), p->length(), p->data(), int());
-  template <typename>
-  static void check(...);
-
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
-};
-
-template <typename Char>
-struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
-
-template <typename... Ts>
-struct conditional_helper {};
-
-template <typename T, typename _ = void>
-struct is_range_ : std::false_type {};
-
-#if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template <typename T>
-struct is_range_<T, typename std::conditional<
-                    false,
-                    conditional_helper<decltype(internal::declval<T>().begin()),
-                                       decltype(internal::declval<T>().end())>,
-                    void>::type> : std::true_type {};
-#endif
-
-/// tuple_size and tuple_element check.
-template <typename T>
-class is_tuple_like_ {
-  template <typename U>
-  static auto check(U *p) ->
-    decltype(std::tuple_size<U>::value,
-      internal::declval<typename std::tuple_element<0, U>::type>(), int());
-  template <typename>
-  static void check(...);
-
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
-};
-
-// Check for integer_sequence
-#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template <typename T, T... N>
-using integer_sequence = std::integer_sequence<T, N...>;
-template <std::size_t... N>
-using index_sequence = std::index_sequence<N...>;
-template <std::size_t N>
-using make_index_sequence = std::make_index_sequence<N>;
-#else
-template <typename T, T... N>
-struct integer_sequence {
-  typedef T value_type;
-
-  static FMT_CONSTEXPR std::size_t size() {
-    return sizeof...(N);
-  }
-};
-
-template <std::size_t... N>
-using index_sequence = integer_sequence<std::size_t, N...>;
-
-template <typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
-
-template <std::size_t N>
-using make_index_sequence = make_integer_sequence<std::size_t, N>;
-#endif
-
-template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
-  using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
-}
-
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
-get_indexes(T const &) { return {}; }
-
-template <class Tuple, class F>
-void for_each(Tuple &&tup, F &&f) {
-  const auto indexes = get_indexes(tup);
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-}
-
-template<typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-  typename std::enable_if<
-    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
-  return add_space ? " {}" : "{}";
-}
-
-template<typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-  typename std::enable_if<
-    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
-
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
-    return add_space ? L" \"{}\"" : L"\"{}\"";
-}
-
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
-    return add_space ? " '{}'" : "'{}'";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
-    return add_space ? L" '{}'" : L"'{}'";
-}
-
-}  // namespace internal
-
-template <typename T>
-struct is_tuple_like {
-  static FMT_CONSTEXPR_DECL const bool value =
-    internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
-};
-
-template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, 
-    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
-private:
-  // C++11 generic lambda for format()
-  template <typename FormatContext>
-  struct format_each {
-    template <typename T>
-    void operator()(const T& v) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) {
-          *out++ = ' ';
-        }
-        internal::copy(formatting.delimiter, out);
-      }
-      format_to(out,
-                internal::format_str_quoted(
-                    (formatting.add_delimiter_spaces && i > 0), v),
-                v);
-      ++i;
-    }
-
-    formatting_tuple<Char>& formatting;
-    std::size_t& i;
-    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
-  };
-
-public:
-  formatting_tuple<Char> formatting;
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
-  }
-
-  template <typename FormatContext = format_context>
-  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    std::size_t i = 0;
-    internal::copy(formatting.prefix, out);
-
-    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
-    if (formatting.add_prepostfix_space) {
-      *out++ = ' ';
-    }
-    internal::copy(formatting.postfix, out);
-
-    return ctx.out();
-  }
-};
-
-template <typename T>
-struct is_range {
-  static FMT_CONSTEXPR_DECL const bool value =
-    internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
-};
-
-template <typename RangeT, typename Char>
-struct formatter<RangeT, Char,
-    typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
-
-  formatting_range<Char> formatting;
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  typename FormatContext::iterator format(
-      const RangeT &values, FormatContext &ctx) {
-    auto out = ctx.out();
-    internal::copy(formatting.prefix, out);
-    std::size_t i = 0;
-    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) {
-          *out++ = ' ';
-        }
-        internal::copy(formatting.delimiter, out);
-      }
-      format_to(out,
-                internal::format_str_quoted(
-                    (formatting.add_delimiter_spaces && i > 0), *it),
-                *it);
-      if (++i > formatting.range_length_limit) {
-        format_to(out, " ... <other elements>");
-        break;
-      }
-    }
-    if (formatting.add_prepostfix_space) {
-      *out++ = ' ';
-    }
-    internal::copy(formatting.postfix, out);
-    return ctx.out();
-  }
-};
-
-FMT_END_NAMESPACE
-
-#endif // FMT_RANGES_H_
-

include/fmt/time.h

@@ -1,160 +0,0 @@
-// Formatting library for C++ - time formatting
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_TIME_H_
-#define FMT_TIME_H_
-
-#include "format.h"
-#include <ctime>
-#include <locale>
-
-FMT_BEGIN_NAMESPACE
-
-// Prevents expansion of a preceding token as a function-style macro.
-// Usage: f FMT_NOMACRO()
-#define FMT_NOMACRO
-
-namespace internal{
-inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
-}  // namespace internal
-
-// Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
-
-    dispatcher(std::time_t t): time_(t) {}
-
-    bool run() {
-      using namespace fmt::internal;
-      return handle(localtime_r(&time_, &tm_));
-    }
-
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
-
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
-      return fallback(localtime_s(&tm_, &time_));
-    }
-
-    bool fallback(int res) { return res == 0; }
-
-#if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
-      using namespace fmt::internal;
-      std::tm *tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != FMT_NULL;
-    }
-#endif
-  };
-  dispatcher lt(time);
-  // Too big time values may be unsupported.
-  if (!lt.run())
-    FMT_THROW(format_error("time_t value out of range"));
-  return lt.tm_;
-}
-
-// Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
-
-    dispatcher(std::time_t t): time_(t) {}
-
-    bool run() {
-      using namespace fmt::internal;
-      return handle(gmtime_r(&time_, &tm_));
-    }
-
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
-
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
-      return fallback(gmtime_s(&tm_, &time_));
-    }
-
-    bool fallback(int res) { return res == 0; }
-
-#if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
-      std::tm *tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != FMT_NULL;
-    }
-#endif
-  };
-  dispatcher gt(time);
-  // Too big time values may be unsupported.
-  if (!gt.run())
-    FMT_THROW(format_error("time_t value out of range"));
-  return gt.tm_;
-}
-
-namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format,
-                            const std::tm *time) {
-  return std::strftime(str, count, format, time);
-}
-
-inline std::size_t strftime(wchar_t *str, std::size_t count,
-                            const wchar_t *format, const std::tm *time) {
-  return std::wcsftime(str, count, format, time);
-}
-}
-
-template <typename Char>
-struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':')
-      ++it;
-    auto end = it;
-    while (end != ctx.end() && *end != '}')
-      ++end;
-    tm_format.reserve(internal::to_unsigned(end - it + 1));
-    tm_format.append(it, end);
-    tm_format.push_back('\0');
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buf;
-    std::size_t start = buf.size();
-    for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-        internal::strftime(&buf[start], size, &tm_format[0], &tm);
-      if (count != 0) {
-        buf.resize(start + count);
-        break;
-      }
-      if (size >= tm_format.size() * 256) {
-        // If the buffer is 256 times larger than the format string, assume
-        // that `strftime` gives an empty result. There doesn't seem to be a
-        // better way to distinguish the two cases:
-        // https://github.com/fmtlib/fmt/issues/367
-        break;
-      }
-      const std::size_t MIN_GROWTH = 10;
-      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-    }
-    return std::copy(buf.begin(), buf.end(), ctx.out());
-  }
-
-  basic_memory_buffer<Char> tm_format;
-};
-FMT_END_NAMESPACE
-
-#endif  // FMT_TIME_H_

posix.h

@@ -0,0 +1,2 @@
+#include "cppformat/posix.h"
+#warning Including posix.h from the top-level directory is deprecated.

src/format.cc

@@ -1,59 +0,0 @@
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/format-inl.h"
-
-FMT_BEGIN_NAMESPACE
-template struct internal::basic_data<void>;
-template FMT_API internal::locale_ref::locale_ref(const std::locale &loc);
-template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
-
-// Explicit instantiations for char.
-
-template FMT_API char internal::thousands_sep_impl(locale_ref);
-
-template FMT_API void internal::basic_buffer<char>::append(const char *, const char *);
-
-template FMT_API void internal::arg_map<format_context>::init(
-    const basic_format_args<format_context> &args);
-
-template FMT_API int internal::char_traits<char>::format_float(
-    char *, std::size_t, const char *, int, double);
-
-template FMT_API int internal::char_traits<char>::format_float(
-    char *, std::size_t, const char *, int, long double);
-
-template FMT_API std::string internal::vformat<char>(
-    string_view, basic_format_args<format_context>);
-
-template FMT_API format_context::iterator internal::vformat_to(
-    internal::buffer &, string_view, basic_format_args<format_context>);
-
-template FMT_API void internal::sprintf_format(
-    double, internal::buffer &, core_format_specs);
-template FMT_API void internal::sprintf_format(
-    long double, internal::buffer &, core_format_specs);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
-
-template FMT_API void internal::basic_buffer<wchar_t>::append(
-    const wchar_t *, const wchar_t *);
-
-template FMT_API void internal::arg_map<wformat_context>::init(
-    const basic_format_args<wformat_context> &);
-
-template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *, std::size_t, const wchar_t *, int, double);
-
-template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *, std::size_t, const wchar_t *, int, long double);
-
-template FMT_API std::wstring internal::vformat<wchar_t>(
-    wstring_view, basic_format_args<wformat_context>);
-FMT_END_NAMESPACE

support/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="net.fmtlib" />

support/README

@@ -2,5 +2,3 @@ This directory contains build support files such as
 
 * CMake modules
 * Build scripts
-* qmake (static build with dynamic libc only)
-

support/appveyor-build.py

@@ -6,34 +6,26 @@ from subprocess import check_call
 
 build = os.environ['BUILD']
 config = os.environ['CONFIGURATION']
-platform = os.environ['PLATFORM']
+platform = os.environ.get('PLATFORM')
 path = os.environ['PATH']
-image = os.environ['APPVEYOR_BUILD_WORKER_IMAGE']
-jobid = os.environ['APPVEYOR_JOB_ID']
-cmake_command = ['cmake', '-DFMT_PEDANTIC=ON', '-DCMAKE_BUILD_TYPE=' + config, '..']
+cmake_command = ['cmake', '-DFMT_PEDANTIC=ON', '-DCMAKE_BUILD_TYPE=' + config]
 if build == 'mingw':
-    cmake_command.append('-GMinGW Makefiles')
-    build_command = ['mingw32-make', '-j4']
-    test_command = ['mingw32-make', 'test']
-    # Remove the path to Git bin directory from $PATH because it breaks
-    # MinGW config.
-    path = path.replace(r'C:\Program Files (x86)\Git\bin', '')
-    os.environ['PATH'] = r'C:\MinGW\bin;' + path
+  cmake_command.append('-GMinGW Makefiles')
+  build_command = ['mingw32-make', '-j4']
+  test_command = ['mingw32-make', 'test']
+  # Remove the path to Git bin directory from $PATH because it breaks MinGW config.
+  path = path.replace(r'C:\Program Files (x86)\Git\bin', '')
+  os.environ['PATH'] = r'C:\MinGW\bin;' + path
 else:
-    # Add MSBuild 14.0 to PATH as described in
-    # http://help.appveyor.com/discussions/problems/2229-v140-not-found-on-vs2105rc.
-    os.environ['PATH'] = r'C:\Program Files (x86)\MSBuild\15.0\Bin;' + path
-    if image == 'Visual Studio 2013':
-        generator = 'Visual Studio 12 2013'
-    elif image == 'Visual Studio 2015':
-        generator = 'Visual Studio 14 2015'
-    elif image == 'Visual Studio 2017':
-        generator = 'Visual Studio 15 2017'
-    if platform == 'x64':
-        generator += ' Win64'
-    cmake_command.append('-G' + generator)
-    build_command = ['cmake', '--build', '.', '--config', config, '--', '/m:4']
-    test_command = ['ctest', '-C', config]
+  # Add MSBuild 14.0 to PATH as described in
+  # http://help.appveyor.com/discussions/problems/2229-v140-not-found-on-vs2105rc.
+  os.environ['PATH'] = r'C:\Program Files (x86)\MSBuild\14.0\Bin;' + path
+  generator = 'Visual Studio 14 2015'
+  if platform == 'x64':
+    generator += ' Win64'
+  cmake_command.append('-G' + generator)
+  build_command = ['msbuild', '/m:4', '/p:Config=' + config, 'FORMAT.sln']
+  test_command = ['msbuild', 'RUN_TESTS.vcxproj']
 
 check_call(cmake_command)
 check_call(build_command)

support/appveyor.yml

@@ -2,33 +2,21 @@ configuration:
   - Debug
   - Release
 
-clone_depth: 1
-
-platform:
-  - Win32
-  - x64
-
-image:
-  - Visual Studio 2013
-  - Visual Studio 2015
-  - Visual Studio 2017
-
 environment:
   CTEST_OUTPUT_ON_FAILURE: 1
-  MSVC_DEFAULT_OPTIONS: ON
-  BUILD: msvc
+  matrix:
+  - BUILD: msvc
+  - BUILD: msvc
+    PLATFORM: x64
+  - BUILD: mingw
 
 before_build:
- - mkdir build
- - cd build
+  # Workaround for CMake not wanting sh.exe on PATH for MinGW.
+  - set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
 
 build_script:
-  - python ../support/appveyor-build.py
+  - python support/appveyor-build.py
 
 on_failure:
   - appveyor PushArtifact Testing/Temporary/LastTest.log
   - appveyor AddTest test
-
-# Uncomment this to debug AppVeyor failures.
-#on_finish:
-#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))

support/biicode-build.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# Build the project with Biicode.
+
+import glob, os, shutil
+from subprocess import check_call
+
+project_dir = 'biicode_project'
+check_call(['bii', 'init', project_dir])
+cppformat_dir = os.path.join(project_dir, 'blocks/vitaut/cppformat')
+shutil.copytree('.', cppformat_dir, ignore=shutil.ignore_patterns(project_dir))
+for f in glob.glob('support/biicode/*'):
+  shutil.copy(f, cppformat_dir)
+check_call(['bii', 'cpp:build'], cwd=project_dir)

support/biicode/biicode.conf

@@ -0,0 +1,19 @@
+# Biicode configuration file
+
+[paths]
+    # Local directories to look for headers (within block)
+    /
+
+[dependencies]
+    # Manual adjust file implicit dependencies, add (+), remove (-), or overwrite (=)
+    CMakeLists.txt + cmake/FindSetEnv.cmake
+    format.h = format.cc
+    format.cc - test/* posix.cc
+    support/biicode/sample.cc - test/*
+
+[mains]
+    # Manual adjust of files that define an executable
+    !test/test-main.cc
+
+[parent]
+    vitaut/cppformat: 0

support/biicode/ignore.bii

@@ -0,0 +1,3 @@
+doc/*
+breathe/*
+gmock/*

support/biicode/sample.cc

@@ -0,0 +1,17 @@
+#include "vitaut/cppformat/format.h"
+
+class Date {
+  int year_, month_, day_;
+ public:
+  Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+
+  friend std::ostream &operator<<(std::ostream &os, const Date &d) {
+    return os << d.year_ << '-' << d.month_ << '-' << d.day_;
+  }
+};
+
+int main() {
+  std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
+  fmt::print("Hello, {}!", "world");  // uses Python-like format string syntax
+  fmt::printf("\n%s", s); // uses printf format string syntax
+}

support/build.gradle

@@ -1,105 +0,0 @@
-
-// General gradle arguments for root project
-buildscript {    
-    repositories {
-        google()
-        jcenter()
-    }
-    dependencies {
-        //
-        // https://developer.android.com/studio/releases/gradle-plugin
-        //
-        // Notice that 3.1.3 here is the version of [Android Gradle Plugin]
-        // Accroding to URL above you will need Gradle 4.4 or higher
-        //
-        classpath 'com.android.tools.build:gradle:3.1.3'
-    }
-}
-repositories {
-    google()
-    jcenter()
-}
-    
-// Output: Shared library (.so) for Android 
-apply plugin: 'com.android.library'
-
-android {
-    compileSdkVersion 25    // Android 7.0
-
-    // Target ABI
-    //  - This option controls target platform of module
-    //  - The platform might be limited by compiler's support
-    //    some can work with Clang(default), but some can work only with GCC...
-    //    if bad, both toolchains might not support it
-    splits {
-        abi {
-            enable true
-            // Specify platforms for Application
-            reset()
-            include  "arm64-v8a", "armeabi-v7a", "x86_64"
-        }
-    }
-
-    defaultConfig {
-        minSdkVersion 21    // Android 5.0+
-        targetSdkVersion 25 // Follow Compile SDK
-        versionCode 20      // Follow release count
-        versionName "5.2.1" // Follow Official version
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
-        
-        externalNativeBuild {
-            cmake {
-                arguments "-DANDROID_STL=c++_shared"    // Specify Android STL
-                arguments "-DBUILD_SHARED_LIBS=true"    // Build shared object
-                arguments "-DFMT_TEST=false"            // Skip test
-                arguments "-DFMT_DOC=false"             // Skip document
-                cppFlags  "-std=c++17"
-            }
-        }
-        println("Gradle CMake Plugin: ")
-        println(externalNativeBuild.cmake.cppFlags)
-        println(externalNativeBuild.cmake.arguments)
-    }
-
-    // External Native build
-    //  - Use existing CMakeList.txt
-    //  - Give path to CMake. This gradle file should be 
-    //    neighbor of the top level cmake
-    externalNativeBuild {
-        cmake {
-            path "../CMakeLists.txt"
-            // buildStagingDirectory "./build"  // Custom path for cmake output
-        }
-        //println(cmake.path)
-    }
-    
-    sourceSets{
-        // Android Manifest for Gradle
-        main {
-            manifest.srcFile 'AndroidManifest.xml'
-        }
-    }
-}
-
-assemble.doLast
-{
-    // Instead of `ninja install`, Gradle will deploy the files.
-    // We are doing this since FMT is dependent to the ANDROID_STL after build
-    copy {
-        from 'build/intermediates/cmake'
-        into '../libs'
-    }
-    // Copy debug binaries
-    copy {
-        from '../libs/debug/obj'
-        into '../libs/debug'
-    }
-    // Copy Release binaries
-    copy {
-        from '../libs/release/obj'
-        into '../libs/release'
-    }
-    // Remove empty directory
-    delete '../libs/debug/obj'
-    delete '../libs/release/obj'
-}

support/cmake/cppformat-config.cmake.in

@@ -1,4 +1,4 @@
 @PACKAGE_INIT@
 
 include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
-check_required_components(fmt)
+check_required_components(cppformat)

support/cmake/cxx14.cmake

@@ -1,97 +0,0 @@
-# C++14 feature support detection
-
-include(CheckCXXSourceCompiles)
-include(CheckCXXCompilerFlag)
-
-if (NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 11)
-endif()
-message(STATUS "CXX_STANDARD: ${CMAKE_CXX_STANDARD}")
-
-if (CMAKE_CXX_STANDARD EQUAL 20)
-  check_cxx_compiler_flag(-std=c++20 has_std_20_flag)
-  check_cxx_compiler_flag(-std=c++2a has_std_2a_flag)
-
-  if (has_std_20_flag)
-    set(CXX_STANDARD_FLAG -std=c++20)
-  elseif (has_std_2a_flag)
-    set(CXX_STANDARD_FLAG -std=c++2a)
-  endif ()
-elseif (CMAKE_CXX_STANDARD EQUAL 17)
-  check_cxx_compiler_flag(-std=c++17 has_std_17_flag)
-  check_cxx_compiler_flag(-std=c++1z has_std_1z_flag)
-
-  if (has_std_17_flag)
-    set(CXX_STANDARD_FLAG -std=c++17)
-  elseif (has_std_1z_flag)
-    set(CXX_STANDARD_FLAG -std=c++1z)
-  endif ()
-elseif (CMAKE_CXX_STANDARD EQUAL 14)
-  check_cxx_compiler_flag(-std=c++14 has_std_14_flag)
-  check_cxx_compiler_flag(-std=c++1y has_std_1y_flag)
-
-  if (has_std_14_flag)
-    set(CXX_STANDARD_FLAG -std=c++14)
-  elseif (has_std_1y_flag)
-    set(CXX_STANDARD_FLAG -std=c++1y)
-  endif ()
-elseif (CMAKE_CXX_STANDARD EQUAL 11)
-  check_cxx_compiler_flag(-std=c++11 has_std_11_flag)
-  check_cxx_compiler_flag(-std=c++0x has_std_0x_flag)
-
-  if (has_std_11_flag)
-    set(CXX_STANDARD_FLAG -std=c++11)
-  elseif (has_std_0x_flag)
-    set(CXX_STANDARD_FLAG -std=c++0x)
-  endif ()
-endif ()
-
-set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG})
-
-# Check if variadic templates are working and not affected by GCC bug 39653:
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39653
-check_cxx_source_compiles("
-  template <class T, class ...Types>
-  struct S { typedef typename S<Types...>::type type; };
-  int main() {}" SUPPORTS_VARIADIC_TEMPLATES)
-if (NOT SUPPORTS_VARIADIC_TEMPLATES)
-  set (SUPPORTS_VARIADIC_TEMPLATES OFF)
-endif ()
-
-# Check if initializer lists are supported.
-check_cxx_source_compiles("
-  #include <initializer_list>
-  int main() {}" SUPPORTS_INITIALIZER_LIST)
-if (NOT SUPPORTS_INITIALIZER_LIST)
-  set (SUPPORTS_INITIALIZER_LIST OFF)
-endif ()
-
-# Check if enum bases are available
-check_cxx_source_compiles("
-  enum C : char {A};
-  int main() {}"
-  SUPPORTS_ENUM_BASE)
-if (NOT SUPPORTS_ENUM_BASE)
-  set (SUPPORTS_ENUM_BASE OFF)
-endif ()
-
-# Check if type traits are available
-check_cxx_source_compiles("
-  #include <type_traits>
-  class C { void operator=(const C&); };
-  int main() { static_assert(!std::is_copy_assignable<C>::value, \"\"); }"
-  SUPPORTS_TYPE_TRAITS)
-if (NOT SUPPORTS_TYPE_TRAITS)
-  set (SUPPORTS_TYPE_TRAITS OFF)
-endif ()
-
-# Check if user-defined literals are available
-check_cxx_source_compiles("
-  void operator\"\" _udl(long double);
-  int main() {}"
-  SUPPORTS_USER_DEFINED_LITERALS)
-if (NOT SUPPORTS_USER_DEFINED_LITERALS)
-  set (SUPPORTS_USER_DEFINED_LITERALS OFF)
-endif ()
-
-set(CMAKE_REQUIRED_FLAGS )

support/cmake/fmt.pc.in

@@ -1,11 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=@CMAKE_INSTALL_PREFIX@
-libdir=@CMAKE_INSTALL_FULL_LIBDIR@
-includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
-
-Name: fmt
-Description: A modern formatting library
-Version: @FMT_VERSION@
-Libs: -L${libdir} -lfmt
-Cflags: -I${includedir}
-

support/cmake/testCxx11.cmake

@@ -0,0 +1,60 @@
+include(CheckCXXCompilerFlag)
+
+if (FMT_USE_CPP11)
+  check_cxx_compiler_flag(-std=c++11 HAVE_STD_CPP11_FLAG)
+  if (HAVE_STD_CPP11_FLAG)
+    # Check if including cmath works with -std=c++11 and -O3.
+    # It may not in MinGW due to bug http://ehc.ac/p/mingw/bugs/2250/.
+    set(CMAKE_REQUIRED_FLAGS "-std=c++11 -O3")
+    check_cxx_source_compiles("
+      #include <cmath>
+      int main() {}" FMT_CPP11_CMATH)
+    # Check if including <unistd.h> works with -std=c++11.
+    # It may not in MinGW due to bug http://sourceforge.net/p/mingw/bugs/2024/.
+    check_cxx_source_compiles("
+      #include <unistd.h>
+      int main() {}" FMT_CPP11_UNISTD_H)
+    if (FMT_CPP11_CMATH AND FMT_CPP11_UNISTD_H)
+      set(CPP11_FLAG -std=c++11)
+    else ()
+      check_cxx_compiler_flag(-std=gnu++11 HAVE_STD_GNUPP11_FLAG)
+      if (HAVE_STD_CPP11_FLAG)
+        set(CPP11_FLAG -std=gnu++11)
+      endif ()
+    endif ()
+    set(CMAKE_REQUIRED_FLAGS )
+  else ()
+    check_cxx_compiler_flag(-std=c++0x HAVE_STD_CPP0X_FLAG)
+    if (HAVE_STD_CPP0X_FLAG)
+      set(CPP11_FLAG -std=c++0x)
+    endif ()
+  endif ()
+endif ()
+
+set(CMAKE_REQUIRED_FLAGS ${CPP11_FLAG})
+
+# Check if variadic templates are working and not affected by GCC bug 39653:
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39653
+check_cxx_source_compiles("
+  template <class T, class ...Types>
+  struct S { typedef typename S<Types...>::type type; };
+  int main() {}" SUPPORTS_VARIADIC_TEMPLATES)
+
+# Check if initializer lists are supported.
+check_cxx_source_compiles("
+  #include <initializer_list>
+  int main() {}" SUPPORTS_INITIALIZER_LIST)
+
+# Check if enum bases are available
+check_cxx_source_compiles("
+  enum C : char {A};
+  int main() {}"
+  SUPPORTS_ENUM_BASE)
+
+# Check if type traits are available
+check_cxx_source_compiles("
+  #include <type_traits>
+  class C { void operator=(const C&); };
+  int main() { static_assert(!std::is_copy_assignable<C>::value, \"\"); }"
+  SUPPORTS_TYPE_TRAITS)
+set(CMAKE_REQUIRED_FLAGS )

support/compute-powers.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-# Compute 10 ** exp with exp in the range [min_exponent, max_exponent] and print
-# normalized (with most-significant bit equal to 1) significands in hexadecimal.
-
-from __future__ import print_function
-
-min_exponent = -348
-max_exponent = 340
-step = 8
-significand_size = 64
-exp_offset = 2000
-
-class fp:
-    pass
-
-powers = []
-for i, exp in enumerate(range(min_exponent, max_exponent + 1, step)):
-    result = fp()
-    n = 10 ** exp if exp >= 0 else 2 ** exp_offset / 10 ** -exp
-    k = significand_size + 1
-    # Convert to binary and round.
-    binary = '{:b}'.format(n)
-    result.f = (int('{:0<{}}'.format(binary[:k], k), 2) + 1) / 2
-    result.e = len(binary) - (exp_offset if exp < 0 else 0) - significand_size
-    powers.append(result)
-    # Sanity check.
-    exp_offset10 = 400
-    actual = result.f * 10 ** exp_offset10
-    if result.e > 0:
-        actual *= 2 ** result.e
-    else:
-        for j in range(-result.e):
-            actual /= 2
-    expected = 10 ** (exp_offset10 + exp)
-    precision = len('{}'.format(expected)) - len('{}'.format(actual - expected))
-    if precision < 19:
-        print('low precision:', precision)
-        exit(1)
-
-print('Significands:', end='')
-for i, fp in enumerate(powers):
-    if i % 3 == 0:
-        print(end='\n ')
-    print(' {:0<#16x}'.format(fp.f, ), end=',')
-
-print('\n\nExponents:', end='')
-for i, fp in enumerate(powers):
-    if i % 11 == 0:
-        print(end='\n ')
-    print(' {:5}'.format(fp.e), end=',')
-
-print('\n\nMax exponent difference:',
-      max([x.e - powers[i - 1].e for i, x in enumerate(powers)][1:]))

support/docopt.py

@@ -1,581 +0,0 @@
-"""Pythonic command-line interface parser that will make you smile.
-
- * http://docopt.org
- * Repository and issue-tracker: https://github.com/docopt/docopt
- * Licensed under terms of MIT license (see LICENSE-MIT)
- * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com
-
-"""
-import sys
-import re
-
-
-__all__ = ['docopt']
-__version__ = '0.6.1'
-
-
-class DocoptLanguageError(Exception):
-
-    """Error in construction of usage-message by developer."""
-
-
-class DocoptExit(SystemExit):
-
-    """Exit in case user invoked program with incorrect arguments."""
-
-    usage = ''
-
-    def __init__(self, message=''):
-        SystemExit.__init__(self, (message + '\n' + self.usage).strip())
-
-
-class Pattern(object):
-
-    def __eq__(self, other):
-        return repr(self) == repr(other)
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def fix(self):
-        self.fix_identities()
-        self.fix_repeating_arguments()
-        return self
-
-    def fix_identities(self, uniq=None):
-        """Make pattern-tree tips point to same object if they are equal."""
-        if not hasattr(self, 'children'):
-            return self
-        uniq = list(set(self.flat())) if uniq is None else uniq
-        for i, child in enumerate(self.children):
-            if not hasattr(child, 'children'):
-                assert child in uniq
-                self.children[i] = uniq[uniq.index(child)]
-            else:
-                child.fix_identities(uniq)
-
-    def fix_repeating_arguments(self):
-        """Fix elements that should accumulate/increment values."""
-        either = [list(child.children) for child in transform(self).children]
-        for case in either:
-            for e in [child for child in case if case.count(child) > 1]:
-                if type(e) is Argument or type(e) is Option and e.argcount:
-                    if e.value is None:
-                        e.value = []
-                    elif type(e.value) is not list:
-                        e.value = e.value.split()
-                if type(e) is Command or type(e) is Option and e.argcount == 0:
-                    e.value = 0
-        return self
-
-
-def transform(pattern):
-    """Expand pattern into an (almost) equivalent one, but with single Either.
-
-    Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
-    Quirks: [-a] => (-a), (-a...) => (-a -a)
-
-    """
-    result = []
-    groups = [[pattern]]
-    while groups:
-        children = groups.pop(0)
-        parents = [Required, Optional, OptionsShortcut, Either, OneOrMore]
-        if any(t in map(type, children) for t in parents):
-            child = [c for c in children if type(c) in parents][0]
-            children.remove(child)
-            if type(child) is Either:
-                for c in child.children:
-                    groups.append([c] + children)
-            elif type(child) is OneOrMore:
-                groups.append(child.children * 2 + children)
-            else:
-                groups.append(child.children + children)
-        else:
-            result.append(children)
-    return Either(*[Required(*e) for e in result])
-
-
-class LeafPattern(Pattern):
-
-    """Leaf/terminal node of a pattern tree."""
-
-    def __init__(self, name, value=None):
-        self.name, self.value = name, value
-
-    def __repr__(self):
-        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value)
-
-    def flat(self, *types):
-        return [self] if not types or type(self) in types else []
-
-    def match(self, left, collected=None):
-        collected = [] if collected is None else collected
-        pos, match = self.single_match(left)
-        if match is None:
-            return False, left, collected
-        left_ = left[:pos] + left[pos + 1:]
-        same_name = [a for a in collected if a.name == self.name]
-        if type(self.value) in (int, list):
-            if type(self.value) is int:
-                increment = 1
-            else:
-                increment = ([match.value] if type(match.value) is str
-                             else match.value)
-            if not same_name:
-                match.value = increment
-                return True, left_, collected + [match]
-            same_name[0].value += increment
-            return True, left_, collected
-        return True, left_, collected + [match]
-
-
-class BranchPattern(Pattern):
-
-    """Branch/inner node of a pattern tree."""
-
-    def __init__(self, *children):
-        self.children = list(children)
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__,
-                           ', '.join(repr(a) for a in self.children))
-
-    def flat(self, *types):
-        if type(self) in types:
-            return [self]
-        return sum([child.flat(*types) for child in self.children], [])
-
-
-class Argument(LeafPattern):
-
-    def single_match(self, left):
-        for n, pattern in enumerate(left):
-            if type(pattern) is Argument:
-                return n, Argument(self.name, pattern.value)
-        return None, None
-
-    @classmethod
-    def parse(class_, source):
-        name = re.findall('(<\S*?>)', source)[0]
-        value = re.findall('\[default: (.*)\]', source, flags=re.I)
-        return class_(name, value[0] if value else None)
-
-
-class Command(Argument):
-
-    def __init__(self, name, value=False):
-        self.name, self.value = name, value
-
-    def single_match(self, left):
-        for n, pattern in enumerate(left):
-            if type(pattern) is Argument:
-                if pattern.value == self.name:
-                    return n, Command(self.name, True)
-                else:
-                    break
-        return None, None
-
-
-class Option(LeafPattern):
-
-    def __init__(self, short=None, long=None, argcount=0, value=False):
-        assert argcount in (0, 1)
-        self.short, self.long, self.argcount = short, long, argcount
-        self.value = None if value is False and argcount else value
-
-    @classmethod
-    def parse(class_, option_description):
-        short, long, argcount, value = None, None, 0, False
-        options, _, description = option_description.strip().partition('  ')
-        options = options.replace(',', ' ').replace('=', ' ')
-        for s in options.split():
-            if s.startswith('--'):
-                long = s
-            elif s.startswith('-'):
-                short = s
-            else:
-                argcount = 1
-        if argcount:
-            matched = re.findall('\[default: (.*)\]', description, flags=re.I)
-            value = matched[0] if matched else None
-        return class_(short, long, argcount, value)
-
-    def single_match(self, left):
-        for n, pattern in enumerate(left):
-            if self.name == pattern.name:
-                return n, pattern
-        return None, None
-
-    @property
-    def name(self):
-        return self.long or self.short
-
-    def __repr__(self):
-        return 'Option(%r, %r, %r, %r)' % (self.short, self.long,
-                                           self.argcount, self.value)
-
-
-class Required(BranchPattern):
-
-    def match(self, left, collected=None):
-        collected = [] if collected is None else collected
-        l = left
-        c = collected
-        for pattern in self.children:
-            matched, l, c = pattern.match(l, c)
-            if not matched:
-                return False, left, collected
-        return True, l, c
-
-
-class Optional(BranchPattern):
-
-    def match(self, left, collected=None):
-        collected = [] if collected is None else collected
-        for pattern in self.children:
-            m, left, collected = pattern.match(left, collected)
-        return True, left, collected
-
-
-class OptionsShortcut(Optional):
-
-    """Marker/placeholder for [options] shortcut."""
-
-
-class OneOrMore(BranchPattern):
-
-    def match(self, left, collected=None):
-        assert len(self.children) == 1
-        collected = [] if collected is None else collected
-        l = left
-        c = collected
-        l_ = None
-        matched = True
-        times = 0
-        while matched:
-            # could it be that something didn't match but changed l or c?
-            matched, l, c = self.children[0].match(l, c)
-            times += 1 if matched else 0
-            if l_ == l:
-                break
-            l_ = l
-        if times >= 1:
-            return True, l, c
-        return False, left, collected
-
-
-class Either(BranchPattern):
-
-    def match(self, left, collected=None):
-        collected = [] if collected is None else collected
-        outcomes = []
-        for pattern in self.children:
-            matched, _, _ = outcome = pattern.match(left, collected)
-            if matched:
-                outcomes.append(outcome)
-        if outcomes:
-            return min(outcomes, key=lambda outcome: len(outcome[1]))
-        return False, left, collected
-
-
-class Tokens(list):
-
-    def __init__(self, source, error=DocoptExit):
-        self += source.split() if hasattr(source, 'split') else source
-        self.error = error
-
-    @staticmethod
-    def from_pattern(source):
-        source = re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source)
-        source = [s for s in re.split('\s+|(\S*<.*?>)', source) if s]
-        return Tokens(source, error=DocoptLanguageError)
-
-    def move(self):
-        return self.pop(0) if len(self) else None
-
-    def current(self):
-        return self[0] if len(self) else None
-
-
-def parse_long(tokens, options):
-    """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;"""
-    long, eq, value = tokens.move().partition('=')
-    assert long.startswith('--')
-    value = None if eq == value == '' else value
-    similar = [o for o in options if o.long == long]
-    if tokens.error is DocoptExit and similar == []:  # if no exact match
-        similar = [o for o in options if o.long and o.long.startswith(long)]
-    if len(similar) > 1:  # might be simply specified ambiguously 2+ times?
-        raise tokens.error('%s is not a unique prefix: %s?' %
-                           (long, ', '.join(o.long for o in similar)))
-    elif len(similar) < 1:
-        argcount = 1 if eq == '=' else 0
-        o = Option(None, long, argcount)
-        options.append(o)
-        if tokens.error is DocoptExit:
-            o = Option(None, long, argcount, value if argcount else True)
-    else:
-        o = Option(similar[0].short, similar[0].long,
-                   similar[0].argcount, similar[0].value)
-        if o.argcount == 0:
-            if value is not None:
-                raise tokens.error('%s must not have an argument' % o.long)
-        else:
-            if value is None:
-                if tokens.current() in [None, '--']:
-                    raise tokens.error('%s requires argument' % o.long)
-                value = tokens.move()
-        if tokens.error is DocoptExit:
-            o.value = value if value is not None else True
-    return [o]
-
-
-def parse_shorts(tokens, options):
-    """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;"""
-    token = tokens.move()
-    assert token.startswith('-') and not token.startswith('--')
-    left = token.lstrip('-')
-    parsed = []
-    while left != '':
-        short, left = '-' + left[0], left[1:]
-        similar = [o for o in options if o.short == short]
-        if len(similar) > 1:
-            raise tokens.error('%s is specified ambiguously %d times' %
-                               (short, len(similar)))
-        elif len(similar) < 1:
-            o = Option(short, None, 0)
-            options.append(o)
-            if tokens.error is DocoptExit:
-                o = Option(short, None, 0, True)
-        else:  # why copying is necessary here?
-            o = Option(short, similar[0].long,
-                       similar[0].argcount, similar[0].value)
-            value = None
-            if o.argcount != 0:
-                if left == '':
-                    if tokens.current() in [None, '--']:
-                        raise tokens.error('%s requires argument' % short)
-                    value = tokens.move()
-                else:
-                    value = left
-                    left = ''
-            if tokens.error is DocoptExit:
-                o.value = value if value is not None else True
-        parsed.append(o)
-    return parsed
-
-
-def parse_pattern(source, options):
-    tokens = Tokens.from_pattern(source)
-    result = parse_expr(tokens, options)
-    if tokens.current() is not None:
-        raise tokens.error('unexpected ending: %r' % ' '.join(tokens))
-    return Required(*result)
-
-
-def parse_expr(tokens, options):
-    """expr ::= seq ( '|' seq )* ;"""
-    seq = parse_seq(tokens, options)
-    if tokens.current() != '|':
-        return seq
-    result = [Required(*seq)] if len(seq) > 1 else seq
-    while tokens.current() == '|':
-        tokens.move()
-        seq = parse_seq(tokens, options)
-        result += [Required(*seq)] if len(seq) > 1 else seq
-    return [Either(*result)] if len(result) > 1 else result
-
-
-def parse_seq(tokens, options):
-    """seq ::= ( atom [ '...' ] )* ;"""
-    result = []
-    while tokens.current() not in [None, ']', ')', '|']:
-        atom = parse_atom(tokens, options)
-        if tokens.current() == '...':
-            atom = [OneOrMore(*atom)]
-            tokens.move()
-        result += atom
-    return result
-
-
-def parse_atom(tokens, options):
-    """atom ::= '(' expr ')' | '[' expr ']' | 'options'
-             | long | shorts | argument | command ;
-    """
-    token = tokens.current()
-    result = []
-    if token in '([':
-        tokens.move()
-        matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token]
-        result = pattern(*parse_expr(tokens, options))
-        if tokens.move() != matching:
-            raise tokens.error("unmatched '%s'" % token)
-        return [result]
-    elif token == 'options':
-        tokens.move()
-        return [OptionsShortcut()]
-    elif token.startswith('--') and token != '--':
-        return parse_long(tokens, options)
-    elif token.startswith('-') and token not in ('-', '--'):
-        return parse_shorts(tokens, options)
-    elif token.startswith('<') and token.endswith('>') or token.isupper():
-        return [Argument(tokens.move())]
-    else:
-        return [Command(tokens.move())]
-
-
-def parse_argv(tokens, options, options_first=False):
-    """Parse command-line argument vector.
-
-    If options_first:
-        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
-    else:
-        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;
-
-    """
-    parsed = []
-    while tokens.current() is not None:
-        if tokens.current() == '--':
-            return parsed + [Argument(None, v) for v in tokens]
-        elif tokens.current().startswith('--'):
-            parsed += parse_long(tokens, options)
-        elif tokens.current().startswith('-') and tokens.current() != '-':
-            parsed += parse_shorts(tokens, options)
-        elif options_first:
-            return parsed + [Argument(None, v) for v in tokens]
-        else:
-            parsed.append(Argument(None, tokens.move()))
-    return parsed
-
-
-def parse_defaults(doc):
-    defaults = []
-    for s in parse_section('options:', doc):
-        # FIXME corner case "bla: options: --foo"
-        _, _, s = s.partition(':')  # get rid of "options:"
-        split = re.split('\n[ \t]*(-\S+?)', '\n' + s)[1:]
-        split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
-        options = [Option.parse(s) for s in split if s.startswith('-')]
-        defaults += options
-    return defaults
-
-
-def parse_section(name, source):
-    pattern = re.compile('^([^\n]*' + name + '[^\n]*\n?(?:[ \t].*?(?:\n|$))*)',
-                         re.IGNORECASE | re.MULTILINE)
-    return [s.strip() for s in pattern.findall(source)]
-
-
-def formal_usage(section):
-    _, _, section = section.partition(':')  # drop "usage:"
-    pu = section.split()
-    return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )'
-
-
-def extras(help, version, options, doc):
-    if help and any((o.name in ('-h', '--help')) and o.value for o in options):
-        print(doc.strip("\n"))
-        sys.exit()
-    if version and any(o.name == '--version' and o.value for o in options):
-        print(version)
-        sys.exit()
-
-
-class Dict(dict):
-    def __repr__(self):
-        return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items()))
-
-
-def docopt(doc, argv=None, help=True, version=None, options_first=False):
-    """Parse `argv` based on command-line interface described in `doc`.
-
-    `docopt` creates your command-line interface based on its
-    description that you pass as `doc`. Such description can contain
-    --options, <positional-argument>, commands, which could be
-    [optional], (required), (mutually | exclusive) or repeated...
-
-    Parameters
-    ----------
-    doc : str
-        Description of your command-line interface.
-    argv : list of str, optional
-        Argument vector to be parsed. sys.argv[1:] is used if not
-        provided.
-    help : bool (default: True)
-        Set to False to disable automatic help on -h or --help
-        options.
-    version : any object
-        If passed, the object will be printed if --version is in
-        `argv`.
-    options_first : bool (default: False)
-        Set to True to require options precede positional arguments,
-        i.e. to forbid options and positional arguments intermix.
-
-    Returns
-    -------
-    args : dict
-        A dictionary, where keys are names of command-line elements
-        such as e.g. "--verbose" and "<path>", and values are the
-        parsed values of those elements.
-
-    Example
-    -------
-    >>> from docopt import docopt
-    >>> doc = '''
-    ... Usage:
-    ...     my_program tcp <host> <port> [--timeout=<seconds>]
-    ...     my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
-    ...     my_program (-h | --help | --version)
-    ...
-    ... Options:
-    ...     -h, --help  Show this screen and exit.
-    ...     --baud=<n>  Baudrate [default: 9600]
-    ... '''
-    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
-    >>> docopt(doc, argv)
-    {'--baud': '9600',
-     '--help': False,
-     '--timeout': '30',
-     '--version': False,
-     '<host>': '127.0.0.1',
-     '<port>': '80',
-     'serial': False,
-     'tcp': True}
-
-    See also
-    --------
-    * For video introduction see http://docopt.org
-    * Full documentation is available in README.rst as well as online
-      at https://github.com/docopt/docopt#readme
-
-    """
-    argv = sys.argv[1:] if argv is None else argv
-
-    usage_sections = parse_section('usage:', doc)
-    if len(usage_sections) == 0:
-        raise DocoptLanguageError('"usage:" (case-insensitive) not found.')
-    if len(usage_sections) > 1:
-        raise DocoptLanguageError('More than one "usage:" (case-insensitive).')
-    DocoptExit.usage = usage_sections[0]
-
-    options = parse_defaults(doc)
-    pattern = parse_pattern(formal_usage(DocoptExit.usage), options)
-    # [default] syntax for argument is disabled
-    #for a in pattern.flat(Argument):
-    #    same_name = [d for d in arguments if d.name == a.name]
-    #    if same_name:
-    #        a.value = same_name[0].value
-    argv = parse_argv(Tokens(argv), list(options), options_first)
-    pattern_options = set(pattern.flat(Option))
-    for options_shortcut in pattern.flat(OptionsShortcut):
-        doc_options = parse_defaults(doc)
-        options_shortcut.children = list(set(doc_options) - pattern_options)
-        #if any_options:
-        #    options_shortcut.children += [Option(o.short, o.long, o.argcount)
-        #                    for o in argv if type(o) is Option]
-    extras(help, version, argv, doc)
-    matched, left, collected = pattern.fix().match(argv)
-    if matched and left == []:  # better error message if left?
-        return Dict((a.name, a.value) for a in (pattern.flat() + collected))
-    raise DocoptExit()

support/download.py

@@ -0,0 +1,46 @@
+# A file downloader.
+
+import contextlib, os, tempfile, timer, urllib2, urlparse
+
+class Downloader:
+  def __init__(self, dir=None):
+    self.dir = dir
+
+  # Downloads a file and removes it when exiting a block.
+  # Usage:
+  #  d = Downloader()
+  #  with d.download(url) as f:
+  #    use_file(f)
+  def download(self, url, cookie=None):
+    suffix = os.path.splitext(urlparse.urlsplit(url)[2])[1]
+    fd, filename = tempfile.mkstemp(suffix=suffix, dir=self.dir)
+    os.close(fd)
+    with timer.print_time('Downloading', url, 'to', filename):
+      opener = urllib2.build_opener()
+      if cookie:
+        opener.addheaders.append(('Cookie', cookie))
+      num_tries = 2
+      for i in range(num_tries):
+        try:
+          f = opener.open(url)
+        except urllib2.URLError, e:
+          print('Failed to open url', url)
+          continue
+        length = f.headers.get('content-length')
+        if not length:
+          print('Failed to get content-length')
+          continue
+        length = int(length)
+        with open(filename, 'wb') as out:
+          count = 0
+          while count < length:
+            data = f.read(1024 * 1024)
+            count += len(data)
+            out.write(data)
+    @contextlib.contextmanager
+    def remove(filename):
+      try:
+        yield filename
+      finally:
+        os.remove(filename)
+    return remove(filename)

support/fmt.pro

@@ -1,27 +0,0 @@
-# Staticlib configuration for qmake builds
-# For some reason qmake 3.1 fails to identify source dependencies and excludes format.cc and printf.cc
-# from compilation so it _MUST_ be called as qmake -nodepend
-# A workaround is implemented below: a custom compiler is defined which does not track dependencies
-
-TEMPLATE = lib
-
-TARGET = fmt
-
-QMAKE_EXT_CPP = .cc
-
-CONFIG = staticlib warn_on c++11
-
-FMT_SOURCES = \
-    ../src/format.cc \
-    ../src/posix.cc
-
-fmt.name = libfmt
-fmt.input = FMT_SOURCES
-fmt.output = ${QMAKE_FILE_BASE}$$QMAKE_EXT_OBJ
-fmt.clean = ${QMAKE_FILE_BASE}$$QMAKE_EXT_OBJ
-fmt.depends = ${QMAKE_FILE_IN}
-# QMAKE_RUN_CXX will not be expanded
-fmt.commands = $$QMAKE_CXX -c $$QMAKE_CXXFLAGS $$QMAKE_CXXFLAGS_WARN_ON $$QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO $$QMAKE_CXXFLAGS_CXX11 ${QMAKE_FILE_IN}
-fmt.variable_out = OBJECTS
-fmt.CONFIG = no_dependencies no_link
-QMAKE_EXTRA_COMPILERS += fmt

support/manage.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python
-
-"""Manage site and releases.
-
-Usage:
-  manage.py release [<branch>]
-  manage.py site
-"""
-
-from __future__ import print_function
-import datetime, docopt, errno, fileinput, json, os
-import re, requests, shutil, sys, tempfile
-from contextlib import contextmanager
-from distutils.version import LooseVersion
-from subprocess import check_call
-
-
-class Git:
-    def __init__(self, dir):
-        self.dir = dir
-
-    def call(self, method, args, **kwargs):
-        return check_call(['git', method] + list(args), **kwargs)
-
-    def add(self, *args):
-        return self.call('add', args, cwd=self.dir)
-
-    def checkout(self, *args):
-        return self.call('checkout', args, cwd=self.dir)
-
-    def clean(self, *args):
-        return self.call('clean', args, cwd=self.dir)
-
-    def clone(self, *args):
-        return self.call('clone', list(args) + [self.dir])
-
-    def commit(self, *args):
-        return self.call('commit', args, cwd=self.dir)
-
-    def pull(self, *args):
-        return self.call('pull', args, cwd=self.dir)
-
-    def push(self, *args):
-        return self.call('push', args, cwd=self.dir)
-
-    def reset(self, *args):
-        return self.call('reset', args, cwd=self.dir)
-
-    def update(self, *args):
-        clone = not os.path.exists(self.dir)
-        if clone:
-            self.clone(*args)
-        return clone
-
-
-def clean_checkout(repo, branch):
-    repo.clean('-f', '-d')
-    repo.reset('--hard')
-    repo.checkout(branch)
-
-
-class Runner:
-    def __init__(self, cwd):
-        self.cwd = cwd
-
-    def __call__(self, *args, **kwargs):
-        kwargs['cwd'] = kwargs.get('cwd', self.cwd)
-        check_call(args, **kwargs)
-
-
-def create_build_env():
-    """Create a build environment."""
-    class Env:
-        pass
-    env = Env()
-
-    # Import the documentation build module.
-    env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    sys.path.insert(0, os.path.join(env.fmt_dir, 'doc'))
-    import build
-
-    env.build_dir = 'build'
-    env.versions = build.versions
-
-    # Virtualenv and repos are cached to speed up builds.
-    build.create_build_env(os.path.join(env.build_dir, 'virtualenv'))
-
-    env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
-    return env
-
-
-@contextmanager
-def rewrite(filename):
-    class Buffer:
-        pass
-    buffer = Buffer()
-    if not os.path.exists(filename):
-        buffer.data = ''
-        yield buffer
-        return
-    with open(filename) as f:
-        buffer.data = f.read()
-    yield buffer
-    with open(filename, 'w') as f:
-        f.write(buffer.data)
-
-
-fmt_repo_url = 'git@github.com:fmtlib/fmt'
-
-
-def update_site(env):
-    env.fmt_repo.update(fmt_repo_url)
-
-    doc_repo = Git(os.path.join(env.build_dir, 'fmtlib.github.io'))
-    doc_repo.update('git@github.com:fmtlib/fmtlib.github.io')
-
-    for version in env.versions:
-        clean_checkout(env.fmt_repo, version)
-        target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
-        # Remove the old theme.
-        for entry in os.listdir(target_doc_dir):
-            path = os.path.join(target_doc_dir, entry)
-            if os.path.isdir(path):
-                shutil.rmtree(path)
-        # Copy the new theme.
-        for entry in ['_static', '_templates', 'basic-bootstrap', 'bootstrap',
-                      'conf.py', 'fmt.less']:
-            src = os.path.join(env.fmt_dir, 'doc', entry)
-            dst = os.path.join(target_doc_dir, entry)
-            copy = shutil.copytree if os.path.isdir(src) else shutil.copyfile
-            copy(src, dst)
-        # Rename index to contents.
-        contents = os.path.join(target_doc_dir, 'contents.rst')
-        if not os.path.exists(contents):
-            os.rename(os.path.join(target_doc_dir, 'index.rst'), contents)
-        # Fix issues in reference.rst/api.rst.
-        for filename in ['reference.rst', 'api.rst']:
-            pattern = re.compile('doxygenfunction.. (bin|oct|hexu|hex)$', re.M)
-            with rewrite(os.path.join(target_doc_dir, filename)) as b:
-                b.data = b.data.replace('std::ostream &', 'std::ostream&')
-                b.data = re.sub(pattern, r'doxygenfunction:: \1(int)', b.data)
-                b.data = b.data.replace('std::FILE*', 'std::FILE *')
-                b.data = b.data.replace('unsigned int', 'unsigned')
-                b.data = b.data.replace('operator""_', 'operator"" _')
-        # Fix a broken link in index.rst.
-        index = os.path.join(target_doc_dir, 'index.rst')
-        with rewrite(index) as b:
-            b.data = b.data.replace(
-                'doc/latest/index.html#format-string-syntax', 'syntax.html')
-        # Build the docs.
-        html_dir = os.path.join(env.build_dir, 'html')
-        if os.path.exists(html_dir):
-            shutil.rmtree(html_dir)
-        include_dir = env.fmt_repo.dir
-        if LooseVersion(version) >= LooseVersion('5.0.0'):
-            include_dir = os.path.join(include_dir, 'include', 'fmt')
-        elif LooseVersion(version) >= LooseVersion('3.0.0'):
-            include_dir = os.path.join(include_dir, 'fmt')
-        import build
-        build.build_docs(version, doc_dir=target_doc_dir,
-                         include_dir=include_dir, work_dir=env.build_dir)
-        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
-        # Create symlinks for older versions.
-        for link, target in {'index': 'contents', 'api': 'reference'}.items():
-            link = os.path.join(html_dir, link) + '.html'
-            target += '.html'
-            if os.path.exists(os.path.join(html_dir, target)) and \
-               not os.path.exists(link):
-                os.symlink(target, link)
-        # Copy docs to the website.
-        version_doc_dir = os.path.join(doc_repo.dir, version)
-        try:
-            shutil.rmtree(version_doc_dir)
-        except OSError as e:
-            if e.errno != errno.ENOENT:
-                raise
-        shutil.move(html_dir, version_doc_dir)
-
-
-def release(args):
-    env = create_build_env()
-    fmt_repo = env.fmt_repo
-
-    branch = args.get('<branch>')
-    if branch is None:
-        branch = 'master'
-    if not fmt_repo.update('-b', branch, fmt_repo_url):
-        clean_checkout(fmt_repo, branch)
-
-    # Convert changelog from RST to GitHub-flavored Markdown and get the
-    # version.
-    changelog = 'ChangeLog.rst'
-    changelog_path = os.path.join(fmt_repo.dir, changelog)
-    import rst2md
-    changes, version = rst2md.convert(changelog_path)
-    cmakelists = 'CMakeLists.txt'
-    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
-                                inplace=True):
-        prefix = 'set(FMT_VERSION '
-        if line.startswith(prefix):
-            line = prefix + version + ')\n'
-        sys.stdout.write(line)
-
-    # Update the version in the changelog.
-    title_len = 0
-    for line in fileinput.input(changelog_path, inplace=True):
-        if line.decode('utf-8').startswith(version + ' - TBD'):
-            line = version + ' - ' + datetime.date.today().isoformat()
-            title_len = len(line)
-            line += '\n'
-        elif title_len:
-            line = '-' * title_len + '\n'
-            title_len = 0
-        sys.stdout.write(line)
-
-    # Add the version to the build script.
-    script = os.path.join('doc', 'build.py')
-    script_path = os.path.join(fmt_repo.dir, script)
-    for line in fileinput.input(script_path, inplace=True):
-      m = re.match(r'( *versions = )\[(.+)\]', line)
-      if m:
-        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
-      sys.stdout.write(line)
-
-    fmt_repo.checkout('-B', 'release')
-    fmt_repo.add(changelog, cmakelists, script)
-    fmt_repo.commit('-m', 'Update version')
-
-    # Build the docs and package.
-    run = Runner(fmt_repo.dir)
-    run('cmake', '.')
-    run('make', 'doc', 'package_source')
-    update_site(env)
-
-    # Create a release on GitHub.
-    fmt_repo.push('origin', 'release')
-    params = {'access_token': os.getenv('FMT_TOKEN')}
-    r = requests.post('https://api.github.com/repos/fmtlib/fmt/releases',
-                      params=params,
-                      data=json.dumps({'tag_name': version,
-                                       'target_commitish': 'release',
-                                       'body': changes, 'draft': True}))
-    if r.status_code != 201:
-        raise Exception('Failed to create a release ' + str(r))
-    id = r.json()['id']
-    uploads_url = 'https://uploads.github.com/repos/fmtlib/fmt/releases'
-    package = 'fmt-{}.zip'.format(version)
-    r = requests.post(
-        '{}/{}/assets?name={}'.format(uploads_url, id, package),
-        headers={'Content-Type': 'application/zip'},
-        params=params, data=open('build/fmt/' + package, 'rb'))
-    if r.status_code != 201:
-        raise Exception('Failed to upload an asset ' + str(r))
-
-
-if __name__ == '__main__':
-    args = docopt.docopt(__doc__)
-    if args.get('release'):
-        release(args)
-    elif args.get('site'):
-        update_site(create_build_env())

support/release.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+# Release script
+
+from __future__ import print_function
+import datetime, fileinput, json, os, re, requests, shutil, sys, tempfile
+from docutils import nodes, writers, core
+from subprocess import check_call
+
+class MDWriter(writers.Writer):
+    """GitHub-flavored markdown writer"""
+
+    supported = ('md',)
+    """Formats this writer supports."""
+
+    def translate(self):
+        translator = Translator(self.document)
+        self.document.walkabout(translator)
+        self.output = (translator.output, translator.version)
+
+
+def is_github_ref(node):
+    return re.match('https://github.com/.*/(issues|pull)/.*', node['refuri'])
+
+
+class Translator(nodes.NodeVisitor):
+    def __init__(self, document):
+        nodes.NodeVisitor.__init__(self, document)
+        self.output = ''
+        self.indent = 0
+        self.preserve_newlines = False
+
+    def write(self, text):
+        self.output += text.replace('\n', '\n' + ' ' * self.indent)
+
+    def visit_document(self, node):
+        pass
+
+    def depart_document(self, node):
+        pass
+
+    def visit_section(self, node):
+        pass
+
+    def depart_section(self, node):
+        # Skip all sections except the first one.
+        raise nodes.StopTraversal
+
+    def visit_title(self, node):
+        self.version = re.match(r'(\d+\.\d+\.\d+).*', node.children[0]).group(1)
+        raise nodes.SkipChildren
+
+    def depart_title(self, node):
+        pass
+
+    def visit_Text(self, node):
+        if not self.preserve_newlines:
+            node = node.replace('\n', ' ')
+        self.write(node)
+
+    def depart_Text(self, node):
+        pass
+
+    def visit_bullet_list(self, node):
+        pass
+
+    def depart_bullet_list(self, node):
+        pass
+
+    def visit_list_item(self, node):
+        self.write('* ')
+        self.indent += 2
+
+    def depart_list_item(self, node):
+        self.indent -= 2
+        self.write('\n\n')
+
+    def visit_paragraph(self, node):
+        pass
+
+    def depart_paragraph(self, node):
+        pass
+
+    def visit_reference(self, node):
+        if not is_github_ref(node):
+            self.write('[')
+
+    def depart_reference(self, node):
+        if not is_github_ref(node):
+            self.write('](' + node['refuri'] + ')')
+
+    def visit_target(self, node):
+        pass
+
+    def depart_target(self, node):
+        pass
+
+    def visit_literal(self, node):
+        self.write('`')
+
+    def depart_literal(self, node):
+        self.write('`')
+
+    def visit_literal_block(self, node):
+        self.write('\n\n```')
+        if 'c++' in node['classes']:
+            self.write('c++')
+        self.write('\n')
+        self.preserve_newlines = True
+
+    def depart_literal_block(self, node):
+        self.write('\n```\n')
+        self.preserve_newlines = False
+
+    def visit_inline(self, node):
+        pass
+
+    def depart_inline(self, node):
+        pass
+
+
+class Runner:
+    def __init__(self):
+        self.cwd = '.'
+
+    def __call__(self, *args, **kwargs):
+        kwargs['cwd'] = kwargs.get('cwd', self.cwd)
+        check_call(args, **kwargs)
+
+workdir = tempfile.mkdtemp()
+try:
+    run = Runner()
+    cppformat_dir = os.path.join(workdir, 'cppformat')
+    run('git', 'clone', 'git@github.com:cppformat/cppformat.git', cppformat_dir)
+
+    # Convert changelog from RST to GitHub-flavored Markdown and get the version.
+    changelog = 'ChangeLog.rst'
+    changelog_path = os.path.join(cppformat_dir, changelog)
+    changes, version = core.publish_file(source_path=changelog_path, writer=MDWriter())
+    cmakelists = 'CMakeLists.txt'
+    for line in fileinput.input(os.path.join(cppformat_dir, cmakelists), inplace=True):
+        prefix = 'set(CPPFORMAT_VERSION '
+        if line.startswith(prefix):
+            line = prefix + version + ')\n'
+        sys.stdout.write(line)
+
+    # Update the version in the changelog.
+    title_len = 0
+    for line in fileinput.input(changelog_path, inplace=True):
+        if line.startswith(version + ' - TBD'):
+            line = version + ' - ' + datetime.date.today().isoformat()
+            title_len = len(line)
+            line += '\n'
+        elif title_len:
+            line = '-' * title_len + '\n'
+            title_len = 0
+        sys.stdout.write(line)
+    run.cwd = cppformat_dir
+    run('git', 'checkout', '-b', 'release')
+    run('git', 'add', changelog, cmakelists)
+    run('git', 'commit', '-m', 'Update version')
+
+    # Build the docs and package.
+    run('cmake', '.')
+    run('make', 'doc', 'package_source')
+    site_dir = os.path.join(workdir, 'cppformat.github.io')
+    run('git', 'clone', 'git@github.com:cppformat/cppformat.github.io.git', site_dir)
+    doc_dir = os.path.join(site_dir, version)
+    shutil.copytree(os.path.join(cppformat_dir, 'doc', 'html'), doc_dir,
+                    ignore=shutil.ignore_patterns('.doctrees', '.buildinfo'))
+    run.cwd = site_dir
+    run('git', 'add', doc_dir)
+    run('git', 'commit', '-m', 'Update docs')
+
+    # Create a release on GitHub.
+    run('git', 'push', 'origin', 'release', cwd=cppformat_dir)
+    r = requests.post('https://api.github.com/repos/cppformat/cppformat/releases',
+                      params={'access_token': os.getenv('CPPFORMAT_TOKEN')},
+                      data=json.dumps({'tag_name1': version, 'target_commitish': 'release',
+                                      'body': changes, 'draft': True}))
+    if r.status_code != 201:
+        raise Exception('Failed to create a release ' + str(r))
+finally:
+    shutil.rmtree(workdir)

support/rst2md.py

@@ -1,159 +0,0 @@
-#!/usr/bin/env python
-# reStructuredText (RST) to GitHub-flavored Markdown converter
-
-import re, sys
-from docutils import core, nodes, writers
-
-
-def is_github_ref(node):
-    return re.match('https://github.com/.*/(issues|pull)/.*', node['refuri'])
-
-
-class Translator(nodes.NodeVisitor):
-    def __init__(self, document):
-        nodes.NodeVisitor.__init__(self, document)
-        self.output = ''
-        self.indent = 0
-        self.preserve_newlines = False
-
-    def write(self, text):
-        self.output += text.replace('\n', '\n' + ' ' * self.indent)
-
-    def visit_document(self, node):
-        pass
-
-    def depart_document(self, node):
-        pass
-
-    def visit_section(self, node):
-        pass
-
-    def depart_section(self, node):
-        # Skip all sections except the first one.
-        raise nodes.StopTraversal
-
-    def visit_title(self, node):
-        self.version = re.match(r'(\d+\.\d+\.\d+).*', node.children[0]).group(1)
-        raise nodes.SkipChildren
-
-    def visit_title_reference(self, node):
-        raise Exception(node)
-
-    def depart_title(self, node):
-        pass
-
-    def visit_Text(self, node):
-        if not self.preserve_newlines:
-            node = node.replace('\n', ' ')
-        self.write(node)
-
-    def depart_Text(self, node):
-        pass
-
-    def visit_bullet_list(self, node):
-        pass
-
-    def depart_bullet_list(self, node):
-        pass
-
-    def visit_list_item(self, node):
-        self.write('* ')
-        self.indent += 2
-
-    def depart_list_item(self, node):
-        self.indent -= 2
-        self.write('\n\n')
-
-    def visit_paragraph(self, node):
-        pass
-
-    def depart_paragraph(self, node):
-        pass
-
-    def visit_reference(self, node):
-        if not is_github_ref(node):
-            self.write('[')
-
-    def depart_reference(self, node):
-        if not is_github_ref(node):
-            self.write('](' + node['refuri'] + ')')
-
-    def visit_target(self, node):
-        pass
-
-    def depart_target(self, node):
-        pass
-
-    def visit_literal(self, node):
-        self.write('`')
-
-    def depart_literal(self, node):
-        self.write('`')
-
-    def visit_literal_block(self, node):
-        self.write('\n\n```')
-        if 'c++' in node['classes']:
-            self.write('c++')
-        self.write('\n')
-        self.preserve_newlines = True
-
-    def depart_literal_block(self, node):
-        self.write('\n```\n')
-        self.preserve_newlines = False
-
-    def visit_inline(self, node):
-        pass
-
-    def depart_inline(self, node):
-        pass
-
-    def visit_image(self, node):
-        self.write('![](' + node['uri'] + ')')
-
-    def depart_image(self, node):
-        pass
-
-    def write_row(self, row, widths):
-        for i, entry in enumerate(row):
-            text = entry[0][0] if len(entry) > 0 else ''
-            if i != 0:
-                self.write('|')
-            self.write('{:{}}'.format(text, widths[i]))
-        self.write('\n')
-
-    def visit_table(self, node):
-        table = node.children[0]
-        colspecs = table[:-2]
-        thead = table[-2]
-        tbody = table[-1]
-        widths = [int(cs['colwidth']) for cs in colspecs]
-        sep = '|'.join(['-' * w for w in widths]) + '\n'
-        self.write('\n\n')
-        self.write_row(thead[0], widths)
-        self.write(sep)
-        for row in tbody:
-            self.write_row(row, widths)
-        raise nodes.SkipChildren
-
-    def depart_table(self, node):
-        pass
-
-class MDWriter(writers.Writer):
-    """GitHub-flavored markdown writer"""
-
-    supported = ('md',)
-    """Formats this writer supports."""
-
-    def translate(self):
-        translator = Translator(self.document)
-        self.document.walkabout(translator)
-        self.output = (translator.output, translator.version)
-
-
-def convert(rst_path):
-    """Converts RST file to Markdown."""
-    return core.publish_file(source_path=rst_path, writer=MDWriter())
-
-
-if __name__ == '__main__':
-    convert(sys.argv[1])

support/rtd/index.rst

@@ -1,2 +1,2 @@
 If you are not redirected automatically, follow the
-`link to the fmt documentation <http://fmtlib.net/latest/>`_.
+`link to the C++ Format documentation <http://cppformat.github.io/latest/>`_.

support/rtd/theme/layout.html

@@ -2,15 +2,15 @@
 
 {% block extrahead %}
 <meta charset="UTF-8">
-<meta http-equiv="refresh" content="1;url=http://fmtlib.net/latest/">
+<meta http-equiv="refresh" content="1;url=http://cppformat.github.io/latest/">
 <script type="text/javascript">
-    window.location.href = "http://fmtlib.net/latest/"
+    window.location.href = "http://cppformat.github.io/latest/"
 </script>
 <title>Page Redirection</title>
 {% endblock %}
 
 {% block document %}
-If you are not redirected automatically, follow the <a href='http://fmtlib.net/latest/'>link to the fmt documentation</a>.
+If you are not redirected automatically, follow the <a href='http://cppformat.github.io/latest/'>link to the C++ Format documentation</a>.
 {% endblock %}
 
 {% block footer %}

support/timer.py

@@ -0,0 +1,35 @@
+# A with statement based timer.
+
+from __future__ import print_function
+from contextlib import contextmanager
+import timeit
+
+class Timer:
+  """
+  A with statement based timer.
+  Usage:
+    t = Timer()
+    with t:
+      do_something()
+    time = t.time
+  """
+    
+  def __enter__(self):
+    self.start = timeit.default_timer()
+
+  def __exit__(self, type, value, traceback):
+    finish = timeit.default_timer()
+    self.time = finish - self.start
+
+@contextmanager
+def print_time(*args):
+  """
+  Measures and prints the time taken to execute nested code.
+  args: Additional arguments to print.
+  """
+  t = Timer()
+  print(*args)
+  with t:
+    yield
+  print(*args, end=' ')
+  print('finished in {0:.2f} second(s)'.format(t.time))

support/travis-build.py

@@ -2,112 +2,76 @@
 # Build the project on Travis CI.
 
 from __future__ import print_function
-import errno, os, shutil, subprocess, sys, urllib
-from subprocess import call, check_call, Popen, PIPE, STDOUT
+import errno, os, re, shutil, sys, tempfile, urllib
+from subprocess import call, check_call, check_output, Popen, PIPE, STDOUT
 
 def rmtree_if_exists(dir):
-    try:
-        shutil.rmtree(dir)
-    except OSError as e:
-        if e.errno == errno.ENOENT:
-            pass
+  try:
+    shutil.rmtree(dir)
+  except OSError as e:
+    if e.errno == errno.ENOENT:
+      pass
 
-def makedirs_if_not_exist(dir):
-    try:
-        os.makedirs(dir)
-    except OSError as e:
-        if e.errno != errno.EEXIST:
-            raise
-
-def install_dependencies():
+build = os.environ['BUILD']
+if build == 'Doc':
+  travis = 'TRAVIS' in os.environ
+  # Install dependencies.
+  if travis:
     branch = os.environ['TRAVIS_BRANCH']
     if branch != 'master':
-        print('Branch: ' + branch)
-        exit(0) # Ignore non-master branches
-    check_call('curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key ' +
-               '| sudo apt-key add -', shell=True)
-    check_call('echo "deb https://deb.nodesource.com/node_0.10 precise main" ' +
-               '| sudo tee /etc/apt/sources.list.d/nodesource.list', shell=True)
+      print('Branch: ' + branch)
+      exit(0) # Ignore non-master branches
+    check_call('curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | ' +
+               'sudo apt-key add -', shell=True)
+    check_call('echo "deb https://deb.nodesource.com/node_0.10 precise main" | ' +
+               'sudo tee /etc/apt/sources.list.d/nodesource.list', shell=True)
     check_call(['sudo', 'apt-get', 'update'])
     check_call(['sudo', 'apt-get', 'install', 'python-virtualenv', 'nodejs'])
-    check_call(['sudo', 'npm', 'install', '-g', 'less@2.6.1', 'less-plugin-clean-css'])
+    check_call(['npm', 'install', '-g', 'less', 'less-plugin-clean-css'])
     deb_file = 'doxygen_1.8.6-2_amd64.deb'
     urllib.urlretrieve('http://mirrors.kernel.org/ubuntu/pool/main/d/doxygen/' +
                        deb_file, deb_file)
     check_call(['sudo', 'dpkg', '-i', deb_file])
-
-fmt_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-
-build = os.environ['BUILD']
-if build == 'Doc':
-    travis = 'TRAVIS' in os.environ
-    if travis:
-        install_dependencies()
-    sys.path.insert(0, os.path.join(fmt_dir, 'doc'))
-    import build
-    build.create_build_env()
-    html_dir = build.build_docs()
-    repo = 'fmtlib.github.io'
-    if travis and 'KEY' not in os.environ:
-        # Don't update the repo if building on Travis from an account that
-        # doesn't have push access.
-        print('Skipping update of ' + repo)
-        exit(0)
-    # Clone the fmtlib.github.io repo.
-    rmtree_if_exists(repo)
-    git_url = 'https://github.com/' if travis else 'git@github.com:'
-    check_call(['git', 'clone', git_url + 'fmtlib/{}.git'.format(repo)])
-    # Copy docs to the repo.
-    target_dir = os.path.join(repo, 'dev')
-    rmtree_if_exists(target_dir)
-    shutil.copytree(html_dir, target_dir, ignore=shutil.ignore_patterns('.*'))
-    if travis:
-        check_call(['git', 'config', '--global', 'user.name', 'amplbot'])
-        check_call(['git', 'config', '--global', 'user.email', 'viz@ampl.com'])
-    # Push docs to GitHub pages.
-    check_call(['git', 'add', '--all'], cwd=repo)
-    if call(['git', 'diff-index', '--quiet', 'HEAD'], cwd=repo):
-        check_call(['git', 'commit', '-m', 'Update documentation'], cwd=repo)
-        cmd = 'git push'
-        if travis:
-            cmd += ' https://$KEY@github.com/fmtlib/fmtlib.github.io.git master'
-        p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd=repo)
-        # Print the output without the key.
-        print(p.communicate()[0].replace(os.environ['KEY'], '$KEY'))
-        if p.returncode != 0:
-            raise subprocess.CalledProcessError(p.returncode, cmd)
+  cppformat_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+  sys.path.insert(0, os.path.join(cppformat_dir, 'doc'))
+  import build
+  html_dir = build.build_docs()
+  repo = 'cppformat.github.io'
+  if travis and 'KEY' not in os.environ:
+    # Don't update the repo if building on Travis from an account that doesn't
+    # have push access.
+    print('Skipping update of ' + repo)
     exit(0)
+  # Clone the cppformat.github.io repo.
+  rmtree_if_exists(repo)
+  git_url = 'https://github.com/' if travis else 'git@github.com:'
+  check_call(['git', 'clone', git_url + 'cppformat/{}.git'.format(repo)])
+  # Copy docs to the repo.
+  target_dir = os.path.join(repo, 'dev')
+  rmtree_if_exists(target_dir)
+  shutil.copytree(html_dir, target_dir, ignore=shutil.ignore_patterns('.*'))
+  if travis:
+    check_call(['git', 'config', '--global', 'user.name', 'amplbot'])
+    check_call(['git', 'config', '--global', 'user.email', 'viz@ampl.com'])
+  # Push docs to GitHub pages.
+  check_call(['git', 'add', '--all'], cwd=repo)
+  if call(['git', 'diff-index', '--quiet', 'HEAD'], cwd=repo):
+    check_call(['git', 'commit', '-m', 'Update documentation'], cwd=repo)
+    cmd = 'git push'
+    if travis:
+      cmd += ' https://$KEY@github.com/cppformat/cppformat.github.io.git master'
+    p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd=repo)
+    # Print the output without the key.
+    print(p.communicate()[0].replace(os.environ['KEY'], '$KEY'))
+    if p.returncode != 0:
+      raise CalledProcessError(p.returncode, cmd)
+  exit(0)
 
-standard = os.environ['STANDARD']
-install_dir    = os.path.join(fmt_dir, "_install")
-build_dir      = os.path.join(fmt_dir, "_build")
-test_build_dir = os.path.join(fmt_dir, "_build_test")
-
-# Configure library.
-makedirs_if_not_exist(build_dir)
-cmake_flags = [
-    '-DCMAKE_INSTALL_PREFIX=' + install_dir, '-DCMAKE_BUILD_TYPE=' + build,
-    '-DCMAKE_CXX_STANDARD=' + standard
-]
-check_call(['cmake', '-DFMT_DOC=OFF', '-DFMT_PEDANTIC=ON', '-DFMT_WERROR=ON', fmt_dir] +
-           cmake_flags, cwd=build_dir)
-
-# Build library.
-check_call(['make', '-j4'], cwd=build_dir)
-
-# Test library.
+check_call(['git', 'submodule', 'update', '--init'])
+check_call(['cmake', '-DCMAKE_BUILD_TYPE=' + build, '-DFMT_PEDANTIC=ON', '.'])
+check_call(['make', '-j4'])
 env = os.environ.copy()
 env['CTEST_OUTPUT_ON_FAILURE'] = '1'
-if call(['make', 'test'], env=env, cwd=build_dir):
-    with open(os.path.join(build_dir, 'Testing', 'Temporary', 'LastTest.log'), 'r') as f:
-        print(f.read())
-    sys.exit(-1)
-
-# Install library.
-check_call(['make', 'install'], cwd=build_dir)
-
-# Test installation.
-makedirs_if_not_exist(test_build_dir)
-check_call(['cmake', os.path.join(fmt_dir, "test", "find-package-test")] +
-            cmake_flags, cwd=test_build_dir)
-check_call(['make', '-j4'], cwd=test_build_dir)
+if call(['make', 'test'], env=env):
+  with open('Testing/Temporary/LastTest.log', 'r') as f:
+    print(f.read())

support/update-converity-branch.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+# Update the coverity branch from the master branch.
+# It is not done automatically because Coverity Scan limits
+# the number of submissions per day.
+
+from __future__ import print_function
+import shutil, tempfile
+from subprocess import check_output, STDOUT
+
+class Git:
+  def __init__(self, dir):
+    self.dir = dir
+
+  def __call__(self, *args):
+    output = check_output(['git'] + list(args), cwd=self.dir, stderr=STDOUT)
+    print(output)
+    return output
+
+dir = tempfile.mkdtemp()
+try:
+  git = Git(dir)
+  git('clone', '-b', 'coverity', 'git@github.com:cppformat/cppformat.git', dir)
+  output = git('merge', '-X', 'theirs', '--no-commit', 'origin/master')
+  if 'Fast-forward' not in output:
+    git('reset', 'HEAD', '.travis.yml')
+    git('checkout', '--', '.travis.yml')
+    git('commit', '-m', 'Update coverity branch')
+  git('push')
+finally:
+  shutil.rmtree(dir)

support/update-coverity-branch.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-# Update the coverity branch from the master branch.
-# It is not done automatically because Coverity Scan limits
-# the number of submissions per day.
-
-from __future__ import print_function
-import shutil, tempfile
-from subprocess import check_output, STDOUT
-
-class Git:
-    def __init__(self, dir):
-        self.dir = dir
-
-    def __call__(self, *args):
-        output = check_output(['git'] + list(args), cwd=self.dir, stderr=STDOUT)
-        print(output)
-        return output
-
-dir = tempfile.mkdtemp()
-try:
-    git = Git(dir)
-    git('clone', '-b', 'coverity', 'git@github.com:fmtlib/fmt.git', dir)
-    output = git('merge', '-X', 'theirs', '--no-commit', 'origin/master')
-    if 'Fast-forward' not in output:
-        git('reset', 'HEAD', '.travis.yml')
-        git('checkout', '--', '.travis.yml')
-        git('commit', '-m', 'Update coverity branch')
-    git('push')
-finally:
-    shutil.rmtree(dir)

test/CMakeLists.txt

@@ -7,8 +7,8 @@
 # at http://code.google.com/p/googletest/wiki/FAQ for more details.
 add_library(gmock STATIC
   gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
-target_compile_definitions(gmock PUBLIC GTEST_HAS_STD_WSTRING=1)
-target_include_directories(gmock SYSTEM PUBLIC . gmock gtest)
+target_compile_options(gmock PUBLIC ${CPP11_FLAG})
+target_include_directories(gmock PUBLIC .)
 
 find_package(Threads)
 if (Threads_FOUND)
@@ -31,10 +31,6 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   target_compile_definitions(gmock PUBLIC GTEST_USE_OWN_TR1_TUPLE=1)
 endif ()
 
-# Silence MSVC tr1 deprecation warning in gmock.
-target_compile_definitions(gmock
-  PUBLIC _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING=0)
-
 #------------------------------------------------------------------------------
 # Build the actual library tests
 
@@ -42,10 +38,7 @@ set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
 add_library(test-main STATIC ${TEST_MAIN_SRC})
 target_compile_definitions(test-main PUBLIC
   FMT_USE_FILE_DESCRIPTORS=$<BOOL:${HAVE_OPEN}>)
-target_include_directories(test-main SYSTEM PUBLIC gtest gmock)
-target_link_libraries(test-main gmock fmt)
-
-include(CheckCXXCompilerFlag)
+target_link_libraries(test-main gmock cppformat)
 
 # Workaround GTest bug https://github.com/google/googletest/issues/705.
 check_cxx_compiler_flag(
@@ -54,107 +47,73 @@ if (HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
   target_compile_options(test-main PUBLIC -fno-delete-null-pointer-checks)
 endif ()
 
-# Use less strict pedantic flags for the tests because GMock doesn't compile
-# cleanly with -pedantic and -std=c++98.
+# relax pedantic flags for the tests
+# TODO: fix warnings in tests to make this redundant. (e.g. -Wshadow,...)
 if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-    #set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -Wno-long-long -Wno-variadic-macros)
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wno-long-long -Wno-variadic-macros)
 endif ()
 
-function(add_fmt_executable name)
-  add_executable(${name} ${ARGN})
-  if (MINGW)
-    target_link_libraries(${name} -static-libgcc -static-libstdc++)
-  endif ()
-endfunction()
-
 # Adds a test.
 # Usage: add_fmt_test(name srcs...)
 function(add_fmt_test name)
-  add_fmt_executable(${name} ${name}.cc ${ARGN})
+  add_executable(${name} ${name}.cc ${ARGN})
   target_link_libraries(${name} test-main)
-
-  # Define if certain C++ features can be used.
+  # define if certain c++ features can be used
   target_compile_definitions(${name} PRIVATE
     FMT_USE_TYPE_TRAITS=$<BOOL:${SUPPORTS_TYPE_TRAITS}>
     FMT_USE_ENUM_BASE=$<BOOL:${SUPPORTS_ENUM_BASE}>)
   if (FMT_PEDANTIC)
     target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
   endif ()
-  target_include_directories(${name} SYSTEM PUBLIC gtest gmock)
   add_test(NAME ${name} COMMAND ${name})
 endfunction()
 
 add_fmt_test(assert-test)
-add_fmt_test(chrono-test)
-add_fmt_test(core-test)
 add_fmt_test(gtest-extra-test)
-add_fmt_test(format-test mock-allocator.h)
-if (NOT (MSVC AND BUILD_SHARED_LIBS))
-  add_fmt_test(format-impl-test)
-endif ()
-add_fmt_test(locale-test)
-add_fmt_test(ostream-test)
+add_fmt_test(format-test)
+add_fmt_test(format-impl-test)
 add_fmt_test(printf-test)
-add_fmt_test(time-test)
-add_fmt_test(custom-formatter-test)
-add_fmt_test(ranges-test)
+add_fmt_test(util-test mock-allocator.h)
+add_fmt_test(macro-test)
+
+# Enable stricter options for one test to make sure that the header is free of
+# warnings.
+# TODO: make all tests warning free and add this flag to PEDANTIC_COMPILE_FLAGS
+if (FMT_PEDANTIC AND MSVC)
+  target_compile_options(format-test PRIVATE /W4)
+endif ()
 
 if (HAVE_OPEN)
-  add_fmt_executable(posix-mock-test
-    posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
-  target_include_directories(
-    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  add_executable(posix-mock-test posix-mock-test.cc ../cppformat/format.cc ${TEST_MAIN_SRC})
+  target_include_directories(posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR})
   target_compile_definitions(posix-mock-test PRIVATE FMT_USE_FILE_DESCRIPTORS=1)
   target_link_libraries(posix-mock-test gmock)
-  target_include_directories(posix-mock-test SYSTEM PUBLIC gtest gmock)
-  if (FMT_PEDANTIC)
-    target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-  endif ()
   add_test(NAME posix-mock-test COMMAND posix-mock-test)
   add_fmt_test(posix-test)
 endif ()
 
-add_fmt_executable(header-only-test
+add_executable(header-only-test
   header-only-test.cc header-only-test2.cc test-main.cc)
 target_link_libraries(header-only-test gmock)
-target_include_directories(header-only-test SYSTEM PUBLIC gtest gmock)
-if (TARGET fmt-header-only)
-  target_link_libraries(header-only-test fmt-header-only)
+if (TARGET cppformat-header-only)
+  target_link_libraries(header-only-test cppformat-header-only)
 else ()
-  target_include_directories(
-    header-only-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  target_include_directories(header-only-test PRIVATE ${PROJECT_SOURCE_DIR})
   target_compile_definitions(header-only-test PRIVATE FMT_HEADER_ONLY=1)
 endif ()
 
 # Test that the library can be compiled with exceptions disabled.
-# -fno-exception is broken in icc: https://github.com/fmtlib/fmt/issues/822.
-if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-  check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
-endif ()
+check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
 if (HAVE_FNO_EXCEPTIONS_FLAG)
-  add_library(noexception-test ../src/format.cc)
-  target_include_directories(
-    noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  add_library(noexception-test ../cppformat/format.cc)
   target_compile_options(noexception-test PRIVATE -fno-exceptions)
-  if (FMT_PEDANTIC)
-    target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-  endif ()
-  target_include_directories(noexception-test SYSTEM PUBLIC gtest gmock)
 endif ()
 
-message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}")
-
 if (FMT_PEDANTIC)
   # Test that the library compiles without windows.h.
   if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    add_library(no-windows-h-test ../src/format.cc)
-    target_include_directories(
-      no-windows-h-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+    add_library(no-windows-h-test ../cppformat/format.cc)
     target_compile_definitions(no-windows-h-test PRIVATE FMT_USE_WINDOWS_H=0)
-    if (FMT_PEDANTIC)
-      target_compile_options(no-windows-h-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-    endif ()
-    target_include_directories(no-windows-h-test SYSTEM PUBLIC gtest gmock)
   endif ()
 
   add_test(compile-test ${CMAKE_CTEST_COMMAND}
@@ -162,18 +121,9 @@ if (FMT_PEDANTIC)
     "${CMAKE_CURRENT_SOURCE_DIR}/compile-test"
     "${CMAKE_CURRENT_BINARY_DIR}/compile-test"
     --build-generator ${CMAKE_GENERATOR}
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
-    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
-    "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}"
-    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
-    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")
-endif ()
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM})
 
-# These tests are disabled on Windows because they take too long.
-if (FMT_PEDANTIC AND NOT WIN32)
-  # Test if the targets are found from the build directory.
+  # test if the targets are findable from the build directory
   add_test(find-package-test ${CMAKE_CTEST_COMMAND}
     -C ${CMAKE_BUILD_TYPE}
     --build-and-test
@@ -181,14 +131,10 @@ if (FMT_PEDANTIC AND NOT WIN32)
     "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
     --build-generator ${CMAKE_GENERATOR}
     --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
-    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
-    "-DFMT_DIR=${PROJECT_BINARY_DIR}"
-    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
-    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+    --build-options "-Dcppformat_DIR=${PROJECT_BINARY_DIR}"
+                    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 
-  # Test if the targets are found when add_subdirectory is used.
+  # test if the targets are findable when add_subdirectory is used
   add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
     -C ${CMAKE_BUILD_TYPE}
     --build-and-test
@@ -196,9 +142,5 @@ if (FMT_PEDANTIC AND NOT WIN32)
     "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
     --build-generator ${CMAKE_GENERATOR}
     --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
-    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
-    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
-    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+    --build-options "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 endif ()

test/add-subdirectory-test/CMakeLists.txt

@@ -1,17 +1,13 @@
-cmake_minimum_required(VERSION 3.1.0)
+cmake_minimum_required(VERSION 2.8.12)
 
-project(fmt-test)
+project(cppformat-test)
 
-add_subdirectory(../.. fmt)
+add_subdirectory(../.. cppformat)
 
-add_executable(library-test "main.cc")
-target_link_libraries(library-test fmt::fmt)
-target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-target_include_directories(library-test PUBLIC SYSTEM .)
+add_executable(library-test "main.cpp")
+target_link_libraries(library-test cppformat)
 
-if (TARGET fmt::fmt-header-only)
-  add_executable(header-only-test "main.cc")
-  target_link_libraries(header-only-test fmt::fmt-header-only)
-  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-  target_include_directories(header-only-test PUBLIC SYSTEM .)
-endif ()
+if (TARGET cppformat-header-only)
+  add_executable(header-only-test "main.cpp")
+  target_link_libraries(header-only-test cppformat-header-only)
+endif ()

test/add-subdirectory-test/main.cc

@@ -1,6 +0,0 @@
-#include "fmt/format.h"
-
-int main(int argc, char** argv) {
-  for(int i = 0; i < argc; ++i)
-    fmt::print("{}: {}\n", i, argv[i]);
-}

test/add-subdirectory-test/main.cpp

@@ -0,0 +1,8 @@
+#include "cppformat/format.h"
+
+int main(int argc, char** argv)
+{
+  for(int i = 0; i < argc; ++i)
+    fmt::print("{}: {}\n", i, argv[i]);
+  return 0;
+}

test/assert-test.cc

@@ -1,12 +1,32 @@
-// Formatting library for C++ - assertion tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Assertion tests
 
-#include "fmt/core.h"
-#include "gtest.h"
+ Copyright (c) 2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppformat/format.h"
+#include "gtest/gtest.h"
 
 #if GTEST_HAS_DEATH_TEST
 # define EXPECT_DEBUG_DEATH_IF_SUPPORTED(statement, regex) \
@@ -17,6 +37,5 @@
 #endif
 
 TEST(AssertTest, Fail) {
-  EXPECT_DEBUG_DEATH_IF_SUPPORTED(
-      FMT_ASSERT(false, "don't panic!"), "don't panic!");
+  EXPECT_DEBUG_DEATH_IF_SUPPORTED(FMT_ASSERT(false, "don't panic!"), "don't panic!");
 }

test/chrono-test.cc

@@ -1,185 +0,0 @@
-// Formatting library for C++ - time formatting tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/chrono.h"
-#include "gtest-extra.h"
-
-#include <iomanip>
-
-std::tm make_tm() {
-  auto time = std::tm();
-  time.tm_mday = 1;
-  return time;
-}
-
-std::tm make_hour(int h) {
-  auto time = make_tm();
-  time.tm_hour = h;
-  return time;
-}
-
-std::tm make_minute(int m) {
-  auto time = make_tm();
-  time.tm_min = m;
-  return time;
-}
-
-std::tm make_second(int s) {
-  auto time = make_tm();
-  time.tm_sec = s;
-  return time;
-}
-
-std::string format_tm(const std::tm &time, const char *spec,
-                      const std::locale &loc) {
-  auto &facet = std::use_facet<std::time_put<char>>(loc);
-  std::ostringstream os;
-  os.imbue(loc);
-  facet.put(os, os, ' ', &time, spec, spec + std::strlen(spec));
-  return os.str();
-}
-
-#define EXPECT_TIME(spec, time, duration) { \
-    std::locale loc("ja_JP.utf8"); \
-    EXPECT_EQ(format_tm(time, spec, loc), \
-              fmt::format(loc, "{:" spec "}", duration)); \
-  }
-
-TEST(ChronoTest, FormatDefault) {
-  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
-  EXPECT_EQ("42as",
-            fmt::format("{}", std::chrono::duration<int, std::atto>(42)));
-  EXPECT_EQ("42fs",
-            fmt::format("{}", std::chrono::duration<int, std::femto>(42)));
-  EXPECT_EQ("42ps",
-            fmt::format("{}", std::chrono::duration<int, std::pico>(42)));
-  EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42)));
-  EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42)));
-  EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42)));
-  EXPECT_EQ("42cs",
-            fmt::format("{}", std::chrono::duration<int, std::centi>(42)));
-  EXPECT_EQ("42ds",
-            fmt::format("{}", std::chrono::duration<int, std::deci>(42)));
-  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
-  EXPECT_EQ("42das",
-            fmt::format("{}", std::chrono::duration<int, std::deca>(42)));
-  EXPECT_EQ("42hs",
-            fmt::format("{}", std::chrono::duration<int, std::hecto>(42)));
-  EXPECT_EQ("42ks",
-            fmt::format("{}", std::chrono::duration<int, std::kilo>(42)));
-  EXPECT_EQ("42Ms",
-            fmt::format("{}", std::chrono::duration<int, std::mega>(42)));
-  EXPECT_EQ("42Gs",
-            fmt::format("{}", std::chrono::duration<int, std::giga>(42)));
-  EXPECT_EQ("42Ts",
-            fmt::format("{}", std::chrono::duration<int, std::tera>(42)));
-  EXPECT_EQ("42Ps",
-            fmt::format("{}", std::chrono::duration<int, std::peta>(42)));
-  EXPECT_EQ("42Es",
-            fmt::format("{}", std::chrono::duration<int, std::exa>(42)));
-  EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42)));
-  EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42)));
-  EXPECT_EQ("42[15]s",
-            fmt::format("{}",
-                        std::chrono::duration<int, std::ratio<15, 1>>(42)));
-  EXPECT_EQ("42[15/4]s",
-            fmt::format("{}",
-                        std::chrono::duration<int, std::ratio<15, 4>>(42)));
-}
-
-TEST(ChronoTest, Align) {
-  auto s = std::chrono::seconds(42);
-  EXPECT_EQ("42s  ", fmt::format("{:5}", s));
-  EXPECT_EQ("42s  ", fmt::format("{:{}}", s, 5));
-  EXPECT_EQ("  42s", fmt::format("{:>5}", s));
-  EXPECT_EQ("**42s**", fmt::format("{:*^7}", s));
-  EXPECT_EQ("03:25:45    ",
-            fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)));
-  EXPECT_EQ("    03:25:45",
-            fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)));
-  EXPECT_EQ("~~03:25:45~~",
-            fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)));
-
-}
-
-TEST(ChronoTest, FormatSpecs) {
-  EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0)));
-  EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0)));
-  EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0)));
-  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0)));
-  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60)));
-  EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42)));
-  EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234)));
-  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0)));
-  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60)));
-  EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42)));
-  EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61)));
-  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0)));
-  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24)));
-  EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14)));
-  EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61)));
-  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0)));
-  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12)));
-  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24)));
-  EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4)));
-  EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14)));
-  EXPECT_EQ("03:25:45",
-            fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)));
-  EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345)));
-  EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345)));
-}
-
-TEST(ChronoTest, InvalidSpecs) {
-  auto sec = std::chrono::seconds(0);
-  EXPECT_THROW_MSG(fmt::format("{:%a}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%A}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%c}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%x}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Ex}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%X}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%EX}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%D}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%F}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Ec}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%w}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%u}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%b}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%B}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%z}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Z}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%q}", sec), fmt::format_error,
-                   "invalid format");
-  EXPECT_THROW_MSG(fmt::format("{:%Eq}", sec), fmt::format_error,
-                   "invalid format");
-  EXPECT_THROW_MSG(fmt::format("{:%Oq}", sec), fmt::format_error,
-                   "invalid format");
-}
-
-TEST(ChronoTest, Locale) {
-  const char *loc_name = "ja_JP.utf8";
-  bool has_locale = false;
-  std::locale loc;
-  try {
-    loc = std::locale(loc_name);
-    has_locale = true;
-  } catch (const std::runtime_error &) {}
-  if (!has_locale) {
-    fmt::print("{} locale is missing.\n", loc_name);
-    return;
-  }
-  EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
-  EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
-  EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
-  EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
-  auto time = make_tm();
-  time.tm_hour = 3;
-  time.tm_min = 25;
-  time.tm_sec = 45;
-  auto sec = std::chrono::seconds(12345);
-  EXPECT_TIME("%r", time, sec);
-  EXPECT_TIME("%p", time, sec);
-}

test/compile-test/CMakeLists.txt

@@ -1,17 +1,14 @@
 # Test if compile errors are produced where necessary.
 
-cmake_minimum_required(VERSION 3.1.0)
+cmake_minimum_required(VERSION 2.8)
 
 include(CheckCXXSourceCompiles)
-include(CheckCXXCompilerFlag)
-
-set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../../include)
-set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG} ${PEDANTIC_COMPILE_FLAGS})
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../..)
 
 function (generate_source result fragment)
   set(${result} "
   #define FMT_HEADER_ONLY 1
-  #include \"fmt/format.h\"
+  #include \"cppformat/format.h\"
   int main() {
     ${fragment}
   }
@@ -22,58 +19,41 @@ function (expect_compile code)
   generate_source(source "${code}")
   check_cxx_source_compiles("${source}" compiles)
   if (NOT compiles)
-    set(error_msg "Compile error for: ${code}")
+    message(FATAL_ERROR "Compile error for: ${code}")
   endif ()
   # Unset the CMake cache variable compiles. Otherwise the compile test will
   # just use cached information next time it runs.
   unset(compiles CACHE)
-  if (error_msg)
-    message(FATAL_ERROR ${error_msg})
-  endif ()
 endfunction ()
 
 function (expect_compile_error code)
   generate_source(source "${code}")
   check_cxx_source_compiles("${source}" compiles)
   if (compiles)
-    set(error_msg "No compile error for: ${code}")
+    message(FATAL_ERROR "No compile error for: ${code}")
   endif ()
   # Unset the CMake cache variable compiles. Otherwise the compile test will
   # just use cached information next time it runs.
   unset(compiles CACHE)
-  if (error_msg)
-    message(FATAL_ERROR ${error_msg})
-  endif ()
 endfunction ()
 
 # check if the source file skeleton compiles
 expect_compile("")
 
+# MakeArg doesn't accept [const] volatile char *.
+expect_compile_error("volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")
+expect_compile_error("const volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")
+
+# MakeArg<char> doesn't accept wchar_t.
+expect_compile_error("fmt::internal::MakeValue<char>(L'a');")
+expect_compile_error("fmt::internal::MakeValue<char>(L\"test\");")
+
+# Writing a wide character to a character stream Writer is forbidden.
+expect_compile_error("fmt::MemoryWriter() << L'a';")
+expect_compile_error("fmt::MemoryWriter() << fmt::pad(\"abc\", 5, L' ');")
+expect_compile_error("fmt::MemoryWriter() << fmt::pad(42, 5, L' ');")
+
 # Formatting a wide character with a narrow format string is forbidden.
-expect_compile_error("fmt::format(\"{}\", L'a');")
+expect_compile_error("fmt::format(\"{}\", L'a';")
 
-# Formatting a wide string with a narrow format string is forbidden.
-expect_compile_error("fmt::format(\"{}\", L\"foo\");")
-
-# Formatting a narrow string with a wide format string is forbidden because
-# mixing UTF-8 with UTF-16/32 can result in an invalid output.
-expect_compile_error("fmt::format(L\"{}\", \"foo\");")
-
-# Formatting a wide string with a narrow format string is forbidden.
-expect_compile_error("
-  struct S {
-    operator std::string() const { return std::string(); }
-  };
-  fmt::format(\"{}\", S());
-")
-
-# Make sure that compiler features detected in the header
-# match the features detected in CMake.
-if (SUPPORTS_USER_DEFINED_LITERALS)
-  set(supports_udl 1)
-else ()
-  set(supports_udl 0)
-endif ()
-expect_compile("#if FMT_USE_USER_DEFINED_LITERALS != ${supports_udl}
-                # error
-                #endif")
+expect_compile_error("FMT_STATIC_ASSERT(0 > 1, \"oops\");")

test/core-test.cc

@@ -1,613 +0,0 @@
-// Formatting library for C++ - core tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include <algorithm>
-#include <climits>
-#include <cstring>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <string>
-#include <type_traits>
-#include <memory>
-
-#include "test-assert.h"
-
-#include "gmock.h"
-
-// Check if fmt/core.h compiles with windows.h included before it.
-#ifdef _WIN32
-# include <windows.h>
-#endif
-
-#include "fmt/core.h"
-
-#undef min
-#undef max
-
-using fmt::basic_format_arg;
-using fmt::internal::basic_buffer;
-using fmt::internal::value;
-using fmt::string_view;
-
-using testing::_;
-using testing::StrictMock;
-
-namespace {
-
-struct test_struct {};
-
-template <typename Context, typename T>
-basic_format_arg<Context> make_arg(const T &value) {
-  return fmt::internal::make_arg<Context>(value);
-}
-}  // namespace
-
-FMT_BEGIN_NAMESPACE
-template <typename Char>
-struct formatter<test_struct, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  typedef std::back_insert_iterator<basic_buffer<Char>> iterator;
-
-  auto format(test_struct, basic_format_context<iterator, char> &ctx)
-      -> decltype(ctx.out()) {
-    const Char *test = "test";
-    return std::copy_n(test, std::strlen(test), ctx.out());
-  }
-};
-FMT_END_NAMESPACE
-
-#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
-TEST(BufferTest, Noncopyable) {
-  EXPECT_FALSE(std::is_copy_constructible<basic_buffer<char> >::value);
-#if !FMT_MSC_VER
-  // std::is_copy_assignable is broken in MSVC2013.
-  EXPECT_FALSE(std::is_copy_assignable<basic_buffer<char> >::value);
-#endif
-}
-
-TEST(BufferTest, Nonmoveable) {
-  EXPECT_FALSE(std::is_move_constructible<basic_buffer<char> >::value);
-#if !FMT_MSC_VER
-  // std::is_move_assignable is broken in MSVC2013.
-  EXPECT_FALSE(std::is_move_assignable<basic_buffer<char> >::value);
-#endif
-}
-#endif
-
-// A test buffer with a dummy grow method.
-template <typename T>
-struct test_buffer : basic_buffer<T> {
-  void grow(std::size_t capacity) { this->set(FMT_NULL, capacity); }
-};
-
-template <typename T>
-struct mock_buffer : basic_buffer<T> {
-  MOCK_METHOD1(do_grow, void (std::size_t capacity));
-
-  void grow(std::size_t capacity) {
-    this->set(this->data(), capacity);
-    do_grow(capacity);
-  }
-
-  mock_buffer() {}
-  mock_buffer(T *data) { this->set(data, 0); }
-  mock_buffer(T *data, std::size_t capacity) { this->set(data, capacity); }
-};
-
-TEST(BufferTest, Ctor) {
-  {
-    mock_buffer<int> buffer;
-    EXPECT_EQ(FMT_NULL, &buffer[0]);
-    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
-  }
-  {
-    int dummy;
-    mock_buffer<int> buffer(&dummy);
-    EXPECT_EQ(&dummy, &buffer[0]);
-    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
-  }
-  {
-    int dummy;
-    std::size_t capacity = std::numeric_limits<std::size_t>::max();
-    mock_buffer<int> buffer(&dummy, capacity);
-    EXPECT_EQ(&dummy, &buffer[0]);
-    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-    EXPECT_EQ(capacity, buffer.capacity());
-  }
-}
-
-struct dying_buffer : test_buffer<int> {
-  MOCK_METHOD0(die, void());
-  ~dying_buffer() { die(); }
-};
-
-TEST(BufferTest, VirtualDtor) {
-  typedef StrictMock<dying_buffer> stict_mock_buffer;
-  stict_mock_buffer *mock_buffer = new stict_mock_buffer();
-  EXPECT_CALL(*mock_buffer, die());
-  basic_buffer<int> *buffer = mock_buffer;
-  delete buffer;
-}
-
-TEST(BufferTest, Access) {
-  char data[10];
-  mock_buffer<char> buffer(data, sizeof(data));
-  buffer[0] = 11;
-  EXPECT_EQ(11, buffer[0]);
-  buffer[3] = 42;
-  EXPECT_EQ(42, *(&buffer[0] + 3));
-  const basic_buffer<char> &const_buffer = buffer;
-  EXPECT_EQ(42, const_buffer[3]);
-}
-
-TEST(BufferTest, Resize) {
-  char data[123];
-  mock_buffer<char> buffer(data, sizeof(data));
-  buffer[10] = 42;
-  EXPECT_EQ(42, buffer[10]);
-  buffer.resize(20);
-  EXPECT_EQ(20u, buffer.size());
-  EXPECT_EQ(123u, buffer.capacity());
-  EXPECT_EQ(42, buffer[10]);
-  buffer.resize(5);
-  EXPECT_EQ(5u, buffer.size());
-  EXPECT_EQ(123u, buffer.capacity());
-  EXPECT_EQ(42, buffer[10]);
-  // Check if resize calls grow.
-  EXPECT_CALL(buffer, do_grow(124));
-  buffer.resize(124);
-  EXPECT_CALL(buffer, do_grow(200));
-  buffer.resize(200);
-}
-
-TEST(BufferTest, Clear) {
-  test_buffer<char> buffer;
-  buffer.resize(20);
-  buffer.resize(0);
-  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-  EXPECT_EQ(20u, buffer.capacity());
-}
-
-TEST(BufferTest, Append) {
-  char data[15];
-  mock_buffer<char> buffer(data, 10);
-  const char *test = "test";
-  buffer.append(test, test + 5);
-  EXPECT_STREQ(test, &buffer[0]);
-  EXPECT_EQ(5u, buffer.size());
-  buffer.resize(10);
-  EXPECT_CALL(buffer, do_grow(12));
-  buffer.append(test, test + 2);
-  EXPECT_EQ('t', buffer[10]);
-  EXPECT_EQ('e', buffer[11]);
-  EXPECT_EQ(12u, buffer.size());
-}
-
-TEST(BufferTest, AppendAllocatesEnoughStorage) {
-  char data[19];
-  mock_buffer<char> buffer(data, 10);
-  const char *test = "abcdefgh";
-  buffer.resize(10);
-  EXPECT_CALL(buffer, do_grow(19));
-  buffer.append(test, test + 9);
-}
-
-TEST(ArgTest, FormatArgs) {
-  fmt::format_args args;
-  EXPECT_FALSE(args.get(1));
-}
-
-struct custom_context {
-  typedef char char_type;
-
-  template <typename T>
-  struct formatter_type {
-    struct type {
-      template <typename ParseContext>
-      auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-        return ctx.begin();
-      }
-
-      const char *format(const T &, custom_context& ctx) {
-        ctx.called = true;
-        return FMT_NULL;
-      }
-    };
-  };
-
-  bool called;
-
-  fmt::format_parse_context parse_context() {
-    return fmt::format_parse_context("");
-  }
-  void advance_to(const char *) {}
-};
-
-TEST(ArgTest, MakeValueWithCustomContext) {
-  test_struct t;
-  fmt::internal::value<custom_context> arg =
-      fmt::internal::make_value<custom_context>(t);
-  custom_context ctx = {false};
-  arg.custom.format(&t, ctx);
-  EXPECT_TRUE(ctx.called);
-}
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-template <typename Char>
-bool operator==(custom_value<Char> lhs, custom_value<Char> rhs) {
-  return lhs.value == rhs.value;
-}
-}
-FMT_END_NAMESPACE
-
-// Use a unique result type to make sure that there are no undesirable
-// conversions.
-struct test_result {};
-
-template <typename T>
-struct mock_visitor {
-  template <typename U>
-  struct result { typedef test_result type; };
-
-  mock_visitor() {
-    ON_CALL(*this, visit(_)).WillByDefault(testing::Return(test_result()));
-  }
-
-  MOCK_METHOD1_T(visit, test_result (T value));
-  MOCK_METHOD0_T(unexpected, void ());
-
-  test_result operator()(T value) { return visit(value); }
-
-  template <typename U>
-  test_result operator()(U) {
-    unexpected();
-    return test_result();
-  }
-};
-
-template <typename T>
-struct visit_type { typedef T Type; };
-
-#define VISIT_TYPE(Type_, visit_type_) \
-  template <> \
-  struct visit_type<Type_> { typedef visit_type_ Type; }
-
-VISIT_TYPE(signed char, int);
-VISIT_TYPE(unsigned char, unsigned);
-VISIT_TYPE(short, int);
-VISIT_TYPE(unsigned short, unsigned);
-
-#if LONG_MAX == INT_MAX
-VISIT_TYPE(long, int);
-VISIT_TYPE(unsigned long, unsigned);
-#else
-VISIT_TYPE(long, long long);
-VISIT_TYPE(unsigned long, unsigned long long);
-#endif
-
-VISIT_TYPE(float, double);
-
-#define CHECK_ARG_(Char, expected, value) { \
-  testing::StrictMock<mock_visitor<decltype(expected)>> visitor; \
-  EXPECT_CALL(visitor, visit(expected)); \
-  typedef std::back_insert_iterator<basic_buffer<Char>> iterator; \
-  fmt::visit(visitor, \
-      make_arg<fmt::basic_format_context<iterator, Char>>(value)); \
-}
-
-#define CHECK_ARG(value, typename_) { \
-  typedef decltype(value) value_type; \
-  typename_ visit_type<value_type>::Type expected = value; \
-  CHECK_ARG_(char, expected, value) \
-  CHECK_ARG_(wchar_t, expected, value) \
-}
-
-template <typename T>
-class NumericArgTest : public testing::Test {};
-
-typedef ::testing::Types<
-  bool, signed char, unsigned char, signed, unsigned short,
-  int, unsigned, long, unsigned long, long long, unsigned long long,
-  float, double, long double> Types;
-TYPED_TEST_CASE(NumericArgTest, Types);
-
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value, T>::type test_value() {
-  return static_cast<T>(42);
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value, T>::type
-    test_value() {
-  return static_cast<T>(4.2);
-}
-
-TYPED_TEST(NumericArgTest, MakeAndVisit) {
-  CHECK_ARG(test_value<TypeParam>(), typename);
-  CHECK_ARG(std::numeric_limits<TypeParam>::min(), typename);
-  CHECK_ARG(std::numeric_limits<TypeParam>::max(), typename);
-}
-
-TEST(ArgTest, CharArg) {
-  CHECK_ARG_(char, 'a', 'a');
-  CHECK_ARG_(wchar_t, L'a', 'a');
-  CHECK_ARG_(wchar_t, L'a', L'a');
-}
-
-TEST(ArgTest, StringArg) {
-  char str_data[] = "test";
-  char *str = str_data;
-  const char *cstr = str;
-  CHECK_ARG_(char, cstr, str);
-
-  string_view sref(str);
-  CHECK_ARG_(char, sref, std::string(str));
-}
-
-TEST(ArgTest, WStringArg) {
-  wchar_t str_data[] = L"test";
-  wchar_t *str = str_data;
-  const wchar_t *cstr = str;
-
-  fmt::wstring_view sref(str);
-  CHECK_ARG_(wchar_t, cstr, str);
-  CHECK_ARG_(wchar_t, cstr, cstr);
-  CHECK_ARG_(wchar_t, sref, std::wstring(str));
-  CHECK_ARG_(wchar_t, sref, fmt::wstring_view(str));
-}
-
-TEST(ArgTest, PointerArg) {
-  void *p = FMT_NULL;
-  const void *cp = FMT_NULL;
-  CHECK_ARG_(char, cp, p);
-  CHECK_ARG_(wchar_t, cp, p);
-  CHECK_ARG(cp, );
-}
-
-struct check_custom {
-  test_result operator()(
-      fmt::basic_format_arg<fmt::format_context>::handle h) const {
-    struct test_buffer : fmt::internal::basic_buffer<char> {
-      char data[10];
-      test_buffer() : fmt::internal::basic_buffer<char>(data, 0, 10) {}
-      void grow(std::size_t) {}
-    } buffer;
-    fmt::internal::basic_buffer<char> &base = buffer;
-    fmt::format_context ctx(std::back_inserter(base), "", fmt::format_args());
-    h.format(ctx);
-    EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
-    return test_result();
-  }
-};
-
-TEST(ArgTest, CustomArg) {
-  test_struct test;
-  typedef mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>
-    visitor;
-  testing::StrictMock<visitor> v;
-  EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
-  fmt::visit(v, make_arg<fmt::format_context>(test));
-}
-
-TEST(ArgTest, VisitInvalidArg) {
-  testing::StrictMock< mock_visitor<fmt::monostate> > visitor;
-  EXPECT_CALL(visitor, visit(_));
-  fmt::basic_format_arg<fmt::format_context> arg;
-  visit(visitor, arg);
-}
-
-TEST(StringViewTest, Length) {
-  // Test that StringRef::size() returns string length, not buffer size.
-  char str[100] = "some string";
-  EXPECT_EQ(std::strlen(str), string_view(str).size());
-  EXPECT_LT(std::strlen(str), sizeof(str));
-}
-
-// Check string_view's comparison operator.
-template <template <typename> class Op>
-void check_op() {
-  const char *inputs[] = {"foo", "fop", "fo"};
-  std::size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
-  for (std::size_t i = 0; i < num_inputs; ++i) {
-    for (std::size_t j = 0; j < num_inputs; ++j) {
-      string_view lhs(inputs[i]), rhs(inputs[j]);
-      EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
-    }
-  }
-}
-
-TEST(StringViewTest, Compare) {
-  EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
-  EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
-  EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
-  EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
-  EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
-  check_op<std::equal_to>();
-  check_op<std::not_equal_to>();
-  check_op<std::less>();
-  check_op<std::less_equal>();
-  check_op<std::greater>();
-  check_op<std::greater_equal>();
-}
-
-enum basic_enum {};
-
-TEST(CoreTest, ConvertToInt) {
-  EXPECT_FALSE((fmt::convert_to_int<char, char>::value));
-  EXPECT_FALSE((fmt::convert_to_int<const char *, char>::value));
-  EXPECT_TRUE((fmt::convert_to_int<basic_enum, char>::value));
-}
-
-enum enum_with_underlying_type : char {};
-
-TEST(CoreTest, IsEnumConvertibleToInt) {
-  EXPECT_TRUE((fmt::convert_to_int<enum_with_underlying_type, char>::value));
-}
-
-namespace my_ns {
-template <typename Char>
-class my_string {
- public:
-  my_string(const Char *s) : s_(s) {}
-  const Char * data() const FMT_NOEXCEPT { return s_.data(); }
-  std::size_t length() const FMT_NOEXCEPT { return s_.size(); }
-  operator const Char*() const { return s_.c_str(); }
- private:
-  std::basic_string<Char> s_;
-};
-
-template <typename Char>
-inline fmt::basic_string_view<Char>
-    to_string_view(const my_string<Char> &s) FMT_NOEXCEPT {
-  return { s.data(), s.length() };
-}
-
-struct non_string {};
-}
-
-namespace FakeQt {
-class QString {
- public:
-  QString(const wchar_t *s) : s_(std::make_shared<std::wstring>(s)) {}
-  const wchar_t *utf16() const FMT_NOEXCEPT { return s_->data(); }
-  int size() const FMT_NOEXCEPT { return static_cast<int>(s_->size()); }
-#ifdef FMT_STRING_VIEW
-  operator FMT_STRING_VIEW<wchar_t>() const FMT_NOEXCEPT { return *s_; }
-#endif
- private:
-  std::shared_ptr<std::wstring> s_;
-};
-
-inline fmt::basic_string_view<wchar_t> to_string_view(
-    const QString &s) FMT_NOEXCEPT {
-  return {s.utf16(),
-          static_cast<std::size_t>(s.size())};
-}
-}
-
-template <typename T>
-class IsStringTest : public testing::Test {};
-
-typedef ::testing::Types<char, wchar_t, char16_t, char32_t> StringCharTypes;
-TYPED_TEST_CASE(IsStringTest, StringCharTypes);
-
-namespace {
-template <typename Char>
-struct derived_from_string_view : fmt::basic_string_view<Char> {};
-}
-
-TYPED_TEST(IsStringTest, IsString) {
-  EXPECT_TRUE((fmt::internal::is_string<TypeParam *>::value));
-  EXPECT_TRUE((fmt::internal::is_string<const TypeParam *>::value));
-  EXPECT_TRUE((fmt::internal::is_string<TypeParam[2]>::value));
-  EXPECT_TRUE((fmt::internal::is_string<const TypeParam[2]>::value));
-  EXPECT_TRUE((fmt::internal::is_string<std::basic_string<TypeParam>>::value));
-  EXPECT_TRUE(
-        (fmt::internal::is_string<fmt::basic_string_view<TypeParam>>::value));
-  EXPECT_TRUE(
-        (fmt::internal::is_string<derived_from_string_view<TypeParam>>::value));
-#ifdef FMT_STRING_VIEW
-  EXPECT_TRUE((fmt::internal::is_string<FMT_STRING_VIEW<TypeParam>>::value));
-#endif
-  EXPECT_TRUE((fmt::internal::is_string<my_ns::my_string<TypeParam>>::value));
-  EXPECT_FALSE((fmt::internal::is_string<my_ns::non_string>::value));
-  EXPECT_TRUE((fmt::internal::is_string<FakeQt::QString>::value));
-}
-
-TEST(CoreTest, Format) {
-  // This should work without including fmt/format.h.
-#ifdef FMT_FORMAT_H_
-# error fmt/format.h must not be included in the core test
-#endif
-  EXPECT_EQ(fmt::format("{}", 42), "42");
-}
-
-TEST(CoreTest, FormatTo) {
-  // This should work without including fmt/format.h.
-#ifdef FMT_FORMAT_H_
-# error fmt/format.h must not be included in the core test
-#endif
-  std::string s;
-  fmt::format_to(std::back_inserter(s), "{}", 42);
-  EXPECT_EQ(s, "42");
-}
-
-TEST(CoreTest, ToStringViewForeignStrings) {
-  using namespace my_ns;
-  using namespace FakeQt;
-  EXPECT_EQ(to_string_view(my_string<char>("42")), "42");
-  EXPECT_EQ(to_string_view(my_string<wchar_t>(L"42")), L"42");
-  EXPECT_EQ(to_string_view(QString(L"42")), L"42");
-  fmt::internal::type type =
-      fmt::internal::get_type<fmt::format_context, my_string<char>>::value;
-  EXPECT_EQ(type, fmt::internal::string_type);
-  type =
-      fmt::internal::get_type<fmt::wformat_context, my_string<wchar_t>>::value;
-  EXPECT_EQ(type, fmt::internal::string_type);
-  type = fmt::internal::get_type<fmt::wformat_context, QString>::value;
-  EXPECT_EQ(type, fmt::internal::string_type);
-  // Does not compile: only wide format contexts are compatible with QString!
-  // type = fmt::internal::get_type<fmt::format_context, QString>::value;
-}
-
-TEST(CoreTest, FormatForeignStrings) {
-  using namespace my_ns;
-  using namespace FakeQt;
-  EXPECT_EQ(fmt::format(my_string<char>("{}"), 42), "42");
-  EXPECT_EQ(fmt::format(my_string<wchar_t>(L"{}"), 42), L"42");
-  EXPECT_EQ(fmt::format(QString(L"{}"), 42), L"42");
-  EXPECT_EQ(fmt::format(QString(L"{}"), my_string<wchar_t>(L"42")), L"42");
-  EXPECT_EQ(fmt::format(my_string<wchar_t>(L"{}"), QString(L"42")), L"42");
-}
-
-struct implicitly_convertible_to_string_view {
-  operator fmt::string_view() const { return "foo"; }
-};
-
-TEST(FormatterTest, FormatImplicitlyConvertibleToStringView) {
-  EXPECT_EQ("foo", fmt::format("{}", implicitly_convertible_to_string_view()));
-}
-
-// std::is_constructible is broken in MSVC until version 2015.
-#if FMT_USE_EXPLICIT && (!FMT_MSC_VER || FMT_MSC_VER >= 1900)
-struct explicitly_convertible_to_string_view {
-  explicit operator fmt::string_view() const { return "foo"; }
-};
-
-TEST(FormatterTest, FormatExplicitlyConvertibleToStringView) {
-  EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_view()));
-}
-
-struct explicitly_convertible_to_wstring_view {
-  explicit operator fmt::wstring_view() const { return L"foo"; }
-};
-
-TEST(FormatterTest, FormatExplicitlyConvertibleToWStringView) {
-  EXPECT_EQ(L"foo",
-            fmt::format(L"{}", explicitly_convertible_to_wstring_view()));
-}
-
-struct explicitly_convertible_to_string_like {
-  template <
-      typename String,
-      typename = typename std::enable_if<
-        std::is_constructible<String, const char*, std::size_t>::value>::type>
-  FMT_EXPLICIT operator String() const { return String("foo", 3u); }
-};
-
-TEST(FormatterTest, FormatExplicitlyConvertibleToStringLike) {
-  EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_like()));
-}
-#endif

test/custom-formatter-test.cc

@@ -1,52 +0,0 @@
-// Formatting library for C++ - custom argument formatter tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/format.h"
-#include "gtest-extra.h"
-
-// MSVC 2013 is known to be broken.
-#if !FMT_MSC_VER || FMT_MSC_VER > 1800
-
-// A custom argument formatter that doesn't print `-` for floating-point values
-// rounded to 0.
-class custom_arg_formatter :
-    public fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>> {
- public:
-  typedef fmt::back_insert_range<fmt::internal::buffer> range;
-  typedef fmt::arg_formatter<range> base;
-
-  custom_arg_formatter(
-      fmt::format_context &ctx, fmt::format_specs *s = FMT_NULL)
-  : base(ctx, s) {}
-
-  using base::operator();
-
-  iterator operator()(double value) {
-    // Comparing a float to 0.0 is safe.
-    if (round(value * pow(10, spec()->precision)) == 0.0)
-      value = 0;
-    return base::operator()(value);
-  }
-};
-
-std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
-  fmt::memory_buffer buffer;
-  // Pass custom argument formatter as a template arg to vwrite.
-  fmt::vformat_to<custom_arg_formatter>(buffer, format_str, args);
-  return std::string(buffer.data(), buffer.size());
-}
-
-template <typename... Args>
-std::string custom_format(const char *format_str, const Args & ... args) {
-  auto va = fmt::make_format_args(args...);
-  return custom_vformat(format_str, va);
-}
-
-TEST(CustomFormatterTest, Format) {
-  EXPECT_EQ("0.00", custom_format("{:.2f}", -.00001));
-}
-#endif

test/find-package-test/CMakeLists.txt

@@ -1,17 +1,13 @@
-cmake_minimum_required(VERSION 3.1.0)
+cmake_minimum_required(VERSION 2.8.12)
 
-project(fmt-test)
+project(cppformat-test)
 
-find_package(FMT REQUIRED)
+find_package(cppformat REQUIRED)
 
-add_executable(library-test main.cc)
-target_link_libraries(library-test fmt::fmt)
-target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-target_include_directories(library-test PUBLIC SYSTEM .)
+add_executable(library-test "main.cpp")
+target_link_libraries(library-test cppformat)
 
-if (TARGET fmt::fmt-header-only)
-  add_executable(header-only-test main.cc)
-  target_link_libraries(header-only-test fmt::fmt-header-only)
-  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-  target_include_directories(header-only-test PUBLIC SYSTEM .)
+if (TARGET cppformat-header-only)
+  add_executable(header-only-test "main.cpp")
+  target_link_libraries(header-only-test cppformat-header-only)
 endif ()

test/find-package-test/main.cc

@@ -1,6 +0,0 @@
-#include "fmt/format.h"
-
-int main(int argc, char** argv) {
-  for(int i = 0; i < argc; ++i)
-    fmt::print("{}: {}\n", i, argv[i]);
-}

test/find-package-test/main.cpp

@@ -0,0 +1,8 @@
+#include "cppformat/format.h"
+
+int main(int argc, char** argv)
+{
+  for(int i = 0; i < argc; ++i)
+    fmt::print("{}: {}\n", i, argv[i]);
+  return 0;
+}

test/format-impl-test.cc

@@ -1,147 +1,65 @@
-// Formatting library for C++ - formatting library implementation tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Formatting library implementation tests.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #define FMT_NOEXCEPT
-#undef FMT_SHARED
 #include "test-assert.h"
 
-// Include format.cc instead of format.h to test implementation.
-#include "../src/format.cc"
-#include "fmt/color.h"
-#include "fmt/printf.h"
+// Include format.cc instead of format.h to test implementation-specific stuff.
+#include "cppformat/format.cc"
 
-#include <algorithm>
 #include <cstring>
 
-#include "gmock.h"
 #include "gtest-extra.h"
 #include "util.h"
 
-#undef min
 #undef max
 
-#if FMT_HAS_CPP_ATTRIBUTE(noreturn)
-# define FMT_NORETURN [[noreturn]]
-#else
-# define FMT_NORETURN
-#endif
-
-using fmt::internal::fp;
-
-template <bool is_iec559>
-void test_construct_from_double() {
-  fmt::print("warning: double is not IEC559, skipping FP tests\n");
-}
-
-template <>
-void test_construct_from_double<true>() {
-  auto v = fp(1.23);
-  EXPECT_EQ(v.f, 0x13ae147ae147aeu);
-  EXPECT_EQ(v.e, -52);
-}
-
-TEST(FPTest, ConstructFromDouble) {
-  test_construct_from_double<std::numeric_limits<double>::is_iec559>();
-}
-
-TEST(FPTest, Normalize) {
-  auto v = fp(0xbeef, 42);
-  v.normalize();
-  EXPECT_EQ(0xbeef000000000000, v.f);
-  EXPECT_EQ(-6, v.e);
-}
-
-TEST(FPTest, ComputeBoundariesSubnormal) {
-  auto v = fp(0xbeef, 42);
-  fp lower, upper;
-  v.compute_boundaries(lower, upper);
-  EXPECT_EQ(0xbeee800000000000, lower.f);
-  EXPECT_EQ(-6, lower.e);
-  EXPECT_EQ(0xbeef800000000000, upper.f);
-  EXPECT_EQ(-6, upper.e);
-}
-
-TEST(FPTest, ComputeBoundaries) {
-  auto v = fp(0x10000000000000, 42);
-  fp lower, upper;
-  v.compute_boundaries(lower, upper);
-  EXPECT_EQ(0x7ffffffffffffe00, lower.f);
-  EXPECT_EQ(31, lower.e);
-  EXPECT_EQ(0x8000000000000400, upper.f);
-  EXPECT_EQ(31, upper.e);
-}
-
-TEST(FPTest, Subtract) {
-  auto v = fp(123, 1) - fp(102, 1);
-  EXPECT_EQ(v.f, 21u);
-  EXPECT_EQ(v.e, 1);
-}
-
-TEST(FPTest, Multiply) {
-  auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
-  EXPECT_EQ(v.f, 123u * 56u);
-  EXPECT_EQ(v.e, 4 + 7 + 64);
-  v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
-  EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
-  EXPECT_EQ(v.e, 4 + 8 + 64);
-}
-
-TEST(FPTest, GetCachedPower) {
-  typedef std::numeric_limits<double> limits;
-  for (auto exp = limits::min_exponent; exp <= limits::max_exponent; ++exp) {
-    int dec_exp = 0;
-    auto fp = fmt::internal::get_cached_power(exp, dec_exp);
-    EXPECT_LE(exp, fp.e);
-    int dec_exp_step = 8;
-    EXPECT_LE(fp.e, exp + dec_exp_step * log2(10));
-    EXPECT_DOUBLE_EQ(pow(10, dec_exp), ldexp(fp.f, fp.e));
-  }
-}
-
-TEST(FPTest, Grisu2FormatCompilesWithNonIEEEDouble) {
-  fmt::memory_buffer buf;
-  grisu2_format(4.2f, buf, fmt::core_format_specs());
-}
-
-template <typename T>
-struct ValueExtractor: fmt::internal::function<T> {
-  T operator()(T value) {
-    return value;
-  }
-
-  template <typename U>
-  FMT_NORETURN T operator()(U) {
-    throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
-  }
-};
-
 TEST(FormatTest, ArgConverter) {
-  long long value = std::numeric_limits<long long>::max();
-  auto arg = fmt::internal::make_arg<fmt::format_context>(value);
-  visit(fmt::internal::arg_converter<long long, fmt::format_context>(arg, 'd'),
-        arg);
-  EXPECT_EQ(value, visit(ValueExtractor<long long>(), arg));
+  using fmt::internal::Arg;
+  Arg arg = Arg();
+  arg.type = Arg::LONG_LONG;
+  arg.long_long_value = std::numeric_limits<fmt::LongLong>::max();
+  fmt::ArgConverter<fmt::LongLong>(arg, 'd').visit(arg);
+  EXPECT_EQ(Arg::LONG_LONG, arg.type);
 }
 
 TEST(FormatTest, FormatNegativeNaN) {
   double nan = std::numeric_limits<double>::quiet_NaN();
-  if (std::signbit(-nan))
+  if (fmt::internal::FPUtil::isnegative(-nan))
     EXPECT_EQ("-nan", fmt::format("{}", -nan));
   else
     fmt::print("Warning: compiler doesn't handle negative NaN correctly");
 }
 
 TEST(FormatTest, StrError) {
-  char *message = FMT_NULL;
+  char *message = 0;
   char buffer[BUFFER_SIZE];
-  EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = FMT_NULL, 0),
-                "invalid buffer");
-  EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = buffer, 0),
-                "invalid buffer");
+  EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = 0, 0), "invalid buffer");
+  EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = buffer, 0), "invalid buffer");
   buffer[0] = 'x';
 #if defined(_GNU_SOURCE) && !defined(__COVERITY__)
   // Use invalid error code to make sure that safe_strerror returns an error
@@ -152,7 +70,7 @@ TEST(FormatTest, StrError) {
 #endif
 
   int result = fmt::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
-  EXPECT_EQ(result, 0);
+  EXPECT_EQ(0, result);
   std::size_t message_size = std::strlen(message);
   EXPECT_GE(BUFFER_SIZE - 1u, message_size);
   EXPECT_EQ(get_system_error(error_code), message);
@@ -171,76 +89,25 @@ TEST(FormatTest, StrError) {
 TEST(FormatTest, FormatErrorCode) {
   std::string msg = "error 42", sep = ": ";
   {
-    fmt::memory_buffer buffer;
-    format_to(buffer, "garbage");
-    fmt::format_error_code(buffer, 42, "test");
-    EXPECT_EQ("test: " + msg, to_string(buffer));
+    fmt::MemoryWriter w;
+    w << "garbage";
+    fmt::format_error_code(w, 42, "test");
+    EXPECT_EQ("test: " + msg, w.str());
   }
   {
-    fmt::memory_buffer buffer;
+    fmt::MemoryWriter w;
     std::string prefix(
-        fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
-    fmt::format_error_code(buffer, 42, prefix);
-    EXPECT_EQ(msg, to_string(buffer));
+        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size() + 1, 'x');
+    fmt::format_error_code(w, 42, prefix);
+    EXPECT_EQ(msg, w.str());
   }
-  int codes[] = {42, -1};
-  for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
-    // Test maximum buffer size.
-    msg = fmt::format("error {}", codes[i]);
-    fmt::memory_buffer buffer;
+  {
+    fmt::MemoryWriter w;
     std::string prefix(
-        fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
-    fmt::format_error_code(buffer, codes[i], prefix);
-    EXPECT_EQ(prefix + sep + msg, to_string(buffer));
-    std::size_t size = fmt::inline_buffer_size;
-    EXPECT_EQ(size, buffer.size());
-    buffer.resize(0);
-    // Test with a message that doesn't fit into the buffer.
-    prefix += 'x';
-    fmt::format_error_code(buffer, codes[i], prefix);
-    EXPECT_EQ(msg, to_string(buffer));
+        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size(), 'x');
+    fmt::format_error_code(w, 42, prefix);
+    EXPECT_EQ(prefix + sep + msg, w.str());
+    std::size_t size = fmt::internal::INLINE_BUFFER_SIZE;
+    EXPECT_EQ(size, w.size());
   }
 }
-
-TEST(FormatTest, CountCodePoints) {
-  EXPECT_EQ(4, fmt::internal::count_code_points(fmt::u8string_view("ёжик")));
-}
-
-TEST(ColorsTest, Colors) {
-  EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
-               "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(fg(fmt::color::blue), "blue"),
-               "\x1b[38;2;000;000;255mblue\x1b[0m");
-  EXPECT_WRITE(
-      stdout,
-      fmt::print(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
-      "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::bold, "bold"),
-               "\x1b[1mbold\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::italic, "italic"),
-               "\x1b[3mitalic\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::underline, "underline"),
-               "\x1b[4munderline\x1b[0m");
-  EXPECT_WRITE(stdout,
-               fmt::print(fmt::emphasis::strikethrough, "strikethrough"),
-               "\x1b[9mstrikethrough\x1b[0m");
-  EXPECT_WRITE(
-      stdout,
-      fmt::print(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
-      "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
-  EXPECT_WRITE(stderr, fmt::print(stderr, fmt::emphasis::bold, "bold error"),
-               "\x1b[1mbold error\x1b[0m");
-  EXPECT_WRITE(stderr, fmt::print(stderr, fg(fmt::color::blue), "blue log"),
-                 "\x1b[38;2;000;000;255mblue log\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(fmt::text_style(), "hi"), "hi");
-  EXPECT_WRITE(stdout, fmt::print(fg(fmt::terminal_color::red), "tred"),
-               "\x1b[31mtred\x1b[0m");
-  EXPECT_WRITE(stdout, fmt::print(bg(fmt::terminal_color::cyan), "tcyan"),
-               "\x1b[46mtcyan\x1b[0m");
-  EXPECT_WRITE(stdout,
-               fmt::print(fg(fmt::terminal_color::bright_green), "tbgreen"),
-               "\x1b[92mtbgreen\x1b[0m");
-  EXPECT_WRITE(stdout,
-               fmt::print(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
-               "\x1b[105mtbmagenta\x1b[0m");
-}

test/gmock-gtest-all.cc

@@ -36,7 +36,7 @@
 
 // This line ensures that gtest.h can be compiled on its own, even
 // when it's fused.
-#include "gtest.h"
+#include "gtest/gtest.h"
 
 // The following lines pull in the real gtest *.cc files.
 // Copyright 2005, Google Inc.

test/gmock/gmock.h

@@ -235,7 +235,7 @@
 
 // Most of the types needed for porting Google Mock are also required
 // for Google Test and are defined in gtest-port.h.
-#include "gtest.h"
+#include "gtest/gtest.h"
 
 // To avoid conditional compilation everywhere, we make it
 // gmock-port.h's responsibility to #include the header implementing
@@ -825,9 +825,8 @@ template <typename T> struct DecayArray<T[]> {
 // crashes).
 template <typename T>
 inline T Invalid() {
-  void *p = NULL;
   return const_cast<typename remove_reference<T>::type&>(
-      *static_cast<volatile typename remove_reference<T>::type*>(p));
+      *static_cast<volatile typename remove_reference<T>::type*>(NULL));
 }
 template <>
 inline void Invalid<void>() {}
@@ -10091,9 +10090,8 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
   // threads concurrently.
   Result InvokeWith(const ArgumentTuple& args)
         GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    const ResultHolder *rh = static_cast<const ResultHolder*>(
-                this->UntypedInvokeWith(&args));
-    return rh ? rh->GetValueAndDelete() : Result();
+    return static_cast<const ResultHolder*>(
+        this->UntypedInvokeWith(&args))->GetValueAndDelete();
   }
 
   // Adds and returns a default action spec for this mock function.

test/gtest-extra-test.cc

@@ -1,9 +1,29 @@
-// Formatting library for C++ - tests of custom Google Test assertions
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Tests of custom Google Test assertions.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include "gtest-extra.h"
 
@@ -26,7 +46,7 @@ namespace {
 std::string sanitize(const std::string &s) {
   std::string result;
   for (std::string::const_iterator i = s.begin(), end = s.end(); i != end; ++i)
-    result.push_back(static_cast<char>(*i & 0xff));
+    result.push_back(*i & 0xff);
   return result;
 }
 
@@ -58,7 +78,7 @@ void throw_exception() {
 }
 
 void throw_system_error() {
-  throw fmt::system_error(EDOM, "test");
+  throw fmt::SystemError(EDOM, "test");
 }
 
 // Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
@@ -187,11 +207,11 @@ TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
 // EXPECT_SYSTEM_ERROR macro.
 TEST(ExpectSystemErrorTest, DoesNotGenerateUnreachableCodeWarning) {
   int n = 0;
-  EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test");
+  EXPECT_SYSTEM_ERROR(throw fmt::SystemError(EDOM, "test"), EDOM, "test");
   EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), "");
   EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), "");
   EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
-      throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"), "");
+      throw fmt::SystemError(EDOM, "aaa"), EDOM, "bbb"), "");
 }
 
 TEST(AssertionSyntaxTest, ExceptionAssertionBehavesLikeSingleStatement) {
@@ -248,10 +268,10 @@ TEST(ExpectTest, EXPECT_SYSTEM_ERROR) {
   EXPECT_NONFATAL_FAILURE(
       EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"),
       "Expected: throw_exception() throws an exception of "
-      "type fmt::system_error.\n  Actual: it throws a different type.");
+      "type fmt::SystemError.\n  Actual: it throws a different type.");
   EXPECT_NONFATAL_FAILURE(
       EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "test"),
-      "Expected: do_nothing() throws an exception of type fmt::system_error.\n"
+      "Expected: do_nothing() throws an exception of type fmt::SystemError.\n"
       "  Actual: it throws nothing.");
   EXPECT_NONFATAL_FAILURE(
       EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"),
@@ -299,27 +319,27 @@ TEST(StreamingAssertionsTest, EXPECT_WRITE) {
 }
 
 TEST(UtilTest, FormatSystemError) {
-  fmt::memory_buffer out;
-  fmt::format_system_error(out, EDOM, "test message");
-  EXPECT_EQ(to_string(out), format_system_error(EDOM, "test message"));
+  fmt::MemoryWriter out;
+  fmt::internal::format_system_error(out, EDOM, "test message");
+  EXPECT_EQ(out.str(), format_system_error(EDOM, "test message"));
 }
 
 #if FMT_USE_FILE_DESCRIPTORS
 
-using fmt::buffered_file;
-using fmt::error_code;
-using fmt::file;
+using fmt::BufferedFile;
+using fmt::ErrorCode;
+using fmt::File;
 
 TEST(ErrorCodeTest, Ctor) {
-  EXPECT_EQ(error_code().get(), 0);
-  EXPECT_EQ(error_code(42).get(), 42);
+  EXPECT_EQ(0, ErrorCode().get());
+  EXPECT_EQ(42, ErrorCode(42).get());
 }
 
 TEST(OutputRedirectTest, ScopedRedirect) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   {
-    buffered_file file(write_end.fdopen("w"));
+    BufferedFile file(write_end.fdopen("w"));
     std::fprintf(file.get(), "[[[");
     {
       OutputRedirect redir(file.get());
@@ -332,53 +352,53 @@ TEST(OutputRedirectTest, ScopedRedirect) {
 
 // Test that OutputRedirect handles errors in flush correctly.
 TEST(OutputRedirectTest, FlushErrorInCtor) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  file write_copy = write_end.dup(write_fd);
-  buffered_file f = write_end.fdopen("w");
+  File write_copy = write_end.dup(write_fd);
+  BufferedFile f = write_end.fdopen("w");
   // Put a character in a file buffer.
   EXPECT_EQ('x', fputc('x', f.get()));
   FMT_POSIX(close(write_fd));
-  scoped_ptr<OutputRedirect> redir{FMT_NULL};
+  scoped_ptr<OutputRedirect> redir;
   EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new OutputRedirect(f.get())),
       EBADF, "cannot flush stream");
-  redir.reset(FMT_NULL);
+  redir.reset();
   write_copy.dup2(write_fd);  // "undo" close or dtor will fail
 }
 
 TEST(OutputRedirectTest, DupErrorInCtor) {
-  buffered_file f = open_buffered_file();
+  BufferedFile f = open_buffered_file();
   int fd = (f.fileno)();
-  file copy = file::dup(fd);
+  File copy = File::dup(fd);
   FMT_POSIX(close(fd));
-  scoped_ptr<OutputRedirect> redir{FMT_NULL};
+  scoped_ptr<OutputRedirect> redir;
   EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new OutputRedirect(f.get())),
       EBADF, fmt::format("cannot duplicate file descriptor {}", fd));
   copy.dup2(fd);  // "undo" close or dtor will fail
 }
 
 TEST(OutputRedirectTest, RestoreAndRead) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
-  buffered_file file(write_end.fdopen("w"));
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
+  BufferedFile file(write_end.fdopen("w"));
   std::fprintf(file.get(), "[[[");
   OutputRedirect redir(file.get());
   std::fprintf(file.get(), "censored");
   EXPECT_EQ("censored", sanitize(redir.restore_and_read()));
   EXPECT_EQ("", sanitize(redir.restore_and_read()));
   std::fprintf(file.get(), "]]]");
-  file = buffered_file();
+  file = BufferedFile();
   EXPECT_READ(read_end, "[[[]]]");
 }
 
 // Test that OutputRedirect handles errors in flush correctly.
 TEST(OutputRedirectTest, FlushErrorInRestoreAndRead) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  file write_copy = write_end.dup(write_fd);
-  buffered_file f = write_end.fdopen("w");
+  File write_copy = write_end.dup(write_fd);
+  BufferedFile f = write_end.fdopen("w");
   OutputRedirect redir(f.get());
   // Put a character in a file buffer.
   EXPECT_EQ('x', fputc('x', f.get()));
@@ -389,11 +409,11 @@ TEST(OutputRedirectTest, FlushErrorInRestoreAndRead) {
 }
 
 TEST(OutputRedirectTest, ErrorInDtor) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  file write_copy = write_end.dup(write_fd);
-  buffered_file f = write_end.fdopen("w");
+  File write_copy = write_end.dup(write_fd);
+  BufferedFile f = write_end.fdopen("w");
   scoped_ptr<OutputRedirect> redir(new OutputRedirect(f.get()));
   // Put a character in a file buffer.
   EXPECT_EQ('x', fputc('x', f.get()));
@@ -403,9 +423,9 @@ TEST(OutputRedirectTest, ErrorInDtor) {
       // output in EXPECT_STDERR and the second close will break output
       // redirection.
       FMT_POSIX(close(write_fd));
-      SUPPRESS_ASSERT(redir.reset(FMT_NULL));
+      SUPPRESS_ASSERT(redir.reset());
   }, format_system_error(EBADF, "cannot flush stream"));
-  write_copy.dup2(write_fd); // "undo" close or dtor of buffered_file will fail
+  write_copy.dup2(write_fd); // "undo" close or dtor of BufferedFile will fail
 }
 
 #endif  // FMT_USE_FILE_DESCRIPTORS

test/gtest-extra.cc

@@ -1,15 +1,35 @@
-// Formatting library for C++ - custom Google Test assertions
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Custom Google Test assertions.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include "gtest-extra.h"
 
 #if FMT_USE_FILE_DESCRIPTORS
 
-using fmt::file;
+using fmt::File;
 
 void OutputRedirect::flush() {
 #if EOF != -1
@@ -18,7 +38,7 @@ void OutputRedirect::flush() {
   int result = 0;
   FMT_RETRY(result, fflush(file_));
   if (result != 0)
-    throw fmt::system_error(errno, "cannot flush stream");
+    throw fmt::SystemError(errno, "cannot flush stream");
 }
 
 void OutputRedirect::restore() {
@@ -30,14 +50,14 @@ void OutputRedirect::restore() {
   original_.close();
 }
 
-OutputRedirect::OutputRedirect(FILE *f) : file_(f) {
+OutputRedirect::OutputRedirect(FILE *file) : file_(file) {
   flush();
-  int fd = FMT_POSIX(fileno(f));
-  // Create a file object referring to the original file.
-  original_ = file::dup(fd);
+  int fd = FMT_POSIX(fileno(file));
+  // Create a File object referring to the original file.
+  original_ = File::dup(fd);
   // Create a pipe.
-  file write_end;
-  file::pipe(read_end_, write_end);
+  File write_end;
+  File::pipe(read_end_, write_end);
   // Connect the passed FILE object to the write end of the pipe.
   write_end.dup2(fd);
 }
@@ -60,22 +80,23 @@ std::string OutputRedirect::restore_and_read() {
     return content;  // Already read.
   enum { BUFFER_SIZE = 4096 };
   char buffer[BUFFER_SIZE];
-  std::size_t count = 0;
+  std::streamsize count = 0;
   do {
     count = read_end_.read(buffer, BUFFER_SIZE);
-    content.append(buffer, count);
+    content.append(buffer, static_cast<std::size_t>(count));
   } while (count != 0);
   read_end_.close();
   return content;
 }
 
-std::string read(file &f, std::size_t count) {
+std::string read(File &f, std::size_t count) {
   std::string buffer(count, '\0');
-  std::size_t n = 0, offset = 0;
+  std::streamsize n = 0;
+  std::size_t offset = 0;
   do {
     n = f.read(&buffer[offset], count - offset);
     // We can't read more than size_t bytes since count has type size_t.
-    offset += n;
+    offset += static_cast<std::size_t>(n);
   } while (offset < count && n != 0);
   buffer.resize(offset);
   return buffer;
@@ -83,8 +104,8 @@ std::string read(file &f, std::size_t count) {
 
 #endif  // FMT_USE_FILE_DESCRIPTORS
 
-std::string format_system_error(int error_code, fmt::string_view message) {
-  fmt::memory_buffer out;
-  format_system_error(out, error_code, message);
-  return to_string(out);
+std::string format_system_error(int error_code, fmt::StringRef message) {
+  fmt::MemoryWriter out;
+  fmt::internal::format_system_error(out, error_code, message);
+  return out.str();
 }

test/gtest-extra.h

@@ -1,24 +1,44 @@
-// Formatting library for C++ - custom Google Test assertions
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Custom Google Test assertions.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef FMT_GTEST_EXTRA_H_
 #define FMT_GTEST_EXTRA_H_
 
 #include <string>
-#include "gmock.h"
+#include <gtest/gtest.h>
 
-#include "fmt/core.h"
+#include "cppformat/format.h"
 
 #ifndef FMT_USE_FILE_DESCRIPTORS
 # define FMT_USE_FILE_DESCRIPTORS 0
 #endif
 
 #if FMT_USE_FILE_DESCRIPTORS
-# include "fmt/posix.h"
+# include "cppformat/posix.h"
 #endif
 
 #define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
@@ -61,10 +81,10 @@
   FMT_TEST_THROW_(statement, expected_exception, \
       expected_message, GTEST_NONFATAL_FAILURE_)
 
-std::string format_system_error(int error_code, fmt::string_view message);
+std::string format_system_error(int error_code, fmt::StringRef message);
 
 #define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
-  EXPECT_THROW_MSG(statement, fmt::system_error, \
+  EXPECT_THROW_MSG(statement, fmt::SystemError, \
       format_system_error(error_code, message))
 
 #if FMT_USE_FILE_DESCRIPTORS
@@ -74,8 +94,8 @@ std::string format_system_error(int error_code, fmt::string_view message);
 class OutputRedirect {
  private:
   FILE *file_;
-  fmt::file original_;  // Original file passed to redirector.
-  fmt::file read_end_;  // Read end of the pipe where the output is redirected.
+  fmt::File original_;  // Original file passed to redirector.
+  fmt::File read_end_;  // Read end of the pipe where the output is redirected.
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(OutputRedirect);
 
@@ -145,17 +165,11 @@ class SuppressAssert {
   EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)
 
 // Attempts to read count characters from a file.
-std::string read(fmt::file &f, std::size_t count);
+std::string read(fmt::File &f, std::size_t count);
 
 #define EXPECT_READ(file, expected_content) \
   EXPECT_EQ(expected_content, read(file, std::strlen(expected_content)))
 
 #endif  // FMT_USE_FILE_DESCRIPTORS
 
-template <typename Mock>
-struct ScopedMock : testing::StrictMock<Mock> {
-  ScopedMock() { Mock::instance = this; }
-  ~ScopedMock() { Mock::instance = FMT_NULL; }
-};
-
 #endif  // FMT_GTEST_EXTRA_H_

test/gtest/gtest.h

@@ -2823,11 +2823,7 @@ inline int IsATTY(int /* fd */) { return 0; }
 inline int IsATTY(int fd) { return _isatty(fd); }
 #  endif  // GTEST_OS_WINDOWS_MOBILE
 inline int StrCaseCmp(const char* s1, const char* s2) {
-#  if _EMULATE_GLIBC
-    return strcasecmp(s1, s2);
-#  else
-    return _stricmp(s1, s2);
-#  endif
+  return _stricmp(s1, s2);
 }
 inline char* StrDup(const char* src) { return _strdup(src); }
 # endif  // __BORLANDC__

test/header-only-test.cc

@@ -1,3 +1,28 @@
-// Header-only configuration test
+/*
+ Header-only configuration test
 
-#include "fmt/core.h"
+ Copyright (c) 2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppformat/format.h"

test/header-only-test2.cc

@@ -1,3 +1,28 @@
-// Additional translation unit for the header-only configuration test
+/*
+ Additional translation unit for the header-only configuration test
 
-#include "fmt/core.h"
+ Copyright (c) 2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppformat/format.h"

test/locale-test.cc

@@ -1,34 +0,0 @@
-// Formatting library for C++ - locale tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/locale.h"
-#include "gmock.h"
-
-template <typename Char>
-struct numpunct : std::numpunct<Char> {
- protected:
-  Char do_thousands_sep() const FMT_OVERRIDE { return '~'; }
-};
-
-TEST(LocaleTest, Format) {
-  std::locale loc(std::locale(), new numpunct<char>());
-  EXPECT_EQ("1,234,567", fmt::format(std::locale(), "{:n}", 1234567));
-  EXPECT_EQ("1~234~567", fmt::format(loc, "{:n}", 1234567));
-  fmt::format_arg_store<fmt::format_context, int> as{1234567};
-  EXPECT_EQ("1~234~567", fmt::vformat(loc, "{:n}", fmt::format_args(as)));
-  std::string s;
-  fmt::format_to(std::back_inserter(s), loc, "{:n}", 1234567);
-  EXPECT_EQ("1~234~567", s);
-}
-
-TEST(LocaleTest, WFormat) {
-  std::locale loc(std::locale(), new numpunct<wchar_t>());
-  EXPECT_EQ(L"1,234,567", fmt::format(std::locale(), L"{:n}", 1234567));
-  EXPECT_EQ(L"1~234~567", fmt::format(loc, L"{:n}", 1234567));
-  fmt::format_arg_store<fmt::wformat_context, int> as{1234567};
-  EXPECT_EQ(L"1~234~567", fmt::vformat(loc, L"{:n}", fmt::wformat_args(as)));
-}

test/macro-test.cc

@@ -0,0 +1,115 @@
+/*
+ Tests of variadic function emulation macros.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <utility>
+#include <gtest/gtest.h>
+
+#define FMT_USE_VARIADIC_TEMPLATES 0
+#include "cppformat/format.h"
+
+#define IDENTITY(x) x
+
+TEST(UtilTest, Gen) {
+  int values[] = {FMT_GEN(10, IDENTITY)};
+  for (int i = 0; i < 10; ++i)
+    EXPECT_EQ(i, values[i]);
+}
+
+#define MAKE_PAIR(x, y) std::make_pair(x, y)
+
+TEST(UtilTest, ForEach) {
+  std::pair<char, int> values[] = {
+      FMT_FOR_EACH10(MAKE_PAIR, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j')
+  };
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_EQ('a' + i, values[i].first);
+    EXPECT_EQ(i, values[i].second);
+  }
+}
+
+TEST(UtilTest, NArg) {
+  EXPECT_EQ(1, FMT_NARG(a));
+  EXPECT_EQ(2, FMT_NARG(a, b));
+  EXPECT_EQ(3, FMT_NARG(a, b, c));
+  EXPECT_EQ(4, FMT_NARG(a, b, c, d));
+  EXPECT_EQ(5, FMT_NARG(a, b, c, d, e));
+  EXPECT_EQ(6, FMT_NARG(a, b, c, d, e, f));
+  EXPECT_EQ(7, FMT_NARG(a, b, c, d, e, f, g));
+  EXPECT_EQ(8, FMT_NARG(a, b, c, d, e, f, g, h));
+  EXPECT_EQ(9, FMT_NARG(a, b, c, d, e, f, g, h, i));
+  EXPECT_EQ(10, FMT_NARG(a, b, c, d, e, f, g, h, i, j));
+}
+
+int result;
+
+#define MAKE_TEST(func) \
+  void func(const char *format, const fmt::ArgList &args) { \
+    result = 0; \
+    for (unsigned i = 0; args[i].type; ++i) \
+      result += args[i].int_value; \
+  }
+
+MAKE_TEST(test_func)
+
+typedef char Char;
+FMT_WRAP1(test_func, const char *, 1)
+
+TEST(UtilTest, Wrap1) {
+  result = 0;
+  test_func("", 42);
+  EXPECT_EQ(42, result);
+}
+
+MAKE_TEST(test_variadic_void)
+FMT_VARIADIC_VOID(test_variadic_void, const char *)
+
+TEST(UtilTest, VariadicVoid) {
+  result = 0;
+  test_variadic_void("", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
+  EXPECT_EQ(550, result);
+}
+
+template <int>
+struct S {};
+
+#define GET_TYPE(n) S<n>
+
+int test_variadic(FMT_GEN(10, GET_TYPE), const fmt::ArgList &args) { \
+  int result = 0; \
+  for (unsigned i = 0; args[i].type; ++i) \
+    result += args[i].int_value; \
+  return result;
+}
+FMT_VARIADIC(int, test_variadic,
+    S<0>, S<1>, S<2>, S<3>, S<4>, S<5>, S<6>, S<7>, S<8>, S<9>)
+
+#define MAKE_ARG(n) S<n>()
+
+TEST(UtilTest, Variadic) {
+  EXPECT_EQ(550, test_variadic(FMT_GEN(10, MAKE_ARG),
+      10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
+}

test/mock-allocator.h

@@ -1,61 +1,84 @@
-// Formatting library for C++ - mock allocator
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Mock allocator.
+
+ Copyright (c) 2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef FMT_MOCK_ALLOCATOR_H_
 #define FMT_MOCK_ALLOCATOR_H_
 
-#include "gmock.h"
-#include "fmt/format.h"
+#include "gmock/gmock.h"
 
 template <typename T>
-class mock_allocator {
+class MockAllocator {
  public:
-  mock_allocator() {}
-  mock_allocator(const mock_allocator &) {}
+  MockAllocator() {}
+  MockAllocator(const MockAllocator &) {}
   typedef T value_type;
   MOCK_METHOD1_T(allocate, T* (std::size_t n));
   MOCK_METHOD2_T(deallocate, void (T* p, std::size_t n));
 };
 
 template <typename Allocator>
-class allocator_ref {
+class AllocatorRef {
  private:
   Allocator *alloc_;
 
-  void move(allocator_ref &other) {
-    alloc_ = other.alloc_;
-    other.alloc_ = FMT_NULL;
-  }
-
  public:
   typedef typename Allocator::value_type value_type;
 
-  explicit allocator_ref(Allocator *alloc = FMT_NULL) : alloc_(alloc) {}
+  explicit AllocatorRef(Allocator *alloc = 0) : alloc_(alloc) {}
 
-  allocator_ref(const allocator_ref &other) : alloc_(other.alloc_) {}
-  allocator_ref(allocator_ref &&other) { move(other); }
+  AllocatorRef(const AllocatorRef &other) : alloc_(other.alloc_) {}
 
-  allocator_ref& operator=(allocator_ref &&other) {
-    assert(this != &other);
-    move(other);
-    return *this;
-  }
-
-  allocator_ref& operator=(const allocator_ref &other) {
+  AllocatorRef& operator=(const AllocatorRef &other) {
     alloc_ = other.alloc_;
     return *this;
   }
 
+#if FMT_USE_RVALUE_REFERENCES
+ private:
+  void move(AllocatorRef &other) {
+    alloc_ = other.alloc_;
+    other.alloc_ = 0;
+  }
+
  public:
+  AllocatorRef(AllocatorRef &&other) {
+    move(other);
+  }
+
+  AllocatorRef& operator=(AllocatorRef &&other) {
+    assert(this != &other);
+    move(other);
+    return *this;
+  }
+#endif
+
   Allocator *get() const { return alloc_; }
 
-  value_type* allocate(std::size_t n) {
-    return fmt::internal::allocate(*alloc_, n);
-  }
+  value_type* allocate(std::size_t n) { return alloc_->allocate(n); }
   void deallocate(value_type* p, std::size_t n) { alloc_->deallocate(p, n); }
 };
 

test/ostream-test.cc

@@ -1,200 +0,0 @@
-// Formatting library for C++ - std::ostream support tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#define FMT_STRING_ALIAS 1
-#include "fmt/ostream.h"
-
-#include <sstream>
-#include "gmock.h"
-#include "gtest-extra.h"
-#include "util.h"
-
-using fmt::format;
-using fmt::format_error;
-
-static std::ostream &operator<<(std::ostream &os, const Date &d) {
-  os << d.year() << '-' << d.month() << '-' << d.day();
-  return os;
-}
-
-static std::wostream &operator<<(std::wostream &os, const Date &d) {
-  os << d.year() << L'-' << d.month() << L'-' << d.day();
-  return os;
-}
-
-enum TestEnum {};
-static std::ostream &operator<<(std::ostream &os, TestEnum) {
-  return os << "TestEnum";
-}
-
-static std::wostream &operator<<(std::wostream &os, TestEnum) {
-  return os << L"TestEnum";
-}
-
-enum TestEnum2 {A};
-
-TEST(OStreamTest, Enum) {
-  EXPECT_FALSE((fmt::convert_to_int<TestEnum, char>::value));
-  EXPECT_EQ("TestEnum", fmt::format("{}", TestEnum()));
-  EXPECT_EQ("0", fmt::format("{}", A));
-  EXPECT_FALSE((fmt::convert_to_int<TestEnum, wchar_t>::value));
-  EXPECT_EQ(L"TestEnum", fmt::format(L"{}", TestEnum()));
-  EXPECT_EQ(L"0", fmt::format(L"{}", A));
-}
-
-typedef fmt::back_insert_range<fmt::internal::buffer> range;
-
-struct test_arg_formatter: fmt::arg_formatter<range> {
-  test_arg_formatter(fmt::format_context &ctx, fmt::format_specs &s)
-    : fmt::arg_formatter<range>(ctx, &s) {}
-};
-
-TEST(OStreamTest, CustomArg) {
-  fmt::memory_buffer buffer;
-  fmt::internal::buffer &base = buffer;
-  fmt::format_context ctx(std::back_inserter(base), "", fmt::format_args());
-  fmt::format_specs spec;
-  test_arg_formatter af(ctx, spec);
-  visit(af, fmt::internal::make_arg<fmt::format_context>(TestEnum()));
-  EXPECT_EQ("TestEnum", std::string(buffer.data(), buffer.size()));
-}
-
-TEST(OStreamTest, Format) {
-  EXPECT_EQ("a string", format("{0}", TestString("a string")));
-  std::string s = format("The date is {0}", Date(2012, 12, 9));
-  EXPECT_EQ("The date is 2012-12-9", s);
-  Date date(2012, 12, 9);
-  EXPECT_EQ(L"The date is 2012-12-9",
-            format(L"The date is {0}", Date(2012, 12, 9)));
-}
-
-TEST(OStreamTest, FormatSpecs) {
-  EXPECT_EQ("def  ", format("{0:<5}", TestString("def")));
-  EXPECT_EQ("  def", format("{0:>5}", TestString("def")));
-  EXPECT_THROW_MSG(format("{0:=5}", TestString("def")),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_EQ(" def ", format("{0:^5}", TestString("def")));
-  EXPECT_EQ("def**", format("{0:*<5}", TestString("def")));
-  EXPECT_THROW_MSG(format("{0:+}", TestString()),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:-}", TestString()),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0: }", TestString()),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:#}", TestString()),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:05}", TestString()),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_EQ("test         ", format("{0:13}", TestString("test")));
-  EXPECT_EQ("test         ", format("{0:{1}}", TestString("test"), 13));
-  EXPECT_EQ("te", format("{0:.2}", TestString("test")));
-  EXPECT_EQ("te", format("{0:.{1}}", TestString("test"), 2));
-}
-
-struct EmptyTest {};
-static std::ostream &operator<<(std::ostream &os, EmptyTest) {
-  return os << "";
-}
-
-TEST(OStreamTest, EmptyCustomOutput) {
-  EXPECT_EQ("", fmt::format("{}", EmptyTest()));
-}
-
-TEST(OStreamTest, Print) {
-  std::ostringstream os;
-  fmt::print(os, "Don't {}!", "panic");
-  EXPECT_EQ("Don't panic!", os.str());
-  std::wostringstream wos;
-  fmt::print(wos, L"Don't {}!", L"panic");
-  EXPECT_EQ(L"Don't panic!", wos.str());
-}
-
-TEST(OStreamTest, WriteToOStream) {
-  std::ostringstream os;
-  fmt::memory_buffer buffer;
-  const char *foo = "foo";
-  buffer.append(foo, foo + std::strlen(foo));
-  fmt::internal::write(os, buffer);
-  EXPECT_EQ("foo", os.str());
-}
-
-TEST(OStreamTest, WriteToOStreamMaxSize) {
-  std::size_t max_size = std::numeric_limits<std::size_t>::max();
-  std::streamsize max_streamsize = std::numeric_limits<std::streamsize>::max();
-  if (max_size <= fmt::internal::to_unsigned(max_streamsize))
-    return;
-
-  struct test_buffer : fmt::internal::buffer {
-    explicit test_buffer(std::size_t size) { resize(size); }
-    void grow(std::size_t) {}
-  } buffer(max_size);
-
-  struct mock_streambuf : std::streambuf {
-    MOCK_METHOD2(xsputn, std::streamsize (const void *s, std::streamsize n));
-    std::streamsize xsputn(const char *s, std::streamsize n) {
-      const void *v = s;
-      return xsputn(v, n);
-    }
-  } streambuf;
-
-  struct test_ostream : std::ostream {
-    explicit test_ostream(mock_streambuf &buffer) : std::ostream(&buffer) {}
-  } os(streambuf);
-
-  testing::InSequence sequence;
-  const char *data = FMT_NULL;
-  typedef std::make_unsigned<std::streamsize>::type ustreamsize;
-  ustreamsize size = max_size;
-  do {
-    auto n = std::min(size, fmt::internal::to_unsigned(max_streamsize));
-    EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
-        .WillOnce(testing::Return(max_streamsize));
-    data += n;
-    size -= n;
-  } while (size != 0);
-  fmt::internal::write(os, buffer);
-}
-
-TEST(OStreamTest, Join) {
-  int v[3] = {1, 2, 3};
-  EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, v + 3, ", ")));
-}
-
-#if FMT_USE_CONSTEXPR
-TEST(OStreamTest, ConstexprString) {
-  EXPECT_EQ("42", format(fmt("{}"), std::string("42")));
-}
-#endif
-
-namespace fmt_test {
-struct ABC {};
-
-template <typename Output> Output &operator<<(Output &out, ABC) {
-  out << "ABC";
-  return out;
-}
-} // namespace fmt_test
-
-TEST(FormatTest, FormatToN) {
-  char buffer[4];
-  buffer[3] = 'x';
-  auto result = fmt::format_to_n(buffer, 3, "{}", fmt_test::ABC());
-  EXPECT_EQ(3u, result.size);
-  EXPECT_EQ(buffer + 3, result.out);
-  EXPECT_EQ("ABCx", fmt::string_view(buffer, 4));
-  result = fmt::format_to_n(buffer, 3, "x{}y", fmt_test::ABC());
-  EXPECT_EQ(5u, result.size);
-  EXPECT_EQ(buffer + 3, result.out);
-  EXPECT_EQ("xABx", fmt::string_view(buffer, 4));
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS
-TEST(FormatTest, UDL) {
-  using namespace fmt::literals;
-  EXPECT_EQ("{}"_format("test"), "test");
-}
-#endif

test/posix-mock-test.cc

@@ -1,17 +1,35 @@
-// Tests of the C++ interface to POSIX functions that require mocks
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Tests of the C++ interface to POSIX functions that require mocks
+
+ Copyright (c) 2012-2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 // Disable bogus MSVC warnings.
-#ifdef _MSC_VER
-# define _CRT_SECURE_NO_WARNINGS
-#endif
+#define _CRT_SECURE_NO_WARNINGS
 
 #include "posix-mock.h"
-#include "../src/posix.cc"
+#include "cppformat/posix.cc"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -23,18 +41,14 @@
 # undef ERROR
 #endif
 
-#include "gmock.h"
 #include "gtest-extra.h"
 #include "util.h"
 
-using fmt::buffered_file;
-using fmt::error_code;
-using fmt::file;
+using fmt::BufferedFile;
+using fmt::ErrorCode;
+using fmt::File;
 
 using testing::internal::scoped_ptr;
-using testing::_;
-using testing::StrEq;
-using testing::Return;
 
 namespace {
 int open_count;
@@ -133,7 +147,7 @@ int test::dup2(int fildes, int fildes2) {
 }
 
 FILE *test::fdopen(int fildes, const char *mode) {
-  EMULATE_EINTR(fdopen, FMT_NULL);
+  EMULATE_EINTR(fdopen, 0);
   return ::FMT_POSIX(fdopen(fildes, mode));
 }
 
@@ -162,7 +176,7 @@ int test::pipe(int *pfds, unsigned psize, int textmode) {
 #endif
 
 FILE *test::fopen(const char *filename, const char *mode) {
-  EMULATE_EINTR(fopen, FMT_NULL);
+  EMULATE_EINTR(fopen, 0);
   return ::fopen(filename, mode);
 }
 
@@ -195,11 +209,17 @@ int (test::fileno)(FILE *stream) {
 # define EXPECT_EQ_POSIX(expected, actual)
 #endif
 
-static void write_file(fmt::cstring_view filename, fmt::string_view content) {
-  fmt::buffered_file f(filename, "w");
+void write_file(fmt::CStringRef filename, fmt::StringRef content) {
+  fmt::BufferedFile f(filename, "w");
   f.print("{}", content);
 }
 
+TEST(UtilTest, StaticAssert) {
+  FMT_STATIC_ASSERT(true, "success");
+  // Static assertion failure is tested in compile-test because it causes
+  // a compile-time error.
+}
+
 TEST(UtilTest, GetPageSize) {
 #ifdef _WIN32
   SYSTEM_INFO si = {};
@@ -216,8 +236,8 @@ TEST(UtilTest, GetPageSize) {
 
 TEST(FileTest, OpenRetry) {
   write_file("test", "there must be something here");
-  scoped_ptr<file> f{FMT_NULL};
-  EXPECT_RETRY(f.reset(new file("test", file::RDONLY)),
+  scoped_ptr<File> f;
+  EXPECT_RETRY(f.reset(new File("test", File::RDONLY)),
                open, "cannot open file test");
 #ifndef _WIN32
   char c = 0;
@@ -226,13 +246,13 @@ TEST(FileTest, OpenRetry) {
 }
 
 TEST(FileTest, CloseNoRetryInDtor) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
-  scoped_ptr<file> f(new file(std::move(read_end)));
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
+  scoped_ptr<File> f(new File(std::move(read_end)));
   int saved_close_count = 0;
   EXPECT_WRITE(stderr, {
     close_count = 1;
-    f.reset(FMT_NULL);
+    f.reset();
     saved_close_count = close_count;
     close_count = 0;
   }, format_system_error(EINTR, "cannot close file") + "\n");
@@ -240,8 +260,8 @@ TEST(FileTest, CloseNoRetryInDtor) {
 }
 
 TEST(FileTest, CloseNoRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   close_count = 1;
   EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
   EXPECT_EQ(2, close_count);
@@ -251,15 +271,16 @@ TEST(FileTest, CloseNoRetry) {
 TEST(FileTest, Size) {
   std::string content = "top secret, destroy before reading";
   write_file("test", content);
-  file f("test", file::RDONLY);
+  File f("test", File::RDONLY);
   EXPECT_GE(f.size(), 0);
-  EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
+  fmt::ULongLong file_size = f.size();
+  EXPECT_EQ(content.size(), file_size);
 #ifdef _WIN32
-  fmt::memory_buffer message;
+  fmt::MemoryWriter message;
   fmt::internal::format_windows_error(
       message, ERROR_ACCESS_DENIED, "cannot get file size");
   fstat_sim = ERROR;
-  EXPECT_THROW_MSG(f.size(), fmt::windows_error, fmt::to_string(message));
+  EXPECT_THROW_MSG(f.size(), fmt::WindowsError, message.str());
   fstat_sim = NONE;
 #else
   f.close();
@@ -269,7 +290,7 @@ TEST(FileTest, Size) {
 
 TEST(FileTest, MaxSize) {
   write_file("test", "");
-  file f("test", file::RDONLY);
+  File f("test", File::RDONLY);
   fstat_sim = MAX_SIZE;
   EXPECT_GE(f.size(), 0);
   EXPECT_EQ(max_file_size(), f.size());
@@ -277,23 +298,23 @@ TEST(FileTest, MaxSize) {
 }
 
 TEST(FileTest, ReadRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   enum { SIZE = 4 };
   write_end.write("test", SIZE);
   write_end.close();
   char buffer[SIZE];
-  std::size_t count = 0;
+  std::streamsize count = 0;
   EXPECT_RETRY(count = read_end.read(buffer, SIZE),
       read, "cannot read from file");
   EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
 }
 
 TEST(FileTest, WriteRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   enum { SIZE = 4 };
-  std::size_t count = 0;
+  std::streamsize count = 0;
   EXPECT_RETRY(count = write_end.write("test", SIZE),
       write, "cannot write to file");
   write_end.close();
@@ -308,29 +329,29 @@ TEST(FileTest, WriteRetry) {
 
 #ifdef _WIN32
 TEST(FileTest, ConvertReadCount) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   char c;
   std::size_t size = UINT_MAX;
   if (sizeof(unsigned) != sizeof(std::size_t))
     ++size;
   read_count = 1;
   read_nbyte = 0;
-  EXPECT_THROW(read_end.read(&c, size), fmt::system_error);
+  EXPECT_THROW(read_end.read(&c, size), fmt::SystemError);
   read_count = 0;
   EXPECT_EQ(UINT_MAX, read_nbyte);
 }
 
 TEST(FileTest, ConvertWriteCount) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   char c;
   std::size_t size = UINT_MAX;
   if (sizeof(unsigned) != sizeof(std::size_t))
     ++size;
   write_count = 1;
   write_nbyte = 0;
-  EXPECT_THROW(write_end.write(&c, size), fmt::system_error);
+  EXPECT_THROW(write_end.write(&c, size), fmt::SystemError);
   write_count = 0;
   EXPECT_EQ(UINT_MAX, write_nbyte);
 }
@@ -339,14 +360,14 @@ TEST(FileTest, ConvertWriteCount) {
 TEST(FileTest, DupNoRetry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
   dup_count = 1;
-  EXPECT_SYSTEM_ERROR(file::dup(stdout_fd), EINTR,
+  EXPECT_SYSTEM_ERROR(File::dup(stdout_fd), EINTR,
       fmt::format("cannot duplicate file descriptor {}", stdout_fd));
   dup_count = 0;
 }
 
 TEST(FileTest, Dup2Retry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
-  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  File f1 = File::dup(stdout_fd), f2 = File::dup(stdout_fd);
   EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
       fmt::format("cannot duplicate file descriptor {} to {}",
       f1.descriptor(), f2.descriptor()));
@@ -354,8 +375,8 @@ TEST(FileTest, Dup2Retry) {
 
 TEST(FileTest, Dup2NoExceptRetry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
-  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
-  error_code ec;
+  File f1 = File::dup(stdout_fd), f2 = File::dup(stdout_fd);
+  ErrorCode ec;
   dup2_count = 1;
   f1.dup2(f2.descriptor(), ec);
 #ifndef _WIN32
@@ -367,16 +388,16 @@ TEST(FileTest, Dup2NoExceptRetry) {
 }
 
 TEST(FileTest, PipeNoRetry) {
-  file read_end, write_end;
+  File read_end, write_end;
   pipe_count = 1;
   EXPECT_SYSTEM_ERROR(
-      file::pipe(read_end, write_end), EINTR, "cannot create pipe");
+      File::pipe(read_end, write_end), EINTR, "cannot create pipe");
   pipe_count = 0;
 }
 
 TEST(FileTest, FdopenNoRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   fdopen_count = 1;
   EXPECT_SYSTEM_ERROR(read_end.fdopen("r"),
       EINTR, "cannot associate stream with file descriptor");
@@ -385,24 +406,24 @@ TEST(FileTest, FdopenNoRetry) {
 
 TEST(BufferedFileTest, OpenRetry) {
   write_file("test", "there must be something here");
-  scoped_ptr<buffered_file> f{FMT_NULL};
-  EXPECT_RETRY(f.reset(new buffered_file("test", "r")),
+  scoped_ptr<BufferedFile> f;
+  EXPECT_RETRY(f.reset(new BufferedFile("test", "r")),
                fopen, "cannot open file test");
 #ifndef _WIN32
   char c = 0;
   if (fread(&c, 1, 1, f->get()) < 1)
-    throw fmt::system_error(errno, "fread failed");
+    throw fmt::SystemError(errno, "fread failed");
 #endif
 }
 
 TEST(BufferedFileTest, CloseNoRetryInDtor) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
-  scoped_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
+  scoped_ptr<BufferedFile> f(new BufferedFile(read_end.fdopen("r")));
   int saved_fclose_count = 0;
   EXPECT_WRITE(stderr, {
     fclose_count = 1;
-    f.reset(FMT_NULL);
+    f.reset();
     saved_fclose_count = fclose_count;
     fclose_count = 0;
   }, format_system_error(EINTR, "cannot close file") + "\n");
@@ -410,9 +431,9 @@ TEST(BufferedFileTest, CloseNoRetryInDtor) {
 }
 
 TEST(BufferedFileTest, CloseNoRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
-  buffered_file f = read_end.fdopen("r");
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
+  BufferedFile f = read_end.fdopen("r");
   fclose_count = 1;
   EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
   EXPECT_EQ(2, fclose_count);
@@ -420,120 +441,11 @@ TEST(BufferedFileTest, CloseNoRetry) {
 }
 
 TEST(BufferedFileTest, FilenoNoRetry) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
-  buffered_file f = read_end.fdopen("r");
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
+  BufferedFile f = read_end.fdopen("r");
   fileno_count = 1;
   EXPECT_SYSTEM_ERROR((f.fileno)(), EINTR, "cannot get file descriptor");
   EXPECT_EQ(2, fileno_count);
   fileno_count = 0;
 }
-
-struct TestMock {
-  static TestMock *instance;
-} *TestMock::instance;
-
-TEST(ScopedMock, Scope) {
-  {
-    ScopedMock<TestMock> mock;
-    EXPECT_EQ(&mock, TestMock::instance);
-    TestMock &copy = mock;
-    static_cast<void>(copy);
-  }
-  EXPECT_EQ(FMT_NULL, TestMock::instance);
-}
-
-#ifdef FMT_LOCALE
-
-typedef fmt::Locale::Type LocaleType;
-
-struct LocaleMock {
-  static LocaleMock *instance;
-  MOCK_METHOD3(newlocale, LocaleType (int category_mask, const char *locale,
-                                      LocaleType base));
-  MOCK_METHOD1(freelocale, void (LocaleType locale));
-
-  MOCK_METHOD3(strtod_l, double (const char *nptr, char **endptr,
-                                 LocaleType locale));
-} *LocaleMock::instance;
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4273)
-
-_locale_t _create_locale(int category, const char *locale) {
-  return LocaleMock::instance->newlocale(category, locale, 0);
-}
-
-void _free_locale(_locale_t locale) {
-  LocaleMock::instance->freelocale(locale);
-}
-
-double _strtod_l(const char *nptr, char **endptr, _locale_t locale) {
-  return LocaleMock::instance->strtod_l(nptr, endptr, locale);
-}
-# pragma warning(pop)
-#endif
-
-#if defined(__THROW) && FMT_GCC_VERSION > 0 && FMT_GCC_VERSION <= 408
-#define FMT_LOCALE_THROW __THROW
-#else
-#define FMT_LOCALE_THROW
-#endif
-
-LocaleType newlocale(int category_mask, const char *locale, LocaleType base) FMT_LOCALE_THROW {
-  return LocaleMock::instance->newlocale(category_mask, locale, base);
-}
-
-#if defined(__APPLE__) || (defined(__FreeBSD__) && __FreeBSD_version < 1200002)
-typedef int FreeLocaleResult;
-#else
-typedef void FreeLocaleResult;
-#endif
-
-FreeLocaleResult freelocale(LocaleType locale) FMT_LOCALE_THROW {
-  LocaleMock::instance->freelocale(locale);
-  return FreeLocaleResult();
-}
-
-double strtod_l(const char *nptr, char **endptr, LocaleType locale) FMT_LOCALE_THROW {
-  return LocaleMock::instance->strtod_l(nptr, endptr, locale);
-}
-
-#undef FMT_LOCALE_THROW
-
-TEST(LocaleTest, LocaleMock) {
-  ScopedMock<LocaleMock> mock;
-  LocaleType locale = reinterpret_cast<LocaleType>(11);
-  EXPECT_CALL(mock, newlocale(222, StrEq("foo"), locale));
-  newlocale(222, "foo", locale);
-}
-
-TEST(LocaleTest, Locale) {
-#ifndef LC_NUMERIC_MASK
-  enum { LC_NUMERIC_MASK = LC_NUMERIC };
-#endif
-  ScopedMock<LocaleMock> mock;
-  LocaleType impl = reinterpret_cast<LocaleType>(42);
-  EXPECT_CALL(mock, newlocale(LC_NUMERIC_MASK, StrEq("C"), FMT_NULL))
-      .WillOnce(Return(impl));
-  EXPECT_CALL(mock, freelocale(impl));
-  fmt::Locale locale;
-  EXPECT_EQ(impl, locale.get());
-}
-
-TEST(LocaleTest, Strtod) {
-  ScopedMock<LocaleMock> mock;
-  EXPECT_CALL(mock, newlocale(_, _, _))
-      .WillOnce(Return(reinterpret_cast<LocaleType>(42)));
-  EXPECT_CALL(mock, freelocale(_));
-  fmt::Locale locale;
-  const char *str = "4.2";
-  char end = 'x';
-  EXPECT_CALL(mock, strtod_l(str, _, locale.get()))
-      .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&end), Return(777)));
-  EXPECT_EQ(777, locale.strtod(str));
-  EXPECT_EQ(&end, str);
-}
-
-#endif  // FMT_LOCALE

test/posix-mock.h

@@ -1,9 +1,29 @@
-// Formatting library for C++ - mocks of POSIX functions
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Mocks of POSIX functions
+
+ Copyright (c) 2012-2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef FMT_POSIX_TEST_H
 #define FMT_POSIX_TEST_H
@@ -14,7 +34,6 @@
 #ifdef _WIN32
 # include <windows.h>
 #else
-# include <sys/param.h>  // for FreeBSD version
 # include <sys/types.h>  // for ssize_t
 #endif
 

test/posix-test.cc

@@ -1,34 +1,53 @@
-// Formatting library for C++ - tests of the C++ interface to POSIX functions
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Tests of the C++ interface to POSIX functions
+
+ Copyright (c) 2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
-#include <cstdlib>  // std::exit
 #include <cstring>
 
-#include "fmt/posix.h"
 #include "gtest-extra.h"
+#include "cppformat/posix.h"
 #include "util.h"
 
 #ifdef fileno
 # undef fileno
 #endif
 
-using fmt::buffered_file;
-using fmt::error_code;
-using fmt::file;
+using fmt::BufferedFile;
+using fmt::ErrorCode;
+using fmt::File;
 
 using testing::internal::scoped_ptr;
 
 // Checks if the file is open by reading one character from it.
-static bool isopen(int fd) {
+bool isopen(int fd) {
   char buffer;
   return FMT_POSIX(read(fd, &buffer, 1)) == 1;
 }
 
-static bool isclosed(int fd) {
+bool isclosed(int fd) {
   char buffer;
   std::streamsize result = 0;
   SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1)));
@@ -36,74 +55,74 @@ static bool isclosed(int fd) {
 }
 
 // Opens a file for reading.
-static file open_file() {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+File open_file() {
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   write_end.write(FILE_CONTENT, std::strlen(FILE_CONTENT));
   write_end.close();
   return read_end;
 }
 
 // Attempts to write a string to a file.
-static void write(file &f, fmt::string_view s) {
+void write(File &f, fmt::StringRef s) {
   std::size_t num_chars_left = s.size();
   const char *ptr = s.data();
   do {
-    std::size_t count = f.write(ptr, num_chars_left);
+    std::streamsize count = f.write(ptr, num_chars_left);
     ptr += count;
     // We can't write more than size_t bytes since num_chars_left
     // has type size_t.
-    num_chars_left -= count;
+    num_chars_left -= static_cast<std::size_t>(count);
   } while (num_chars_left != 0);
 }
 
 TEST(BufferedFileTest, DefaultCtor) {
-  buffered_file f;
-  EXPECT_TRUE(f.get() == FMT_NULL);
+  BufferedFile f;
+  EXPECT_TRUE(f.get() == 0);
 }
 
 TEST(BufferedFileTest, MoveCtor) {
-  buffered_file bf = open_buffered_file();
+  BufferedFile bf = open_buffered_file();
   FILE *fp = bf.get();
-  EXPECT_TRUE(fp != FMT_NULL);
-  buffered_file bf2(std::move(bf));
+  EXPECT_TRUE(fp != 0);
+  BufferedFile bf2(std::move(bf));
   EXPECT_EQ(fp, bf2.get());
-  EXPECT_TRUE(bf.get() == FMT_NULL);
+  EXPECT_TRUE(bf.get() == 0);
 }
 
 TEST(BufferedFileTest, MoveAssignment) {
-  buffered_file bf = open_buffered_file();
+  BufferedFile bf = open_buffered_file();
   FILE *fp = bf.get();
-  EXPECT_TRUE(fp != FMT_NULL);
-  buffered_file bf2;
+  EXPECT_TRUE(fp != 0);
+  BufferedFile bf2;
   bf2 = std::move(bf);
   EXPECT_EQ(fp, bf2.get());
-  EXPECT_TRUE(bf.get() == FMT_NULL);
+  EXPECT_TRUE(bf.get() == 0);
 }
 
 TEST(BufferedFileTest, MoveAssignmentClosesFile) {
-  buffered_file bf = open_buffered_file();
-  buffered_file bf2 = open_buffered_file();
+  BufferedFile bf = open_buffered_file();
+  BufferedFile bf2 = open_buffered_file();
   int old_fd = bf2.fileno();
   bf2 = std::move(bf);
   EXPECT_TRUE(isclosed(old_fd));
 }
 
 TEST(BufferedFileTest, MoveFromTemporaryInCtor) {
-  FILE *fp = FMT_NULL;
-  buffered_file f(open_buffered_file(&fp));
+  FILE *fp = 0;
+  BufferedFile f(open_buffered_file(&fp));
   EXPECT_EQ(fp, f.get());
 }
 
 TEST(BufferedFileTest, MoveFromTemporaryInAssignment) {
-  FILE *fp = FMT_NULL;
-  buffered_file f;
+  FILE *fp = 0;
+  BufferedFile f;
   f = open_buffered_file(&fp);
   EXPECT_EQ(fp, f.get());
 }
 
 TEST(BufferedFileTest, MoveFromTemporaryInAssignmentClosesFile) {
-  buffered_file f = open_buffered_file();
+  BufferedFile f = open_buffered_file();
   int old_fd = f.fileno();
   f = open_buffered_file();
   EXPECT_TRUE(isclosed(old_fd));
@@ -112,60 +131,60 @@ TEST(BufferedFileTest, MoveFromTemporaryInAssignmentClosesFile) {
 TEST(BufferedFileTest, CloseFileInDtor) {
   int fd = 0;
   {
-    buffered_file f = open_buffered_file();
+    BufferedFile f = open_buffered_file();
     fd = f.fileno();
   }
   EXPECT_TRUE(isclosed(fd));
 }
 
 TEST(BufferedFileTest, CloseErrorInDtor) {
-  scoped_ptr<buffered_file> f(new buffered_file(open_buffered_file()));
+  scoped_ptr<BufferedFile> f(new BufferedFile(open_buffered_file()));
   EXPECT_WRITE(stderr, {
       // The close function must be called inside EXPECT_WRITE, otherwise
       // the system may recycle closed file descriptor when redirecting the
       // output in EXPECT_STDERR and the second close will break output
       // redirection.
       FMT_POSIX(close(f->fileno()));
-      SUPPRESS_ASSERT(f.reset(FMT_NULL));
+      SUPPRESS_ASSERT(f.reset());
   }, format_system_error(EBADF, "cannot close file") + "\n");
 }
 
 TEST(BufferedFileTest, Close) {
-  buffered_file f = open_buffered_file();
+  BufferedFile f = open_buffered_file();
   int fd = f.fileno();
   f.close();
-  EXPECT_TRUE(f.get() == FMT_NULL);
+  EXPECT_TRUE(f.get() == 0);
   EXPECT_TRUE(isclosed(fd));
 }
 
 TEST(BufferedFileTest, CloseError) {
-  buffered_file f = open_buffered_file();
+  BufferedFile f = open_buffered_file();
   FMT_POSIX(close(f.fileno()));
   EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
-  EXPECT_TRUE(f.get() == FMT_NULL);
+  EXPECT_TRUE(f.get() == 0);
 }
 
 TEST(BufferedFileTest, Fileno) {
-  buffered_file f;
+  BufferedFile f;
 #ifndef __COVERITY__
   // fileno on a null FILE pointer either crashes or returns an error.
   // Disable Coverity because this is intentional.
   EXPECT_DEATH_IF_SUPPORTED({
     try {
       f.fileno();
-    } catch (const fmt::system_error&) {
+    } catch (fmt::SystemError) {
       std::exit(1);
     }
   }, "");
 #endif
   f = open_buffered_file();
   EXPECT_TRUE(f.fileno() != -1);
-  file copy = file::dup(f.fileno());
+  File copy = File::dup(f.fileno());
   EXPECT_READ(copy, FILE_CONTENT);
 }
 
 TEST(FileTest, DefaultCtor) {
-  file f;
+  File f;
   EXPECT_EQ(-1, f.descriptor());
 }
 
@@ -173,64 +192,64 @@ TEST(FileTest, OpenBufferedFileInCtor) {
   FILE *fp = safe_fopen("test-file", "w");
   std::fputs(FILE_CONTENT, fp);
   std::fclose(fp);
-  file f("test-file", file::RDONLY);
+  File f("test-file", File::RDONLY);
   ASSERT_TRUE(isopen(f.descriptor()));
 }
 
 TEST(FileTest, OpenBufferedFileError) {
-  EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY),
+  EXPECT_SYSTEM_ERROR(File("nonexistent", File::RDONLY),
       ENOENT, "cannot open file nonexistent");
 }
 
 TEST(FileTest, MoveCtor) {
-  file f = open_file();
+  File f = open_file();
   int fd = f.descriptor();
   EXPECT_NE(-1, fd);
-  file f2(std::move(f));
+  File f2(std::move(f));
   EXPECT_EQ(fd, f2.descriptor());
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, MoveAssignment) {
-  file f = open_file();
+  File f = open_file();
   int fd = f.descriptor();
   EXPECT_NE(-1, fd);
-  file f2;
+  File f2;
   f2 = std::move(f);
   EXPECT_EQ(fd, f2.descriptor());
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, MoveAssignmentClosesFile) {
-  file f = open_file();
-  file f2 = open_file();
+  File f = open_file();
+  File f2 = open_file();
   int old_fd = f2.descriptor();
   f2 = std::move(f);
   EXPECT_TRUE(isclosed(old_fd));
 }
 
-static file OpenBufferedFile(int &fd) {
-  file f = open_file();
+File OpenBufferedFile(int &fd) {
+  File f = open_file();
   fd = f.descriptor();
-  return f;
+  return std::move(f);
 }
 
 TEST(FileTest, MoveFromTemporaryInCtor) {
-  int fd = 0xdead;
-  file f(OpenBufferedFile(fd));
+  int fd = 0xdeadbeef;
+  File f(OpenBufferedFile(fd));
   EXPECT_EQ(fd, f.descriptor());
 }
 
 TEST(FileTest, MoveFromTemporaryInAssignment) {
-  int fd = 0xdead;
-  file f;
+  int fd = 0xdeadbeef;
+  File f;
   f = OpenBufferedFile(fd);
   EXPECT_EQ(fd, f.descriptor());
 }
 
 TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) {
-  int fd = 0xdead;
-  file f = open_file();
+  int fd = 0xdeadbeef;
+  File f = open_file();
   int old_fd = f.descriptor();
   f = OpenBufferedFile(fd);
   EXPECT_TRUE(isclosed(old_fd));
@@ -239,26 +258,26 @@ TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) {
 TEST(FileTest, CloseFileInDtor) {
   int fd = 0;
   {
-    file f = open_file();
+    File f = open_file();
     fd = f.descriptor();
   }
   EXPECT_TRUE(isclosed(fd));
 }
 
 TEST(FileTest, CloseErrorInDtor) {
-  scoped_ptr<file> f(new file(open_file()));
+  scoped_ptr<File> f(new File(open_file()));
   EXPECT_WRITE(stderr, {
       // The close function must be called inside EXPECT_WRITE, otherwise
       // the system may recycle closed file descriptor when redirecting the
       // output in EXPECT_STDERR and the second close will break output
       // redirection.
       FMT_POSIX(close(f->descriptor()));
-      SUPPRESS_ASSERT(f.reset(FMT_NULL));
+      SUPPRESS_ASSERT(f.reset());
   }, format_system_error(EBADF, "cannot close file") + "\n");
 }
 
 TEST(FileTest, Close) {
-  file f = open_file();
+  File f = open_file();
   int fd = f.descriptor();
   f.close();
   EXPECT_EQ(-1, f.descriptor());
@@ -266,19 +285,19 @@ TEST(FileTest, Close) {
 }
 
 TEST(FileTest, CloseError) {
-  file f = open_file();
+  File f = open_file();
   FMT_POSIX(close(f.descriptor()));
   EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, Read) {
-  file f = open_file();
+  File f = open_file();
   EXPECT_READ(f, FILE_CONTENT);
 }
 
 TEST(FileTest, ReadError) {
-  file f("test-file", file::WRONLY);
+  File f("test-file", File::WRONLY);
   char buf;
   // We intentionally read from a file opened in the write-only mode to
   // cause error.
@@ -286,23 +305,23 @@ TEST(FileTest, ReadError) {
 }
 
 TEST(FileTest, Write) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   write(write_end, "test");
   write_end.close();
   EXPECT_READ(read_end, "test");
 }
 
 TEST(FileTest, WriteError) {
-  file f("test-file", file::RDONLY);
+  File f("test-file", File::RDONLY);
   // We intentionally write to a file opened in the read-only mode to
   // cause error.
   EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
 }
 
 TEST(FileTest, Dup) {
-  file f = open_file();
-  file copy = file::dup(f.descriptor());
+  File f = open_file();
+  File copy = File::dup(f.descriptor());
   EXPECT_NE(f.descriptor(), copy.descriptor());
   EXPECT_EQ(FILE_CONTENT, read(copy, std::strlen(FILE_CONTENT)));
 }
@@ -310,45 +329,45 @@ TEST(FileTest, Dup) {
 #ifndef __COVERITY__
 TEST(FileTest, DupError) {
   int value = -1;
-  EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value),
+  EXPECT_SYSTEM_ERROR_NOASSERT(File::dup(value),
       EBADF, "cannot duplicate file descriptor -1");
 }
 #endif
 
 TEST(FileTest, Dup2) {
-  file f = open_file();
-  file copy = open_file();
+  File f = open_file();
+  File copy = open_file();
   f.dup2(copy.descriptor());
   EXPECT_NE(f.descriptor(), copy.descriptor());
   EXPECT_READ(copy, FILE_CONTENT);
 }
 
 TEST(FileTest, Dup2Error) {
-  file f = open_file();
+  File f = open_file();
   EXPECT_SYSTEM_ERROR_NOASSERT(f.dup2(-1), EBADF,
     fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
 }
 
 TEST(FileTest, Dup2NoExcept) {
-  file f = open_file();
-  file copy = open_file();
-  error_code ec;
+  File f = open_file();
+  File copy = open_file();
+  ErrorCode ec;
   f.dup2(copy.descriptor(), ec);
-  EXPECT_EQ(ec.get(), 0);
+  EXPECT_EQ(0, ec.get());
   EXPECT_NE(f.descriptor(), copy.descriptor());
   EXPECT_READ(copy, FILE_CONTENT);
 }
 
 TEST(FileTest, Dup2NoExceptError) {
-  file f = open_file();
-  error_code ec;
+  File f = open_file();
+  ErrorCode ec;
   SUPPRESS_ASSERT(f.dup2(-1, ec));
   EXPECT_EQ(EBADF, ec.get());
 }
 
 TEST(FileTest, Pipe) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   EXPECT_NE(-1, read_end.descriptor());
   EXPECT_NE(-1, write_end.descriptor());
   write(write_end, "test");
@@ -356,23 +375,14 @@ TEST(FileTest, Pipe) {
 }
 
 TEST(FileTest, Fdopen) {
-  file read_end, write_end;
-  file::pipe(read_end, write_end);
+  File read_end, write_end;
+  File::pipe(read_end, write_end);
   int read_fd = read_end.descriptor();
   EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
 }
 
 TEST(FileTest, FdopenError) {
-  file f;
+  File f;
   EXPECT_SYSTEM_ERROR_NOASSERT(
       f.fdopen("r"), EBADF, "cannot associate stream with file descriptor");
 }
-
-#ifdef FMT_LOCALE
-TEST(LocaleTest, Strtod) {
-  fmt::Locale locale;
-  const char *start = "4.2", *ptr = start;
-  EXPECT_EQ(4.2, locale.strtod(ptr));
-  EXPECT_EQ(start + 3, ptr);
-}
-#endif

test/printf-test.cc

@@ -1,127 +1,123 @@
-// Formatting library for C++ - printf tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ printf tests.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include <cctype>
 #include <climits>
 #include <cstring>
 
-#include "fmt/core.h"
-#include "fmt/printf.h"
+#include "cppformat/format.h"
 #include "gtest-extra.h"
 #include "util.h"
 
 using fmt::format;
-using fmt::format_error;
+using fmt::FormatError;
 
 const unsigned BIG_NUM = INT_MAX + 1u;
 
 // Makes format string argument positional.
-static std::string make_positional(fmt::string_view format) {
-  std::string s(format.data(), format.size());
+std::string make_positional(fmt::StringRef format) {
+  std::string s(format.to_string());
   s.replace(s.find('%'), 1, "%1$");
   return s;
 }
 
-static std::wstring make_positional(fmt::wstring_view format) {
-  std::wstring s(format.data(), format.size());
-  s.replace(s.find(L'%'), 1, L"%1$");
-  return s;
-}
-
-// A wrapper around fmt::sprintf to workaround bogus warnings about invalid
-// format strings in MSVC.
-template <typename... Args>
-std::string test_sprintf(fmt::string_view format, const Args &... args) {
-  return fmt::sprintf(format, args...);
-}
-template <typename... Args>
-std::wstring test_sprintf(fmt::wstring_view format, const Args &... args) {
-  return fmt::sprintf(format, args...);
-}
-
 #define EXPECT_PRINTF(expected_output, format, arg) \
-  EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
+  EXPECT_EQ(expected_output, fmt::sprintf(format, arg)) \
     << "format: " << format; \
   EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))
 
 TEST(PrintfTest, NoArgs) {
-  EXPECT_EQ("test", test_sprintf("test"));
-  EXPECT_EQ(L"test", fmt::sprintf(L"test"));
+  EXPECT_EQ("test", fmt::sprintf("test"));
 }
 
 TEST(PrintfTest, Escape) {
-  EXPECT_EQ("%", test_sprintf("%%"));
-  EXPECT_EQ("before %", test_sprintf("before %%"));
-  EXPECT_EQ("% after", test_sprintf("%% after"));
-  EXPECT_EQ("before % after", test_sprintf("before %% after"));
-  EXPECT_EQ("%s", test_sprintf("%%s"));
-  EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
-  EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
-  EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
-  EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
-  EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
+  EXPECT_EQ("%", fmt::sprintf("%%"));
+  EXPECT_EQ("before %", fmt::sprintf("before %%"));
+  EXPECT_EQ("% after", fmt::sprintf("%% after"));
+  EXPECT_EQ("before % after", fmt::sprintf("before %% after"));
+  EXPECT_EQ("%s", fmt::sprintf("%%s"));
 }
 
 TEST(PrintfTest, PositionalArgs) {
-  EXPECT_EQ("42", test_sprintf("%1$d", 42));
-  EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
-  EXPECT_EQ("42 after", test_sprintf("%1$d after",42));
-  EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
-  EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
+  EXPECT_EQ("42", fmt::sprintf("%1$d", 42));
+  EXPECT_EQ("before 42", fmt::sprintf("before %1$d", 42));
+  EXPECT_EQ("42 after", fmt::sprintf("%1$d after",42));
+  EXPECT_EQ("before 42 after", fmt::sprintf("before %1$d after", 42));
+  EXPECT_EQ("answer = 42", fmt::sprintf("%1$s = %2$d", "answer", 42));
   EXPECT_EQ("42 is the answer",
-      test_sprintf("%2$d is the %1$s", "answer", 42));
-  EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
+      fmt::sprintf("%2$d is the %1$s", "answer", 42));
+  EXPECT_EQ("abracadabra", fmt::sprintf("%1$s%2$s%1$s", "abra", "cad"));
 }
 
 TEST(PrintfTest, AutomaticArgIndexing) {
-  EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
+  EXPECT_EQ("abc", fmt::sprintf("%c%c%c", 'a', 'b', 'c'));
 }
 
 TEST(PrintfTest, NumberIsTooBigInArgIndex) {
-  EXPECT_THROW_MSG(test_sprintf(format("%{}$", BIG_NUM)),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", BIG_NUM)),
-      format_error, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$", BIG_NUM)),
+      FormatError, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", BIG_NUM)),
+      FormatError, "number is too big");
 }
 
 TEST(PrintfTest, SwitchArgIndexing) {
-  EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2),
-      format_error, "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(fmt::sprintf("%1$d%", 1, 2),
+      FormatError, "invalid format string");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
+      FormatError, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf("%1$d%d", 1, 2),
+      FormatError, "cannot switch from manual to automatic argument indexing");
 
-  EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2),
-      format_error, "cannot switch from automatic to manual argument indexing");
-  EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", BIG_NUM), 1, 2),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2),
-      format_error, "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(fmt::sprintf("%d%1$", 1, 2),
+      FormatError, "invalid format string");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%d%{}$d", BIG_NUM), 1, 2),
+      FormatError, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf("%d%1$d", 1, 2),
+      FormatError, "cannot switch from automatic to manual argument indexing");
 
   // Indexing errors override width errors.
-  EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", BIG_NUM), 1, 2),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
-      format_error, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%d%1${}d", BIG_NUM), 1, 2),
+      FormatError, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
+      FormatError, "number is too big");
 }
 
 TEST(PrintfTest, InvalidArgIndex) {
-  EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%0$d", 42), FormatError,
       "argument index out of range");
-  EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%2$d", 42), FormatError,
       "argument index out of range");
-  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42),
-      format_error, "argument index out of range");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", INT_MAX), 42),
+      FormatError, "argument index out of range");
 
-  EXPECT_THROW_MSG(test_sprintf("%2$", 42),
-      format_error, "argument index out of range");
-  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", BIG_NUM), 42),
-      format_error, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf("%2$", 42),
+      FormatError, "invalid format string");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", BIG_NUM), 42),
+      FormatError, "number is too big");
 }
 
 TEST(PrintfTest, DefaultAlignRight) {
@@ -140,7 +136,7 @@ TEST(PrintfTest, ZeroFlag) {
   EXPECT_PRINTF("+00042", "%00+6d", 42);
 
   // '0' flag is ignored for non-numeric types.
-  EXPECT_PRINTF("0000x", "%05c", 'x');
+  EXPECT_PRINTF("    x", "%05c", 'x');
 }
 
 TEST(PrintfTest, PlusFlag) {
@@ -207,23 +203,23 @@ TEST(PrintfTest, Width) {
   EXPECT_PRINTF("  abc", "%5s", "abc");
 
   // Width cannot be specified twice.
-  EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
-      "invalid type specifier");
+  EXPECT_THROW_MSG(fmt::sprintf("%5-5d", 42), FormatError,
+      "unknown format code '-' for integer");
 
-  EXPECT_THROW_MSG(test_sprintf(format("%{}d", BIG_NUM), 42),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(test_sprintf(format("%1${}d", BIG_NUM), 42),
-      format_error, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%{}d", BIG_NUM), 42),
+      FormatError, "number is too big");
+  EXPECT_THROW_MSG(fmt::sprintf(format("%1${}d", BIG_NUM), 42),
+      FormatError, "number is too big");
 }
 
 TEST(PrintfTest, DynamicWidth) {
-  EXPECT_EQ("   42", test_sprintf("%*d", 5, 42));
-  EXPECT_EQ("42   ", test_sprintf("%*d", -5, 42));
-  EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
+  EXPECT_EQ("   42", fmt::sprintf("%*d", 5, 42));
+  EXPECT_EQ("42   ", fmt::sprintf("%*d", -5, 42));
+  EXPECT_THROW_MSG(fmt::sprintf("%*d", 5.0, 42), FormatError,
       "width is not integer");
-  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%*d"), FormatError,
       "argument index out of range");
-  EXPECT_THROW_MSG(test_sprintf("%*d", BIG_NUM, 42), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%*d", BIG_NUM, 42), FormatError,
       "number is too big");
 }
 
@@ -264,58 +260,56 @@ TEST(PrintfTest, IgnorePrecisionForNonNumericArg) {
 }
 
 TEST(PrintfTest, DynamicPrecision) {
-  EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
-  EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
-  EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
+  EXPECT_EQ("00042", fmt::sprintf("%.*d", 5, 42));
+  EXPECT_EQ("42", fmt::sprintf("%.*d", -5, 42));
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d", 5.0, 42), FormatError,
       "precision is not integer");
-  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d"), FormatError,
       "argument index out of range");
-  EXPECT_THROW_MSG(test_sprintf("%.*d", BIG_NUM, 42), format_error,
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d", BIG_NUM, 42), FormatError,
       "number is too big");
-  if (sizeof(long long) != sizeof(int)) {
-    long long prec = static_cast<long long>(INT_MIN) - 1;
-    EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
+  if (sizeof(fmt::LongLong) != sizeof(int)) {
+    fmt::LongLong prec = static_cast<fmt::LongLong>(INT_MIN) - 1;
+    EXPECT_THROW_MSG(fmt::sprintf("%.*d", prec, 42), FormatError,
         "number is too big");
  }
 }
 
 template <typename T>
-struct make_signed { typedef T type; };
+struct MakeSigned { typedef T Type; };
 
 #define SPECIALIZE_MAKE_SIGNED(T, S) \
   template <> \
-  struct make_signed<T> { typedef S type; }
+  struct MakeSigned<T> { typedef S Type; }
 
 SPECIALIZE_MAKE_SIGNED(char, signed char);
 SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
 SPECIALIZE_MAKE_SIGNED(unsigned short, short);
 SPECIALIZE_MAKE_SIGNED(unsigned, int);
 SPECIALIZE_MAKE_SIGNED(unsigned long, long);
-SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);
+SPECIALIZE_MAKE_SIGNED(fmt::ULongLong, fmt::LongLong);
 
-// Test length format specifier ``length_spec``.
 template <typename T, typename U>
 void TestLength(const char *length_spec, U value) {
-  long long signed_value = 0;
-  unsigned long long unsigned_value = 0;
+  fmt::LongLong signed_value = value;
+  fmt::ULongLong unsigned_value = value;
   // Apply integer promotion to the argument.
-  using std::numeric_limits;
-  unsigned long long max = numeric_limits<U>::max();
-  using fmt::internal::const_check;
-  if (const_check(max <= static_cast<unsigned>(numeric_limits<int>::max()))) {
+  fmt::ULongLong max = std::numeric_limits<U>::max();
+  using fmt::internal::check;
+  if (check(max <= static_cast<unsigned>(std::numeric_limits<int>::max()))) {
     signed_value = static_cast<int>(value);
-    unsigned_value = static_cast<unsigned>(value);
-  } else if (const_check(max <= numeric_limits<unsigned>::max())) {
+    unsigned_value = static_cast<int>(value);
+  } else if (check(max <= std::numeric_limits<unsigned>::max())) {
     signed_value = static_cast<unsigned>(value);
     unsigned_value = static_cast<unsigned>(value);
   }
+  using fmt::internal::MakeUnsigned;
   if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
-    signed_value = static_cast<long long>(value);
-    unsigned_value =
-        static_cast<typename std::make_unsigned<unsigned>::type>(value);
+    signed_value = unsigned_value =
+        static_cast<typename MakeUnsigned<unsigned>::Type>(value);
   } else {
-    signed_value = static_cast<typename make_signed<T>::type>(value);
-    unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
+    signed_value = static_cast<typename MakeSigned<T>::Type>(value);
+    unsigned_value = static_cast<typename MakeUnsigned<T>::Type>(value);
   }
   std::ostringstream os;
   os << signed_value;
@@ -342,20 +336,23 @@ void TestLength(const char *length_spec) {
   TestLength<T>(length_spec, -42);
   TestLength<T>(length_spec, min);
   TestLength<T>(length_spec, max);
-  TestLength<T>(length_spec, static_cast<long long>(min) - 1);
-  unsigned long long long_long_max = std::numeric_limits<long long>::max();
-  if (static_cast<unsigned long long>(max) < long_long_max)
-    TestLength<T>(length_spec, static_cast<long long>(max) + 1);
+  using fmt::internal::check;
+  fmt::LongLong long_long_min = std::numeric_limits<fmt::LongLong>::min();
+  if (check(min >= 0) || check(static_cast<fmt::LongLong>(min) > long_long_min))
+    TestLength<T>(length_spec, fmt::LongLong(min) - 1);
+  fmt::ULongLong long_long_max = std::numeric_limits<fmt::LongLong>::max();
+  if (check(max < 0 || static_cast<fmt::ULongLong>(max) < long_long_max))
+    TestLength<T>(length_spec, fmt::LongLong(max) + 1);
   TestLength<T>(length_spec, std::numeric_limits<short>::min());
   TestLength<T>(length_spec, std::numeric_limits<unsigned short>::max());
   TestLength<T>(length_spec, std::numeric_limits<int>::min());
   TestLength<T>(length_spec, std::numeric_limits<int>::max());
   TestLength<T>(length_spec, std::numeric_limits<unsigned>::min());
   TestLength<T>(length_spec, std::numeric_limits<unsigned>::max());
-  TestLength<T>(length_spec, std::numeric_limits<long long>::min());
-  TestLength<T>(length_spec, std::numeric_limits<long long>::max());
-  TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::min());
-  TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::max());
+  TestLength<T>(length_spec, std::numeric_limits<fmt::LongLong>::min());
+  TestLength<T>(length_spec, std::numeric_limits<fmt::LongLong>::max());
+  TestLength<T>(length_spec, std::numeric_limits<fmt::ULongLong>::min());
+  TestLength<T>(length_spec, std::numeric_limits<fmt::ULongLong>::max());
 }
 
 TEST(PrintfTest, Length) {
@@ -366,8 +363,8 @@ TEST(PrintfTest, Length) {
   TestLength<unsigned short>("h");
   TestLength<long>("l");
   TestLength<unsigned long>("l");
-  TestLength<long long>("ll");
-  TestLength<unsigned long long>("ll");
+  TestLength<fmt::LongLong>("ll");
+  TestLength<fmt::ULongLong>("ll");
   TestLength<intmax_t>("j");
   TestLength<std::size_t>("z");
   TestLength<std::ptrdiff_t>("t");
@@ -384,25 +381,15 @@ TEST(PrintfTest, Bool) {
 TEST(PrintfTest, Int) {
   EXPECT_PRINTF("-42", "%d", -42);
   EXPECT_PRINTF("-42", "%i", -42);
-  unsigned u = 0 - 42u;
+  unsigned u = -42;
   EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
   EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
   EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
   EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
 }
 
-TEST(PrintfTest, long_long) {
-  // fmt::printf allows passing long long arguments to %d without length
-  // specifiers.
-  long long max = std::numeric_limits<long long>::max();
-  EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
-}
-
 TEST(PrintfTest, Float) {
   EXPECT_PRINTF("392.650000", "%f", 392.65);
-  EXPECT_PRINTF("392.65", "%.2f", 392.65);
-  EXPECT_PRINTF("392.6", "%.1f", 392.65);
-  EXPECT_PRINTF("393", "%.f", 392.65);
   EXPECT_PRINTF("392.650000", "%F", 392.65);
   char buffer[BUFFER_SIZE];
   safe_sprintf(buffer, "%e", 392.65);
@@ -421,7 +408,7 @@ TEST(PrintfTest, Inf) {
   double inf = std::numeric_limits<double>::infinity();
   for (const char* type = "fega"; *type; ++type) {
     EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
-    char upper = static_cast<char>(std::toupper(*type));
+    char upper = std::toupper(*type);
     EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
   }
 }
@@ -431,42 +418,32 @@ TEST(PrintfTest, Char) {
   int max = std::numeric_limits<int>::max();
   EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
   //EXPECT_PRINTF("x", "%lc", L'x');
-  EXPECT_PRINTF(L"x", L"%c", L'x');
-  EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
+  // TODO: test wchar_t
 }
 
 TEST(PrintfTest, String) {
   EXPECT_PRINTF("abc", "%s", "abc");
-  const char *null_str = FMT_NULL;
+  const char *null_str = 0;
   EXPECT_PRINTF("(null)", "%s", null_str);
   EXPECT_PRINTF("    (null)", "%10s", null_str);
-  EXPECT_PRINTF(L"abc", L"%s", L"abc");
-  const wchar_t *null_wstr = FMT_NULL;
-  EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
-  EXPECT_PRINTF(L"    (null)", L"%10s", null_wstr);
+  // TODO: wide string
 }
 
 TEST(PrintfTest, Pointer) {
   int n;
   void *p = &n;
   EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
-  p = FMT_NULL;
+  p = 0;
   EXPECT_PRINTF("(nil)", "%p", p);
   EXPECT_PRINTF("     (nil)", "%10p", p);
   const char *s = "test";
   EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
-  const char *null_str = FMT_NULL;
+  const char *null_str = 0;
   EXPECT_PRINTF("(nil)", "%p", null_str);
+}
 
-  p = &n;
-  EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
-  p = FMT_NULL;
-  EXPECT_PRINTF(L"(nil)", L"%p", p);
-  EXPECT_PRINTF(L"     (nil)", L"%10p", p);
-  const wchar_t *w = L"test";
-  EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
-  const wchar_t *null_wstr = FMT_NULL;
-  EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
+TEST(PrintfTest, Custom) {
+  EXPECT_PRINTF("abc", "%s", TestString("abc"));
 }
 
 TEST(PrintfTest, Location) {
@@ -489,81 +466,13 @@ TEST(PrintfTest, Examples) {
 }
 
 TEST(PrintfTest, PrintfError) {
-  fmt::file read_end, write_end;
-  fmt::file::pipe(read_end, write_end);
+  fmt::File read_end, write_end;
+  fmt::File::pipe(read_end, write_end);
   int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
   EXPECT_LT(result, 0);
 }
 #endif
 
 TEST(PrintfTest, WideString) {
-  EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
-}
-
-TEST(PrintfTest, PrintfCustom) {
-  EXPECT_EQ("abc", test_sprintf("%s", TestString("abc")));
-}
-
-TEST(PrintfTest, OStream) {
-  std::ostringstream os;
-  int ret = fmt::fprintf(os, "Don't %s!", "panic");
-  EXPECT_EQ("Don't panic!", os.str());
-  EXPECT_EQ(12, ret);
-}
-
-TEST(PrintfTest, VPrintf) {
-  fmt::format_arg_store<fmt::printf_context, int> as{42};
-  fmt::basic_format_args<fmt::printf_context> args(as);
-  EXPECT_EQ(fmt::vsprintf("%d", args), "42");
-  EXPECT_WRITE(stdout, fmt::vprintf("%d", args), "42");
-  EXPECT_WRITE(stdout, fmt::vfprintf(stdout, "%d", args), "42");
-  EXPECT_WRITE(stdout, fmt::vfprintf(std::cout, "%d", args), "42");
-}
-
-template<typename... Args>
-void check_format_string_regression(fmt::string_view s, const Args&... args) {
-  fmt::sprintf(s, args...);
-}
-
-TEST(PrintfTest, CheckFormatStringRegression) {
-  check_format_string_regression("%c%s", 'x', "");
-}
-
-TEST(PrintfTest, VSPrintfMakeArgsExample) {
-  fmt::format_arg_store<fmt::printf_context, int, const char *> as{
-      42, "something"};
-  fmt::basic_format_args<fmt::printf_context> args(as);
-  EXPECT_EQ(
-      "[42] something happened", fmt::vsprintf("[%d] %s happened", args));
-  auto as2 = fmt::make_printf_args(42, "something");
-  fmt::basic_format_args<fmt::printf_context> args2(as2);
-  EXPECT_EQ(
-      "[42] something happened", fmt::vsprintf("[%d] %s happened", args2));
-  //the older gcc versions can't cast the return value
-#if !defined(__GNUC__) || (__GNUC__ > 4) 
-  EXPECT_EQ(
-      "[42] something happened",
-      fmt::vsprintf(
-          "[%d] %s happened", fmt::make_printf_args(42, "something")));
-#endif
-}
-
-TEST(PrintfTest, VSPrintfMakeWArgsExample) {
-  fmt::format_arg_store<fmt::wprintf_context, int, const wchar_t *> as{
-     42, L"something"};
-  fmt::basic_format_args<fmt::wprintf_context> args(as);
-  EXPECT_EQ(
-     L"[42] something happened",
-     fmt::vsprintf(L"[%d] %s happened", args));
-  auto  as2 = fmt::make_wprintf_args(42, L"something");
-  fmt::basic_format_args<fmt::wprintf_context> args2(as2);
-  EXPECT_EQ(
-      L"[42] something happened", fmt::vsprintf(L"[%d] %s happened", args2));
-  // the older gcc versions can't cast the return value
-#if !defined(__GNUC__) || (__GNUC__ > 4)
-  EXPECT_EQ(
-      L"[42] something happened",
-      fmt::vsprintf(
-          L"[%d] %s happened", fmt::make_wprintf_args(42, L"something")));
-#endif
+  EXPECT_EQ(L"abc", fmt::sprintf(L"%s", TestWString(L"abc")));
 }

test/ranges-test.cc

@@ -1,87 +0,0 @@
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for ranges, containers and types tuple interface.
-
-/// Check if  'if constexpr' is supported.
-#if (__cplusplus > 201402L) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
-
-#include "fmt/ranges.h"
-#include "gtest.h"
-
-#include <vector>
-#include <array>
-#include <map>
-#include <string>
-
-TEST(RangesTest, FormatVector) {
-  std::vector<int32_t> iv{1, 2, 3, 5, 7, 11};
-  auto ivf = fmt::format("{}", iv);
-  EXPECT_EQ("{1, 2, 3, 5, 7, 11}", ivf);
-}
-
-TEST(RangesTest, FormatVector2) {
-  std::vector<std::vector<int32_t>> ivv{{1, 2}, {3, 5}, {7, 11}};
-  auto ivf = fmt::format("{}", ivv);
-  EXPECT_EQ("{{1, 2}, {3, 5}, {7, 11}}", ivf);
-}
-
-TEST(RangesTest, FormatMap) {
-  std::map<std::string, int32_t> simap{{"one", 1}, {"two", 2}};
-  EXPECT_EQ("{(\"one\", 1), (\"two\", 2)}", fmt::format("{}", simap));
-}
-
-TEST(RangesTest, FormatPair) {
-  std::pair<int64_t, float> pa1{42, 3.14159265358979f};
-  EXPECT_EQ("(42, 3.14159)", fmt::format("{}", pa1));
-}
-
-TEST(RangesTest, FormatTuple) {
-  std::tuple<int64_t, float, std::string, char> tu1{42, 3.14159265358979f,
-                                              "this is tuple", 'i'};
-  EXPECT_EQ("(42, 3.14159, \"this is tuple\", 'i')", fmt::format("{}", tu1));
-}
-
-struct my_struct {
-  int32_t i;
-  std::string str;  // can throw
-  template <std::size_t N>
-  decltype(auto) get() const noexcept {
-    if constexpr (N == 0)
-      return i;
-    else if constexpr (N == 1)
-      return fmt::string_view{str};
-  }
-};
-
-template <std::size_t N>
-decltype(auto) get(const my_struct& s) noexcept {
-  return s.get<N>();
-}
-
-namespace std {
-
-template <>
-struct tuple_size<my_struct> : std::integral_constant<std::size_t, 2> {};
-
-template <std::size_t N>
-struct tuple_element<N, my_struct> {
-  using type = decltype(std::declval<my_struct>().get<N>());
-};
-
-}  // namespace std
-
-TEST(RangesTest, FormatStruct) {
-  my_struct mst{13, "my struct"};
-  EXPECT_EQ("(13, \"my struct\")", fmt::format("{}", mst));
-}
-
-#endif  // (__cplusplus > 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >
-        // 201402L && _MSC_VER >= 1910)

test/test-assert.h

@@ -1,26 +1,47 @@
-// Formatting library for C++ - test version of FMT_ASSERT
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Test version of FMT_ASSERT
 
-#ifndef FMT_TEST_ASSERT_H_
-#define FMT_TEST_ASSERT_H_
+ Copyright (c) 2015, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FMT_TEST_ASSERT_H
+#define FMT_TEST_ASSERT_H
 
 #include <stdexcept>
-#include "gtest.h"
 
-class assertion_failure : public std::logic_error {
+class AssertionFailure : public std::logic_error {
  public:
-  explicit assertion_failure(const char *message) : std::logic_error(message) {}
+  explicit AssertionFailure(const char *message) : std::logic_error(message) {}
 };
 
 #define FMT_ASSERT(condition, message) \
-  if (!(condition)) throw assertion_failure(message);
+  if (!(condition)) throw AssertionFailure(message);
+
+#include "gtest-extra.h"
 
 // Expects an assertion failure.
 #define EXPECT_ASSERT(stmt, message) \
-  FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_)
+  EXPECT_THROW_MSG(stmt, AssertionFailure, message)
 
-#endif  // FMT_TEST_ASSERT_H_
+#endif  // FMT_TEST_ASSERT_H

test/test-main.cc

@@ -1,12 +1,32 @@
-// Formatting library for C++ - test main function.
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Tests of additional gtest macros.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include <cstdlib>
-#include "gtest.h"
+#include <gtest/gtest.h>
 
 #ifdef _WIN32
 # include <windows.h>

test/time-test.cc

@@ -1,68 +0,0 @@
-// Formatting library for C++ - time formatting tests
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifdef WIN32
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
-#include "gmock.h"
-#include "fmt/locale.h"
-#include "fmt/time.h"
-
-TEST(TimeTest, Format) {
-  std::tm tm = std::tm();
-  tm.tm_year = 116;
-  tm.tm_mon  = 3;
-  tm.tm_mday = 25;
-  EXPECT_EQ("The date is 2016-04-25.",
-            fmt::format("The date is {:%Y-%m-%d}.", tm));
-}
-
-TEST(TimeTest, GrowBuffer) {
-  std::string s = "{:";
-  for (int i = 0; i < 30; ++i)
-    s += "%c";
-  s += "}\n";
-  std::time_t t = std::time(FMT_NULL);
-  fmt::format(s, *std::localtime(&t));
-}
-
-TEST(TimeTest, FormatToEmptyContainer) {
-  std::string s;
-  auto time = std::tm();
-  time.tm_sec = 42;
-  fmt::format_to(std::back_inserter(s), "{:%S}", time);
-  EXPECT_EQ(s, "42");
-}
-
-TEST(TimeTest, EmptyResult) {
-  EXPECT_EQ("", fmt::format("{}", std::tm()));
-}
-
-static bool EqualTime(const std::tm &lhs, const std::tm &rhs) {
-  return lhs.tm_sec == rhs.tm_sec &&
-         lhs.tm_min == rhs.tm_min &&
-         lhs.tm_hour == rhs.tm_hour &&
-         lhs.tm_mday == rhs.tm_mday &&
-         lhs.tm_mon == rhs.tm_mon &&
-         lhs.tm_year == rhs.tm_year &&
-         lhs.tm_wday == rhs.tm_wday &&
-         lhs.tm_yday == rhs.tm_yday &&
-         lhs.tm_isdst == rhs.tm_isdst;
-}
-
-TEST(TimeTest, LocalTime) {
-  std::time_t t = std::time(FMT_NULL);
-  std::tm tm = *std::localtime(&t);
-  EXPECT_TRUE(EqualTime(tm, fmt::localtime(t)));
-}
-
-TEST(TimeTest, GMTime) {
-  std::time_t t = std::time(FMT_NULL);
-  std::tm tm = *std::gmtime(&t);
-  EXPECT_TRUE(EqualTime(tm, fmt::gmtime(t)));
-}

test/util-test.cc

@@ -0,0 +1,917 @@
+/*
+ Utility tests.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test-assert.h"
+
+#include <cfloat>
+#include <climits>
+#include <cstring>
+#include <functional>
+#include <limits>
+
+#if FMT_USE_TYPE_TRAITS
+# include <type_traits>
+#endif
+
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "mock-allocator.h"
+#include "util.h"
+
+// Check if format.h compiles with windows.h included.
+#ifdef _WIN32
+# include <windows.h>
+#endif
+
+#include "cppformat/format.h"
+
+#undef max
+
+using fmt::StringRef;
+using fmt::internal::Arg;
+using fmt::Buffer;
+using fmt::internal::MemoryBuffer;
+
+using testing::Return;
+using testing::StrictMock;
+
+namespace {
+
+struct Test {};
+template <typename Char>
+std::basic_ostream<Char> &operator<<(std::basic_ostream<Char> &os, Test) {
+  return os << "test";
+}
+
+template <typename Char, typename T>
+Arg make_arg(const T &value) {
+  Arg arg = fmt::internal::MakeValue<Char>(value);
+  arg.type = static_cast<Arg::Type>(
+        fmt::internal::MakeValue<Char>::type(value));
+  return arg;
+}
+}  // namespace
+
+void CheckForwarding(
+    MockAllocator<int> &alloc, AllocatorRef< MockAllocator<int> > &ref) {
+  int mem;
+  // Check if value_type is properly defined.
+  AllocatorRef< MockAllocator<int> >::value_type *ptr = &mem;
+  // Check forwarding.
+  EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
+  ref.allocate(42);
+  EXPECT_CALL(alloc, deallocate(ptr, 42));
+  ref.deallocate(ptr, 42);
+}
+
+TEST(AllocatorTest, AllocatorRef) {
+  StrictMock< MockAllocator<int> > alloc;
+  typedef AllocatorRef< MockAllocator<int> > TestAllocatorRef;
+  TestAllocatorRef ref(&alloc);
+  // Check if AllocatorRef forwards to the underlying allocator.
+  CheckForwarding(alloc, ref);
+  TestAllocatorRef ref2(ref);
+  CheckForwarding(alloc, ref2);
+  TestAllocatorRef ref3;
+  EXPECT_EQ(0, ref3.get());
+  ref3 = ref;
+  CheckForwarding(alloc, ref3);
+}
+
+#if FMT_USE_TYPE_TRAITS
+TEST(BufferTest, Noncopyable) {
+  EXPECT_FALSE(std::is_copy_constructible<Buffer<char> >::value);
+  EXPECT_FALSE(std::is_copy_assignable<Buffer<char> >::value);
+}
+
+TEST(BufferTest, Nonmoveable) {
+  EXPECT_FALSE(std::is_move_constructible<Buffer<char> >::value);
+  EXPECT_FALSE(std::is_move_assignable<Buffer<char> >::value);
+}
+#endif
+
+// A test buffer with a dummy grow method.
+template <typename T>
+struct TestBuffer : Buffer<T> {
+  void grow(std::size_t size) { this->capacity_ = size; }
+};
+
+template <typename T>
+struct MockBuffer : Buffer<T> {
+  MOCK_METHOD1(do_grow, void (std::size_t size));
+
+  void grow(std::size_t size) {
+    this->capacity_ = size;
+    do_grow(size);
+  }
+
+  MockBuffer() {}
+  MockBuffer(T *ptr) : Buffer<T>(ptr) {}
+  MockBuffer(T *ptr, std::size_t capacity) : Buffer<T>(ptr, capacity) {}
+};
+
+TEST(BufferTest, Ctor) {
+  {
+    MockBuffer<int> buffer;
+    EXPECT_EQ(0, &buffer[0]);
+    EXPECT_EQ(0u, buffer.size());
+    EXPECT_EQ(0u, buffer.capacity());
+  }
+  {
+    int dummy;
+    MockBuffer<int> buffer(&dummy);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(0u, buffer.size());
+    EXPECT_EQ(0u, buffer.capacity());
+  }
+  {
+    int dummy;
+    std::size_t capacity = std::numeric_limits<std::size_t>::max();
+    MockBuffer<int> buffer(&dummy, capacity);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(0u, buffer.size());
+    EXPECT_EQ(capacity, buffer.capacity());
+  }
+}
+
+struct DyingBuffer : TestBuffer<int> {
+  MOCK_METHOD0(die, void());
+  ~DyingBuffer() { die(); }
+};
+
+TEST(BufferTest, VirtualDtor) {
+  typedef StrictMock<DyingBuffer> StictMockBuffer;
+  StictMockBuffer *mock_buffer = new StictMockBuffer();
+  EXPECT_CALL(*mock_buffer, die());
+  Buffer<int> *buffer = mock_buffer;
+  delete buffer;
+}
+
+TEST(BufferTest, Access) {
+  char data[10];
+  MockBuffer<char> buffer(data, sizeof(data));
+  buffer[0] = 11;
+  EXPECT_EQ(11, buffer[0]);
+  buffer[3] = 42;
+  EXPECT_EQ(42, *(&buffer[0] + 3));
+  const Buffer<char> &const_buffer = buffer;
+  EXPECT_EQ(42, const_buffer[3]);
+}
+
+TEST(BufferTest, Resize) {
+  char data[123];
+  MockBuffer<char> buffer(data, sizeof(data));
+  buffer[10] = 42;
+  EXPECT_EQ(42, buffer[10]);
+  buffer.resize(20);
+  EXPECT_EQ(20u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  buffer.resize(5);
+  EXPECT_EQ(5u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  // Check if resize calls grow.
+  EXPECT_CALL(buffer, do_grow(124));
+  buffer.resize(124);
+  EXPECT_CALL(buffer, do_grow(200));
+  buffer.resize(200);
+}
+
+TEST(BufferTest, Clear) {
+  TestBuffer<char> buffer;
+  buffer.resize(20);
+  buffer.clear();
+  EXPECT_EQ(0u, buffer.size());
+  EXPECT_EQ(20u, buffer.capacity());
+}
+
+TEST(BufferTest, PushBack) {
+  int data[15];
+  MockBuffer<int> buffer(data, 10);
+  buffer.push_back(11);
+  EXPECT_EQ(11, buffer[0]);
+  EXPECT_EQ(1u, buffer.size());
+  buffer.resize(10);
+  EXPECT_CALL(buffer, do_grow(11));
+  buffer.push_back(22);
+  EXPECT_EQ(22, buffer[10]);
+  EXPECT_EQ(11u, buffer.size());
+}
+
+TEST(BufferTest, Append) {
+  char data[15];
+  MockBuffer<char> buffer(data, 10);
+  const char *test = "test";
+  buffer.append(test, test + 5);
+  EXPECT_STREQ(test, &buffer[0]);
+  EXPECT_EQ(5u, buffer.size());
+  buffer.resize(10);
+  EXPECT_CALL(buffer, do_grow(12));
+  buffer.append(test, test + 2);
+  EXPECT_EQ('t', buffer[10]);
+  EXPECT_EQ('e', buffer[11]);
+  EXPECT_EQ(12u, buffer.size());
+}
+
+TEST(BufferTest, AppendAllocatesEnoughStorage) {
+  char data[19];
+  MockBuffer<char> buffer(data, 10);
+  const char *test = "abcdefgh";
+  buffer.resize(10);
+  EXPECT_CALL(buffer, do_grow(19));
+  buffer.append(test, test + 9);
+}
+
+TEST(MemoryBufferTest, Ctor) {
+  MemoryBuffer<char, 123> buffer;
+  EXPECT_EQ(0u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+}
+
+#if FMT_USE_RVALUE_REFERENCES
+
+typedef AllocatorRef< std::allocator<char> > TestAllocator;
+
+void check_move_buffer(const char *str,
+                       MemoryBuffer<char, 5, TestAllocator> &buffer) {
+  std::allocator<char> *alloc = buffer.get_allocator().get();
+  MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
+  // Move shouldn't destroy the inline content of the first buffer.
+  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+  EXPECT_EQ(5u, buffer2.capacity());
+  // Move should transfer allocator.
+  EXPECT_EQ(0, buffer.get_allocator().get());
+  EXPECT_EQ(alloc, buffer2.get_allocator().get());
+}
+
+TEST(MemoryBufferTest, MoveCtor) {
+  std::allocator<char> alloc;
+  MemoryBuffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  check_move_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_buffer("testa", buffer);
+  const char *inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('b');
+  MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
+  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
+  EXPECT_GT(buffer2.capacity(), 5u);
+}
+
+void check_move_assign_buffer(const char *str, MemoryBuffer<char, 5> &buffer) {
+  MemoryBuffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move shouldn't destroy the inline content of the first buffer.
+  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+  EXPECT_EQ(5u, buffer2.capacity());
+}
+
+TEST(MemoryBufferTest, MoveAssignment) {
+  MemoryBuffer<char, 5> buffer;
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  check_move_assign_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_assign_buffer("testa", buffer);
+  const char *inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('b');
+  MemoryBuffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
+  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
+  EXPECT_GT(buffer2.capacity(), 5u);
+}
+
+#endif  // FMT_USE_RVALUE_REFERENCES
+
+TEST(MemoryBufferTest, Grow) {
+  typedef AllocatorRef< MockAllocator<int> > Allocator;
+  typedef MemoryBuffer<int, 10, Allocator> Base;
+  MockAllocator<int> alloc;
+  struct TestMemoryBuffer : Base {
+    TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
+    void grow(std::size_t size) { Base::grow(size); }
+  } buffer((Allocator(&alloc)));
+  buffer.resize(7);
+  for (int i = 0; i < 7; ++i)
+    buffer[i] = i * i;
+  EXPECT_EQ(10u, buffer.capacity());
+  int mem[20];
+  mem[7] = 0xdead;
+  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
+  buffer.grow(20);
+  EXPECT_EQ(20u, buffer.capacity());
+  // Check if size elements have been copied
+  for (int i = 0; i < 7; ++i)
+    EXPECT_EQ(i * i, buffer[i]);
+  // and no more than that.
+  EXPECT_EQ(0xdead, buffer[7]);
+  EXPECT_CALL(alloc, deallocate(mem, 20));
+}
+
+TEST(MemoryBufferTest, Allocator) {
+  typedef AllocatorRef< MockAllocator<char> > TestAllocator;
+  MemoryBuffer<char, 10, TestAllocator> buffer;
+  EXPECT_EQ(0, buffer.get_allocator().get());
+  StrictMock< MockAllocator<char> > alloc;
+  char mem;
+  {
+    MemoryBuffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
+    EXPECT_EQ(&alloc, buffer2.get_allocator().get());
+    std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
+    buffer2.reserve(size);
+    EXPECT_CALL(alloc, deallocate(&mem, size));
+  }
+}
+
+TEST(MemoryBufferTest, ExceptionInDeallocate) {
+  typedef AllocatorRef< MockAllocator<char> > TestAllocator;
+  StrictMock< MockAllocator<char> > alloc;
+  MemoryBuffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
+  std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
+  std::vector<char> mem(size);
+  {
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
+    buffer.resize(size);
+    std::fill(&buffer[0], &buffer[0] + size, 'x');
+  }
+  std::vector<char> mem2(2 * size);
+  {
+    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
+    std::exception e;
+    EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
+    EXPECT_THROW(buffer.reserve(2 * size), std::exception);
+    EXPECT_EQ(&mem2[0], &buffer[0]);
+    // Check that the data has been copied.
+    for (std::size_t i = 0; i < size; ++i)
+      EXPECT_EQ('x', buffer[i]);
+  }
+  EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
+}
+
+TEST(UtilTest, Increment) {
+  char s[10] = "123";
+  increment(s);
+  EXPECT_STREQ("124", s);
+  s[2] = '8';
+  increment(s);
+  EXPECT_STREQ("129", s);
+  increment(s);
+  EXPECT_STREQ("130", s);
+  s[1] = s[2] = '9';
+  increment(s);
+  EXPECT_STREQ("200", s);
+}
+
+template <Arg::Type>
+struct ArgInfo;
+
+#define ARG_INFO(type_code, Type, field) \
+  template <> \
+  struct ArgInfo<Arg::type_code> { \
+    static Type get(const Arg &arg) { return arg.field; } \
+  };
+
+ARG_INFO(INT, int, int_value);
+ARG_INFO(UINT, unsigned, uint_value);
+ARG_INFO(LONG_LONG, fmt::LongLong, long_long_value);
+ARG_INFO(ULONG_LONG, fmt::ULongLong, ulong_long_value);
+ARG_INFO(BOOL, int, int_value);
+ARG_INFO(CHAR, int, int_value);
+ARG_INFO(DOUBLE, double, double_value);
+ARG_INFO(LONG_DOUBLE, long double, long_double_value);
+ARG_INFO(CSTRING, const char *, string.value);
+ARG_INFO(STRING, const char *, string.value);
+ARG_INFO(WSTRING, const wchar_t *, wstring.value);
+ARG_INFO(POINTER, const void *, pointer);
+ARG_INFO(CUSTOM, Arg::CustomValue, custom);
+
+#define CHECK_ARG_INFO(Type, field, value) { \
+  Arg arg = Arg(); \
+  arg.field = value; \
+  EXPECT_EQ(value, ArgInfo<Arg::Type>::get(arg)); \
+}
+
+TEST(ArgTest, ArgInfo) {
+  CHECK_ARG_INFO(INT, int_value, 42);
+  CHECK_ARG_INFO(UINT, uint_value, 42u);
+  CHECK_ARG_INFO(LONG_LONG, long_long_value, 42);
+  CHECK_ARG_INFO(ULONG_LONG, ulong_long_value, 42u);
+  CHECK_ARG_INFO(DOUBLE, double_value, 4.2);
+  CHECK_ARG_INFO(LONG_DOUBLE, long_double_value, 4.2);
+  CHECK_ARG_INFO(CHAR, int_value, 'x');
+  const char STR[] = "abc";
+  CHECK_ARG_INFO(CSTRING, string.value, STR);
+  const wchar_t WSTR[] = L"abc";
+  CHECK_ARG_INFO(WSTRING, wstring.value, WSTR);
+  int p = 0;
+  CHECK_ARG_INFO(POINTER, pointer, &p);
+  Arg arg = Arg();
+  arg.custom.value = &p;
+  EXPECT_EQ(&p, ArgInfo<Arg::CUSTOM>::get(arg).value);
+}
+
+#define EXPECT_ARG_(Char, type_code, MakeArgType, ExpectedType, value) { \
+  MakeArgType input = static_cast<MakeArgType>(value); \
+  Arg arg = make_arg<Char>(input); \
+  EXPECT_EQ(Arg::type_code, arg.type); \
+  ExpectedType expected_value = static_cast<ExpectedType>(value); \
+  EXPECT_EQ(expected_value, ArgInfo<Arg::type_code>::get(arg)); \
+}
+
+#define EXPECT_ARG(type_code, Type, value) \
+  EXPECT_ARG_(char, type_code, Type, Type, value)
+
+#define EXPECT_ARGW(type_code, Type, value) \
+  EXPECT_ARG_(wchar_t, type_code, Type, Type, value)
+
+TEST(ArgTest, MakeArg) {
+  // Test bool.
+  EXPECT_ARG_(char, BOOL, bool, int, true);
+  EXPECT_ARG_(wchar_t, BOOL, bool, int, true);
+
+  // Test char.
+  EXPECT_ARG(CHAR, char, 'a');
+  EXPECT_ARG(CHAR, char, CHAR_MIN);
+  EXPECT_ARG(CHAR, char, CHAR_MAX);
+
+  // Test wchar_t.
+  EXPECT_ARGW(CHAR, wchar_t, L'a');
+  EXPECT_ARGW(CHAR, wchar_t, WCHAR_MIN);
+  EXPECT_ARGW(CHAR, wchar_t, WCHAR_MAX);
+
+  // Test signed/unsigned char.
+  EXPECT_ARG(INT, signed char, 42);
+  EXPECT_ARG(INT, signed char, SCHAR_MIN);
+  EXPECT_ARG(INT, signed char, SCHAR_MAX);
+  EXPECT_ARG(UINT, unsigned char, 42);
+  EXPECT_ARG(UINT, unsigned char, UCHAR_MAX );
+
+  // Test short.
+  EXPECT_ARG(INT, short, 42);
+  EXPECT_ARG(INT, short, SHRT_MIN);
+  EXPECT_ARG(INT, short, SHRT_MAX);
+  EXPECT_ARG(UINT, unsigned short, 42);
+  EXPECT_ARG(UINT, unsigned short, USHRT_MAX);
+
+  // Test int.
+  EXPECT_ARG(INT, int, 42);
+  EXPECT_ARG(INT, int, INT_MIN);
+  EXPECT_ARG(INT, int, INT_MAX);
+  EXPECT_ARG(UINT, unsigned, 42);
+  EXPECT_ARG(UINT, unsigned, UINT_MAX);
+
+  // Test long.
+#if LONG_MAX == INT_MAX
+# define LONG INT
+# define ULONG UINT
+# define long_value int_value
+# define ulong_value uint_value
+#else
+# define LONG LONG_LONG
+# define ULONG ULONG_LONG
+# define long_value long_long_value
+# define ulong_value ulong_long_value
+#endif
+  EXPECT_ARG(LONG, long, 42);
+  EXPECT_ARG(LONG, long, LONG_MIN);
+  EXPECT_ARG(LONG, long, LONG_MAX);
+  EXPECT_ARG(ULONG, unsigned long, 42);
+  EXPECT_ARG(ULONG, unsigned long, ULONG_MAX);
+
+  // Test long long.
+  EXPECT_ARG(LONG_LONG, fmt::LongLong, 42);
+  EXPECT_ARG(LONG_LONG, fmt::LongLong, LLONG_MIN);
+  EXPECT_ARG(LONG_LONG, fmt::LongLong, LLONG_MAX);
+  EXPECT_ARG(ULONG_LONG, fmt::ULongLong, 42);
+  EXPECT_ARG(ULONG_LONG, fmt::ULongLong, ULLONG_MAX);
+
+  // Test float.
+  EXPECT_ARG(DOUBLE, float, 4.2);
+  EXPECT_ARG(DOUBLE, float, FLT_MIN);
+  EXPECT_ARG(DOUBLE, float, FLT_MAX);
+
+  // Test double.
+  EXPECT_ARG(DOUBLE, double, 4.2);
+  EXPECT_ARG(DOUBLE, double, DBL_MIN);
+  EXPECT_ARG(DOUBLE, double, DBL_MAX);
+
+  // Test long double.
+  EXPECT_ARG(LONG_DOUBLE, long double, 4.2);
+  EXPECT_ARG(LONG_DOUBLE, long double, LDBL_MIN);
+  EXPECT_ARG(LONG_DOUBLE, long double, LDBL_MAX);
+
+  // Test string.
+  char STR[] = "test";
+  EXPECT_ARG(CSTRING, char*, STR);
+  EXPECT_ARG(CSTRING, const char*, STR);
+  EXPECT_ARG(STRING, std::string, STR);
+  EXPECT_ARG(STRING, fmt::StringRef, STR);
+
+  // Test wide string.
+  wchar_t WSTR[] = L"test";
+  EXPECT_ARGW(WSTRING, wchar_t*, WSTR);
+  EXPECT_ARGW(WSTRING, const wchar_t*, WSTR);
+  EXPECT_ARGW(WSTRING, std::wstring, WSTR);
+  EXPECT_ARGW(WSTRING, fmt::WStringRef, WSTR);
+
+  int n = 42;
+  EXPECT_ARG(POINTER, void*, &n);
+  EXPECT_ARG(POINTER, const void*, &n);
+
+  ::Test t;
+  Arg arg = make_arg<char>(t);
+  EXPECT_EQ(fmt::internal::Arg::CUSTOM, arg.type);
+  EXPECT_EQ(&t, arg.custom.value);
+  fmt::MemoryWriter w;
+  fmt::BasicFormatter<char> formatter(fmt::ArgList(), w);
+  const char *s = "}";
+  arg.custom.format(&formatter, &t, &s);
+  EXPECT_EQ("test", w.str());
+}
+
+TEST(UtilTest, ArgList) {
+  fmt::ArgList args;
+  EXPECT_EQ(Arg::NONE, args[1].type);
+}
+
+struct Result {
+  Arg arg;
+
+  Result() : arg(make_arg<char>(0xdeadbeef)) {}
+
+  template <typename T>
+  Result(const T& value) : arg(make_arg<char>(value)) {}
+  Result(const wchar_t *s) : arg(make_arg<wchar_t>(s)) {}
+};
+
+struct TestVisitor : fmt::internal::ArgVisitor<TestVisitor, Result> {
+  Result visit_int(int value) { return value; }
+  Result visit_uint(unsigned value) { return value; }
+  Result visit_long_long(fmt::LongLong value) { return value; }
+  Result visit_ulong_long(fmt::ULongLong value) { return value; }
+  Result visit_double(double value) { return value; }
+  Result visit_long_double(long double value) { return value; }
+  Result visit_char(int value) { return static_cast<char>(value); }
+  Result visit_cstring(const char *s) { return s; }
+  Result visit_string(Arg::StringValue<char> s) { return s.value; }
+  Result visit_wstring(Arg::StringValue<wchar_t> s) { return s.value; }
+  Result visit_pointer(const void *p) { return p; }
+  Result visit_custom(Arg::CustomValue c) {
+    return *static_cast<const ::Test*>(c.value);
+  }
+};
+
+#define EXPECT_RESULT_(Char, type_code, value) { \
+  Arg arg = make_arg<Char>(value); \
+  Result result = TestVisitor().visit(arg); \
+  EXPECT_EQ(Arg::type_code, result.arg.type); \
+  EXPECT_EQ(value, ArgInfo<Arg::type_code>::get(result.arg)); \
+}
+
+#define EXPECT_RESULT(type_code, value) \
+  EXPECT_RESULT_(char, type_code, value)
+#define EXPECT_RESULTW(type_code, value) \
+  EXPECT_RESULT_(wchar_t, type_code, value)
+
+TEST(ArgVisitorTest, VisitAll) {
+  EXPECT_RESULT(INT, 42);
+  EXPECT_RESULT(UINT, 42u);
+  EXPECT_RESULT(LONG_LONG, 42ll);
+  EXPECT_RESULT(ULONG_LONG, 42ull);
+  EXPECT_RESULT(DOUBLE, 4.2);
+  EXPECT_RESULT(LONG_DOUBLE, 4.2l);
+  EXPECT_RESULT(CHAR, 'x');
+  const char STR[] = "abc";
+  EXPECT_RESULT(CSTRING, STR);
+  const wchar_t WSTR[] = L"abc";
+  EXPECT_RESULTW(WSTRING, WSTR);
+  const void *p = STR;
+  EXPECT_RESULT(POINTER, p);
+  ::Test t;
+  Result result = TestVisitor().visit(make_arg<char>(t));
+  EXPECT_EQ(Arg::CUSTOM, result.arg.type);
+  EXPECT_EQ(&t, result.arg.custom.value);
+}
+
+struct TestAnyVisitor : fmt::internal::ArgVisitor<TestAnyVisitor, Result> {
+  template <typename T>
+  Result visit_any_int(T value) { return value; }
+
+  template <typename T>
+  Result visit_any_double(T value) { return value; }
+};
+
+#undef EXPECT_RESULT
+#define EXPECT_RESULT(type_code, value) { \
+  Result result = TestAnyVisitor().visit(make_arg<char>(value)); \
+  EXPECT_EQ(Arg::type_code, result.arg.type); \
+  EXPECT_EQ(value, ArgInfo<Arg::type_code>::get(result.arg)); \
+}
+
+TEST(ArgVisitorTest, VisitAny) {
+  EXPECT_RESULT(INT, 42);
+  EXPECT_RESULT(UINT, 42u);
+  EXPECT_RESULT(LONG_LONG, 42ll);
+  EXPECT_RESULT(ULONG_LONG, 42ull);
+  EXPECT_RESULT(DOUBLE, 4.2);
+  EXPECT_RESULT(LONG_DOUBLE, 4.2l);
+}
+
+struct TestUnhandledVisitor :
+    fmt::internal::ArgVisitor<TestUnhandledVisitor, const char *> {
+  const char *visit_unhandled_arg() { return "test"; }
+};
+
+#define EXPECT_UNHANDLED(value) \
+  EXPECT_STREQ("test", TestUnhandledVisitor().visit(make_arg<wchar_t>(value)));
+
+TEST(ArgVisitorTest, VisitUnhandledArg) {
+  EXPECT_UNHANDLED(42);
+  EXPECT_UNHANDLED(42u);
+  EXPECT_UNHANDLED(42ll);
+  EXPECT_UNHANDLED(42ull);
+  EXPECT_UNHANDLED(4.2);
+  EXPECT_UNHANDLED(4.2l);
+  EXPECT_UNHANDLED('x');
+  const char STR[] = "abc";
+  EXPECT_UNHANDLED(STR);
+  const wchar_t WSTR[] = L"abc";
+  EXPECT_UNHANDLED(WSTR);
+  const void *p = STR;
+  EXPECT_UNHANDLED(p);
+  EXPECT_UNHANDLED(::Test());
+}
+
+TEST(ArgVisitorTest, VisitInvalidArg) {
+  Arg arg = Arg();
+  arg.type = static_cast<Arg::Type>(Arg::CUSTOM + 1);
+  EXPECT_ASSERT(TestVisitor().visit(arg), "invalid argument type");
+}
+
+// Tests fmt::internal::count_digits for integer type Int.
+template <typename Int>
+void test_count_digits() {
+  for (Int i = 0; i < 10; ++i)
+    EXPECT_EQ(1u, fmt::internal::count_digits(i));
+  for (Int i = 1, n = 1,
+      end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
+    n *= 10;
+    EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
+    EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
+  }
+}
+
+TEST(UtilTest, StringRef) {
+  // Test that StringRef::size() returns string length, not buffer size.
+  char str[100] = "some string";
+  EXPECT_EQ(std::strlen(str), StringRef(str).size());
+  EXPECT_LT(std::strlen(str), sizeof(str));
+}
+
+// Check StringRef's comparison operator.
+template <template <typename> class Op>
+void CheckOp() {
+  const char *inputs[] = {"foo", "fop", "fo"};
+  std::size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
+  for (std::size_t i = 0; i < num_inputs; ++i) {
+    for (std::size_t j = 0; j < num_inputs; ++j) {
+      StringRef lhs(inputs[i]), rhs(inputs[j]);
+      EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<StringRef>()(lhs, rhs));
+    }
+  }
+}
+
+TEST(UtilTest, StringRefCompare) {
+  EXPECT_EQ(0, StringRef("foo").compare(StringRef("foo")));
+  EXPECT_GT(StringRef("fop").compare(StringRef("foo")), 0);
+  EXPECT_LT(StringRef("foo").compare(StringRef("fop")), 0);
+  EXPECT_GT(StringRef("foo").compare(StringRef("fo")), 0);
+  EXPECT_LT(StringRef("fo").compare(StringRef("foo")), 0);
+  CheckOp<std::equal_to>();
+  CheckOp<std::not_equal_to>();
+  CheckOp<std::less>();
+  CheckOp<std::less_equal>();
+  CheckOp<std::greater>();
+  CheckOp<std::greater_equal>();
+}
+
+TEST(UtilTest, CountDigits) {
+  test_count_digits<uint32_t>();
+  test_count_digits<uint64_t>();
+}
+
+#ifdef _WIN32
+TEST(UtilTest, UTF16ToUTF8) {
+  std::string s = "ёжик";
+  fmt::internal::UTF16ToUTF8 u(L"\x0451\x0436\x0438\x043A");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+TEST(UtilTest, UTF8ToUTF16) {
+  std::string s = "лошадка";
+  fmt::internal::UTF8ToUTF16 u(s.c_str());
+  EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
+  EXPECT_EQ(7, u.size());
+}
+
+template <typename Converter, typename Char>
+void check_utf_conversion_error(
+        const char *message,
+        fmt::BasicStringRef<Char> str = fmt::BasicStringRef<Char>(0, 0)) {
+  fmt::MemoryWriter out;
+  fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
+  fmt::SystemError error(0, "");
+  try {
+    (Converter)(str);
+  } catch (const fmt::SystemError &e) {
+    error = e;
+  }
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
+  EXPECT_EQ(out.str(), error.what());
+}
+
+TEST(UtilTest, UTF16ToUTF8Error) {
+  check_utf_conversion_error<fmt::internal::UTF16ToUTF8, wchar_t>(
+      "cannot convert string from UTF-16 to UTF-8");
+}
+
+TEST(UtilTest, UTF8ToUTF16Error) {
+  const char *message = "cannot convert string from UTF-8 to UTF-16";
+  check_utf_conversion_error<fmt::internal::UTF8ToUTF16, char>(message);
+  check_utf_conversion_error<fmt::internal::UTF8ToUTF16, char>(
+    message, fmt::StringRef("foo", INT_MAX + 1u));
+}
+
+TEST(UtilTest, UTF16ToUTF8Convert) {
+  fmt::internal::UTF16ToUTF8 u;
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::WStringRef(0, 0)));
+  EXPECT_EQ(ERROR_INVALID_PARAMETER,
+            u.convert(fmt::WStringRef(L"foo", INT_MAX + 1u)));
+}
+#endif  // _WIN32
+
+typedef void (*FormatErrorMessage)(
+        fmt::Writer &out, int error_code, StringRef message);
+
+template <typename Error>
+void check_throw_error(int error_code, FormatErrorMessage format) {
+  fmt::SystemError error(0, "");
+  try {
+    throw Error(error_code, "test {}", "error");
+  } catch (const fmt::SystemError &e) {
+    error = e;
+  }
+  fmt::MemoryWriter message;
+  format(message, error_code, "test error");
+  EXPECT_EQ(message.str(), error.what());
+  EXPECT_EQ(error_code, error.error_code());
+}
+
+TEST(UtilTest, FormatSystemError) {
+  fmt::MemoryWriter message;
+  fmt::internal::format_system_error(message, EDOM, "test");
+  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), message.str());
+  message.clear();
+  fmt::internal::format_system_error(
+        message, EDOM, fmt::StringRef(0, std::numeric_limits<size_t>::max()));
+  EXPECT_EQ(fmt::format("error {}", EDOM), message.str());
+}
+
+TEST(UtilTest, SystemError) {
+  fmt::SystemError e(EDOM, "test");
+  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
+  EXPECT_EQ(EDOM, e.error_code());
+  check_throw_error<fmt::SystemError>(EDOM, fmt::internal::format_system_error);
+}
+
+TEST(UtilTest, ReportSystemError) {
+  fmt::MemoryWriter out;
+  fmt::internal::format_system_error(out, EDOM, "test error");
+  out << '\n';
+  EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"), out.str());
+}
+
+#ifdef _WIN32
+
+TEST(UtilTest, FormatWindowsError) {
+  LPWSTR message = 0;
+  FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
+      ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, 0);
+  fmt::internal::UTF16ToUTF8 utf8_message(message);
+  LocalFree(message);
+  fmt::MemoryWriter actual_message;
+  fmt::internal::format_windows_error(
+      actual_message, ERROR_FILE_EXISTS, "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+      actual_message.str());
+  actual_message.clear();
+  fmt::internal::format_windows_error(
+        actual_message, ERROR_FILE_EXISTS,
+        fmt::StringRef(0, std::numeric_limits<size_t>::max()));
+  EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS), actual_message.str());
+}
+
+TEST(UtilTest, WindowsError) {
+  check_throw_error<fmt::WindowsError>(
+      ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
+}
+
+TEST(UtilTest, ReportWindowsError) {
+  fmt::MemoryWriter out;
+  fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
+  out << '\n';
+  EXPECT_WRITE(stderr,
+      fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"), out.str());
+}
+
+#endif  // _WIN32
+
+enum TestEnum2 {};
+enum TestEnum3 {};
+std::ostream &operator<<(std::ostream &, TestEnum3);
+
+TEST(UtilTest, ConvertToInt) {
+  EXPECT_TRUE(fmt::internal::ConvertToInt<char>::enable_conversion);
+  EXPECT_FALSE(fmt::internal::ConvertToInt<const char *>::enable_conversion);
+  EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum2>::value);
+  EXPECT_FALSE(fmt::internal::ConvertToInt<TestEnum3>::value);
+}
+
+#if FMT_USE_ENUM_BASE
+enum TestEnum : char {TestValue};
+TEST(UtilTest, IsEnumConvertibleToInt) {
+  EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum>::enable_conversion);
+}
+#endif
+
+template <typename T>
+bool check_enable_if(
+    typename fmt::internal::EnableIf<sizeof(T) == sizeof(int), T>::type *) {
+  return true;
+}
+
+template <typename T>
+bool check_enable_if(
+    typename fmt::internal::EnableIf<sizeof(T) != sizeof(int), T>::type *) {
+  return false;
+}
+
+TEST(UtilTest, EnableIf) {
+  int i = 0;
+  EXPECT_TRUE(check_enable_if<int>(&i));
+  char c = 0;
+  EXPECT_FALSE(check_enable_if<char>(&c));
+}
+
+TEST(UtilTest, Conditional) {
+  int i = 0;
+  fmt::internal::Conditional<true, int, char>::type *pi = &i;
+  (void)pi;
+  char c = 0;
+  fmt::internal::Conditional<false, int, char>::type *pc = &c;
+  (void)pc;
+}

test/util.cc

@@ -1,9 +1,29 @@
-// Formatting library for C++ - test utilities
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Test utilities.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include "util.h"
 #include <cstring>
@@ -32,12 +52,12 @@ std::string get_system_error(int error_code) {
 
 const char *const FILE_CONTENT = "Don't panic!";
 
-fmt::buffered_file open_buffered_file(FILE **fp) {
-  fmt::file read_end, write_end;
-  fmt::file::pipe(read_end, write_end);
+fmt::BufferedFile open_buffered_file(FILE **fp) {
+  fmt::File read_end, write_end;
+  fmt::File::pipe(read_end, write_end);
   write_end.write(FILE_CONTENT, std::strlen(FILE_CONTENT));
   write_end.close();
-  fmt::buffered_file f = read_end.fdopen("r");
+  fmt::BufferedFile f = read_end.fdopen("r");
   if (fp)
     *fp = f.get();
   return f;

test/util.h

@@ -1,15 +1,35 @@
-// Formatting library for C++ - test utilities
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
+/*
+ Test utilities.
+
+ Copyright (c) 2012-2014, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include <cstdarg>
 #include <cstdio>
 #include <string>
 
-#include "fmt/posix.h"
+#include "cppformat/posix.h"
 
 enum {BUFFER_SIZE = 256};
 
@@ -35,7 +55,7 @@ std::string get_system_error(int error_code);
 extern const char *const FILE_CONTENT;
 
 // Opens a buffered file for reading.
-fmt::buffered_file open_buffered_file(FILE **fp = FMT_NULL);
+fmt::BufferedFile open_buffered_file(FILE **fp = 0);
 
 inline FILE *safe_fopen(const char *filename, const char *mode) {
 #if defined(_WIN32) && !defined(__MINGW32__)
@@ -58,7 +78,11 @@ class BasicTestString {
  public:
   explicit BasicTestString(const Char *value = EMPTY) : value_(value) {}
 
-  const std::basic_string<Char> &value() const { return value_; }
+  friend std::basic_ostream<Char> &operator<<(
+      std::basic_ostream<Char> &os, const BasicTestString &s) {
+    os << s.value_;
+    return os;
+  }
 };
 
 template <typename Char>
@@ -66,20 +90,3 @@ const Char BasicTestString<Char>::EMPTY[] = {0};
 
 typedef BasicTestString<char> TestString;
 typedef BasicTestString<wchar_t> TestWString;
-
-template <typename Char>
-std::basic_ostream<Char> &operator<<(
-    std::basic_ostream<Char> &os, const BasicTestString<Char> &s) {
-  os << s.value();
-  return os;
-}
-
-class Date {
-  int year_, month_, day_;
- public:
-  Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
-
-  int year() const { return year_; }
-  int month() const { return month_; }
-  int day() const { return day_; }
-};