[libc] add fputs and puts

[michaelrj]

Summary

add fputs, puts, and the EOF macro that they use.

[sivachandra]

libc/src/stdio/fputs.cpp

29

Casting a unsigned value to a signed value can lead to incorrect sign. Why don't we just return 1 here?

libc/test/src/stdio/fileop_test.cpp

88

What are we testing for here?

[michaelrj]

add puts, address comments.

[michaelrj]

libc/src/stdio/fputs.cpp

29

that's fair, I've changed it to 0.

libc/test/src/stdio/fileop_test.cpp

88

I've reordered the assert and updated the comment.

libc/config/linux/api.td

 
 def StdIOAPI : PublicAPI<"stdio.h"> {
   let Macros = [
     SimpleMacroDef<"stderr", "stderr">,
     SimpleMacroDef<"stdout", "stdout">,
     SimpleMacroDef<"_IOFBF", "0">,
     SimpleMacroDef<"_IOLBF", "1">,
     SimpleMacroDef<"_IONBF", "2">,
+    SimpleMacroDef<"EOF", "-1">,
   ];
   let Types = ["size_t", "FILE", "cookie_io_functions_t"];
 }
 
 def StdlibAPI : PublicAPI<"stdlib.h"> {
   let Types = [
     "div_t",
     "ldiv_t",

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fclose
     libc.src.stdio.flockfile
     libc.src.stdio.feof
     libc.src.stdio.feof_unlocked
     libc.src.stdio.ferror
     libc.src.stdio.ferror_unlocked
     libc.src.stdio.fflush
     libc.src.stdio.fopen
+    libc.src.stdio.fputs
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
     libc.src.stdio.fprintf
     libc.src.stdio.printf
+    libc.src.stdio.puts
     libc.src.stdio.stderr
     libc.src.stdio.stdout
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.atexit
     libc.src.stdlib.exit
     libc.src.stdlib.getenv

libc/docs/stdio.rst

 ==========================
 
 These functions operate on files on the host's system, without using the 
 ``FILE`` object type. They only take the name of the file being operated on.
 
 =============  =========
 Function_Name  Available
 =============  =========
-remove
+remove         YES
 rename
 tmpnam
 =============  =========
 
 Unformatted ``FILE`` Input/Output Functions
 ===========================================
 
 The ``gets`` function was removed in C11 for having no bounds checking and
 therefor being impossible to use safely.
 
 =============  =========
 Function_Name  Available
 =============  =========
 (f)getc
 fgets
 getchar
 fread          YES
 (f)putc
-(f)puts
+(f)puts        YES
 putchar
 fwrite         YES
 ungetc
 =============  =========

libc/spec/stdc.td

def StdC : StandardSpec<"stdc"> {
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [
           Macro<"stderr">,
           Macro<"stdout">,
           Macro<"_IOFBF">,
           Macro<"_IOLBF">,
           Macro<"_IONBF">,
+          Macro<"EOF">,
       ], // Macros
       [ // Types
           SizeTType,
           FILE,
       ],
       [], // Enumerations
       [
           FunctionSpec<
HeaderSpec StdIO = HeaderSpec<
           >,
           FunctionSpec<
               "fopen",
               RetValSpec<FILEPtr>,
               [ArgSpec<ConstCharPtr>,
                ArgSpec<ConstCharPtr>]
           >,
           FunctionSpec<
+              "fputs",
+              RetValSpec<IntType>,
+              [ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<FILERestrictedPtr>]
+          >,
+          FunctionSpec<
+              "puts",
+              RetValSpec<IntType>,
+              [ArgSpec<ConstCharRestrictedPtr>]
+          >,
+          FunctionSpec<
               "fread",
               RetValSpec<SizeTType>,
               [ArgSpec<VoidRestrictedPtr>,
                ArgSpec<SizeTType>,
                ArgSpec<SizeTType>,
                ArgSpec<FILERestrictedPtr>]
           >,
           FunctionSpec<

libc/src/__support/File/file.cpp

size_t File::write_unlocked_fbf(const uint8_t *data, size_t len) {
   }
 
   return len;
 }
 
 size_t File::write_unlocked_lbf(const uint8_t *data, size_t len) {
   constexpr uint8_t NEWLINE_CHAR = '\n';
   size_t last_newline = len;
-  for (size_t i = len; i > 1; --i) {
+  for (size_t i = len; i >= 1; --i) {
     if (data[i - 1] == NEWLINE_CHAR) {
       last_newline = i - 1;
       break;
     }
   }
 
   // If there is no newline, treat this as fully buffered.
   if (last_newline == len) {

libc/src/stdio/CMakeLists.txt

HDRS
     fwrite.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
+  fputs
+  SRCS
+    fputs.cpp
+  HDRS
+    fputs.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+
+add_entrypoint_object(
+  puts
+  SRCS
+    puts.cpp
+  HDRS
+    puts.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
   fseek
   SRCS
     fseek.cpp
   HDRS
     fseek.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file

libc/src/stdio/fputs.h

+//===-- Implementation header of fputs --------------------------*- 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_FPUTS_H
+#define LLVM_LIBC_SRC_STDIO_FPUTS_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int fputs(const char *__restrict str, ::FILE *__restrict stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FPUTS_H

libc/src/stdio/fputs.cpp

+//===-- Implementation of fputs -------------------------------------------===//
+//
+// 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/fputs.h"
+#include "src/__support/CPP/string_view.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, fputs,
+                   (const char *__restrict str, ::FILE *__restrict stream)) {
+  cpp::string_view str_view(str);
+
+  size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(
+      str, str_view.size());
+  if (str_view.size() != written) {
+    // The stream should be in an error state in this case.
+    return EOF;
+  }
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/puts.h

+//===-- Implementation header of puts ---------------------------*- 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_PUTS_H
+#define LLVM_LIBC_SRC_STDIO_PUTS_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int puts(const char *__restrict str);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_PUTS_H

libc/src/stdio/puts.cpp

+//===-- Implementation of puts --------------------------------------------===//
+//
+// 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/puts.h"
+#include "src/__support/CPP/string_view.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
+  cpp::string_view str_view(str);
+  size_t written = __llvm_libc::stdout->write(str, str_view.size());
+  if (str_view.size() != written) {
+    // The stream should be in an error state in this case.
+    return EOF;
+  }
+  written = __llvm_libc::stdout->write("\n", 1);
+  if (1 != written) {
+    // The stream should be in an error state in this case.
+    return EOF;
+  }
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

DEPENDS
     libc.include.errno
     libc.include.stdio
     libc.src.stdio.clearerr
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fflush
     libc.src.stdio.fopen
+    libc.src.stdio.fputs
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
 )
 
 add_libc_unittest(
   unlocked_fileop_test
   SUITE

 add_libc_unittest(
   printf_test
   SUITE
     libc_stdio_unittests
   SRCS
     printf_test.cpp
   DEPENDS
     libc.src.stdio.printf
-    libc.src.fenv.fesetround
+)
+
+add_libc_unittest(
+  puts_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    puts_test.cpp
+  DEPENDS
+    libc.src.stdio.puts
 )
 
 add_libc_unittest(
   remove_test
   SUITE
     libc_stdio_unittests
   SRCS
     remove_test.cpp

libc/test/src/stdio/fileop_test.cpp

 //===-- Unittests for file operations like fopen, flcose etc --------------===//
 //
 // 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/clearerr.h"
 #include "src/stdio/fclose.h"
 #include "src/stdio/feof.h"
 #include "src/stdio/ferror.h"
 #include "src/stdio/fflush.h"
 #include "src/stdio/fopen.h"
+#include "src/stdio/fputs.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <stdio.h>
 
TEST(LlvmLibcFILETest, SimpleFileOperations) {
 
   // Should be an error to write.
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), file));
   ASSERT_NE(__llvm_libc::ferror(file), 0);
   ASSERT_NE(errno, 0);
   errno = 0;
 
   __llvm_libc::clearerr(file);
+
+  // Should be an error to puts.
+  ASSERT_EQ(EOF, __llvm_libc::fputs(CONTENT, file));
+  ASSERT_NE(__llvm_libc::ferror(file), 0);
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
+  __llvm_libc::clearerr(file);
+  ASSERT_EQ(__llvm_libc::ferror(file), 0);
+
+  ASSERT_EQ(__llvm_libc::fclose(file), 0);
+
+  // Now try puts.
+  file = __llvm_libc::fopen(FILENAME, "w");
+  ASSERT_FALSE(file == nullptr);
+  // fputs returns a negative value on error (EOF) or any non-negative value on
+  // success. This assert checks that the return value is non-negative.
+  ASSERT_GE(__llvm_libc::fputs(CONTENT, file), 0);
+
+  __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
+  ASSERT_EQ(0, __llvm_libc::fclose(file));
+
+  file = __llvm_libc::fopen(FILENAME, "r");
+  ASSERT_FALSE(file == nullptr);
+
+  ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT) - 1, file),
+            sizeof(CONTENT) - 1);
+  read_data[sizeof(CONTENT) - 1] = '\0';
+  ASSERT_STREQ(read_data, CONTENT);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 }
 
 TEST(LlvmLibcFILETest, FFlush) {
   constexpr char FILENAME[] = "testdata/fflush.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";

libc/test/src/stdio/puts_test.cpp

+//===-- Unittests for puts ---------------------------------------------===//
+//
+// 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/puts.h"
+
+#include "utils/UnitTest/Test.h"
+
+TEST(LlvmLibcPutsTest, PrintOut) {
+  int result;
+
+  constexpr char simple[] = "A simple string";
+  result = __llvm_libc::puts(simple);
+  EXPECT_GE(result, 0);
+
+  // check that it appends a second newline at the end.
+  constexpr char numbers[] = "1234567890\n";
+  result = __llvm_libc::puts(numbers);
+  EXPECT_GE(result, 0);
+
+  constexpr char more[] = "1234 and more\n6789 and rhyme";
+  result = __llvm_libc::puts(more);
+  EXPECT_GE(result, 0);
+}