Subversion Repositories Kolibri OS

Rev

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

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