Changes in uspace/lib/posix/stdlib/strtol.c [aa5acd47:ec18957a] in mainline

File:

• uspace/lib/posix/stdlib/strtol.c (modified) (12 diffs)

uspace/lib/posix/stdlib/strtol.c

@@ -30 +30 @@
  * @{
  */
-/** @file Backend for integer conversions.
+/** @file
  */
 
@@ -38 +38 @@
 #include "../stdlib.h"
 
+#include "../limits.h"
 #include "../ctype.h"
 #include "../errno.h"
-#include "../inttypes.h"
-#include "../limits.h"
-
-#define intmax_t posix_intmax_t
-#define uintmax_t posix_uintmax_t
-
-/**
- * Decides whether a digit belongs to a particular base.
- *
- * @param c Character representation of the digit.
- * @param base Base against which the digit shall be tested.
- * @return True if the digit belongs to the base, false otherwise.
- */
+
+// TODO: documentation
+
 static inline bool is_digit_in_base(int c, int base)
 {
@@ -63 +54 @@
 }
 
-/**
- * Derive a digit from its character representation.
- *
- * @param c Character representation of the digit.
- * @return Digit value represented by an integer.
- */
-static inline int digit_value(int c)
+static inline int get_digit_in_base(int c, int base)
 {
         if (c <= '9') {
@@ -78 +63 @@
 }
 
-/**
- * Generic function for parsing an integer from it's string representation.
- * Different variants differ in lower and upper bounds.
- * The parsed string returned by this function is always positive, sign
- * information is provided via a dedicated parameter.
- *
- * @param nptr Input string.
- * @param endptr If non-NULL, *endptr is set to the position of the first
- *     unrecognized character. If no digit has been parsed, value of
- *     nptr is stored there (regardless of any skipped characters at the
- *     beginning).
- * @param base Expected base of the string representation. If 0, base is
- *    determined to be decimal, octal or hexadecimal using the same rules
- *    as C syntax. Otherwise, value must be between 2 and 36, inclusive.
- * @param min_value Lower bound for the resulting conversion.
- * @param max_value Upper bound for the resulting conversion.
- * @param out_negative Either NULL for unsigned conversion or a pointer to the
- *     bool variable into which shall be placed the negativity of the resulting
- *     converted value.
- * @return The absolute value of the parsed value, or the closest in-range value
- *     if the parsed value is out of range. If the input is invalid, zero is
- *     returned and errno is set to EINVAL.
- */
-static inline uintmax_t internal_strtol(
+static inline unsigned long long internal_strtol(
     const char *restrict nptr, char **restrict endptr, int base,
-    const intmax_t min_value, const uintmax_t max_value,
+    const long long min_value, const unsigned long long max_value,
     bool *restrict out_negative)
 {
@@ -116 +78 @@
         }
         
-        /* The maximal absolute value that can be returned in this run.
-         * Depends on sign.
-         */
-        uintmax_t real_max_value = max_value;
+        unsigned long long real_max_value = max_value;
         
         /* Current index in the input string. */
-        size_t i = 0;
+        int i = 0;
         bool negative = false;
         
@@ -134 +93 @@
         case '-':
                 negative = true;
-                
-                /* The strange computation is are there to avoid a corner case
-                 * where -min_value can't be represented in intmax_t.
-                 * (I'm not exactly sure what the semantics are in such a
-                 *  case, but this should be safe for any case.)
-                 */
-                real_max_value = (min_value == 0)
-                    ? 0
-                    :(((uintmax_t) -(min_value + 1)) + 1);
-                
+                real_max_value = -min_value;
                 /* fallthrough */
         case '+':
@@ -154 +104 @@
                 if (nptr[i] == '0') {
                         if (tolower(nptr[i + 1]) == 'x') {
-                                /* 0x... is hex. */
                                 base = 16;
                                 i += 2;
                         } else {
-                                /* 0... is octal. */
                                 base = 8;
                         }
                 } else {
-                        /* Anything else is decimal by default. */
                         base = 10;
                 }
                 break;
         case 16:
-                /* Allow hex number to be prefixed with "0x". */
                 if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x') {
                         i += 2;
@@ -187 +133 @@
          * of overflow.
          */
-        uintmax_t max_safe_value = (real_max_value - base + 1) / base;
-        
-        uintmax_t result = 0;
+        unsigned long long max_safe_value = (real_max_value - base + 1) / base;
+        
+        unsigned long long result = 0;
         
         if (real_max_value == 0) {
@@ -199 +145 @@
                         if (nptr[i] != '0') {
                                 errno = ERANGE;
-                                result = 0;
+                                result = max_value;
                         }
                         i++;
@@ -206 +152 @@
         
         while (is_digit_in_base(nptr[i], base)) {
-                int digit = digit_value(nptr[i]);
+                int digit = get_digit_in_base(nptr[i], base);
                 
                 if (result > max_safe_value) {
                         /* corner case, check for overflow */
                         
-                        uintmax_t boundary = (real_max_value - digit) / base;
+                        unsigned long long
+                            boundary = (real_max_value - digit) / base;
                         
                         if (result > boundary) {
                                 /* overflow */
                                 errno = ERANGE;
-                                result = real_max_value;
+                                result = max_value;
                                 break;
                         }
@@ -241 +188 @@
 }
 
-/**
- * Convert a string to an integer.
- *
- * @param nptr Input string.
- * @return Result of the conversion.
- */
 int posix_atoi(const char *nptr)
 {
         bool neg = false;
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, NULL, 10, INT_MIN, INT_MAX, &neg);
 
-        return (neg ? ((int) -result) : (int) result);
-}
-
-/**
- * Convert a string to a long integer.
- *
- * @param nptr Input string.
- * @return Result of the conversion.
- */
+        return (int) (neg ? -result : result);
+}
+
 long posix_atol(const char *nptr)
 {
         bool neg = false;
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, NULL, 10, LONG_MIN, LONG_MAX, &neg);
 
-        return (neg ? ((long) -result) : (long) result);
-}
-
-/**
- * Convert a string to a long long integer.
- *
- * @param nptr Input string.
- * @return Result of the conversion.
- */
+        return (long) (neg ? -result : result);
+}
+
 long long posix_atoll(const char *nptr)
 {
         bool neg = false;
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, NULL, 10, LLONG_MIN, LLONG_MAX, &neg);
 
-        return (neg ? ((long long) -result) : (long long) result);
-}
-
-/**
- * Convert a string to a long integer.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
+        return (long long) (neg ? -result : result);
+}
+
 long posix_strtol(const char *restrict nptr, char **restrict endptr, int base)
 {
         bool neg = false;
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, endptr, base, LONG_MIN, LONG_MAX, &neg);
 
-        return (neg ? ((long) -result) : ((long) result));
-}
-
-/**
- * Convert a string to a long long integer.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
+        return (long) (neg ? -result : result);
+}
+
 long long posix_strtoll(
     const char *restrict nptr, char **restrict endptr, int base)
 {
         bool neg = false;
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &neg);
 
-        return (neg ? ((long long) -result) : (long long) result);
-}
-
-/**
- * Convert a string to a largest signed integer type.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
-intmax_t posix_strtoimax(
-    const char *restrict nptr, char **restrict endptr, int base)
-{
-        bool neg = false;
-        uintmax_t result =
-            internal_strtol(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &neg);
-
-        return (neg ? ((intmax_t) -result) : (intmax_t) result);
-}
-
-/**
- * Convert a string to an unsigned long integer.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
+        return (long long) (neg ? -result : result);
+}
+
 unsigned long posix_strtoul(
     const char *restrict nptr, char **restrict endptr, int base)
 {
-        uintmax_t result =
+        unsigned long long result =
             internal_strtol(nptr, endptr, base, 0, ULONG_MAX, NULL);
 
@@ -360 +243 @@
 }
 
-/**
- * Convert a string to an unsigned long long integer.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
 unsigned long long posix_strtoull(
     const char *restrict nptr, char **restrict endptr, int base)
 {
-        uintmax_t result =
-            internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL);
-
-        return (unsigned long long) result;
-}
-
-/**
- * Convert a string to a largest unsigned integer type.
- *
- * @param nptr Input string.
- * @param endptr Pointer to the final part of the string which
- *     was not used for conversion.
- * @param base Expected base of the string representation.
- * @return Result of the conversion.
- */
-uintmax_t posix_strtoumax(
-    const char *restrict nptr, char **restrict endptr, int base)
-{
-        uintmax_t result =
-            internal_strtol(nptr, endptr, base, 0, UINTMAX_MAX, NULL);
-
-        return result;
-}
+        return internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL);
+}
+
 
 /** @}
  */
+