iokit/Kernel/IOStringFuncs.c

   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         char *os1;
 479         int i = n;
 480
 481         os1 = s1;
 482         while (*s1++)
 483                 ;
 484         --s1;
 485         while ((*s1++ = *s2++))
 486                 if (--i < 0) {
 487                         *--s1 = '\0';
 488                         break;
 489                 }
 490         return(os1);
 491 }