Add compiler-specific "examine printf format" attributes to printfs.

base/string_util.h

 // Copyright (c) 2006-2008 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.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRING_UTIL_H_
 #define BASE_STRING_UTIL_H_
 
 #include <stdarg.h>   // va_list
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/string16.h"
 #include "base/string_piece.h"  // For implicit conversions.
 
 // TODO(brettw) this dependency should be removed and callers that need
 // these functions should include this file directly.
 #include "base/utf_string_conversions.h"
 
 // Safe standard library wrappers for all platforms.
 
 namespace base {
 
 // C standard-library functions like "strncasecmp" and "snprintf" that aren't
 // cross-platform are provided as "base::strncasecmp", and their prototypes
 // are listed below.  These functions are then implemented as inline calls
 // to the platform-specific equivalents in the platform-specific headers.
 
 // Compare the two strings s1 and s2 without regard to case using
 // the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
 // s2 > s1 according to a lexicographic comparison.
 int strcasecmp(const char* s1, const char* s2);
 
 // Compare up to count characters of s1 and s2 without regard to case using
 // the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
 // s2 > s1 according to a lexicographic comparison.
 int strncasecmp(const char* s1, const char* s2, size_t count);
 
 // Wrapper for vsnprintf that always null-terminates and always returns the
 // number of characters that would be in an untruncated formatted
 // string, even when truncation occurs.
-int vsnprintf(char* buffer, size_t size, const char* format, va_list arguments);
+int vsnprintf(char* buffer, size_t size, const char* format, va_list arguments)
+    PRINTF_FORMAT(3, 0);
 
 // vswprintf always null-terminates, but when truncation occurs, it will either
 // return -1 or the number of characters that would be in an untruncated
 // formatted string.  The actual return value depends on the underlying
 // C library's vswprintf implementation.
 int vswprintf(wchar_t* buffer, size_t size,
-              const wchar_t* format, va_list arguments);
+              const wchar_t* format, va_list arguments) WPRINTF_FORMAT(3, 0);
 
 // Some of these implementations need to be inlined.
 
+// We separate the declaration from the implementation of this inline
+// function just so the PRINTF_FORMAT works.
+inline int snprintf(char* buffer, size_t size, const char* format, ...)
+    PRINTF_FORMAT(3, 4);
 inline int snprintf(char* buffer, size_t size, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   int result = vsnprintf(buffer, size, format, arguments);
   va_end(arguments);
   return result;
 }
 
+// We separate the declaration from the implementation of this inline
+// function just so the WPRINTF_FORMAT works.
+inline int swprintf(wchar_t* buffer, size_t size, const wchar_t* format, ...)
+    WPRINTF_FORMAT(3, 4);
 inline int swprintf(wchar_t* buffer, size_t size, const wchar_t* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   int result = vswprintf(buffer, size, format, arguments);
   va_end(arguments);
   return result;
 }
 
 // BSD-style safe and consistent string copy functions.
 // Copies |src| to |dst|, where |dst_size| is the total allocated size of |dst|.
@@ skipping 357 matching lines @@
 int StringToInt(const std::string& value);
 int StringToInt(const string16& value);
 int64 StringToInt64(const std::string& value);
 int64 StringToInt64(const string16& value);
 int HexStringToInt(const std::string& value);
 int HexStringToInt(const string16& value);
 double StringToDouble(const std::string& value);
 double StringToDouble(const string16& value);
 
 // Return a C++ string given printf-like input.
-std::string StringPrintf(const char* format, ...);
-std::wstring StringPrintf(const wchar_t* format, ...);
+std::string StringPrintf(const char* format, ...) PRINTF_FORMAT(1, 2);
+std::wstring StringPrintf(const wchar_t* format, ...) WPRINTF_FORMAT(1, 2);
 
 // Store result into a supplied string and return it
-const std::string& SStringPrintf(std::string* dst, const char* format, ...);
+const std::string& SStringPrintf(std::string* dst, const char* format, ...)
+    PRINTF_FORMAT(2, 3);
 const std::wstring& SStringPrintf(std::wstring* dst,
-                                  const wchar_t* format, ...);
+                                  const wchar_t* format, ...)
+    WPRINTF_FORMAT(2, 3);
 
 // Append result to a supplied string
-void StringAppendF(std::string* dst, const char* format, ...);
-void StringAppendF(std::wstring* dst, const wchar_t* format, ...);
+void StringAppendF(std::string* dst, const char* format, ...)
+    PRINTF_FORMAT(2, 3);
+void StringAppendF(std::wstring* dst, const wchar_t* format, ...)
+    WPRINTF_FORMAT(2, 3);
 
 // Lower-level routine that takes a va_list and appends to a specified
 // string.  All other routines are just convenience wrappers around it.
-void StringAppendV(std::string* dst, const char* format, va_list ap);
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap);
+void StringAppendV(std::string* dst, const char* format, va_list ap)
+    PRINTF_FORMAT(2, 0);
+void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap)
+    WPRINTF_FORMAT(2, 0);
 
 // This is mpcomplete's pattern for saving a string copy when dealing with
 // a function that writes results into a wchar_t[] and wanting the result to
 // end up in a std::wstring.  It ensures that the std::wstring's internal
 // buffer has enough room to store the characters to be written into it, and
 // sets its .length() attribute to the right value.
 //
 // The reserve() call allocates the memory required to hold the string
 // plus a terminating null.  This is done because resize() isn't
 // guaranteed to reserve space for the null.  The resize() call is
@@ skipping 143 matching lines @@
 #elif defined(WCHAR_T_IS_UTF32)
   typedef uint32 Unsigned;
 #endif
 };
 template<>
 struct ToUnsigned<short> {
   typedef unsigned short Unsigned;
 };
 
 #endif  // BASE_STRING_UTIL_H_