Subversion Repositories Kolibri OS

Rev

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

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