[libc] Add implementation of ungetc.

[sivachandra]

Summary

A bug in the file read logic has also been fixed along the way. Parts
of the ungetc tests will fail without that bug fixed.

[michaelrj]

libc/src/__support/File/file.cpp

265–266

this could have issues in the case where ungetc is called twice in a row. If pos is 1 and ungetc is called, then pos is set to 0 and the char is written to bufref[pos], but on the second call pos is already 0 so subtracting will cause an underflow and likely a segfault.

[sivachandra]

Address comments.

libc/src/__support/File/file.cpp

265–266

I have added a conditional now.

[michaelrj]

libc/src/__support/File/file.cpp

265–266

this is okay for now (since it guarantees a buffer size of at least 1) but in future I'd like to look into a way to increase the size of the pushback buffer.

[sivachandra]

libc/src/__support/File/file.cpp

265–266

The standards require a minimum unget buffer of 1 character. A program relying on anything else would be a relying on internals so I do not think trying to build larger push back buffer is required or worth the complication.

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fprintf
     libc.src.stdio.printf
     libc.src.stdio.putc
     libc.src.stdio.putchar
     libc.src.stdio.puts
     libc.src.stdio.stderr
     libc.src.stdio.stdin
     libc.src.stdio.stdout
+    libc.src.stdio.ungetc
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.abort
     libc.src.stdlib.atexit
     libc.src.stdlib.exit
     libc.src.stdlib.getenv
 

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
           >,
           FunctionSpec<
               "fprintf",
               RetValSpec<IntType>,
               [ArgSpec<FILERestrictedPtr>,
                ArgSpec<ConstCharRestrictedPtr>,
                ArgSpec<VarArgType>]
           >,
+          FunctionSpec<
+              "ungetc",
+              RetValSpec<IntType>,
+              [ArgSpec<IntType>, ArgSpec<FILEPtr>]
+          >,
       ],
       [
           ObjectSpec<
               "stdin",
               "FILE *"
           >,
           ObjectSpec<
               "stdout",

libc/src/__support/File/file.h

public:
   // buffer is currently being used as a read buffer.
   int flush() {
     FileLock lock(this);
     return flush_unlocked();
   }
 
   int flush_unlocked();
 
+  // Returns EOF on error and keeps the file unchanged.
+  int ungetc_unlocked(int c);
+
+  int ungetc(int c) {
+    FileLock lock(this);
+    return ungetc_unlocked(c);
+  }
+
   // Sets the internal buffer to |buffer| with buffering mode |mode|.
   // |size| is the size of |buffer|. This new |buffer| is owned by the
   // stream only if |owned| is true.
   void set_buffer(void *buffer, size_t size, bool owned);
 
   // Closes the file stream and frees up all resources owned by it.
   int close();
 

libc/src/__support/File/file.cpp

if (len <= available_data) {
     return len;
   }
 
   // Copy all of the available data.
   // TODO: Replace the for loop with a call to internal memcpy.
   for (size_t i = 0; i < available_data; ++i)
     dataref[i] = bufref[i + pos];
   read_limit = pos = 0; // Reset the pointers.
+  // Update the dataref to reflect that fact that we have already
+  // copied |available_data| into |data|.
+  dataref = cpp::span<uint8_t>(dataref.data() + available_data,
+                               dataref.size() - available_data);
 
   size_t to_fetch = len - available_data;
   if (to_fetch > bufsize) {
-    size_t fetched_size = platform_read(this, data, to_fetch);
+    size_t fetched_size = platform_read(this, dataref.data(), to_fetch);
     if (fetched_size < to_fetch) {
       if (errno == 0)
         eof = true;
       else
         err = true;
       return available_data + fetched_size;
     }
     return len;
if (fetched_size < to_fetch) {
     if (errno == 0)
       eof = true;
     else
       err = true;
   }
   return transfer_size + available_data;
 }
 
+int File::ungetc_unlocked(int c) {
+  // There is no meaning to unget if:
+  // 1. You are trying to push back EOF.
+  // 2. Read operations are not allowed on this file.
+  // 3. The previous operation was a write operation.
+  if (c == EOF || !read_allowed() || (prev_op == FileOp::WRITE))
+    return EOF;
+
+  cpp::span<uint8_t> bufref(static_cast<uint8_t *>(buf), bufsize);
+  if (read_limit == 0) {
+    // If |read_limit| is zero, it can mean three things:
+    //   a. This file was just created.
+    //   b. The previous operation was a seek operation.
+    //   c. The previous operation was a read operation which emptied
+    //      the buffer.
+    // For all the above cases, we simply write |c| at the beginning
+    // of the buffer and bump |read_limit|. Note that |pos| will also
+    // be zero in this case, so we don't need to adjust it.
+    bufref[0] = static_cast<unsigned char>(c);
+    ++read_limit;
+  } else {
+    // If |read_limit| is non-zero, it means that there is data in the buffer
+    // from a previous read operation. Which would also mean that |pos| is not
+    // zero. So, we decrement |pos| and write |c| in to the buffer at the new
+    // |pos|. If too many ungetc operations are performed without reads, it
+    // can lead to (pos == 0 but read_limit != 0). We will just error out in
+    // such a case.
+    if (pos == 0)
+      return EOF;
+    --pos;
+    bufref[pos] = static_cast<unsigned char>(c);
+  }
+
+  eof = false; // There is atleast one character that can be read now.
+  err = false; // This operation was a success.
+  return c;
+}
+
 int File::seek(long offset, int whence) {
   FileLock lock(this);
   if (prev_op == FileOp::WRITE && pos > 0) {
     size_t transferred_size = platform_write(this, buf, pos);
     if (transferred_size < pos) {
       err = true;
       return -1;
     }

libc/src/stdio/CMakeLists.txt

HDRS
     fseek.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
+  ungetc
+  SRCS
+    ungetc.cpp
+  HDRS
+    ungetc.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
   fopencookie
   SRCS
     fopencookie.cpp
   HDRS
     fopencookie.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file

libc/src/stdio/ungetc.h

+//===-- Implementation header of ungetc -------------------------*- 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_UNGETC_H
+#define LLVM_LIBC_SRC_STDIO_UNGETC_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int ungetc(int c, ::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_UNGETC_H

libc/src/stdio/ungetc.cpp

+//===-- Implementation of ungetc ------------------------------------------===//
+//
+// 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/ungetc.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, ungetc, (int c, ::FILE *stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->ungetc(c);
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

DEPENDS
     libc.src.stdio.fopen
     libc.src.stdio.fputs
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
 )
 
 add_libc_unittest(
+  ungetc_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    ungetc_test.cpp
+  DEPENDS
+    libc.include.stdio
+    libc.src.stdio.fclose
+    libc.src.stdio.fopen
+    libc.src.stdio.fread
+    libc.src.stdio.fseek
+    libc.src.stdio.fwrite
+    libc.src.stdio.ungetc
+)
+
+add_libc_unittest(
   unlocked_fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     unlocked_fileop_test.cpp
   DEPENDS
     libc.include.errno
     libc.include.stdio

libc/test/src/stdio/ungetc_test.cpp

+//===-- Unittests for ungetc ----------------------------------------------===//
+//
+// 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/fclose.h"
+#include "src/stdio/fopen.h"
+#include "src/stdio/fread.h"
+#include "src/stdio/fseek.h"
+#include "src/stdio/fwrite.h"
+#include "src/stdio/ungetc.h"
+#include "utils/UnitTest/Test.h"
+
+#include <stdio.h>
+
+TEST(LlvmLibcUngetcTest, UngetAndReadBack) {
+  constexpr char FILENAME[] = "testdata/ungetc_test.test";
+  ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
+  ASSERT_FALSE(file == nullptr);
+  constexpr char CONTENT[] = "abcdef";
+  constexpr size_t CONTENT_SIZE = sizeof(CONTENT);
+  ASSERT_EQ(CONTENT_SIZE, __llvm_libc::fwrite(CONTENT, 1, CONTENT_SIZE, file));
+  // Cannot unget to an un-readable file.
+  ASSERT_EQ(EOF, __llvm_libc::ungetc('1', file));
+  ASSERT_EQ(0, __llvm_libc::fclose(file));
+
+  file = __llvm_libc::fopen(FILENAME, "r+");
+  ASSERT_FALSE(file == nullptr);
+  char c;
+  ASSERT_EQ(__llvm_libc::fread(&c, 1, 1, file), size_t(1));
+  ASSERT_EQ(c, CONTENT[0]);
+  ASSERT_EQ(__llvm_libc::ungetc(int(c), file), int(c));
+
+  char data[CONTENT_SIZE];
+  ASSERT_EQ(CONTENT_SIZE, __llvm_libc::fread(data, 1, CONTENT_SIZE, file));
+  ASSERT_STREQ(CONTENT, data);
+
+  ASSERT_EQ(0, __llvm_libc::fseek(file, 0, SEEK_SET));
+  // ungetc should not fail after a seek operation.
+  int unget_char = 'z';
+  ASSERT_EQ(unget_char, __llvm_libc::ungetc(unget_char, file));
+  // Another unget should fail.
+  ASSERT_EQ(EOF, __llvm_libc::ungetc(unget_char, file));
+  // ungetting a char at the beginning of the file will allow us to fetch
+  // one additional character.
+  char new_data[CONTENT_SIZE + 1];
+  ASSERT_EQ(CONTENT_SIZE + 1,
+            __llvm_libc::fread(new_data, 1, CONTENT_SIZE + 1, file));
+  ASSERT_STREQ("zabcdef", new_data);
+
+  ASSERT_EQ(size_t(1), __llvm_libc::fwrite("x", 1, 1, file));
+  // unget should fail after a write operation.
+  ASSERT_EQ(EOF, __llvm_libc::ungetc('1', file));
+
+  ASSERT_EQ(0, __llvm_libc::fclose(file));
+}