1235537Sgber/*- 2235537Sgber * Copyright (c) 2014 The Regents of the University of California. 3235537Sgber * All rights reserved. 4235537Sgber * 5235537Sgber * Redistribution and use in source and binary forms, with or without 6235537Sgber * modification, are permitted provided that the following conditions 7235537Sgber * are met: 8235537Sgber * 1. Redistributions of source code must retain the above copyright 9235537Sgber * notice, this list of conditions and the following disclaimer. 10235537Sgber * 2. Redistributions in binary form must reproduce the above copyright 11235537Sgber * notice, this list of conditions and the following disclaimer in the 12235537Sgber * documentation and/or other materials provided with the distribution. 13235537Sgber * 3. [rescinded 22 July 1999] 14235537Sgber * 4. Neither the name of the University nor the names of its contributors 15235537Sgber * may be used to endorse or promote products derived from this software 16235537Sgber * without specific prior written permission. 17235537Sgber * 18235537Sgber * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 19235537Sgber * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20235537Sgber * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21235537Sgber * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22235537Sgber * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23235537Sgber * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24235537Sgber * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25235537Sgber * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26235537Sgber * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27235537Sgber * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28235537Sgber * SUCH DAMAGE. 29235537Sgber */ 30235537Sgber 31235537Sgber/* 32235537Sgber 33235537Sgber@deftypefn Supplemental {long long int} strtoll (const char *@var{string}, @ 34235537Sgber char **@var{endptr}, int @var{base}) 35235537Sgber@deftypefnx Supplemental {unsigned long long int} strtoul (@ 36235537Sgber const char *@var{string}, char **@var{endptr}, int @var{base}) 37235537Sgber 38235537SgberThe @code{strtoll} function converts the string in @var{string} to a 39235537Sgberlong long integer value according to the given @var{base}, which must be 40235537Sgberbetween 2 and 36 inclusive, or be the special value 0. If @var{base} 41235537Sgberis 0, @code{strtoll} will look for the prefixes @code{0} and @code{0x} 42235537Sgberto indicate bases 8 and 16, respectively, else default to base 10. 43235537SgberWhen the base is 16 (either explicitly or implicitly), a prefix of 44235537Sgber@code{0x} is allowed. The handling of @var{endptr} is as that of 45235537Sgber@code{strtod} above. The @code{strtoull} function is the same, except 46235537Sgberthat the converted value is unsigned. 47235537Sgber 48235537Sgber@end deftypefn 49235537Sgber 50235537Sgber*/ 51235537Sgber 52235537Sgber#ifdef HAVE_CONFIG_H 53235537Sgber#include "config.h" 54235537Sgber#endif 55235537Sgber#ifdef HAVE_LIMITS_H 56235537Sgber#include <limits.h> 57235537Sgber#endif 58235537Sgber#ifdef HAVE_SYS_PARAM_H 59235537Sgber#include <sys/param.h> 60235537Sgber#endif 61235537Sgber#include <errno.h> 62235537Sgber#ifdef NEED_DECLARATION_ERRNO 63235537Sgberextern int errno; 64235537Sgber#endif 65235537Sgber#include "safe-ctype.h" 66235537Sgber 67235537Sgber#ifdef HAVE_LONG_LONG 68235537Sgber 69235537Sgber__extension__ 70235537Sgbertypedef unsigned long long ullong_type; 71235537Sgber 72235537Sgber__extension__ 73235537Sgbertypedef long long llong_type; 74235537Sgber 75235537Sgber/* FIXME: It'd be nice to configure around these, but the include files are too 76235537Sgber painful. These macros should at least be more portable than hardwired hex 77235537Sgber constants. */ 78235537Sgber 79235537Sgber#ifndef ULLONG_MAX 80235537Sgber#define ULLONG_MAX (~(ullong_type)0) /* 0xFFFFFFFFFFFFFFFF */ 81235537Sgber#endif 82235537Sgber 83235537Sgber#ifndef LLONG_MAX 84235537Sgber#define LLONG_MAX ((llong_type)(ULLONG_MAX >> 1)) /* 0x7FFFFFFFFFFFFFFF */ 85235537Sgber#endif 86235537Sgber 87235537Sgber#ifndef LLONG_MIN 88235537Sgber#define LLONG_MIN (~LLONG_MAX) /* 0x8000000000000000 */ 89235537Sgber#endif 90235537Sgber 91235537Sgber/* 92235537Sgber * Convert a string to a long long integer. 93235537Sgber * 94235537Sgber * Ignores `locale' stuff. Assumes that the upper and lower case 95235537Sgber * alphabets and digits are each contiguous. 96235537Sgber */ 97235537Sgberllong_type 98235537Sgberstrtoll(const char *nptr, char **endptr, register int base) 99235537Sgber{ 100235537Sgber register const char *s = nptr; 101235537Sgber register ullong_type acc; 102235537Sgber register int c; 103235537Sgber register ullong_type cutoff; 104235537Sgber register int neg = 0, any, cutlim; 105235537Sgber 106235537Sgber /* 107235537Sgber * Skip white space and pick up leading +/- sign if any. 108235537Sgber * If base is 0, allow 0x for hex and 0 for octal, else 109235537Sgber * assume decimal; if base is already 16, allow 0x. 110235537Sgber */ 111235537Sgber do { 112235537Sgber c = *s++; 113235537Sgber } while (ISSPACE(c)); 114235537Sgber if (c == '-') { 115235537Sgber neg = 1; 116235537Sgber c = *s++; 117235537Sgber } else if (c == '+') 118235537Sgber c = *s++; 119235537Sgber if ((base == 0 || base == 16) && 120235537Sgber c == '0' && (*s == 'x' || *s == 'X')) { 121235537Sgber c = s[1]; 122235537Sgber s += 2; 123235537Sgber base = 16; 124235537Sgber } 125235537Sgber if (base == 0) 126235537Sgber base = c == '0' ? 8 : 10; 127235537Sgber 128235537Sgber /* 129235537Sgber * Compute the cutoff value between legal numbers and illegal 130235537Sgber * numbers. That is the largest legal value, divided by the 131235537Sgber * base. An input number that is greater than this value, if 132235537Sgber * followed by a legal input character, is too big. One that 133235537Sgber * is equal to this value may be valid or not; the limit 134235537Sgber * between valid and invalid numbers is then based on the last 135235537Sgber * digit. For instance, if the range for longs is 136235537Sgber * [-2147483648..2147483647] and the input base is 10, 137235537Sgber * cutoff will be set to 214748364 and cutlim to either 138235537Sgber * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated 139235537Sgber * a value > 214748364, or equal but the next digit is > 7 (or 8), 140235537Sgber * the number is too big, and we will return a range error. 141 * 142 * Set any if any `digits' consumed; make it negative to indicate 143 * overflow. 144 */ 145 cutoff = neg ? -(ullong_type)LLONG_MIN : LLONG_MAX; 146 cutlim = cutoff % (ullong_type)base; 147 cutoff /= (ullong_type)base; 148 for (acc = 0, any = 0;; c = *s++) { 149 if (ISDIGIT(c)) 150 c -= '0'; 151 else if (ISALPHA(c)) 152 c -= ISUPPER(c) ? 'A' - 10 : 'a' - 10; 153 else 154 break; 155 if (c >= base) 156 break; 157 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) 158 any = -1; 159 else { 160 any = 1; 161 acc *= base; 162 acc += c; 163 } 164 } 165 if (any < 0) { 166 acc = neg ? LLONG_MIN : LLONG_MAX; 167 errno = ERANGE; 168 } else if (neg) 169 acc = -acc; 170 if (endptr != 0) 171 *endptr = (char *) (any ? s - 1 : nptr); 172 return (acc); 173} 174 175#endif /* ifdef HAVE_LONG_LONG */ 176