Convert COMPILE_ASSERT to static_assert

util/stdlib/string_number_conversion.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/stdlib/string_number_conversion.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <limits>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "util/stdlib/cxx.h"
 
-// CONSTEXPR_COMPILE_ASSERT will be a normal COMPILE_ASSERT if the C++ library
-// is the C++11 library. If using an older C++ library when compiling C++11
-// code, the std::numeric_limits<>::min() and max() functions will not be
-// marked as constexpr, and thus won’t be usable with C++11’s static_assert().
-// In that case, a run-time CHECK() will have to do.
+// CONSTEXPR_STATIC_ASSERT will be a normal static_assert if the C++ library is
+// the C++11 library. If using an older C++ library when compiling C++11 code,
+// the std::numeric_limits<>::min() and max() functions will not be marked as
+// constexpr, and thus won’t be usable with C++11’s static_assert(). In that
+// case, a run-time CHECK() will have to do.
 #if CXX_LIBRARY_VERSION >= 2011
-#define CONSTEXPR_COMPILE_ASSERT(condition, message) \
-  COMPILE_ASSERT(condition, message)
+#define CONSTEXPR_STATIC_ASSERT(condition, message) \
+  static_assert(condition, message)
 #else
-#define CONSTEXPR_COMPILE_ASSERT(condition, message) CHECK(condition)
+#define CONSTEXPR_STATIC_ASSERT(condition, message) CHECK(condition) << message
 #endif
 
 namespace {
 
 template <typename TIntType, typename TLongType>
 struct StringToIntegerTraits {
   typedef TIntType IntType;
   typedef TLongType LongType;
   static void TypeCheck() {
-    COMPILE_ASSERT(std::numeric_limits<TIntType>::is_integer &&
-                       std::numeric_limits<TLongType>::is_integer,
-                   IntType_and_LongType_must_be_integer);
-    COMPILE_ASSERT(std::numeric_limits<TIntType>::is_signed ==
-                       std::numeric_limits<TLongType>::is_signed,
-                   IntType_and_LongType_signedness_must_agree);
-    CONSTEXPR_COMPILE_ASSERT(std::numeric_limits<TIntType>::min() >=
-                                     std::numeric_limits<TLongType>::min() &&
-                                 std::numeric_limits<TIntType>::min() <
-                                     std::numeric_limits<TLongType>::max(),
-                             IntType_min_must_be_in_LongType_range);
-    CONSTEXPR_COMPILE_ASSERT(std::numeric_limits<TIntType>::max() >
-                                     std::numeric_limits<TLongType>::min() &&
-                                 std::numeric_limits<TIntType>::max() <=
-                                     std::numeric_limits<TLongType>::max(),
-                             IntType_max_must_be_in_LongType_range);
+    static_assert(std::numeric_limits<TIntType>::is_integer &&
+                      std::numeric_limits<TLongType>::is_integer,
+                  "IntType and LongType must be integer");
+    static_assert(std::numeric_limits<TIntType>::is_signed ==
+                      std::numeric_limits<TLongType>::is_signed,
+                  "IntType and LongType signedness must agree");
+    CONSTEXPR_STATIC_ASSERT(std::numeric_limits<TIntType>::min() >=
+                                    std::numeric_limits<TLongType>::min() &&
+                                std::numeric_limits<TIntType>::min() <
+                                    std::numeric_limits<TLongType>::max(),
+                            "IntType min must be in LongType range");
+    CONSTEXPR_STATIC_ASSERT(std::numeric_limits<TIntType>::max() >
+                                    std::numeric_limits<TLongType>::min() &&
+                                std::numeric_limits<TIntType>::max() <=
+                                    std::numeric_limits<TLongType>::max(),
+                            "IntType max must be in LongType range");
   }
 };
 
 template <typename TIntType, typename TLongType>
 struct StringToSignedIntegerTraits
     : public StringToIntegerTraits<TIntType, TLongType> {
   static void TypeCheck() {
-    COMPILE_ASSERT(std::numeric_limits<TIntType>::is_signed,
-                   StringToSignedTraits_IntType_must_be_signed);
+    static_assert(std::numeric_limits<TIntType>::is_signed,
+                  "StringToSignedTraits IntType must be signed");
     return super::TypeCheck();
   }
   static bool IsNegativeOverflow(TLongType value) {
     return value < std::numeric_limits<TIntType>::min();
   }
 
  private:
   typedef StringToIntegerTraits<TIntType, TLongType> super;
 };
 
 template <typename TIntType, typename TLongType>
 struct StringToUnsignedIntegerTraits
     : public StringToIntegerTraits<TIntType, TLongType> {
   static void TypeCheck() {
-    COMPILE_ASSERT(!std::numeric_limits<TIntType>::is_signed,
-                   StringToUnsignedTraits_IntType_must_be_unsigned);
+    static_assert(!std::numeric_limits<TIntType>::is_signed,
+                  "StringToUnsignedTraits IntType must be unsigned");
     return super::TypeCheck();
   }
   static bool IsNegativeOverflow(TLongType value) { return false; }
 
  private:
   typedef StringToIntegerTraits<TIntType, TLongType> super;
 };
 
 struct StringToIntTraits : public StringToSignedIntegerTraits<int, long> {
   static LongType Convert(const char* str, char** end, int base) {
@@ skipping 50 matching lines @@
 
 bool StringToNumber(const base::StringPiece& string, int* number) {
   return StringToIntegerInternal<StringToIntTraits>(string, number);
 }
 
 bool StringToNumber(const base::StringPiece& string, unsigned int* number) {
   return StringToIntegerInternal<StringToUnsignedIntTraits>(string, number);
 }
 
 }  // namespace crashpad