[libc] move printf to use StringViews

[michaelrj]

Summary

The FormatSection and the writer functions both previously took a char*
and a length to represent a string. Now they use the StringView class to
represent that more succinctly. This change also required fixing
everywhere these were used, so it touches a lot of files.

[sivachandra]

libc/src/stdio/printf_core/char_converter.h

35

Here and elsewhere, instead of calling the StringView constructor explicitly, can you do {&c, string_len}?

libc/src/stdio/printf_core/file_writer.h

34–39

While we are at it, we should make these static methods of FileWriter and simplify the names to write_str and write_chars.

libc/src/stdio/printf_core/string_writer.h

41

Make these static methods of StringWriter.

libc/src/stdio/printf_core/writer.h

51

Something we should have done earlier is to name all of these methods as just write. So, I think we should have:

int write(cpp::StringView);
int write(char c, size_t count);
int write(char c);

I am suggesting a separate write(char) to avoid calling, for example, memcpy to write a single char to a string buffer. Likewise, the FileWriter can implement a char writer by calling putc_unlocked when it is available. More importantly though, you will avoid the ugliness of writer->write(StringView(&some_char, 1)) at many places in this change.

libc/test/src/stdio/printf_core/parser_test.cpp

57

Can you do:

expected.raw_string = {str, 4};

[michaelrj]

rebase

[michaelrj]

address comments

[sivachandra]

A comment about inconsistent usage of a pattern but good to go otherwise.

libc/test/src/stdio/printf_core/string_writer_test.cpp

36

Can we follow the pattern of {"abc", 3} here and elsewhere in the patch.

[michaelrj]

fix final string_view initialization

libc/src/stdio/printf_core/CMakeLists.txt

 
 add_header_library(
   core_structs
   HDRS
     core_structs.h
+  DEPENDS
+    libc.src.__support.CPP.string_view
+    libc.src.__support.FPUtil.fputil
 )
 
 add_object_library(
   parser
   SRCS
     parser.cpp
   HDRS
     parser.h
   DEPENDS
     .core_structs
     libc.src.__support.arg_list
     libc.src.__support.ctype_utils
     libc.src.__support.str_to_integer
     libc.src.__support.CPP.bit
-    libc.src.string.memory_utils.memset_implementation
+    libc.src.__support.CPP.string_view
 )
 
 add_object_library(
   string_writer
   SRCS
     string_writer.cpp
   HDRS
     string_writer.h
   DEPENDS
+    libc.src.__support.CPP.string_view
     libc.src.string.memory_utils.memcpy_implementation
+    libc.src.string.memory_utils.memset_implementation
     .core_structs
 )
 
 add_object_library(
   writer
   SRCS
     writer.cpp
   HDRS
     writer.h
-  DEPENDS
-    libc.src.string.memory_utils.memset_implementation
 )
 
 add_object_library(
   converter
   SRCS
     converter.cpp
   HDRS
     converter.h

 add_object_library(
   file_writer
   SRCS
     file_writer.cpp
   HDRS
     file_writer.h
   DEPENDS
     libc.src.__support.File.file
+    libc.src.__support.CPP.string_view
+    libc.src.string.memory_utils.memset_implementation
     .core_structs
 )
 
 add_object_library(
   vfprintf_internal
   SRCS
     vfprintf_internal.cpp
   HDRS

libc/src/stdio/printf_core/char_converter.h

 //===-- String Converter for printf -----------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CHAR_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CHAR_CONVERTER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int inline convert_char(Writer *writer, const FormatSection &to_conv) {
   char c = to_conv.conv_val_raw;
 
-  if (to_conv.min_width > 1) {
-    if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
-        FormatFlags::LEFT_JUSTIFIED) {
-      RET_IF_RESULT_NEGATIVE(writer->write(&c, 1));
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', to_conv.min_width - 1));
-    } else {
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', to_conv.min_width - 1));
-      RET_IF_RESULT_NEGATIVE(writer->write(&c, 1));
-    }
-  } else {
-    RET_IF_RESULT_NEGATIVE(writer->write(&c, 1));
+  constexpr int string_len = 1;
+
+  size_t padding_spaces =
+      to_conv.min_width > string_len ? to_conv.min_width - string_len : 0;
+
+  // If the padding is on the left side, write the spaces first.
+  if (padding_spaces > 0 &&
+      (to_conv.flags & FormatFlags::LEFT_JUSTIFIED) == 0) {
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', to_conv.min_width - string_len));
+
+  RET_IF_RESULT_NEGATIVE(writer->write(c));
+
+  // If the padding is on the right side, write the spaces last.
+  if (padding_spaces > 0 &&
+      (to_conv.flags & FormatFlags::LEFT_JUSTIFIED) != 0) {
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', to_conv.min_width - string_len));
   }
+
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CHAR_CONVERTER_H

libc/src/stdio/printf_core/converter.cpp

 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int convert(Writer *writer, const FormatSection &to_conv) {
   if (!to_conv.has_conv)
-    return writer->write(to_conv.raw_string, to_conv.raw_len);
+    return writer->write(to_conv.raw_string);
 
   switch (to_conv.conv_name) {
   case '%':
-    return writer->write("%", 1);
+    return writer->write("%");
   case 'c':
     return convert_char(writer, to_conv);
   case 's':
     return convert_string(writer, to_conv);
   case 'd':
   case 'i':
   case 'u':
   case 'o':

 #endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
 #ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
   case 'n':
     return convert_write_int(writer, to_conv);
 #endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
   case 'p':
     return convert_pointer(writer, to_conv);
   default:
-    return writer->write(to_conv.raw_string, to_conv.raw_len);
+    return writer->write(to_conv.raw_string);
   }
   return -1;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/core_structs.h

enum FormatFlags : uint8_t {
   // These flags come from the GNU extensions which aren't yet implemented.
   //  group_decimals = 0x20, // '
   //  locale_digits = 0x40,  // I
 };
 
 struct FormatSection {
   bool has_conv;
 
-  const char *__restrict raw_string;
-  size_t raw_len;
+  cpp::string_view raw_string;
 
   // Format Specifier Values
   FormatFlags flags = FormatFlags(0);
   LengthModifier length_modifier = LengthModifier::none;
   int min_width = 0;
   int precision = -1;
 
   // Needs to be large enough to hold a long double.
   fputil::FPBits<long double>::UIntType conv_val_raw;
   void *conv_val_ptr;
 
   char conv_name;
 
   // This operator is only used for testing and should be automatically
   // optimized out for release builds.
   bool operator==(const FormatSection &other) {
     if (has_conv != other.has_conv)
       return false;
 
-    if (cpp::string_view(raw_string, raw_len) !=
-        cpp::string_view(other.raw_string, other.raw_len))
+    if (raw_string != other.raw_string)
       return false;
 
     if (has_conv) {
       if (!((static_cast<uint8_t>(flags) ==
              static_cast<uint8_t>(other.flags)) &&
             (min_width == other.min_width) && (precision == other.precision) &&
             (length_modifier == other.length_modifier) &&
             (conv_name == other.conv_name)))

libc/src/stdio/printf_core/file_writer.h

 //===-- FILE Writer definition for printf -----------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FILE_WRITER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FILE_WRITER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 
 #include <stddef.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 class FileWriter {
   __llvm_libc::File *file;
 
 public:
   FileWriter(::FILE *init_file) {
     file = reinterpret_cast<__llvm_libc::File *>(init_file);
     file->lock();
   }
 
   ~FileWriter() { file->unlock(); }
 
   int write(const char *__restrict to_write, size_t len);
-};
 
-// write_to_file treats raw_pointer as a File and calls its write
-// function.
-int write_to_file(void *raw_pointer, const char *__restrict to_write,
-                  size_t len);
+  // These write functions take a FileWriter as a void* in raw_pointer, and
+  // call the appropriate write function on it.
+  static int write_str(void *raw_pointer, cpp::string_view new_string);
+  static int write_chars(void *raw_pointer, char new_char, size_t len);
+  static int write_char(void *raw_pointer, char new_char);
+};
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FILE_WRITER_H

libc/src/stdio/printf_core/file_writer.cpp

 //===-- FILE Writer implementation for printf -------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdio/printf_core/file_writer.h"
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int FileWriter::write(const char *__restrict to_write, size_t len) {
   int written = file->write_unlocked(to_write, len);
   if (written != static_cast<int>(len))
     written = FILE_WRITE_ERROR;
   if (file->error_unlocked())
     written = FILE_STATUS_ERROR;
   return written;
 }
 
-int write_to_file(void *raw_pointer, const char *__restrict to_write,
-                  size_t len) {
+int FileWriter::write_str(void *raw_pointer, cpp::string_view new_string) {
   FileWriter *file_writer = reinterpret_cast<FileWriter *>(raw_pointer);
-  return file_writer->write(to_write, len);
+  return file_writer->write(new_string.data(), new_string.size());
+}
+
+int FileWriter::write_chars(void *raw_pointer, char new_char, size_t len) {
+  FileWriter *file_writer = reinterpret_cast<FileWriter *>(raw_pointer);
+  constexpr size_t BUFF_SIZE = 8;
+  char buff[BUFF_SIZE] = {new_char};
+  int result;
+  while (len > BUFF_SIZE) {
+    result = file_writer->write(buff, BUFF_SIZE);
+    if (result < 0)
+      return result;
+    len -= BUFF_SIZE;
+  }
+  return file_writer->write(buff, len);
+}
+
+// TODO(michaelrj): Move this to putc_unlocked once that is available.
+int FileWriter::write_char(void *raw_pointer, char new_char) {
+  FileWriter *file_writer = reinterpret_cast<FileWriter *>(raw_pointer);
+  return file_writer->write(&new_char, 1);
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/float_hex_converter.h

 //===-- Hexadecimal Converter for printf ------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/float_inf_nan_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
int inline convert_float_hex_exp(Writer *writer, const FormatSection &to_conv) {
   int trailing_zeroes = 0;
   int padding;
 
   // prefix is "0x", and always appears.
   constexpr size_t PREFIX_LEN = 2;
   char prefix[PREFIX_LEN];
   prefix[0] = '0';
   prefix[1] = a + ('x' - 'a');
+  const cpp::string_view prefix_str(prefix, PREFIX_LEN);
 
   // If the precision is greater than the actual result, pad with 0s
   if (to_conv.precision > static_cast<int>(mant_digits - 1))
     trailing_zeroes = to_conv.precision - (mant_digits - 1);
 
   bool has_hexadecimal_point =
       (mant_digits > 1) || ((to_conv.flags & FormatFlags::ALTERNATE_FORM) ==
                             FormatFlags::ALTERNATE_FORM);
-  constexpr char HEXADECIMAL_POINT = '.';
+  constexpr cpp::string_view HEXADECIMAL_POINT(".");
 
   // This is for the letter 'p' before the exponent.
   const char exp_seperator = a + ('p' - 'a');
   constexpr int EXP_SEPERATOR_LEN = 1;
 
   padding = to_conv.min_width - (sign_char > 0 ? 1 : 0) - PREFIX_LEN -
             mant_digits - (has_hexadecimal_point ? 1 : 0) - EXP_SEPERATOR_LEN -
             (EXP_LEN - exp_cur);
   if (padding < 0)
     padding = 0;
 
   if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
       FormatFlags::LEFT_JUSTIFIED) {
     // The pattern is (sign), 0x, digit, (.), (other digits), (zeroes), p,
     // exponent, (spaces)
     if (sign_char > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
-    RET_IF_RESULT_NEGATIVE(writer->write(prefix, PREFIX_LEN));
-    RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer, 1));
+      RET_IF_RESULT_NEGATIVE(writer->write(sign_char));
+    RET_IF_RESULT_NEGATIVE(writer->write(prefix_str));
+    RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer[0]));
     if (has_hexadecimal_point)
-      RET_IF_RESULT_NEGATIVE(writer->write(&HEXADECIMAL_POINT, 1));
+      RET_IF_RESULT_NEGATIVE(writer->write(HEXADECIMAL_POINT));
     if (mant_digits > 1)
-      RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer + 1, mant_digits - 1));
+      RET_IF_RESULT_NEGATIVE(writer->write({mant_buffer + 1, mant_digits - 1}));
     if (trailing_zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', trailing_zeroes));
-    RET_IF_RESULT_NEGATIVE(writer->write(&exp_seperator, EXP_SEPERATOR_LEN));
+      RET_IF_RESULT_NEGATIVE(writer->write('0', trailing_zeroes));
+    RET_IF_RESULT_NEGATIVE(writer->write(exp_seperator));
     RET_IF_RESULT_NEGATIVE(
-        writer->write(exp_buffer + exp_cur, EXP_LEN - exp_cur));
+        writer->write({exp_buffer + exp_cur, EXP_LEN - exp_cur}));
     if (padding > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', padding));
+      RET_IF_RESULT_NEGATIVE(writer->write(' ', padding));
   } else {
     // The pattern is (spaces), (sign), 0x, (zeroes), digit, (.), (other
     // digits), (zeroes), p, exponent
     if ((padding > 0) && ((to_conv.flags & FormatFlags::LEADING_ZEROES) !=
                           FormatFlags::LEADING_ZEROES))
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', padding));
+      RET_IF_RESULT_NEGATIVE(writer->write(' ', padding));
     if (sign_char > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
-    RET_IF_RESULT_NEGATIVE(writer->write(prefix, PREFIX_LEN));
+      RET_IF_RESULT_NEGATIVE(writer->write(sign_char));
+    RET_IF_RESULT_NEGATIVE(writer->write(prefix_str));
     if ((padding > 0) && ((to_conv.flags & FormatFlags::LEADING_ZEROES) ==
                           FormatFlags::LEADING_ZEROES))
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', padding));
-    RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer, 1));
+      RET_IF_RESULT_NEGATIVE(writer->write('0', padding));
+    RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer[0]));
     if (has_hexadecimal_point)
-      RET_IF_RESULT_NEGATIVE(writer->write(&HEXADECIMAL_POINT, 1));
+      RET_IF_RESULT_NEGATIVE(writer->write(HEXADECIMAL_POINT));
     if (mant_digits > 1)
-      RET_IF_RESULT_NEGATIVE(writer->write(mant_buffer + 1, mant_digits - 1));
+      RET_IF_RESULT_NEGATIVE(writer->write({mant_buffer + 1, mant_digits - 1}));
     if (trailing_zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', trailing_zeroes));
-    RET_IF_RESULT_NEGATIVE(writer->write(&exp_seperator, EXP_SEPERATOR_LEN));
+      RET_IF_RESULT_NEGATIVE(writer->write('0', trailing_zeroes));
+    RET_IF_RESULT_NEGATIVE(writer->write(exp_seperator));
     RET_IF_RESULT_NEGATIVE(
-        writer->write(exp_buffer + exp_cur, EXP_LEN - exp_cur));
+        writer->write({exp_buffer + exp_cur, EXP_LEN - exp_cur}));
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H

libc/src/stdio/printf_core/float_inf_nan_converter.h

int inline convert_inf_nan(Writer *writer, const FormatSection &to_conv) {
   // Both "inf" and "nan" are the same number of characters, being 3.
   int padding = to_conv.min_width - (sign_char > 0 ? 1 : 0) - 3;
 
   // The right justified pattern is (spaces), (sign), inf/nan
   // The left justified pattern is  (sign), inf/nan, (spaces)
 
   if (padding > 0 && ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) !=
                       FormatFlags::LEFT_JUSTIFIED))
-    RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', padding));
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', padding));
 
   if (sign_char)
-    RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
+    RET_IF_RESULT_NEGATIVE(writer->write(sign_char));
   if (mantissa == 0) { // inf
-    RET_IF_RESULT_NEGATIVE(writer->write((a == 'a' ? "inf" : "INF"), 3));
+    RET_IF_RESULT_NEGATIVE(writer->write(a == 'a' ? "inf" : "INF"));
   } else { // nan
-    RET_IF_RESULT_NEGATIVE(writer->write((a == 'a' ? "nan" : "NAN"), 3));
+    RET_IF_RESULT_NEGATIVE(writer->write(a == 'a' ? "nan" : "NAN"));
   }
 
   if (padding > 0 && ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
                       FormatFlags::LEFT_JUSTIFIED))
-    RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', padding));
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', padding));
 
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_INF_NAN_CONVERTER_H

libc/src/stdio/printf_core/int_converter.h

 namespace __llvm_libc {
 namespace printf_core {
 
 // These functions only work on characters that are already known to be in the
 // alphabet. Their behavior is undefined otherwise.
 constexpr char inline to_lower(char a) { return a | 32; }
 constexpr bool inline is_lower(char a) { return (a & 32) > 0; }
 
-cpp::optional<cpp::string_view> inline num_to_strview(
-    uintmax_t num, cpp::span<char> bufref, char conv_name) {
+cpp::optional<cpp::string_view> inline num_to_strview(uintmax_t num,
+                                                      cpp::span<char> bufref,
+                                                      char conv_name) {
   if (to_lower(conv_name) == 'x') {
     return IntegerToString::hex(num, bufref, is_lower(conv_name));
   } else if (conv_name == 'o') {
     return IntegerToString::oct(num, bufref);
   } else {
     return IntegerToString::dec(num, bufref);
   }
 }
int inline convert_int(Writer *writer, const FormatSection &to_conv) {
 
   // These are signed to prevent underflow due to negative values. The eventual
   // values will always be non-negative.
   int zeroes;
   int spaces;
 
   // prefix is "0x" for hexadecimal, or the sign character for signed
   // conversions. Since hexadecimal is unsigned these will never conflict.
-  int prefix_len;
+  size_t prefix_len;
   char prefix[2];
   if ((to_lower(to_conv.conv_name) == 'x') &&
       ((flags & FormatFlags::ALTERNATE_FORM) != 0)) {
     prefix_len = 2;
     prefix[0] = '0';
     prefix[1] = a + ('x' - 'a');
   } else {
     prefix_len = (sign_char == 0 ? 0 : 1);
if ((to_conv.conv_name == 'o') &&
       ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0) && zeroes < 1) {
     zeroes = 1;
     --spaces;
   }
 
   if ((flags & FormatFlags::LEFT_JUSTIFIED) == FormatFlags::LEFT_JUSTIFIED) {
     // If left justified it goes prefix zeroes digits spaces
     if (prefix_len != 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(prefix, prefix_len));
+      RET_IF_RESULT_NEGATIVE(writer->write({prefix, prefix_len}));
     if (zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
+      RET_IF_RESULT_NEGATIVE(writer->write('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(str->data(), digits_written));
+      RET_IF_RESULT_NEGATIVE(writer->write(*str));
     if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
+      RET_IF_RESULT_NEGATIVE(writer->write(' ', spaces));
   } else {
     // Else it goes spaces prefix zeroes digits
     if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
+      RET_IF_RESULT_NEGATIVE(writer->write(' ', spaces));
     if (prefix_len != 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(prefix, prefix_len));
+      RET_IF_RESULT_NEGATIVE(writer->write({prefix, prefix_len}));
     if (zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
+      RET_IF_RESULT_NEGATIVE(writer->write('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(str->data(), digits_written));
+      RET_IF_RESULT_NEGATIVE(writer->write(*str));
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H

libc/src/stdio/printf_core/parser.h

 //===-- Format string parser for printf -------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PARSER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PARSER_H
 
 #include "src/__support/arg_list.h"
 #include "src/stdio/printf_core/core_structs.h"
-#include "src/string/memory_utils/memset_implementations.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 class Parser {
   const char *__restrict str;
#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
   };
   // TODO: Make this size configurable via a compile option.
   static constexpr size_t DESC_ARR_LEN = 32;
   // desc_arr stores the sizes of the variables in the ArgList. This is used in
   // index mode to reduce repeated string parsing. The sizes are stored as
   // TypeDesc objects, which store the size as well as minimal type information.
   // This is necessary because some systems separate the floating point and
   // integer values in va_args.
-  TypeDesc desc_arr[DESC_ARR_LEN];
+  TypeDesc desc_arr[DESC_ARR_LEN] = {{0, Integer}};;
 
   // TODO: Look into object stores for optimization.
 
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 public:
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
   Parser(const char *__restrict new_str, internal::ArgList &args)
-      : str(new_str), args_cur(args), args_start(args) {
-    inline_memset(reinterpret_cast<char *>(desc_arr), 0,
-                  DESC_ARR_LEN * sizeof(TypeDesc));
-  }
+      : str(new_str), args_cur(args), args_start(args) {}
 #else
   Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args) {}
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its

libc/src/stdio/printf_core/parser.cpp

 //===-- Format string parser implementation for printf ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 // #define LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE 1 // This will be a compile flag.
 
 #include "parser.h"
 
 #include "src/__support/arg_list.h"
 
 #include "src/__support/CPP/bit.h"
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 #define GET_ARG_VAL_SIMPLEST(arg_type, index) get_arg_value<arg_type>(index)
 #else
 #define GET_ARG_VAL_SIMPLEST(arg_type, _) get_next_arg_value<arg_type>()
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 FormatSection Parser::get_next_section() {
   FormatSection section;
-  section.raw_string = str + cur_pos;
   size_t starting_pos = cur_pos;
   if (str[cur_pos] == '%') {
     // format section
     section.has_conv = true;
 
     ++cur_pos;
     [[maybe_unused]] size_t conv_index = 0;
 
#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
     }
     ++cur_pos;
   } else {
     // raw section
     section.has_conv = false;
     while (str[cur_pos] != '%' && str[cur_pos] != '\0')
       ++cur_pos;
   }
-  section.raw_len = cur_pos - starting_pos;
+  section.raw_string = {str + starting_pos, cur_pos - starting_pos};
   return section;
 }
 
 FormatFlags Parser::parse_flags(size_t *local_pos) {
   bool found_flag = true;
   FormatFlags flags = FormatFlags(0);
   while (found_flag) {
     switch (str[*local_pos]) {

libc/src/stdio/printf_core/printf_main.cpp

 namespace __llvm_libc {
 namespace printf_core {
 
 int printf_main(Writer *writer, const char *__restrict str,
                 internal::ArgList &args) {
   Parser parser(str, args);
   int result = 0;
   for (FormatSection cur_section = parser.get_next_section();
-       cur_section.raw_len > 0; cur_section = parser.get_next_section()) {
+       !cur_section.raw_string.empty();
+       cur_section = parser.get_next_section()) {
     if (cur_section.has_conv)
       result = convert(writer, cur_section);
     else
-      result = writer->write(cur_section.raw_string, cur_section.raw_len);
+      result = writer->write(cur_section.raw_string);
 
     if (result < 0)
       return result;
   }
 
   return writer->get_chars_written();
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/ptr_converter.h

 //===-- Pointer Converter for printf ----------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_CONVERTER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/int_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int inline convert_pointer(Writer *writer, const FormatSection &to_conv) {
   if (to_conv.conv_val_ptr == (void *)(nullptr)) {
-    const char ZERO_STR[] = "(nullptr)";
-    // subtract 1 from sizeof to remove the null byte at the end.
-    RET_IF_RESULT_NEGATIVE(writer->write(ZERO_STR, sizeof(ZERO_STR) - 1));
+    RET_IF_RESULT_NEGATIVE(writer->write("(nullptr)"));
   } else {
     FormatSection hex_conv;
     hex_conv.has_conv = true;
     hex_conv.conv_name = 'x';
     hex_conv.flags = FormatFlags::ALTERNATE_FORM;
     hex_conv.conv_val_raw = reinterpret_cast<uintptr_t>(to_conv.conv_val_ptr);
     return convert_int(writer, hex_conv);
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_CONVERTER_H

libc/src/stdio/printf_core/string_converter.h

 //===-- String Converter for printf -----------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_CONVERTER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int inline convert_string(Writer *writer, const FormatSection &to_conv) {
-  int string_len = 0;
+  size_t string_len = 0;
 
   for (char *cur_str = reinterpret_cast<char *>(to_conv.conv_val_ptr);
        cur_str[string_len]; ++string_len) {
     ;
   }
 
-  if (to_conv.precision >= 0 && to_conv.precision < string_len)
+  if (to_conv.precision >= 0 &&
+      static_cast<size_t>(to_conv.precision) < string_len)
     string_len = to_conv.precision;
 
-  if (to_conv.min_width > string_len) {
-    if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
-        FormatFlags::LEFT_JUSTIFIED) {
-      RET_IF_RESULT_NEGATIVE(writer->write(
-          reinterpret_cast<const char *>(to_conv.conv_val_ptr), string_len));
-      RET_IF_RESULT_NEGATIVE(
-          writer->write_chars(' ', to_conv.min_width - string_len));
-
-    } else {
-      RET_IF_RESULT_NEGATIVE(
-          writer->write_chars(' ', to_conv.min_width - string_len));
-      RET_IF_RESULT_NEGATIVE(writer->write(
-          reinterpret_cast<const char *>(to_conv.conv_val_ptr), string_len));
-    }
-  } else {
-    RET_IF_RESULT_NEGATIVE(writer->write(
-        reinterpret_cast<const char *>(to_conv.conv_val_ptr), string_len));
+  size_t padding_spaces = to_conv.min_width > static_cast<int>(string_len)
+                              ? to_conv.min_width - string_len
+                              : 0;
+
+  // If the padding is on the left side, write the spaces first.
+  if (padding_spaces > 0 &&
+      (to_conv.flags & FormatFlags::LEFT_JUSTIFIED) == 0) {
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', to_conv.min_width - string_len));
+
+      {reinterpret_cast<const char *>(to_conv.conv_val_ptr), string_len}));
+
+  // If the padding is on the right side, write the spaces last.
+  if (padding_spaces > 0 &&
+      (to_conv.flags & FormatFlags::LEFT_JUSTIFIED) != 0) {
+    RET_IF_RESULT_NEGATIVE(writer->write(' ', to_conv.min_width - string_len));
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_CONVERTER_H

libc/src/stdio/printf_core/string_writer.h

 //===-- String Writer definition for printf ---------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_WRITER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_WRITER_H
 
+#include "src/__support/CPP/string_view.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 class StringWriter {
   char *__restrict cur_buffer;
   size_t available_capacity;
 
 public:
   // StringWriter is intended to take a copy of the cur_buffer pointer, as well
   // as the maximum length of the string. This maximum length should not include
   // the null terminator, since that's written separately.
   StringWriter(char *__restrict buffer, size_t max_len = ~size_t(0))
       : cur_buffer(buffer), available_capacity(max_len) {}
 
-  void write(const char *__restrict to_write, size_t len);
+  void write(cpp::string_view new_string);
+  void write(char new_char, size_t len);
+  void write(char new_char);
 
   // Terminate should only be called if the original max length passed to
   // snprintf was greater than 0. It writes a null byte to the end of the
   // cur_buffer, regardless of available_capacity.
   void terminate() { *cur_buffer = '\0'; }
-};
 
-// write_to_string treats raw_pointer as a StringWriter and calls its write
-// function.
-int write_to_string(void *raw_pointer, const char *__restrict to_write,
-                    size_t len);
+  // These write functions take a StringWriter as a void* in raw_pointer, and
+  // call the appropriate write function on it.
+  static int write_str(void *raw_pointer, cpp::string_view new_string);
+  static int write_chars(void *raw_pointer, char new_char, size_t len);
+  static int write_char(void *raw_pointer, char new_char);
+};
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_WRITER_H

libc/src/stdio/printf_core/string_writer.cpp

 //===-- String Writer implementation for printf -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdio/printf_core/string_writer.h"
+#include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/memset_implementations.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-void StringWriter::write(const char *__restrict to_write, size_t len) {
+void StringWriter::write(cpp::string_view new_string) {
+  size_t len = new_string.size();
   if (len > available_capacity)
     len = available_capacity;
 
   if (len > 0) {
-    inline_memcpy(cur_buffer, to_write, len);
+    inline_memcpy(cur_buffer, new_string.data(), len);
     cur_buffer += len;
     available_capacity -= len;
   }
 }
 
-int write_to_string(void *raw_pointer, const char *__restrict to_write,
-                    size_t len) {
+void StringWriter::write(char new_char, size_t len) {
+  if (len > available_capacity)
+    len = available_capacity;
+
+  if (len > 0) {
+    inline_memset(cur_buffer, new_char, len);
+    cur_buffer += len;
+    available_capacity -= len;
+  }
+}
+
+void StringWriter::write(char new_char) {
+  if (1 > available_capacity)
+    return;
+
+  cur_buffer[0] = new_char;
+  ++cur_buffer;
+  available_capacity -= 1;
+}
+
+int StringWriter::write_str(void *raw_pointer, cpp::string_view new_string) {
+  StringWriter *string_writer = reinterpret_cast<StringWriter *>(raw_pointer);
+  string_writer->write(new_string);
+  return WRITE_OK;
+}
+
+int StringWriter::write_chars(void *raw_pointer, char new_char, size_t len) {
+  StringWriter *string_writer = reinterpret_cast<StringWriter *>(raw_pointer);
+  string_writer->write(new_char, len);
+  return WRITE_OK;
+}
+
+int StringWriter::write_char(void *raw_pointer, char new_char) {
   StringWriter *string_writer = reinterpret_cast<StringWriter *>(raw_pointer);
-  string_writer->write(to_write, len);
+  string_writer->write(new_char);
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/vfprintf_internal.cpp

 
 namespace __llvm_libc {
 namespace printf_core {
 
 int vfprintf_internal(::FILE *__restrict stream, const char *__restrict format,
                       internal::ArgList &args) {
   FileWriter file_writer(stream);
   printf_core::Writer writer(reinterpret_cast<void *>(&file_writer),
-                             printf_core::write_to_file);
+                             printf_core::FileWriter::write_str,
+                             printf_core::FileWriter::write_chars,
+                             printf_core::FileWriter::write_char);
   return printf_core::printf_main(&writer, format, args);
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/writer.h

 //===-- Writer definition for printf ----------------------------*- 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 LLVM_LIBC_SRC_STDIO_PRINTF_CORE_WRITER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_WRITER_H
 
+#include "src/__support/CPP/string_view.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-using WriteFunc = int (*)(void *, const char *__restrict, size_t);
+using WriteStrFunc = int (*)(void *, cpp::string_view);
+using WriteCharsFunc = int (*)(void *, char, size_t);
+using WriteCharFunc = int (*)(void *, char);
 
 class Writer final {
   // output is a pointer to the string or file that the writer is meant to write
   // to.
   void *output;
 
   // raw_write is a function that, when called on output with a char* and
   // length, will copy the number of bytes equal to the length from the char*
   // onto the end of output. It should return a positive number or zero on
   // success, or a negative number on failure.
-  WriteFunc raw_write;
+  WriteStrFunc str_write;
+  WriteCharsFunc chars_write;
+  WriteCharFunc char_write;
 
   int chars_written = 0;
 
 public:
-  Writer(void *init_output, WriteFunc init_raw_write)
-      : output(init_output), raw_write(init_raw_write) {}
-
-  // write will copy length bytes from new_string into output using
-  // raw_write. It increments chars_written by length always. It returns the
-  // result of raw_write.
-  int write(const char *new_string, size_t length);
-
-  // write_chars will copy length copies of new_char into output using the write
-  // function and a statically sized buffer. This is primarily used for padding.
-  // If write returns a negative value, this will return early with that value.
-  int write_chars(char new_char, size_t length);
+  Writer(void *init_output, WriteStrFunc init_str_write,
+         WriteCharsFunc init_chars_write, WriteCharFunc init_char_write)
+      : output(init_output), str_write(init_str_write),
+        chars_write(init_chars_write), char_write(init_char_write) {}
+
+  // write will copy new_string into output using str_write. It increments
+  // chars_written by the length of new_string. It returns the result of
+  // str_write.
+  int write(cpp::string_view new_string);
+
+  // this version of write will copy length copies of new_char into output using
+  // chars_write. This is primarily used for padding.  It returns the result of
+  // chars_write.
+  int write(char new_char, size_t len);
+
+  // this version of write will copy just new_char into output. This is often
+  // used for negative signs. It returns the result of chars_write.
+  int write(char new_char);
 
   int get_chars_written() { return chars_written; }
 };
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_WRITER_H

libc/src/stdio/printf_core/writer.cpp

 //===-- Writer definition for printf ----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "writer.h"
-#include "src/string/memory_utils/memset_implementations.h"
+#include "src/__support/CPP/string_view.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-int Writer::write(const char *new_string, size_t length) {
-  chars_written += length;
-  return raw_write(output, new_string, length);
+int Writer::write(cpp::string_view new_string) {
+  chars_written += new_string.size();
+  return str_write(output, new_string);
 }
 
-int Writer::write_chars(char new_char, size_t length) {
-  constexpr size_t BUFF_SIZE = 8;
-  char buff[BUFF_SIZE];
-  int result;
-  inline_memset(buff, new_char, BUFF_SIZE);
-  while (length > BUFF_SIZE) {
-    result = write(buff, BUFF_SIZE);
-    if (result < 0)
-      return result;
-    length -= BUFF_SIZE;
-  }
-  return write(buff, length);
+int Writer::write(char new_char, size_t length) {
+  chars_written += length;
+  return chars_write(output, new_char, length);
+
+int Writer::write(char new_char) {
+  chars_written += 1;
+  return char_write(output, new_char);
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/snprintf.cpp

LLVM_LIBC_FUNCTION(int, snprintf,
   va_list vlist;
   va_start(vlist, format);
   internal::ArgList args(vlist); // This holder class allows for easier copying
                                  // and pointer semantics, as well as handling
                                  // destruction automatically.
   va_end(vlist);
   printf_core::StringWriter str_writer(buffer, (buffsz > 0 ? buffsz - 1 : 0));
   printf_core::Writer writer(reinterpret_cast<void *>(&str_writer),
-                             printf_core::write_to_string);
+                             printf_core::StringWriter::write_str,
+                             printf_core::StringWriter::write_chars,
+                             printf_core::StringWriter::write_char);
 
   int ret_val = printf_core::printf_main(&writer, format, args);
   if (buffsz > 0) // if the buffsz is 0 the buffer may be a null pointer.
     str_writer.terminate();
   return ret_val;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/sprintf.cpp

LLVM_LIBC_FUNCTION(int, sprintf,
   va_list vlist;
   va_start(vlist, format);
   internal::ArgList args(vlist); // This holder class allows for easier copying
                                  // and pointer semantics, as well as handling
                                  // destruction automatically.
   va_end(vlist);
   printf_core::StringWriter str_writer(buffer);
   printf_core::Writer writer(reinterpret_cast<void *>(&str_writer),
-                             printf_core::write_to_string);
+                             printf_core::StringWriter::write_str,
+                             printf_core::StringWriter::write_chars,
+                             printf_core::StringWriter::write_char);
 
   int ret_val = printf_core::printf_main(&writer, format, args);
   str_writer.terminate();
   return ret_val;
 }
 
 } // namespace __llvm_libc

libc/test/src/stdio/printf_core/CMakeLists.txt

 add_libc_unittest(
   parser_test
   SUITE
     libc_stdio_unittests
   SRCS
     parser_test.cpp
   LINK_LIBRARIES
     LibcPrintfHelpers
   DEPENDS
     libc.src.stdio.printf_core.parser
     libc.src.stdio.printf_core.core_structs
+    libc.src.__support.CPP.string_view
     libc.src.__support.arg_list
 )
 
 add_libc_unittest(
   string_writer_test
   SUITE
     libc_stdio_unittests
   SRCS
     string_writer_test.cpp
   DEPENDS
     libc.src.stdio.printf_core.writer
     libc.src.stdio.printf_core.string_writer
+    libc.src.__support.CPP.string_view
 )
 
 add_libc_unittest(
   converter_test
   SUITE
     libc_stdio_unittests
   SRCS
     converter_test.cpp
   DEPENDS
     libc.src.stdio.printf_core.converter
     libc.src.stdio.printf_core.writer
     libc.src.stdio.printf_core.string_writer
     libc.src.stdio.printf_core.core_structs
 )

libc/test/src/stdio/printf_core/converter_test.cpp

protected:
   // void SetUp() override {}
   // void TearDown() override {}
 
   char str[60];
   __llvm_libc::printf_core::StringWriter str_writer =
       __llvm_libc::printf_core::StringWriter(str);
   __llvm_libc::printf_core::Writer writer = __llvm_libc::printf_core::Writer(
       reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+      __llvm_libc::printf_core::StringWriter::write_str,
+      __llvm_libc::printf_core::StringWriter::write_chars,
+      __llvm_libc::printf_core::StringWriter::write_char);
 };
 
 TEST_F(LlvmLibcPrintfConverterTest, SimpleRawConversion) {
   __llvm_libc::printf_core::FormatSection raw_section;
   raw_section.has_conv = false;
   raw_section.raw_string = "abc";
-  raw_section.raw_len = 3;
 
   __llvm_libc::printf_core::convert(&writer, raw_section);
 
   str_writer.terminate();
 
   ASSERT_STREQ(str, "abc");
   ASSERT_EQ(writer.get_chars_written(), 3);
 }
TEST_F(LlvmLibcPrintfConverterTest, IntConversionSimple) {
   __llvm_libc::printf_core::convert(&writer, section);
 
   str_writer.terminate();
 
   ASSERT_STREQ(str, "12345");
   ASSERT_EQ(writer.get_chars_written(), 5);
 }
 
-TEST(LlvmLibcPrintfConverterTest, HexConversion) {
-  char str[20];
-  __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-
+TEST_F(LlvmLibcPrintfConverterTest, HexConversion) {
   __llvm_libc::printf_core::FormatSection section;
   section.has_conv = true;
   section.raw_string = "%#018x";
-  section.raw_len = 6;
   section.conv_name = 'x';
   section.flags = static_cast<__llvm_libc::printf_core::FormatFlags>(
       __llvm_libc::printf_core::FormatFlags::ALTERNATE_FORM |
       __llvm_libc::printf_core::FormatFlags::LEADING_ZEROES);
   section.min_width = 18;
   section.conv_val_raw = 0x123456ab;
   __llvm_libc::printf_core::convert(&writer, section);
 
   str_writer.terminate();
   ASSERT_STREQ(str, "0x00000000123456ab");
   ASSERT_EQ(writer.get_chars_written(), 18);
 }
 
-TEST(LlvmLibcPrintfConverterTest, PointerConversion) {
-  char str[20];
-  __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+TEST_F(LlvmLibcPrintfConverterTest, PointerConversion) {
 
   __llvm_libc::printf_core::FormatSection section;
   section.has_conv = true;
   section.raw_string = "%p";
-  section.raw_len = 2;
   section.conv_name = 'p';
   section.conv_val_ptr = (void *)(0x123456ab);
   __llvm_libc::printf_core::convert(&writer, section);
 
   str_writer.terminate();
   ASSERT_STREQ(str, "0x123456ab");
   ASSERT_EQ(writer.get_chars_written(), 10);
 }
 
-TEST(LlvmLibcPrintfConverterTest, OctConversion) {
-  char str[20];
-  __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+TEST_F(LlvmLibcPrintfConverterTest, OctConversion) {
 
   __llvm_libc::printf_core::FormatSection section;
   section.has_conv = true;
   section.raw_string = "%o";
-  section.raw_len = 2;
   section.conv_name = 'o';
   section.conv_val_raw = 01234;
   __llvm_libc::printf_core::convert(&writer, section);
 
   str_writer.terminate();
   ASSERT_STREQ(str, "1234");
   ASSERT_EQ(writer.get_chars_written(), 4);
 }

libc/test/src/stdio/printf_core/parser_test.cpp

 //===-- Unittests for the printf Parser -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/bit.h"
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/arg_list.h"
 #include "src/stdio/printf_core/parser.h"
 
 #include <stdarg.h>
 
 #include "utils/UnitTest/PrintfMatcher.h"
 #include "utils/UnitTest/Test.h"
 
+using __llvm_libc::cpp::string_view;
+
 void init(const char *__restrict str, ...) {
   va_list vlist;
   va_start(vlist, str);
   __llvm_libc::internal::ArgList v(vlist);
   va_end(vlist);
 
   __llvm_libc::printf_core::Parser parser(str, v);
 }
 
 void evaluate(__llvm_libc::printf_core::FormatSection *format_arr,
               const char *__restrict str, ...) {
   va_list vlist;
   va_start(vlist, str);
   __llvm_libc::internal::ArgList v(vlist);
   va_end(vlist);
 
   __llvm_libc::printf_core::Parser parser(str, v);
 
-  for (auto cur_section = parser.get_next_section(); cur_section.raw_len > 0;
+  for (auto cur_section = parser.get_next_section();
+       !cur_section.raw_string.empty();
        cur_section = parser.get_next_section()) {
     *format_arr = cur_section;
     ++format_arr;
   }
 }
 
 TEST(LlvmLibcPrintfParserTest, Constructor) { init("test", 1, 2); }
 
 TEST(LlvmLibcPrintfParserTest, EvalRaw) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "test";
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = false;
-  expected.raw_len = 4;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 4};
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
   // TODO: add checks that the format_arr after the last one has length 0
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalSimple) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "test %% test";
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = false;
-  expected0.raw_len = 5;
-  expected0.raw_string = str;
+
+  expected0.raw_string = {str, 5};
 
   ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
-  expected1.raw_len = 2;
-  expected1.raw_string = str + 5;
+
+  expected1.raw_string = {str + 5, 2};
   expected1.conv_name = '%';
 
   ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = false;
-  expected2.raw_len = 5;
-  expected2.raw_string = str + 7;
+
+  expected2.raw_string = {str + 7, 5};
 
   ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArg) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 2;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 2};
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithFlags) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%+-0 #d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 7;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 7};
   expected.flags = static_cast<__llvm_libc::printf_core::FormatFlags>(
       __llvm_libc::printf_core::FormatFlags::FORCE_SIGN |
       __llvm_libc::printf_core::FormatFlags::LEFT_JUSTIFIED |
       __llvm_libc::printf_core::FormatFlags::LEADING_ZEROES |
       __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX |
       __llvm_libc::printf_core::FormatFlags::ALTERNATE_FORM);
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithWidth) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%12d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 4;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 4};
   expected.min_width = 12;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithPrecision) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%.34d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 5;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 5};
   expected.precision = 34;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithTrivialPrecision) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%.d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 3;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 3};
   expected.precision = 0;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithShortLengthModifier) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%hd";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 3;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 3};
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::h;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithLongLengthModifier) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%lld";
   long long arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 4;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 4};
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::ll;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalOneArgWithAllOptions) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "% -056.78jd";
   intmax_t arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 11;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 11};
   expected.flags = static_cast<__llvm_libc::printf_core::FormatFlags>(
       __llvm_libc::printf_core::FormatFlags::LEFT_JUSTIFIED |
       __llvm_libc::printf_core::FormatFlags::LEADING_ZEROES |
       __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX);
   expected.min_width = 56;
   expected.precision = 78;
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::j;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalThreeArgs) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%d%f%s";
   int arg1 = 12345;
   double arg2 = 123.45;
   const char *arg3 = "12345";
   evaluate(format_arr, str, arg1, arg2, arg3);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = true;
-  expected0.raw_len = 2;
-  expected0.raw_string = str;
+
+  expected0.raw_string = {str, 2};
   expected0.conv_val_raw = arg1;
   expected0.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
-  expected1.raw_len = 2;
-  expected1.raw_string = str + 2;
+
+  expected1.raw_string = {str + 2, 2};
   expected1.conv_val_raw = __llvm_libc::cpp::bit_cast<uint64_t>(arg2);
   expected1.conv_name = 'f';
 
   ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = true;
-  expected2.raw_len = 2;
-  expected2.raw_string = str + 4;
+
+  expected2.raw_string = {str + 4, 2};
   expected2.conv_val_ptr = const_cast<char *>(arg3);
   expected2.conv_name = 's';
 
   ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 TEST(LlvmLibcPrintfParserTest, IndexModeOneArg) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%1$d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
-  expected.raw_len = 4;
-  expected.raw_string = str;
+
+  expected.raw_string = {str, 4};
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
 TEST(LlvmLibcPrintfParserTest, IndexModeThreeArgsSequential) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%1$d%2$f%3$s";
   int arg1 = 12345;
   double arg2 = 123.45;
   const char *arg3 = "12345";
   evaluate(format_arr, str, arg1, arg2, arg3);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = true;
-  expected0.raw_len = 4;
-  expected0.raw_string = str;
+
+  expected0.raw_string = {str, 4};
   expected0.conv_val_raw = arg1;
   expected0.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
-  expected1.raw_len = 4;
-  expected1.raw_string = str + 4;
+
+  expected1.raw_string = {str + 4, 4};
   expected1.conv_val_raw = __llvm_libc::cpp::bit_cast<uint64_t>(arg2);
   expected1.conv_name = 'f';
 
   ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = true;
-  expected2.raw_len = 4;
-  expected2.raw_string = str + 8;
+
+  expected2.raw_string = {str + 8, 4};
   expected2.conv_val_ptr = const_cast<char *>(arg3);
   expected2.conv_name = 's';
 
   ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }
 
 TEST(LlvmLibcPrintfParserTest, IndexModeThreeArgsReverse) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%3$d%2$f%1$s";
   int arg1 = 12345;
   double arg2 = 123.45;
   const char *arg3 = "12345";
   evaluate(format_arr, str, arg3, arg2, arg1);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = true;
-  expected0.raw_len = 4;
-  expected0.raw_string = str;
+
+  expected0.raw_string = {str, 4};
   expected0.conv_val_raw = arg1;
   expected0.conv_name = 'd';
 
   ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
-  expected1.raw_len = 4;
-  expected1.raw_string = str + 4;
+
+  expected1.raw_string = {str + 4, 4};
   expected1.conv_val_raw = __llvm_libc::cpp::bit_cast<uint64_t>(arg2);
   expected1.conv_name = 'f';
 
   ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = true;
-  expected2.raw_len = 4;
-  expected2.raw_string = str + 8;
+
+  expected2.raw_string = {str + 8, 4};
   expected2.conv_val_ptr = const_cast<char *>(arg3);
   expected2.conv_name = 's';
 
   ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }
 
 TEST(LlvmLibcPrintfParserTest, IndexModeTenArgsRandom) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%6$d%3$d%7$d%2$d%8$d%1$d%4$d%9$d%5$d%10$d";
   int args[10] = {6, 4, 2, 7, 9, 1, 3, 5, 8, 10};
   evaluate(format_arr, str, args[0], args[1], args[2], args[3], args[4],
            args[5], args[6], args[7], args[8], args[9]);
 
   for (size_t i = 0; i < 10; ++i) {
     __llvm_libc::printf_core::FormatSection expected;
     expected.has_conv = true;
-    expected.raw_len = 4 + (i >= 9 ? 1 : 0);
-    expected.raw_string = str + (4 * i);
+
+    expected.raw_string = {str + (4 * i),
+                           static_cast<size_t>(4 + (i >= 9 ? 1 : 0))};
     expected.conv_val_raw = i + 1;
     expected.conv_name = 'd';
     EXPECT_FORMAT_EQ(expected, format_arr[i]);
   }
 }
 
 TEST(LlvmLibcPrintfParserTest, IndexModeComplexParsing) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "normal text %3$llu %% %2$ *4$f %2$ .*4$f %1$1.1c";
   char arg1 = '1';
   double arg2 = 123.45;
   unsigned long long arg3 = 12345;
   int arg4 = 10;
   evaluate(format_arr, str, arg1, arg2, arg3, arg4);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2,
       expected3, expected4, expected5, expected6, expected7, expected8,
       expected9;
 
   expected0.has_conv = false;
-  expected0.raw_len = 12;
-  expected0.raw_string = str;
+
+  expected0.raw_string = {str, 12};
 
   EXPECT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
-  expected1.raw_len = 6;
-  expected1.raw_string = str + 12;
+
+  expected1.raw_string = {str + 12, 6};
   expected1.length_modifier = __llvm_libc::printf_core::LengthModifier::ll;
   expected1.conv_val_raw = arg3;
   expected1.conv_name = 'u';
 
   EXPECT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = false;
-  expected2.raw_len = 1;
-  expected2.raw_string = str + 18;
+
+  expected2.raw_string = {str + 18, 1};
 
   EXPECT_FORMAT_EQ(expected2, format_arr[2]);
 
   expected3.has_conv = true;
-  expected3.raw_len = 2;
-  expected3.raw_string = str + 19;
+
+  expected3.raw_string = {str + 19, 2};
   expected3.conv_name = '%';
 
   EXPECT_FORMAT_EQ(expected3, format_arr[3]);
 
   expected4.has_conv = false;
-  expected4.raw_len = 1;
-  expected4.raw_string = str + 21;
+
+  expected4.raw_string = {str + 21, 1};
 
   EXPECT_FORMAT_EQ(expected4, format_arr[4]);
 
   expected5.has_conv = true;
-  expected5.raw_len = 8;
-  expected5.raw_string = str + 22;
+
+  expected5.raw_string = {str + 22, 8};
   expected5.flags = __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX;
   expected5.min_width = arg4;
   expected5.conv_val_raw = __llvm_libc::cpp::bit_cast<uint64_t>(arg2);
   expected5.conv_name = 'f';
 
   EXPECT_FORMAT_EQ(expected5, format_arr[5]);
 
   expected6.has_conv = false;
-  expected6.raw_len = 1;
-  expected6.raw_string = str + 30;
+
+  expected6.raw_string = {str + 30, 1};
 
   EXPECT_FORMAT_EQ(expected6, format_arr[6]);
 
   expected7.has_conv = true;
-  expected7.raw_len = 9;
-  expected7.raw_string = str + 31;
+
+  expected7.raw_string = {str + 31, 9};
   expected7.flags = __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX;
   expected7.precision = arg4;
   expected7.conv_val_raw = __llvm_libc::cpp::bit_cast<uint64_t>(arg2);
   expected7.conv_name = 'f';
 
   EXPECT_FORMAT_EQ(expected7, format_arr[7]);
 
   expected8.has_conv = false;
-  expected8.raw_len = 1;
-  expected8.raw_string = str + 40;
+
+  expected8.raw_string = {str + 40, 1};
 
   EXPECT_FORMAT_EQ(expected8, format_arr[8]);
 
   expected9.has_conv = true;
-  expected9.raw_len = 7;
-  expected9.raw_string = str + 41;
+
+  expected9.raw_string = {str + 41, 7};
   expected9.min_width = 1;
   expected9.precision = 1;
   expected9.conv_val_raw = arg1;
   expected9.conv_name = 'c';
 
   EXPECT_FORMAT_EQ(expected9, format_arr[9]);
 }
 
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE

libc/test/src/stdio/printf_core/string_writer_test.cpp

 //===-- Unittests for the printf String Writer ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/string_writer.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include "utils/UnitTest/Test.h"
 
+using __llvm_libc::cpp::string_view;
+
+__llvm_libc::printf_core::Writer get_writer(void *str_writer) {
+  return __llvm_libc::printf_core::Writer(
+      str_writer, __llvm_libc::printf_core::StringWriter::write_str,
+      __llvm_libc::printf_core::StringWriter::write_chars,
+      __llvm_libc::printf_core::StringWriter::write_char);
+}
+
 TEST(LlvmLibcPrintfStringWriterTest, Constructor) {
   char str[10];
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, Write) {
   char str[4] = {'D', 'E', 'F', 'G'};
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write("abc", 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write({"abc", 3});
 
   EXPECT_EQ(str[3], 'G');
   // This null terminates the string. The writer has no indication when the
   // string is done, so it relies on the user to tell it when to null terminate
   // the string. Importantly, it can't tell the difference between an intended
   // max length of 0 (write nothing) or 1 (write just a null byte), and so it
   // relies on the caller to do that bounds check.
   str_writer.terminate();
 
   ASSERT_STREQ("abc", str);
   ASSERT_EQ(writer.get_chars_written(), 3);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteMultipleTimes) {
   char str[10];
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write("abc", 3);
-  writer.write("DEF", 3);
-  writer.write("1234", 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write({"abc", 3});
+  writer.write({"DEF", 3});
+  writer.write({"1234", 3});
 
   str_writer.terminate();
 
   ASSERT_STREQ("abcDEF123", str);
   ASSERT_EQ(writer.get_chars_written(), 9);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteChars) {
   char str[4] = {'D', 'E', 'F', 'G'};
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('a', 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('a', 3);
 
   EXPECT_EQ(str[3], 'G');
   str_writer.terminate();
 
   ASSERT_STREQ("aaa", str);
   ASSERT_EQ(writer.get_chars_written(), 3);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteCharsMultipleTimes) {
   char str[10];
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('a', 3);
-  writer.write_chars('D', 3);
-  writer.write_chars('1', 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('a', 3);
+  writer.write('D', 3);
+  writer.write('1', 3);
 
   str_writer.terminate();
 
   ASSERT_STREQ("aaaDDD111", str);
   ASSERT_EQ(writer.get_chars_written(), 9);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteManyChars) {
   char str[100];
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('Z', 99);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('Z', 99);
 
   str_writer.terminate();
 
   ASSERT_STREQ("ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZZ"
                "ZZZZZZZZZ",
                str);
   ASSERT_EQ(writer.get_chars_written(), 99);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, MixedWrites) {
   char str[13];
   __llvm_libc::printf_core::StringWriter str_writer(str);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('a', 3);
-  writer.write("DEF", 3);
-  writer.write_chars('1', 3);
-  writer.write("456", 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('a', 3);
+  writer.write({"DEF", 3});
+  writer.write('1', 3);
+  writer.write({"456", 3});
 
   str_writer.terminate();
 
   ASSERT_STREQ("aaaDEF111456", str);
   ASSERT_EQ(writer.get_chars_written(), 12);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteWithMaxLength) {
   char str[11];
   __llvm_libc::printf_core::StringWriter str_writer(str, 10);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write("abcDEF123456", 12);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write({"abcDEF123456", 12});
 
   str_writer.terminate();
 
   ASSERT_STREQ("abcDEF1234", str);
   ASSERT_EQ(writer.get_chars_written(), 12);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, WriteCharsWithMaxLength) {
   char str[11];
   __llvm_libc::printf_core::StringWriter str_writer(str, 10);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
 
-  writer.write_chars('1', 15);
+  writer.write('1', 15);
 
   str_writer.terminate();
 
   ASSERT_STREQ("1111111111", str);
   ASSERT_EQ(writer.get_chars_written(), 15);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, MixedWriteWithMaxLength) {
   char str[11];
   __llvm_libc::printf_core::StringWriter str_writer(str, 10);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('a', 3);
-  writer.write("DEF", 3);
-  writer.write_chars('1', 3);
-  writer.write("456", 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('a', 3);
+  writer.write({"DEF", 3});
+  writer.write('1', 3);
+  writer.write({"456", 3});
 
   str_writer.terminate();
 
   ASSERT_STREQ("aaaDEF1114", str);
   ASSERT_EQ(writer.get_chars_written(), 12);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, StringWithMaxLengthOne) {
   char str[1];
   __llvm_libc::printf_core::StringWriter str_writer(str, 0);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
   // This is because the max length should be at most 1 less than the size of
   // the buffer it's writing to.
-  writer.write_chars('a', 3);
-  writer.write("DEF", 3);
-  writer.write_chars('1', 3);
-  writer.write("456", 3);
+  writer.write('a', 3);
+  writer.write({"DEF", 3});
+  writer.write('1', 3);
+  writer.write({"456", 3});
 
   str_writer.terminate();
 
   ASSERT_STREQ("", str);
   ASSERT_EQ(writer.get_chars_written(), 12);
 }
 
 TEST(LlvmLibcPrintfStringWriterTest, NullStringWithZeroMaxLength) {
   __llvm_libc::printf_core::StringWriter str_writer(nullptr, 0);
-  __llvm_libc::printf_core::Writer writer(
-      reinterpret_cast<void *>(&str_writer),
-      __llvm_libc::printf_core::write_to_string);
-  writer.write_chars('a', 3);
-  writer.write("DEF", 3);
-  writer.write_chars('1', 3);
-  writer.write("456", 3);
+  __llvm_libc::printf_core::Writer writer =
+      get_writer(reinterpret_cast<void *>(&str_writer));
+  writer.write('a', 3);
+  writer.write({"DEF", 3});
+  writer.write('1', 3);
+  writer.write({"456", 3});
 
   ASSERT_EQ(writer.get_chars_written(), 12);
 }

libc/utils/UnitTest/CMakeLists.txt

LibcPrintfHelpers
     PrintfMatcher.h
     PrintfMatcher.cpp
 )
 target_include_directories(LibcPrintfHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcPrintfHelpers LibcUnitTest)
 add_dependencies(
   LibcPrintfHelpers
   LibcUnitTest
-  libc.src.__support.CPP.uint128
+  libc.src.__support.FPUtil.fputil #FPBits
   libc.src.stdio.printf_core.core_structs
   libc.utils.UnitTest.string_utils
 )

libc/utils/UnitTest/PrintfMatcher.cpp

 //===-- PrintfMatcher.cpp ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrintfMatcher.h"
 
-#include "src/__support/CPP/UInt128.h"
+#include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include "utils/UnitTest/StringUtils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace printf_core {
if ((form.flags & FormatFlags::flag_name) == FormatFlags::flag_name)       \
       stream << "\n\t\t" << #flag_name;                                        \
   } while (false)
 #define CASE_LM(lm)                                                            \
   case (LengthModifier::lm):                                                   \
     stream << #lm;                                                             \
     break
 
 void display(testutils::StreamWrapper &stream, FormatSection form) {
-  stream << "Raw String (len " << form.raw_len << "): \"";
-  for (size_t i = 0; i < form.raw_len; ++i) {
+  stream << "Raw String (len " << form.raw_string.size() << "): \"";
+  for (size_t i = 0; i < form.raw_string.size(); ++i) {
     stream << form.raw_string[i];
   }
   stream << "\"";
   if (form.has_conv) {
     stream << "\n\tHas Conv\n\tFlags:";
     IF_FLAG_SHOW_FLAG(LEFT_JUSTIFIED);
     IF_FLAG_SHOW_FLAG(FORCE_SIGN);
     IF_FLAG_SHOW_FLAG(SPACE_PREFIX);
if (form.has_conv) {
     stream << "\n";
     stream << "\tconversion name: " << form.conv_name << "\n";
     if (form.conv_name == 'p' || form.conv_name == 'n' || form.conv_name == 's')
       stream << "\tpointer value: "
              << int_to_hex<uintptr_t>(
                     reinterpret_cast<uintptr_t>(form.conv_val_ptr))
              << "\n";
     else if (form.conv_name != '%')
-      stream << "\tvalue: " << int_to_hex<UInt128>(form.conv_val_raw) << "\n";
+      stream << "\tvalue: "
+             << int_to_hex<fputil::FPBits<long double>::UIntType>(
+                    form.conv_val_raw)
+             << "\n";
   }
 }
 } // anonymous namespace
 
 void FormatSectionMatcher::explainError(testutils::StreamWrapper &stream) {
   stream << "expected format section: ";
   display(stream, expected);
   stream << '\n';
   stream << "actual format section  : ";
   display(stream, actual);
   stream << '\n';
 }
 
 } // namespace testing
 } // namespace printf_core
 } // namespace __llvm_libc