Mercurial > hg > CbC > CbC_gcc
annotate libiberty/strtol.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | f6334be47118 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /*- |
| 2 * Copyright (c) 1990 The Regents of the University of California. | |
| 3 * All rights reserved. | |
| 4 * | |
| 5 * Redistribution and use in source and binary forms, with or without | |
| 6 * modification, are permitted provided that the following conditions | |
| 7 * are met: | |
| 8 * 1. Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * 2. Redistributions in binary form must reproduce the above copyright | |
| 11 * notice, this list of conditions and the following disclaimer in the | |
| 12 * documentation and/or other materials provided with the distribution. | |
| 13 * 3. [rescinded 22 July 1999] | |
| 14 * 4. Neither the name of the University nor the names of its contributors | |
| 15 * may be used to endorse or promote products derived from this software | |
| 16 * without specific prior written permission. | |
| 17 * | |
| 18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
| 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
| 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
| 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
| 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
| 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
| 28 * SUCH DAMAGE. | |
| 29 */ | |
| 30 | |
| 31 /* | |
| 32 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
33 @deftypefn Supplemental {long int} strtol (const char *@var{string}, @ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
34 char **@var{endptr}, int @var{base}) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
35 @deftypefnx Supplemental {unsigned long int} strtoul (const char *@var{string}, @ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
36 char **@var{endptr}, int @var{base}) |
| 0 | 37 |
| 38 The @code{strtol} function converts the string in @var{string} to a | |
| 39 long integer value according to the given @var{base}, which must be | |
| 40 between 2 and 36 inclusive, or be the special value 0. If @var{base} | |
| 41 is 0, @code{strtol} will look for the prefixes @code{0} and @code{0x} | |
| 42 to indicate bases 8 and 16, respectively, else default to base 10. | |
| 43 When the base is 16 (either explicitly or implicitly), a prefix of | |
| 44 @code{0x} is allowed. The handling of @var{endptr} is as that of | |
| 45 @code{strtod} above. The @code{strtoul} function is the same, except | |
| 46 that the converted value is unsigned. | |
| 47 | |
| 48 @end deftypefn | |
| 49 | |
| 50 */ | |
| 51 | |
| 52 #ifdef HAVE_CONFIG_H | |
| 53 #include "config.h" | |
| 54 #endif | |
| 55 #ifdef HAVE_LIMITS_H | |
| 56 #include <limits.h> | |
| 57 #endif | |
| 58 #ifdef HAVE_SYS_PARAM_H | |
| 59 #include <sys/param.h> | |
| 60 #endif | |
| 61 #include <errno.h> | |
| 62 #ifdef NEED_DECLARATION_ERRNO | |
| 63 extern int errno; | |
| 64 #endif | |
| 65 #include "safe-ctype.h" | |
| 66 | |
| 67 /* FIXME: It'd be nice to configure around these, but the include files are too | |
| 68 painful. These macros should at least be more portable than hardwired hex | |
| 69 constants. */ | |
| 70 | |
| 71 #ifndef ULONG_MAX | |
| 72 #define ULONG_MAX ((unsigned long)(~0L)) /* 0xFFFFFFFF */ | |
| 73 #endif | |
| 74 | |
| 75 #ifndef LONG_MAX | |
| 76 #define LONG_MAX ((long)(ULONG_MAX >> 1)) /* 0x7FFFFFFF */ | |
| 77 #endif | |
| 78 | |
| 79 #ifndef LONG_MIN | |
| 80 #define LONG_MIN ((long)(~LONG_MAX)) /* 0x80000000 */ | |
| 81 #endif | |
| 82 | |
| 83 /* | |
| 84 * Convert a string to a long integer. | |
| 85 * | |
| 86 * Ignores `locale' stuff. Assumes that the upper and lower case | |
| 87 * alphabets and digits are each contiguous. | |
| 88 */ | |
| 89 long | |
| 90 strtol(const char *nptr, char **endptr, register int base) | |
| 91 { | |
| 92 register const char *s = nptr; | |
| 93 register unsigned long acc; | |
| 94 register int c; | |
| 95 register unsigned long cutoff; | |
| 96 register int neg = 0, any, cutlim; | |
| 97 | |
| 98 /* | |
| 99 * Skip white space and pick up leading +/- sign if any. | |
| 100 * If base is 0, allow 0x for hex and 0 for octal, else | |
| 101 * assume decimal; if base is already 16, allow 0x. | |
| 102 */ | |
| 103 do { | |
| 104 c = *s++; | |
| 105 } while (ISSPACE(c)); | |
| 106 if (c == '-') { | |
| 107 neg = 1; | |
| 108 c = *s++; | |
| 109 } else if (c == '+') | |
| 110 c = *s++; | |
| 111 if ((base == 0 || base == 16) && | |
| 112 c == '0' && (*s == 'x' || *s == 'X')) { | |
| 113 c = s[1]; | |
| 114 s += 2; | |
| 115 base = 16; | |
| 116 } | |
| 117 if (base == 0) | |
| 118 base = c == '0' ? 8 : 10; | |
| 119 | |
| 120 /* | |
| 121 * Compute the cutoff value between legal numbers and illegal | |
| 122 * numbers. That is the largest legal value, divided by the | |
| 123 * base. An input number that is greater than this value, if | |
| 124 * followed by a legal input character, is too big. One that | |
| 125 * is equal to this value may be valid or not; the limit | |
| 126 * between valid and invalid numbers is then based on the last | |
| 127 * digit. For instance, if the range for longs is | |
| 128 * [-2147483648..2147483647] and the input base is 10, | |
| 129 * cutoff will be set to 214748364 and cutlim to either | |
| 130 * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated | |
| 131 * a value > 214748364, or equal but the next digit is > 7 (or 8), | |
| 132 * the number is too big, and we will return a range error. | |
| 133 * | |
| 134 * Set any if any `digits' consumed; make it negative to indicate | |
| 135 * overflow. | |
| 136 */ | |
| 137 cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX; | |
| 138 cutlim = cutoff % (unsigned long)base; | |
| 139 cutoff /= (unsigned long)base; | |
| 140 for (acc = 0, any = 0;; c = *s++) { | |
| 141 if (ISDIGIT(c)) | |
| 142 c -= '0'; | |
| 143 else if (ISALPHA(c)) | |
| 144 c -= ISUPPER(c) ? 'A' - 10 : 'a' - 10; | |
| 145 else | |
| 146 break; | |
| 147 if (c >= base) | |
| 148 break; | |
| 149 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) | |
| 150 any = -1; | |
| 151 else { | |
| 152 any = 1; | |
| 153 acc *= base; | |
| 154 acc += c; | |
| 155 } | |
| 156 } | |
| 157 if (any < 0) { | |
| 158 acc = neg ? LONG_MIN : LONG_MAX; | |
| 159 errno = ERANGE; | |
| 160 } else if (neg) | |
| 161 acc = -acc; | |
| 162 if (endptr != 0) | |
| 163 *endptr = (char *) (any ? s - 1 : nptr); | |
| 164 return (acc); | |
| 165 } |