1/*
2 * Copyright (c) 1998-2016 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29/*
30 * Copyright (c) 1995 NeXT Computer, Inc. All rights reserved.
31 *
32 * strol.c - The functions strtol() & strtoul() are exported as public API
33 * via the header file ~driverkit/generalFuncs.h
34 *
35 * HISTORY
36 * 25-Oct-1995 Dean Reece at NeXT
37 * Created based on BSD4.4's strtol.c & strtoul.c.
38 * Removed dependency on _ctype_ by static versions of isupper()...
39 * Added support for "0b101..." binary constants.
40 * Commented out references to errno.
41 */
42
43/*
44 * Copyright (c) 1990, 1993
45 * The Regents of the University of California. All rights reserved.
46 *
47 * Redistribution and use in source and binary forms, with or without
48 * modification, are permitted provided that the following conditions
49 * are met:
50 * 1. Redistributions of source code must retain the above copyright
51 * notice, this list of conditions and the following disclaimer.
52 * 2. Redistributions in binary form must reproduce the above copyright
53 * notice, this list of conditions and the following disclaimer in the
54 * documentation and/or other materials provided with the distribution.
55 * 3. All advertising materials mentioning features or use of this software
56 * must display the following acknowledgement:
57 * This product includes software developed by the University of
58 * California, Berkeley and its contributors.
59 * 4. Neither the name of the University nor the names of its contributors
60 * may be used to endorse or promote products derived from this software
61 * without specific prior written permission.
62 *
63 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
64 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
65 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
66 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
67 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
68 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
69 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
70 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
71 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
72 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
73 * SUCH DAMAGE.
74 */
75
76/*
77#include <string.h>
78#include <stdlib.h>
79#include <limits.h>
80*/
81#include <sys/types.h>
82#include <machine/limits.h>
83
84
85long strtol(const char *nptr, char **endptr, int base);
86unsigned long strtoul(const char *nptr, char **endptr, int base);
87quad_t strtoq(const char *nptr, char **endptr, int base);
88u_quad_t strtouq(const char *nptr, char **endptr, int base);
89char *strncat(char *s1, const char *s2, unsigned long n);
90
91
92typedef int BOOL;
93
94static inline BOOL
95isupper(char c)
96{
97 return (c >= 'A' && c <= 'Z');
98}
99
100static inline BOOL
101isalpha(char c)
102{
103 return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
104}
105
106
107static inline BOOL
108isspace(char c)
109{
110 return (c == ' ' || c == '\t' || c == '\n' || c == '\12');
111}
112
113static inline BOOL
114isdigit(char c)
115{
116 return (c >= '0' && c <= '9');
117}
118
119/*
120 * Convert a string to a long integer.
121 *
122 * Ignores `locale' stuff. Assumes that the upper and lower case
123 * alphabets and digits are each contiguous.
124 */
125long
126strtol(const char *nptr, char **endptr, int base)
127{
128 const char *s = nptr;
129 unsigned long acc;
130 char c;
131 unsigned long cutoff;
132 int neg = 0, any, cutlim;
133
134 /*
135 * Skip white space and pick up leading +/- sign if any.
136 * If base is 0, allow 0x for hex and 0 for octal, else
137 * assume decimal; if base is already 16, allow 0x.
138 */
139 do {
140 c = *s++;
141 } while (isspace(c));
142 if (c == '-') {
143 neg = 1;
144 c = *s++;
145 } else if (c == '+')
146 c = *s++;
147 if ((base == 0 || base == 16) &&
148 c == '0' && (*s == 'x' || *s == 'X')) {
149 c = s[1];
150 s += 2;
151 base = 16;
152 } else if ((base == 0 || base == 2) &&
153 c == '0' && (*s == 'b' || *s == 'B')) {
154 c = s[1];
155 s += 2;
156 base = 2;
157 }
158 if (base == 0)
159 base = c == '0' ? 8 : 10;
160
161 /*
162 * Compute the cutoff value between legal numbers and illegal
163 * numbers. That is the largest legal value, divided by the
164 * base. An input number that is greater than this value, if
165 * followed by a legal input character, is too big. One that
166 * is equal to this value may be valid or not; the limit
167 * between valid and invalid numbers is then based on the last
168 * digit. For instance, if the range for longs is
169 * [-2147483648..2147483647] and the input base is 10,
170 * cutoff will be set to 214748364 and cutlim to either
171 * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
172 * a value > 214748364, or equal but the next digit is > 7 (or 8),
173 * the number is too big, and we will return a range error.
174 *
175 * Set any if any `digits' consumed; make it negative to indicate
176 * overflow.
177 */
178 cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
179 cutlim = cutoff % (unsigned long)base;
180 cutoff /= (unsigned long)base;
181 for (acc = 0, any = 0;; c = *s++) {
182 if (isdigit(c))
183 c -= '0';
184 else if (isalpha(c))
185 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
186 else
187 break;
188 if (c >= base)
189 break;
190 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim) )
191 any = -1;
192 else {
193 any = 1;
194 acc *= base;
195 acc += c;
196 }
197 }
198 if (any < 0) {
199 acc = neg ? LONG_MIN : LONG_MAX;
200// errno = ERANGE;
201 } else if (neg)
202 acc = -acc;
203 if (endptr != 0)
204 {
205 if(any)
206 {
207 *endptr = __CAST_AWAY_QUALIFIER(s - 1, const, char *);
208 }
209 else
210 {
211 *endptr = __CAST_AWAY_QUALIFIER(nptr, const, char *);
212 }
213 }
214 return (acc);
215}
216
217unsigned long
218strtoul(const char *nptr, char **endptr, int base)
219{
220 const char *s = nptr;
221 unsigned long acc;
222 char c;
223 unsigned long cutoff;
224 int neg = 0, any, cutlim;
225
226 /*
227 * See strtol for comments as to the logic used.
228 */
229 do {
230 c = *s++;
231 } while (isspace(c));
232 if (c == '-') {
233 neg = 1;
234 c = *s++;
235 } else if (c == '+')
236 c = *s++;
237 if ((base == 0 || base == 16) &&
238 c == '0' && (*s == 'x' || *s == 'X')) {
239 c = s[1];
240 s += 2;
241 base = 16;
242 } else if ((base == 0 || base == 2) &&
243 c == '0' && (*s == 'b' || *s == 'B')) {
244 c = s[1];
245 s += 2;
246 base = 2;
247 }
248 if (base == 0)
249 base = c == '0' ? 8 : 10;
250 cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
251 cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
252 for (acc = 0, any = 0;; c = *s++) {
253 if (isdigit(c))
254 c -= '0';
255 else if (isalpha(c))
256 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
257 else
258 break;
259 if (c >= base)
260 break;
261 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim) )
262 any = -1;
263 else {
264 any = 1;
265 acc *= base;
266 acc += c;
267 }
268 }
269 if (any < 0) {
270 acc = ULONG_MAX;
271// errno = ERANGE;
272 } else if (neg)
273 acc = -acc;
274 if (endptr != 0)
275 {
276 if(any)
277 {
278 *endptr = __CAST_AWAY_QUALIFIER(s - 1, const, char *);
279 }
280 else
281 {
282 *endptr = __CAST_AWAY_QUALIFIER(nptr, const, char *);
283 }
284 }
285
286 return (acc);
287}
288
289/*
290 * Convert a string to a quad integer.
291 *
292 * Ignores `locale' stuff. Assumes that the upper and lower case
293 * alphabets and digits are each contiguous.
294 */
295quad_t
296strtoq(const char *nptr, char **endptr, int base)
297{
298 const char *s;
299 u_quad_t acc;
300 char c;
301 u_quad_t qbase, cutoff;
302 int neg, any, cutlim;
303
304 /*
305 * Skip white space and pick up leading +/- sign if any.
306 * If base is 0, allow 0x for hex and 0 for octal, else
307 * assume decimal; if base is already 16, allow 0x.
308 */
309 s = nptr;
310 do {
311 c = *s++;
312 } while (isspace(c));
313 if (c == '-') {
314 neg = 1;
315 c = *s++;
316 } else {
317 neg = 0;
318 if (c == '+')
319 c = *s++;
320 }
321 if ((base == 0 || base == 16) &&
322 c == '0' && (*s == 'x' || *s == 'X')) {
323 c = s[1];
324 s += 2;
325 base = 16;
326 }
327 if (base == 0)
328 base = c == '0' ? 8 : 10;
329
330 /*
331 * Compute the cutoff value between legal numbers and illegal
332 * numbers. That is the largest legal value, divided by the
333 * base. An input number that is greater than this value, if
334 * followed by a legal input character, is too big. One that
335 * is equal to this value may be valid or not; the limit
336 * between valid and invalid numbers is then based on the last
337 * digit. For instance, if the range for quads is
338 * [-9223372036854775808..9223372036854775807] and the input base
339 * is 10, cutoff will be set to 922337203685477580 and cutlim to
340 * either 7 (neg==0) or 8 (neg==1), meaning that if we have
341 * accumulated a value > 922337203685477580, or equal but the
342 * next digit is > 7 (or 8), the number is too big, and we will
343 * return a range error.
344 *
345 * Set any if any `digits' consumed; make it negative to indicate
346 * overflow.
347 */
348 qbase = (unsigned)base;
349 cutoff = neg ? -(u_quad_t)QUAD_MIN : QUAD_MAX;
350 cutlim = cutoff % qbase;
351 cutoff /= qbase;
352 for (acc = 0, any = 0;; c = *s++) {
353 if (isdigit(c))
354 c -= '0';
355 else if (isalpha(c))
356 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
357 else
358 break;
359 if (c >= base)
360 break;
361 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
362 any = -1;
363 else {
364 any = 1;
365 acc *= qbase;
366 acc += c;
367 }
368 }
369 if (any < 0) {
370 acc = neg ? QUAD_MIN : QUAD_MAX;
371// errno = ERANGE;
372 } else if (neg)
373 acc = -acc;
374 if (endptr != 0)
375 {
376 if(any)
377 {
378 *endptr = __CAST_AWAY_QUALIFIER(s - 1, const, char *);
379 }
380 else
381 {
382 *endptr = __CAST_AWAY_QUALIFIER(nptr, const, char *);
383 }
384 }
385
386 return (acc);
387}
388
389
390/*
391 * Convert a string to an unsigned quad integer.
392 *
393 * Ignores `locale' stuff. Assumes that the upper and lower case
394 * alphabets and digits are each contiguous.
395 */
396u_quad_t
397strtouq(const char *nptr,
398 char **endptr,
399 int base)
400{
401 const char *s = nptr;
402 u_quad_t acc;
403 char c;
404 u_quad_t qbase, cutoff;
405 int neg, any, cutlim;
406
407 /*
408 * See strtoq for comments as to the logic used.
409 */
410 s = nptr;
411 do {
412 c = *s++;
413 } while (isspace(c));
414 if (c == '-') {
415 neg = 1;
416 c = *s++;
417 } else {
418 neg = 0;
419 if (c == '+')
420 c = *s++;
421 }
422 if ((base == 0 || base == 16) &&
423 c == '0' && (*s == 'x' || *s == 'X')) {
424 c = s[1];
425 s += 2;
426 base = 16;
427 }
428 if (base == 0)
429 base = c == '0' ? 8 : 10;
430 qbase = (unsigned)base;
431 cutoff = (u_quad_t)UQUAD_MAX / qbase;
432 cutlim = (u_quad_t)UQUAD_MAX % qbase;
433 for (acc = 0, any = 0;; c = *s++) {
434 if (isdigit(c))
435 c -= '0';
436 else if (isalpha(c))
437 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
438 else
439 break;
440 if (c >= base)
441 break;
442 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
443 any = -1;
444 else {
445 any = 1;
446 acc *= qbase;
447 acc += c;
448 }
449 }
450 if (any < 0) {
451 acc = UQUAD_MAX;
452// errno = ERANGE;
453 } else if (neg)
454 acc = -acc;
455 if (endptr != 0)
456 {
457 if(any)
458 {
459 *endptr = __CAST_AWAY_QUALIFIER(s - 1, const, char *);
460 }
461 else
462 {
463 *endptr = __CAST_AWAY_QUALIFIER(nptr, const, char *);
464 }
465 }
466
467 return (acc);
468}
469
470
471/*
472 *
473 */
474
475char *
476strncat(char *s1, const char *s2, unsigned long n)
477{
478 if (n != 0) {
479 char *d = s1;
480 const char *s = s2;
481
482 while (*d != 0)
483 d++;
484 do {
485 if ((*d = *s++) == '\0')
486 break;
487 d++;
488 } while (--n != 0);
489 *d = '\0';
490 }
491 return (s1);
492}
493