Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #include "kosSyst.h"
  2. #include "func.h"
  3. #include <stdarg.h>
  4.  
  5. //////////////////////////////////////////////////////////////////////
  6. //
  7. // âûâîä ñòðîêè íà ïå÷àòü. barsuk äîáàâèë %f
  8.  
  9. //#define PREC 2
  10. //#define HALF 0.499
  11. #define PREC 6
  12. #define HALF 0.4999999
  13.  
  14. static double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
  15. 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};
  16.  
  17.  
  18. //
  19.  
  20. static Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
  21.                    10000, 1000, 100, 10, 0 };
  22.  
  23. //
  24. void sprintf( char *Str, char* Format, ... )
  25. {
  26.         int i, fmtlinesize, j, k, flag;
  27.         Dword head, tail;
  28.         char c;
  29.         va_list arglist;
  30.         //
  31.         va_start(arglist, Format);
  32.  
  33.         //
  34.         fmtlinesize = strlen( Format );
  35.         //
  36.         if( fmtlinesize == 0 ) return;
  37.  
  38.         //
  39.         for( i = 0, j = 0; i < fmtlinesize; i++ )
  40.         {
  41.                 //
  42.                 c = Format[i];
  43.                 //
  44.                 if( c != '%' )
  45.                 {
  46.                         Str[j++] = c;
  47.                         continue;
  48.                 }
  49.                 //
  50.                 i++;
  51.                 //
  52.                 if( i >= fmtlinesize ) break;
  53.  
  54.                 //
  55.                 flag = 0;
  56.                 //
  57.                 c = Format[i];
  58.                 //
  59.                 switch( c )
  60.                 {
  61.                 //
  62.                 case '%':
  63.                         Str[j++] = c;
  64.                         break;
  65.                 // âûâîä ñòðîêè
  66.                 case 'S':
  67.                         Byte* str;
  68.                         str = va_arg(arglist, Byte*);
  69.                         for( k = 0; ( c = str[k] ) != 0; k++ )
  70.                         {
  71.                                 Str[j++] = c;
  72.                         }
  73.                         break;
  74.                 // âûâîä áàéòà
  75.                 case 'B':
  76.                         k = va_arg(arglist, int) & 0xFF;
  77.                         Str[j++] = num2hex( ( k >> 4 ) & 0xF );
  78.                         Str[j++] = num2hex( k & 0xF );
  79.                         break;
  80.                 // âûâîä ñèìâîëà
  81.                 case 'C':
  82.                         Str[j++] = va_arg(arglist, int) & 0xFF;
  83.                         break;
  84.                 // âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
  85.                 case 'X':
  86.                         Dword val;
  87.                         val = va_arg(arglist, Dword);
  88.                         for( k = 7; k >= 0; k-- )
  89.                         {
  90.                                 //
  91.                                 c = num2hex ( ( val >> (k * 4) ) & 0xF );
  92.                                 //
  93.                                 if( c == '0' )
  94.                                 {
  95.                                         if( flag ) Str[j++] = c;
  96.                                 }
  97.                                 else
  98.                                 {
  99.                                         flag++;
  100.                                         Str[j++] = c;
  101.                                 }
  102.                         }
  103.                         //
  104.                         if( flag == 0 ) Str[j++] = '0';
  105.                         break;
  106.                 // âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå
  107.                 case 'U':
  108.                         head = va_arg(arglist, Dword);
  109.                         tail = 0;
  110.                         for( k = 0; dectab[k] != 0; k++ )
  111.                         {
  112.                                 tail = head % dectab[k];
  113.                                 head /= dectab[k];
  114.                                 c = head + '0';
  115.                                 if( c == '0' )
  116.                                 {
  117.                                         if( flag ) Str[j++] = c;
  118.                                 }
  119.                                 else
  120.                                 {
  121.                                         flag++;
  122.                                         Str[j++] = c;
  123.                                 }
  124.                                 //
  125.                                 head = tail;
  126.                         }
  127.                         //
  128.                         c = head + '0';
  129.                         Str[j++] = c;
  130.                         break;
  131.                 // âåùåñòâåííîå ÷èñëî â ôîðìàòå 7.2
  132.                 case 'f':
  133.                 case 'F':
  134.                 case 'g':
  135.                 case 'G':
  136.                         {
  137.                         double val, w;
  138.                         int p;
  139.                         val = va_arg(arglist, double);
  140.                         if (val < 0.0)
  141.                         {
  142.                                 Str[j++] = '-';
  143.                                 val = -val;
  144.                         }
  145.                         for (k = 0; k < 30; k++)
  146.                                 if (val < double_tab[k])
  147.                                         break;
  148.  
  149.                         if (val < 1.0)
  150.                         {
  151.                                 Str[j++] = '0';
  152.                         }
  153.                        
  154.                         for (p = 1; p < k + 1; p++)
  155.                         {
  156.                                 int d = (int)di(val / double_tab[k - p] - HALF) % 10;
  157.                                 Str[j++] = '0' + d;
  158.                                 val -= d * double_tab[k - p];
  159.                         }
  160.                         Str[j++] = '.';
  161.                         w = 0.1;
  162.                         for (p = 0; p < PREC - 1; p++)
  163.                         {
  164.                                 val-=floor(val);
  165.                                 Str[j++] = '0' + di(val / w - HALF) % 10;
  166.                                 w /= 10.0;
  167.                         }
  168.                         }
  169.                         break;
  170.  
  171.                 // âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
  172.                 case 'Q':
  173.                         unsigned int low_dword, high_dword;
  174.                         low_dword = va_arg(arglist, unsigned int);
  175.                         high_dword = va_arg(arglist, unsigned int);
  176.                         for( k = 7; k >= 0; k-- )
  177.                         {
  178.                                 //
  179.                                 c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );
  180.                                 //
  181.                                 if( c == '0' )
  182.                                 {
  183.                                         if( flag ) Str[j++] = c;
  184.                                 }
  185.                                 else
  186.                                 {
  187.                                         flag++;
  188.                                         Str[j++] = c;
  189.                                 }
  190.                         }
  191.                         //
  192.                         for( k=7; k >= 0; k-- )
  193.                         {
  194.                                 //
  195.                                 c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );
  196.                                 //
  197.                                 if( c == '0' )
  198.                                 {
  199.                                         if( flag ) Str[j++] = c;
  200.                                 }
  201.                                 else
  202.                                 {
  203.                                         flag++;
  204.                                         Str[j++] = c;
  205.                                 }
  206.                         }
  207.                         //
  208.                         if( flag == 0 ) Str[j++] = '0';
  209.                         //
  210.                         break;
  211.                 //
  212.                 default:
  213.                         break;
  214.                 }
  215.         }
  216.         //
  217.         Str[j] = 0;
  218. }
  219.  
  220. char *ftoa(double d)
  221. {
  222.         char buffer[256], *p;
  223.         sprintf(buffer, "%f", d);
  224.         p = (char*)allocmem(strlen(buffer)+1);
  225.         strcpy(p, buffer);
  226.         return p;
  227. }
  228.  
  229.