base/stringprintf.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/stringprintf.h"
   6
   7 #include <errno.h>
   8
   9 #include "base/string_util.h"
  10 #include "base/utf_string_conversions.h"
  11
  12 namespace base {
  13
  14 namespace {
  15
  16 // Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
  17 // is the size of the buffer. These return the number of characters in the
  18 // formatted string excluding the NUL terminator. If the buffer is not
  19 // large enough to accommodate the formatted string without truncation, they
  20 // return the number of characters that would be in the fully-formatted string
  21 // (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
  22 inline int vsnprintfT(char* buffer,
  23                       size_t buf_size,
  24                       const char* format,
  25                       va_list argptr) {
  26   return base::vsnprintf(buffer, buf_size, format, argptr);
  27 }
  28
  29 inline int vsnprintfT(wchar_t* buffer,
  30                       size_t buf_size,
  31                       const wchar_t* format,
  32                       va_list argptr) {
  33   return base::vswprintf(buffer, buf_size, format, argptr);
  34 }
  35
  36 // Templatized backend for StringPrintF/StringAppendF. This does not finalize
  37 // the va_list, the caller is expected to do that.
  38 template <class StringType>
  39 static void StringAppendVT(StringType* dst,
  40                            const typename StringType::value_type* format,
  41                            va_list ap) {
  42   // First try with a small fixed size buffer.
  43   // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
  44   // and StringUtilTest.StringPrintfBounds.
  45   typename StringType::value_type stack_buf[1024];
  46
  47   va_list ap_copy;
  48   GG_VA_COPY(ap_copy, ap);
  49
  50 #if !defined(OS_WIN)
  51   errno = 0;
  52 #endif
  53   int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
  54   va_end(ap_copy);
  55
  56   if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
  57     // It fit.
  58     dst->append(stack_buf, result);
  59     return;
  60   }
  61
  62   // Repeatedly increase buffer size until it fits.
  63   int mem_length = arraysize(stack_buf);
  64   while (true) {
  65     if (result < 0) {
  66 #if !defined(OS_WIN)
  67       // On Windows, vsnprintfT always returns the number of characters in a
  68       // fully-formatted string, so if we reach this point, something else is
  69       // wrong and no amount of buffer-doubling is going to fix it.
  70       if (errno != 0 && errno != EOVERFLOW)
  71 #endif
  72       {
  73         // If an error other than overflow occurred, it's never going to work.
  74         DLOG(WARNING) << "Unable to printf the requested string due to error.";
  75         return;
  76       }
  77       // Try doubling the buffer size.
  78       mem_length *= 2;
  79     } else {
  80       // We need exactly "result + 1" characters.
  81       mem_length = result + 1;
  82     }
  83
  84     if (mem_length > 32 * 1024 * 1024) {
  85       // That should be plenty, don't try anything larger.  This protects
  86       // against huge allocations when using vsnprintfT implementations that
  87       // return -1 for reasons other than overflow without setting errno.
  88       DLOG(WARNING) << "Unable to printf the requested string due to size.";
  89       return;
  90     }
  91
  92     std::vector<typename StringType::value_type> mem_buf(mem_length);
  93
  94     // NOTE: You can only use a va_list once.  Since we're in a while loop, we
  95     // need to make a new copy each time so we don't use up the original.
  96     GG_VA_COPY(ap_copy, ap);
  97     result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
  98     va_end(ap_copy);
  99
 100     if ((result >= 0) && (result < mem_length)) {
 101       // It fit.
 102       dst->append(&mem_buf[0], result);
 103       return;
 104     }
 105   }
 106 }
 107
 108 }  // namespace
 109
 110 std::string StringPrintf(const char* format, ...) {
 111   va_list ap;
 112   va_start(ap, format);
 113   std::string result;
 114   StringAppendV(&result, format, ap);
 115   va_end(ap);
 116   return result;
 117 }
 118
 119 std::wstring StringPrintf(const wchar_t* format, ...) {
 120   va_list ap;
 121   va_start(ap, format);
 122   std::wstring result;
 123   StringAppendV(&result, format, ap);
 124   va_end(ap);
 125   return result;
 126 }
 127
 128 std::string StringPrintV(const char* format, va_list ap) {
 129   std::string result;
 130   StringAppendV(&result, format, ap);
 131   return result;
 132 }
 133
 134 const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
 135   va_list ap;
 136   va_start(ap, format);
 137   dst->clear();
 138   StringAppendV(dst, format, ap);
 139   va_end(ap);
 140   return *dst;
 141 }
 142
 143 const std::wstring& SStringPrintf(std::wstring* dst,
 144                                   const wchar_t* format, ...) {
 145   va_list ap;
 146   va_start(ap, format);
 147   dst->clear();
 148   StringAppendV(dst, format, ap);
 149   va_end(ap);
 150   return *dst;
 151 }
 152
 153 void StringAppendF(std::string* dst, const char* format, ...) {
 154   va_list ap;
 155   va_start(ap, format);
 156   StringAppendV(dst, format, ap);
 157   va_end(ap);
 158 }
 159
 160 void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
 161   va_list ap;
 162   va_start(ap, format);
 163   StringAppendV(dst, format, ap);
 164   va_end(ap);
 165 }
 166
 167 void StringAppendV(std::string* dst, const char* format, va_list ap) {
 168   StringAppendVT(dst, format, ap);
 169 }
 170
 171 void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
 172   StringAppendVT(dst, format, ap);
 173 }
 174
 175 }  // namespace base