1 /* 2 * Copyright (c) 1998 Todd C. Miller <Todd.Miller (at) courtesan.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 17 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 18 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 19 * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * $Id: compat.c,v 1.1.1.1 2008/08/24 05:33:08 gmcgarry Exp $ 28 29 * Copyright (c) 1997, 2002 The NetBSD Foundation, Inc. 30 * All rights reserved. 31 * 32 * This code is derived from software contributed to The NetBSD Foundation 33 * by Klaus Klein and Jason R. Thorpe. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. All advertising materials mentioning features or use of this software 44 * must display the following acknowledgement: 45 * This product includes software developed by the NetBSD 46 * Foundation, Inc. and its contributors. 47 * 4. Neither the name of The NetBSD Foundation nor the names of its 48 * contributors may be used to endorse or promote products derived 49 * from this software without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 52 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 53 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 54 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 55 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 56 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 57 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 58 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 59 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 60 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 61 * POSSIBILITY OF SUCH DAMAGE. 62 * 63 * $NetBSD: compat.c,v 1.1.1.1 2008/08/24 05:33:08 gmcgarry Exp $ 64 65 * Copyright (c) 1987, 1993 66 * The Regents of the University of California. All rights reserved. 67 * 68 * Redistribution and use in source and binary forms, with or without 69 * modification, are permitted provided that the following conditions 70 * are met: 71 * 1. Redistributions of source code must retain the above copyright 72 * notice, this list of conditions and the following disclaimer. 73 * 2. Redistributions in binary form must reproduce the above copyright 74 * notice, this list of conditions and the following disclaimer in the 75 * documentation and/or other materials provided with the distribution. 76 * 3. Neither the name of the University nor the names of its contributors 77 * may be used to endorse or promote products derived from this software 78 * without specific prior written permission. 79 * 80 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 81 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 82 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 83 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 84 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 85 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 86 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 87 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 88 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 89 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 90 * SUCH DAMAGE. 91 * 92 * $NetBSD: compat.c,v 1.1.1.1 2008/08/24 05:33:08 gmcgarry Exp $ 93 */ 94 #include <LibConfig.h> 95 #include <string.h> 96 #include <fcntl.h> 97 #include <sys/syslimits.h> 98 99 #ifndef HAVE_GETOPT 100 char *optarg; 101 int optind = 1; 102 int 103 getopt(int argc, char **argv, char *args) 104 { 105 size_t n; 106 size_t nlen = strlen(args); 107 char cmd; 108 char rv; 109 110 if (argv[optind] && *argv[optind] == '-') { 111 cmd = *(argv[optind] + 1); 112 113 for (n = 0; n < nlen; n++) { 114 if (args[n] == ':') 115 continue; 116 if (args[n] == cmd) { 117 rv = *(argv[optind] + 1); 118 if (args[n+1] == ':') { 119 if (*(argv[optind] + 2) != '\0') { 120 optarg = argv[optind] + 2; 121 optind += 1; 122 } else { 123 optarg = argv[optind + 1]; 124 optind += 2; 125 } 126 if (!optarg) 127 optarg=""; 128 return rv; 129 } else { 130 optarg = NULL; 131 optind += 1; 132 return rv; 133 } 134 } 135 } 136 } 137 return -1; 138 } 139 #endif 140 141 #define ISPATHSEPARATOR(x) ((x == '/') || (x == '\\')) 142 143 #ifdef HAVE_BASENAME 144 #ifndef PATH_MAX 145 #define PATH_MAX 5000 146 #endif 147 148 char * 149 basename(char *path) 150 { 151 static char singledot[] = "."; 152 static char result[PATH_MAX]; 153 char *p, *lastp; 154 size_t len; 155 156 /* 157 * If `path' is a null pointer or points to an empty string, 158 * return a pointer to the string ".". 159 */ 160 if ((path == NULL) || (*path == '\0')) 161 return (singledot); 162 163 /* Strip trailing slashes, if any. */ 164 lastp = path + strlen(path) - 1; 165 while (lastp != path && ISPATHSEPARATOR(*lastp)) 166 lastp--; 167 168 /* Now find the beginning of this (final) component. */ 169 p = lastp; 170 while (p != path && !ISPATHSEPARATOR(*(p - 1))) 171 p--; 172 173 /* ...and copy the result into the result buffer. */ 174 len = (lastp - p) + 1 /* last char */; 175 if (len > (PATH_MAX - 1)) 176 len = PATH_MAX - 1; 177 178 memcpy(result, p, len); 179 result[len] = '\0'; 180 181 return (result); 182 } 183 #endif 184 185 #if !defined(HAVE_MKSTEMP) && !defined(WIN32) 186 int 187 mkstemp(char *path) 188 { 189 char *start, *trv; 190 unsigned int pid; 191 192 /* To guarantee multiple calls generate unique names even if 193 the file is not created. 676 different possibilities with 7 194 or more X's, 26 with 6 or less. */ 195 static char xtra[2] = "aa"; 196 int xcnt = 0; 197 198 pid = getpid(); 199 200 /* Move to end of path and count trailing X's. */ 201 for (trv = path; *trv; ++trv) 202 if (*trv == 'X') 203 xcnt++; 204 else 205 xcnt = 0; 206 207 /* Use at least one from xtra. Use 2 if more than 6 X's. */ 208 if (*(trv - 1) == 'X') 209 *--trv = xtra[0]; 210 if (xcnt > 6 && *(trv - 1) == 'X') 211 *--trv = xtra[1]; 212 213 /* Set remaining X's to pid digits with 0's to the left. */ 214 while (*--trv == 'X') { 215 *trv = (pid % 10) + '0'; 216 pid /= 10; 217 } 218 219 /* update xtra for next call. */ 220 if (xtra[0] != 'z') 221 xtra[0]++; 222 else { 223 xtra[0] = 'a'; 224 if (xtra[1] != 'z') 225 xtra[1]++; 226 else 227 xtra[1] = 'a'; 228 } 229 230 return open(path, O_CREAT | O_EXCL | O_RDWR, 0600); 231 } 232 #endif 233 234 #ifdef HAVE_FFS 235 int 236 ffs(int x) 237 { 238 int r = 1; 239 if (!x) return 0; 240 if (!(x & 0xffff)) { x >>= 16; r += 16; } 241 if (!(x & 0xff)) { x >>= 8; r += 8; } 242 if (!(x & 0xf)) { x >>= 4; r += 4; } 243 if (!(x & 3)) { x >>= 2; r += 2; } 244 if (!(x & 1)) { x >>= 1; r += 1; } 245 246 return r; 247 } 248 #endif 249 250 /* 251 * Copyright Patrick Powell 1995 252 * This code is based on code written by Patrick Powell (papowell (at) astart.com) 253 * It may be used for any purpose as long as this notice remains intact 254 * on all source code distributions 255 */ 256 257 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) 258 259 static void 260 dopr(char *buffer, size_t maxlen, const char *format, va_list args); 261 262 static void 263 fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, 264 int min, int max); 265 266 static void 267 fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base, 268 int min, int max, int flags); 269 270 static void 271 fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, 272 int min, int max, int flags); 273 274 static void 275 dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c); 276 277 /* 278 * dopr(): poor man's version of doprintf 279 */ 280 281 /* format read states */ 282 #define DP_S_DEFAULT 0 283 #define DP_S_FLAGS 1 284 #define DP_S_MIN 2 285 #define DP_S_DOT 3 286 #define DP_S_MAX 4 287 #define DP_S_MOD 5 288 #define DP_S_CONV 6 289 #define DP_S_DONE 7 290 291 /* format flags - Bits */ 292 #define DP_F_MINUS (1 << 0) 293 #define DP_F_PLUS (1 << 1) 294 #define DP_F_SPACE (1 << 2) 295 #define DP_F_NUM (1 << 3) 296 #define DP_F_ZERO (1 << 4) 297 #define DP_F_UP (1 << 5) 298 #define DP_F_UNSIGNED (1 << 6) 299 300 /* Conversion Flags */ 301 #define DP_C_SHORT 1 302 #define DP_C_LONG 2 303 #define DP_C_LDOUBLE 3 304 #define DP_C_LONG_LONG 4 305 306 #define char_to_int(p) (p - '0') 307 #define abs_val(p) (p < 0 ? -p : p) 308 309 310 static void 311 dopr(char *buffer, size_t maxlen, const char *format, va_list args) 312 { 313 char *strvalue, ch; 314 long value; 315 long double fvalue; 316 int min = 0, max = -1, state = DP_S_DEFAULT, flags = 0, cflags = 0; 317 size_t currlen = 0; 318 319 ch = *format++; 320 321 while (state != DP_S_DONE) { 322 if ((ch == '\0') || (currlen >= maxlen)) 323 state = DP_S_DONE; 324 325 switch(state) { 326 case DP_S_DEFAULT: 327 if (ch == '%') 328 state = DP_S_FLAGS; 329 else 330 dopr_outch(buffer, &currlen, maxlen, ch); 331 ch = *format++; 332 break; 333 case DP_S_FLAGS: 334 switch (ch) { 335 case '-': 336 flags |= DP_F_MINUS; 337 ch = *format++; 338 break; 339 case '+': 340 flags |= DP_F_PLUS; 341 ch = *format++; 342 break; 343 case ' ': 344 flags |= DP_F_SPACE; 345 ch = *format++; 346 break; 347 case '#': 348 flags |= DP_F_NUM; 349 ch = *format++; 350 break; 351 case '0': 352 flags |= DP_F_ZERO; 353 ch = *format++; 354 break; 355 default: 356 state = DP_S_MIN; 357 break; 358 } 359 break; 360 case DP_S_MIN: 361 if (isdigit((unsigned char)ch)) { 362 min = 10 * min + char_to_int (ch); 363 ch = *format++; 364 } else if (ch == '*') { 365 min = va_arg (args, int); 366 ch = *format++; 367 state = DP_S_DOT; 368 } else 369 state = DP_S_DOT; 370 break; 371 case DP_S_DOT: 372 if (ch == '.') { 373 state = DP_S_MAX; 374 ch = *format++; 375 } else 376 state = DP_S_MOD; 377 break; 378 case DP_S_MAX: 379 if (isdigit((unsigned char)ch)) { 380 if (max < 0) 381 max = 0; 382 max = 10 * max + char_to_int(ch); 383 ch = *format++; 384 } else if (ch == '*') { 385 max = va_arg (args, int); 386 ch = *format++; 387 state = DP_S_MOD; 388 } else 389 state = DP_S_MOD; 390 break; 391 case DP_S_MOD: 392 switch (ch) { 393 case 'h': 394 cflags = DP_C_SHORT; 395 ch = *format++; 396 break; 397 case 'l': 398 cflags = DP_C_LONG; 399 ch = *format++; 400 if (ch == 'l') { 401 cflags = DP_C_LONG_LONG; 402 ch = *format++; 403 } 404 break; 405 case 'q': 406 cflags = DP_C_LONG_LONG; 407 ch = *format++; 408 break; 409 case 'L': 410 cflags = DP_C_LDOUBLE; 411 ch = *format++; 412 break; 413 default: 414 break; 415 } 416 state = DP_S_CONV; 417 break; 418 case DP_S_CONV: 419 switch (ch) { 420 case 'd': 421 case 'i': 422 if (cflags == DP_C_SHORT) 423 value = va_arg(args, int); 424 else if (cflags == DP_C_LONG) 425 value = va_arg(args, long int); 426 else if (cflags == DP_C_LONG_LONG) 427 value = va_arg (args, long long); 428 else 429 value = va_arg (args, int); 430 fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags); 431 break; 432 case 'o': 433 flags |= DP_F_UNSIGNED; 434 if (cflags == DP_C_SHORT) 435 value = va_arg(args, unsigned int); 436 else if (cflags == DP_C_LONG) 437 value = va_arg(args, unsigned long int); 438 else if (cflags == DP_C_LONG_LONG) 439 value = va_arg(args, unsigned long long); 440 else 441 value = va_arg(args, unsigned int); 442 fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags); 443 break; 444 case 'u': 445 flags |= DP_F_UNSIGNED; 446 if (cflags == DP_C_SHORT) 447 value = va_arg(args, unsigned int); 448 else if (cflags == DP_C_LONG) 449 value = va_arg(args, unsigned long int); 450 else if (cflags == DP_C_LONG_LONG) 451 value = va_arg(args, unsigned long long); 452 else 453 value = va_arg(args, unsigned int); 454 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); 455 break; 456 case 'X': 457 flags |= DP_F_UP; 458 case 'x': 459 flags |= DP_F_UNSIGNED; 460 if (cflags == DP_C_SHORT) 461 value = va_arg(args, unsigned int); 462 else if (cflags == DP_C_LONG) 463 value = va_arg(args, unsigned long int); 464 else if (cflags == DP_C_LONG_LONG) 465 value = va_arg(args, unsigned long long); 466 else 467 value = va_arg(args, unsigned int); 468 fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags); 469 break; 470 case 'f': 471 if (cflags == DP_C_LDOUBLE) 472 fvalue = va_arg(args, long double); 473 else 474 fvalue = va_arg(args, double); 475 /* um, floating point? */ 476 fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags); 477 break; 478 case 'E': 479 flags |= DP_F_UP; 480 case 'e': 481 if (cflags == DP_C_LDOUBLE) 482 fvalue = va_arg(args, long double); 483 else 484 fvalue = va_arg(args, double); 485 break; 486 case 'G': 487 flags |= DP_F_UP; 488 case 'g': 489 if (cflags == DP_C_LDOUBLE) 490 fvalue = va_arg(args, long double); 491 else 492 fvalue = va_arg(args, double); 493 break; 494 case 'c': 495 dopr_outch(buffer, &currlen, maxlen, va_arg(args, int)); 496 break; 497 case 's': 498 strvalue = va_arg(args, char *); 499 if (max < 0) 500 max = maxlen; /* ie, no max */ 501 fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max); 502 break; 503 case 'p': 504 strvalue = va_arg(args, void *); 505 fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags); 506 break; 507 case 'n': 508 if (cflags == DP_C_SHORT) { 509 short int *num; 510 num = va_arg(args, short int *); 511 *num = currlen; 512 } else if (cflags == DP_C_LONG) { 513 long int *num; 514 num = va_arg(args, long int *); 515 *num = currlen; 516 } else if (cflags == DP_C_LONG_LONG) { 517 long long *num; 518 num = va_arg(args, long long *); 519 *num = currlen; 520 } else { 521 int *num; 522 num = va_arg(args, int *); 523 *num = currlen; 524 } 525 break; 526 case '%': 527 dopr_outch(buffer, &currlen, maxlen, ch); 528 break; 529 case 'w': /* not supported yet, treat as next char */ 530 ch = *format++; 531 break; 532 default: /* Unknown, skip */ 533 break; 534 } 535 ch = *format++; 536 state = DP_S_DEFAULT; 537 flags = cflags = min = 0; 538 max = -1; 539 break; 540 case DP_S_DONE: 541 break; 542 default: /* hmm? */ 543 break; /* some picky compilers need this */ 544 } 545 } 546 if (currlen < maxlen - 1) 547 buffer[currlen] = '\0'; 548 else 549 buffer[maxlen - 1] = '\0'; 550 } 551 552 static void 553 fmtstr(char *buffer, size_t *currlen, size_t maxlen, 554 char *value, int flags, int min, int max) 555 { 556 int cnt = 0, padlen, strln; /* amount to pad */ 557 558 if (value == 0) 559 value = "<NULL>"; 560 561 for (strln = 0; value[strln]; ++strln); /* strlen */ 562 padlen = min - strln; 563 if (padlen < 0) 564 padlen = 0; 565 if (flags & DP_F_MINUS) 566 padlen = -padlen; /* Left Justify */ 567 568 while ((padlen > 0) && (cnt < max)) { 569 dopr_outch(buffer, currlen, maxlen, ' '); 570 --padlen; 571 ++cnt; 572 } 573 while (*value && (cnt < max)) { 574 dopr_outch(buffer, currlen, maxlen, *value++); 575 ++cnt; 576 } 577 while ((padlen < 0) && (cnt < max)) { 578 dopr_outch(buffer, currlen, maxlen, ' '); 579 ++padlen; 580 ++cnt; 581 } 582 } 583 584 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ 585 586 static void 587 fmtint(char *buffer, size_t *currlen, size_t maxlen, 588 long value, int base, int min, int max, int flags) 589 { 590 unsigned long uvalue; 591 char convert[20]; 592 int signvalue = 0, place = 0, caps = 0; 593 int spadlen = 0; /* amount to space pad */ 594 int zpadlen = 0; /* amount to zero pad */ 595 596 #define PADMAX(x,y) ((x) > (y) ? (x) : (y)) 597 598 if (max < 0) 599 max = 0; 600 601 uvalue = value; 602 603 if (!(flags & DP_F_UNSIGNED)) { 604 if (value < 0) { 605 signvalue = '-'; 606 uvalue = -value; 607 } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ 608 signvalue = '+'; 609 else if (flags & DP_F_SPACE) 610 signvalue = ' '; 611 } 612 613 if (flags & DP_F_UP) 614 caps = 1; /* Should characters be upper case? */ 615 do { 616 convert[place++] = 617 (caps ? "0123456789ABCDEF" : "0123456789abcdef") 618 [uvalue % (unsigned)base]; 619 uvalue = (uvalue / (unsigned)base ); 620 } while (uvalue && (place < 20)); 621 if (place == 20) 622 place--; 623 convert[place] = 0; 624 625 zpadlen = max - place; 626 spadlen = min - PADMAX(max, place) - (signvalue ? 1 : 0); 627 if (zpadlen < 0) 628 zpadlen = 0; 629 if (spadlen < 0) 630 spadlen = 0; 631 if (flags & DP_F_ZERO) { 632 zpadlen = PADMAX(zpadlen, spadlen); 633 spadlen = 0; 634 } 635 if (flags & DP_F_MINUS) 636 spadlen = -spadlen; /* Left Justifty */ 637 638 /* Spaces */ 639 while (spadlen > 0) { 640 dopr_outch(buffer, currlen, maxlen, ' '); 641 --spadlen; 642 } 643 644 /* Sign */ 645 if (signvalue) 646 dopr_outch(buffer, currlen, maxlen, signvalue); 647 648 /* Zeros */ 649 if (zpadlen > 0) { 650 while (zpadlen > 0) { 651 dopr_outch(buffer, currlen, maxlen, '0'); 652 --zpadlen; 653 } 654 } 655 656 /* Digits */ 657 while (place > 0) 658 dopr_outch(buffer, currlen, maxlen, convert[--place]); 659 660 /* Left Justified spaces */ 661 while (spadlen < 0) { 662 dopr_outch (buffer, currlen, maxlen, ' '); 663 ++spadlen; 664 } 665 } 666 667 static long double 668 pow10(int exp) 669 { 670 long double result = 1; 671 672 while (exp) { 673 result *= 10; 674 exp--; 675 } 676 677 return result; 678 } 679 680 static long 681 round(long double value) 682 { 683 long intpart = value; 684 685 value -= intpart; 686 if (value >= 0.5) 687 intpart++; 688 689 return intpart; 690 } 691 692 static void 693 fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, 694 int min, int max, int flags) 695 { 696 char iconvert[20], fconvert[20]; 697 int signvalue = 0, iplace = 0, fplace = 0; 698 int padlen = 0; /* amount to pad */ 699 int zpadlen = 0, caps = 0; 700 long intpart, fracpart; 701 long double ufvalue; 702 703 /* 704 * AIX manpage says the default is 0, but Solaris says the default 705 * is 6, and sprintf on AIX defaults to 6 706 */ 707 if (max < 0) 708 max = 6; 709 710 ufvalue = abs_val(fvalue); 711 712 if (fvalue < 0) 713 signvalue = '-'; 714 else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ 715 signvalue = '+'; 716 else if (flags & DP_F_SPACE) 717 signvalue = ' '; 718 719 intpart = ufvalue; 720 721 /* 722 * Sorry, we only support 9 digits past the decimal because of our 723 * conversion method 724 */ 725 if (max > 9) 726 max = 9; 727 728 /* We "cheat" by converting the fractional part to integer by 729 * multiplying by a factor of 10 730 */ 731 fracpart = round((pow10 (max)) * (ufvalue - intpart)); 732 733 if (fracpart >= pow10 (max)) { 734 intpart++; 735 fracpart -= pow10 (max); 736 } 737 738 /* Convert integer part */ 739 do { 740 iconvert[iplace++] = 741 (caps ? "0123456789ABCDEF" : "0123456789abcdef") 742 [intpart % 10]; 743 intpart = (intpart / 10); 744 } while(intpart && (iplace < 20)); 745 if (iplace == 20) 746 iplace--; 747 iconvert[iplace] = 0; 748 749 /* Convert fractional part */ 750 do { 751 fconvert[fplace++] = 752 (caps ? "0123456789ABCDEF" : "0123456789abcdef") 753 [fracpart % 10]; 754 fracpart = (fracpart / 10); 755 } while(fracpart && (fplace < 20)); 756 if (fplace == 20) 757 fplace--; 758 fconvert[fplace] = 0; 759 760 /* -1 for decimal point, another -1 if we are printing a sign */ 761 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 762 zpadlen = max - fplace; 763 if (zpadlen < 0) 764 zpadlen = 0; 765 if (padlen < 0) 766 padlen = 0; 767 if (flags & DP_F_MINUS) 768 padlen = -padlen; /* Left Justifty */ 769 770 if ((flags & DP_F_ZERO) && (padlen > 0)) { 771 if (signvalue) { 772 dopr_outch(buffer, currlen, maxlen, signvalue); 773 --padlen; 774 signvalue = 0; 775 } 776 while (padlen > 0) { 777 dopr_outch(buffer, currlen, maxlen, '0'); 778 --padlen; 779 } 780 } 781 while (padlen > 0) { 782 dopr_outch(buffer, currlen, maxlen, ' '); 783 --padlen; 784 } 785 if (signvalue) 786 dopr_outch(buffer, currlen, maxlen, signvalue); 787 788 while (iplace > 0) 789 dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]); 790 791 /* 792 * Decimal point. This should probably use locale to find the 793 * correct char to print out. 794 */ 795 dopr_outch(buffer, currlen, maxlen, '.'); 796 797 while (fplace > 0) 798 dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]); 799 800 while (zpadlen > 0) { 801 dopr_outch(buffer, currlen, maxlen, '0'); 802 --zpadlen; 803 } 804 805 while (padlen < 0) { 806 dopr_outch(buffer, currlen, maxlen, ' '); 807 ++padlen; 808 } 809 } 810 811 static void 812 dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c) 813 { 814 if (*currlen < maxlen) 815 buffer[(*currlen)++] = c; 816 } 817 #endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */ 818 819 #ifndef HAVE_VSNPRINTF 820 int 821 vsnprintf(char *str, size_t count, const char *fmt, va_list args) 822 { 823 str[0] = 0; 824 dopr(str, count, fmt, args); 825 826 return(strlen(str)); 827 } 828 #endif /* !HAVE_VSNPRINTF */ 829 830 #ifndef HAVE_SNPRINTF 831 int 832 snprintf(char *str,size_t count,const char *fmt,...) 833 { 834 va_list ap; 835 836 va_start(ap, fmt); 837 (void) vsnprintf(str, count, fmt, ap); 838 va_end(ap); 839 840 return(strlen(str)); 841 } 842 843 #endif /* !HAVE_SNPRINTF */ 844
