Cleanups and improvements.

Author: mordante

libcxx/include/__format/buffer.h

@@ -12,7 +12,6 @@
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
-#include <__algorithm/for_each.h>
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/ranges_copy.h>
@@ -35,13 +34,11 @@
 #include <__memory/construct_at.h>
 #include <__memory/destroy.h>
 #include <__memory/uninitialized_algorithms.h>
-#include <__system_error/system_error.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/conditional.h>
 #include <__utility/exception_guard.h>
 #include <__utility/move.h>
 #include <stdexcept>
-#include <stdio.h> // Uses the POSIX/Windows unlocked stream I/O
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__ostream/print.h

@@ -111,9 +111,9 @@ _LIBCPP_HIDE_FROM_ABI void __vprint_unicode(ostream& __os, string_view __fmt, fo
     ostream::sentry __s(__os);
     if (__s) {
 #        ifndef _LIBCPP_WIN32API
-      __print::__vprint_unicode_posix(__file, __fmt, __args, __write_nl, true);
+      __print::__vprint_unicode_posix<__print::__lock_policy::__stdio>(__file, __fmt, __args, __write_nl, true);
 #        elif _LIBCPP_HAS_WIDE_CHARACTERS
-    __print::__vprint_unicode_windows(__file, __fmt, __args, __write_nl, true);
+      __print::__vprint_unicode_windows<__print::__lock_policy::__stdio>(__file, __fmt, __args, __write_nl, true);
 #        else
 #          error "Windows builds with wchar_t disabled are not supported."
 #        endif

libcxx/include/print

@@ -14,6 +14,7 @@ export namespace std {
   using std::println;
 
   using std::vprint_nonunicode;
+  using ::std::vprint_nonunicode_buffered;
 #  if _LIBCPP_HAS_UNICODE
   using std::vprint_unicode;
   using std::vprint_unicode_buffered;

libcxx/modules/std/print.inc

@@ -21,6 +21,7 @@
 // <print>
 
 // Tests the implementation of
+//   template <__print::__lock_policy __policy>
 //   void __print::__vprint_unicode_posix(FILE* __stream, string_view __fmt,
 //                                        format_args __args, bool __write_nl,
 //                                        bool __is_terminal);
@@ -39,7 +40,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**) {
+template <std::__print::__lock_policy policy>
+static void test() {
   std::array<char, 100> buffer;
   std::ranges::fill(buffer, '*');
 
@@ -55,15 +57,15 @@ int main(int, char**) {
 #endif
 
   // Test writing to a "non-terminal" stream does not flush.
-  std::__print::__vprint_unicode_posix(file, " world", std::make_format_args(), false, false);
+  std::__print::__vprint_unicode_posix<policy>(file, " world", std::make_format_args(), false, false);
   assert(std::ftell(file) == 11);
 #if defined(TEST_HAS_GLIBC) &&                                                                                         \
     !(__has_feature(address_sanitizer) || __has_feature(thread_sanitizer) || __has_feature(memory_sanitizer))
   assert(std::ranges::all_of(buffer, [](char c) { return c == '*'; }));
 #endif
 
   // Test writing to a "terminal" stream flushes before writing.
-  std::__print::__vprint_unicode_posix(file, "!", std::make_format_args(), false, true);
+  std::__print::__vprint_unicode_posix<policy>(file, "!", std::make_format_args(), false, true);
   assert(std::ftell(file) == 12);
   assert(std::string_view(buffer.data(), buffer.data() + 11) == "Hello world");
 #if defined(TEST_HAS_GLIBC)
@@ -74,6 +76,11 @@ int main(int, char**) {
   // Test everything is written when closing the stream.
   std::fclose(file);
   assert(std::string_view(buffer.data(), buffer.data() + 12) == "Hello world!");
+}
+
+int main(int, char**) {
+  test<std::__print::__lock_policy::__manual>();
+  test<std::__print::__lock_policy::__stdio>();
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.pass.cpp

@@ -20,6 +20,7 @@
 // <print>
 
 // Tests the implementation of
+//   template <__print::__lock_policy __policy>
 //   void __print::__vprint_unicode_windows(FILE* __stream, string_view __fmt,
 //                                          format_args __args, bool __write_nl,
 //                                          bool __is_terminal);
@@ -47,8 +48,8 @@ TEST_GCC_DIAGNOSTIC_IGNORED("-Wuse-after-free")
 
 #define SV(S) MAKE_STRING_VIEW(wchar_t, S)
 
-bool calling               = false;
-std::wstring_view expected = L" world";
+bool calling = true;
+std::wstring_view expected;
 
 void write_to_console(FILE*, std::wstring_view data) {
   assert(calling);
@@ -58,29 +59,35 @@ void write_to_console(FILE*, std::wstring_view data) {
 scoped_test_env env;
 std::string filename = env.create_file("output.txt");
 
+template <std::__print::__lock_policy policy>
 static void test_basics() {
   FILE* file = std::fopen(filename.c_str(), "wb");
   assert(file);
 
+  calling  = false;
+  expected = L" world";
+
   // Test writing to a "non-terminal" stream does not call WriteConsoleW.
-  std::__print::__vprint_unicode_windows(file, "Hello", std::make_format_args(), false, false);
+  std::__print::__vprint_unicode_windows<policy>(file, "Hello", std::make_format_args(), false, false);
   assert(std::ftell(file) == 5);
 
   // It's not possible to reliably test whether writing to a "terminal" stream
   // flushes before writing. Testing flushing a closed stream worked on some
   // platforms, but was unreliable.
   calling = true;
-  std::__print::__vprint_unicode_windows(file, " world", std::make_format_args(), false, true);
+  std::__print::__vprint_unicode_windows<policy>(file, " world", std::make_format_args(), false, true);
+  std::fclose(file);
 }
 
 // When the output is a file the data is written as-is.
 // When the output is a "terminal" invalid UTF-8 input is flagged.
+template <std::__print::__lock_policy policy>
 static void test(std::wstring_view output, std::string_view input) {
   // *** File ***
   FILE* file = std::fopen(filename.c_str(), "wb");
   assert(file);
 
-  std::__print::__vprint_unicode_windows(file, input, std::make_format_args(), false, false);
+  std::__print::__vprint_unicode_windows<policy>(file, input, std::make_format_args(), false, false);
   assert(std::ftell(file) == static_cast<long>(input.size()));
   std::fclose(file);
 
@@ -95,12 +102,13 @@ static void test(std::wstring_view output, std::string_view input) {
 
   // *** Terminal ***
   expected = output;
-  std::__print::__vprint_unicode_windows(file, input, std::make_format_args(), false, true);
+  std::__print::__vprint_unicode_windows<policy>(file, input, std::make_format_args(), false, true);
 }
 
+template <std::__print::__lock_policy policy>
 static void test() {
   // *** Test valid UTF-8 ***
-#define TEST(S) test(SV(S), S)
+#define TEST(S) test<policy>(SV(S), S)
   TEST("hello world");
 
   // copied from benchmarks/std_format_spec_string_unicode.bench.cpp
@@ -112,24 +120,29 @@ static void test() {
 #undef TEST
 
   // *** Test invalid utf-8 ***
-  test(SV("\ufffd"), "\xc3");
-  test(SV("\ufffd("), "\xc3\x28");
+  test<policy>(SV("\ufffd"), "\xc3");
+  test<policy>(SV("\ufffd("), "\xc3\x28");
 
   // surrogate range
-  test(SV("\ufffd"), "\xed\xa0\x80"); // U+D800
-  test(SV("\ufffd"), "\xed\xaf\xbf"); // U+DBFF
-  test(SV("\ufffd"), "\xed\xbf\x80"); // U+DC00
-  test(SV("\ufffd"), "\xed\xbf\xbf"); // U+DFFF
+  test<policy>(SV("\ufffd"), "\xed\xa0\x80"); // U+D800
+  test<policy>(SV("\ufffd"), "\xed\xaf\xbf"); // U+DBFF
+  test<policy>(SV("\ufffd"), "\xed\xbf\x80"); // U+DC00
+  test<policy>(SV("\ufffd"), "\xed\xbf\xbf"); // U+DFFF
 
   // beyond valid values
-  test(SV("\ufffd"), "\xf4\x90\x80\x80"); // U+110000
-  test(SV("\ufffd"), "\xf4\xbf\xbf\xbf"); // U+11FFFF
+  test<policy>(SV("\ufffd"), "\xf4\x90\x80\x80"); // U+110000
+  test<policy>(SV("\ufffd"), "\xf4\xbf\xbf\xbf"); // U+11FFFF
 
   // Validates  http://unicode.org/review/pr-121.html option 3.
-  test(SV("\u0061\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\u0062"), "\x61\xf1\x80\x80\xe1\x80\xc2\x62");
+  test<policy>(SV("\u0061\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\u0062"), "\x61\xf1\x80\x80\xe1\x80\xc2\x62");
 }
 
 int main(int, char**) {
-  test_basics();
-  test();
+  test_basics<std::__print::__lock_policy::__manual>();
+  test<std::__print::__lock_policy::__manual>();
+
+  test_basics<std::__print::__lock_policy::__stdio>();
+  test<std::__print::__lock_policy::__stdio>();
+
+  return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.pass.cpp

@@ -764,7 +764,6 @@ queue deque
 queue initializer_list
 queue iosfwd
 queue limits
-queue optional
 queue stdexcept
 queue string
 queue string_view
@@ -831,7 +830,6 @@ regex deque
 regex initializer_list
 regex iosfwd
 regex limits
-regex optional
 regex stdexcept
 regex string
 regex string_view
@@ -1076,7 +1074,6 @@ thread iosfwd
 thread istream
 thread limits
 thread locale
-thread optional
 thread ratio
 thread sstream
 thread stdexcept
@@ -1148,7 +1145,6 @@ vector cwctype
 vector initializer_list
 vector iosfwd
 vector limits
-vector optional
 vector stdexcept
 vector string
 vector string_view

libcxx/test/libcxx/transitive_includes/cxx23.csv

@@ -763,7 +763,6 @@ queue deque
 queue initializer_list
 queue iosfwd
 queue limits
-queue optional
 queue stdexcept
 queue string
 queue string_view
@@ -830,7 +829,6 @@ regex deque
 regex initializer_list
 regex iosfwd
 regex limits
-regex optional
 regex stdexcept
 regex string
 regex string_view
@@ -1075,7 +1073,6 @@ thread iosfwd
 thread istream
 thread limits
 thread locale
-thread optional
 thread ratio
 thread sstream
 thread stdexcept
@@ -1147,7 +1144,6 @@ vector cwctype
 vector initializer_list
 vector iosfwd
 vector limits
-vector optional
 vector stdexcept
 vector string
 vector string_view