| // Copyright 2016 The Fuchsia 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 "src/lib/fxl/strings/string_printf.h" | |
| #include <assert.h> | |
| #include <errno.h> | |
| #include <stdarg.h> | |
| #include <stddef.h> | |
| #include <stdio.h> | |
| #include <memory> | |
| namespace fxl { | |
| namespace { | |
| void StringVAppendfHelper(std::string* dest, const char* format, va_list ap) { | |
| // Size of the small stack buffer to use first. This should be kept in sync | |
| // with the numbers in StringPrintfTest.StringPrintf_Boundary. | |
| constexpr size_t kStackBufferSize = 1024u; | |
| // First, try with a small buffer on the stack. | |
| char stack_buf[kStackBufferSize]; | |
| // Copy |ap| (which can only be used once), in case we need to retry. | |
| va_list ap_copy; | |
| va_copy(ap_copy, ap); | |
| int result = vsnprintf(stack_buf, kStackBufferSize, format, ap_copy); | |
| va_end(ap_copy); | |
| if (result < 0) { | |
| // As far as I can tell, we'd only get |EOVERFLOW| if the result is so large | |
| // that it can't be represented by an |int| (in which case retrying would be | |
| // futile), so Chromium's implementation is wrong. | |
| return; | |
| } | |
| // |result| should be the number of characters we need, not including the | |
| // terminating null. However, |vsnprintf()| always null-terminates! | |
| size_t output_size = static_cast<size_t>(result); | |
| // Check if the output fit into our stack buffer. This is "<" not "<=", since | |
| // |vsnprintf()| will null-terminate. | |
| if (output_size < kStackBufferSize) { | |
| // It fit. | |
| dest->append(stack_buf, static_cast<size_t>(result)); | |
| return; | |
| } | |
| // Since we have the required output size, we can just heap allocate that. | |
| // (Add 1 because |vsnprintf()| will always null-terminate.) | |
| size_t heap_buf_size = output_size + 1u; | |
| std::unique_ptr<char[]> heap_buf(new char[heap_buf_size]); | |
| result = vsnprintf(heap_buf.get(), heap_buf_size, format, ap); | |
| if (result < 0 || static_cast<size_t>(result) > output_size) { | |
| assert(false); | |
| return; | |
| } | |
| assert(static_cast<size_t>(result) == output_size); | |
| dest->append(heap_buf.get(), static_cast<size_t>(result)); | |
| } | |
| } // namespace | |
| std::string StringPrintf(const char* format, ...) { | |
| va_list ap; | |
| va_start(ap, format); | |
| std::string rv; | |
| StringVAppendf(&rv, format, ap); | |
| va_end(ap); | |
| return rv; | |
| } | |
| std::string StringVPrintf(const char* format, va_list ap) { | |
| std::string rv; | |
| StringVAppendf(&rv, format, ap); | |
| return rv; | |
| } | |
| void StringAppendf(std::string* dest, const char* format, ...) { | |
| va_list ap; | |
| va_start(ap, format); | |
| StringVAppendf(dest, format, ap); | |
| va_end(ap); | |
| } | |
| void StringVAppendf(std::string* dest, const char* format, va_list ap) { | |
| int old_errno = errno; | |
| StringVAppendfHelper(dest, format, ap); | |
| errno = old_errno; | |
| } | |
| } // namespace fxl |