forked from KolibriOS/kolibrios
496 lines
11 KiB
C++
496 lines
11 KiB
C++
//IO library
|
||
|
||
/*
|
||
class IO:
|
||
io.count(path) - êîëè÷åñòâî ôàéëîâ â äèððåêòîðèè path
|
||
io.size(path) - ðàçìåð (ôàéëà/ïàïêè) path
|
||
io.run(path,param) - çàïóñòèòü ôàéë path ñ ïàðàìåòðîì param
|
||
io.write(path,data) - çàïèñàòü ôàéë ñ äàííûìè data â äèððåêòîðèþ path
|
||
io.read(path) - ïðî÷èòàòü ôàéë path è âîçâðàòèòü óêàçàòåëü íà äàííûå
|
||
io.move(path1,path2) - ïåðåìåñòèòü (ôàéë/ïàïêó) èç path1 â path2
|
||
io.copy(path1,path2) - êîïèðîâàòü (ôàéë/ïàïêó) èç path1 â path2
|
||
io.set(path,attribute) - óñòàíîâèòü àòòðèáóòû äëÿ (ôàéëà/ïàïêè)
|
||
io.del(path) - óäàëèòü (ôàéë/ïàïêó)
|
||
|
||
io.dir.load(path) - çàãðóçèòü â áóôôåð äàííûå ïàïêè path (ñëåäóåò î÷èùàòü áóôôåð ñîìàíäîé free!!!)
|
||
io.dir.position(number) - âîçâðàòèòü óêàçàòåëü èìåíè ôàéëà ïî ïîçèöèè number
|
||
io.dir.make(path) - ñîçäàòü ïàïêó path
|
||
|
||
io.dir.buffer - áóôôåð äàííûõ çàãðóæåííîé ïàïêè ô-öèåé (io.dir.load)
|
||
io.dir.count - êîëè÷åñòâî ôàéëîâ ôàãðóæåííîé ô-öèåé (io.count)
|
||
*/
|
||
|
||
#ifndef INCLUDE_IO_H
|
||
#define INCLUDE_IO_H
|
||
#print "[include <io.h>]\n"
|
||
|
||
#ifndef INCLUDE_DATE_H
|
||
#include "../lib/date.h"
|
||
#endif
|
||
|
||
#ifdef LANG_RUS
|
||
#define __T__GB "ƒ¡"
|
||
#define __T__MB "Œ¡"
|
||
#define __T__KB "Š¡"
|
||
#define __T___B "<22>"
|
||
#else
|
||
#define __T__GB "Gb"
|
||
#define __T__MB "Mb"
|
||
#define __T__KB "Kb"
|
||
#define __T___B "B"
|
||
#endif
|
||
|
||
#define ATR_READONLY 000001b
|
||
#define ATR_HIDDEN 000100b
|
||
#define ATR_SYSTEM 010000b
|
||
|
||
#define ATR_NOREADONLY 000010b
|
||
#define ATR_NOHIDDEN 001000b
|
||
#define ATR_NOSYSTEM 100000b
|
||
|
||
:enum
|
||
{
|
||
DIR_ALL,
|
||
DIR_NOROOT,
|
||
DIR_ONLYREAL
|
||
};
|
||
|
||
:struct ___f70{
|
||
dword func;
|
||
dword param1;
|
||
dword param2;
|
||
dword param3;
|
||
dword param4;
|
||
char rezerv;
|
||
dword name;
|
||
}__file_F70;
|
||
|
||
:int ___ReadDir(dword file_count, read_buffer, dir_path)
|
||
{
|
||
__file_F70.func = 1;
|
||
__file_F70.param1 =
|
||
__file_F70.param2 =
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.param3 = file_count;
|
||
__file_F70.param4 = read_buffer;
|
||
__file_F70.name = io.path.path(dir_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
|
||
:dword ___GetFileInfo(dword file_path, bdvk_struct)
|
||
{
|
||
__file_F70.func = 5;
|
||
__file_F70.param1 =
|
||
__file_F70.param2 =
|
||
__file_F70.param3 = 0;
|
||
__file_F70.param4 = bdvk_struct;
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(file_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
|
||
:struct ____BDVK {
|
||
dword readonly:1, hidden:1, system:1, volume_label:1, isfolder:1, notarchived:1, :0;
|
||
byte type_name;
|
||
byte rez1, rez2, selected;
|
||
dword timecreate;
|
||
date datecreate;
|
||
dword timelastaccess;
|
||
date datelastaccess;
|
||
dword timelastedit;
|
||
date datelastedit;
|
||
dword sizelo;
|
||
dword sizehi;
|
||
char name[518];
|
||
};
|
||
|
||
:struct __FILE
|
||
{
|
||
dword count;
|
||
int del(...);
|
||
int read(...);
|
||
int write(...);
|
||
dword set(...);
|
||
};
|
||
:dword __FILE::set(dword file_path)
|
||
{
|
||
__file_F70.func = 6;
|
||
__file_F70.param1 =
|
||
__file_F70.param2 =
|
||
__file_F70.param3 = 0;
|
||
__file_F70.param4 = #io.BDVK;
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(file_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
:int __FILE::del(dword PATH)
|
||
{
|
||
__file_F70.func = 8;
|
||
__file_F70.param1 =
|
||
__file_F70.param2 =
|
||
__file_F70.param3 =
|
||
__file_F70.param4 =
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(PATH);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
:int __FILE::read(dword read_pos, read_file_size, read_buffer, read_file_path)
|
||
{
|
||
__file_F70.func = 0;
|
||
__file_F70.param1 = read_pos;
|
||
__file_F70.param2 = 0;
|
||
__file_F70.param3 = read_file_size;
|
||
__file_F70.param4 = read_buffer;
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(read_file_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
:int __FILE::write(dword write_file_size, write_buffer, write_file_path)
|
||
{
|
||
__file_F70.func = 2;
|
||
__file_F70.param1 = 0;
|
||
__file_F70.param2 = 0;
|
||
__file_F70.param3 = write_file_size;
|
||
__file_F70.param4 = write_buffer;
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(write_file_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
:struct __DIR
|
||
{
|
||
int make(dword name);
|
||
dword load(...);
|
||
dword position(dword i);
|
||
dword buffer;
|
||
signed count;
|
||
};
|
||
:dword __DIR::position(dword i)
|
||
{
|
||
return i*304+buffer+72;
|
||
}
|
||
:int __DIR::make(dword new_folder_path)
|
||
{
|
||
__file_F70.func = 9;
|
||
__file_F70.param1 =
|
||
__file_F70.param2 =
|
||
__file_F70.param3 =
|
||
__file_F70.param4 =
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.name = io.path.path(new_folder_path);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
|
||
:dword __DIR::load(dword PATH;byte options)
|
||
{
|
||
io.count(PATH);
|
||
if(count!=-1)
|
||
{
|
||
buffer = malloc(count+1*304+32);
|
||
___ReadDir(count, buffer, PATH);
|
||
if (options == DIR_ONLYREAL)
|
||
{
|
||
if (!strcmp(".",buffer+72)){count--; memmov(buffer,buffer+304,count*304);}
|
||
if (!strcmp("..",buffer+72)){count--; memmov(buffer,buffer+304,count*304);}
|
||
return buffer;
|
||
}
|
||
if (options == DIR_NOROOT)
|
||
{
|
||
if (!strcmp(".",buffer+72)) memmov(buffer,buffer+304,count*304-304);
|
||
return buffer;
|
||
}
|
||
return buffer;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
:struct __PATH
|
||
{
|
||
dword file(...);
|
||
dword path(...);
|
||
};
|
||
|
||
:char __PATH_NEW[4096];
|
||
:dword __PATH::path(dword PATH)
|
||
{
|
||
dword pos;
|
||
if(!PATH) return self.dir;
|
||
pos = PATH;
|
||
if(DSBYTE[pos]=='/')
|
||
{
|
||
pos++;
|
||
if(!strncmp(pos,"sys/",4)) return PATH;
|
||
if(!strncmp(pos,"kolibrios/",10)) return PATH;
|
||
if(!strncmp(pos,"hd/",3)) return PATH;
|
||
if(!strncmp(pos,"fd/",3)) return PATH;
|
||
if(!strncmp(pos,"rd/",3)) return PATH;
|
||
if(!strncmp(pos,"tmp/",4)) return PATH;
|
||
if(!strncmp(pos,"cd/",3)) return PATH;
|
||
if(!strncmp(pos,"bd/",3)) return PATH;
|
||
if(!strncmp(pos,"usbhd/",6)) return PATH;
|
||
if(!strncmp(pos,"kolibrios/",10)) return PATH;
|
||
sprintf(#__PATH_NEW,"/sys%s",PATH);
|
||
return #__PATH_NEW;
|
||
}
|
||
if(!strncmp(PATH,"./",2)) return PATH;
|
||
sprintf(#__PATH_NEW,"%s/%s",self.dir,PATH);
|
||
return #__PATH_NEW;
|
||
}
|
||
|
||
:dword __PATH::file(dword name)
|
||
{
|
||
dword ret;
|
||
ret = name;
|
||
while(DSBYTE[name])
|
||
{
|
||
if(DSBYTE[name]=='/')ret = name+1;
|
||
name++;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
:struct IO
|
||
{
|
||
dword buffer_data;
|
||
dword size_dir;
|
||
dword count_dirs,count_files;
|
||
signed FILES_SIZE;
|
||
dword file_name;
|
||
double size(...);
|
||
dword get_size_dir(dword name);
|
||
signed count(dword path);
|
||
signed int run(dword path,param);
|
||
byte del(...);
|
||
dword read(...);
|
||
int write(...);
|
||
byte copy(...);
|
||
byte move(...);
|
||
dword set(...);
|
||
dword readKPACK(dword path1);
|
||
dword convert_size();
|
||
__DIR dir;
|
||
__PATH path;
|
||
__FILE file;
|
||
____BDVK BDVK;
|
||
}io;
|
||
:dword IO::readKPACK(dword path1)
|
||
{
|
||
dword sizes;
|
||
EAX = 68;
|
||
EBX = 27;
|
||
ECX = path.path(path1);
|
||
EDX = sizes;
|
||
$int 0x40;
|
||
return EAX;
|
||
}
|
||
:byte __ConvertSize_size_prefix[8];
|
||
:dword IO::convert_size()
|
||
{
|
||
byte size_nm[3];
|
||
dword bytes;
|
||
bytes = FILES_SIZE;
|
||
if (bytes>=1073741824) strlcpy(#size_nm, __T__GB,2);
|
||
else if (bytes>=1048576) strlcpy(#size_nm, __T__MB,2);
|
||
else if (bytes>=1024) strlcpy(#size_nm, __T__KB,2);
|
||
else strlcpy(#size_nm, __T___B,1);
|
||
while (bytes>1023) bytes/=1024;
|
||
sprintf(#__ConvertSize_size_prefix,"%d %s",bytes,#size_nm);
|
||
return #__ConvertSize_size_prefix;
|
||
}
|
||
|
||
:int IO::write(dword PATH,data)
|
||
{
|
||
file.write(0,strlen(data),data,PATH);
|
||
}
|
||
:dword IO::read(dword PATH)
|
||
{
|
||
___GetFileInfo(PATH, #BDVK);
|
||
if(BDVK.isfolder)return 0;
|
||
FILES_SIZE = BDVK.sizelo;
|
||
buffer_data = malloc(FILES_SIZE+1);
|
||
file.read(0,FILES_SIZE,buffer_data,PATH);
|
||
return buffer_data;
|
||
}
|
||
|
||
:signed int IO::run(dword rpath,rparam)
|
||
{
|
||
__file_F70.func = 7;
|
||
__file_F70.param1 =
|
||
__file_F70.param3 =
|
||
__file_F70.param4 =
|
||
__file_F70.rezerv = 0;
|
||
__file_F70.param2 = rparam;
|
||
__file_F70.name = path.path(rpath);
|
||
$mov eax,70
|
||
$mov ebx,#__file_F70.func
|
||
$int 0x40
|
||
}
|
||
:signed IO::count(dword PATH)
|
||
{
|
||
byte buf[32];
|
||
if(!___ReadDir(0, #buf, PATH))
|
||
{
|
||
dir.count = ESDWORD[#buf+8];
|
||
return dir.count;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
:double IO::size(dword PATH)
|
||
{
|
||
dword i,tmp_buf,count_dir,count_file;
|
||
dword filename;
|
||
double size_tmp;
|
||
double tmp;
|
||
if(!PATH)return 0;
|
||
if(___GetFileInfo(PATH, #BDVK))return -1;
|
||
if(BDVK.isfolder)
|
||
{
|
||
tmp_buf = dir.load(PATH,DIR_ONLYREAL);
|
||
if(dir.count<1)return 0;
|
||
count_dir = dir.count;
|
||
i = 0;
|
||
size_tmp = 0;
|
||
count_file = malloc(4096);
|
||
while(i<count_dir)
|
||
{
|
||
filename = i*304+tmp_buf+72;
|
||
sprintf(count_file,"%s/%s",PATH,filename);
|
||
tmp = size(count_file);
|
||
if(tmp==-1)return -1;
|
||
size_tmp += tmp;
|
||
i++;
|
||
if (TestBit(ESDWORD[filename-40], 4))count_dirs++;
|
||
else count_files++;
|
||
}
|
||
|
||
free(tmp_buf);
|
||
free(count_file);
|
||
FILES_SIZE = size_tmp;
|
||
return FILES_SIZE;
|
||
}
|
||
FILES_SIZE = BDVK.sizelo;
|
||
count_files++;
|
||
return FILES_SIZE;
|
||
}
|
||
:byte IO::del(dword PATH)
|
||
{
|
||
dword i,tmp_buf,count_dir,count_file;
|
||
if(!PATH)return 0;
|
||
if(___GetFileInfo(PATH, #BDVK))return false;
|
||
if(BDVK.isfolder)
|
||
{
|
||
tmp_buf = dir.load(PATH,DIR_ONLYREAL);
|
||
count_dir = dir.count;
|
||
i = 0;
|
||
count_file = malloc(4096);
|
||
while(i<count_dir)
|
||
{
|
||
sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
|
||
if(!del(count_file))return false;
|
||
i++;
|
||
}
|
||
free(tmp_buf);
|
||
free(count_file);
|
||
}
|
||
file.del(PATH);
|
||
return true;
|
||
}
|
||
:dword IO::set(dword PATH,atr)
|
||
{
|
||
dword i,tmp_buf,count_dir,count_file;
|
||
byte cmd_read,cmd_hide,cmd_system;
|
||
if(!PATH)return 0;
|
||
if(___GetFileInfo(PATH, #BDVK))return false;
|
||
cmd_read = atr&11b;
|
||
atr>>=2;
|
||
cmd_hide = atr&11b;
|
||
atr>>=2;
|
||
cmd_system = atr&11b;
|
||
if(BDVK.isfolder)
|
||
{
|
||
tmp_buf = dir.load(PATH,DIR_ONLYREAL);
|
||
count_dir = dir.count;
|
||
i = 0;
|
||
count_file = malloc(4096);
|
||
while(i<count_dir)
|
||
{
|
||
sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
|
||
file.set(PATH,atr);
|
||
i++;
|
||
}
|
||
free(tmp_buf);
|
||
free(count_file);
|
||
return 0;
|
||
}
|
||
if(cmd_read)
|
||
{
|
||
if(cmd_read&01b)BDVK.readonly = true;
|
||
else BDVK.readonly = false;
|
||
}
|
||
if(cmd_hide)
|
||
{
|
||
if(cmd_hide&01b)BDVK.hidden = true;
|
||
else BDVK.hidden = false;
|
||
}
|
||
if(cmd_system)
|
||
{
|
||
if(cmd_system&01b)BDVK.system = true;
|
||
else BDVK.system = false;
|
||
}
|
||
file.set(PATH);
|
||
}
|
||
:byte IO::copy(dword PATH,PATH1)
|
||
{
|
||
dword i,tmp_buf,count_dir,count_file;
|
||
dword _path_;
|
||
byte ret;
|
||
if(!PATH)return 0;
|
||
if(___GetFileInfo(PATH, #BDVK))return false;
|
||
_path_ = malloc(4096);
|
||
if(BDVK.isfolder)
|
||
{
|
||
sprintf(_path_,"%s/%s",PATH1,path.file(PATH));
|
||
dir.make(_path_);
|
||
tmp_buf = dir.load(PATH,DIR_ONLYREAL);
|
||
count_dir = dir.count;
|
||
i = 0;
|
||
count_file = malloc(4096);
|
||
while(i<count_dir)
|
||
{
|
||
sprintf(count_file,"%s/%s",PATH,i*304+tmp_buf+72);
|
||
if(!copy(count_file,_path_))return false;
|
||
i++;
|
||
}
|
||
free(tmp_buf);
|
||
free(count_file);
|
||
free(_path_);
|
||
return true;
|
||
}
|
||
read(PATH);
|
||
sprintf(_path_,"%s/%s",PATH1,path.file(PATH));
|
||
ret = file.write(FILES_SIZE,buffer_data,_path_);
|
||
free(_path_);
|
||
if(!ret)return true;
|
||
return false;
|
||
}
|
||
:byte IO::move(dword PATH,PATH1)
|
||
{
|
||
if(copy(PATH,PATH1))if(del(PATH))return true;
|
||
return false;
|
||
}
|
||
|
||
#endif |