gen/libsa/strtol.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 /*-
  26  * Copyright (c) 1990 The Regents of the University of California.
  27  * All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  */
  57
  58 /* Modified by Curtis Galloway at NeXT June 1993,
  59  * for use in the standalone library.
  60  */
  61
  62 #if defined(LIBC_SCCS) && !defined(lint)
  63 static char sccsid[] = "@(#)strtol.c    5.4 (Berkeley) 2/23/91";
  64 #endif /* LIBC_SCCS and not lint */
  65
  66 #include <limits.h>
  67 #include <errno.h>
  68 //#include <stdlib.h>
  69 #import "libsa.h"
  70
  71 #import "ctype.h"
  72
  73
  74 /* Fudge here -- to save space, make strtol and strtoul do the same
  75  * conversion.  If you really need that extra range on strtoul, too bad.
  76  */
  77
  78 #define SIGNED          1
  79 #define UNSIGNED        0
  80
  81
  82 /*
  83  * Convert a string to a long integer.
  84  *
  85  * Ignores `locale' stuff.  Assumes that the upper and lower case
  86  * alphabets and digits are each contiguous.
  87  */
  88 static long
  89 actual_strtol(
  90     const char *nptr,
  91     char **endptr,
  92     register int base,
  93     int is_signed
  94 )
  95 {
  96         register const char *s = nptr;
  97         register unsigned long acc;
  98         register int c;
  99         register unsigned long cutoff;
 100         register int neg = 0, any, cutlim;
 101
 102         /*
 103          * Skip white space and pick up leading +/- sign if any.
 104          * If base is 0, allow 0x for hex and 0 for octal, else
 105          * assume decimal; if base is already 16, allow 0x.
 106          */
 107         do {
 108                 c = *s++;
 109         } while (isspace(c));
 110         if (is_signed && c == '-') {
 111                 neg = 1;
 112                 c = *s++;
 113         } else if (c == '+')
 114                 c = *s++;
 115         if ((base == 0 || base == 16) &&
 116             c == '0' && (*s == 'x' || *s == 'X')) {
 117                 c = s[1];
 118                 s += 2;
 119                 base = 16;
 120         }
 121         if (base == 0)
 122                 base = c == '0' ? 8 : 10;
 123
 124         /*
 125          * Compute the cutoff value between legal numbers and illegal
 126          * numbers.  That is the largest legal value, divided by the
 127          * base.  An input number that is greater than this value, if
 128          * followed by a legal input character, is too big.  One that
 129          * is equal to this value may be valid or not; the limit
 130          * between valid and invalid numbers is then based on the last
 131          * digit.  For instance, if the range for longs is
 132          * [-2147483648..2147483647] and the input base is 10,
 133          * cutoff will be set to 214748364 and cutlim to either
 134          * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
 135          * a value > 214748364, or equal but the next digit is > 7 (or 8),
 136          * the number is too big, and we will return a range error.
 137          *
 138          * Set any if any `digits' consumed; make it negative to indicate
 139          * overflow.
 140          */
 141         cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
 142         cutlim = cutoff % (unsigned long)base;
 143         cutoff /= (unsigned long)base;
 144         for (acc = 0, any = 0;; c = *s++) {
 145                 if (isdigit(c))
 146                         c -= '0';
 147                 else if (isalpha(c))
 148                         c -= isupper(c) ? 'A' - 10 : 'a' - 10;
 149                 else
 150                         break;
 151                 if (c >= base)
 152                         break;
 153                 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
 154                         any = -1;
 155                 else {
 156                         any = 1;
 157                         acc *= base;
 158                         acc += c;
 159                 }
 160         }
 161         if (any < 0) {
 162                 acc = neg ? LONG_MIN : LONG_MAX;
 163                 errno = ERANGE;
 164         } else if (neg)
 165                 acc = -acc;
 166         if (endptr != 0)
 167                 *endptr = any ? s - 1 : (char *)nptr;
 168         return (acc);
 169 }
 170
 171 long
 172 strtol(
 173     const char *nptr,
 174     char **endptr,
 175     register int base
 176 )
 177 {
 178     return actual_strtol(nptr, endptr, base, SIGNED);
 179 }
 180
 181 unsigned long
 182 strtoul(
 183     const char *nptr,
 184     char **endptr,
 185     register int base
 186 )
 187 {
 188     return actual_strtol(nptr, endptr, base, UNSIGNED);
 189 }
 190
 191 #if notdef
 192 /*
 193  * Convert a string to an unsigned long integer.
 194  *
 195  * Ignores `locale' stuff.  Assumes that the upper and lower case
 196  * alphabets and digits are each contiguous.
 197  */
 198 unsigned long
 199 strtoul(nptr, endptr, base)
 200         const char *nptr;
 201         char **endptr;
 202         register int base;
 203 {
 204         register const char *s = nptr;
 205         register unsigned long acc;
 206         register int c;
 207         register unsigned long cutoff;
 208         register int neg = 0, any, cutlim;
 209
 210         /*
 211          * See strtol for comments as to the logic used.
 212          */
 213         do {
 214                 c = *s++;
 215         } while (isspace(c));
 216         if (c == '-') {
 217                 neg = 1;
 218                 c = *s++;
 219         } else if (c == '+')
 220                 c = *s++;
 221         if ((base == 0 || base == 16) &&
 222             c == '0' && (*s == 'x' || *s == 'X')) {
 223                 c = s[1];
 224                 s += 2;
 225                 base = 16;
 226         }
 227         if (base == 0)
 228                 base = c == '0' ? 8 : 10;
 229         cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
 230         cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
 231         for (acc = 0, any = 0;; c = *s++) {
 232                 if (isdigit(c))
 233                         c -= '0';
 234                 else if (isalpha(c))
 235                         c -= isupper(c) ? 'A' - 10 : 'a' - 10;
 236                 else
 237                         break;
 238                 if (c >= base)
 239                         break;
 240                 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
 241                         any = -1;
 242                 else {
 243                         any = 1;
 244                         acc *= base;
 245                         acc += c;
 246                 }
 247         }
 248         if (any < 0) {
 249                 acc = ULONG_MAX;
 250                 errno = ERANGE;
 251         } else if (neg)
 252                 acc = -acc;
 253         if (endptr != 0)
 254                 *endptr = any ? s - 1 : (char *)nptr;
 255         return (acc);
 256 }
 257
 258 #endif notdef