Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mkinitrd-magellan/busybox/libbb/bb_strtonum.c

    Contents of /trunk/mkinitrd-magellan/busybox/libbb/bb_strtonum.c

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 532 - (show annotations) (download)
    Sat Sep 1 22:45:15 2007 UTC (16 years, 9 months ago) by niro
    File MIME type: text/plain
    File size: 3904 byte(s) 
    -import if magellan mkinitrd; it is a fork of redhats mkinitrd-5.0.8 with all magellan patches and features; deprecates magellan-src/mkinitrd
    1 /* vi: set sw=4 ts=4: */
    2 /*
    3 * Utility routines.
    4 *
    5 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
    6 *
    7 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
    8 */
    9
    10 #include "libbb.h"
    11
    12 /* On exit: errno = 0 only if there was non-empty, '\0' terminated value
    13 * errno = EINVAL if value was not '\0' terminated, but othervise ok
    14 * Return value is still valid, caller should just check whether end[0]
    15 * is a valid terminating char for particular case. OTOH, if caller
    16 * requires '\0' terminated input, [s]he can just check errno == 0.
    17 * errno = ERANGE if value had alphanumeric terminating char ("1234abcg").
    18 * errno = ERANGE if value is out of range, missing, etc.
    19 * errno = ERANGE if value had minus sign for strtouXX (even "-0" is not ok )
    20 * return value is all-ones in this case.
    21 */
    22
    23 static unsigned long long ret_ERANGE(void)
    24 {
    25 errno = ERANGE; /* this ain't as small as it looks (on glibc) */
    26 return ULLONG_MAX;
    27 }
    28
    29 static unsigned long long handle_errors(unsigned long long v, char **endp, char *endptr)
    30 {
    31 if (endp) *endp = endptr;
    32
    33 /* Check for the weird "feature":
    34 * a "-" string is apparently a valid "number" for strto[u]l[l]!
    35 * It returns zero and errno is 0! :( */
    36 if (endptr[-1] == '-')
    37 return ret_ERANGE();
    38
    39 /* errno is already set to ERANGE by strtoXXX if value overflowed */
    40 if (endptr[0]) {
    41 /* "1234abcg" or out-of-range? */
    42 if (isalnum(endptr[0]) || errno)
    43 return ret_ERANGE();
    44 /* good number, just suspicious terminator */
    45 errno = EINVAL;
    46 }
    47 return v;
    48 }
    49
    50
    51 unsigned long long bb_strtoull(const char *arg, char **endp, int base)
    52 {
    53 unsigned long long v;
    54 char *endptr;
    55
    56 /* strtoul(" -4200000000") returns 94967296, errno 0 (!) */
    57 /* I don't think that this is right. Preventing this... */
    58 if (!isalnum(arg[0])) return ret_ERANGE();
    59
    60 /* not 100% correct for lib func, but convenient for the caller */
    61 errno = 0;
    62 v = strtoull(arg, &endptr, base);
    63 return handle_errors(v, endp, endptr);
    64 }
    65
    66 long long bb_strtoll(const char *arg, char **endp, int base)
    67 {
    68 unsigned long long v;
    69 char *endptr;
    70
    71 if (arg[0] != '-' && !isalnum(arg[0])) return ret_ERANGE();
    72 errno = 0;
    73 v = strtoll(arg, &endptr, base);
    74 return handle_errors(v, endp, endptr);
    75 }
    76
    77 #if ULONG_MAX != ULLONG_MAX
    78 unsigned long bb_strtoul(const char *arg, char **endp, int base)
    79 {
    80 unsigned long v;
    81 char *endptr;
    82
    83 if (!isalnum(arg[0])) return ret_ERANGE();
    84 errno = 0;
    85 v = strtoul(arg, &endptr, base);
    86 return handle_errors(v, endp, endptr);
    87 }
    88
    89 long bb_strtol(const char *arg, char **endp, int base)
    90 {
    91 long v;
    92 char *endptr;
    93
    94 if (arg[0] != '-' && !isalnum(arg[0])) return ret_ERANGE();
    95 errno = 0;
    96 v = strtol(arg, &endptr, base);
    97 return handle_errors(v, endp, endptr);
    98 }
    99 #endif
    100
    101 #if UINT_MAX != ULONG_MAX
    102 unsigned bb_strtou(const char *arg, char **endp, int base)
    103 {
    104 unsigned long v;
    105 char *endptr;
    106
    107 if (!isalnum(arg[0])) return ret_ERANGE();
    108 errno = 0;
    109 v = strtoul(arg, &endptr, base);
    110 if (v > UINT_MAX) return ret_ERANGE();
    111 return handle_errors(v, endp, endptr);
    112 }
    113
    114 int bb_strtoi(const char *arg, char **endp, int base)
    115 {
    116 long v;
    117 char *endptr;
    118
    119 if (arg[0] != '-' && !isalnum(arg[0])) return ret_ERANGE();
    120 errno = 0;
    121 v = strtol(arg, &endptr, base);
    122 if (v > INT_MAX) return ret_ERANGE();
    123 if (v < INT_MIN) return ret_ERANGE();
    124 return handle_errors(v, endp, endptr);
    125 }
    126 #endif
    127
    128 /* Floating point */
    129
    130 #if 0
    131
    132 #include <math.h> /* just for HUGE_VAL */
    133 #define NOT_DIGIT(a) (((unsigned char)(a-'0')) > 9)
    134 double bb_strtod(const char *arg, char **endp)
    135 {
    136 double v;
    137 char *endptr;
    138
    139 if (arg[0] != '-' && NOT_DIGIT(arg[0])) goto err;
    140 errno = 0;
    141 v = strtod(arg, &endptr);
    142 if (endp) *endp = endptr;
    143 if (endptr[0]) {
    144 /* "1234abcg" or out-of-range? */
    145 if (isalnum(endptr[0]) || errno) {
    146 err:
    147 errno = ERANGE;
    148 return HUGE_VAL;
    149 }
    150 /* good number, just suspicious terminator */
    151 errno = EINVAL;
    152 }
    153 return v;
    154 }
    155
    156 #endif