[libc] add result class to strtointeger

[michaelrj]

Summary

This is a class intended to improve errno handling for internal
functions by allowing functions to return their result and error status
instead of setting errno. This specific class will be used for
strtointeger and (in a followup patch) strtofloat.

[lntue]

libc/src/__support/error_and.h

24 ↗

(On Diff #457423)

I think ValWithErrno, WithErrno or something similar would be more suitable, especially since the constructors have value comes first.

[sivachandra]

libc/src/__support/error_and.h

23 ↗

(On Diff #457423)

Going by the use case in strtointeger, it doesn't feel like this is the appropriate data structure. The use cases always return a value and some times need an error status also. So, I suggest that strointeger only return a data type like:

<typename T>
struct StrToIntegerResult {
  // Errors during conversion are represented with error values from errno.h.
  int conv_status = 0;
  // Length of the input string parsed.
  size_t parse_length = 0;
  // Conversion result.
  T result = 0;
};

The strtointeger header is modified as:

// As this is a template, we don't need to mark this with `static inline`.
template <typename T>
StrToIntegerResult<T> strtointeger(cpp::string_view src, int base) {
 ...
}

See below for example how this is to be used at call sites.

libc/src/__support/str_to_integer.h

153

We should not set errno in internal functions, especially in __support.

libc/src/inttypes/strtoimax.cpp

18–25

auto result = strtointeger(str, base);
errno = result.conv_status;
*str_end = str + result.parse_length;
return result.conv_val;

It might feel like repeated code, but it was already physically repeated in strtointeger_errno. Textual repetition is OK.

[michaelrj]

libc/src/__support/error_and.h

23 ↗

(On Diff #457423)

While we could move to a full struct containing the output, I like the idea of sticking closer to the original prototype of the function. It means less adaptor code and avoids defining a struct for this one function. Additionally, a stringview doesn't work as an input for this function, since it's not provided with a string length. While we could effectively call strlen on the string, that isn't helpful as one of the outputs of this function is already the length of the integer parsed which is less than or equal to the total length of the string.

24 ↗

(On Diff #457423)

I like the name ErrorAnd because when it's templated you get a name like ErrorAnd<int>. Additionally, for functions that don't return a value on error I've briefly discussed the idea of an ErrorOr class, and I don't know if there's as good a parallel for WithErrno. Ultimately it's just a name though, and I don't have a particularly strong opinion.

libc/src/__support/str_to_integer.h

153

I feel that it's more important to not set errno unexpectedly in __support, as opposed to at all. While it's true we could just repeat the code in strtointeger_errno in every entrypoint to avoid having errno in here that feels like unnecessary repetition. The code isn't just similar, it's literally the same. It's also used in 9 different entrypoints in 2 different folders, which leads to a significant chance for mistakes during refactors. If you really don't want errno in __support then we can move this errno wrapper into a shared header in stdlib, but I don't think having it identical in every entrypoint is good.

[sivachandra]

libc/src/__support/error_and.h

23 ↗

(On Diff #457423)

A struct is not any different operationally from ErrorAnd and would be more strtointeger specific. The adapter code is all confined to just one place (like the template helper you have below.) But, the point you make about string_view is valid not just because of strlen, but even correctness wise:

1. string_view has a constructor which can initialize from a raw pointer: https://github.com/llvm/llvm-project/blob/main/libc/src/__support/CPP/string_view.h#L67
2. But, there is not guarantee that the raw pointer is null-terminated. So, we cannot use string_view as you have concluded.

libc/src/__support/str_to_integer.h

153

OK for moving this errno setting template to some other place, say stdlib as you have said.

[michaelrj]

move to specific strtointeger result struct since the new design will have separate return structs for different internal components.

[sivachandra]

libc/src/__support/str_to_num_result.h

17

You can keep this a struct and avoid the getters. You can choose to keep the has_error method if you want.

20

Nit: str_len can be ambiguous. Name it parsed_length of something more indicative of what it is.

[michaelrj]

move to struct with directly accessed members instead of getters.

[michaelrj]

fix up cmake names before landing

libc/src/__support/CMakeLists.txt

 
 add_header_library(
   ctype_utils
   HDRS
     ctype_utils.h
 )
 
 add_header_library(
+  str_to_num_result
+  HDRS
+    str_to_num_result.h
+)
+
+add_header_library(
   str_to_integer
   HDRS
     str_to_integer.h
   DEPENDS
     .ctype_utils
+    .str_to_num_result
     libc.include.errno
     libc.src.errno.errno
     libc.src.__support.CPP.limits
 )
 
 add_header_library(
   integer_to_string
   HDRS

libc/src/__support/high_precision_decimal.h

HighPrecisionDecimal(const char *__restrict numString) {
     }
 
     if (!saw_dot)
       this->decimal_point = total_digits;
 
     if ((*numString | 32) == 'e') {
       ++numString;
       if (isdigit(*numString) || *numString == '+' || *numString == '-') {
-        int32_t add_to_exp = strtointeger<int32_t>(numString, nullptr, 10);
+        int32_t add_to_exp = strtointeger<int32_t>(numString, 10);
         if (add_to_exp > 100000) {
           add_to_exp = 100000;
         } else if (add_to_exp < -100000) {
           add_to_exp = -100000;
         }
         this->decimal_point += add_to_exp;
       }
     }

libc/src/__support/str_to_float.h

decimal_string_to_float(const char *__restrict src, const char DECIMAL_POINT,
 
   if (!seen_digit)
     return false;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
       char *temp_str_end;
-      int32_t add_to_exponent = strtointeger<int32_t>(src, &temp_str_end, 10);
+      auto result = strtointeger<int32_t>(src, 10);
+      // TODO: If error, return with error.
+      temp_str_end = const_cast<char *>(src + result.parsed_len);
+      int32_t add_to_exponent = result.value;
       if (add_to_exponent > 100000)
         add_to_exponent = 100000;
       else if (add_to_exponent < -100000)
         add_to_exponent = -100000;
 
       src = temp_str_end;
       exponent += add_to_exponent;
     }
static inline bool hexadecimal_string_to_float(
 
   // Convert the exponent from having a base of 16 to having a base of 2.
   exponent *= 4;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
       char *temp_str_end;
-      int32_t add_to_exponent = strtointeger<int32_t>(src, &temp_str_end, 10);
+      auto result = strtointeger<int32_t>(src, 10);
+      // TODO: If error, return error.
+      temp_str_end = const_cast<char *>(src + result.parsed_len);
+      int32_t add_to_exponent = result.value;
       if (add_to_exponent > 100000)
         add_to_exponent = 100000;
       else if (add_to_exponent < -100000)
         add_to_exponent = -100000;
       src = temp_str_end;
       exponent += add_to_exponent;
     }
   }
if ((src[1] | 32) == nan_string[1] && (src[2] | 32) == nan_string[2]) {
           ++src;
           char *temp_src = 0;
           if (isdigit(*(left_paren + 1))) {
             // This is to prevent errors when BitsType is larger than 64 bits,
             // since strtointeger only supports up to 64 bits. This is actually
             // more than is required by the specification, which says for the
             // input type "NAN(n-char-sequence)" that "the meaning of
             // the n-char sequence is implementation-defined."
-            nan_mantissa = static_cast<BitsType>(
-                strtointeger<uint64_t>(left_paren + 1, &temp_src, 0));
+
+            auto result = strtointeger<uint64_t>(left_paren + 1, 0);
+            // TODO: If error, return error
+            temp_src = const_cast<char *>(left_paren + 1 + result.parsed_len);
+            nan_mantissa = result.value;
             if (*temp_src != ')')
               nan_mantissa = 0;
           }
         } else
           src = left_paren;
       }
       nan_mantissa |= fputil::FloatProperties<T>::QUIET_NAN_MASK;
       if (result.get_sign()) {

libc/src/__support/str_to_integer.h

 //===-- String to integer conversion utils ----------------------*- 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 LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 #define LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/ctype_utils.h"
+#include "src/__support/str_to_num_result.h"
 #include <errno.h>
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
 // character (as determined by isspace())
else if (**src == '0') {
     return 8;
   } // A decimal number is defined as beginning "with a nonzero digit and
     // consist[ing] of a sequence of decimal digits." (C standard 6.4.4.1)
   else {
     return 10;
   }
 }
 
-// Takes a pointer to a string, a pointer to a string pointer, and the base to
-// convert to. This function is used as the backend for all of the string to int
-// functions.
+// Takes a pointer to a string and the base to convert to. This function is used
+// as the backend for all of the string to int functions.
 template <class T>
-static inline T strtointeger(const char *__restrict src,
-                             char **__restrict str_end, int base) {
+static inline StrToNumResult<T> strtointeger(const char *__restrict src,
+                                             int base) {
   unsigned long long result = 0;
   bool is_number = false;
   const char *original_src = src;
+  int error_val = 0;
 
   if (base < 0 || base == 1 || base > 36) {
-    errno = EINVAL;
-    return 0;
+    error_val = EINVAL;
+    return {0, 0, error_val};
   }
 
   src = first_non_whitespace(src);
 
   char result_sign = '+';
   if (*src == '+' || *src == '-') {
     result_sign = *src;
     ++src;
while (isalnum(*src)) {
 
     is_number = true;
     ++src;
 
     // If the number has already hit the maximum value for the current type then
     // the result cannot change, but we still need to advance src to the end of
     // the number.
     if (result == abs_max) {
-      errno = ERANGE;
+      error_val = ERANGE;
       continue;
     }
 
     if (result > abs_max_div_by_base) {
       result = abs_max;
-      errno = ERANGE;
+      error_val = ERANGE;
     } else {
       result = result * base;
     }
     if (result > abs_max - cur_digit) {
       result = abs_max;
-      errno = ERANGE;
+      error_val = ERANGE;
     } else {
       result = result + cur_digit;
     }
   }
 
-  if (str_end != nullptr)
-    *str_end = const_cast<char *>(is_number ? src : original_src);
+  ptrdiff_t str_len = is_number ? (src - original_src) : 0;
 
   if (result == abs_max) {
     if (is_positive || IS_UNSIGNED)
-      return cpp::numeric_limits<T>::max();
+      return {cpp::numeric_limits<T>::max(), str_len, error_val};
     else // T is signed and there is a negative overflow
-      return cpp::numeric_limits<T>::min();
+      return {cpp::numeric_limits<T>::min(), str_len, error_val};
   }
 
-  return is_positive ? static_cast<T>(result) : -static_cast<T>(result);
+  return {is_positive ? static_cast<T>(result) : -static_cast<T>(result),
+          str_len, error_val};
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_SUPPORT_STR_TO_INTEGER_H

libc/src/__support/str_to_num_result.h

+//===-- A data structure for str_to_number to return ------------*- 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_SUPPORT_STR_TO_NUM_RESULT_H
+#define LLVM_LIBC_SUPPORT_STR_TO_NUM_RESULT_H
+
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+template <typename T> struct StrToNumResult {
+  T value;
+  int error;
+  ptrdiff_t parsed_len;
+
+  constexpr StrToNumResult(T value) : value(value), error(0), parsed_len(0) {}
+  constexpr StrToNumResult(T value, ptrdiff_t parsed_len)
+      : value(value), error(0), parsed_len(parsed_len) {}
+  constexpr StrToNumResult(T value, ptrdiff_t parsed_len, int error)
+      : value(value), error(error), parsed_len(parsed_len) {}
+
+  constexpr bool has_error() { return error != 0; }
+
+  constexpr operator T() { return value; }
+};
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SUPPORT_STR_TO_NUM_RESULT_H

libc/src/inttypes/strtoimax.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(intmax_t, strtoimax,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<intmax_t>(str, str_end, base);
+  auto result = internal::strtointeger<intmax_t>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/inttypes/strtoumax.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(uintmax_t, strtoumax,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<uintmax_t>(str, str_end, base);
+  auto result = internal::strtointeger<uintmax_t>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/parser.cpp

#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
     // handle width
     section.min_width = 0;
     if (str[cur_pos] == '*') {
       ++cur_pos;
 
       section.min_width = GET_ARG_VAL_SIMPLEST(int, parse_index(&cur_pos));
     } else if (internal::isdigit(str[cur_pos])) {
-      char *int_end;
-      section.min_width =
-          internal::strtointeger<int>(str + cur_pos, &int_end, 10);
-      cur_pos = int_end - str;
+      auto result = internal::strtointeger<int>(str + cur_pos, 10);
+      section.min_width = result.value;
+      cur_pos = cur_pos + result.parsed_len;
     }
     if (section.min_width < 0) {
       section.min_width = -section.min_width;
       section.flags =
           static_cast<FormatFlags>(section.flags | FormatFlags::LEFT_JUSTIFIED);
     }
 
     // handle precision
     section.precision = -1; // negative precisions are ignored.
     if (str[cur_pos] == '.') {
       ++cur_pos;
       section.precision = 0; // if there's a . but no specified precision, the
                              // precision is implicitly 0.
       if (str[cur_pos] == '*') {
         ++cur_pos;
 
         section.precision = GET_ARG_VAL_SIMPLEST(int, parse_index(&cur_pos));
 
       } else if (internal::isdigit(str[cur_pos])) {
-        char *int_end;
-        section.precision =
-            internal::strtointeger<int>(str + cur_pos, &int_end, 10);
-        cur_pos = int_end - str;
+        auto result = internal::strtointeger<int>(str + cur_pos, 10);
+        section.precision = result.value;
+        cur_pos = cur_pos + result.parsed_len;
       }
     }
 
     LengthModifier lm = parse_length_modifier(&cur_pos);
 
     section.length_modifier = lm;
     section.conv_name = str[cur_pos];
     switch (str[cur_pos]) {

 //----------------------------------------------------
 // INDEX MODE ONLY FUNCTIONS AFTER HERE:
 //----------------------------------------------------
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 size_t Parser::parse_index(size_t *local_pos) {
   if (internal::isdigit(str[*local_pos])) {
-    char *int_end;
-    size_t index =
-        internal::strtointeger<size_t>(str + *local_pos, &int_end, 10);
-    if (int_end[0] != '$')
+    auto result = internal::strtointeger<int>(str + *local_pos, 10);
+    size_t index = result.value;
+    if (str[*local_pos + result.parsed_len] != '$')
       return 0;
-    *local_pos = 1 + int_end - str;
+    *local_pos = 1 + result.parsed_len + *local_pos;
     return index;
   }
   return 0;
 }
 
 Parser::TypeDesc Parser::get_type_desc(size_t index) {
   // index mode is assumed, and the indicies start at 1, so an index
   // of 0 is invalid.

libc/src/stdio/scanf_core/parser.cpp

#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
     if (str[cur_pos] == '*') {
       ++cur_pos;
       section.flags = FormatFlags::NO_WRITE;
     }
 
     // handle width
     section.max_width = -1;
     if (internal::isdigit(str[cur_pos])) {
-      char *int_end;
-      section.max_width =
-          internal::strtointeger<int>(str + cur_pos, &int_end, 10);
-      cur_pos = int_end - str;
+      auto result = internal::strtointeger<int>(str + cur_pos, 10);
+      section.max_width = result.value;
+      cur_pos = cur_pos + result.parsed_len;
     }
 
     // TODO(michaelrj): add posix allocate flag support.
     // if (str[cur_pos] == 'm') {
     //   ++cur_pos;
     //   section.flags = FormatFlags::ALLOCATE;
     // }
 

 //----------------------------------------------------
 // INDEX MODE ONLY FUNCTIONS AFTER HERE:
 //----------------------------------------------------
 
 #ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
 
 size_t Parser::parse_index(size_t *local_pos) {
   if (internal::isdigit(str[*local_pos])) {
-    char *int_end;
-    size_t index =
-        internal::strtointeger<size_t>(str + *local_pos, &int_end, 10);
-    if (int_end[0] != '$')
+    auto result = internal::strtointeger<int>(str + *local_pos, 10);
+    size_t index = result.value;
+    if (str[*local_pos + result.parsed_len] != '$')
       return 0;
-    *local_pos = 1 + int_end - str;
+    *local_pos = 1 + result.parsed_len + *local_pos;
     return index;
   }
   return 0;
 }
 
 void Parser::args_to_index(size_t index) {
   if (args_index > index) {
     args_index = 1;

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_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, atoi, (const char *str)) {
-  return internal::strtointeger<int>(str, nullptr, 10);
+  auto result = internal::strtointeger<int>(str, 10);
+  if (result.has_error())
+    errno = result.error;
+
+  return result;
 }
 
 } // namespace __llvm_libc

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_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, atol, (const char *str)) {
-  return internal::strtointeger<long>(str, nullptr, 10);
+  auto result = internal::strtointeger<int>(str, 10);
+  if (result.has_error())
+    errno = result.error;
+
+  return result;
 }
 
 } // namespace __llvm_libc

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_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, atoll, (const char *str)) {
-  return internal::strtointeger<long long>(str, nullptr, 10);
+  auto result = internal::strtointeger<long long>(str, 10);
+  if (result.has_error())
+    errno = result.error;
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtol.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, strtol,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<long>(str, str_end, base);
+  auto result = internal::strtointeger<long>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoll.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, strtoll,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<long long>(str, str_end, base);
+  auto result = internal::strtointeger<long long>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoul.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(unsigned long, strtoul,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<unsigned long>(str, str_end, base);
+  auto result = internal::strtointeger<unsigned long>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoull.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(unsigned long long, strtoull,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtointeger<unsigned long long>(str, str_end, base);
+  auto result = internal::strtointeger<unsigned long long>(str, base);
+  if (result.has_error())
+    errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
 }
 
 } // namespace __llvm_libc

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

cc_library(
     hdrs = ["src/__support/UInt128.h"],
     deps = [
         ":__support_uint",
         ":libc_root",
     ],
 )
 
 cc_library(
+    name = "__support_str_to_num_result",
+    hdrs = ["src/__support/str_to_num_result.h"],
+    deps = [
+        ":libc_root",
+    ],
+)
+
+cc_library(
     name = "__support_integer_operations",
     hdrs = ["src/__support/integer_operations.h"],
     deps = [":__support_cpp_type_traits"],
 )
 
 cc_library(
     name = "__support_ctype_utils",
     hdrs = ["src/__support/ctype_utils.h"],
 )
 
 cc_library(
     name = "__support_str_to_integer",
     hdrs = ["src/__support/str_to_integer.h"],
     deps = [
         ":__support_cpp_limits",
         ":__support_ctype_utils",
+        ":__support_str_to_num_result",
     ],
 )
 
 cc_library(
     name = "__support_fputil_basic_operations",
     hdrs = ["src/__support/FPUtil/BasicOperations.h"],
     deps = [
         ":__support_cpp_type_traits",