Return to strtol.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / gen

Annotation of coherent/b/lib/libc/gen/strtol.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * C general utilities library.
        !             3:  * strtol(), strtoul()
        !             4:  * ANSI 4.10.1.5, 4.10.1.6.
        !             5:  * Convert ASCII to long or unsigned long (the System V way).
        !             6:  * atol() was so simple before System V/ANSI got hold of it...
        !             7:  */
        !             8: 
        !             9: #include <stdlib.h>
        !            10: #include <ctype.h>
        !            11: #include <errno.h>
        !            12: #include <limits.h>
        !            13: 
        !            14: extern unsigned long _strtoul();
        !            15: 
        !            16: long
        !            17: strtol(nptr, endptr, base) char *nptr; char **endptr; int base;
        !            18: {
        !            19:        return (long)_strtoul(nptr, endptr, base, 0);
        !            20: }
        !            21: 
        !            22: unsigned long
        !            23: strtoul(nptr, endptr, base) char *nptr; char **endptr; int base;
        !            24: {
        !            25:        return _strtoul(nptr, endptr, base, 1);
        !            26: }
        !            27: 
        !            28: static
        !            29: unsigned long
        !            30: _strtoul(nptr, endptr, base, uflag) char *nptr; char **endptr; int base, uflag;
        !            31: {
        !            32:        register char *cp;
        !            33:        register unsigned long val;
        !            34:        register int c, sign, overflow, pflag, dlimit, ulimit, llimit;
        !            35:        unsigned long quot, rem;
        !            36: 
        !            37:        cp = nptr;
        !            38:        val = pflag = overflow = sign = 0;
        !            39: 
        !            40:        /* Leading white space. */
        !            41:        while (isspace(c = *cp++))
        !            42:                ;
        !            43: 
        !            44:        /* Optional sign. */
        !            45:        switch(c) {
        !            46:        case '-':
        !            47:                sign = 1;
        !            48:                /* fall through... */
        !            49:        case '+':
        !            50:                c = *cp++;
        !            51:        }
        !            52: 
        !            53:        /* Determine implicit base. */
        !            54:        if (base == 0) {
        !            55:                if (c == '0')
        !            56:                        base = (*cp == 'x' || *cp == 'X') ? 16 : 8;
        !            57:                else if (isdigit(c))
        !            58:                        base = 10;
        !            59:                else {                  /* expected form not found */
        !            60:                        cp = nptr;
        !            61:                        goto done;
        !            62:                }
        !            63:        }
        !            64: 
        !            65:        /* Skip optional hex base "0x" or "0X". */
        !            66:        if (base == 16 && c == '0' && (*cp == 'x' || *cp == 'X')) {
        !            67:                ++pflag;
        !            68:                ++cp;
        !            69:                c = *cp++;
        !            70:        }
        !            71: 
        !            72:        /* Initialize legal character limits. */
        !            73:        dlimit = '0' + base;
        !            74:        ulimit = 'A' + base - 10;
        !            75:        llimit = 'a' + base - 10;
        !            76: 
        !            77:        /* The next character must be a legitimate digit; e.g. " +@" fails. */
        !            78:        /* Watch out for e.g. "0xy", which is "0" followed by "xy". */
        !            79:        if (!(   (isdigit(c) && c < dlimit)
        !            80:              || (isupper(c) && c < ulimit)
        !            81:              || (islower(c) && c < llimit))) {
        !            82:                cp = (pflag) ? cp - 2 : nptr;
        !            83:                goto done;
        !            84:        }
        !            85: 
        !            86:        /* Determine limits for overflow computation. */
        !            87:        /* This would use ldiv() if it worked for unsigned long. */
        !            88:        if (uflag) {
        !            89:                quot = ULONG_MAX / base;
        !            90:                rem = ULONG_MAX % base;
        !            91:        } else {
        !            92:                quot = LONG_MAX / base;
        !            93:                rem = LONG_MAX % base;
        !            94:        }
        !            95: 
        !            96:        /* Process digit string. */
        !            97:        for ( ; ; c = *cp++) {
        !            98:                if (isdigit(c) && c < dlimit)
        !            99:                        c -= '0';
        !           100:                else if (isupper(c) && c < ulimit)
        !           101:                        c -= 'A'-10;
        !           102:                else if (islower(c) && c < llimit)
        !           103:                        c -= 'a'-10;
        !           104:                else {
        !           105:                        --cp;
        !           106:                        break;
        !           107:                }
        !           108:                if (val < quot || (val == quot && c <= rem))
        !           109:                        val = val * base + c;
        !           110:                else
        !           111:                        ++overflow;
        !           112:        }
        !           113: 
        !           114: done:
        !           115:        /* Store end pointer and return approriate result. */
        !           116:        if (endptr != (char **)NULL)
        !           117:                *endptr = cp;
        !           118:        if (overflow) {
        !           119:                errno = ERANGE;
        !           120:                if (uflag)
        !           121:                        return ULONG_MAX;
        !           122:                return (unsigned long)(sign ? LONG_MIN : LONG_MAX);
        !           123:        }
        !           124:        return (sign) ? (unsigned long)(-(long)val) : val;
        !           125: }
        !           126: 
        !           127: /* end of strtol.c */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.