[libc] add scanf system file support

[michaelrj]

Summary

This patch is similar to the patch adding system file support to printf:
https://reviews.llvm.org/D146001. It also modifies the file reader
slightly to check for errors when ungetc is called.

[mcgrathr]

libc/src/stdio/fscanf.cpp

21

This is rather different from what I was expecting. I hadn't seen D146001 before now, so I was thinking of the integration with FILE or whatever other underlying i/o mechanism as being entirely provided by the integrator. It's not clear to me if we have full parity here between the printf and scanf cores. That seems desirable, i.e. that a purely abstract interface can be filled out unrelated to anybody's concept of a FILE type, for the i/o interactions that the core needs. For integrating with a particular stdio implementation, it's not clear whether using the public stdio interfaces will be what's most desirable. The integrator should be able to write things up to their own internals, whether or not those look at all like what you presume stdio looks like.

35

ISTM that the integrator-provided template instantiations should be responsible for FILE*->FileT* rather than presuming that a reinterpret_cast here is safe and correct.

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.free
 
     # stdio.h entrypoints
     libc.src.stdio.remove
     libc.src.stdio.sprintf
     libc.src.stdio.snprintf
     libc.src.stdio.fprintf
     libc.src.stdio.printf
+    libc.src.stdio.sscanf
+    libc.src.stdio.scanf
+    libc.src.stdio.fscanf
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.madvise
     libc.src.sys.mman.mmap
     libc.src.sys.mman.mprotect
     libc.src.sys.mman.munmap
     libc.src.sys.mman.posix_madvise
 
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.ftell
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
     libc.src.stdio.getc
     libc.src.stdio.getc_unlocked
     libc.src.stdio.getchar
     libc.src.stdio.getchar_unlocked
-    libc.src.stdio.sscanf
-    libc.src.stdio.scanf
-    libc.src.stdio.fscanf
     libc.src.stdio.putc
     libc.src.stdio.putchar
     libc.src.stdio.puts
     libc.src.stdio.setbuf
     libc.src.stdio.setvbuf
     libc.src.stdio.stderr
     libc.src.stdio.stdin
     libc.src.stdio.stdout

libc/src/stdio/CMakeLists.txt

HDRS
     sscanf.h
   DEPENDS
     libc.src.__support.arg_list
     libc.src.stdio.scanf_core.string_reader
     libc.src.stdio.scanf_core.reader
     libc.src.stdio.scanf_core.scanf_main
 )
 
+list(APPEND scanf_deps 
+      libc.src.__support.arg_list 
+      libc.src.stdio.scanf_core.vfscanf_internal
+)
+if(LLVM_LIBC_FULL_BUILD)
+ list(APPEND scanf_deps  
+      libc.src.__support.File.file 
+      libc.src.__support.File.platform_file 
+  )
+else()
+ set(scanf_copts "-DLIBC_COPT_SCANF_USE_SYSTEM_FILE")
+endif()
+
 add_entrypoint_object(
   fscanf
   SRCS
     fscanf.cpp
   HDRS
     fscanf.h
   DEPENDS
-    libc.src.__support.arg_list
-    libc.src.stdio.scanf_core.vfscanf_internal
+    ${scanf_deps}
+  COMPILE_OPTIONS
+    ${scanf_copts}
 )
 
 add_entrypoint_object(
   scanf
   SRCS
     scanf.cpp
   HDRS
     scanf.h
   DEPENDS
-    libc.src.__support.arg_list
-    libc.src.stdio.scanf_core.vfscanf_internal
+    ${scanf_deps}
+  COMPILE_OPTIONS
+    ${scanf_copts}
 )
 
 add_entrypoint_object(
   sprintf
   SRCS
     sprintf.cpp
   HDRS
     sprintf.h

 
 add_entrypoint_object(
   fprintf
   SRCS
     fprintf.cpp
   HDRS
     fprintf.h
   DEPENDS
-    libc.src.__support.arg_list
-    libc.src.stdio.printf_core.vfprintf_internal
+    ${printf_deps}
   COMPILE_OPTIONS
     ${printf_copts}
 )
 
 add_entrypoint_object(
   ftell
   SRCS
     ftell.cpp

libc/src/stdio/fscanf.cpp

 
 #include "src/__support/File/file.h"
 #include "src/__support/arg_list.h"
 #include "src/stdio/scanf_core/vfscanf_internal.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 
+#ifndef LIBC_COPT_SCANF_USE_SYSTEM_FILE
+using FileT = __llvm_libc::File;
+#else  // defined(LIBC_COPT_SCANF_USE_SYSTEM_FILE)
+using FileT = ::FILE;
+#endif // LIBC_COPT_SCANF_USE_SYSTEM_FILE
+
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fscanf,
                    (::FILE *__restrict stream, const char *__restrict format,
                     ...)) {
   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);
-  int ret_val = scanf_core::vfscanf_internal(stream, format, args);
+  int ret_val = scanf_core::vfscanf_internal(reinterpret_cast<FileT *>(stream),
+                                             format, args);
   // This is done to avoid including stdio.h in the internals. On most systems
   // EOF is -1, so this will be transformed into just "return ret_val".
   return (ret_val == -1) ? EOF : ret_val;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/CMakeLists.txt

DEPENDS
     .core_structs
 )
 
 add_header_library(
   vfprintf_internal
   HDRS
     vfprintf_internal.h
   DEPENDS
-    libc.include.stdio
-    libc.src.__support.File.file
     libc.src.__support.arg_list
     libc.src.stdio.printf_core.printf_main
     libc.src.stdio.printf_core.file_writer
     libc.src.stdio.printf_core.writer
 )

libc/src/stdio/printf_core/vfprintf_internal.h

 //===-- Internal implementation header of vfprintf --------------*- 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_VFPRINTF_INTERNAL_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_VFPRINTF_INTERNAL_H
 
-#include "src/__support/File/file.h"
 #include "src/__support/arg_list.h"
 #include "src/__support/macros/attributes.h" // For LIBC_INLINE
 #include "src/stdio/printf_core/file_writer.h"
 #include "src/stdio/printf_core/printf_main.h"
 #include "src/stdio/printf_core/writer.h"
 
-#include <stdio.h>
-
 namespace __llvm_libc {
 namespace printf_core {
 
 template <typename file_t>
 LIBC_INLINE int vfprintf_internal(file_t *__restrict stream,
                                   const char *__restrict format,
                                   internal::ArgList &args) {
   FileWriter<file_t> file_writer(stream);

libc/src/stdio/scanf.cpp

 //===-- Implementation of 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.h"
 
-#include "src/__support/File/file.h"
 #include "src/__support/arg_list.h"
 #include "src/stdio/scanf_core/vfscanf_internal.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 
+#ifndef LIBC_COPT_SCANF_USE_SYSTEM_FILE
+#include "src/__support/File/file.h"
+#define SCANF_STDIN __llvm_libc::stdin
+#else // LIBC_COPT_SCANF_USE_SYSTEM_FILE
+#define SCANF_STDIN ::stdin
+#endif // LIBC_COPT_SCANF_USE_SYSTEM_FILE
+
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, scanf, (const char *__restrict format, ...)) {
   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);
-  int ret_val = scanf_core::vfscanf_internal(
-      reinterpret_cast<::FILE *>(__llvm_libc::stdin), format, args);
+  int ret_val = scanf_core::vfscanf_internal(SCANF_STDIN, format, args);
   // This is done to avoid including stdio.h in the internals. On most systems
   // EOF is -1, so this will be transformed into just "return ret_val".
   return (ret_val == -1) ? EOF : ret_val;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/CMakeLists.txt

DEPENDS
     libc.src.__support.arg_list
     libc.src.__support.ctype_utils
     libc.src.__support.str_to_integer
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.bitset
     libc.src.__support.CPP.string_view
 )
 
-if(NOT (TARGET libc.src.__support.File.file))
-  # Not all platforms have a file implementation. If file is unvailable,
-  # then we must skip all the parts that need file.
+if(NOT (TARGET libc.src.__support.File.file) AND LLVM_LIBC_FULL_BUILD)
+  # Not all platforms have a file implementation. If file is unvailable, and a 
+  # full build is requested, then we must skip all file based printf sections.
   return()
 endif()
 
 add_object_library(
   scanf_main
   SRCS
     scanf_main.cpp
   HDRS

 add_object_library(
   string_reader
   SRCS
     string_reader.cpp
   HDRS
     string_reader.h
 )
 
-add_object_library(
+add_header_library(
   file_reader
-  SRCS
-    file_reader.cpp
   HDRS
     file_reader.h
   DEPENDS
+    libc.include.stdio
     libc.src.__support.File.file
 )
 
 add_object_library(
   reader
   SRCS
     reader.cpp
   HDRS
DEPENDS
     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.src.__support.str_to_float
 )
 
-add_object_library(
+add_header_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

if (internal::isspace(raw_string[i])) {
       if (raw_string[i] == cur_char) {
         cur_char = reader->getc();
       } else {
         ret_val = MATCHING_FAILURE;
         break;
       }
     }
   }
-  reader->ungetc(cur_char);
+  if (!reader->ungetc(cur_char)) {
+    return UNGET_ERROR;
+  }
   return ret_val;
 }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/core_structs.h

enum ErrorCodes : int {
   // This is the value to be returned by conversions when no error has occurred.
   READ_OK = 0,
   // These are the scanf return values for when an error has occurred. They are
   // all negative, and should be distinct.
   FILE_READ_ERROR = -1,
   FILE_STATUS_ERROR = -2,
   MATCHING_FAILURE = -3,
   ALLOCATION_FAILURE = -4,
+  UNGET_ERROR = -5,
 };
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_CORE_STRUCTS_H

libc/src/stdio/scanf_core/file_reader.h

 #include "src/__support/File/file.h"
 
 #include <stddef.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-class FileReader {
-  __llvm_libc::File *file;
+template <typename file_t> class FileReader {
+  file_t *file;
 
 public:
-  FileReader(::FILE *init_file) {
-    file = reinterpret_cast<__llvm_libc::File *>(init_file);
-    file->lock();
-  }
+  FileReader(file_t *init_file);
 
-  ~FileReader() { file->unlock(); }
+  ~FileReader();
 
   char get_char();
-  void unget_char(char c);
-  bool has_error() { return file->error_unlocked(); }
+  bool unget_char(char c); // Returns true on success, false on failure.
+  bool has_error();
 };
 
+// The interface for using our internal file implementation.
+template <>
+LIBC_INLINE
+FileReader<__llvm_libc::File>::FileReader(__llvm_libc::File *init_file) {
+  file = init_file;
+  file->lock();
+}
+template <> LIBC_INLINE FileReader<__llvm_libc::File>::~FileReader() {
+  file->unlock();
+}
+
+template <> LIBC_INLINE char FileReader<__llvm_libc::File>::get_char() {
+  char tiny_buff = 0;
+  auto result = file->read_unlocked(&tiny_buff, 1);
+  if (result.value != 1 || result.has_error())
+    return 0;
+  return tiny_buff;
+}
+template <> LIBC_INLINE bool FileReader<__llvm_libc::File>::has_error() {
+  return file->error_unlocked();
+}
+template <> LIBC_INLINE bool FileReader<__llvm_libc::File>::unget_char(char c) {
+  int result = file->ungetc_unlocked(c);
+  return !(result == EOF || this->has_error());
+}
+
+// The interface for using the system's file implementation.
+template <> LIBC_INLINE FileReader<::FILE>::FileReader(::FILE *init_file) {
+  file = init_file;
+  ::flockfile(file);
+}
+template <> LIBC_INLINE FileReader<::FILE>::~FileReader() {
+  ::funlockfile(file);
+}
+
+template <> LIBC_INLINE char FileReader<::FILE>::get_char() {
+  int result = ::fgetc_unlocked(file);
+  if (result == EOF || ::ferror_unlocked(file))
+    return 0;
+  return static_cast<char>(result);
+}
+template <> LIBC_INLINE bool FileReader<::FILE>::has_error() {
+  return ::ferror(file) != 0;
+}
+template <> LIBC_INLINE bool FileReader<::FILE>::unget_char(char c) {
+  int result = ::ungetc(c, file); // There is no unlocked version of ungetc.
+  return !(result == EOF || this->has_error());
+}
+
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_FILE_READER_H

libc/src/stdio/scanf_core/file_reader.cpp

-//===-- FILE Reader implementation 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/file_reader.h"
-#include "src/__support/File/file.h"
-#include <stddef.h>
-
-namespace __llvm_libc {
-namespace scanf_core {
-
-char FileReader::get_char() {
-  char tiny_buff = 0;
-  auto result = file->read_unlocked(&tiny_buff, 1);
-  if (result.value != 1 || result.has_error())
-    return 0;
-  return tiny_buff;
-}
-
-void FileReader::unget_char(char c) { file->ungetc_unlocked(c); }
-
-} // namespace scanf_core
-} // namespace __llvm_libc

libc/src/stdio/scanf_core/float_converter.cpp

while (internal::isdigit(cur_char) && out_str.length() < max_width) {
         return ALLOCATION_FAILURE;
       }
       cur_char = reader->getc();
     }
   }
 
   // We always read one more character than will be used, so we have to put the
   // last one back.
-  reader->ungetc(cur_char);
+  if (!reader->ungetc(cur_char)) {
+    return UNGET_ERROR;
+  }
 
   // If we haven't actually found any digits, this is a matching failure (this
   // catches cases like "+.")
   if (!is_number) {
     return MATCHING_FAILURE;
   }
   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

if (cur_char == '0') {
       }
     } 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);
+        if (!reader->ungetc(cur_char)) {
+          return UNGET_ERROR;
+        }
         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 =
if (result > MAX - cur_digit) {
       has_overflow = true;
     } else {
       result = result + cur_digit;
     }
   }
 
   // We always read one more character than will be used, so we have to put the
   // last one back.
-  reader->ungetc(cur_char);
+  if (!reader->ungetc(cur_char)) {
+    return UNGET_ERROR;
+  }
 
   if (has_overflow) {
     write_int_with_length(MAX, to_conv);
   } else {
     if (is_negative)
       result = -result;
 
     write_int_with_length(result, to_conv);

libc/src/stdio/scanf_core/ptr_converter.cpp

int convert_pointer(Reader *reader, const FormatSection &to_conv) {
   }
   if (i == (sizeof(nullptr_string) - 1)) {
     *reinterpret_cast<void **>(to_conv.output_ptr) = nullptr;
     return READ_OK;
   } else if (i > 0) {
     return MATCHING_FAILURE;
   }
 
-  reader->ungetc(cur_char);
+  if (!reader->ungetc(cur_char)) {
+    return UNGET_ERROR;
+  }
 
   // Else treat it as a hex int
   return convert_int(reader, to_conv);
 }
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/reader.h

 
 #include "src/stdio/scanf_core/file_reader.h"
 #include "src/stdio/scanf_core/string_reader.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-enum class ReaderType { String, File };
+enum class ReaderType { String, SystemFile, InternalFile };
 
 class Reader final {
   union {
     StringReader *string_reader;
-    FileReader *file_reader;
+    FileReader<::FILE> *system_file_reader;
+    FileReader<__llvm_libc::File> *internal_file_reader;
   };
 
   const ReaderType reader_type;
 
   size_t cur_chars_read = 0;
 
 public:
   Reader(StringReader *init_string_reader)
       : string_reader(init_string_reader), reader_type(ReaderType::String) {}
 
-  Reader(FileReader *init_file_reader)
-      : file_reader(init_file_reader), reader_type(ReaderType::File) {}
+  Reader(FileReader<__llvm_libc::File> *init_file_reader)
+      : internal_file_reader(init_file_reader),
+        reader_type(ReaderType::InternalFile) {}
+
+  Reader(FileReader<::FILE> *init_file_reader)
+      : system_file_reader(init_file_reader),
+        reader_type(ReaderType::SystemFile) {}
 
   // This returns the next character from the input and advances it by one
   // character. When it hits the end of the string or file it returns '\0' to
   // signal to stop parsing.
   char getc();
 
   // This moves the input back by one character, placing c into the buffer if
-  // this is a file reader, else c is ignored.
-  void ungetc(char c);
+  // this is a file reader, else c is ignored. It returns true on success.
+  bool ungetc(char c);
 
   size_t chars_read() { return cur_chars_read; }
 
   bool has_error();
 };
 
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_READER_H

libc/src/stdio/scanf_core/reader.cpp

 //===-- Reader definition 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/reader.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
 char Reader::getc() {
   ++cur_chars_read;
-  if (reader_type == ReaderType::String) {
+  switch (reader_type) {
+  case ReaderType::String:
     return string_reader->get_char();
-  } else {
-    return file_reader->get_char();
+  case ReaderType::InternalFile:
+    return internal_file_reader->get_char();
+  case ReaderType::SystemFile:
+    return system_file_reader->get_char();
   }
 }
 
-void Reader::ungetc(char c) {
+bool Reader::ungetc(char c) {
   --cur_chars_read;
-  if (reader_type == ReaderType::String) {
+  switch (reader_type) {
+  case ReaderType::String:
     // The string reader ignores the char c passed to unget since it doesn't
     // need to place anything back into a buffer, and modifying the source
     // string would be dangerous.
     return string_reader->unget_char();
-  } else {
-    return file_reader->unget_char(c);
+  case ReaderType::InternalFile:
+    return internal_file_reader->unget_char(c);
+  case ReaderType::SystemFile:
+    return system_file_reader->unget_char(c);
   }
 }
 
 bool Reader::has_error() {
-  if (reader_type == ReaderType::File) {
-    return file_reader->has_error();
-  }
+  switch (reader_type) {
+  case ReaderType::String:
+    // The string reader can't error since it's just reading from a char*.
     return false;
+  case ReaderType::InternalFile:
+    return internal_file_reader->has_error();
+  case ReaderType::SystemFile:
+    return system_file_reader->has_error();
+  }
 }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/string_converter.cpp

for (; i < max_width && cur_char != '\0'; ++i) {
     // if the NO_WRITE flag is not set, write to the output.
     if ((to_conv.flags & NO_WRITE) == 0)
       output[i] = cur_char;
     cur_char = reader->getc();
   }
 
   // We always read one more character than will be used, so we have to put the
   // last one back.
-  reader->ungetc(cur_char);
+  if (!reader->ungetc(cur_char)) {
+    return UNGET_ERROR;
+  }
 
   // If this is %s or %[]
   if (to_conv.conv_name != 'c' && (to_conv.flags & NO_WRITE) == 0) {
     // Always null terminate the string. This may cause a write to the
     // (max_width + 1) byte, which is correct. The max width describes the max
     // number of characters read from the input string, and doesn't necessarily
     // correspond to the output.
     output[i] = '\0';

libc/src/stdio/scanf_core/string_reader.h

class StringReader {
   size_t cur_index = 0;
 
 public:
   StringReader(const char *init_string) { string = init_string; }
 
   ~StringReader() {}
 
   char get_char();
-  void unget_char();
+  bool unget_char();
 };
 
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_STRING_READER_H

libc/src/stdio/scanf_core/string_reader.cpp

 namespace scanf_core {
 
 char StringReader::get_char() {
   char cur_char = string[cur_index];
   ++cur_index;
   return cur_char;
 }
 
-void StringReader::unget_char() { --cur_index; }
+bool StringReader::unget_char() {
+  --cur_index;
+  return true;
+}
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/vfscanf_internal.h

 //===-- Internal implementation header of vfscanf ---------------*- 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_VFSCANF_INTERNAL_H
 #define LLVM_LIBC_SRC_STDIO_SCANF_CORE_VFSCANF_INTERNAL_H
 
 #include "src/__support/arg_list.h"
+#include "src/__support/macros/attributes.h" // For LIBC_INLINE
+#include "src/stdio/scanf_core/file_reader.h"
+#include "src/stdio/scanf_core/reader.h"
+#include "src/stdio/scanf_core/scanf_main.h"
 
 #include <stdio.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-int vfscanf_internal(::FILE *__restrict stream, const char *__restrict format,
-                     internal::ArgList &args);
+template <typename file_t>
+LIBC_INLINE int vfscanf_internal(file_t *__restrict stream,
+                                 const char *__restrict format,
+                                 internal::ArgList &args) {
+  FileReader<file_t> file_reader(stream);
+  scanf_core::Reader reader(&file_reader);
+  return scanf_core::scanf_main(&reader, format, args);
+}
+
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_VFSCANF_INTERNAL_H

libc/src/stdio/scanf_core/vfscanf_internal.cpp

-//===-- Internal implementation of vfscanf ---------------------*- 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/vfscanf_internal.h"
-
-#include "src/__support/arg_list.h"
-#include "src/stdio/scanf_core/file_reader.h"
-#include "src/stdio/scanf_core/reader.h"
-#include "src/stdio/scanf_core/scanf_main.h"
-
-#include <stdio.h>
-
-namespace __llvm_libc {
-namespace scanf_core {
-
-int vfscanf_internal(::FILE *__restrict stream, const char *__restrict format,
-                     internal::ArgList &args) {
-  FileReader file_reader(stream);
-  scanf_core::Reader reader(&file_reader);
-  return scanf_core::scanf_main(&reader, format, args);
-}
-
-} // namespace scanf_core
-} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

add_libc_unittest(
   SUITE
     libc_stdio_unittests
   SRCS
     snprintf_test.cpp
   DEPENDS
     libc.src.stdio.snprintf
 )
 
-# In fullbuild mode, fprintf's tests use the internal FILE for other functions.
-if(LLVM_LIBC_FULL_BUILD)
-add_libc_unittest(
-  fprintf_test
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    fprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.fprintf
+list(APPEND fprintf_test_deps
+)
+if(LLVM_LIBC_FULL_BUILD)
+# In fullbuild mode, fprintf's tests use the internal FILE for other functions.
+  list(APPEND fprintf_test_deps
     libc.src.stdio.fclose
     libc.src.stdio.ferror
     libc.src.stdio.fopen
     libc.src.stdio.fread
   )
 else()
 # Else in overlay mode they use the system's FILE.
+ set(fprintf_test_copts "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE")
+endif()
+
 add_libc_unittest(
   fprintf_test
   SUITE
     libc_stdio_unittests
   SRCS
     fprintf_test.cpp
   DEPENDS
-    libc.src.stdio.fprintf
+    ${fprintf_test_deps}
   COMPILE_OPTIONS
-    -DLIBC_COPT_PRINTF_USE_SYSTEM_FILE
+    ${fprintf_test_copts}
 )
-endif()
 
 add_libc_unittest(
   printf_test
   SUITE
     libc_stdio_unittests
   SRCS
     printf_test.cpp
   DEPENDS
     libc.src.stdio.printf
 )
 
+list(APPEND fscanf_test_deps
+  libc.src.stdio.fscanf
+  libc.src.__support.CPP.string_view
+)
+if(LLVM_LIBC_FULL_BUILD)
+# In fullbuild mode, fscanf's tests use the internal FILE for other functions.
+  list(APPEND fscanf_test_deps
+    libc.src.stdio.fclose
+    libc.src.stdio.ferror
+    libc.src.stdio.fopen
+    libc.src.stdio.fwrite
+  )
+else()
+# Else in overlay mode they use the system's FILE.
+ set(fscanf_test_copts "-DLIBC_COPT_SCANF_USE_SYSTEM_FILE")
+endif()
+
 add_libc_unittest(
   fscanf_test
   SUITE
     libc_stdio_unittests
   SRCS
     fscanf_test.cpp
   DEPENDS
-    libc.src.stdio.fscanf
-    libc.src.stdio.fclose
-    libc.src.stdio.ferror
-    libc.src.stdio.fopen
-    libc.src.stdio.fwrite
-    libc.src.__support.CPP.string_view
+    ${fscanf_test_deps}
+  COMPILE_OPTIONS
+    ${fscanf_test_copts}
 )
 
 add_libc_unittest(
   sscanf_test
   SUITE
     libc_stdio_unittests
   SRCS
     sscanf_test.cpp

libc/test/src/stdio/fscanf_test.cpp

 //===-- Unittests for fscanf ----------------------------------------------===//
 //
 // 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"
+#ifndef LIBC_COPT_SCANF_USE_SYSTEM_FILE
 #include "src/stdio/fclose.h"
 #include "src/stdio/ferror.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fwrite.h"
+#endif // LIBC_COPT_SCANF_USE_SYSTEM_FILE
 
 #include "src/stdio/fscanf.h"
 
+#include "src/__support/CPP/string_view.h"
+
 #include "test/UnitTest/Test.h"
 
 #include <stdio.h>
 
+namespace scanf_test {
+#ifndef LIBC_COPT_SCANF_USE_SYSTEM_FILE
+using __llvm_libc::fclose;
+using __llvm_libc::ferror;
+using __llvm_libc::fopen;
+using __llvm_libc::fwrite;
+#else  // defined(LIBC_COPT_SCANF_USE_SYSTEM_FILE)
+using ::fclose;
+using ::ferror;
+using ::fopen;
+using ::fwrite;
+#endif // LIBC_COPT_SCANF_USE_SYSTEM_FILE
+} // namespace scanf_test
+
 TEST(LlvmLibcFScanfTest, WriteToFile) {
-  constexpr char FILENAME[] = "testdata/fscanf_output.test";
-  ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
+
+  const char *FILENAME = "fscanf_output.test";
+  auto FILE_PATH = libc_make_test_file_path(FILENAME);
+
+  ::FILE *file = scanf_test::fopen(FILE_PATH, "w");
   ASSERT_FALSE(file == nullptr);
 
   int read;
 
   constexpr char simple[] = "A simple string with no conversions.\n";
 
   ASSERT_EQ(sizeof(simple) - 1,
-            __llvm_libc::fwrite(simple, 1, sizeof(simple) - 1, file));
+            scanf_test::fwrite(simple, 1, sizeof(simple) - 1, file));
 
   constexpr char numbers[] = "1234567890\n";
 
   ASSERT_EQ(sizeof(numbers) - 1,
-            __llvm_libc::fwrite(numbers, 1, sizeof(numbers) - 1, file));
+            scanf_test::fwrite(numbers, 1, sizeof(numbers) - 1, file));
 
   constexpr char numbers_and_more[] = "1234 and more\n";
 
   ASSERT_EQ(sizeof(numbers_and_more) - 1,
-            __llvm_libc::fwrite(numbers_and_more, 1,
-                                sizeof(numbers_and_more) - 1, file));
+            scanf_test::fwrite(numbers_and_more, 1,
 
   read =
       __llvm_libc::fscanf(file, "Reading from a write-only file should fail.");
   EXPECT_LT(read, 0);
 
-  ASSERT_EQ(0, __llvm_libc::fclose(file));
+  ASSERT_EQ(0, scanf_test::fclose(file));
 
-  file = __llvm_libc::fopen(FILENAME, "r");
+  file = scanf_test::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   char data[50];
   read = __llvm_libc::fscanf(file, "%[A-Za-z .\n]", data);
   ASSERT_EQ(read, 1);
   ASSERT_STREQ(simple, data);
 
   read = __llvm_libc::fscanf(file, "%s", data);
   ASSERT_EQ(read, 1);
   ASSERT_EQ(__llvm_libc::cpp::string_view(numbers, 10),
             __llvm_libc::cpp::string_view(data));
 
   // The format string starts with a space to handle the fact that the %s leaves
   // a trailing \n and %c doesn't strip leading whitespace.
   read = __llvm_libc::fscanf(file, " %50c", data);
   ASSERT_EQ(read, 1);
   ASSERT_EQ(__llvm_libc::cpp::string_view(numbers_and_more),
             __llvm_libc::cpp::string_view(data, sizeof(numbers_and_more) - 1));
 
-  ASSERT_EQ(__llvm_libc::ferror(file), 0);
-  ASSERT_EQ(__llvm_libc::fclose(file), 0);
+  ASSERT_EQ(scanf_test::ferror(file), 0);
+  ASSERT_EQ(scanf_test::fclose(file), 0);
 }