Use non C++11 version of SafeSNPrintf() when building with gcc

base/strings/safe_sprintf.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_STRINGS_SAFE_SPRINTF_H_
 #define BASE_STRINGS_SAFE_SPRINTF_H_
 
 #include "build/build_config.h"
 
 #include <stddef.h>
@@ skipping 172 matching lines @@
 #if !defined(NDEBUG)
 // In debug builds, allow unit tests to artificially lower the kSSizeMax
 // constant that is used as a hard upper-bound for all buffers. In normal
 // use, this constant should always be std::numeric_limits<ssize_t>::max().
 BASE_EXPORT void SetSafeSPrintfSSizeMaxForTest(size_t max);
 BASE_EXPORT size_t GetSafeSPrintfSSizeMaxForTest();
 #endif
 
 }  // namespace internal
 
-#if __cplusplus >= 201103  // C++11

[Nico, 2013/12/05 21:11:35]

Huh where did that come from? We should probably delete this block.

[Inactive, 2013/12/05 21:15:15]

Hmm. This is a bit more readable than the non-C++11 alternative. I think the
idea was to switch everyone to that code once all compilers support it.

+#if __cplusplus >= 201103 && !defined(COMPILER_GCC) // C++11
+
+// The following does not build with gcc yet.
 
 template<typename... Args>
 ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args... args) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
   const internal::Arg arg_array[] = { args... };
   return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
 }
 
 template<size_t N, typename... Args>
 ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, Args... args) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
   const internal::Arg arg_array[] = { args... };
   return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
 }
 
 #else  // Pre-C++11
 
 // TODO(markus): C++11 has a much more concise and readable solution for

[Inactive, 2013/12/05 21:15:15]

See this comment as well.

 //   expressing what we are doing here. Delete the fall-back code for older
 //   compilers as soon as we have fully switched to C++11.
 
 template<class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
 ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
                      T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
                      T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
@@ skipping 208 matching lines @@
 BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt);
 template<size_t N>
 inline ssize_t SafeSPrintf(char (&buf)[N], const char* fmt) {
   return SafeSNPrintf(buf, N, fmt);
 }
 
 }  // namespace strings
 }  // namespace base
 
 #endif  // BASE_STRINGS_SAFE_SPRINTF_H_