1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1985-2011 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Eclipse Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.eclipse.org/org/documents/epl-v10.html * 11 * (with md5 checksum b35adb5213ca9657e911e9befb180842) * 12 * * 13 * Information and Software Systems Research * 14 * AT&T Research * 15 * Florham Park NJ * 16 * * 17 * Glenn Fowler <gsf@research.att.com> * 18 * David Korn <dgk@research.att.com> * 19 * Phong Vo <kpv@research.att.com> * 20 * * 21 ***********************************************************************/ 22 /* 23 * AT&T Research 24 * Glenn Fowler 25 * Phong Vo 26 * 27 * common header and implementation for 28 * 29 * strtol strtoul strton 30 * strtoll strtoull strtonll 31 * strntol strntoul strnton 32 * strntoll strntoull strntonll 33 * 34 * define these macros to instantiate an implementation: 35 * 36 * S2I_function the function name 37 * S2I_number the signed number type 38 * S2I_unumber the unsigned number type 39 * S2I_unsigned 1 for unsigned, 0 for signed 40 * S2I_qualifier 1 for optional qualifier suffix, 0 otherwise 41 * S2I_multiplier 1 for optional multiplier suffix, 0 otherwise 42 * S2I_size the second argument is the input string size 43 * 44 * convert string to number 45 * errno=ERANGE on overflow (LONG_MAX) or underflow (LONG_MIN) 46 * if non-null e will point to first unrecognized char in s 47 * if basep!=0 it points to the default base on input and 48 * will point to the explicit base on return 49 * a default base of 0 will determine the base from the input 50 * a default base of 1 will determine the base from the input using bb#* 51 * a base prefix in the string overrides *b 52 * *b will not be set if the string has no base prefix 53 * if m>1 and no multipler was specified then the result is multiplied by m 54 * if m<0 then multipliers are not consumed 55 * if a base arg or prefix is specified then multiplier is not consumed 56 * 57 * integer numbers are of the form: 58 * 59 * [sign][base][number[qualifier]][multiplier] 60 * 61 * base: nnn# base nnn 62 * 0[xX] hex 63 * 0 octal 64 * [1-9] decimal 65 * 66 * number: [0-9a-zA-Z]* 67 * 68 * qualifier: [lL] 69 * [uU] 70 * [uU][lL] 71 * [lL][uU] 72 * [lL][lL][uU] 73 * [uU][lL][lL] 74 * 75 * multiplier: . pseudo-float if m>1 76 * [bB] block (512) 77 * [cC] char (1) 78 * [gG] giga (1000*1000*1000) 79 * [gG]i gibi (1024*1024*1024) 80 * [kK] kilo (1000) 81 * [kK]i kibi (1024) 82 * [mM] mega (1000*1000) 83 * [mM]i mibi (1024*1024) 84 */ 85 86 #include <ast.h> 87 #include <ctype.h> 88 89 #include "sfhdr.h" 90 91 #if !__STD_C && !defined(const) 92 #define const 93 #endif 94 95 #ifndef ERANGE 96 #define ERANGE EINVAL 97 #endif 98 99 #define QL 01 100 #define QU 02 101 102 #define S2I_umax (~((S2I_unumber)0)) 103 104 #if S2I_unsigned 105 #define S2I_type S2I_unumber 106 #define S2I_min 0 107 #define S2I_max S2I_umax 108 #else 109 #define S2I_type S2I_number 110 #define S2I_min (-S2I_max-1) 111 #define S2I_max (S2I_umax>>1) 112 #endif 113 114 #if S2I_size 115 #define S2I_valid(s) ((s)<(z)) 116 #else 117 #define S2I_valid(s) 1 118 #endif 119 120 #define ADDOVER(n,c,s) ((S2I_umax-(n))<((S2I_unumber)((c)+(s)))) 121 #define MPYOVER(n,c) (((S2I_unumber)(n))>(S2I_umax/(c))) 122 123 static const S2I_unumber mm[] = 124 { 125 0, 126 S2I_umax / 1, 127 S2I_umax / 2, 128 S2I_umax / 3, 129 S2I_umax / 4, 130 S2I_umax / 5, 131 S2I_umax / 6, 132 S2I_umax / 7, 133 S2I_umax / 8, 134 S2I_umax / 9, 135 S2I_umax / 10, 136 S2I_umax / 11, 137 S2I_umax / 12, 138 S2I_umax / 13, 139 S2I_umax / 14, 140 S2I_umax / 15, 141 S2I_umax / 16, 142 S2I_umax / 17, 143 S2I_umax / 18, 144 S2I_umax / 19, 145 S2I_umax / 20, 146 S2I_umax / 21, 147 S2I_umax / 22, 148 S2I_umax / 23, 149 S2I_umax / 24, 150 S2I_umax / 25, 151 S2I_umax / 26, 152 S2I_umax / 27, 153 S2I_umax / 28, 154 S2I_umax / 29, 155 S2I_umax / 30, 156 S2I_umax / 31, 157 S2I_umax / 32, 158 S2I_umax / 33, 159 S2I_umax / 34, 160 S2I_umax / 35, 161 S2I_umax / 36, 162 S2I_umax / 37, 163 S2I_umax / 38, 164 S2I_umax / 39, 165 S2I_umax / 40, 166 S2I_umax / 41, 167 S2I_umax / 42, 168 S2I_umax / 43, 169 S2I_umax / 44, 170 S2I_umax / 45, 171 S2I_umax / 46, 172 S2I_umax / 47, 173 S2I_umax / 48, 174 S2I_umax / 49, 175 S2I_umax / 50, 176 S2I_umax / 51, 177 S2I_umax / 52, 178 S2I_umax / 53, 179 S2I_umax / 54, 180 S2I_umax / 55, 181 S2I_umax / 56, 182 S2I_umax / 57, 183 S2I_umax / 58, 184 S2I_umax / 59, 185 S2I_umax / 60, 186 S2I_umax / 61, 187 S2I_umax / 62, 188 S2I_umax / 63, 189 S2I_umax / 64, 190 }; 191 192 #if defined(__EXPORT__) 193 #define extern __EXPORT__ 194 #endif 195 extern S2I_type 196 #undef extern 197 #if S2I_size 198 #if S2I_multiplier 199 #if __STD_C 200 S2I_function(const char* a, size_t size, char** e, char* basep, int m) 201 #else 202 S2I_function(a, size, e, basep, m) const char* a; size_t size; char** e; char* basep; int m; 203 #endif 204 #else 205 #if __STD_C 206 S2I_function(const char* a, size_t size, char** e, int base) 207 #else 208 S2I_function(a, size, e, base) const char* a; size_t size; char** e; int base; 209 #endif 210 #endif 211 #else 212 #if S2I_multiplier 213 #if __STD_C 214 S2I_function(const char* a, char** e, char* basep, int m) 215 #else 216 S2I_function(a, e, basep, m) const char* a; char** e; char* basep; int m; 217 #endif 218 #else 219 #if __STD_C 220 S2I_function(const char* a, char** e, int base) 221 #else 222 S2I_function(a, e, base) const char* a; char** e; int base; 223 #endif 224 #endif 225 #endif 226 { 227 register unsigned char* s = (unsigned char*)a; 228 #if S2I_size 229 register unsigned char* z = s + size; 230 #endif 231 register S2I_unumber n; 232 register S2I_unumber x; 233 register int c; 234 register int shift; 235 register unsigned char* p; 236 register unsigned char* cv; 237 unsigned char* b; 238 unsigned char* k; 239 S2I_unumber v; 240 #if S2I_multiplier 241 register int base; 242 #endif 243 int negative; 244 int overflow = 0; 245 int decimal = 0; 246 int thousand = 0; 247 #if !S2I_unsigned 248 int qualifier = 0; 249 #endif 250 251 #if S2I_multiplier 252 base = basep ? *((unsigned char*)basep) : 0; 253 #else 254 if (base > 36 && base <= SF_RADIX) 255 { 256 static int conformance = -1; 257 258 if (conformance < 0) 259 conformance = !strcmp(astconf("CONFORMANCE", NiL, NiL), "standard"); 260 if (conformance) 261 base = 1; 262 } 263 #endif 264 if (base && (base < 2 || base > SF_RADIX)) 265 { 266 errno = EINVAL; 267 return 0; 268 } 269 while (S2I_valid(s) && isspace(*s)) 270 s++; 271 if ((negative = S2I_valid(s) && (*s == '-')) || S2I_valid(s) && *s == '+') 272 k = ++s; 273 else 274 k = 0; 275 p = s; 276 if (!base) 277 { 278 if (S2I_valid(p) && (c = *p++) >= '0' && c <= '9') 279 { 280 n = c - '0'; 281 if (S2I_valid(p) && (c = *p) >= '0' && c <= '9') 282 { 283 n = (n << 3) + (n << 1) + c - '0'; 284 p++; 285 } 286 if (S2I_valid(p) && *p == '#') 287 { 288 if (n >= 2 && n <= 64) 289 { 290 k = s = p + 1; 291 base = n; 292 } 293 } 294 else if (base) 295 base = 0; 296 else if (S2I_valid(s) && *s == '0' && S2I_valid(s + 1)) 297 { 298 if ((c = *(s + 1)) == 'x' || c == 'X') 299 { 300 k = s += 2; 301 base = 16; 302 } 303 else if (c >= '0' && c <= '7') 304 { 305 s++; 306 base = 8; 307 } 308 } 309 } 310 if (!base) 311 base = 10; 312 else if (base < 2 || base > SF_RADIX) 313 { 314 errno = EINVAL; 315 return 0; 316 } 317 #if S2I_multiplier 318 else 319 { 320 if (basep) 321 *basep = base; 322 m = -1; 323 } 324 #endif 325 } 326 #if S2I_multiplier 327 else 328 m = -1; 329 #endif 330 331 /* 332 * this part transcribed from sfvscanf() 333 */ 334 335 SFSETLOCALE(&decimal, &thousand); 336 x = mm[base]; 337 n = 0; 338 if (base == 10) 339 { 340 b = s; 341 p = 0; 342 for (;;) 343 { 344 if (S2I_valid(s) && (c = *s++) >= '0' && c <= '9') 345 { 346 if (n > x) 347 overflow = 1; 348 else 349 { 350 n = (n << 3) + (n << 1); 351 c -= '0'; 352 if (ADDOVER(n, c, negative)) 353 overflow = 1; 354 n += c; 355 } 356 } 357 else if (p && (s - p) != (3 + S2I_valid(s))) 358 { 359 s = p; 360 n = v; 361 c = 0; 362 break; 363 } 364 else if (!S2I_valid(s) || c != thousand) 365 break; 366 else if (!p && (s - b) > 4) 367 { 368 if (e) 369 *e = (char*)s - 1; 370 if (overflow) 371 { 372 errno = ERANGE; 373 #if S2I_unsigned 374 n = S2I_max; 375 #else 376 n = negative ? S2I_min : S2I_max; 377 #endif 378 } 379 return n; 380 } 381 else 382 { 383 p = s; 384 v = n; 385 } 386 } 387 } 388 else 389 { 390 SFCVINIT(); 391 cv = base <= 36 ? _Sfcv36 : _Sfcv64; 392 if ((base & ~(base - 1)) == base) 393 { 394 #if !S2I_unsigned 395 qualifier |= QU; 396 #endif 397 if (base < 8) 398 shift = base < 4 ? 1 : 2; 399 else if (base < 32) 400 shift = base < 16 ? 3 : 4; 401 else 402 shift = base < 64 ? 5 : 6; 403 while (S2I_valid(s) && (c = cv[*s++]) < base) 404 { 405 if (n > x) 406 overflow = 1; 407 else 408 { 409 n <<= shift; 410 if (ADDOVER(n, c, negative)) 411 overflow = 1; 412 n += c; 413 } 414 } 415 } 416 else 417 while (S2I_valid(s) && (c = cv[*s++]) < base) 418 { 419 if (n > x) 420 overflow = 1; 421 else 422 { 423 n *= base; 424 if (ADDOVER(n, c, negative)) 425 overflow = 1; 426 n += c; 427 } 428 } 429 c = *(s - 1); 430 } 431 432 #if S2I_qualifier 433 434 /* 435 * optional qualifier suffix 436 */ 437 438 if (S2I_valid(s) && s > (unsigned char*)(a + 1)) 439 { 440 base = 0; 441 for (;;) 442 { 443 if (!(base & QL) && (c == 'l' || c == 'L')) 444 { 445 base |= QL; 446 if (!S2I_valid(s)) 447 break; 448 c = *s++; 449 if (c == 'l' || c == 'L') 450 { 451 if (!S2I_valid(s)) 452 break; 453 c = *s++; 454 } 455 } 456 else if (!(base & QU) && (c == 'u' || c == 'U')) 457 { 458 base |= QU; 459 #if !S2I_unsigned 460 qualifier |= QU; 461 #endif 462 if (!S2I_valid(s)) 463 break; 464 c = *s++; 465 } 466 else 467 break; 468 } 469 } 470 #endif 471 if (S2I_valid(s)) 472 { 473 #if S2I_multiplier 474 /* 475 * optional multiplier suffix 476 */ 477 478 if (m < 0 || s == (unsigned char*)(a + 1)) 479 s--; 480 else 481 { 482 x = m != 1; 483 switch (c) 484 { 485 case 'b': 486 case 'B': 487 shift = 9; 488 x = 0; 489 break; 490 case 'k': 491 case 'K': 492 shift = 10; 493 break; 494 case 'm': 495 case 'M': 496 shift = 20; 497 break; 498 case 'g': 499 case 'G': 500 shift = 30; 501 break; 502 case 't': 503 case 'T': 504 shift = 40; 505 break; 506 case 'p': 507 case 'P': 508 shift = 50; 509 break; 510 case 'e': 511 case 'E': 512 shift = 60; 513 break; 514 default: 515 if (m <= 1) 516 v = 0; 517 else if (c == decimal && S2I_valid(s)) 518 { 519 if (MPYOVER(n, m)) 520 overflow = 1; 521 n *= m; 522 v = 0; 523 while (S2I_valid(s) && (c = *s++) >= '0' && c <= '9') 524 v += (m /= 10) * (c - '0'); 525 if (ADDOVER(n, v, negative)) 526 overflow = 1; 527 n += v; 528 v = 0; 529 } 530 else 531 v = m; 532 s--; 533 shift = 0; 534 break; 535 } 536 if (shift) 537 { 538 if (S2I_valid(s)) 539 switch (*s) 540 { 541 case 'i': 542 case 'I': 543 s++; 544 x = 0; 545 break; 546 } 547 if (S2I_valid(s)) 548 switch (*s) 549 { 550 case 'b': 551 case 'B': 552 s++; 553 break; 554 } 555 if (x) 556 { 557 v = 1; 558 for (shift /= 10; shift; shift--) 559 { 560 if (v >= (S2I_max/1000)) 561 { 562 v = 0; 563 overflow = 1; 564 } 565 v *= 1000; 566 } 567 } 568 else 569 #if S2I_unsigned 570 if (shift >= (sizeof(S2I_type) * CHAR_BIT)) 571 #else 572 if (shift >= (sizeof(S2I_type) * CHAR_BIT - 1)) 573 #endif 574 { 575 v = 0; 576 overflow = 1; 577 } 578 else 579 v = ((S2I_unumber)1) << shift; 580 } 581 if (v) 582 { 583 if (MPYOVER(n, v)) 584 overflow = 1; 585 n *= v; 586 } 587 } 588 #else 589 s--; 590 #endif 591 } 592 if (s == k) 593 { 594 s--; 595 #if S2I_multiplier 596 if (basep) 597 *basep = 10; 598 #endif 599 } 600 #if !S2I_unsigned 601 else if (!(qualifier & QU)) 602 { 603 if (negative) 604 { 605 if (!n) 606 { 607 b = k; 608 do 609 { 610 if (b >= s) 611 { 612 negative = 0; 613 break; 614 } 615 } while (*b++ == '0'); 616 } 617 if (negative && (n - 1) > S2I_max) 618 overflow = 1; 619 } 620 else if (n > S2I_max) 621 overflow = 1; 622 } 623 #endif 624 if (e) 625 *e = (char*)s; 626 if (overflow) 627 { 628 #if !S2I_unsigned 629 if (negative) 630 { 631 if (x << 1) 632 errno = ERANGE; 633 return (S2I_type)S2I_min; 634 } 635 #endif 636 errno = ERANGE; 637 return (S2I_type)S2I_max; 638 } 639 return negative ? -n : n; 640 } 641