[libc] add scanf current position conversion

[michaelrj]

Summary

To add the current position (%n) conversion, some reorganization needed
to be done. The "write a number to this pointer using the length
modifier" utilities and a couple other shared parsing functions have
been moved into converter_utils.h. This made implementing
current_pos_converter very simple.

[lntue]

libc/src/stdio/scanf_core/converter_utils.h

24–34

For consistency, can you keep LIBC_INLINE before return types in the definitions.

libc/src/stdio/scanf_core/current_pos_converter.cpp

19 ↗

(On Diff #491862)

This function is quite short. Will it get more complicated later? Otherwise you can inline it in the header instead.

[sivachandra]

libc/src/stdio/scanf_core/converter_utils.h

24–34

Not just consistency, it is a requirement as we want to be able to add attributes. I will update the documentation with this information. It should be listed before constexpr also.

[michaelrj]

move inline annotations in function headers
remove current_pos_converter.cpp

libc/src/stdio/scanf_core/current_pos_converter.cpp

19 ↗

(On Diff #491862)

I moved it to the header and also tagged it as LIBC_INLINE.

libc/src/stdio/scanf_core/CMakeLists.txt

add_object_library(
   converter
   SRCS
     converter.cpp
     string_converter.cpp
     int_converter.cpp
     float_converter.cpp
   HDRS
     converter.h
+    converter_utils.h
     int_converter.h
     string_converter.h
     float_converter.h
+    current_pos_converter.h
   DEPENDS
     .reader
     .core_structs
+    libc.src.__support.common
     libc.src.__support.ctype_utils
     libc.src.__support.CPP.bitset
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.limits
     libc.src.__support.char_vector
-    libc.include.errno
-    libc.src.errno.errno
+    libc.src.__support.str_to_float
 )
 
 add_object_library(
   vfscanf_internal
   SRCS
     vfscanf_internal.cpp
   HDRS
     vfscanf_internal.h
   DEPENDS
     .reader
     .file_reader
     .scanf_main
     libc.src.__support.arg_list
 )

libc/src/stdio/scanf_core/converter.cpp

 
 #include "src/__support/ctype_utils.h"
 #include "src/stdio/scanf_core/core_structs.h"
 #include "src/stdio/scanf_core/reader.h"
 
 #ifndef LLVM_LIBC_SCANF_DISABLE_FLOAT
 #include "src/stdio/scanf_core/float_converter.h"
 #endif // LLVM_LIBC_SCANF_DISABLE_FLOAT
+#include "src/stdio/scanf_core/current_pos_converter.h"
 #include "src/stdio/scanf_core/int_converter.h"
 #include "src/stdio/scanf_core/string_converter.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
#ifndef LLVM_LIBC_SCANF_DISABLE_FLOAT
   case 'A':
   case 'g':
   case 'G':
     ret_val = raw_match(reader, " ");
     if (ret_val != READ_OK)
       return ret_val;
     return convert_float(reader, to_conv);
 #endif // LLVM_LIBC_SCANF_DISABLE_FLOAT
-    //   case 'n':
-    //     return convert_write_int(reader, to_conv);
+  case 'n':
+    return convert_current_pos(reader, to_conv);
     //   case 'p':
     //     ret_val = raw_match(reader, " ");
     //     if (ret_val != READ_OK)
     //       return ret_val;
     //     return convert_pointer(reader, to_conv);
   default:
     return raw_match(reader, to_conv.raw_string);
   }

libc/src/stdio/scanf_core/converter_utils.h

+//===-- Format specifier converter for scanf -------------------*- 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_SCANF_CORE_CONVERTER_UTILS_H
+#define LLVM_LIBC_SRC_STDIO_SCANF_CORE_CONVERTER_UTILS_H
+
+#include "src/__support/common.h"
+#include "src/__support/ctype_utils.h"
+#include "src/__support/str_to_float.h"
+#include "src/stdio/scanf_core/core_structs.h"
+#include "src/stdio/scanf_core/reader.h"
+
+#include <stddef.h>
+
+namespace __llvm_libc {
+namespace scanf_core {
+
+LIBC_INLINE constexpr char to_lower(char a) { return a | 32; }
+
+LIBC_INLINE constexpr int b36_char_to_int(char input) {
+  if (internal::isdigit(input))
+    return input - '0';
+  if (internal::isalpha(input))
+    return to_lower(input) + 10 - 'a';
+  return 0;
+}
+
+LIBC_INLINE void write_int_with_length(uintmax_t output_val,
+                                       const FormatSection &to_conv) {
+  if ((to_conv.flags & NO_WRITE) != 0) {
+    return;
+  }
+  LengthModifier lm = to_conv.length_modifier;
+  void *output_ptr = to_conv.output_ptr;
+  switch (lm) {
+  case (LengthModifier::hh):
+    *reinterpret_cast<unsigned char *>(output_ptr) =
+        static_cast<unsigned char>(output_val);
+    break;
+  case (LengthModifier::h):
+    *reinterpret_cast<unsigned short *>(output_ptr) =
+        static_cast<unsigned short>(output_val);
+    break;
+  case (LengthModifier::NONE):
+    *reinterpret_cast<unsigned int *>(output_ptr) =
+        static_cast<unsigned int>(output_val);
+    break;
+  case (LengthModifier::l):
+    *reinterpret_cast<unsigned long *>(output_ptr) =
+        static_cast<unsigned long>(output_val);
+    break;
+  case (LengthModifier::ll):
+  case (LengthModifier::L):
+    *reinterpret_cast<unsigned long long *>(output_ptr) =
+        static_cast<unsigned long long>(output_val);
+    break;
+  case (LengthModifier::j):
+    *reinterpret_cast<uintmax_t *>(output_ptr) =
+        static_cast<uintmax_t>(output_val);
+    break;
+  case (LengthModifier::z):
+    *reinterpret_cast<size_t *>(output_ptr) = static_cast<size_t>(output_val);
+    break;
+  case (LengthModifier::t):
+    *reinterpret_cast<ptrdiff_t *>(output_ptr) =
+        static_cast<ptrdiff_t>(output_val);
+    break;
+  }
+}
+
+LIBC_INLINE void write_float_with_length(char *str,
+                                         const FormatSection &to_conv) {
+  if ((to_conv.flags & NO_WRITE) != 0) {
+    return;
+  }
+
+  void *output_ptr = to_conv.output_ptr;
+
+  LengthModifier lm = to_conv.length_modifier;
+  switch (lm) {
+  case (LengthModifier::l): {
+    auto value = internal::strtofloatingpoint<double>(str, nullptr);
+    *reinterpret_cast<double *>(output_ptr) = value;
+    break;
+  }
+  case (LengthModifier::L): {
+    auto value = internal::strtofloatingpoint<long double>(str, nullptr);
+    *reinterpret_cast<long double *>(output_ptr) = value;
+    break;
+  }
+  default: {
+    auto value = internal::strtofloatingpoint<float>(str, nullptr);
+    *reinterpret_cast<float *>(output_ptr) = value;
+    break;
+  }
+  }
+}
+
+} // namespace scanf_core
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_CONVERTER_UTILS_H

libc/src/stdio/scanf_core/current_pos_converter.h

+//===-- Current position specifier converter for scanf ----------*- 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_SCANF_CORE_CURRENT_POS_CONVERTER_H
+#define LLVM_LIBC_SRC_STDIO_SCANF_CORE_CURRENT_POS_CONVERTER_H
+
+#include "src/__support/common.h"
+#include "src/stdio/scanf_core/converter_utils.h"
+#include "src/stdio/scanf_core/core_structs.h"
+#include "src/stdio/scanf_core/reader.h"
+
+#include <stddef.h>
+
+namespace __llvm_libc {
+namespace scanf_core {
+
+LIBC_INLINE int convert_current_pos(Reader *reader,
+                                    const FormatSection &to_conv) {
+  write_int_with_length(reader->chars_read(), to_conv);
+  return READ_OK;
+}
+
+} // namespace scanf_core
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_CURRENT_POS_CONVERTER_H

libc/src/stdio/scanf_core/float_converter.cpp

 //===-- Int type specifier converters for scanf -----------------*- 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/scanf_core/float_converter.h"
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/char_vector.h"
 #include "src/__support/ctype_utils.h"
-#include "src/__support/str_to_float.h"
+#include "src/stdio/scanf_core/converter_utils.h"
 #include "src/stdio/scanf_core/core_structs.h"
 #include "src/stdio/scanf_core/reader.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-constexpr char inline to_lower(char a) { return a | 32; }
-
-void write_with_length(char *str, const FormatSection &to_conv) {
-  if ((to_conv.flags & NO_WRITE) != 0) {
-    return;
-  }
-
-  void *output_ptr = to_conv.output_ptr;
-
-  LengthModifier lm = to_conv.length_modifier;
-  switch (lm) {
-  case (LengthModifier::l): {
-    auto value = internal::strtofloatingpoint<double>(str, nullptr);
-    *reinterpret_cast<double *>(output_ptr) = value;
-    break;
-  }
-  case (LengthModifier::L): {
-    auto value = internal::strtofloatingpoint<long double>(str, nullptr);
-    *reinterpret_cast<long double *>(output_ptr) = value;
-    break;
-  }
-  default: {
-    auto value = internal::strtofloatingpoint<float>(str, nullptr);
-    *reinterpret_cast<float *>(output_ptr) = value;
-    break;
-  }
-  }
-}
-
 // All of the floating point conversions are the same for scanf, every name will
 // accept every style.
 int convert_float(Reader *reader, const FormatSection &to_conv) {
   // %a/A/e/E/f/F/g/G "Matches an optionally signed floating-point number,
   // infinity, or NaN, whose format is the same as expected for the subject
   // sequence of the strtod function. The corresponding argument shall be a
   // pointer to floating."
 
for (; to_lower(cur_char) == inf_string[inf_index] &&
          ++inf_index) {
       if (!out_str.append(cur_char)) {
         return ALLOCATION_FAILURE;
       }
       cur_char = reader->getc();
     }
 
     if (inf_index == 3 || inf_index == sizeof(inf_string) - 1) {
-      write_with_length(out_str.c_str(), to_conv);
+      write_float_with_length(out_str.c_str(), to_conv);
       return READ_OK;
     } else {
       return MATCHING_FAILURE;
     }
   }
 
   static const char nan_string[] = "nan";
 
   // Handle nan
   if (to_lower(cur_char) == nan_string[0]) {
     size_t nan_index = 0;
 
     for (; to_lower(cur_char) == nan_string[nan_index] &&
            nan_index < sizeof(nan_string) && out_str.length() < max_width;
          ++nan_index) {
       if (!out_str.append(cur_char)) {
         return ALLOCATION_FAILURE;
       }
       cur_char = reader->getc();
     }
 
     if (nan_index == sizeof(nan_string) - 1) {
-      write_with_length(out_str.c_str(), to_conv);
+      write_float_with_length(out_str.c_str(), to_conv);
       return READ_OK;
     } else {
       return MATCHING_FAILURE;
     }
   }
 
   // Assume base of 10 by default but check if it is actually base 16.
   int base = 10;
 
   // If the string starts with 0 it might be in hex.
   if (cur_char == '0') {
     is_number = true;
     // Read the next character to check.
     if (!out_str.append(cur_char)) {
       return ALLOCATION_FAILURE;
     }
     // If we've hit the end, then this is "0", which is valid.
     if (out_str.length() == max_width) {
-      write_with_length(out_str.c_str(), to_conv);
+      write_float_with_length(out_str.c_str(), to_conv);
       return READ_OK;
     } else {
       cur_char = reader->getc();
     }
 
     // If that next character is an 'x' then this is a hexadecimal number.
     if (to_lower(cur_char) == 'x') {
       base = 16;
 
       if (!out_str.append(cur_char)) {
         return ALLOCATION_FAILURE;
       }
       // If we've hit the end here, we have "0x" which is a valid prefix to a
       // floating point number, and will be evaluated to 0.
       if (out_str.length() == max_width) {
-        write_with_length(out_str.c_str(), to_conv);
+        write_float_with_length(out_str.c_str(), to_conv);
         return READ_OK;
       } else {
         cur_char = reader->getc();
       }
     }
   }
 
   const char exponent_mark = ((base == 10) ? 'e' : 'p');
int convert_float(Reader *reader, const FormatSection &to_conv) {
   // last one back.
   reader->ungetc(cur_char);
 
   // If we haven't actually found any digits, this is a matching failure (this
   // catches cases like "+.")
   if (!is_number) {
     return MATCHING_FAILURE;
   }
-  write_with_length(out_str.c_str(), to_conv);
+  write_float_with_length(out_str.c_str(), to_conv);
 
   return READ_OK;
 }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/int_converter.cpp

 //===-- Int type specifier converters for scanf -----------------*- 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/scanf_core/int_converter.h"
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/ctype_utils.h"
+#include "src/stdio/scanf_core/converter_utils.h"
 #include "src/stdio/scanf_core/core_structs.h"
 #include "src/stdio/scanf_core/reader.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-constexpr char inline to_lower(char a) { return a | 32; }
-
-constexpr inline int b36_char_to_int(char input) {
-  if (internal::isdigit(input))
-    return input - '0';
-  if (internal::isalpha(input))
-    return to_lower(input) + 10 - 'a';
-  return 0;
-}
-
-void write_with_length(uintmax_t output_val, const FormatSection &to_conv) {
-  if ((to_conv.flags & NO_WRITE) != 0) {
-    return;
-  }
-  LengthModifier lm = to_conv.length_modifier;
-  void *output_ptr = to_conv.output_ptr;
-  switch (lm) {
-  case (LengthModifier::hh):
-    *reinterpret_cast<unsigned char *>(output_ptr) =
-        static_cast<unsigned char>(output_val);
-    break;
-  case (LengthModifier::h):
-    *reinterpret_cast<unsigned short *>(output_ptr) =
-        static_cast<unsigned short>(output_val);
-    break;
-  case (LengthModifier::NONE):
-    *reinterpret_cast<unsigned int *>(output_ptr) =
-        static_cast<unsigned int>(output_val);
-    break;
-  case (LengthModifier::l):
-    *reinterpret_cast<unsigned long *>(output_ptr) =
-        static_cast<unsigned long>(output_val);
-    break;
-  case (LengthModifier::ll):
-  case (LengthModifier::L):
-    *reinterpret_cast<unsigned long long *>(output_ptr) =
-        static_cast<unsigned long long>(output_val);
-    break;
-  case (LengthModifier::j):
-    *reinterpret_cast<uintmax_t *>(output_ptr) =
-        static_cast<uintmax_t>(output_val);
-    break;
-  case (LengthModifier::z):
-    *reinterpret_cast<size_t *>(output_ptr) = static_cast<size_t>(output_val);
-    break;
-  case (LengthModifier::t):
-    *reinterpret_cast<ptrdiff_t *>(output_ptr) =
-        static_cast<ptrdiff_t>(output_val);
-    break;
-  }
-}
-
 // This code is very similar to the code in __support/str_to_integer.h but is
 // not quite the same. Here is the list of differences and why they exist:
 //  1) This takes a reader and a format section instead of a char* and the base.
 //      This should be fairly self explanatory. While the char* could be adapted
 //      to a reader and the base could be calculated ahead of time, the
 //      semantics are slightly different, specifically a char* can be indexed
 //      freely (I can read str[2] and then str[0]) whereas a File (which the
 //      reader may contain) cannot.
int convert_int(Reader *reader, const FormatSection &to_conv) {
   if (cur_char == '+' || cur_char == '-') {
     result_sign = cur_char;
     if (max_width > 1) {
       --max_width;
       cur_char = reader->getc();
     } else {
       // If the max width has been hit already, then the return value must be 0
       // since no actual digits of the number have been parsed yet.
-      write_with_length(0, to_conv);
+      write_int_with_length(0, to_conv);
       return MATCHING_FAILURE;
     }
   }
   const bool is_negative = result_sign == '-';
 
   // Base of 0 means automatically determine the base. Base of 16 may have a
   // prefix of "0x"
   if (base == 0 || base == 16) {
     // If the first character is 0, then it could be octal or hex.
     if (cur_char == '0') {
       is_number = true;
 
       // Read the next character to check.
       if (max_width > 1) {
         --max_width;
         cur_char = reader->getc();
       } else {
-        write_with_length(0, to_conv);
+        write_int_with_length(0, to_conv);
         return READ_OK;
       }
 
       if (to_lower(cur_char) == 'x') {
         // This is a valid hex prefix.
         base = 16;
         if (max_width > 1) {
           --max_width;
           cur_char = reader->getc();
         } else {
-          write_with_length(0, to_conv);
+          write_int_with_length(0, to_conv);
           return READ_OK;
         }
 
       } else {
         if (base == 0) {
           base = 8;
         }
       }
     } else if (base == 0) {
       if (internal::isdigit(cur_char)) {
         // If the first character is a different number, then it's 10.
         base = 10;
       } else {
         // If the first character isn't a valid digit, then there are no valid
         // digits at all. The number is 0.
         reader->ungetc(cur_char);
-        write_with_length(0, to_conv);
+        write_int_with_length(0, to_conv);
         return MATCHING_FAILURE;
       }
     }
   }
 
   constexpr uintmax_t UNSIGNED_MAX = cpp::numeric_limits<uintmax_t>::max();
   constexpr uintmax_t SIGNED_MAX =
       static_cast<uintmax_t>(cpp::numeric_limits<intmax_t>::max());
for (; i < max_width && internal::isalnum(cur_char) &&
     }
   }
 
   // We always read one more character than will be used, so we have to put the
   // last one back.
   reader->ungetc(cur_char);
 
   if (has_overflow) {
-    write_with_length(MAX, to_conv);
+    write_int_with_length(MAX, to_conv);
   } else {
     if (is_negative)
       result = -result;
 
-    write_with_length(result, to_conv);
+    write_int_with_length(result, to_conv);
   }
 
   if (!is_number)
     return MATCHING_FAILURE;
   return READ_OK;
 }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/scanf_main.cpp

int scanf_main(Reader *reader, const char *__restrict str,
   Parser parser(str, args);
   int ret_val = READ_OK;
   int conversions = 0;
   for (FormatSection cur_section = parser.get_next_section();
        !cur_section.raw_string.empty() && ret_val == READ_OK;
        cur_section = parser.get_next_section()) {
     if (cur_section.has_conv) {
       ret_val = convert(reader, cur_section);
+      // The %n (current position) conversion doesn't increment the number of
+      // assignments.
+      if (cur_section.conv_name != 'n')
         conversions += ret_val == READ_OK ? 1 : 0;
     } else {
       ret_val = raw_match(reader, cur_section.raw_string);
     }
   }
 
   if (conversions == 0 && reader->has_error()) {
     // This is intended to be converted to EOF in the client call to avoid
     // including stdio.h in this internal file.
     return -1;
   }
   return conversions;
 }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/test/src/stdio/sscanf_test.cpp

TEST(LlvmLibcSScanfTest, IntConvSimple) {
   ret_val = __llvm_libc::sscanf("012", "%o", &result);
   EXPECT_EQ(ret_val, 1);
   EXPECT_EQ(result, 012);
 
   ret_val = __llvm_libc::sscanf("345", "%u", &result);
   EXPECT_EQ(ret_val, 1);
   EXPECT_EQ(result, 345);
 
+  // 288 characters
+  ret_val = __llvm_libc::sscanf("10000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000",
+                                "%d", &result);
+  EXPECT_EQ(ret_val, 1);
+  EXPECT_EQ(result, int(__llvm_libc::cpp::numeric_limits<intmax_t>::max()));
+
   ret_val = __llvm_libc::sscanf("Not an integer", "%d", &result);
   EXPECT_EQ(ret_val, 0);
 }
 
 TEST(LlvmLibcSScanfTest, IntConvLengthModifier) {
   int ret_val;
   uintmax_t max_result = 0;
   int int_result = 0;
TEST(LlvmLibcSScanfTest, FloatConvComplexParsing) {
   EXPECT_EQ(ret_val, 1);
   EXPECT_FP_EQ(result, -.1e1);
 
   ret_val = __llvm_libc::sscanf("1.2.e1", "%f", &result);
   EXPECT_EQ(ret_val, 1);
   EXPECT_FP_EQ(result, 1.2);
 }
 
-/*
-TODO:
-  Max width tests
-*/
-
 TEST(LlvmLibcSScanfTest, FloatConvMaxWidth) {
   int ret_val;
   float result = 0;
 
   float inf = __llvm_libc::fputil::FPBits<float>::inf().get_val();
 
   ret_val = __llvm_libc::sscanf("123", "%3f", &result);
   EXPECT_EQ(ret_val, 1);
TEST(LlvmLibcSScanfTest, FloatConvNoWrite) {
   ret_val = __llvm_libc::sscanf("456", "%*1f", &result);
   EXPECT_EQ(ret_val, 1);
   EXPECT_FP_EQ(result, 0.0);
 
   ret_val = __llvm_libc::sscanf("Not a float", "%*f", &result);
   EXPECT_EQ(ret_val, 0);
 }
 
+TEST(LlvmLibcSScanfTest, CurPosCombined) {
+  int ret_val;
+  int result = -1;
+  char c_result = 0;
+
+  ret_val = __llvm_libc::sscanf("some text", "%n", &result);
+  // %n doesn't count as a conversion for the return value.
+  EXPECT_EQ(ret_val, 0);
+  EXPECT_EQ(result, 0);
+
+  ret_val = __llvm_libc::sscanf("1234567890", "12345%n", &result);
+  EXPECT_EQ(ret_val, 0);
+  EXPECT_EQ(result, 5);
+
+  ret_val = __llvm_libc::sscanf("1234567890", "12345%n", &result);
+  EXPECT_EQ(ret_val, 0);
+  EXPECT_EQ(result, 5);
+
+  // 288 characters
+  ret_val = __llvm_libc::sscanf("10000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000",
+                                "%*d%hhn", &c_result);
+  EXPECT_EQ(ret_val, 1);
+  EXPECT_EQ(c_result, char(288)); // Overflow is handled by casting.
+
+  // 320 characters
+  ret_val = __llvm_libc::sscanf("10000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000"
+                                "00000000000000000000000000000000",
+                                "%*d%n", &result);
+  EXPECT_EQ(ret_val, 1);
+  EXPECT_EQ(result, 320);
+}
+
 TEST(LlvmLibcSScanfTest, CombinedConv) {
   int ret_val;
   int result = 0;
   char buffer[10];
   ret_val = __llvm_libc::sscanf("123abc", "%i%s", &result, buffer);
   EXPECT_EQ(ret_val, 2);
   EXPECT_EQ(result, 123);
   ASSERT_STREQ(buffer, "abc");