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 | |
85 | long strtol(const char *nptr, char **endptr, int base); |
86 | unsigned long strtoul(const char *nptr, char **endptr, int base); |
87 | quad_t strtoq(const char *nptr, char **endptr, int base); |
88 | u_quad_t strtouq(const char *nptr, char **endptr, int base); |
89 | char *strncat(char *s1, const char *s2, unsigned long n); |
90 | |
91 | |
92 | typedef int BOOL; |
93 | |
94 | static inline BOOL |
95 | isupper(char c) |
96 | { |
97 | return (c >= 'A' && c <= 'Z'); |
98 | } |
99 | |
100 | static inline BOOL |
101 | isalpha(char c) |
102 | { |
103 | return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')); |
104 | } |
105 | |
106 | |
107 | static inline BOOL |
108 | isspace(char c) |
109 | { |
110 | return (c == ' ' || c == '\t' || c == '\n' || c == '\12'); |
111 | } |
112 | |
113 | static inline BOOL |
114 | isdigit(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 | */ |
125 | long |
126 | strtol(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 | |
217 | unsigned long |
218 | strtoul(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 | */ |
295 | quad_t |
296 | strtoq(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 | */ |
396 | u_quad_t |
397 | strtouq(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 | |
475 | char * |
476 | strncat(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 | |