Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include "stdio.h"
  2. const char xdigs_lower[16]="0123456789abcdef";
  3. const char xdigs_upper[16]="0123456789ABCDEF";
  4. int fprintf(FILE* file, const char* format, ...)
  5. {
  6.         void* arg;
  7.         int ispoint;
  8.         int beforepoint;
  9.         int afterpoint;
  10.         int longflag;
  11.         int contflag;
  12.         int i;
  13.         long long number;
  14.         char buffer[50];
  15.         char* str;
  16.         arg=&format;
  17.         arg+=sizeof(const char*);
  18.         while (*format!='\0')
  19.         {
  20.                 if (*format!='%')
  21.                 {
  22.                         fputc(*format,file);
  23.                         format++;
  24.                         continue;
  25.                 }
  26.                 ispoint=0;
  27.                 beforepoint=0;
  28.                 afterpoint=0;
  29.                 longflag=0;
  30.                 contflag=1;
  31.                 format++;
  32.                 while (*format && contflag)
  33.                 {
  34.                         switch (*format)
  35.                         {
  36.                         case '.':
  37.                                 ispoint=1;
  38.                                 format++;
  39.                                 break; 
  40.                         case '0':
  41.                         case '1':
  42.                         case '2':
  43.                         case '3':
  44.                         case '4':
  45.                         case '5':
  46.                         case '6':
  47.                         case '7':
  48.                         case '8':
  49.                         case '9':
  50.                                 if (ispoint)
  51.                                         afterpoint=afterpoint*10+(*format)-'0';
  52.                                 else
  53.                                         beforepoint=beforepoint*10+(*format)-'0';
  54.                                 format++;
  55.                                 break;
  56.                         case 'l':
  57.                                 if (longflag==0)
  58.                                         longflag=1;
  59.                                 else
  60.                                         longflag=2;
  61.                                 format++;
  62.                                 break;
  63.                         case 'L':
  64.                                 longflag=2;
  65.                                 format++;
  66.                                 break;
  67.                         case 'f':
  68.                         case 'd':
  69.                         case 'x':
  70.                         case 'X':
  71.                         case 'c':
  72.                         case 's':
  73.                         case '%':
  74.                                 contflag=0;
  75.                                 break;
  76.                         default:
  77.                                 contflag=0;
  78.                         }
  79.                 }
  80.                 if (contflag)
  81.                         break;
  82.                 switch (*format)
  83.                 {
  84.                 case '%':
  85.                         fpuc('%',file);
  86.                         break;
  87.                 case 'd':
  88.                         if (longflag==2)
  89.                         {
  90.                                 number=*((long long *)arg);
  91.                                 arg+=sizeof(long long);
  92.                         }else
  93.                         {
  94.                                 number=*((int*)arg);
  95.                                 arg+=sizeof(int);
  96.                         }
  97.                         if (number<0)
  98.                         {
  99.                                 beforepoint--;
  100.                                 fputc('-',file);
  101.                                 number=-number;
  102.                         }
  103.                         i=0;
  104.                         while (number>0)
  105.                         {
  106.                                 buffer[i]='0'+number%10;
  107.                                 number=number/10;
  108.                                 i++;
  109.                         }
  110.                         while (i<beforepoint)
  111.                         {
  112.                                 fputc(' ',file);
  113.                                 beforepoint--;
  114.                         }
  115.                         while (i>0)
  116.                         {
  117.                                 i--;
  118.                                 fputc(buffer[i],file);
  119.                         }
  120.                         break;
  121.                 case 'c':
  122.                         fputc(*(char*)arg,file);
  123.                         arg+=sizeof(char);
  124.                         break;
  125.                 case 's':
  126.                         str=*(char**)arg;
  127.                         arg+=sizeof(char*);
  128.                         if (beforepoint==0)
  129.                                 beforepoint--;
  130.                         while (*str && beforepoint)
  131.                         {
  132.                                 fputc(*str,file);
  133.                                 beforepoint--;
  134.                                 str++;
  135.                         }
  136.                         break;
  137.                 case 'x':
  138.                         if (longflag==2)
  139.                         {
  140.                                 number=*((long long *)arg);
  141.                                 arg+=sizeof(long long);
  142.                         }else
  143.                         {
  144.                                 number=*((int*)arg);
  145.                                 arg+=sizeof(int);
  146.                         }
  147.                         if (number<0)
  148.                         {
  149.                                 beforepoint--;
  150.                                 fputc('-',file);
  151.                                 number=-number;
  152.                         }
  153.                         i=0;
  154.                         while (number>0)
  155.                         {
  156.                                 buffer[i]=xdigs_lower[number & 15];
  157.                                 number=number>>4;
  158.                                 i++;
  159.                         }
  160.                         while (i<beforepoint)
  161.                         {
  162.                                 fputc(' ',file);
  163.                                 beforepoint--;
  164.                         }
  165.                         while (i>0)
  166.                         {
  167.                                 i--;
  168.                                 fputc(buffer[i],file);
  169.                         }
  170.                         break;
  171.                 case 'X':
  172.                         if (longflag==2)
  173.                         {
  174.                                 number=*((long long *)arg);
  175.                                 arg+=sizeof(long long);
  176.                         }else
  177.                         {
  178.                                 number=*((int*)arg);
  179.                                 arg+=sizeof(int);
  180.                         }
  181.                         if (number<0)
  182.                         {
  183.                                 beforepoint--;
  184.                                 fputc('-',file);
  185.                                 number=-number;
  186.                         }
  187.                         i=0;
  188.                         while (number>0)
  189.                         {
  190.                                 buffer[i]=xdigs_upper[number & 15];
  191.                                 number=number>>4;
  192.                                 i++;
  193.                         }
  194.                         while (i<beforepoint)
  195.                         {
  196.                                 fputc(' ',file);
  197.                                 beforepoint--;
  198.                         }
  199.                         while (i>0)
  200.                         {
  201.                                 i--;
  202.                                 fputc(buffer[i],file);
  203.                         }
  204.                         break;
  205.                 case 'f':
  206.                         if (longflag==2)
  207.                                 arg+=10;
  208.                         else if (longflag==1)
  209.                                 arg+=8;
  210.                         else
  211.                                 arg+=4;
  212.                         break;                                 
  213.                 }
  214.                 format++;
  215.         }
  216. }
  217.