Subversion Repositories Kolibri OS

Rev

Rev 5276 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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