[libc++][print] Adds stdout functions.

[Mordante]

Summary

Implements parts of

• P2093R14 Formatted output
• P2539R4 Should the output of std::print to a terminal be synchronized with the underlying stream?

Depends on D150044

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Disable failing println test on Windows.

[Mordante]

Disables the right test.

[ldionne]

libcxx/test/std/input.output/iostream.format/print.fun/check-stdout.sh

5–6 ↗

(On Diff #540696)

9–14 ↗

(On Diff #540696)

libcxx/test/std/input.output/iostream.format/print.fun/print.sh.cpp

27

28

33–34

I think this would work, and it would be a bit simpler cause it would only use the Lit internal shell. We could also remove the dependency on executor-has-no-bash and the FILE_DEPENDENCIES.

39

libcxx/test/std/input.output/iostream.format/print.fun/println.sh.cpp

37

Or the other way around, but IDK why the test passes even with that.

[Mordante]

libcxx/test/std/input.output/iostream.format/print.fun/check-stdout.sh

5–6 ↗

(On Diff #540696)

This file has been removed.

libcxx/test/std/input.output/iostream.format/print.fun/print.sh.cpp

33–34

I tried the suggested approach, but that didn't entirely work, so did it slightly different.

[Mordante]

Rebased and addresses review comments.

[ldionne]

This is nice! I like the testing a lot more than what we do for std::cout.

[Mordante]

CI fixes.

libcxx/docs/Status/FormatPaper.csv

 `[format.range.fmtstr] <https://wg21.link/format.range.fmtstr>`_,"Formatting for ranges: strings",,Mark de Wever,|Complete|,17.0
 `[format.range.fmtstr] <https://wg21.link/format.range.fmtstr>`_,"Formatting for ranges: debug_strings",,Mark de Wever,|Complete|,17.0
 
 "`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``"
 `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,"Formatting ``thread::id``",,Mark de Wever,|Complete|,17.0
 `[stacktrace.format] <https://wg21.link/stacktrace.format>`_,"Formatting ``stacktrace``",A ``<stacktrace>`` implementation,Mark de Wever,,
 
 "`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output"
-`[print.fun] <https://wg21.link/print.fun>`__,"Output to ``stdout``",,Mark de Wever,|In Progress|,
+`[print.fun] <https://wg21.link/print.fun>`__,"Output to ``stdout``",,Mark de Wever,|Complete|, 17.0
 `[print.fun] <https://wg21.link/print.fun>`__,"Output to ``FILE*``",,Mark de Wever,|Complete|, 17.0
 `[ostream.formatted.print] <https://wg21.link/ostream.formatted.print>`__,"Output to ``ostream``",,Mark de Wever

libcxx/include/print

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_PRINT
 #define _LIBCPP_PRINT
 
 /*
 namespace std {
   // [print.fun], print functions
   template<class... Args>
+    void print(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
     void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
 
   template<class... Args>
+    void println(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
     void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
 
+  void vprint_unicode(string_view fmt, format_args args);
   void vprint_unicode(FILE* stream, string_view fmt, format_args args);
 
+  void vprint_nonunicode(string_view fmt, format_args args);
   void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/buffer.h>
#  ifndef _LIBCPP_HAS_NO_UNICODE
   else
     __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
 #  else  // _LIBCPP_HAS_NO_UNICODE
   __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
 #  endif // _LIBCPP_HAS_NO_UNICODE
 }
 
 template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __args) {
+  std::print(stdout, __fmt, std::forward<_Args>(__args)...);
+}
+
+template <class... _Args>
 _LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
 #  ifndef _LIBCPP_HAS_NO_UNICODE
   // Note the wording in the Standard is inefficient. The output of
   // std::format is a std::string which is then copied. This solution
   // just appends a newline at the end of the output.
   if constexpr (__print::__use_unicode)
     __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
   else
     __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
 #  else  // _LIBCPP_HAS_NO_UNICODE
   __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
 #  endif // _LIBCPP_HAS_NO_UNICODE
 }
 
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __args) {
+  std::println(stdout, __fmt, std::forward<_Args>(__args)...);
+}
+
 #  ifndef _LIBCPP_HAS_NO_UNICODE
 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {
   __print::__vprint_unicode(__stream, __fmt, __args, false);
 }
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(string_view __fmt, format_args __args) {
+  std::vprint_unicode(stdout, __fmt, __args);
+}
+
 #  endif // _LIBCPP_HAS_NO_UNICODE
 
 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args) {
   __print::__vprint_nonunicode(__stream, __fmt, __args, false);
 }
 
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(string_view __fmt, format_args __args) {
+  std::vprint_nonunicode(stdout, __fmt, __args);
+}
+
 #endif // _LIBCPP_STD_VER >= 23
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_PRINT

libcxx/test/std/input.output/iostream.format/print.fun/print.sh.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// template<class... Args>
+//   void print(format_string<Args...> fmt, Args&&... args);
+
+// Testing this properly is quite hard; the function unconditionally
+// writes to stdout. When stdout is redirected to a file it is no longer
+// considered a terminal. The function is a small wrapper around
+//
+// template<class... Args>
+//   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+//
+// So do minimal tests for this function and rely on the FILE* overload
+// to do more testing.
+//
+// The testing is based on the testing for std::cout.
+
+// RUN: %{build}
+// RUN: %{exec} echo -ne "1234 一二三四 true 0x0" > %t.expected
+// RUN: %{exec} "%t.exe" > %t.actual
+// RUN: diff -u %t.actual %t.expected
+
+#include <print>
+
+int main(int, char**) {
+  // The data is passed as-is so it does not depend on the encoding of the input.
+  std::print("{} {} ", 1234, "一二三四");
+  std::print("{} {}", true, nullptr);
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/println.sh.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// template<class... Args>
+//   void println(format_string<Args...> fmt, Args&&... args);
+
+// Testing this properly is quite hard; the function unconditionally
+// writes to stdout. When stdout is redirected to a file it is no longer
+// considered a terminal. The function is a small wrapper around
+//
+// template<class... Args>
+//   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+//
+// So do minimal tests for this function and rely on the FILE* overload
+// to do more testing.
+//
+// The testing is based on the testing for std::cout.
+
+// RUN: %{build}
+// RUN: %{exec} echo -ne "1234 一二三四\ntrue 0x0\n" > %t.expected
+// RUN: %{exec} "%t.exe" > %t.actual
+// RUN: diff -u %t.actual %t.expected
+
+#include <print>
+
+int main(int, char**) {
+  // The data is passed as-is so it does not depend on the encoding of the input.
+  std::println("{} {}", 1234, "一二三四");
+  std::println("{} {}", true, nullptr);
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/vprint_nonunicode.sh.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+//  void vprint_nonunicode(string_view fmt, format_args args);
+
+// Testing this properly is quite hard; the function unconditionally
+// writes to stdout. When stdout is redirected to a file it is no longer
+// considered a terminal. The function is a small wrapper around
+//
+//  void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+//
+// So do minimal tests for this function and rely on the FILE* overload
+// to do more testing.
+//
+// The testing is based on the testing for std::cout.
+
+// RUN: %{build}
+// RUN: %{exec} echo -ne "1234 一二三四 true 0x0" > %t.expected
+// RUN: %{exec} "%t.exe" > %t.actual
+// RUN: diff -u %t.actual %t.expected
+
+#include <print>
+
+int main(int, char**) {
+  // The data is passed as-is so it does not depend on the encoding of the input.
+  std::vprint_nonunicode("{} {} ", std::make_format_args(1234, "一二三四"));
+  std::vprint_nonunicode("{} {}", std::make_format_args(true, nullptr));
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.sh.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+//  void vprint_unicode(string_view fmt, format_args args);
+
+// Testing this properly is quite hard; the function unconditionally
+// writes to stdout. When stdout is redirected to a file it is no longer
+// considered a terminal. The function is a small wrapper around
+//
+//  void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+//
+// So do minimal tests for this function and rely on the FILE* overload
+// to do more testing.
+//
+// The testing is based on the testing for std::cout.
+
+// RUN: %{build}
+// RUN: %{exec} echo -ne "1234 一二三四 true 0x0" > %t.expected
+// RUN: %{exec} "%t.exe" > %t.actual
+// RUN: diff -u %t.actual %t.expected
+
+#include <print>
+
+int main(int, char**) {
+  // The data is passed as-is so it does not depend on the encoding of the input.
+  std::vprint_unicode("{} {} ", std::make_format_args(1234, "一二三四"));
+  std::vprint_unicode("{} {}", std::make_format_args(true, nullptr));
+
+  return 0;
+}

libcxx/utils/ci/run-buildbot

if [ -s ${BUILD_DIR}/generated_output.status ]; then
         echo "formatting of some of the changed files."
         false
     fi
 
     # Reject patches that introduce non-ASCII characters or hard tabs.
     # Depends on LC_COLLATE set at the top of this script.
     ! grep -rn '[^ -~]' libcxx/include libcxx/src libcxx/test libcxx/benchmarks \
            --exclude '*.dat' \
+           --exclude '*unicode*.cpp' \
+           --exclude '*print*.sh.cpp' \
            --exclude 'escaped_output.*.pass.cpp' \
-           --exclude 'fill.unicode.pass.cpp' \
            --exclude 'format_tests.h' \
            --exclude 'format.functions.tests.h' \
            --exclude 'formatter.*.pass.cpp' \
            --exclude 'grep.pass.cpp' \
            --exclude 'locale-specific_form.pass.cpp' \
            --exclude 'ostream.pass.cpp' \
-           --exclude 'std_format_spec_string_unicode.bench.cpp' \
            --exclude 'transcoding.pass.cpp' \
-           --exclude 'vprint_unicode_windows.pass.cpp' \
            --exclude 'underflow.pass.cpp' \
            || false
 
     # Reject code with trailing whitespace
     ! grep -rn '[[:blank:]]$' libcxx/include libcxx/src libcxx/test libcxx/benchmarks || false
 ;;
 #
 # Various Standard modes