[libc] add atoi, atol, and atoll

[michaelrj]

Summary

This is based on the work done to add strtoll and the other strto
functions. The atoi functions also were added to stdc and
entrypoints.txt.

[sivachandra]

libc/test/src/stdlib/atol_test.cpp

42

No LONG_MAX tests?

Also, test for overflow values in all tests? We don't need to check the errno value but may be check that the return value is *_MAX/*_MIN?

48

Is this really an invalid number?

[michaelrj]

address comments

libc/test/src/stdlib/atol_test.cpp

42

I've been avoiding LONG_MAX in the tests, since the size of LONG_MAX changes based on the operating system, specifically Windows uses 32 bit long while linux uses 64 bit long. This is difficult when I'm hardcoding the strings.

There aren't any overflow value tests since overflowing is undefined behavior for atoi. I can add them, but it means we're testing things that aren't in the specification.

48

I've changed the name of the tests, 010 isn't an invalid number, but it is interpreted as an octal number if the base is set to 0.

libc/config/linux/x86_64/entrypoints.txt

if(LLVM_LIBC_FULL_BUILD)
   list(APPEND TARGET_LIBC_ENTRYPOINTS
     # assert.h entrypoints
     libc.src.assert.__assert_fail
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.abort
     libc.src.stdlib.abs
+    libc.src.stdlib.atoi
+    libc.src.stdlib.atol
+    libc.src.stdlib.atoll
     libc.src.stdlib.labs
     libc.src.stdlib.llabs
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull
 
     # signal.h entrypoints

libc/spec/stdc.td

def StdC : StandardSpec<"stdc"> {
   HeaderSpec StdLib = HeaderSpec<
       "stdlib.h",
       [], // Macros
       [], // Types
       [], // Enumerations
       [
           FunctionSpec<"abort", RetValSpec<NoReturn>, [ArgSpec<VoidType>]>,
           FunctionSpec<"abs", RetValSpec<IntType>, [ArgSpec<IntType>]>,
+          FunctionSpec<"atoi", RetValSpec<IntType>, [ArgSpec<ConstCharPtr>]>,
+          FunctionSpec<"atol", RetValSpec<LongType>, [ArgSpec<ConstCharPtr>]>,
+          FunctionSpec<"atoll", RetValSpec<LongLongType>, [ArgSpec<ConstCharPtr>]>,
           FunctionSpec<"labs", RetValSpec<LongType>, [ArgSpec<LongType>]>,
           FunctionSpec<"llabs", RetValSpec<LongLongType>, [ArgSpec<LongLongType>]>,
           FunctionSpec<"strtol", RetValSpec<LongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"strtoll", RetValSpec<LongLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"strtoul", RetValSpec<UnsignedLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"strtoull", RetValSpec<UnsignedLongLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"_Exit", RetValSpec<NoReturn>, [ArgSpec<IntType>]>,
       ]

libc/src/stdlib/CMakeLists.txt

SRCS
     abs.cpp
   HDRS
     abs.h
   DEPENDS
     libc.src.__support.integer_operations
 )
 
 add_entrypoint_object(
+  atoi
+  SRCS
+    atoi.cpp
+  HDRS
+    atoi.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
+  atol
+  SRCS
+    atol.cpp
+  HDRS
+    atol.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
+  atoll
+  SRCS
+    atoll.cpp
+  HDRS
+    atoll.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
   labs
   SRCS
     labs.cpp
   HDRS
     labs.h
   DEPENDS
     libc.src.__support.integer_operations
 )

libc/src/stdlib/atoi.h

+//===-- Implementation header for atoi --------------------------*- 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_STDLIB_ATOI_H
+#define LLVM_LIBC_SRC_STDLIB_ATOI_H
+
+namespace __llvm_libc {
+
+int atoi(const char *str);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_ATOI_H

libc/src/stdlib/atoi.cpp

+//===-- Implementation of atoi --------------------------------------------===//
+//
+// 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/stdlib/atoi.h"
+#include "src/__support/common.h"
+#include "src/__support/str_conv_utils.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, atoi, (const char *str)) {
+  return internal::strtointeger<int>(str, nullptr, 10);
+}
+
+} // namespace __llvm_libc

libc/src/stdlib/atol.h

+//===-- Implementation header for atol --------------------------*- 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_STDLIB_ATOL_H
+#define LLVM_LIBC_SRC_STDLIB_ATOL_H
+
+namespace __llvm_libc {
+
+long atol(const char *str);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_ATOL_H

libc/src/stdlib/atol.cpp

+//===-- Implementation of atol --------------------------------------------===//
+//
+// 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/stdlib/atol.h"
+#include "src/__support/common.h"
+#include "src/__support/str_conv_utils.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(long, atol, (const char *str)) {
+  return internal::strtointeger<long>(str, nullptr, 10);
+}
+
+} // namespace __llvm_libc

libc/src/stdlib/atoll.h

+//===-- Implementation header for atoll -------------------------*- 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_STDLIB_ATOLL_H
+#define LLVM_LIBC_SRC_STDLIB_ATOLL_H
+
+namespace __llvm_libc {
+
+long long atoll(const char *str);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_ATOLL_H

libc/src/stdlib/atoll.cpp

+//===-- Implementation of atoll -------------------------------------------===//
+//
+// 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/stdlib/atoll.h"
+#include "src/__support/common.h"
+#include "src/__support/str_conv_utils.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(long long, atoll, (const char *str)) {
+  return internal::strtointeger<long long>(str, nullptr, 10);
+}
+
+} // namespace __llvm_libc

libc/test/src/stdlib/atoi_test.cpp

+//===-- Unittests for atoi -----------------------------------------------===//
+//
+// 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/stdlib/atoi.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+TEST(LlvmLibcAToITest, ValidNumbers) {
+  const char *zero = "0";
+  ASSERT_EQ(__llvm_libc::atoi(zero), 0);
+
+  const char *ten = "10";
+  ASSERT_EQ(__llvm_libc::atoi(ten), 10);
+
+  const char *negative_hundred = "-100";
+  ASSERT_EQ(__llvm_libc::atoi(negative_hundred), -100);
+
+  const char *positive_thousand = "+1000";
+  ASSERT_EQ(__llvm_libc::atoi(positive_thousand), 1000);
+
+  const char *spaces_before = "     12345";
+  ASSERT_EQ(__llvm_libc::atoi(spaces_before), 12345);
+
+  const char *tabs_before = "\t\t\t\t67890";
+  ASSERT_EQ(__llvm_libc::atoi(tabs_before), 67890);
+
+  const char *letters_after = "123abc";
+  ASSERT_EQ(__llvm_libc::atoi(letters_after), 123);
+
+  const char *letters_between = "456def789";
+  ASSERT_EQ(__llvm_libc::atoi(letters_between), 456);
+
+  const char *all_together = "\t   110 times 5 = 550";
+  ASSERT_EQ(__llvm_libc::atoi(all_together), 110);
+
+  const char *biggest_int = "2147483647";
+  ASSERT_EQ(__llvm_libc::atoi(biggest_int), INT_MAX);
+
+  const char *smallest_int = "-2147483648";
+  ASSERT_EQ(__llvm_libc::atoi(smallest_int), INT_MIN);
+}
+
+TEST(LlvmLibcAToITest, InvalidNumbers) {
+  const char *hexadecimal = "0x10";
+  ASSERT_EQ(__llvm_libc::atoi(hexadecimal), 0);
+
+  const char *octal = "010";
+  ASSERT_EQ(__llvm_libc::atoi(octal), 10);
+
+  const char *decimal_point = "5.9";
+  ASSERT_EQ(__llvm_libc::atoi(decimal_point), 5);
+}
+
+TEST(LlvmLibcAToITest, NotNumbers) {
+  const char *ten_as_word = "ten";
+  ASSERT_EQ(__llvm_libc::atoi(ten_as_word), 0);
+
+  const char *lots_of_letters =
+      "wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
+  ASSERT_EQ(__llvm_libc::atoi(lots_of_letters), 0);
+}

libc/test/src/stdlib/atol_test.cpp

+//===-- Unittests for atol -----------------------------------------------===//
+//
+// 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/stdlib/atol.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+TEST(LlvmLibcAToLTest, ValidNumbers) {
+  const char *zero = "0";
+  ASSERT_EQ(__llvm_libc::atol(zero), 0l);
+
+  const char *ten = "10";
+  ASSERT_EQ(__llvm_libc::atol(ten), 10l);
+
+  const char *negative_hundred = "-100";
+  ASSERT_EQ(__llvm_libc::atol(negative_hundred), -100l);
+
+  const char *positive_thousand = "+1000";
+  ASSERT_EQ(__llvm_libc::atol(positive_thousand), 1000l);
+
+  const char *spaces_before = "     12345";
+  ASSERT_EQ(__llvm_libc::atol(spaces_before), 12345l);
+
+  const char *tabs_before = "\t\t\t\t67890";
+  ASSERT_EQ(__llvm_libc::atol(tabs_before), 67890l);
+
+  const char *letters_after = "123abc";
+  ASSERT_EQ(__llvm_libc::atol(letters_after), 123l);
+
+  const char *letters_between = "456def789";
+  ASSERT_EQ(__llvm_libc::atol(letters_between), 456l);
+
+  const char *all_together = "\t   110 times 5 = 550";
+  ASSERT_EQ(__llvm_libc::atol(all_together), 110l);
+}
+
+TEST(LlvmLibcAToLTest, InvalidNumbers) {
+  const char *hexadecimal = "0x10";
+  ASSERT_EQ(__llvm_libc::atol(hexadecimal), 0l);
+
+  const char *octal = "010";
+  ASSERT_EQ(__llvm_libc::atol(hexadecimal), 10l);
+
+  const char *decimal_point = "5.9";
+  ASSERT_EQ(__llvm_libc::atol(decimal_point), 5l);
+}
+
+TEST(LlvmLibcAToLTest, NotNumbers) {
+  const char *ten_as_word = "ten";
+  ASSERT_EQ(__llvm_libc::atol(ten_as_word), 0l);
+
+  const char *lots_of_letters =
+      "wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
+  ASSERT_EQ(__llvm_libc::atol(lots_of_letters), 0l);
+}

libc/test/src/stdlib/atoll_test.cpp

+//===-- Unittests for atoll -----------------------------------------------===//
+//
+// 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/stdlib/atoll.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+TEST(LlvmLibcAToLLTest, ValidNumbers) {
+  const char *zero = "0";
+  ASSERT_EQ(__llvm_libc::atoll(zero), 0ll);
+
+  const char *ten = "10";
+  ASSERT_EQ(__llvm_libc::atoll(ten), 10ll);
+
+  const char *negative_hundred = "-100";
+  ASSERT_EQ(__llvm_libc::atoll(negative_hundred), -100ll);
+
+  const char *positive_thousand = "+1000";
+  ASSERT_EQ(__llvm_libc::atoll(positive_thousand), 1000ll);
+
+  const char *spaces_before = "     12345";
+  ASSERT_EQ(__llvm_libc::atoll(spaces_before), 12345ll);
+
+  const char *tabs_before = "\t\t\t\t67890";
+  ASSERT_EQ(__llvm_libc::atoll(tabs_before), 67890ll);
+
+  const char *letters_after = "123abc";
+  ASSERT_EQ(__llvm_libc::atoll(letters_after), 123ll);
+
+  const char *letters_between = "456def789";
+  ASSERT_EQ(__llvm_libc::atoll(letters_between), 456ll);
+
+  const char *all_together = "\t   110 times 5 = 550";
+  ASSERT_EQ(__llvm_libc::atoll(all_together), 110ll);
+
+  const char *biggest_long_long = "9223372036854775807";
+  ASSERT_EQ(__llvm_libc::atoll(biggest_int), LLONG_MAX);
+
+  const char *smallest_long_long = "-9223372036854775808";
+  ASSERT_EQ(__llvm_libc::atoll(smallest_int), LLONG_MIN);
+}
+
+TEST(LlvmLibcAToLLTest, InvalidNumbers) {
+  const char *hexadecimal = "0x10";
+  ASSERT_EQ(__llvm_libc::atoll(hexadecimal), 0ll);
+
+  const char *octal = "010";
+  ASSERT_EQ(__llvm_libc::atoll(hexadecimal), 10ll);
+
+  const char *decimal_point = "5.9";
+  ASSERT_EQ(__llvm_libc::atol(decimal_point), 5l);
+}
+
+TEST(LlvmLibcAToLLTest, NotNumbers) {
+  const char *ten_as_word = "ten";
+  ASSERT_EQ(__llvm_libc::atoll(ten_as_word), 0ll);
+
+  const char *lots_of_letters =
+      "wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
+  ASSERT_EQ(__llvm_libc::atoll(lots_of_letters), 0ll);
+}