Apply clang format and other minor formatting tweaks

CMakeLists.txt

@@ -192,7 +192,7 @@ if (BUILD_SHARED_LIBS)
   target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
 endif ()
 if (FMT_SAFE_DURATION_CAST)
-    target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
+  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
 endif()
 
 add_library(fmt-header-only INTERFACE)
@@ -275,7 +275,7 @@ if (FMT_TEST)
   add_subdirectory(test)
 endif ()
 
-# control fuzzing independent of the unit tests
+# Control fuzzing independent of the unit tests.
 if (FMT_FUZZ)
   add_subdirectory(test/fuzzing)
 endif ()

support/travis-build.py

@@ -90,7 +90,7 @@ def install_dependencies():
     '-DCMAKE_CXX_STANDARD=' + standard
 ]
 
-# make sure the fuzzers still compile
+# Make sure the fuzzers still compile.
 if 'ENABLE_FUZZING' in os.environ:
     cmake_flags += ['-DFMT_FUZZ=ON', '-DFMT_FUZZ_LINKMAIN=On']
 

test/fuzzing/CMakeLists.txt

@@ -6,33 +6,33 @@
 # (note that libFuzzer can also reproduce, just pass it the files)
 option(FMT_FUZZ_LINKMAIN "enables the reproduce mode, instead of libFuzzer" On)
 
-#for oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
-#the fuzz targets, otherwise the cmake configuration step fails.
+# For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
+# the fuzz targets, otherwise the cmake configuration step fails.
 set(FMT_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")
 
-#find all fuzzers.
+# Find all fuzzers.
 set(SOURCES
-chrono_duration.cpp
-named_arg.cpp
-one_arg.cpp
-sprintf.cpp
-two_args.cpp
+  chrono_duration.cpp
+  named_arg.cpp
+  one_arg.cpp
+  sprintf.cpp
+  two_args.cpp
 )
 
 macro(implement_fuzzer sourcefile)
   get_filename_component(basename ${sourcefile} NAME_WE)
   set(name fuzzer_${basename})
   add_executable(${name} ${sourcefile} fuzzer_common.h)
-  if(FMT_FUZZ_LINKMAIN)
+  if (FMT_FUZZ_LINKMAIN)
       target_sources(${name} PRIVATE main.cpp)
-  endif()
+  endif ()
   target_link_libraries(${name} PRIVATE fmt)
-if(FMT_FUZZ_LDFLAGS)
+if (FMT_FUZZ_LDFLAGS)
   target_link_libraries(${name} PRIVATE ${FMT_FUZZ_LDFLAGS})
-endif()
+endif ()
   target_compile_features(${name} PRIVATE cxx_generic_lambdas)
-endmacro()
+endmacro ()
 
-foreach(X IN ITEMS ${SOURCES})
-    implement_fuzzer(${X})
-endforeach()
+foreach (X IN ITEMS ${SOURCES})
+  implement_fuzzer(${X})
+endforeach ()

test/fuzzing/README.md

@@ -1,18 +1,27 @@
 # FMT Fuzzer
-Fuzzing has revealed [several bugs](https://github.com/fmtlib/fmt/issues?&q=is%3Aissue+fuzz) in fmt. It is a part of the continous fuzzing at [oss-fuzz](https://github.com/google/oss-fuzz)
 
-The source code is modified to make the fuzzing possible without locking up on resource exhaustion:
+Fuzzing has revealed [several bugs](https://github.com/fmtlib/fmt/issues?&q=is%3Aissue+fuzz)
+in fmt. It is a part of the continous fuzzing at
+[oss-fuzz](https://github.com/google/oss-fuzz).
+
+The source code is modified to make the fuzzing possible without locking up on
+resource exhaustion:
 ```cpp
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 if(spec.precision>100000) {
- throw std::runtime_error("fuzz mode - avoiding large precision");
+  throw std::runtime_error("fuzz mode - avoiding large precision");
 }
 #endif
 ```
-This macro is the defacto standard for making fuzzing practically possible, see [the libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode).
+This macro is the defacto standard for making fuzzing practically possible, see
+[the libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode).
 
 ## Running the fuzzers locally
-There is a [helper script](build.sh) to build the fuzzers, which has only been tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on Windows (using clang>=8) or on Mac, but the script will probably not work out of the box.
+
+There is a [helper script](build.sh) to build the fuzzers, which has only been
+tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on
+Windows (using clang>=8) or on Mac, but the script will probably not work out of
+the box.
 
 Something along
 ```sh

test/fuzzing/fuzzer_common.h

@@ -4,9 +4,9 @@
 // Copyright (c) 2019, Paul Dreik
 // License: see LICENSE.rst in the fmt root directory
 
-#include <cstring>     // memcpy
-#include <type_traits> // trivially copyable
-#include <cstdint>     // std::uint8_t
+#include <cstdint>      // std::uint8_t
+#include <cstring>      // memcpy
+#include <type_traits>  // trivially copyable
 
 // one can format to either a string, or a buf. buf is faster,
 // but one may be interested in formatting to a string instead to
@@ -25,36 +25,33 @@
 // is likely interesting.
 // For this, we must know the size of the largest possible type in use.
 
-// There are some problems on travis, claiming Nfixed is not a constant expression
-// which seems to be an issue with older versions of libstdc++
-#if  _GLIBCXX_RELEASE >= 7
-# include <algorithm>
+// There are some problems on travis, claiming Nfixed is not a constant
+// expression which seems to be an issue with older versions of libstdc++
+#if _GLIBCXX_RELEASE >= 7
+#  include <algorithm>
 namespace fmt_fuzzer {
-  constexpr auto Nfixed = std::max(sizeof(long double), sizeof(std::intmax_t));
+constexpr auto Nfixed = std::max(sizeof(long double), sizeof(std::intmax_t));
 }
 #else
 namespace fmt_fuzzer {
-  constexpr auto Nfixed=16;
+constexpr auto Nfixed = 16;
 }
 #endif
 
 namespace fmt_fuzzer {
 // view data as a c char pointer.
-template <typename T>
-inline const char* as_chars(const T* data) {
-    return static_cast<const char*>(static_cast<const void*>(data));
+template <typename T> inline const char* as_chars(const T* data) {
+  return static_cast<const char*>(static_cast<const void*>(data));
 }
 
 // view data as a byte pointer
-template <typename T>
-inline const std::uint8_t* as_bytes(const T* data) {
-    return static_cast<const std::uint8_t*>(static_cast<const void*>(data));
+template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
+  return static_cast<const std::uint8_t*>(static_cast<const void*>(data));
 }
 
 // blits bytes from Data to form an (assumed trivially constructible) object
 // of type Item
-template <class Item>
-inline Item assignFromBuf(const std::uint8_t* Data) {
+template <class Item> inline Item assignFromBuf(const std::uint8_t* Data) {
   Item item{};
   std::memcpy(&item, Data, sizeof(Item));
   return item;
@@ -65,7 +62,6 @@ template <> inline bool assignFromBuf<bool>(const std::uint8_t* Data) {
   return !!Data[0];
 }
 
-} // namespace fmt_fuzzer
+}  // namespace fmt_fuzzer
 
-
-#endif // FUZZER_COMMON_H
+#endif  // FUZZER_COMMON_H

test/fuzzing/main.cpp

@@ -11,7 +11,7 @@ int main(int argc, char* argv[]) {
     assert(in);
     in.seekg(0, std::ios_base::end);
     const auto pos = in.tellg();
-    assert(pos>=0);
+    assert(pos >= 0);
     in.seekg(0, std::ios_base::beg);
     std::vector<char> buf(static_cast<std::size_t>(pos));
     in.read(buf.data(), static_cast<long>(buf.size()));

test/fuzzing/named_arg.cpp

@@ -12,7 +12,7 @@
 template <typename Item1>
 void invoke_fmt(const uint8_t* Data, std::size_t Size, unsigned int argsize) {
   constexpr auto N1 = sizeof(Item1);
-  static_assert (N1<=fmt_fuzzer::Nfixed,"Nfixed too small");
+  static_assert(N1 <= fmt_fuzzer::Nfixed, "Nfixed too small");
   if (Size <= fmt_fuzzer::Nfixed) {
     return;
   }
@@ -126,4 +126,3 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
   }
   return 0;
 }
-

test/fuzzing/one_arg.cpp

@@ -15,7 +15,7 @@ using fmt_fuzzer::Nfixed;
 template <typename Item>
 void invoke_fmt(const uint8_t* Data, std::size_t Size) {
   constexpr auto N = sizeof(Item);
-  static_assert (N<=Nfixed,"Nfixed is too small");
+  static_assert(N <= Nfixed, "Nfixed is too small");
   if (Size <= Nfixed) {
     return;
   }
@@ -43,7 +43,7 @@ void invoke_fmt(const uint8_t* Data, std::size_t Size) {
 void invoke_fmt_time(const uint8_t* Data, std::size_t Size) {
   using Item = std::time_t;
   constexpr auto N = sizeof(Item);
-  static_assert (N<=Nfixed,"Nfixed too small");
+  static_assert(N <= Nfixed, "Nfixed too small");
   if (Size <= Nfixed) {
     return;
   }

test/fuzzing/two_args.cpp

@@ -7,7 +7,7 @@
 
 #include "fuzzer_common.h"
 
-constexpr auto Nfixed=fmt_fuzzer::Nfixed;
+constexpr auto Nfixed = fmt_fuzzer::Nfixed;
 
 template <typename Item1, typename Item2>
 void invoke_fmt(const uint8_t* Data, std::size_t Size) {
@@ -18,11 +18,11 @@ void invoke_fmt(const uint8_t* Data, std::size_t Size) {
   if (Size <= Nfixed + Nfixed) {
     return;
   }
-  const Item1 item1=fmt_fuzzer::assignFromBuf<Item1>(Data);
+  const Item1 item1 = fmt_fuzzer::assignFromBuf<Item1>(Data);
   Data += Nfixed;
   Size -= Nfixed;
 
-  const Item2 item2=fmt_fuzzer::assignFromBuf<Item2>(Data);
+  const Item2 item2 = fmt_fuzzer::assignFromBuf<Item2>(Data);
   Data += Nfixed;
   Size -= Nfixed;