Ensure showbase does not overflow do_put buffers

[dim]

Summary

In https://bugs.freebsd.org/207918, Daniel McRobb describes how using
std::showbase with ostreams can cause truncation of unsigned long long
when output format is octal. In fact, this can even happen with
unsigned int and unsigned long.

To ensure this does not happen, add one additional character to the
do_put buffers if std::showbase is on. Also add a test case.

[dim]

Note: I copied some of the test case from rL227097, which had a similar case of a too short buffer.

[dim]

Simplify test case a bit.

[dim]

Ping :)

include/locale

num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, long __v) const
 {
     // Stage 1 - Get number in narrow char
     char __fmt[6] = {'%', 0};
     const char* __len = "l";
     this->__format_int(__fmt+1, __len, true, __iob.flags());
     const unsigned __nbuf = (numeric_limits<long>::digits / 3)
                           + ((numeric_limits<long>::digits % 3) != 0)
+                          + ((__iob.flags() & ios_base::showbase) != 0)
                           + 2;
     char __nar[__nbuf];
     int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, long long __v) const
 {
     // Stage 1 - Get number in narrow char
     char __fmt[8] = {'%', 0};
     const char* __len = "ll";
     this->__format_int(__fmt+1, __len, true, __iob.flags());
     const unsigned __nbuf = (numeric_limits<long long>::digits / 3)
                           + ((numeric_limits<long long>::digits % 3) != 0)
+                          + ((__iob.flags() & ios_base::showbase) != 0)
                           + 2;
     char __nar[__nbuf];
     int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, unsigned long __v) const
 {
     // Stage 1 - Get number in narrow char
     char __fmt[6] = {'%', 0};
     const char* __len = "l";
     this->__format_int(__fmt+1, __len, false, __iob.flags());
     const unsigned __nbuf = (numeric_limits<unsigned long>::digits / 3)
                           + ((numeric_limits<unsigned long>::digits % 3) != 0)
+                          + ((__iob.flags() & ios_base::showbase) != 0)
                           + 1;
     char __nar[__nbuf];
     int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, unsigned long long __v) const
 {
     // Stage 1 - Get number in narrow char
     char __fmt[8] = {'%', 0};
     const char* __len = "ll";
     this->__format_int(__fmt+1, __len, false, __iob.flags());
     const unsigned __nbuf = (numeric_limits<unsigned long long>::digits / 3)
                           + ((numeric_limits<unsigned long long>::digits % 3) != 0)
+                          + ((__iob.flags() & ios_base::showbase) != 0)
                           + 1;
     char __nar[__nbuf];
     int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <ostream>
+
+// template <class charT, class traits = char_traits<charT> >
+//   class basic_ostream;
+
+// operator<<(short n);
+// operator<<(unsigned short n);
+// operator<<(int n);
+// operator<<(unsigned int n);
+// operator<<(long n);
+// operator<<(unsigned long n);
+// operator<<(long long n);
+// operator<<(unsigned long long n);
+
+//  Testing to make sure that the max length values are correctly inserted when
+//  using std::showbase
+
+#include <cassert>
+#include <cstdint>
+#include <ios>
+#include <limits>
+#include <sstream>
+#include <type_traits>
+
+template <typename T>
+void test_min_oct(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::oct << std::showbase << std::numeric_limits<T>::min();
+    assert(ss.str() == expected);
+}
+
+template <typename T>
+void test_max_oct(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::oct << std::showbase << std::numeric_limits<T>::max();
+    assert(ss.str() == expected);
+}
+
+template <typename T>
+void test_min_dec(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::dec << std::showbase << std::numeric_limits<T>::min();
+    assert(ss.str() == expected);
+}
+
+template <typename T>
+void test_max_dec(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::dec << std::showbase << std::numeric_limits<T>::max();
+    assert(ss.str() == expected);
+}
+
+template <typename T>
+void test_min_hex(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::hex << std::showbase << std::numeric_limits<T>::min();
+    assert(ss.str() == expected);
+}
+
+template <typename T>
+void test_max_hex(const char *expected)
+{
+    std::stringstream ss;
+    ss << std::hex << std::showbase << std::numeric_limits<T>::max();
+    assert(ss.str() == expected);
+}
+
+int main(void)
+{
+    test_min_oct<short>("0100000");
+    test_min_dec<short>("-32768");
+    test_min_hex<short>("0x8000");
+
+    test_max_oct<unsigned short>("0177777");
+    test_max_dec<unsigned short>("65535");
+    test_max_hex<unsigned short>("0xffff");
+
+    test_min_oct<int>("020000000000");
+    test_min_dec<int>("-2147483648");
+    test_min_hex<int>("0x80000000");
+
+    test_max_oct<unsigned int>("037777777777");
+    test_max_dec<unsigned int>("4294967295");
+    test_max_hex<unsigned int>("0xffffffff");
+
+    const bool long_is_32 = std::integral_constant<bool, sizeof(long) == sizeof(int32_t)>::value; // avoid compiler warnings
+    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(int64_t)>::value; // avoid compiler warnings
+
+    if (long_is_32) {
+        test_min_oct<long>("020000000000");
+        test_min_dec<long>("-2147483648");
+        test_min_hex<long>("0x80000000");
+
+        test_max_oct<unsigned long>("037777777777");
+        test_max_dec<unsigned long>("4294967295");
+        test_max_hex<unsigned long>("0xffffffff");
+    } else if (long_is_64) {
+        test_min_oct<long>("01000000000000000000000");
+        test_min_dec<long>("-9223372036854775808");
+        test_min_hex<long>("0x8000000000000000");
+
+        test_max_oct<unsigned long>("01777777777777777777777");
+        test_max_dec<unsigned long>("18446744073709551615");
+        test_max_hex<unsigned long>("0xffffffffffffffff");
+    }
+    if (long_long_is_64) {
+        test_min_oct<long long>("01000000000000000000000");
+        test_min_dec<long long>("-9223372036854775808");
+        test_min_hex<long long>("0x8000000000000000");
+
+        test_max_oct<unsigned long long>("01777777777777777777777");
+        test_max_dec<unsigned long long>("18446744073709551615");
+        test_max_hex<unsigned long long>("0xffffffffffffffff");
+    }
+
+    return 0;
+}