made code compile under windows with level 4 warnings

format.cc

@@ -84,6 +84,7 @@ using fmt::internal::Arg;
 #if _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4127)  // conditional expression is constant
+# pragma warning(disable: 4702)  // unreachable code
 #endif
 
 namespace {
@@ -239,6 +240,8 @@ void check_sign(const Char *&s, const Arg &arg) {
 // left alignment if it is negative.
 class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> {
  private:
+  WidthHandler& operator=(WidthHandler const&); //no impl
+
   fmt::FormatSpec &spec_;
 
  public:
@@ -283,6 +286,8 @@ class PrecisionHandler :
 template <typename T>
 class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
  private:
+  ArgConverter& operator=(ArgConverter const&); //no impl
+
   fmt::internal::Arg &arg_;
   wchar_t type_;
 
@@ -321,6 +326,7 @@ class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
 // Converts an integer argument to char for printf.
 class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
  private:
+  CharConverter& operator=(CharConverter const&); // no impl
   fmt::internal::Arg &arg_;
 
  public:
@@ -525,6 +531,8 @@ template <typename Char>
 class fmt::internal::ArgFormatter :
     public fmt::internal::ArgVisitor<fmt::internal::ArgFormatter<Char>, void> {
  private:
+  ArgFormatter& operator=(ArgFormatter const&); // no impl
+
   fmt::BasicFormatter<Char> &formatter_;
   fmt::BasicWriter<Char> &writer_;
   fmt::FormatSpec &spec_;
@@ -1124,6 +1132,24 @@ template int fmt::internal::CharTraits<wchar_t>::format_float(
     wchar_t *buffer, std::size_t size, const wchar_t *format,
     unsigned width, int precision, long double value);
 
+template <> template <> char* fmt::BasicWriter<char>::append_float_length<float>( char* format_ptr) { return format_ptr; }
+template <> template <> wchar_t* fmt::BasicWriter<wchar_t>::append_float_length<float>( wchar_t* format_ptr) { return format_ptr; }
+
+template <> template <> char* fmt::BasicWriter<char>::append_float_length<double>( char* format_ptr) { return format_ptr; }
+template <> template <> wchar_t* fmt::BasicWriter<wchar_t>::append_float_length<double>( wchar_t* format_ptr) { return format_ptr; }
+
+template <> template <> char* fmt::BasicWriter<char>::append_float_length<long double>( char* format_ptr)
+{
+    *format_ptr++ = 'L';
+    return format_ptr;
+}
+
+template <> template <> wchar_t* fmt::BasicWriter<wchar_t>::append_float_length<long double>( wchar_t* format_ptr)
+{
+    *format_ptr++ = 'L';
+    return format_ptr;
+}
+
 #if _MSC_VER
 # pragma warning(pop)
 #endif

format.h

@@ -407,13 +407,16 @@ inline int getsign(double value) {
   return sign;
 }
 inline int isinfinity(double x) { return !_finite(x); }
+inline int isinfinity( long double x) { return !_finite(static_cast<double>(x)); }
 #endif
 
+/*
 template <typename T>
 struct IsLongDouble { enum {VALUE = 0}; };
 
 template <>
 struct IsLongDouble<long double> { enum {VALUE = 1}; };
+*/
 
 template <typename Char>
 class BasicCharTraits {
@@ -996,6 +999,8 @@ class PrintfFormatter : private FormatterBase {
 template <typename Char>
 class BasicFormatter : private internal::FormatterBase {
  private:
+  BasicFormatter& operator=(BasicFormatter const&); // no impl
+
   BasicWriter<Char> &writer_;
   const Char *start_;
 
@@ -1496,6 +1501,9 @@ class BasicWriter {
   // Do not implement!
   void operator<<(typename internal::CharTraits<Char>::UnsupportedStrType);
 
+  template<typename T>
+  Char* append_float_length(Char* format_ptr);
+
   friend class internal::ArgFormatter<Char>;
   friend class internal::PrintfFormatter<Char>;
 
@@ -1926,8 +1934,8 @@ void BasicWriter<Char>::write_double(
     *format_ptr++ = '.';
     *format_ptr++ = '*';
   }
-  if (internal::IsLongDouble<T>::VALUE)
-    *format_ptr++ = 'L';
+
+  format_ptr = append_float_length<T>(format_ptr);
   *format_ptr++ = type;
   *format_ptr = '\0';