Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. #include "kolibri.h"
  3. #include <string.h>
  4. #include <malloc.h>
  5. #include "kolibc.h"
  6.  
  7. extern char *__appcwd;
  8. extern int __appcwdlen;
  9.  
  10. char* getfullpath(char* path)
  11. {
  12.     int prev_is_slash=0;
  13.     int len=0, depth=0, i;
  14.     char* buff;
  15.     char c;
  16.    
  17.     len= __appcwdlen;
  18.    
  19.     buff = (char*)malloc(len+strlen(path)+1);
  20.     strncpy(buff, __appcwd, __appcwdlen);
  21.    
  22.     if(*path == '/')
  23.     { buff[0] = '\0';
  24.       len=0;
  25.     }  
  26.     else
  27.     {
  28.       prev_is_slash = 1;
  29.       buff[len] = 0;
  30.       for(i=0; buff[i]; i++)
  31.         if(buff[i] == '/' && i < len-1) depth++;
  32.     }
  33.    
  34.     while(c=*path++)
  35.     {
  36.       switch (c)
  37.       {
  38.      
  39.         case '.':
  40.           if((*path == '.')&&
  41.              (*path+1)== '/')
  42.           { if(!depth)
  43.             {  free(buff);
  44.                return 0;
  45.             };
  46.             buff[len-1] = 0;
  47.             len = strrchr(buff, '/') + 1 - buff;
  48.             buff[len] = 0;
  49.             depth--;
  50.             path +=2;
  51.             prev_is_slash = 1;
  52.             continue;
  53.           }
  54.           if(*path == '/')
  55.           {
  56.             path++;
  57.             prev_is_slash = 1;
  58.             continue;
  59.           }
  60.           buff[len++] = c;
  61.           continue;
  62.      
  63.         case '/':
  64.           prev_is_slash = 1;
  65.           buff[len++] = c;
  66.           continue;
  67.          
  68.         default:
  69.           prev_is_slash = 0;
  70.           buff[len++] = c;
  71.           continue;
  72.         };
  73.     };
  74.     buff[len]= '\0';
  75.     return buff;
  76. }
  77.  
  78. FILE* fopen(const char* filename, const char *mode)
  79. {
  80.     FILEINFO fileinfo;
  81.         FILE* res;
  82.     char *path;
  83.         int err;
  84.         int imode;
  85.     size_t bytes;
  86.    
  87.     imode=0;
  88.     if (*mode=='r')
  89.     {
  90.       imode=FILE_OPEN_READ;    
  91.        mode++;
  92.     }
  93.     else
  94.     if (*mode=='w')
  95.     {
  96.       imode=FILE_OPEN_WRITE;
  97.        mode++;
  98.     }
  99.     else
  100.     if (*mode=='a')
  101.     {
  102.       imode=FILE_OPEN_APPEND;
  103.       mode++;
  104.     }
  105.     else
  106.       return 0;
  107.     if (*mode=='t')
  108.     {
  109.       imode|=FILE_OPEN_TEXT;
  110.       mode++;
  111.     }
  112.     else
  113.     if (*mode=='b')
  114.       mode++;
  115.     if (*mode=='+')
  116.     {
  117.        imode|=FILE_OPEN_PLUS;
  118.        mode++;
  119.     }
  120.     if (*mode!=0)
  121.        return 0;
  122.        
  123.     path= getfullpath(filename);
  124.     err=get_fileinfo(path, &fileinfo);
  125.     if(err)
  126.     {
  127.       if ((imode & 7)== 0)
  128.       { free(path);
  129.         return 0;
  130.       };
  131.   //    err=_msys_create_file(path);
  132.       if (err)
  133.       {  free(path);
  134.          return 0;
  135.       }
  136.       fileinfo.size=0;
  137.     };
  138.                
  139.     res=(FILE*)malloc(sizeof(FILE));
  140.     if(!res)
  141.     { free(path);
  142.       return 0;
  143.     };
  144.  
  145.     res->buffer=UserAlloc(8192);
  146.     res->stream=res->buffer;
  147.     res->strpos=0;
  148.     res->remain=8192;
  149.     res->buffersize=8192;
  150.     res->filesize=fileinfo.size;
  151.     res->filename=path;
  152.     res->mode=imode;
  153.        
  154.     if (imode & FILE_OPEN_APPEND)
  155.     { size_t bytes;
  156.       res->strpos= res->filesize & 8191;
  157.       if (res->strpos)    //not align
  158.       {
  159.         res->filepos=res->filesize & -8192; // align buffer
  160.         res->remain=8192-res->strpos;      
  161.         err=read_file(res->filename,res->buffer,
  162.                       res->filesize,res->remain,&bytes);
  163.         res->stream=res->buffer+res->strpos;
  164.       };
  165.     }  
  166.     else
  167.     { size_t bytes;
  168.    
  169.        err=read_file(res->filename,res->buffer,
  170.                     0,8192,&bytes);
  171.        res->filepos=0;
  172.     };
  173.     return res;
  174. }
  175.  
  176. size_t FileSize(FILE *handle)
  177. {
  178.   return handle->filesize;
  179.  
  180. }
  181.