Usermode/Libraries/libc.so_src/printf.c

   1 /*
   2  * Acess2 C Library
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * scanf.c
   6  * - *scanf family of functions
   7  */
   8 #include "lib.h"
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <string.h>
  12 #include <ctype.h>      // toupper
  13 #include <assert.h>     // assert()
  14
  15 // Quick booleans
  16 typedef char    BOOL;
  17 #define TRUE    1
  18 #define FALSE   0
  19
  20 // === TYPES ===
  21 typedef void    (*printf_puts_t)(void *h, const char *s, size_t len);
  22 enum eFPN {
  23         FPN_STD,
  24         FPN_SCI,
  25         FPN_SHORTEST,
  26 };
  27
  28 // === PROTOTYPES ===
  29 void    itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned);
  30 size_t  _printf_itoa(printf_puts_t puts_cb, void *puts_h, uint64_t num,
  31         size_t base, int bUpper,
  32         int bSigned, char SignChar, int Precision,
  33         int PadLength, char PadChar, int bPadRight);
  34 size_t  _printf_ftoa_hex(printf_puts_t puts_cb, void *puts_h, long double num, int Precision, int bForcePoint, int bForceSign, int bCapitals);
  35 size_t  _printf_ftoa(printf_puts_t puts_cb, void *puts_h, long double num, size_t Base, enum eFPN Notation, int Precision, int bForcePoint, int bForceSign, int bCapitals);
  36
  37 // === CODE ===
  38 /**
  39  * \fn EXPORT void vsnprintf(char *buf, const char *format, va_list args)
  40  * \brief Prints a formatted string to a buffer
  41  * \param buf   Pointer - Destination Buffer
  42  * \param format        String - Format String
  43  * \param args  VarArgs List - Arguments
  44  */
  45 EXPORT int _vcprintf_int(printf_puts_t puts_cb, void *puts_h, const char *format, va_list args)
  46 {
  47         char    tmp[65];
  48          int    c, minSize, precision, len;
  49         size_t  pos = 0;
  50         char    *p;
  51         uint64_t        arg;
  52         long double     arg_f;
  53 //      char    cPositiveChar;
  54         BOOL    bLongLong, bLong, bJustifyLeft, bAltForm;
  55         char    cNumPad, cPlus;
  56
  57         #define _addchar(ch) do { \
  58                 char _ch = ch; \
  59                 puts_cb(puts_h, &_ch, 1); \
  60                 pos ++; \
  61         } while(0)
  62
  63         tmp[32] = '\0';
  64
  65         while((c = *format++) != 0)
  66         {
  67                 // Non-control character
  68                 if (c != '%') {
  69                         const char      *start = format-1;
  70                         while( (c = *format) != 0 && c != '%' )
  71                                 format ++;
  72                         puts_cb(puts_h, start, format - start);
  73                         pos += format - start;
  74                         continue;
  75                 }
  76
  77                 // Control Character
  78                 c = *format++;
  79                 if(c == '%') {  // Literal %
  80                         _addchar('%');
  81                         continue;
  82                 }
  83
  84                 bAltForm = 0;
  85                 cNumPad = ' ';
  86                 bJustifyLeft = 0;
  87                 cPlus = '\0';
  88                 bLong = 0;
  89                 bLongLong = 0;
  90                 minSize = 0;
  91                 precision = -1;
  92
  93                 // - Flags
  94                 do
  95                 {
  96                         // Alternate form (0<oct>, 0x<hex>, 123.)
  97                         if(c == '#') {
  98                                 bAltForm = 1;
  99                         }
 100                         // Padding with '0'
 101                         else if(c == '0') {
 102                                 cNumPad = '0';
 103                         }
 104                         // Pad on left
 105                         else if(c == '-') {
 106                                 bJustifyLeft = 1;
 107                         }
 108                         // Include space for positive sign
 109                         else if(c == ' ') {
 110                                 cPlus = ' ';
 111                         }
 112                         // Always include sign
 113                         else if(c == '+') {
 114                                 cPlus = '+';
 115                         }
 116                         else
 117                                 break;
 118                 }
 119                 while( (c = *format++) );
 120
 121                 // Padding length
 122                 if( c == '*' ) {
 123                         // Variable length
 124                         minSize = va_arg(args, size_t);
 125                         c = *format++;
 126                 }
 127                 else if('1' <= c && c <= '9')
 128                 {
 129                         minSize = 0;
 130                         while('0' <= c && c <= '9')
 131                         {
 132                                 minSize *= 10;
 133                                 minSize += c - '0';
 134                                 c = *format++;
 135                         }
 136                 }
 137
 138                 // Precision
 139                 if(c == '.') {
 140                         c = *format++;
 141                         if(c == '*') {
 142                                 precision = va_arg(args, size_t);
 143                                 c = *format++;
 144                         }
 145                         else if('1' <= c && c <= '9')
 146                         {
 147                                 precision = 0;
 148                                 while('0' <= c && c <= '9')
 149                                 {
 150                                         precision *= 10;
 151                                         precision += c - '0';
 152                                         c = *format++;
 153                                 }
 154                         }
 155                 }
 156
 157                 // Check for long long
 158                 if(c == 'l')
 159                 {
 160                         bLong = 1;
 161                         c = *format++;
 162                         if(c == 'l') {
 163                                 bLongLong = 1;
 164                                 c = *format++;
 165                         }
 166                 }
 167
 168                 // Just help things along later
 169                 p = tmp;
 170
 171                 // Get Type
 172                 switch( c )
 173                 {
 174                 // Signed Integer
 175                 case 'd':
 176                 case 'i':
 177                         // Get Argument
 178                         arg = bLongLong ? va_arg(args, int64_t) : va_arg(args, int32_t);
 179                         if( arg == 0 && precision == 0 )
 180                                 break;
 181                         pos += _printf_itoa(puts_cb, puts_h, arg, 10, FALSE,
 182                                 TRUE, cPlus, precision, minSize, cNumPad, bJustifyLeft);
 183                         break;
 184
 185                 // Unsigned Integer
 186                 case 'u':
 187                         arg = bLongLong ? va_arg(args, int64_t) : va_arg(args, int32_t);
 188                         pos += _printf_itoa(puts_cb, puts_h, arg, 10, FALSE,
 189                                 FALSE, '\0', precision, minSize, cNumPad, bJustifyLeft);
 190                         break;
 191
 192                 // Pointer
 193                 case 'p':
 194                         _addchar('*');
 195                         _addchar('0');
 196                         _addchar('x');
 197                         arg = va_arg(args, intptr_t);
 198                         pos += _printf_itoa(puts_cb, puts_h, arg, 16, FALSE,
 199                                 FALSE, '\0', sizeof(intptr_t)*2, 0,'\0',FALSE);
 200                         break;
 201                 // Unsigned Hexadecimal
 202                 case 'X':
 203                 case 'x':
 204                         if(bAltForm) {
 205                                 _addchar('0');
 206                                 _addchar(c);
 207                         }
 208                         arg = bLongLong ? va_arg(args, uint64_t) : va_arg(args, uint32_t);
 209                         pos += _printf_itoa(puts_cb, puts_h, arg, 16, c=='X',
 210                                 FALSE, '\0', precision, minSize,cNumPad,bJustifyLeft);
 211                         break;
 212
 213                 // Unsigned Octal
 214                 case 'o':
 215                         if(bAltForm) {
 216                                 _addchar('0');
 217                         }
 218                         arg = bLongLong ? va_arg(args, int64_t) : va_arg(args, int32_t);
 219                         pos += _printf_itoa(puts_cb, puts_h, arg, 8, FALSE,
 220                                 FALSE, '\0', precision, minSize,cNumPad,bJustifyLeft);
 221                         break;
 222
 223                 // Unsigned binary
 224                 case 'b':
 225                         if(bAltForm) {
 226                                 _addchar('0');
 227                                 _addchar('b');
 228                         }
 229                         arg = bLongLong ? va_arg(args, int64_t) : va_arg(args, int32_t);
 230                         pos += _printf_itoa(puts_cb, puts_h, arg, 2, FALSE,
 231                                 FALSE, '\0', precision, minSize,cNumPad,bJustifyLeft);
 232                         break;
 233
 234                 // Standard float
 235                 case 'f':
 236                 case 'F':
 237                         arg_f = bLong ? va_arg(args, long double) : va_arg(args, double);
 238                         pos += _printf_ftoa(puts_cb, puts_h, arg_f, 10, FPN_STD,
 239                                 precision, 0, bJustifyLeft, c == 'F');
 240                         break;
 241                 // Scientific Float
 242                 case 'e':
 243                 case 'E':
 244                         arg_f = bLong ? va_arg(args, long double) : va_arg(args, double);
 245                         pos += _printf_ftoa(puts_cb, puts_h, arg_f, 10, FPN_SCI,
 246                                 precision, 0, bJustifyLeft, c == 'E');
 247                         break;
 248                 // Scientific Float
 249                 case 'g':
 250                 case 'G':
 251                         arg_f = bLong ? va_arg(args, long double) : va_arg(args, double);
 252                         pos += _printf_ftoa(puts_cb, puts_h, arg_f, 10, FPN_SHORTEST,
 253                                 precision, 0, bJustifyLeft, c == 'G');
 254                         break;
 255                 // Hexadecimal Scientific
 256                 case 'a':
 257                 case 'A':
 258                         arg_f = bLong ? va_arg(args, long double) : va_arg(args, double);
 259                         pos += _printf_ftoa_hex(puts_cb, puts_h, arg_f, precision, 0, bJustifyLeft, c == 'A');
 260                         break;
 261
 262                 // String
 263                 case 's':
 264                         p = va_arg(args, char*);
 265                         if(!p)  p = "(null)";
 266                         //_SysDebug("vsnprintf: p = '%s'", p);
 267                         if(precision >= 0)
 268                                 len = strnlen(p, precision);
 269                         else
 270                                 len = strlen(p);
 271                         if(!bJustifyLeft)
 272                                 while(minSize-- > len)  _addchar(' ');
 273                         puts_cb(puts_h, p, len); pos += len;
 274                         if(bJustifyLeft)
 275                                 while(minSize-- > len)  _addchar(' ');
 276                         break;
 277
 278                 // Unknown, just treat it as a character
 279                 default:
 280                         arg = va_arg(args, uint32_t);
 281                         _addchar(arg);
 282                         break;
 283                 }
 284         }
 285         #undef _addchar
 286
 287         return pos;
 288 }
 289
 290 struct s_sprintf_info {
 291         char    *dest;
 292         size_t  ofs;
 293         size_t  maxlen;
 294 };
 295
 296 void _vsnprintf_puts(void *h, const char *str, size_t len)
 297 {
 298         struct s_sprintf_info   *info = h;
 299         while( info->ofs < info->maxlen && len -- )
 300                 info->dest[info->ofs++] = *str++;
 301 }
 302
 303 EXPORT int vsnprintf(char *__s, size_t __maxlen, const char *__format, va_list __args)
 304 {
 305         struct s_sprintf_info   info = {__s, 0, __maxlen};
 306         int ret;
 307         ret = _vcprintf_int(_vsnprintf_puts, &info, __format, __args);
 308         _vsnprintf_puts(&info, "", 1);
 309         return ret;
 310 }
 311
 312 EXPORT int snprintf(char *buf, size_t maxlen, const char *format, ...)
 313 {
 314          int    ret;
 315         va_list args;
 316         va_start(args, format);
 317         ret = vsnprintf((char*)buf, maxlen, (char*)format, args);
 318         va_end(args);
 319         return ret;
 320 }
 321
 322
 323 EXPORT int vsprintf(char * __s, const char *__format, va_list __args)
 324 {
 325         return vsnprintf(__s, 0x7FFFFFFF, __format, __args);
 326 }
 327 EXPORT int sprintf(char *buf, const char *format, ...)
 328 {
 329          int    ret;
 330         va_list args;
 331         va_start(args, format);
 332         ret = vsprintf((char*)buf, (char*)format, args);
 333         va_end(args);
 334         return ret;
 335 }
 336
 337 void _vfprintf_puts(void *h, const char *str, size_t len)
 338 {
 339         fwrite(str, len, 1, h);
 340 }
 341
 342 EXPORT int vfprintf(FILE *__fp, const char *__format, va_list __args)
 343 {
 344         return _vcprintf_int(_vfprintf_puts, __fp, __format, __args);
 345 }
 346
 347 EXPORT int fprintf(FILE *fp, const char *format, ...)
 348 {
 349         va_list args;
 350          int    ret;
 351
 352         // Get Size
 353         va_start(args, format);
 354         ret = vfprintf(fp, (char*)format, args);
 355         va_end(args);
 356
 357         return ret;
 358 }
 359
 360 EXPORT int vprintf(const char *__format, va_list __args)
 361 {
 362         return vfprintf(stdout, __format, __args);
 363 }
 364
 365 EXPORT int printf(const char *format, ...)
 366 {
 367         va_list args;
 368          int    ret;
 369
 370         // Get final size
 371         va_start(args, format);
 372         ret = vprintf(format, args);
 373         va_end(args);
 374
 375         // Return
 376         return ret;
 377 }
 378
 379 void itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned)
 380 {
 381         struct s_sprintf_info   info = {buf, 0, 1024};
 382         if(!buf)        return;
 383         _printf_itoa(_vsnprintf_puts, &info, num, base, FALSE, bSigned, '\0', 0, minLength, pad, FALSE);
 384         buf[info.ofs] = '\0';
 385 }
 386
 387 const char cDIGITS[] = "0123456789abcdef";
 388 const char cUDIGITS[] = "0123456789ABCDEF";
 389 /**
 390  * \brief Convert an integer into a character string
 391  * \param buf   Destination Buffer
 392  * \param num   Number to convert
 393  * \param base  Base-n number output
 394  * \param minLength     Minimum length of output
 395  * \param pad   Padding used to ensure minLength
 396  * \param bSigned       Signed number output?
 397  */
 398 size_t _printf_itoa(printf_puts_t puts_cb, void *puts_h, uint64_t num,
 399         size_t base, int bUpper,
 400         int bSigned, char SignChar, int Precision,
 401         int PadLength, char PadChar, int bPadRight)
 402 {
 403         char    tmpBuf[64+1];
 404          int    pos = sizeof(tmpBuf);
 405         size_t  ret = 0;
 406          int    sign_is_neg = 0;
 407         const char *map = bUpper ? cUDIGITS : cDIGITS;
 408
 409         if(base > 16 || base < 2) {
 410                 return 0;
 411         }
 412
 413         if(bSigned && (int64_t)num < 0)
 414         {
 415                 num = -(int64_t)num;
 416                 sign_is_neg = 1;
 417         }
 418
 419         // Encode into string
 420         while(num > base-1) {
 421                 tmpBuf[--pos] = map[ num % base ];
 422                 num = (uint64_t) num / (uint64_t)base;          // Shift {number} right 1 digit
 423         }
 424         tmpBuf[--pos] = map[ num % base ];              // Most significant digit of {number}
 425
 426         // Sign
 427         if(sign_is_neg)
 428                 tmpBuf[--pos] = '-';    // Negative sign character
 429         else if(SignChar)
 430                 tmpBuf[--pos] = SignChar;       // positive sign character
 431         else {
 432         }
 433
 434         // length of number, minus the sign character
 435         size_t len = sizeof(tmpBuf)-pos;
 436         PadLength -= len;
 437         Precision -= len;
 438         if( !bPadRight )
 439         {
 440                 while(PadLength-- > 0)
 441                         puts_cb(puts_h, &PadChar, 1), ret ++;
 442         }
 443
 444         // TODO: Will {Precision} ever be > size
 445         while( Precision-- > 0 )
 446                 puts_cb(puts_h, "0", 1), ret++;
 447
 448         puts_cb(puts_h, tmpBuf+pos, len);
 449         ret += len;
 450
 451         if( bPadRight )
 452         {
 453                 while(PadLength-- > 0)
 454                         puts_cb(puts_h, &PadChar, 1), ret ++;
 455         }
 456
 457         return ret;
 458 }
 459
 460 int expand_double(double num, uint64_t *Significand, int16_t *Exponent, int *SignIsNeg)
 461 {
 462         // IEEE 754 binary64
 463         #if 0
 464         {
 465                 uint64_t test_exp = 0xC000000000000000;
 466                 double test_value = -2.0f;
 467                 assert( *((uint64_t*)&test_value) == test_exp );
 468         }
 469         #endif
 470
 471         const uint64_t  *bit_rep = (void*)&num;
 472
 473         *SignIsNeg = *bit_rep >> 63;
 474         *Exponent = ((*bit_rep >> 52) & 0x7FF) - 1023;
 475         *Significand = (*bit_rep & ((1ULL << 52)-1)) << (64-52);
 476
 477 //      printf("%llx %i %i %llx\n", *bit_rep, (int)*SignIsNeg, (int)*Exponent, *Significand);
 478
 479         // Subnormals
 480         if( *Exponent == -0x3FF && *Significand != 0 )
 481                 return 1;
 482         // Infinity
 483         if( *Exponent == 0x400 && *Significand == 0)
 484                 return 2;
 485         // NaNs
 486         if( *Exponent == 0x400 && *Significand != 0)
 487                 return 3;
 488
 489         return 0;
 490 }
 491
 492 /**
 493  * Internal function
 494  * \return Remainder
 495  */
 496 double _longdiv(double num, double den, int *quot)
 497 {
 498         assert(num >= 0);
 499         assert(den > 0);
 500 //      printf("%llu / %llu\n", (long long int)num, (long long int)den);
 501
 502         *quot = 0;
 503         assert(num < den*10);
 504         while(num >= den)
 505         {
 506                 num -= den;
 507                 (*quot) ++;
 508                 assert( *quot < 10 );
 509         }
 510 //      printf(" %i\n", *quot);
 511         return num;
 512 }
 513
 514 size_t _printf_ftoa_hex(printf_puts_t puts_cb, void *puts_h, long double num, int Precision, int bForcePoint, int bForceSign, int bCapitals)
 515 {
 516         uint64_t        significand;
 517         int16_t exponent;
 518          int    signisneg;
 519          int    rv;
 520         size_t  ret = 0;
 521
 522         #define _putch(_ch) do{\
 523                 char __ch = (bCapitals ? toupper(_ch) : _ch);\
 524                 puts_cb(puts_h, &__ch, 1); \
 525                 ret ++;\
 526         }while(0)
 527
 528         if( Precision == -1 )
 529                 Precision = (64-4)/4;
 530
 531         rv = expand_double(num, &significand, &exponent, &signisneg);
 532         switch(rv)
 533         {
 534         // 0: No errors, nothing special
 535         case 0:
 536                 break;
 537         // 1: Subnormals
 538         case 1:
 539                 // TODO: Subnormal = 0?
 540                 break;
 541         // 2: Infinity
 542         case 2:
 543                 puts_cb(puts_h, "inf", 3);
 544                 return 3;
 545         case 3:
 546                 puts_cb(puts_h, "NaN", 3);
 547                 return 3;
 548         }
 549
 550         // int  exp_ofs = exponent % 4;
 551         // int  exp_16 = exponent - exp_ofs;
 552         //uint8_t       whole = (1 << exp_ofs) | ((significand >> (64-3)) >> exp_ofs);
 553         //significand <<= 3 - exp_ofs;
 554         uint8_t whole = (rv != 1) ? 1 : 0;
 555
 556         if( signisneg )
 557                 _putch('-');
 558         else if( bForceSign )
 559                 _putch('+');
 560         else {
 561         }
 562         _putch('0');
 563         _putch('x');
 564         _putch(cDIGITS[whole]);
 565         if( significand || bForcePoint )
 566                 _putch('.');
 567         // Fractional
 568         while( significand && Precision -- )
 569         {
 570                 uint8_t val = significand >> (64-4);
 571                 _putch(cDIGITS[val]);
 572                 significand <<= 4;
 573         }
 574         _putch('p');
 575         //ret += _printf_itoa(puts_cb, puts_h, exp_16, 16, bCapitals, TRUE, '+', 0, 0, '\0', 0);
 576         ret += _printf_itoa(puts_cb, puts_h, exponent, 10, bCapitals, TRUE, '+', 0, 0, '\0', 0);
 577
 578         #undef _putch
 579         return ret;
 580 }
 581
 582 #if 0
 583 size_t _printf_itoa_fixed(printf_putch_t putch_cb, void *putch_h, uint64_t num, size_t Base)
 584 {
 585         uint64_t        den;
 586         size_t  ret = 0;
 587
 588         den = 1ULL << (64-1);
 589
 590         while( den )
 591         {
 592                 putch_cb(putch_h, cDIGITS[num / den]);
 593                 ret ++;
 594                 num %= den;
 595                 den /= Base;
 596         }
 597
 598         return ret;
 599 }
 600
 601 size_t _printf_ftoa_dec(printf_putch_t putch_cb, void *putch_h, long double num, enum eFPN Notation, int Precision, int bForcePoint, int bForceSign, int bCapitals)
 602 {
 603         size_t  ret = 0;
 604          int    i;
 605
 606         #define _putch(_ch) do{\
 607                 putch_cb(putch_h, bCapitals ? toupper(_ch) : _ch), ret++;\
 608         }while(0)
 609
 610         uint64_t        significand;
 611          int16_t        exponent;
 612          int    signisneg;
 613          int    rv = expand_double(num, &significand, &exponent, &signisneg);
 614         switch(rv)
 615         {
 616         // 0: No errors, nothing special
 617         case 0:
 618                 break;
 619         // 1: Subnormals
 620         case 1:
 621                 // TODO: Subnormal = 0?
 622                 break;
 623         // 2: Infinity
 624         case 2:
 625                 _putch('i');
 626                 _putch('n');
 627                 _putch('f');
 628                 return 3;
 629         case 3:
 630                 _putch('N');
 631                 _putch('a');
 632                 _putch('N');
 633                 return 3;
 634         }
 635
 636         uint64_t        whole, part;
 637          int    pre_zeros, post_zeros;
 638
 639         #define XXX     0
 640         if( Notation == FPN_SCI )
 641         {
 642         }
 643         else if( exponent < 0 )
 644         {
 645                 whole = 0;
 646                 part = XXX;
 647                 pre_zeros = 0;
 648                 post_zeros = XXX;
 649         }
 650         else if( exponent >= 64 )
 651         {
 652                 part = 0;
 653                 whole = XXX;
 654                 pre_zeros = XXX;
 655                 post_zeros = 0;
 656         }
 657         else
 658         {
 659                 // Split into fixed point
 660                 whole = (1 << exponent) | (significand >> (64-exponent));
 661                 part = significand << exponent;
 662                 pre_zeros = 0;
 663                 post_zeros = 0;
 664         }
 665
 666
 667         // Whole portion
 668         ret += _printf_itoa(putch_cb, putch_h, whole, 10, FALSE, FALSE, '\0', 0, 0, '\0', FALSE);
 669         for(i = pre_zeros; i --; )      _putch('0');
 670         // TODO: Conditional point
 671         _putch('-');
 672         for(i = post_zeros; i--; )      _putch('0');
 673         ret += _printf_itoa_fixed(putch_cb, putch_h, part, 10);
 674
 675         #undef _putch
 676
 677         return 0;
 678 }
 679 #endif
 680
 681 size_t _printf_ftoa(printf_puts_t puts_cb, void *puts_h, long double num, size_t Base, enum eFPN Notation, int Precision, int bForcePoint, int bForceSign, int bCapitals)
 682 {
 683         uint64_t        significand;
 684         int16_t exponent;
 685          int    signisneg;
 686          int    rv, i;
 687         size_t  ret = 0;
 688
 689         #define _putch(_ch) do{\
 690                 char __ch = (bCapitals ? toupper(_ch) : _ch);\
 691                 puts_cb(puts_h, &__ch, 1); \
 692                 ret ++;\
 693         }while(0)
 694
 695         if( Base <= 1 || Base > 16 )
 696                 return 0;
 697
 698         rv = expand_double(num, &significand, &exponent, &signisneg);
 699         switch(rv)
 700         {
 701         // 0: No errors, nothing special
 702         case 0:
 703                 break;
 704         // 1: Subnormals
 705         case 1:
 706                 // TODO: Subnormal = 0?
 707                 break;
 708         // 2: Infinity
 709         case 2:
 710                 _putch('i');
 711                 _putch('n');
 712                 _putch('f');
 713                 return 3;
 714         case 3:
 715                 _putch('N');
 716                 _putch('a');
 717                 _putch('N');
 718                 return 3;
 719         }
 720
 721         // - Used as 0/1 bools in arithmatic later on
 722         bForcePoint = !!bForcePoint;
 723         bForceSign = !!bForceSign;
 724
 725         // Apply default to precision
 726         if( Precision == -1 )
 727                 Precision = 6;
 728
 729         if( num < 0 )
 730                 num = -num;
 731
 732         // Select optimum type
 733         if( Notation == FPN_SHORTEST )
 734         {
 735                 //TODO:
 736                 //int   first_set_sig = BSL(significand);
 737                 // bSign+log10(num)+1+precision vs. bSign+1+1+precision+1+1+log10(exponent)
 738                  int    log10_num = exponent * 301 / 1000;      // log_10(2) = 0.30102999566...
 739                  int    log10_exp10 = 2;
 740                  int    sci_len = (signisneg || bForceSign) + 2 + (Precision-1) + 2 + log10_exp10;
 741                  int    std_whole_len = (log10_num > 0 ? log10_num : 1);
 742                  int    std_len = (signisneg || bForceSign) + std_whole_len + 1 + (Precision-std_whole_len);
 743                 if( sci_len > std_len ) {
 744                         Precision -= std_whole_len;
 745                         Notation = FPN_STD;
 746                 }
 747                 else {
 748                         Precision -= 1;
 749                         Notation = FPN_SCI;
 750                 }
 751         }
 752
 753         double precision_max = 1;
 754         for(i = Precision; i--; )
 755                 precision_max /= Base;
 756
 757         // Determine scientific's exponent and starting denominator
 758         double den = 1;
 759          int    sci_exponent = 0;
 760         if( Notation == FPN_SCI )
 761         {
 762                 if( num < 1 )
 763                 {
 764                         while(num < 1)
 765                         {
 766                                 num *= Base;
 767                                 sci_exponent ++;
 768                         }
 769                 }
 770                 else if( num >= Base )
 771                 {
 772                         while(num >= Base)
 773                         {
 774                                 num /= Base;
 775                                 sci_exponent ++;
 776                         }
 777                 }
 778                 else
 779                 {
 780                         // no exponent
 781                 }
 782                 den = 1;
 783         }
 784         else if( num != 0.0 )
 785         {
 786                 while( den <= num )
 787                         den *= Base;
 788                 den /= Base;
 789         }
 790
 791         // Leading sign
 792         if( signisneg )
 793                 _putch('-');
 794         else if( bForceSign )
 795                 _putch('+');
 796         else {
 797         }
 798
 799         num += precision_max/10 * 4.999;
 800
 801          int    value;
 802         // Whole section
 803         do
 804         {
 805                 num = _longdiv(num, den, &value);
 806                 _putch(cDIGITS[value]);
 807                 den /= Base;
 808         } while( den >= 1 );
 809
 810         // Decimal point (if needed/forced)
 811         if( Precision > 0 || bForcePoint )
 812                 _putch('.');
 813         // Decimal section
 814         for(i = Precision; i--; )
 815         {
 816                 num = _longdiv(num, den, &value);
 817                 _putch(cDIGITS[value]);
 818                 den /= Base;
 819         }
 820
 821         if( Notation == FPN_SCI )
 822         {
 823                 if( Base == 16 )
 824                         _putch('p');
 825                 else
 826                         _putch('e');
 827                 ret += _printf_itoa(puts_cb, puts_h, sci_exponent, Base, FALSE, TRUE, '+', 3, 0, '\0', FALSE);
 828         }
 829
 830         #undef _putch
 831
 832         return ret;
 833 }