Subversion Repositories Kolibri OS

Rev

Rev 7773 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. //IO library
  2.  
  3. /*
  4.         class IO:
  5.                 io.count(path)           - êîëè÷åñòâî ôàéëîâ â äèððåêòîðèè path
  6.                 io.size(path)            - ðàçìåð (ôàéëà/ïàïêè) path
  7.                 io.run(path,param)       - çàïóñòèòü ôàéë path ñ ïàðàìåòðîì param
  8.                 io.write(size,data,path) - çàïèñàòü ôàéë ñ äàííûìè data â äèððåêòîðèþ path
  9.                 io.read(path)            - ïðî÷èòàòü ôàéë path è âîçâðàòèòü óêàçàòåëü íà äàííûå
  10.                 io.move(path1,path2)     - ïåðåìåñòèòü (ôàéë/ïàïêó) èç path1 â path2
  11.                 io.copy(path1,path2)     - êîïèðîâàòü (ôàéë/ïàïêó) èç path1 â path2
  12.                 io.set(path,attribute)   - óñòàíîâèòü àòòðèáóòû äëÿ (ôàéëà/ïàïêè)
  13.                 io.del(path)             - óäàëèòü (ôàéë/ïàïêó)
  14.                
  15.                 io.dir.load(path)        - çàãðóçèòü â áóôôåð äàííûå ïàïêè path (ñëåäóåò î÷èùàòü áóôôåð ñîìàíäîé free!!!)
  16.                 io.dir.position(number)  - âîçâðàòèòü óêàçàòåëü èìåíè ôàéëà ïî ïîçèöèè number
  17.                 io.dir.make(path)        - ñîçäàòü ïàïêó path
  18.                
  19.                 io.dir.buffer            - áóôôåð äàííûõ çàãðóæåííîé ïàïêè ô-öèåé (io.dir.load)
  20.                 io.dir.count             - êîëè÷åñòâî ôàéëîâ ôàãðóæåííîé ô-öèåé (io.count)
  21. */
  22.  
  23. #ifndef INCLUDE_IO_H
  24. #define INCLUDE_IO_H
  25.  
  26. #ifndef INCLUDE_DATE_H
  27. #include "../lib/date.h"
  28. #endif
  29.  
  30. #ifdef LANG_RUS
  31.         #define __T__GB "ƒ¡"
  32.         #define __T__MB "Œ¡"
  33.         #define __T__KB "Š¡"
  34.         #define __T___B ""
  35. #else
  36.         #define __T__GB "Gb"
  37.         #define __T__MB "Mb"
  38.         #define __T__KB "Kb"
  39.         #define __T___B "B"
  40. #endif
  41.  
  42. #define ATR_READONLY   000001b
  43. #define ATR_HIDDEN     000100b
  44. #define ATR_SYSTEM     010000b
  45.  
  46. #define ATR_NOREADONLY 000010b
  47. #define ATR_NOHIDDEN   001000b
  48. #define ATR_NOSYSTEM   100000b
  49.  
  50. :enum
  51. {
  52.         DIR_ALL,
  53.         DIR_NOROOT,
  54.         DIR_ONLYREAL
  55. };
  56.  
  57. :struct ___f70{
  58.         dword   func;
  59.         dword   param1;
  60.         dword   param2;
  61.         dword   param3;
  62.         dword   param4;
  63.         char    rezerv;
  64.         dword   name;
  65. }__file_F70;
  66.  
  67. :int ___ReadDir(dword file_count, read_buffer, dir_path)
  68. {
  69.         __file_F70.func = 1;
  70.         __file_F70.param1 =
  71.         __file_F70.param2 =
  72.         __file_F70.rezerv = 0;
  73.         __file_F70.param3 = file_count;
  74.         __file_F70.param4 = read_buffer;
  75.         __file_F70.name = io.path.path(dir_path);
  76.         $mov eax,70
  77.         $mov ebx,#__file_F70.func
  78.         $int 0x40
  79. }
  80.  
  81. :dword ___GetFileInfo(dword file_path, bdvk_struct)
  82. {    
  83.     __file_F70.func = 5;
  84.     __file_F70.param1 =
  85.     __file_F70.param2 =
  86.     __file_F70.param3 = 0;
  87.     __file_F70.param4 = bdvk_struct;
  88.     __file_F70.rezerv = 0;
  89.     __file_F70.name = io.path.path(file_path);
  90.     $mov eax,70
  91.     $mov ebx,#__file_F70.func
  92.     $int 0x40
  93. }
  94.  
  95. :struct ____BDVK {
  96.         dword   readonly:1, hidden:1, system:1, volume_label:1, isfolder:1, notarchived:1, :0;
  97.         byte    type_name;
  98.         byte    rez1, rez2, selected;
  99.         dword   timecreate;
  100.         date    datecreate;
  101.         dword   timelastaccess;
  102.         date    datelastaccess;
  103.         dword   timelastedit;
  104.         date    datelastedit;
  105.         dword   sizelo;
  106.         dword   sizehi;
  107.         char    name[518];
  108. };
  109.  
  110. :struct __FILE
  111. {
  112.         dword count;
  113.         int del(...);
  114.         int read(...);
  115.         int write(...);
  116.         dword set(...);
  117. };
  118. :dword __FILE::set(dword file_path)
  119. {    
  120.     __file_F70.func = 6;
  121.     __file_F70.param1 =
  122.     __file_F70.param2 =
  123.     __file_F70.param3 = 0;
  124.     __file_F70.param4 = #io.BDVK;
  125.     __file_F70.rezerv = 0;
  126.     __file_F70.name = io.path.path(file_path);
  127.     $mov eax,70
  128.     $mov ebx,#__file_F70.func
  129.     $int 0x40
  130. }
  131. :int __FILE::del(dword PATH)
  132. {
  133.         __file_F70.func = 8;
  134.         __file_F70.param1 =
  135.         __file_F70.param2 =
  136.         __file_F70.param3 =
  137.         __file_F70.param4 =
  138.         __file_F70.rezerv = 0;
  139.         __file_F70.name = io.path.path(PATH);
  140.         $mov eax,70
  141.         $mov ebx,#__file_F70.func
  142.         $int 0x40
  143. }
  144. :int __FILE::read(dword read_pos, read_file_size, read_buffer, read_file_path)
  145. {
  146.         __file_F70.func = 0;
  147.         __file_F70.param1 = read_pos;
  148.         __file_F70.param2 = 0;
  149.         __file_F70.param3 = read_file_size;
  150.         __file_F70.param4 = read_buffer;
  151.         __file_F70.rezerv = 0;
  152.         __file_F70.name = io.path.path(read_file_path);
  153.         $mov eax,70
  154.         $mov ebx,#__file_F70.func
  155.         $int 0x40
  156. }
  157. :int __FILE::write(dword write_offset, write_len, write_buffer, wfile_path)
  158. {
  159.         __file_F70.func = 2;
  160.         __file_F70.param1 = write_offset;
  161.         __file_F70.param2 = 0;
  162.         __file_F70.param3 = write_len;
  163.         __file_F70.param4 = write_buffer;
  164.         __file_F70.rezerv = 0;
  165.         __file_F70.name = io.path.path(wfile_path);
  166.         $mov eax,70
  167.         $mov ebx,#__file_F70.func
  168.         $int 0x40
  169. }
  170. :struct __DIR
  171. {
  172.         int make(dword name);
  173.         dword load(...);
  174.         dword position(dword i);
  175.         dword buffer;
  176.         signed count;
  177. };
  178. :dword __DIR::position(dword i)
  179. {
  180.         return i*304+buffer+72;
  181. }
  182. :int __DIR::make(dword new_folder_path)
  183. {
  184.         __file_F70.func = 9;
  185.         __file_F70.param1 =
  186.         __file_F70.param2 =
  187.         __file_F70.param3 =
  188.         __file_F70.param4 =
  189.         __file_F70.rezerv = 0;
  190.         __file_F70.name = io.path.path(new_folder_path);
  191.         $mov eax,70
  192.         $mov ebx,#__file_F70.func
  193.         $int 0x40
  194. }
  195.  
  196. :dword __DIR::load(dword PATH;byte options)
  197. {
  198.         io.count(PATH);
  199.         if(count!=-1)
  200.         {      
  201.                 buffer = malloc(count+1*304+32);
  202.                 ___ReadDir(count, buffer, PATH);
  203.                 if (options == DIR_ONLYREAL)
  204.                 {
  205.                         if (!strcmp(".",buffer+72)){count--; memmov(buffer,buffer+304,count*304);}
  206.                         if (!strcmp("..",buffer+72)){count--; memmov(buffer,buffer+304,count*304);}
  207.                         return buffer;
  208.                 }
  209.                 if (options == DIR_NOROOT)
  210.                 {
  211.                         if (!strcmp(".",buffer+72)) memmov(buffer,buffer+304,count*304-304);
  212.                         return buffer;
  213.                 }
  214.                 return buffer;
  215.         }
  216.         return NULL;
  217. }
  218.  
  219. :void get_path_name(dword BUF,PATH)
  220. {
  221.         dword beg = PATH;
  222.         dword pos = PATH;
  223.         dword sav = PATH;
  224.         dword i;
  225.         while(DSBYTE[pos])
  226.         {
  227.                 if(DSBYTE[pos]=='/')sav = pos;
  228.                 pos++;
  229.         }
  230.         i = sav-beg;
  231.         while(i)
  232.         {
  233.                 DSBYTE[BUF] = DSBYTE[beg];
  234.                 beg++;
  235.                 BUF++;
  236.                 i--;
  237.         }
  238.         DSBYTE[BUF] = 0;
  239. }
  240.  
  241. :struct __PATH
  242. {
  243.         dword file(...);
  244.         dword path(...);
  245. };
  246.  
  247. :char __PATH_NEW[4096];
  248. :dword __PATH::path(dword PATH)
  249. {
  250.         char self_dir[4096];
  251.         dword pos;
  252.        
  253.         get_path_name(#self_dir,I_Path);
  254.  
  255.         if(!PATH) return #self_dir;
  256.         pos = PATH;
  257.         if(DSBYTE[pos]=='/') || (!strncmp(PATH,"./",2))
  258.         {
  259.                 return PATH;
  260.         }
  261.         strcpy(#__PATH_NEW, #self_dir);
  262.         chrcat(#__PATH_NEW, '/');
  263.         strcpy(#__PATH_NEW, PATH);
  264.         return #__PATH_NEW;
  265. }
  266.  
  267. :dword __PATH::file(dword name)
  268. {
  269.         dword ret;
  270.         ret = name;
  271.         while(DSBYTE[name])
  272.         {
  273.                 if(DSBYTE[name]=='/')ret = name+1;
  274.                 name++;
  275.         }
  276.         return ret;
  277. }
  278.  
  279. :struct IO
  280. {
  281.         dword buffer_data;
  282.         dword size_dir;
  283.         dword count_dirs,count_files;
  284.         signed FILES_SIZE;
  285.         dword file_name;
  286.         double size(...);
  287.         dword get_size_dir(dword name);
  288.         signed count(dword path);
  289.         signed int run(dword path,param);
  290.         byte del(...);
  291.         dword read(...);
  292.         int write(...);
  293.         byte copy(...);
  294.         byte move(...);
  295.         dword set(...);
  296.         dword readKPACK(dword path1);
  297.         dword convert_size();
  298.         __DIR dir;
  299.         __PATH path;
  300.         __FILE file;
  301.         ____BDVK BDVK;
  302. }io;
  303. :byte __ConvertSize_size_prefix[8];
  304. :dword IO::convert_size()
  305. {
  306.         byte size_nm[3];
  307.         dword bytes;
  308.         bytes = FILES_SIZE;
  309.         if (bytes>=1073741824) strlcpy(#size_nm, __T__GB,2);
  310.         else if (bytes>=1048576) strlcpy(#size_nm, __T__MB,2);
  311.         else if (bytes>=1024) strlcpy(#size_nm, __T__KB,2);
  312.         else strlcpy(#size_nm, __T___B,1);
  313.         while (bytes>1023) bytes/=1024;
  314.         sprintf(#__ConvertSize_size_prefix,"%d %s",bytes,#size_nm);
  315.         return #__ConvertSize_size_prefix;
  316. }
  317. :dword IO::readKPACK(dword path1)
  318. {
  319.         EAX = 68;
  320.         EBX = 27;
  321.         ECX = path1;
  322.         $int 0x40;
  323.         FILES_SIZE = EDX;
  324.         buffer_data = EAX;
  325.         return buffer_data;
  326. }      
  327. :int IO::write(dword PATH,data)
  328. {
  329.         return file.write(0,strlen(data),data,PATH);
  330. }
  331. :char BYTE_HEAD_FILE_KPCK[4];
  332. :dword IO::read(dword PATH)
  333. {
  334.         int result;
  335.         ___GetFileInfo(PATH, #BDVK);
  336.         if(BDVK.isfolder)return false;
  337.         file.read(0,4,#BYTE_HEAD_FILE_KPCK,PATH);
  338.         IF(DSDWORD[#BYTE_HEAD_FILE_KPCK]=='KCPK')return readKPACK(PATH);
  339.         FILES_SIZE = BDVK.sizelo;
  340.         buffer_data = malloc(FILES_SIZE+1);
  341.         result = file.read(0,FILES_SIZE,buffer_data,PATH);
  342.         if (result!=0) buffer_data = free(buffer_data); //file read failed
  343.         return buffer_data;
  344. }
  345.  
  346. :signed int IO::run(dword rpath,rparam)
  347. {
  348.         __file_F70.func = 7;
  349.     __file_F70.param1 =
  350.     __file_F70.param3 =
  351.     __file_F70.param4 =
  352.     __file_F70.rezerv = 0;
  353.     __file_F70.param2 = rparam;
  354.     __file_F70.name = path.path(rpath);
  355.     $mov eax,70
  356.     $mov ebx,#__file_F70.func
  357.     $int 0x40
  358.     return EAX;
  359. }
  360. :signed IO::count(dword PATH)
  361. {
  362.         byte buf[32];
  363.         if(!___ReadDir(0, #buf, PATH))
  364.         {
  365.                 dir.count = ESDWORD[#buf+8];
  366.                 return dir.count;
  367.         }
  368.         return -1;
  369. }
  370.  
  371. :double IO::size(dword PATH)
  372. {
  373.         dword i,tmp_buf,count_dir,count_file;
  374.         dword filename;
  375.         double size_tmp;
  376.         double tmp;
  377.         if(!PATH)return 0;
  378.         if(___GetFileInfo(PATH, #BDVK))return -1;
  379.         if(BDVK.isfolder)
  380.         {
  381.                 tmp_buf = dir.load(PATH,DIR_ONLYREAL);
  382.                 if(dir.count<1)return 0;
  383.                 count_dir = dir.count;
  384.                 i = 0;
  385.                 size_tmp = 0;
  386.                 count_file = malloc(4096);
  387.                 while(i<count_dir)
  388.                 {
  389.                         filename = i*304+tmp_buf+72;
  390.                         sprintf(count_file,"%s/%s",PATH,filename);
  391.                         tmp = size(count_file);
  392.                         if(tmp==-1)return -1;
  393.                         size_tmp += tmp;
  394.                         i++;
  395.                         if (TestBit(ESDWORD[filename-40], 4))count_dirs++;
  396.                         else count_files++;
  397.                 }
  398.                
  399.                 free(tmp_buf);
  400.                 free(count_file);
  401.                 FILES_SIZE = size_tmp;
  402.                 return FILES_SIZE;
  403.         }
  404.         FILES_SIZE = BDVK.sizelo;
  405.         count_files++;
  406.         return FILES_SIZE;
  407. }
  408. :byte IO::del(dword PATH)
  409. {
  410.         dword i,tmp_buf,count_dir,count_file;
  411.         if(!PATH)return 0;
  412.         if(___GetFileInfo(PATH, #BDVK))return false;
  413.         if(BDVK.isfolder)
  414.         {
  415.                 tmp_buf = dir.load(PATH,DIR_ONLYREAL);
  416.                 count_dir = dir.count;
  417.                 i = 0;
  418.                 count_file = malloc(4096);
  419.                 while(i<count_dir)
  420.                 {
  421.                         sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
  422.                         if(!del(count_file))return false;
  423.                         i++;
  424.                 }
  425.                 free(tmp_buf);
  426.                 free(count_file);
  427.         }
  428.         file.del(PATH);
  429.         return true;
  430. }
  431. :dword IO::set(dword PATH,atr)
  432. {
  433.         dword i,tmp_buf,count_dir,count_file;
  434.         byte cmd_read,cmd_hide,cmd_system;
  435.         if(!PATH)return 0;
  436.         if(___GetFileInfo(PATH, #BDVK))return false;
  437.         cmd_read   = atr&11b;
  438.         atr>>=2;
  439.         cmd_hide   = atr&11b;
  440.         atr>>=2;
  441.         cmd_system = atr&11b;
  442.         if(BDVK.isfolder)
  443.         {
  444.                 tmp_buf = dir.load(PATH,DIR_ONLYREAL);
  445.                 count_dir = dir.count;
  446.                 i = 0;
  447.                 count_file = malloc(4096);
  448.                 while(i<count_dir)
  449.                 {
  450.                         sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
  451.                         file.set(PATH,atr);
  452.                         i++;
  453.                 }
  454.                 free(tmp_buf);
  455.                 free(count_file);
  456.                 return 0;
  457.         }
  458.         if(cmd_read)
  459.         {
  460.                 if(cmd_read&01b)BDVK.readonly = true;
  461.                 else BDVK.readonly = false;
  462.         }
  463.         if(cmd_hide)
  464.         {
  465.                 if(cmd_hide&01b)BDVK.hidden = true;
  466.                 else BDVK.hidden = false;
  467.         }
  468.         if(cmd_system)
  469.         {
  470.                 if(cmd_system&01b)BDVK.system = true;
  471.                 else BDVK.system = false;
  472.         }
  473.         file.set(PATH);
  474. }
  475. :byte IO::copy(dword PATH,PATH1)
  476. {
  477.         dword i,tmp_buf,count_dir,count_file;
  478.         dword _path_;
  479.         byte ret;
  480.         if(!PATH)return 0;
  481.         if(___GetFileInfo(PATH, #BDVK))return false;
  482.         _path_ = malloc(4096);
  483.         if(BDVK.isfolder)
  484.         {
  485.                 sprintf(_path_,"%s/%s",PATH1,path.file(PATH));
  486.                 dir.make(_path_);
  487.                 tmp_buf = dir.load(PATH,DIR_ONLYREAL);
  488.                 count_dir = dir.count;
  489.                 i = 0;
  490.                 count_file = malloc(4096);
  491.                 while(i<count_dir)
  492.                 {
  493.                         sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
  494.                         if(!copy(count_file,_path_))return false;
  495.                         i++;
  496.                 }
  497.                 free(tmp_buf);
  498.                 free(count_file);
  499.                 free(_path_);
  500.                 return true;
  501.         }
  502.         read(PATH);
  503.         sprintf(_path_,"%s/%s",PATH1,path.file(PATH));
  504.         ret = file.write(FILES_SIZE,buffer_data,_path_);
  505.         free(_path_);
  506.         if(!ret)return true;
  507.         return false;
  508. }
  509. :byte IO::move(dword PATH,PATH1)
  510. {
  511.         if(copy(PATH,PATH1))if(del(PATH))return true;
  512.         return false;
  513. }
  514.  
  515. #endif