Subversion Repositories Kolibri OS

Rev

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

  1. #include "kolibc.h"
  2. void skipspaces(FILE* file)
  3. {
  4.         int c;
  5.         while(1)
  6.         {
  7.                 c=getc(file);
  8.                 if (c!=' ' && c!='\r' && c!='\n')
  9.                 {
  10.                         ungetc(c,file);
  11.                         return;
  12.                 }
  13.         }
  14. }
  15. int fscanf(FILE* file,const char* format, ...)
  16. {
  17.         int res;
  18.         char* arg;
  19.         int i;
  20.         int c;
  21.         int contflag;
  22.         int longflag;
  23.         int sign;
  24.         long long number;
  25.         long double rnumber;
  26.         char* str;
  27.         res=0;
  28.         arg=(char*)&format;
  29.         arg+=sizeof(const char*);
  30.         while (*format!='\0')
  31.         {
  32.                 if (*format!='%')
  33.                 {
  34.                         c=fgetc(file);
  35.                         if (c!=*format)
  36.                         {
  37.                                 fungetc(c,file);
  38.                                 return -1;
  39.                         }
  40.                         format++;
  41.                         continue;
  42.                 }
  43.                 contflag=1;
  44.                 longflag=0;
  45.                 while (*format && contflag)
  46.                 {
  47.                         switch(*format)
  48.                         {
  49.                                 case '.':
  50.                                 case '0':
  51.                                 case '1':
  52.                                 case '2':
  53.                                 case '3':
  54.                                 case '4':
  55.                                 case '5':
  56.                                 case '6':
  57.                                 case '7':
  58.                                 case '8':
  59.                                 case '9':
  60.                                         format++;
  61.                                         continue;
  62.                                         break;
  63.                                 case 'l':
  64.                                         if (longflag==0)
  65.                                                 longflag=1;
  66.                                         else
  67.                                                 longflag=2;
  68.                                         format++;
  69.                                         break;
  70.                                 case 'L':
  71.                                         longflag=2;
  72.                                         format++;
  73.                                         break;
  74.                                 case 'f':
  75.                                 case 'd':
  76.                                 case 'c':
  77.                                 case 's':
  78.                                 case '%':
  79.                                         contflag=0;
  80.                                         break;
  81.                                 default:
  82.                                         contflag=0;    
  83.                         }
  84.                 }
  85.                 if (contflag)
  86.                         break;
  87.                 switch(*format)
  88.                 {
  89.                 case '%':
  90.                         c=fgetc(file);
  91.                         if (c!='%')
  92.                         {
  93.                                 ungetc(c,file);
  94.                                 return -1;
  95.                         }
  96.                         res--;
  97.                         break;
  98.                 case 'd':
  99.                         number=0;
  100.                         sign=1;
  101.                         skipspaces(file);
  102.                         c=fgetc(file);
  103.                         if (c=='-')
  104.                         {
  105.                                 sign=-1;
  106.                         }else if (c!='+')
  107.                                 ungetc(c,file);
  108.                         contflag=0;
  109.                         while(1)
  110.                         {
  111.                                 c=fgetc(file);
  112.                                 if (c>='0' && c<='9')
  113.                                 {
  114.                                         contflag++;
  115.                                         number=number*10+(c-'0');
  116.                                 }else
  117.                                         break;
  118.                         }
  119.                         ungetc(c,file);
  120.                         if (!contflag)
  121.                                 return res;
  122.                         if (longflag<=1)
  123.                         {
  124.                                 *((int*)arg)=number;
  125.                                 arg+=sizeof(int);
  126.                         }else
  127.                         {
  128.                                 *((long long*)arg)=number;
  129.                                 arg+=sizeof(long long);
  130.                         }
  131.                         break;
  132.                 case 'c':
  133.                         c=fgetc(file);
  134.                         if (c==EOF)
  135.                                 return res;
  136.                         *((char*)arg)=c;
  137.                         arg+=sizeof(char);
  138.                         break;
  139.                 case 's':
  140.                         skipspaces(file);
  141.                         contflag=0;
  142.                         str=*((char**)arg);
  143.                         arg+=sizeof(char*);
  144.                         while(1)
  145.                         {
  146.                                 c=fgetc(file);
  147.                                 if (c==EOF || c==' ' || c=='\n' || c=='\r')
  148.                                 {
  149.                                         ungetc(c,file);
  150.                                         break;
  151.                                 }
  152.                                 *str=c;
  153.                                 str++;
  154.                                 contflag++;
  155.                         }
  156.                         if (!contflag)
  157.                                 return res;
  158.                         break;
  159.                 case 'f':
  160.                         skipspaces(file);
  161.                         // TODO: read real numbers
  162.                         rnumber=0;
  163.                         switch (longflag)
  164.                         {
  165.                         case 0:
  166.                                 *((float*)arg)=rnumber;
  167.                                 arg+=sizeof(float);
  168.                                 break;
  169.                         case 1:
  170.                                 *((double*)arg)=rnumber;
  171.                                 arg+=sizeof(double);
  172.                                 break;
  173.                         case 2:
  174.                                 *((long double*)arg)=rnumber;
  175.                                 arg+=sizeof(long double);
  176.                                 break;
  177.                         default:
  178.                                 return res;
  179.                         }
  180.                         break;
  181.                 default:
  182.                         break;
  183.                 }
  184.                 format++;
  185.                 res++;
  186.         }
  187.         return res;    
  188. }
  189.