[libc] simplify printf float writing

[michaelrj]

Summary

The two decimal float printing styles are similar, but different in how
they end. For simplicity of writing I initially gave them different
"write_last_block" functions. This patch unifies them into one function.

libc/src/stdio/printf_core/float_dec_converter.h

if (block == MAX_BLOCK) { // Buffer max blocks in case of rounding
         block_buffer[count] = int_to_str[count + 1];
       }
 
       buffered_digits = BLOCK_SIZE;
     }
     return 0;
   }
 
-  int write_last_block_dec(BlockInt block, size_t block_digits,
-                           RoundDirection round) {
-    char end_buff[BLOCK_SIZE];
-
-    const DecimalString buf(block + (MAX_BLOCK + 1));
-    const cpp::string_view int_to_str = buf.view();
-
-    // copy the last block_digits characters into the start of end_buff.
-    // TODO: Replace with memcpy
-    for (size_t count = 0; count < block_digits; ++count) {
-      end_buff[count] = int_to_str[count + 1 + (BLOCK_SIZE - block_digits)];
-    }
-
-    char low_digit = '0';
-    if (block_digits > 0) {
-      low_digit = end_buff[block_digits - 1];
-    } else if (max_block_count > 0) {
-      low_digit = '9';
-    } else if (buffered_digits > 0) {
-      low_digit = block_buffer[buffered_digits - 1];
-    }
-
-    bool round_up_max_blocks = false;
-
-    // Round up
-    if (round == RoundDirection::Up ||
-        (round == RoundDirection::Even && low_digit % 2 != 0)) {
-      bool has_carry = true;
-      round_up_max_blocks = true; // if we're rounding up, we might need to
-                                  // round up the max blocks that are buffered.
-      // handle the low block that we're adding
-      for (int count = static_cast<int>(block_digits) - 1;
-           count >= 0 && has_carry; --count) {
-        if (end_buff[count] == '9') {
-          end_buff[count] = '0';
-        } else {
-          end_buff[count] += 1;
-          has_carry = false;
-          round_up_max_blocks = false; // If the low block isn't all nines, then
-                                       // the max blocks aren't rounded up.
-        }
-      }
-      // handle the high block that's buffered
-      for (int count = static_cast<int>(buffered_digits) - 1;
-           count >= 0 && has_carry; --count) {
-        if (block_buffer[count] == '9') {
-          block_buffer[count] = '0';
-        } else {
-          block_buffer[count] += 1;
-          has_carry = false;
-        }
-      }
-
-      // has_carry should only be true here if every previous digit is 9, which
-      // implies that the number has never been written.
-      if (has_carry /* && !has_written */) {
-        ++total_digits;
-        ++digits_before_decimal;
-        // Normally write_left_padding is called by flush_buffer but since we're
-        // rounding up all of the digits, the ones in the buffer are wrong and
-        // can't be flushed.
-        RET_IF_RESULT_NEGATIVE(
-            padding_writer.write_left_padding(writer, total_digits));
-        // Now we know we need to print a leading 1, zeroes up to the decimal
-        // point, the decimal point, and then finally digits after it.
-        RET_IF_RESULT_NEGATIVE(writer->write('1'));
-        // digits_before_decimal - 1 to account for the leading '1'
-        RET_IF_RESULT_NEGATIVE(writer->write('0', digits_before_decimal - 1));
-        if (has_decimal_point) {
-          RET_IF_RESULT_NEGATIVE(writer->write(DECIMAL_POINT));
-          // add one to digits_before_decimal to account for the decimal point
-          // itself.
-          if (total_digits > digits_before_decimal + 1) {
-            RET_IF_RESULT_NEGATIVE(
-                writer->write('0', total_digits - (digits_before_decimal + 1)));
-          }
-        }
-        total_digits_written = total_digits;
-        return 0;
-      }
-    }
-    // Either we intend to round down, or the rounding up is complete. Flush the
-    // buffers.
-
-    RET_IF_RESULT_NEGATIVE(flush_buffer(round_up_max_blocks));
-
-    // And then write the final block.
-    RET_IF_RESULT_NEGATIVE(writer->write({end_buff, block_digits}));
-    total_digits_written += block_digits;
-    return 0;
-  }
+  int write_last_block(BlockInt block, size_t block_digits,
+                       RoundDirection round, int exponent = 0,
+                       char exp_char = '\0') {
+    bool has_exp = (exp_char != '\0');
 
-  int write_last_block_exp(uint32_t block, size_t block_digits,
-                           RoundDirection round, int exponent, char exp_char) {
     char end_buff[BLOCK_SIZE];
 
     {
       const DecimalString buf(block + (MAX_BLOCK + 1));
       const cpp::string_view int_to_str = buf.view();
 
       // copy the last block_digits characters into the start of end_buff.
       // TODO: Replace with memcpy
if (round == RoundDirection::Up ||
           block_buffer[count] += 1;
           has_carry = false;
         }
       }
 
       // has_carry should only be true here if every previous digit is 9, which
       // implies that the number has never been written.
       if (has_carry /* && !has_written */) {
+        if (has_exp) { // This is in %e style
           // Since this is exponential notation, we don't write any more digits
           // but we do increment the exponent.
           ++exponent;
 
           const ExponentString buf(exponent);
           const cpp::string_view int_to_str = buf.view();
 
           // TODO: also change this to calculate the width of the number more
           // efficiently.
           size_t exponent_width = int_to_str.size();
           size_t number_digits =
               buffered_digits + (max_block_count * BLOCK_SIZE) + block_digits;
 
           // Here we have to recalculate the total number of digits since the
           // exponent's width may have changed. We're only adding 1 to exponent
           // width since exp_str appends the sign.
           total_digits =
               (has_decimal_point ? 1 : 0) + number_digits + 1 + exponent_width;
 
-        // Normally write_left_padding is called by flush_buffer but since we're
-        // rounding up all of the digits, the ones in the buffer are wrong and
-        // can't be flushed.
+          // Normally write_left_padding is called by flush_buffer but since
+          // we're rounding up all of the digits, the ones in the buffer are
+          // wrong and can't be flushed.
           RET_IF_RESULT_NEGATIVE(
               padding_writer.write_left_padding(writer, total_digits));
-        // Now we know we need to print a leading 1, the decimal point, and then
-        // zeroes after it.
+          // Now we know we need to print a leading 1, the decimal point, and
+          // then zeroes after it.
           RET_IF_RESULT_NEGATIVE(writer->write('1'));
           // digits_before_decimal - 1 to account for the leading '1'
           if (has_decimal_point) {
             RET_IF_RESULT_NEGATIVE(writer->write(DECIMAL_POINT));
             // This is just the length of the number, not including the decimal
             // point, or exponent.
 
             if (number_digits > 1) {
               RET_IF_RESULT_NEGATIVE(writer->write('0', number_digits - 1));
             }
           }
           RET_IF_RESULT_NEGATIVE(writer->write(exp_char));
           RET_IF_RESULT_NEGATIVE(writer->write(int_to_str));
 
           total_digits_written = total_digits;
           return WRITE_OK;
+        } else { // This is in %f style
+          ++total_digits;
+          ++digits_before_decimal;
+          // Normally write_left_padding is called by flush_buffer but since
+          // we're rounding up all of the digits, the ones in the buffer are
+          // wrong and can't be flushed.
+          RET_IF_RESULT_NEGATIVE(
+              padding_writer.write_left_padding(writer, total_digits));
+          // Now we know we need to print a leading 1, zeroes up to the decimal
+          // point, the decimal point, and then finally digits after it.
+          RET_IF_RESULT_NEGATIVE(writer->write('1'));
+          // digits_before_decimal - 1 to account for the leading '1'
+          RET_IF_RESULT_NEGATIVE(writer->write('0', digits_before_decimal - 1));
+          if (has_decimal_point) {
+            RET_IF_RESULT_NEGATIVE(writer->write(DECIMAL_POINT));
+            // add one to digits_before_decimal to account for the decimal point
+            // itself.
+            if (total_digits > digits_before_decimal + 1) {
+              RET_IF_RESULT_NEGATIVE(writer->write(
+                  '0', total_digits - (digits_before_decimal + 1)));
+            }
+          }
+          total_digits_written = total_digits;
+          return WRITE_OK;
+        }
       }
     }
     // Either we intend to round down, or the rounding up is complete. Flush the
     // buffers.
 
     RET_IF_RESULT_NEGATIVE(flush_buffer(round_up_max_blocks));
 
     // And then write the final block. It's written via the buffer so that if
     // this is also the first block, the decimal point will be placed correctly.
 
     // TODO: Replace with memcpy
     for (size_t count = 0; count < block_digits; ++count) {
       block_buffer[count] = end_buff[count];
     }
     buffered_digits = block_digits;
     RET_IF_RESULT_NEGATIVE(flush_buffer());
 
+    if (has_exp) {
       RET_IF_RESULT_NEGATIVE(writer->write(exp_char));
       const ExponentString buf(exponent);
       RET_IF_RESULT_NEGATIVE(writer->write(buf.view()));
-
+    }
     total_digits_written = total_digits;
 
     return WRITE_OK;
   }
 
   int write_zeroes(uint32_t num_zeroes) {
     RET_IF_RESULT_NEGATIVE(flush_buffer());
     RET_IF_RESULT_NEGATIVE(writer->write('0', num_zeroes));
for (; i < blocks; ++i) {
         }
         RoundDirection round;
         const bool truncated =
             !zero_after_digits(exponent - MANT_WIDTH, precision,
                                float_bits.get_explicit_mantissa());
         round = get_round_direction(last_digit, truncated, is_negative);
 
         RET_IF_RESULT_NEGATIVE(
-            float_writer.write_last_block_dec(digits, maximum, round));
+            float_writer.write_last_block(digits, maximum, round));
         break;
       }
     }
   } else {
     RET_IF_RESULT_NEGATIVE(float_writer.write_zeroes(precision));
   }
   RET_IF_RESULT_NEGATIVE(float_writer.right_pad());
   return WRITE_OK;
if (!truncated && exponent - MANT_WIDTH < 0) {
       // Use the formula from %f.
       truncated =
           !zero_after_digits(exponent - MANT_WIDTH, precision - final_exponent,
                              float_bits.get_explicit_mantissa());
     }
   }
   round = get_round_direction(last_digit, truncated, is_negative);
 
-  RET_IF_RESULT_NEGATIVE(float_writer.write_last_block_exp(
+  RET_IF_RESULT_NEGATIVE(float_writer.write_last_block(
       digits, maximum, round, final_exponent, a + 'E' - 'A'));
 
   RET_IF_RESULT_NEGATIVE(float_writer.right_pad());
   return WRITE_OK;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,