Changeset aa5acd47 in mainline

Timestamp:

2011-07-20T23:02:33Z (13 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

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

Children:

91aded7

Parents:

4cf8ca6

Message:

Modify strtol implementation to use intmax_t. Add strtoimax() and strtoumax().

Location:

uspace/lib/posix

Files:

• inttypes.h (modified) (1 diff)
• stdint.h (modified) (1 diff)
• stdlib/strtol.c (modified) (18 diffs)

uspace/lib/posix/inttypes.h

@@ -39 +39 @@
 #include "libc/inttypes.h"
 
+extern posix_intmax_t posix_strtoimax(const char *restrict nptr,
+    char **restrict endptr, int base);
+extern posix_uintmax_t posix_strtoumax(const char *restrict nptr,
+    char **restrict endptr, int base);
+
 #endif /* POSIX_INTTYPES_H_ */
 

uspace/lib/posix/stdint.h

@@ -88 +88 @@
 #define AOFF64_MIN  UINT64_MIN
 
+#undef INTMAX_MIN
+#undef INTMAX_MAX
+#define INTMAX_MIN INT64_MIN
+#define INTMAX_MAX INT64_MAX
+
+#undef UINTMAX_MIN
+#undef UINTMAX_MAX
+#define UINTMAX_MIN UINT64_MIN
+#define UINTMAX_MAX UINT64_MAX
+
 #include "libc/sys/types.h"
 

uspace/lib/posix/stdlib/strtol.c

@@ -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
 
 /**
@@ -63 +67 @@
  *
  * @param c Character representation of the digit.
- * @param base Base into which the digit belongs to.
  * @return Digit value represented by an integer.
  */
-static inline int get_digit_in_base(int c, int base)
+static inline int digit_value(int c)
 {
         if (c <= '9') {
@@ -76 +79 @@
 
 /**
- * Backend for all integer conversion functions. Can be configured by arguments
- * to convert both signed and unsigned integers of various sizes.
+ * 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.
- * @param base Expected base of the string representation.
+ *     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.
@@ -88 +97 @@
  *     bool variable into which shall be placed the negativity of the resulting
  *     converted value.
- * @return Result of the conversion.
- */
-static inline unsigned long long internal_strtol(
+ * @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)
 {
@@ -105 +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;
         
@@ -120 +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 '+':
@@ -131 +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;
@@ -160 +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) {
@@ -172 +199 @@
                         if (nptr[i] != '0') {
                                 errno = ERANGE;
-                                result = max_value;
+                                result = 0;
                         }
                         i++;
@@ -179 +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) {
@@ -224 +250 @@
 {
         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);
 }
 
@@ -239 +265 @@
 {
         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);
 }
 
@@ -254 +280 @@
 {
         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);
 }
 
@@ -272 +298 @@
 {
         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));
 }
 
@@ -291 +317 @@
 {
         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);
 }
 
@@ -309 +354 @@
     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);
 
@@ -316 +361 @@
 
 /**
- * Convert a string to a an unsigned long long integer.
+ * Convert a string to an unsigned long long integer.
  *
  * @param nptr Input string.
@@ -327 +372 @@
     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;
 }