Changeset eccd20e6 in mainline for uspace/lib/posix/stdlib/strtol.c

Timestamp:

2011-07-21T22:34:14Z (13 years ago)

Author:

Petr Koupy <petr.koupy@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

c6f4681, e478cebf

Parents:

df0956ee (diff), cfbb5d18 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge libposix changes.

File:

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

uspace/lib/posix/stdlib/strtol.c

@@ -30 +30 @@
  * @{
  */
-/** @file
+/** @file Backend for integer conversions.
  */
 
@@ -38 +38 @@
 #include "../stdlib.h"
 
-#include "../limits.h"
 #include "../ctype.h"
 #include "../errno.h"
-
-// TODO: documentation
-
+#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.
+ */
 static inline bool is_digit_in_base(int c, int base)
 {
@@ -54 +63 @@
 }
 
-static inline int get_digit_in_base(int c, int base)
+/**
+ * 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)
 {
         if (c <= '9') {
@@ -63 +78 @@
 }
 
-static inline unsigned long long internal_strtol(
+/**
+ * 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(
     const char *restrict nptr, char **restrict endptr, int base,
-    const long long min_value, const unsigned long long max_value,
+    const intmax_t min_value, const uintmax_t max_value,
     bool *restrict out_negative)
 {
@@ -78 +116 @@
         }
         
-        unsigned long long real_max_value = max_value;
+        /* The maximal absolute value that can be returned in this run.
+         * Depends on sign.
+         */
+        uintmax_t real_max_value = max_value;
         
         /* Current index in the input string. */
-        int i = 0;
+        size_t i = 0;
         bool negative = false;
         
@@ -93 +134 @@
         case '-':
                 negative = true;
-                real_max_value = -min_value;
+                
+                /* 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);
+                
                 /* fallthrough */
         case '+':
@@ -104 +154 @@
                 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;
@@ -133 +187 @@
          * of overflow.
          */
-        unsigned long long max_safe_value = (real_max_value - base + 1) / base;
-        
-        unsigned long long result = 0;
+        uintmax_t max_safe_value = (real_max_value - base + 1) / base;
+        
+        uintmax_t result = 0;
         
         if (real_max_value == 0) {
@@ -145 +199 @@
                         if (nptr[i] != '0') {
                                 errno = ERANGE;
-                                result = max_value;
+                                result = 0;
                         }
                         i++;
@@ -152 +206 @@
         
         while (is_digit_in_base(nptr[i], base)) {
-                int digit = get_digit_in_base(nptr[i], base);
+                int digit = digit_value(nptr[i]);
                 
                 if (result > max_safe_value) {
                         /* corner case, check for overflow */
                         
-                        unsigned long long
-                            boundary = (real_max_value - digit) / base;
+                        uintmax_t boundary = (real_max_value - digit) / base;
                         
                         if (result > boundary) {
                                 /* overflow */
                                 errno = ERANGE;
-                                result = max_value;
+                                result = real_max_value;
                                 break;
                         }
@@ -188 +241 @@
 }
 
+/**
+ * Convert a string to an integer.
+ *
+ * @param nptr Input string.
+ * @return Result of the conversion.
+ */
 int posix_atoi(const char *nptr)
 {
         bool neg = false;
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, NULL, 10, INT_MIN, INT_MAX, &neg);
 
-        return (int) (neg ? -result : result);
-}
-
+        return (neg ? ((int) -result) : (int) result);
+}
+
+/**
+ * Convert a string to a long integer.
+ *
+ * @param nptr Input string.
+ * @return Result of the conversion.
+ */
 long posix_atol(const char *nptr)
 {
         bool neg = false;
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, NULL, 10, LONG_MIN, LONG_MAX, &neg);
 
-        return (long) (neg ? -result : result);
-}
-
+        return (neg ? ((long) -result) : (long) result);
+}
+
+/**
+ * Convert a string to a long long integer.
+ *
+ * @param nptr Input string.
+ * @return Result of the conversion.
+ */
 long long posix_atoll(const char *nptr)
 {
         bool neg = false;
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, NULL, 10, LLONG_MIN, LLONG_MAX, &neg);
 
-        return (long long) (neg ? -result : result);
-}
-
+        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.
+ */
 long posix_strtol(const char *restrict nptr, char **restrict endptr, int base)
 {
         bool neg = false;
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, endptr, base, LONG_MIN, LONG_MAX, &neg);
 
-        return (long) (neg ? -result : result);
-}
-
+        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.
+ */
 long long posix_strtoll(
     const char *restrict nptr, char **restrict endptr, int base)
 {
         bool neg = false;
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &neg);
 
-        return (long long) (neg ? -result : result);
-}
-
+        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.
+ */
 unsigned long posix_strtoul(
     const char *restrict nptr, char **restrict endptr, int base)
 {
-        unsigned long long result =
+        uintmax_t result =
             internal_strtol(nptr, endptr, base, 0, ULONG_MAX, NULL);
 
@@ -243 +360 @@
 }
 
+/**
+ * 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)
 {
-        return internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL);
-}
-
+        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;
+}
 
 /** @}
  */
-