text: // Copyright 2010 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.
  
  #include "base/strings/stringprintf.h"
  
  #include <stdarg.h>
  
  #include <vector>
  
  #include "base/logging.h"
  #include "base/scoped_clear_errno.h"
  #include "base/stl_util.h"
  #include "base/strings/string_util.h"
  
  namespace base {
  
  namespace {
  
  inline int vsnprintfT(char* buffer,
                        size_t buf_size,
                        const char* format,
                        va_list argptr) {
    return base::vsnprintf(buffer, buf_size, format, argptr);
  }
  
  template <class StringType>
  static void StringAppendVT(StringType* dst,
                             const typename StringType::value_type* format,
                             va_list ap) {
    typename StringType::value_type stack_buf[1024];
  
    va_list ap_copy;
    va_copy(ap_copy, ap);
  
  #if !defined(OS_WIN)
    ScopedClearErrno clear_errno;
  #endif
    int result = vsnprintfT(stack_buf, size(stack_buf), format, ap_copy);
    va_end(ap_copy);
  
    if (result >= 0 && result < static_cast<int>(size(stack_buf))) {
      dst->append(stack_buf, result);
      return;
    }
  
    // Repeatedly increase buffer size until it fits.
    size_t mem_length = size(stack_buf);
    while (true) {
      if (result < 0) {
  #if !defined(OS_WIN)
        // On Windows, vsnprintfT always returns the number of characters in a
        // fully-formatted string, so if we reach this point, something else is
        // wrong and no amount of buffer-doubling is going to fix it.
        if (errno != 0 && errno != EOVERFLOW)
  #endif
        {
          DLOG(WARNING) << "Unable to printf the requested string due to error.";
          return;
        }
  #if !defined(OS_WIN)
        // Try doubling the buffer size.
        mem_length *= 2;
  #endif
      } else {
        // We need exactly "result + 1" characters.
        mem_length = result + 1;
      }
  
      if (mem_length > 32 * 1024 * 1024) {
        // That should be plenty, don't try anything larger.  This protects
        // against huge allocations when using vsnprintfT implementations that
        // return -1 for reasons other than overflow without setting errno.
        DLOG(WARNING) << "Unable to printf the requested string due to size.";
        return;
      }
  
      std::vector<typename StringType::value_type> mem_buf(mem_length);
  
      // NOTE: You can only use a va_list once.  Since we're in a while loop, we
      // need to make a new copy each time so we don't use up the original.
      va_copy(ap_copy, ap);
      result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
      va_end(ap_copy);
  
      if ((result >= 0) && static_cast<unsigned int>(result) < mem_length) {
        // It fit.
        dst->append(&mem_buf[0], result);
        return;
      }
    }
  }
  
  }  // namespace
  
  std::string StringPrintf(const char* format, ...) {
    va_list ap;
    va_start(ap, format);
    std::string result;
    StringAppendV(&result, format, ap);
    va_end(ap);
    return result;
  }
  
  void StringAppendV(std::string* dst, const char* format, va_list ap) {
    StringAppendVT(dst, format, ap);
  }
  
  }  // namespace base
  