WebSVN – Kolibri OS – Diff – /programs/cmm/lib/io.h


//IO library
 
/*
	class IO:
		io.count(path)           - êîëè÷åñòâî ôàéëîâ â äèððåêòîðèè path
		io.size(path)            - ðàçìåð (ôàéëà/ïàïêè) path
		io.run(path,param)       - çàïóñòèòü ôàéë path ñ ïàðàìåòðîì param
		io.write(size,data,path) - çàïèñàòü ôàéë ñ äàííûìè 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
 
#ifndef INCLUDE_DATE_H
#include "../lib/date.h"
#endif
 
#ifdef LANG_RUS
	#define __T__GB "¡"
	#define __T__MB "¡"
	#define __T__KB "¡"
	#define __T___B ""
#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;
}
 
:void get_path_name(dword BUF,PATH)
{
	dword beg = PATH;
	dword pos = PATH;
	dword sav = PATH;
	dword i;
	while(DSBYTE[pos])
	{
		if(DSBYTE[pos]=='/')sav = pos;
		pos++;
	}
	i = sav-beg;
	while(i)
	{
		DSBYTE[BUF] = DSBYTE[beg];
		beg++;
		BUF++;
		i--;
	}
	DSBYTE[BUF] = 0;
}
 
:struct __PATH
{
	dword file(...);
	dword path(...);
};
 
:char __PATH_NEW[4096];
:dword __PATH::path(dword PATH)
{
	char self_dir[4096];
	dword pos;
	
	get_path_name(#self_dir,I_Path);
 
	if(!PATH) return #self_dir;
	pos = PATH;
	if(DSBYTE[pos]=='/') || (!strncmp(PATH,"./",2))
	{
		return PATH;
	}
	strcpy(#__PATH_NEW, #self_dir);
	chrcat(#__PATH_NEW, '/');
	strcpy(#__PATH_NEW, 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;
: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;
}
:dword IO::readKPACK(dword path1)
{
	EAX = 68;
	EBX = 27;
	ECX = path1;
	$int 0x40;
	FILES_SIZE = EDX;
	buffer_data = EAX;
	return buffer_data;
}	
:int IO::write(dword PATH,data)
{
	file.write(0,strlen(data),data,PATH);
}
:char BYTE_HEAD_FILE_KPCK[4];
:dword IO::read(dword PATH)
{
	int result;
	___GetFileInfo(PATH, #BDVK);
	if(BDVK.isfolder)return false;
	file.read(0,4,#BYTE_HEAD_FILE_KPCK,PATH);
	IF(DSDWORD[#BYTE_HEAD_FILE_KPCK]=='KCPK')return readKPACK(PATH);
	FILES_SIZE = BDVK.sizelo;
	buffer_data = malloc(FILES_SIZE+1);
	result = file.read(0,FILES_SIZE,buffer_data,PATH);
	if (result!=0) buffer_data = free(buffer_data);	//file read failed
	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
		{
			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
		{
			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
		{
			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
		{
			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
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/io.h – Rev 7768 → 7773