[libc] clean up printf error codes

[michaelrj]

Summary

Move the constants for printf's return values into core_structs, and
update the converters to match.

[michaelrj]

rebase to include float hex changes

libc/src/stdio/printf_core/CMakeLists.txt

 add_object_library(
   string_writer
   SRCS
     string_writer.cpp
   HDRS
     string_writer.h
   DEPENDS
     libc.src.string.memory_utils.memcpy_implementation
+    .core_structs
 )
 
 add_object_library(
   file_writer
   SRCS
     file_writer.cpp
   HDRS
     file_writer.h
   DEPENDS
     libc.src.__support.File.file
+    .core_structs
 )
 
 add_object_library(
   writer
   SRCS
     writer.cpp
   HDRS
     writer.h

libc/src/stdio/printf_core/char_converter.h

if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
       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));
   }
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CHAR_CONVERTER_H

libc/src/stdio/printf_core/core_structs.h

if (has_conv) {
       if (conv_name == 'p' || conv_name == 'n' || conv_name == 's')
         return (conv_val_ptr == other.conv_val_ptr);
       else if (conv_name != '%')
         return (conv_val_raw == other.conv_val_raw);
     }
     return true;
   }
 };
+
+// This is the value to be returned by conversions when no error has occurred.
+constexpr int WRITE_OK = 0;
+// These are the printf return values for when an error has occurred. They are
+// all negative, and should be distinct.
+constexpr int FILE_WRITE_ERROR = -1;
+constexpr int FILE_STATUS_ERROR = -2;
+constexpr int NULLPTR_WRITE_ERROR = -3;
+
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CORE_STRUCTS_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/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 = -1;
+    written = FILE_WRITE_ERROR;
   if (file->error_unlocked())
-    written = -2;
+    written = FILE_STATUS_ERROR;
   return written;
 }
 
 int write_to_file(void *raw_pointer, const char *__restrict to_write,
                   size_t len) {
   FileWriter *file_writer = reinterpret_cast<FileWriter *>(raw_pointer);
   return file_writer->write(to_write, len);
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/float_hex_converter.h

if (is_inf_or_nan) {
     } else { // nan
       RET_IF_RESULT_NEGATIVE(writer->write((a == 'a' ? "nan" : "NAN"), 3));
     }
 
     if (padding > 0 && ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
                         FormatFlags::LEFT_JUSTIFIED))
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', padding));
 
-    return 0;
+    return WRITE_OK;
   }
 
   // Handle the exponent for numbers with a 0 exponent
   if (exponent == -exponent_bias) {
     if (mantissa > 0) // Subnormals
       ++exponent;
     else // Zeroes
       exponent = 0;
if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
     if (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(exp_buffer + exp_cur, EXP_LEN - exp_cur));
   }
-  return 0;
+  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/hex_converter.h

if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
     if (prefix[0] != 0)
       RET_IF_RESULT_NEGATIVE(writer->write(prefix, 2));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
       RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, digits_written));
   }
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_HEX_CONVERTER_H

libc/src/stdio/printf_core/int_converter.h

if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
     if (sign_char != 0)
       RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
       RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, digits_written));
   }
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H

libc/src/stdio/printf_core/oct_converter.h

if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
     // Else the pattern is spaces zeroes digits
     if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (num_digits > 0)
       RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, num_digits));
   }
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_OCT_CONVERTER_H

libc/src/stdio/printf_core/ptr_converter.h

int inline convert_pointer(Writer *writer, const FormatSection &to_conv) {
   } 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_hex(writer, hex_conv);
   }
-  return 0;
+  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

if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
           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));
   }
-  return 0;
+  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.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/stdio/printf_core/core_structs.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 void StringWriter::write(const char *__restrict to_write, size_t len) {
   if (len > available_capacity)
     len = available_capacity;
 
   if (len > 0) {
     inline_memcpy(cur_buffer, to_write, len);
     cur_buffer += len;
     available_capacity -= len;
   }
 }
 
 int write_to_string(void *raw_pointer, const char *__restrict to_write,
                     size_t len) {
   StringWriter *string_writer = reinterpret_cast<StringWriter *>(raw_pointer);
   string_writer->write(to_write, len);
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/write_int_converter.h

 namespace printf_core {
 
 int inline convert_write_int(Writer *writer, const FormatSection &to_conv) {
 
   // This is an additional check added by LLVM-libc. The reason it returns -3 is
   // because printf uses negative return values for errors, and -1 and -2 are
   // already in use by the file_writer class for file errors.
   if (to_conv.conv_val_ptr == nullptr)
-    return -3;
+    return NULLPTR_WRITE_ERROR;
 
   int written = writer->get_chars_written();
 
   switch (to_conv.length_modifier) {
   case LengthModifier::none:
     *reinterpret_cast<int *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::l:
case LengthModifier::z:
     break;
   case LengthModifier::t:
     *reinterpret_cast<ptrdiff_t *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::j:
     *reinterpret_cast<uintmax_t *>(to_conv.conv_val_ptr) = written;
     break;
   }
-  return 0;
+  return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_WRITE_INT_CONVERTER_H