source code library

git-svn-id: svn://kolibrios.org@5936 a494cfbc-eb01-0410-851d-a64ba20cac60

programs/develop/libraries/libs_v2/array.bat

@@ -0,0 +1 @@
+build.bat %~n0

programs/develop/libraries/libs_v2/array.c

@@ -0,0 +1,244 @@
+/*
+	2015
+	Author: Pavel Yakovlev.
+*/
+
+#define LIB_NAME "array"
+
+#include "coff.h"
+
+#include <string.c>
+#include <stdlib.c>
+
+typedef struct
+{
+	dword key;
+	dword value;
+} array;
+
+char *ARRAY_KEY_STRING = (char *)0;
+char *ARRAY_VALUE_STRING = (char *)0;
+array *ARRAY_ADRESS = (dword)0;
+
+dword hash_binary(char *data,dword size)
+{
+	byte h1,h2,h3,h4;
+	if(!size) return 0;
+	h1 = *data;
+	if(size==1) return h1<<24;
+	h2 = *++data;
+	if(size==2) return (h1<<24)|(h2<<16);
+	h3 = *++data;
+	if(size==3) return (h1<<24)|(h2<<16)|(h3<<8);
+	h4 = *++data;
+	if(size==4) return (h1<<24)|(h2<<16)|(h3<<8)|(h4);
+	
+	size-=4;
+	
+	while(size--)
+	{
+		h1^=*data;h2^=*data;h3^=*data;h4^=*data;
+		++data;
+	}
+	
+	return (h1<<24)|(h2<<16)|(h3<<8)|(h4);
+}
+dword hash_string(char *data)
+{
+	byte h1,h2,h3,h4;
+	if(!*data) return 0;
+	h1 = *data;
+	if(!*++data) return h1<<24;
+	h2 = *data;
+	if(!*++data) return (h1<<24)|(h2<<16);
+	h3 = *data;
+	if(!*++data) return (h1<<24)|(h2<<16)|(h3<<8);
+	h4 = *data;
+	if(!*++data) return (h1<<24)|(h2<<16)|(h3<<8)|(h4);
+	
+	while(*data)
+	{
+		h1^=*data;h2^=*data;h3^=*data;h4^=*data;
+		++data;
+	}
+	
+	return (h1<<24)|(h2<<16)|(h3<<8)|(h4);
+}
+
+dword hash_integer(dword dec)
+{
+	dword tmp = dec;
+	tmp <<= 16;
+	tmp ^= 0xFFFFFFFF;
+	dec &= tmp;
+	dec ^= dec>>5;
+	dec += dec<<3;
+	dec ^= dec>>13;
+	tmp = dec<<9;
+	tmp ^= 0xFFFFFFFF;
+	dec += tmp;
+	dec ^= dec>>17;
+	return dec;
+}
+
+dword buffer = 0xFF;
+dword ARRAY_COUNT = 0;
+dword tmp,tmp1;
+
+array *key_string_set(dword *ary,char *key,void *data)
+{
+	//dword *ptr = (dword *)ary;
+	array *m;
+	if(!*ary)
+	{
+		*ary = (dword)malloc(sizeof(array)*(buffer+1));
+		m = (array *)*ary;
+		m[0].value = buffer;
+	}
+	
+	else
+	{
+		m = (array *)*ary;
+		if(m[0].value<=m[0].key)
+		{
+			m[0].value += buffer;
+			*ary = (dword)realloc((void*)*ary,sizeof(array)*(m[0].value+1));
+		}
+	}
+	
+	++m[0].key;
+	
+	dword tmp = hash_string(key)%buffer;
+	tmp+=(m[0].value/buffer)*buffer;
+	++tmp;
+	
+	while(m[tmp].key)
+	{
+		if(!strcmp(key,(char*)m[tmp].key))break;
+		++tmp;
+	}
+	m[tmp].key = (dword)key;
+	m[tmp].value = (dword)data;
+	return m;
+}
+
+array *key_binary_set(dword *ary,void *key,void *data,dword size)
+{
+	
+	array *m;
+	if(!*ary)
+	{
+		*ary = (dword)malloc(sizeof(array)*(buffer+1));
+		m = (array *)*ary;
+		m[0].value = buffer+1;
+	}
+	else
+	{
+		m = (array *)*ary;
+	}
+	
+	++m[0].key;
+	
+	dword tmp = hash_string(key)%buffer;
+	++tmp;
+	while(m[tmp].key)
+	{
+		if(!strncmp((char*)key,(char*)m[tmp].key,size))break;
+		++tmp;
+	}
+	m[tmp].key = (dword)key;
+	m[tmp].value = (dword)data;
+	return m;
+}
+
+array *key_integer_set(dword *ary,dword key,void *data)
+{
+	
+	
+	if(!*ary)
+	{
+		//(dword)m[0].value = (dword)buffer;
+		*ary = (dword)malloc(sizeof(array)*(buffer+1));
+	}
+	
+	array *m = (array *)*ary;
+	
+	dword tmp = hash_integer(key)%buffer;
+	
+	while(m[tmp].key)
+	{
+		if(key==m[tmp].key)break;
+		++tmp;
+	}
+	m[tmp].key = (dword)key;
+	m[tmp].value = (dword)data;
+	return m;
+}
+
+
+void *key_string_get(dword *ary,char *key)
+{
+	if(!*ary)return 0;
+	
+	array *m = (array *)*ary;
+	
+	dword tmp = hash_string(key)%buffer;
+	tmp+=(m[0].value/buffer)*buffer;
+	++tmp;
+	while(m[tmp].key)
+	{
+		if(!strcmp(key,(char*)m[tmp].key))break;
+		++tmp;
+	}
+	return (void *)m[tmp].value;
+}
+
+void *key_binary_get(dword *ary,char *key,dword size)
+{
+	if(!*ary)return 0;
+	
+	array *m = (array *)*ary;
+	
+	dword tmp = hash_string(key)%buffer;
+	
+	while(m[tmp].key)
+	{
+		if(!strncmp(key,(char*)m[tmp].key,size))break;
+		++tmp;
+	}
+	return (void *)m[tmp].value;
+}
+
+void *key_integer_get(dword *ary,dword key)
+{
+	if(!*ary)return 0;
+	
+	array *m = (array *)*ary;
+	
+	dword tmp = hash_integer(key)%buffer;
+	
+	while(m[tmp].key)
+	{
+		if(key==m[tmp].key)break;
+		++tmp;
+	}
+	return (void *)m[tmp].value;
+}
+
+
+EXPORT_
+	export(buffer)
+	
+	export(hash_string)
+	export(hash_binary)
+	export(hash_integer)
+	
+	export(key_string_set)
+	export(key_binary_set)
+	export(key_integer_set)
+	
+	export(key_string_get)
+	export(key_binary_get)
+	export(key_integer_get)
+	
+_EXPORT

programs/develop/libraries/libs_v2/build.bat

@@ -0,0 +1,10 @@
+set FILE_NAME=%1
+set DIR_LIB=C:\Programs\KlbrInWin\LIB
+
+del "%FILE_NAME%.obj"
+gcc -w --target=alpha-coff -nostdlib -I"./include" --prefix=/opt/cross-gcc -c -o "%FILE_NAME%.obj" "%FILE_NAME%.c"
+kpack %FILE_NAME%.obj
+@echo off
+copy "%FILE_NAME%.obj" "%DIR_LIB%\%FILE_NAME%.obj">Nul
+
+pause

programs/develop/libraries/libs_v2/coff.h

@@ -0,0 +1,45 @@
+/*
+	2015
+	Author: Pavel Yakovlev.
+*/
+
+typedef struct
+{
+	void	*name;
+	void	*function;
+} export_t;
+
+typedef unsigned long long qword;
+typedef unsigned int dword;
+typedef unsigned char byte;
+typedef unsigned short word;
+
+#define NULL ((void*)0)
+
+#define quotess(name) #name
+
+#ifdef NO_LIBIMPORT_FUNC
+	#define EXPORT_ export_t EXPORTS[]={
+#else
+	#define EXPORT_ export_t EXPORTS[]={{"lib_pointer_library",&lib_pointer_library},
+#endif
+
+
+#define export(name) {LIB_NAME "." quotess(name),&name},
+#define _EXPORT { NULL, NULL }};
+
+#ifndef NO_LIBIMPORT_FUNC
+static struct LIBDLL_STRUCT
+{
+	int (*load)(char *path);
+	dword (*get)(char *name);
+};
+
+static inline struct LIBDLL_STRUCT library;
+
+static void lib_pointer_library(dword adr1,dword adr2)
+{
+	library.load = adr1;
+	library.get = adr2;
+}
+#endif

programs/develop/libraries/libs_v2/fs.bat

@@ -0,0 +1 @@
+build.bat %~n0

programs/develop/libraries/libs_v2/fs.c

@@ -0,0 +1,897 @@
+/*
+	2015
+	Author: Pavel Yakovlev.
+*/
+
+#define LIB_NAME "fs"
+
+#include "coff.h"
+#include <kolibri.c>
+#include <stdlib.c>
+
+
+//char _PATH_[4096];
+char *_PATH_;
+dword *_ADR_ = 32;
+char *FS_SELF_PATH;
+char *FS_SELF_DIR=0;
+
+char TMP1[4096] = {0};
+char TMP2[4096] = {0};
+
+static void*(* _stdcall pointer_callback_copy)(void);
+static void*(* _stdcall pointer_callback_move)(void);
+static void*(* _stdcall pointer_callback_remove)(void);
+
+#pragma pack(push,1)
+typedef struct 
+{
+unsigned	p00;
+unsigned	p04;
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+char		p20;
+char		*p21;
+} FS_struct70;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct
+{
+unsigned	p00;
+char		p04;
+char		p05[3];
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+unsigned	p20;
+unsigned	p24;
+unsigned	p28;
+//unsigned	p32[2];
+long long p32;
+unsigned	p40;
+} FS_struct_BDVK;
+#pragma pack(pop)
+
+#define FS_COPY_BUFFER_SET 0x100000
+static inline char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
+
+static inline char *string_error_code(char code)
+{
+	if(!code)return "Successfully!";
+	if(code==1)return "Not defined basis and / or hard disk partition (sub-functions 7, 8 function 21)!";
+	if(code==2)return "Function is not supported for this file system!";
+	if(code==3)return "Unknown file system!";
+	if(code==4)return "Reserved, never returned to the current implementation!";
+	if(code==5)return "File not found!";
+	if(code==6)return "The file is ended!";
+	if(code==7)return "Pointer out the application memory!";
+	if(code==8)return "Disk is full!";
+	if(code==9)return "FAT table is destroyed!";
+	if(code==10)return "Access is denied!";
+	if(code==11)return "Device error!";
+	return "An unexpected error!";
+}
+
+static inline dword sprintf(char *mstr,const char *fmt,...)
+{
+	
+	dword *arg = &fmt;
+	char *tmp = 0;
+	char *pos = mstr;
+	--pos;
+	--fmt;
+	while(*++fmt)
+	{
+		char s = *fmt;
+		if(s=='%')
+		{
+			s = *++fmt;
+			if(s=='s')
+			{
+				tmp = *++arg;
+				while(*tmp)*++pos = *tmp++;
+			}
+			else
+			{
+				*++pos='%';
+				--fmt;
+			}
+		}
+		else *++pos=s;
+	}
+	*++pos = 0;
+	return pos-mstr;
+}
+
+static inline int FS_file_70(FS_struct70 *k)
+{
+	asm volatile ("int $0x40"::"a"(70), "b"(k));
+}
+
+FS_struct_BDVK ret_struct;
+static inline char get_bdvk(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 5;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = (unsigned)&ret_struct;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	return FS_file_70(&file_read_struct);
+	//return (FS_struct_BDVK*)&ret_struct;
+}
+
+static inline char set_bdvk(char *path,FS_struct_BDVK *bdvk)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 6;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = bdvk;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	return FS_file_70(&file_read_struct);
+}
+
+static inline long long file_size(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	return data->p32;
+}
+
+static inline byte file_isdir(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	if(data->p00&0b10000)return 1;
+	return 0;
+}
+
+static inline byte file_ismetka(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	if(data->p00&0b1000)return 1;
+	return 0;
+}
+
+static inline byte file_isfile()
+{
+	//FS_struct_BDVK *data =  get_bdvk(path);
+	if(ret_struct.p00&0b11000)return 0;
+	return 1;
+}
+
+static inline int file_run(char *path,char *arg)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 7;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = arg;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	return FS_file_70(&file_read_struct);
+	
+}
+
+static inline int file_read_binary(char *path,unsigned pos,unsigned size,void *adr)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 0;
+	file_read_struct.p04 = pos;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = (unsigned)adr;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error read file (%s) file: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_delete(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 8;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error delete file: %s. Info: %s'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_mkdir(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 9;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error make dir: %s. Info: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_write(char *path,void *ukaz,dword size)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 2;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = ukaz;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error write file: %s. Info: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_rewrite(char *path,dword pos1,dword pos2,void *ukaz,dword size)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 3;
+	file_read_struct.p04 = pos1;
+	file_read_struct.p08 = pos2;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = ukaz;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error rewrite file (%s) file: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,&BUF_COPY,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET;
+	dword ost = size-cel*FS_COPY_BUFFER_SET;
+	long long i = 0;
+	char err=0;
+	if(cel)
+	{
+		if(file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
+		if(file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
+		++i;
+	}
+	else
+	{
+		if(file_read_binary(path1,0,ost,&BUF_COPY))goto ERROR;
+		if(file_write(path2,&BUF_COPY,ost))goto ERROR;
+		return 1;
+	}
+	while(i<cel)
+	{
+		if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
+		if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
+		++i;
+	}
+	if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY))goto ERROR;
+	if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost))goto ERROR;
+	return 1;
+	ERROR:
+	
+	//asm("":"=a"(err));
+	//sprintf(&BUF_COPY,"Error %s file: %s.",string_error_code(err),path1);
+	//file_run("/sys/@notify",&BUF_COPY);
+	return 0;
+}
+
+/*
+dword FS_COPY_BUFFER_SET_POINT = 0x100000;
+dword BUF_COPY_POINT = 0;
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,BUF_COPY_POINT,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET_POINT;
+	dword ost = size-cel*FS_COPY_BUFFER_SET_POINT;
+	long long i = 0;
+	char err=0;
+	if(cel)
+	{
+		if(file_read_binary(path1,0,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
+		if(file_write(path2,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
+		++i;
+	}
+	else
+	{
+		if(file_read_binary(path1,0,ost,BUF_COPY_POINT))goto ERROR;
+		if(file_write(path2,BUF_COPY_POINT,ost))goto ERROR;
+		return 1;
+	}
+	while(i<cel)
+	{
+		if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
+		if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
+		++i;
+	}
+	if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,ost,BUF_COPY_POINT))goto ERROR;
+	if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,ost))goto ERROR;
+	return 1;
+	ERROR:
+	
+	//asm("":"=a"(err));
+	//sprintf(BUF_COPY_POINT,"Error %s file: %s.",string_error_code(err),path1);
+	//file_run("/sys/@notify",BUF_COPY_POINT);
+	return 0;
+}
+*/
+/*
+#define FS_COPY_BUFFER_SET 0x100000
+char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,&BUF_COPY,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET;
+	dword ost = size-cel*FS_COPY_BUFFER_SET;
+	long long i = 0;
+	
+	if(cel)
+	{
+		file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY);
+		file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET);
+		++i;
+	}
+	else
+	{
+		file_read_binary(path1,0,ost,&BUF_COPY);
+		file_write(path2,&BUF_COPY,ost);
+		return 1;
+	}
+	while(i<cel)
+	{
+		file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY);
+		file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET);
+		++i;
+	}
+	file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY);
+	file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost);
+	return 1;
+}
+*/
+long long size_long_file=0;
+
+static inline void *file_read(char *path)
+{
+	size_long_file = file_size(path);
+	void *data = malloc(size_long_file+1);
+	
+	if(file_read_binary(path,0,size_long_file,data))return 0;
+	
+	return data;
+}
+
+static inline void *file_readKPACK(char *path)
+{
+	void *data = 0;
+	dword size=0;
+	asm ("int $0x40":"=a"(data),"=d"(size):"a"(68), "b"(27), "c"(path));
+	size_long_file = size;
+	asm volatile(""::"c"(size));
+	return data;
+}
+
+static inline int file_read_dir(dword begin,dword file_count,dword read_buffer,char *dir_path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 1;
+	file_read_struct.p04 = begin;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = file_count;
+	file_read_struct.p16 = read_buffer;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = dir_path;
+	return FS_file_70(&file_read_struct);
+}
+
+
+static inline byte strncmp(char *s1,const char *s2, dword n)
+{
+	while(n)
+	{
+		if(*s1!=*s2)return *s1-*s2;
+		++s1;
+		++s2;
+		--n;
+	}
+	return 0;
+}
+
+char *strdup(char *str)
+{
+	char *r = malloc(strlen(str));
+	strcpy(r,str);
+	return r;
+}
+
+char *self_get_dir(void)
+{
+	if(!FS_SELF_DIR)
+	{
+		FS_SELF_DIR = malloc(4096);
+		//FS_SELF_PATH = malloc(4096);
+		//strcpy(FS_SELF_PATH,*_ADR_);
+		FS_SELF_PATH = *_ADR_;
+		int pos=0;
+		int tmp=0;
+
+		while(FS_SELF_PATH[pos])
+		{
+			FS_SELF_DIR[pos] = FS_SELF_PATH[pos];
+			if(FS_SELF_PATH[pos]=='/')tmp = pos;
+			++pos;
+		}
+		if(tmp)pos=tmp;
+		FS_SELF_DIR[pos]=0;
+	}
+	return FS_SELF_DIR;
+}
+
+
+char *get_full_path(char *path)
+{
+	self_get_dir();
+	if(!path) return FS_SELF_DIR;
+	char *pos = path;
+	if(!_PATH_) _PATH_ = malloc(4096);
+	if(*pos=='/')
+	{
+		++pos;
+		if(!strncmp(pos,"sys/",4)) return path;
+		if(!strncmp(pos,"kolibrios/",10)) return path;
+		if(!strncmp(pos,"rd/",3)) return path;
+		if(!strncmp(pos,"fd/",3)) return path;
+		if(!strncmp(pos,"cd",2)) return path;
+		if(!strncmp(pos,"hd",2)) return path;
+		if(!strncmp(pos,"bd",2)) return path;
+		if(!strncmp(pos,"tmp",3)) return path;
+		if(!strncmp(pos,"usbhd",5)) return path;
+		if(!*pos)return path;
+		strcpy(_PATH_,"/sys");
+		strcpy(_PATH_+4,path);
+		return _PATH_;
+	}
+	if(!strncmp(path,"./",2)) return path;
+	sprintf(_PATH_,"%s/%s",FS_SELF_DIR,path);
+	return _PATH_;
+}
+
+long long FS_LENGHT=0;
+
+dword *__BUF__COUNT__ = 0;
+int COUNT_FILE = 0;
+int _get_entries_count(char *path)
+{
+	//char BUF[32];
+	if(!__BUF__COUNT__)__BUF__COUNT__=malloc(32);
+	if(!file_read_dir(0,0, __BUF__COUNT__, path))
+	{
+		if(strcmp(path,"/"))COUNT_FILE = *(__BUF__COUNT__+2)-2;
+		else COUNT_FILE = *(__BUF__COUNT__+2);
+		return COUNT_FILE;
+	}
+	COUNT_FILE = -1;
+	return -1;
+}
+
+int get_entries_count(char *path)
+{
+	return _get_entries_count(get_full_path(path));
+}
+
+dword _get_dir_info(char *path)
+{
+	_get_entries_count(path);
+	if(!strcmp(path,"/"))
+	{
+		if(COUNT_FILE==-1)return 0;
+		dword buffer = malloc(304*COUNT_FILE+72);
+		file_read_dir(0,COUNT_FILE,buffer,path);
+		return buffer;
+	}
+	if(COUNT_FILE==-1)return 0;
+	dword buffer = malloc(304*COUNT_FILE+72);
+	file_read_dir(2,COUNT_FILE+2,buffer,path);
+	return buffer;
+}
+
+dword get_dir_info(char *path)
+{
+	return _get_dir_info(get_full_path(path));
+}
+
+dword get_dir_position(dword a,dword i)
+{
+	return i*344+32+a;
+}
+
+char *get_file_name(void *args)
+{
+	return args+40;
+}
+
+char BUF_HEADER[5]={0};
+dword read(char *path)
+{
+	dword *adr = &BUF_HEADER;
+	path = get_full_path(path);
+	file_read_binary(path,0,4,adr);
+	if(*adr=='KCPK') return file_readKPACK(path);
+	dword ret = file_read(path);
+	//FS_LENGHT = size_long_file;
+	asm volatile(""::"c"((long)size_long_file));
+	return ret;
+}
+
+
+dword quantity_dir = 0,quantity_file = 0;
+long long fs_size_global = 0;
+long long LOOP_SIZE(char *path)
+{
+	dword tmp_len = file_size(path);
+	if(ret_struct.p00&0b10000)
+	{
+		++quantity_dir;
+		dword tmp_buf = get_dir_info(path);
+		if(COUNT_FILE<1) return 0;
+		
+		char *new_path_file = malloc(4096);
+		int tmp_count = COUNT_FILE;
+		int i = 0;
+		fs_size_global = 0;
+		while(i<tmp_count)
+		{
+			sprintf(new_path_file,"%s/%s",path,304*i+tmp_buf+72);
+			fs_size_global += LOOP_SIZE(new_path_file);
+			++i;
+		}
+		free(tmp_buf);
+		free(new_path_file);
+		return fs_size_global;
+	}
+	++quantity_file;
+	return tmp_len;
+}
+
+dword get_size(char *path)
+{
+	quantity_dir = 0;
+	quantity_file = 0;
+	long long size = LOOP_SIZE(get_full_path(path));
+	if(quantity_dir>0)--quantity_dir;
+	asm volatile(""::"c"(quantity_dir),"d"(quantity_file));
+	return (dword)size;
+}
+
+/*
+char set_attributes_loop(char *path,dword strucs)
+{
+	if(get_bdvk(path))return 0;
+	dword tmp = (ret_struct.p00^strucs)&0b111;
+	ret_struct.p00=(tmp^ret_struct.p00)^0xFFFFFFFF;
+	if(ret_struct.p00&0b10000)
+	{
+		dword tmp_buf = _get_dir_info(path);
+		if(!COUNT_FILE) goto END;
+		
+		char *new_path_file = malloc(4096);
+		int tmp_count = COUNT_FILE;
+		int i = 0;
+		char *position = tmp_buf+72;
+		while(i<tmp_count)
+		{	
+			sprintf(new_path_file,"%s/%s",path,position);
+			position+=304;
+			if(!set_attributes_loop(new_path_file,strucs))
+			{
+				free(tmp_buf);
+				free(new_path_file);
+				return 0;
+			}
+			++i;
+		}
+		free(new_path_file);
+		END:
+		free(tmp_buf);
+	}
+	if(set_bdvk(path,&ret_struct))return 0;
+	return 1;
+}
+
+char set_attributes(char *path,dword strucs,char cmd)
+{
+	if(cmd)return set_attributes_loop(get_full_path(path),strucs);
+	
+}
+*/
+
+char remove_loop(char *path)
+{
+	if(get_bdvk(path))return 0;
+	if(ret_struct.p00&0b10000)
+	{
+		dword tmp_buf = _get_dir_info(path);
+		if(!COUNT_FILE) goto END;
+		
+		char *new_path_file = malloc(4096);
+		int tmp_count = COUNT_FILE;
+		int i = 0;
+		char *position = tmp_buf+72;
+		while(i<tmp_count)
+		{	
+			sprintf(new_path_file,"%s/%s",path,position);
+			position+=304;
+			if(!remove_loop(new_path_file))
+			{
+				free(tmp_buf);
+				free(new_path_file);
+				return 0;
+			}
+			++i;
+		}
+		free(new_path_file);
+		END:
+		free(tmp_buf);
+	}
+	if(file_delete(path))return 0;
+	return 1;
+}
+
+char remove(char *path)
+{
+	return remove_loop(get_full_path(path));
+}
+
+int make_dir(char *path)
+{
+	return file_mkdir(get_full_path(path));
+}
+
+char copy_loop(char *path1,char *path2)
+{
+	if(get_bdvk(path1))return 0;
+	if(ret_struct.p00&0b10000)
+	{
+		file_mkdir(path2);
+		set_bdvk(path2,&ret_struct);
+		dword tmp_buf = _get_dir_info(path1);
+		if(!COUNT_FILE) goto END;
+		
+		char *new_path_file1 = malloc(4096);
+		char *new_path_file2 = malloc(4096);
+		int tmp_count = COUNT_FILE;
+		int i = 0;
+		dword position = tmp_buf+72;
+		while(i<tmp_count)
+		{
+			sprintf(new_path_file1,"%s/%s",path1,position);
+			sprintf(new_path_file2,"%s/%s",path2,position);
+			if(pointer_callback_copy)
+			{
+				asm volatile(""::"c"(new_path_file1),"d"(new_path_file2));
+				pointer_callback_copy();
+			}
+			position+=304;
+			if(!copy_loop(new_path_file1,new_path_file2))
+			{
+				free(tmp_buf);
+				free(new_path_file1);
+				free(new_path_file2);
+				return 0;
+			}
+			++i;
+		}
+		free(new_path_file1);
+		free(new_path_file2);
+		END:
+		free(tmp_buf);
+		return 1;
+	}
+	char r = file_copy(path1,path2);
+	set_bdvk(path2,&ret_struct);
+	return r;
+}
+
+char copy(char *path1,char *path2)
+{
+	char *tmp = get_full_path(path1);
+	path1 = malloc(4096);
+	strcpy(path1,tmp);
+	
+	char *r=copy_loop(path1,get_full_path(path2));
+	
+	free(path1);
+	return r;
+}
+
+char move_loop(char *path1,char *path2)
+{
+	if(get_bdvk(path1))return 0;
+	if(ret_struct.p00&0b10000)
+	{
+		file_mkdir(path2);
+		set_bdvk(path2,&ret_struct);
+		dword tmp_buf = _get_dir_info(path1);
+		if(!COUNT_FILE) goto END;
+		
+		char *new_path_file1 = malloc(4096);
+		char *new_path_file2 = malloc(4096);
+		int tmp_count = COUNT_FILE;
+		int i = 0;
+		dword position = tmp_buf+72;
+		while(i<tmp_count)
+		{
+			sprintf(new_path_file1,"%s/%s",path1,position);
+			sprintf(new_path_file2,"%s/%s",path2,position);
+			if(pointer_callback_move)
+			{
+				asm volatile(""::"c"(new_path_file1),"d"(new_path_file2));
+				pointer_callback_copy();
+			}
+			position+=304;
+			if(!move_loop(new_path_file1,new_path_file2))
+			{
+				free(tmp_buf);
+				free(new_path_file1);
+				free(new_path_file2);
+				return 0;
+			}
+			++i;
+		}
+		free(new_path_file1);
+		free(new_path_file2);
+		END:
+		free(tmp_buf);
+		if(file_delete(path1)) return 0;
+		return 1;
+	}
+	char r = 0;
+	if(file_copy(path1,path2)) if(!file_delete(path1))r=1;
+	if(r)set_bdvk(path2,&ret_struct);
+	return r;
+}
+
+
+char move(char *path1,char *path2)
+{
+	char *tmp = get_full_path(path1);
+	path1 = malloc(4096);
+	strcpy(path1,tmp);
+	
+	char *r=move_loop(path1,get_full_path(path2));
+	
+	free(path1);
+	return r;
+}
+
+char write(char *path,void *data,dword size)
+{
+	if(file_write(get_full_path(path),data,size))return 0;
+	return 1;
+}
+
+dword execute(char *path,char *arg)
+{
+	return file_run(get_full_path(path),arg);
+}
+
+dword open(char *path)
+{
+	return file_run("/sys/@open",get_full_path(path));
+}
+
+char rename(char *path,char *new_name)
+{
+	if(!strcmp(path,new_name))return 0;
+	char *pos = path;
+	char *pos1 = &TMP1;
+	char *tmp = 0;
+	while(*pos)
+	{
+		*pos1=*pos;
+		if(*pos=='/')
+		{
+			if(*++pos)tmp = pos1;
+		}
+		else ++pos;
+		++pos1;
+	}
+	if(tmp)
+	{
+		while(*new_name)*++tmp = *new_name++;
+		*++tmp = 0;
+		return move(path,&TMP1);
+	}
+	return move(path,new_name);
+}
+
+char callback_copy(char *path1,char *path2,dword func)
+{
+	pointer_callback_copy = func;
+	return copy(path1,path2);
+}
+
+char callback_move(char *path1,char *path2,dword func)
+{
+	pointer_callback_move = func;
+	return move(path1,path2);
+}
+
+char callback_remove(char *path,dword func)
+{
+	pointer_callback_remove = func;
+	return remove(path);
+}
+
+char *version = "Ver. 1.3, Author:Pavel Yakovlev, http://vk.com/pavelyakov39";
+
+EXPORT_
+	export(execute)
+	export(open)
+	export(read)
+	export(write)
+	export(copy)
+	export(move)
+	export(remove)
+	export(rename)
+	export(get_size)
+	//export(set_attributes)
+	export(get_entries_count)
+	export(get_dir_info)
+	export(get_dir_position)
+	export(get_file_name)
+	
+	export(get_full_path)
+	
+	export(make_dir)
+	
+	export(callback_copy)
+	export(callback_move)
+	export(callback_remove)
+	
+	export(pointer_callback_copy)
+	export(pointer_callback_move)
+	export(pointer_callback_remove)
+	
+	export(version)
+_EXPORT

programs/develop/libraries/libs_v2/include/all.h

@@ -0,0 +1,18 @@
+
+/// ===========================================================
+
+#ifndef AUTOBUILD
+// autobuild does not create lang.h, but defines LANG_{RUS,ENG} directly
+
+#endif
+
+#include "boolean.c"
+#include "kolibri.c"
+#include "stdlib.c"
+#include "string.c"
+#include "ctype.c"
+
+#include "console.c"
+
+
+/// ===========================================================

programs/develop/libraries/libs_v2/include/array.h

@@ -0,0 +1,24 @@
+typedef struct
+{
+	dword key;
+	dword value;
+} array_data;
+
+typedef struct 
+{
+	array_data *(* key_string_set)(char *);
+	void *(* key_string_get)(char *,array_data *);
+} ARRAY;
+
+
+ARRAY array;
+
+char _init_array_ = 0;
+void init_array(void)
+{
+	if(_init_array_) return;
+	library.load("/sys/lib/array.obj");
+	array.key_string_set = library.get("array.key_string_set");
+	array.key_string_get = library.get("array.key_string_get");
+	_init_array_ = 1;
+}

programs/develop/libraries/libs_v2/include/boolean.c

@@ -0,0 +1,3 @@
+
+#define FALSE 0
+#define TRUE 1

programs/develop/libraries/libs_v2/include/console.c

@@ -0,0 +1,117 @@
+
+///===========================
+
+#define CON_COLOR_BLUE		1
+#define CON_COLOR_GREEN		2
+#define CON_COLOR_RED		4
+#define CON_COLOR_BRIGHT	8
+/* öâåò ôîíà */
+#define CON_BGR_BLUE		0x10
+#define CON_BGR_GREEN		0x20
+#define CON_BGR_RED			0x40
+#define CON_BGR_BRIGHT		0x80
+
+///===========================
+char console_init_command = FALSE;
+static inline void (* _stdcall con_init)(unsigned w_w, unsigned w_h, unsigned s_w, unsigned s_h, const char* t);
+static inline void (* _cdecl _printf)(const char* format,...);
+static inline void (* _stdcall _print)(const char* text);
+static inline void (* _stdcall _exit)(char bCloseWindow);
+static inline void (* __stdcall _gets)(char* str, int n);
+static inline int (* __stdcall _getch)(void);
+static inline int (* __stdcall con_get_font_height)(void);
+static inline int (* __stdcall con_set_cursor_height)(int new_height);
+unsigned (*__stdcall con_get_flags)(void);
+unsigned (*__stdcall con_set_flags)(unsigned new_flags);
+static inline void (*__stdcall con_cls)(void);
+
+///===========================
+
+static inline void print(const char *text)
+{
+	_print(text);
+}
+
+char _buf_gets[255];
+static inline char *gets(void)
+{
+	CONSOLE_INIT("console");
+	_gets(&_buf_gets,255);
+	return &_buf_gets;
+}
+static inline char getch(void)
+{
+	CONSOLE_INIT("console");
+	_getch();
+}
+
+static inline void CONSOLE_INIT(char title[])
+{
+
+if(console_init_command)return;
+
+struct_import *imp;
+
+imp = cofflib_load("/sys/lib/console.obj");
+if (imp == NULL)
+	exit();
+
+con_init = ( _stdcall  void (*)(unsigned, unsigned, unsigned, unsigned, const char*)) 
+		cofflib_procload (imp, "con_init");
+if (con_init == NULL)
+	exit();
+
+_printf = ( _cdecl void (*)(const char*,...))
+		cofflib_procload (imp, "con_printf");
+if (_printf == NULL)
+	exit();
+	
+_print = ( _cdecl void (*)(const char*))
+		cofflib_procload (imp, "con_write_asciiz");
+if (_printf == NULL)
+	exit();
+
+_exit = ( _stdcall void (*)(char))
+		cofflib_procload (imp, "con_exit");
+if (_exit == NULL)
+	exit();
+
+_gets = ( _stdcall void (*)(char*, int))
+		cofflib_procload (imp, "con_gets");
+if (_gets == NULL)
+	exit();
+
+_getch = ( _stdcall int (*)(void))
+		cofflib_procload (imp, "con_getch2");
+if (_getch == NULL)
+	exit();
+
+con_get_font_height = ( _stdcall int (*)(void))
+		cofflib_procload (imp, "con_get_font_height");
+if (con_get_font_height == NULL)
+	exit();
+
+con_set_cursor_height = ( _stdcall int (*)(int))
+		cofflib_procload (imp, "con_set_cursor_height");
+if (con_set_cursor_height == NULL)
+	exit();
+
+con_get_flags = ( _stdcall unsigned (*)(void))
+		cofflib_procload (imp, "con_get_flags");
+if (con_get_flags == NULL)
+	exit();
+
+con_set_flags = ( _stdcall unsigned (*)(unsigned))
+		cofflib_procload (imp, "con_set_flags");
+if (con_set_flags == NULL)
+	exit();
+
+con_cls = ( _stdcall void (*)(void))
+		cofflib_procload (imp, "con_cls");
+if (con_cls == NULL)
+	exit();
+
+con_init(-1, -1, -1, -1, title);
+
+console_init_command = TRUE;
+}

programs/develop/libraries/libs_v2/include/ctype.c

@@ -0,0 +1,39 @@
+
+#include "ctype.h"
+
+static inline int toupper(int c)
+{
+
+if ( (c >= 97) && (c <= 122) )
+	return c-32 ;
+
+if ( (c >= 160) && (c <= 175) )
+	return c-32 ;
+
+if ( (c >= 224) && (c <= 239) )
+	return c-80 ;
+
+if ( (c == 241) || (c == 243) || (c == 245) || (c == 247) )
+	return c-1;
+
+return c;
+}
+
+static inline int tolower(int c)
+{
+
+if ( (c >= 65) && (c <= 90) )
+	return c+32 ;
+
+if ( (c >= 128) && (c <= 143) )
+	return c+32 ;
+
+if ( (c >= 144) && (c <= 159) )
+	return c+80 ;
+
+if ( (c == 240) || (c == 242) || (c == 244) || (c == 246) )
+	return c+1;
+
+return c;
+}
+

programs/develop/libraries/libs_v2/include/font.h

@@ -0,0 +1,13 @@
+
+:typedef struct
+{
+	char (*load)(char *path);
+} _FONT_;
+_FONT_ font;
+
+static inline font_lib_init(void)
+{
+	if(font.load)return;
+	library.load("/sys/lib/font.obj");
+	font.load = library.get("font.load");
+}

programs/develop/libraries/libs_v2/include/fs.c

@@ -0,0 +1,394 @@
+#ifndef FS_C_INCLUDE
+#define FS_C_INCLUDE
+
+#include "stdlib.c"
+
+#pragma pack(push,1)
+typedef struct 
+{
+unsigned	p00;
+unsigned	p04;
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+char		p20;
+char		*p21;
+} FS_struct70;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct
+{
+unsigned	p00;
+char		p04;
+char		p05[3];
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+unsigned	p20;
+unsigned	p24;
+unsigned	p28;
+//unsigned	p32[2];
+long long p32;
+unsigned	p40;
+} FS_struct_BDVK;
+#pragma pack(pop)
+
+#define FS_COPY_BUFFER_SET 0x100000
+static inline char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
+
+static inline char *string_error_code(char code)
+{
+	if(!code)return "Successfully!";
+	if(code==1)return "Not defined basis and / or hard disk partition (sub-functions 7, 8 function 21)!";
+	if(code==2)return "Function is not supported for this file system!";
+	if(code==3)return "Unknown file system!";
+	if(code==4)return "Reserved, never returned to the current implementation!";
+	if(code==5)return "File not found!";
+	if(code==6)return "The file is ended!";
+	if(code==7)return "Pointer out the application memory!";
+	if(code==8)return "Disk is full!";
+	if(code==9)return "FAT table is destroyed!";
+	if(code==10)return "Access is denied!";
+	if(code==11)return "Device error!";
+	return "An unexpected error!";
+}
+
+static inline dword sprintf(char *mstr,const char *fmt,...)
+{
+	
+	dword *arg = &fmt;
+	char *tmp = 0;
+	char *pos = mstr;
+	--pos;
+	--fmt;
+	while(*++fmt)
+	{
+		char s = *fmt;
+		if(s=='%')
+		{
+			s = *++fmt;
+			if(s=='s')
+			{
+				tmp = *++arg;
+				while(*tmp)*++pos = *tmp++;
+			}
+			else
+			{
+				*++pos='%';
+				--fmt;
+			}
+		}
+		else *++pos=s;
+	}
+	*++pos = 0;
+	return pos-mstr;
+}
+
+static inline int FS_file_70(FS_struct70 *k)
+{
+	asm volatile ("int $0x40"::"a"(70), "b"(k));
+}
+
+FS_struct_BDVK ret_struct;
+static inline FS_struct_BDVK* get_bdvk(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 5;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = (unsigned)&ret_struct;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	FS_file_70(&file_read_struct);
+	return (FS_struct_BDVK*)&ret_struct;
+}
+
+static inline long long file_size(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	return data->p32;
+}
+
+static inline byte file_isdir(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	if(data->p00&0b10000)return 1;
+	return 0;
+}
+
+static inline byte file_ismetka(char *path)
+{
+	FS_struct_BDVK *data =  get_bdvk(path);
+	if(data->p00&0b1000)return 1;
+	return 0;
+}
+
+static inline byte file_isfile()
+{
+	//FS_struct_BDVK *data =  get_bdvk(path);
+	if(ret_struct.p00&0b11000)return 0;
+	return 1;
+}
+
+static inline int file_run(char *path,char *arg)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 7;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = arg;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	return FS_file_70(&file_read_struct);
+	
+}
+
+static inline int file_read_binary(char *path,unsigned pos,unsigned size,void *adr)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 0;
+	file_read_struct.p04 = pos;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = (unsigned)adr;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error read file (%s) file: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_delete(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 8;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error delete file: %s. Info: %s'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_mkdir(char *path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 9;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = 0;
+	file_read_struct.p16 = 0;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error make dir: %s. Info: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_write(char *path,void *ukaz,dword size)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 2;
+	file_read_struct.p04 = 0;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = ukaz;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error write file: %s. Info: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+static inline int file_rewrite(char *path,dword pos1,dword pos2,void *ukaz,dword size)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 3;
+	file_read_struct.p04 = pos1;
+	file_read_struct.p08 = pos2;
+	file_read_struct.p12 = size;
+	file_read_struct.p16 = ukaz;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = path;
+	char c = FS_file_70(&file_read_struct);
+	if(c)
+	{
+		sprintf(&BUF_COPY,"'Error rewrite file (%s) file: %s.'E",string_error_code(c),path);
+		file_run("/sys/@notify",&BUF_COPY);
+	}
+	return c;
+}
+
+
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,&BUF_COPY,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET;
+	dword ost = size-cel*FS_COPY_BUFFER_SET;
+	long long i = 0;
+	char err=0;
+	if(cel)
+	{
+		if(file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
+		if(file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
+		++i;
+	}
+	else
+	{
+		if(file_read_binary(path1,0,ost,&BUF_COPY))goto ERROR;
+		if(file_write(path2,&BUF_COPY,ost))goto ERROR;
+		return 1;
+	}
+	while(i<cel)
+	{
+		if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
+		if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
+		++i;
+	}
+	if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY))goto ERROR;
+	if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost))goto ERROR;
+	return 1;
+	ERROR:
+	
+	//asm("":"=a"(err));
+	//sprintf(&BUF_COPY,"Error %s file: %s.",string_error_code(err),path1);
+	//file_run("/sys/@notify",&BUF_COPY);
+	return 0;
+}
+
+/*
+dword FS_COPY_BUFFER_SET_POINT = 0x100000;
+dword BUF_COPY_POINT = 0;
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,BUF_COPY_POINT,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET_POINT;
+	dword ost = size-cel*FS_COPY_BUFFER_SET_POINT;
+	long long i = 0;
+	char err=0;
+	if(cel)
+	{
+		if(file_read_binary(path1,0,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
+		if(file_write(path2,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
+		++i;
+	}
+	else
+	{
+		if(file_read_binary(path1,0,ost,BUF_COPY_POINT))goto ERROR;
+		if(file_write(path2,BUF_COPY_POINT,ost))goto ERROR;
+		return 1;
+	}
+	while(i<cel)
+	{
+		if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
+		if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
+		++i;
+	}
+	if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,ost,BUF_COPY_POINT))goto ERROR;
+	if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,ost))goto ERROR;
+	return 1;
+	ERROR:
+	
+	//asm("":"=a"(err));
+	//sprintf(BUF_COPY_POINT,"Error %s file: %s.",string_error_code(err),path1);
+	//file_run("/sys/@notify",BUF_COPY_POINT);
+	return 0;
+}
+*/
+/*
+#define FS_COPY_BUFFER_SET 0x100000
+char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
+static inline char file_copy(char *path1,char *path2)
+{
+	long long size = file_size(path1);
+	if(!size)file_write(path2,&BUF_COPY,0);
+	long long cel = size;
+	cel /= FS_COPY_BUFFER_SET;
+	dword ost = size-cel*FS_COPY_BUFFER_SET;
+	long long i = 0;
+	
+	if(cel)
+	{
+		file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY);
+		file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET);
+		++i;
+	}
+	else
+	{
+		file_read_binary(path1,0,ost,&BUF_COPY);
+		file_write(path2,&BUF_COPY,ost);
+		return 1;
+	}
+	while(i<cel)
+	{
+		file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY);
+		file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET);
+		++i;
+	}
+	file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY);
+	file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost);
+	return 1;
+}
+*/
+long long size_long_file=0;
+
+static inline void *file_read(char *path)
+{
+	size_long_file = file_size(path);
+	void *data = malloc(size_long_file+1);
+	
+	if(file_read_binary(path,0,size_long_file,data))return 0;
+	
+	return data;
+}
+
+static inline void *file_readKPACK(char *path)
+{
+	void *data = 0;
+	dword size=0;
+	asm ("int $0x40":"=a"(data),"=d"(size):"a"(68), "b"(27), "c"(path));
+	size_long_file = size;
+	asm volatile(""::"c"(size));
+	return data;
+}
+
+static inline int file_read_dir(dword begin,dword file_count,dword read_buffer,char *dir_path)
+{
+	FS_struct70 file_read_struct;
+	file_read_struct.p00 = 1;
+	file_read_struct.p04 = begin;
+	file_read_struct.p08 = 0;
+	file_read_struct.p12 = file_count;
+	file_read_struct.p16 = read_buffer;
+	file_read_struct.p20 = 0;
+	file_read_struct.p21 = dir_path;
+	return FS_file_70(&file_read_struct);
+}
+
+#endif

programs/develop/libraries/libs_v2/include/fs.h

@@ -0,0 +1,23 @@
+
+static struct FS
+{
+	void *(*read)(char *path);
+};
+
+
+void *(* _stdcall _ptr_fs_read_)(char *path);
+
+char _init_fs_ = 0;
+void init_fs(void)
+{
+	if(_init_fs_) return;
+	library.load("/sys/lib/fs.obj");
+	_ptr_fs_read_ = library.get("fs.read");
+	_init_fs_ = 1;
+}
+
+static inline dword _FS__READ_(char *name)
+{
+	return _ptr_fs_read_(name);
+}
+struct FS fs = {&_FS__READ_};

programs/develop/libraries/libs_v2/include/kolibri.c

@@ -0,0 +1,525 @@
+#ifndef KOLIBRI_INCLUDE
+#define KOLIBRI_INCLUDE
+
+#define NULL ((void*)0)
+
+#define SHM_OPEN		0
+#define SHM_OPEN_ALWAYS	0x04
+#define SHM_CREATE		0x08 
+#define SHM_READ		0x00 
+#define SHM_WRITE		0x01
+
+#define E_NOTFOUND	5 
+#define E_ACCESS	10 
+#define E_NOMEM		30 
+#define E_PARAM		33
+
+#define evReDraw  1
+#define evKey     2
+#define evButton  3
+#define evDesktop 5
+#define evMouse   6
+#define evIPC     7
+#define evNetwork 8
+#define evDebug   9
+
+#pragma pack(push,1)
+typedef struct 
+{
+unsigned	p00;
+unsigned	p04;
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+char		p20;
+char		*p21;
+} struct70;
+#pragma pack(pop)
+
+
+#pragma pack(push,1)
+typedef struct
+{
+unsigned	p00;
+char		p04;
+char		p05[3];
+unsigned	p08;
+unsigned	p12;
+unsigned	p16;
+unsigned	p20;
+unsigned	p24;
+unsigned	p28;
+unsigned	p32[2];
+unsigned	p40;
+} struct_BDVK;
+#pragma pack(pop)
+
+
+#pragma pack(push,1)
+typedef struct
+{
+char	*name;
+void	*data;
+} struct_import;
+#pragma pack(pop)
+
+#include "string.c"
+
+
+extern char PATH[256];
+extern char PARAM[256];
+extern char DIR[256];
+
+
+static inline void exit()
+{
+	asm volatile ("int $0x40"::"a"(-1));
+}
+
+static inline dword get_pixel(unsigned x,unsigned y,unsigned size)
+{
+	asm volatile ("int $0x40"::"a"(35), "b"((y*size+x)));
+}
+
+static inline void sleep(unsigned d)
+{
+	asm volatile ("int $0x40"::"a"(5), "b"(d));
+}
+
+static inline void GetRGB(unsigned x,unsigned y, unsigned w, unsigned h,unsigned d)
+{
+	asm volatile ("int $0x40"::"a"(36), "b"(d), "c"((w<<16)|h), "d"((x<<16)|y));
+}
+
+// define a window
+// x, y - position; w, h - size; cs - color and style; c - caption; b - boder
+static inline void wnd_define(unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	asm volatile ("int $0x40"::"a"(0), "b"(x*65536+w), "c"(y*65536+h), "d"(0x43000000));
+}
+
+
+static inline void wnd_move(unsigned x, unsigned y)
+{
+	asm volatile ("int $0x40"::"a"(67), "b"(x), "c"(y), "d"(-1), "S"(-1));
+}
+
+
+static inline void event_mask(unsigned e)
+{
+	asm volatile ("int $0x40"::"a"(40), "b"(e));
+}
+
+
+static inline unsigned event_wait() 
+{
+	asm volatile ("int $0x40"::"a"(10));
+}
+
+
+static inline unsigned event_wait_time(unsigned time)
+{
+	asm volatile ("int $0x40"::"a"(23), "b"(time));
+}
+
+
+static inline unsigned event_check()
+{
+	asm volatile ("int $0x40"::"a"(11));
+}
+
+
+static inline void __attribute__((__always_inline__)) paint_start()
+{
+	asm volatile ("int $0x40"::"a"(12), "b"(1));
+}
+
+
+static inline void __attribute__((__always_inline__)) paint_end()
+{
+	asm volatile ("int $0x40"::"a"(12), "b"(2));
+}
+
+
+static inline void paint_pixel(unsigned x, unsigned y, unsigned c)
+{
+	asm volatile ("int $0x40"::"a"(1), "b"(x), "c"(y), "d"(c));
+}
+
+
+static inline void paint_bar(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c)
+{
+	asm volatile ("int $0x40"::"a"(13), "b"(x*65536+w), "c"(y*65536+h), "d"(c));
+}
+
+
+static inline void paint_line(unsigned x1, unsigned y1, unsigned x2, unsigned y2, unsigned c)
+{
+	asm volatile ("int $0x40"::"a"(38), "b"(x1*65536+x2), "c"(y1*65536+y2), "d"(c));
+}
+
+
+static inline void paint_string(unsigned x, unsigned y, char *s, unsigned c)
+{
+	asm volatile ("int $0x40"::"a"(4), "b"(x*65536+y), "c"(c), "d"(s));
+}
+
+
+static inline void paint_image(unsigned x, unsigned y, unsigned w, unsigned h, char *d)
+{
+	asm volatile ("int $0x40"::"a"(7), "c"(w*65536+h), "d"(x*65536+y), "b"(d));
+}
+
+
+static inline void paint_image_pal(unsigned x, unsigned y, unsigned w, unsigned h, char *d, unsigned *palette)
+{
+	asm volatile ("int $0x40"::"a"(65), "b"(d), "c"(w*65536+h), "d"(x*65536+y), "D"(palette), "S"(8));
+}
+
+
+static inline unsigned key_get()
+{
+	asm volatile ("int $0x40"::"a"(2));
+}
+
+
+static inline unsigned key_control()
+{
+	asm volatile ("int $0x40"::"a"(66), "b"(3));
+}
+
+
+static inline void key_lang_set(unsigned lang)
+{
+	asm volatile ("int $0x40"::"a"(21), "b"(2), "c"(9), "d"(lang));
+}
+
+
+static inline unsigned key_lang_get()
+{
+	asm volatile ("int $0x40"::"a"(26), "b"(2), "c"(9));
+}
+
+
+static inline void key_mode_set(unsigned mode)
+{
+	asm volatile ("int $0x40"::"a"(66), "b"(1), "c"(mode));
+}
+
+
+static inline unsigned key_mode_get()
+{
+	asm volatile ("int $0x40"::"a"(66), "b"(2));
+}
+
+
+static inline unsigned btn_get()
+{
+	asm volatile ("int $0x40"::"a"(17));
+}
+
+
+static inline void btn_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned d, unsigned c)
+{
+	asm volatile ("int $0x40"::"a"(8), "b"(x*65536+w), "c"(y*65536+h), "d"(d), "S"(c));
+}
+
+
+static inline void btn_type(unsigned t)
+{
+	asm volatile ("int $0x40"::"a"(48), "b"(1), "c"(t));
+}
+
+
+static inline void wnd_caption(char *s)
+{
+	asm volatile ("int $0x40"::"a"(71), "b"(1), "c"(s));
+}
+
+
+static inline unsigned mouse_pos()
+{
+	asm volatile ("int $0x40"::"a"(37), "b"(0));
+}
+
+
+static inline unsigned mouse_posw()
+{
+	asm volatile ("int $0x40"::"a"(37), "b"(1));
+}
+
+
+static inline unsigned mouse_btn()
+{
+	asm volatile ("int $0x40"::"a"(37), "b"(2));
+}
+
+
+static inline void board_putc(char c)
+{
+	asm volatile ("int $0x40"::"a"(63), "b"(1), "c"(c));
+}
+
+
+static inline void board_puts(char *s)
+{
+	unsigned i;
+	i = 0;
+	while (*(s+i))
+	{
+		asm volatile ("int $0x40"::"a"(63), "b"(1), "c"(*(s+i)));
+	i++;
+	}
+}
+
+
+static inline void board_puti(int n)
+{
+	char c;
+
+	if ( n > 1 )
+		board_puti(n / 10);
+
+	c = n % 10 + '0';
+	asm volatile ("int $0x40"::"a"(63), "b"(1), "c"(c));
+
+}
+
+
+static inline int file_70(struct70 *k)
+{
+	asm volatile ("int $0x40"::"a"(70), "b"(k));
+}
+
+
+static inline struct_import* cofflib_load(char *name)
+{
+	asm volatile ("int $0x40"::"a"(68), "b"(19), "c"(name));
+}
+
+
+static inline void* cofflib_procload (struct_import *imp, char *name)
+{
+	int i;
+	for (i=0;;i++)
+	if ( NULL == ((imp+i) -> name))
+		break;
+	else
+		if ( 0 == strcmp(name, (imp+i)->name) )
+			return (imp+i)->data;
+	return NULL;
+}
+
+
+static inline unsigned cofflib_procnum (struct_import *imp)
+{
+	unsigned i, n;
+
+	for (i=n=0;;i++)
+		if ( NULL == ((imp+i) -> name))
+			break;
+		else
+			n++;
+
+	return n;
+}
+
+
+static inline void cofflib_procname (struct_import *imp, char *name, unsigned n)
+{
+	unsigned i;
+	*name = 0;
+
+	for (i=0;;i++)
+		if ( NULL == ((imp+i) -> name))
+			break;
+		else
+			if ( i == n )
+				{
+					strcpy(name, ((imp+i)->name));
+					break;
+				}
+
+}
+
+
+static inline unsigned system_cpufreq()
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(5));
+}
+
+
+static inline unsigned system_mem()
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(17));
+}
+
+
+static inline unsigned system_memfree()
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(16));
+}
+
+
+static inline unsigned system_time_get()
+{
+	asm volatile ("int $0x40"::"a"(3));
+}
+
+
+static inline unsigned system_date_get()
+{
+	asm volatile ("int $0x40"::"a"(29));
+}
+
+
+static inline unsigned system_end(unsigned param)
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(9), "c"(param));
+}
+
+static inline unsigned win_min()
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(10));
+}
+
+
+static inline void path_file2dir(char *dir, char *fname)
+{
+	unsigned i;
+	strcpy (dir, fname);
+	for ( i = strlen(dir);; --i)
+		if ( '/' == dir[i])
+		{
+			dir[i] = '\0';
+			return;
+		}
+}
+
+
+static inline void path_full(char *full, char *fname)
+{
+	char temp[256];
+
+	switch (*fname)
+		{
+
+		case '/':
+			strncpy(temp, fname+1, 2);
+			temp[2]=0;
+			if ( (!strcmp("rd", temp)) || (!strcmp("hd", temp)) || (!strcmp("cd", temp)) )
+				strcpy (full, fname);
+			break;
+
+		case '.':
+			break;
+
+		default:
+			break;
+
+		};
+}
+
+
+
+static inline void __attribute__((__always_inline__)) screen_wait_rr()
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(14));
+}
+
+
+
+static inline void screen_get_size(unsigned *w, unsigned *h)
+{
+	unsigned size;
+	asm volatile ("int $0x40":"=a"(size):"a"(14));
+	*h = size&0xFFFF;
+	*w = size>>16;
+}
+
+
+static inline unsigned skin_height()
+{
+	asm volatile ("int $0x40"::"a"(48), "b"(4));
+}
+
+
+static inline unsigned thread_start(unsigned start, unsigned stack)
+{
+	asm volatile ("int $0x40"::"a"(51), "b"(1), "c"(start), "d"(stack));
+}
+
+
+static inline unsigned time_tick()
+{
+	asm volatile ("int $0x40"::"a"(26), "b"(9));
+}
+
+
+static inline unsigned sound_speaker(char data[])
+{
+	asm volatile ("movl %0, %%esi"::"a"(data));
+	asm volatile ("int $0x40"::"a"(55), "b"(55));
+}
+
+
+static inline unsigned process_info(signed slot, char buf1k[])
+{
+	asm volatile ("int $0x40"::"a"(9), "b"(buf1k), "c"(slot));
+}
+
+
+static inline int process_kill_pid(unsigned process)
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(18), "c"(process));
+}
+
+static inline int kill_process(unsigned process)
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(2), "c"(process));
+}
+
+static inline void get_kernel_ver(char buff16b[])
+{
+	asm volatile ("int $0x40"::"a"(18), "b"(13), "c"(buff16b));
+}
+
+static inline long GetFreeRam(void)
+{
+	asm ("int $0x40"::"a"(18), "b"(16));
+}
+
+static inline long WaitBlanking(void)
+{
+	asm ("int $0x40"::"a"(18), "b"(14));
+}
+
+static inline int buffer_open(char name[], int mode, int size, char **buf)
+{
+	int error;
+	asm volatile ("int $0x40":"=a"(*buf), "=d"(error):"a"(68), "b"(22), "c"(name), "d"(size), "S"(mode));
+	return error;
+}
+
+static inline void buffer_close(char name[])
+{
+	asm volatile ("int $0x40"::"a"(68), "b"(23), "c"(name));
+}
+
+static inline int clip_num()
+{
+	asm volatile ("int $0x40"::"a"(54), "b"(0));
+}
+
+static inline char* clip_get(int n)
+{
+	asm volatile ("int $0x40"::"a"(54), "b"(1), "c"(n));
+}
+
+static inline int clip_set(int n, char buffer[])
+{
+	asm volatile ("int $0x40"::"a"(54), "b"(2), "c"(n), "d"(buffer));
+}
+
+
+#endif

programs/develop/libraries/libs_v2/include/lexer.h

@@ -0,0 +1 @@
+

programs/develop/libraries/libs_v2/include/library.h

@@ -0,0 +1,51 @@
+#ifndef LIBRARY_H
+#define LIBRARY_H
+
+#pragma pack(push,1)
+	typedef struct
+	{
+		char	*name;
+		void	*data;
+	} struct_import_lib_init;
+#pragma pack(pop)
+
+typedef struct
+{
+	int (*load)(char *path);
+	unsigned int (*get)(char *name);
+} OBJECT_LIBRARY;
+
+static char init_load_obj = 0;
+
+static int (* _stdcall _ptr_load_dll_)(char *path);
+static unsigned int (* _stdcall _ptr_get_dll_)(char *path);
+
+static inline int _OBJECT__LOAD_(char *path)
+{
+	struct_import_lib_init *imp;
+	if(!init_load_obj)
+	{
+		asm("int $0x40":"=a"(imp):"a"(68), "b"(19), "c"("/sys/lib/library.obj"));
+		_ptr_load_dll_ = imp[0].data;
+		_ptr_get_dll_ = imp[1].data;
+		init_load_obj = 1;
+	}
+	return _ptr_load_dll_(path);
+}
+
+static inline unsigned int _OBJECT__GET_(char *name)
+{
+	return _ptr_get_dll_(name);
+}
+
+static inline OBJECT_LIBRARY library = {&_OBJECT__LOAD_,&_OBJECT__GET_};
+
+/*
+	Example:
+	void*(* stdcall name_func)(...);
+	library.load("/sys/lib/... .obj");
+	name_func = library.get("name_function");
+	name_func(...);
+*/
+
+#endif

programs/develop/libraries/libs_v2/include/math.c

@@ -0,0 +1,76 @@
+//IO library
+#ifndef INCLUDE_MATH_C
+#define INCLUDE_MATH_C
+
+static inline signed math_round(float x)
+{
+	x+=0.6;
+	return x;
+}
+static inline signed math_ceil(float x)
+{
+	long z = (long)x;
+	if(z<x) return ++z;
+	return z;
+}
+static inline float math_floor(float x)
+{
+	signed long z = x;
+	if(z==x)return x;
+	if(z<0) return --z;
+	return z;
+}
+static inline float math_abs(float x)
+{
+	if(x<0)return -x;
+	return x;
+}
+
+/*
+static inline float math_cos(float x)
+{
+	float r;
+	asm 
+	{
+		fld x
+		fcos
+		fstp r
+	}
+	return r;
+}
+static inline float math_sin(float x)
+{
+	float r;
+	asm 
+	{
+		fld x
+		fsin
+		fstp r
+	}
+	return r;
+}
+static inline float math_sqrt(float x)
+{
+	float r;
+	asm 
+	{
+		fld x
+		fsqrt
+		fstp r
+	}
+	return r;
+}
+static inline float math_tan(float x)
+{
+	float r;
+	asm 
+	{
+		fld x
+		fld1
+		fpatan
+		fstp r
+	}
+	return r;
+}
+*/
+#endif

programs/develop/libraries/libs_v2/include/stdlib.c

@@ -0,0 +1,49 @@
+#ifndef STDLIB_C_INCLUDE
+#define STDLIB_C_INCLUDE
+
+#define RAND_MAX 0x7FFFU
+
+#define isspace(c) ((c)==' ')
+#define abs(i) (((i)<0)?(-(i)):(i))
+
+#define random(num) ((rand()*(num))/((RAND_MAX+1)))
+
+static unsigned int seed_o = 0x45168297;
+
+
+static inline void srand (unsigned seed)
+{
+	seed_o = seed;
+}
+
+
+static inline int rand (void)
+{
+	seed_o = seed_o * 0x15a4e35 + 1;
+	return(seed_o >> 16);
+}
+
+
+static inline void* malloc(unsigned s)
+{
+	asm ("int $0x40"::"a"(68), "b"(12), "c"(s) );
+}
+
+
+static inline void free(void *p)
+{
+	asm ("int $0x40"::"a"(68), "b"(13), "c"(p) );
+}
+
+static inline void *realloc(void *data, long size)
+{
+	void *r = malloc(size);
+	byte *p = (byte *)r;
+	byte *pd = (byte *)data;
+	while(size--) *p++=*pd++;
+	free(data);
+	return r;
+}
+
+
+#endif

programs/develop/libraries/libs_v2/include/string.c

@@ -0,0 +1,197 @@
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+static inline void*  memset(void *mem, int c, unsigned size)
+{
+unsigned i;
+
+for ( i = 0; i < size; i++ )
+	 *((char *)mem+i) = (char) c;
+
+return NULL;	
+}
+
+
+static inline void* memcpy(void *dst, const void *src, unsigned size)
+{
+
+unsigned i;
+
+for ( i = 0; i < size; i++)
+	*(char *)(dst+i) = *(char *)(src+i);
+
+return NULL;
+}
+
+
+static inline int memcmp(const void* buf1, const void* buf2, int count)
+{
+int i;
+for (i=0;i<count;i++)
+	{
+	if (*(unsigned char*)buf1<*(unsigned char*)buf2)
+		return -1;
+	if (*(unsigned char*)buf1>*(unsigned char*)buf2)			
+		return 1;
+	}
+return 0;
+}
+
+static inline char *strcat(char strDest[], char strSource[])
+{
+	int i, j; 
+	i = j = 0;
+	while (strDest[i] != '\0') i++;
+	while ((strDest[i++] = strSource[j++]) != '\0');
+	return strDest;
+}
+
+
+static inline int strcmp(char* string1,char* string2)
+{
+
+while (1)
+{
+if (*string1<*string2)
+	return -1;
+if (*string1>*string2)
+	return 1;
+
+if (*string1=='\0')
+	return 0;
+
+string1++;
+string2++;
+}
+
+}
+
+static inline char *strcpy(char strDest[], const char strSource[])
+{
+	unsigned i;
+	i = 0;
+	while ((strDest[i] = strSource[i]) != '\0') i++;
+	return strDest;
+}
+
+
+char* strncpy(char *strDest, const char *strSource, unsigned n)
+{
+	unsigned i;
+
+	if (! n )
+		return strDest;
+
+	i = 0;
+	while ((strDest[i] = strSource[i]) != '\0')
+		if ( (n-1) == i )
+			break;
+		else
+			i++;
+
+	return strDest;
+}
+
+
+static inline int strlen(const char* string)
+{
+	int i;
+
+	i=0;
+	while (*string++) i++;
+	return i;
+}
+
+
+
+static inline char* strchr(const char* string, int c)
+{
+	while (*string)
+	{
+		if (*string==c)
+			return (char*)string;
+		string++;
+	}	
+	return (char*)0;
+}
+
+
+static inline char* strrchr(const char* string, int c)
+{
+	char* last_found;
+	while (*string)
+	{
+		if (*string==c)
+		{
+			last_found = (char*)string;
+		}
+		string++;
+	}	
+	return last_found;
+}
+
+
+
+static inline void _itoa(int i, char *s)
+{
+	int a, b, c, d;
+	a = (i - i%1000)/1000;
+	b = (i - i%100)/100 - a*10;
+	c = (i - i%10)/10 - a*100 - b*10;
+	d = i%10;
+	s[0] = a + '0';
+	s[1] = b + '0';
+	s[2] = c + '0';
+	s[3] = d + '0';
+	s[4] = 0;
+}
+
+
+ /* reverse:  ïåðåâîðà÷èâàåì ñòðîêó s íà ìåñòå */
+static inline void reverse(char s[])
+ {
+     int i, j;
+     char c;
+ 
+     for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
+         c = s[i];
+         s[i] = s[j];
+         s[j] = c;
+     }
+ }
+
+
+ /* itoa:  êîíâåðòèðóåì n â ñèìâîëû â s */
+static inline void itoa(int n, char s[])
+ {
+     int i, sign;
+ 
+     if ((sign = n) < 0)
+         n = -n;
+     i = 0;
+     do {
+         s[i++] = n % 10 + '0';
+     } while ((n /= 10) > 0);
+     if (sign < 0)
+         s[i++] = '-';
+     s[i] = '\0';
+     reverse(s);
+ }
+
+
+
+static inline int atoi ( char *s )
+{
+	int i, n;
+
+	n = 0;
+	for ( i = 0; s[i]!= '\0'; ++i)
+		if ((s[i]<'0') || (s[i]>'9'))
+			return 0;
+		else
+			n = 10 * n + s[i] - '0';
+
+	return n;
+}

programs/develop/libraries/libs_v2/library.bat

@@ -0,0 +1 @@
+build.bat library

programs/develop/libraries/libs_v2/library.c

@@ -0,0 +1,151 @@
+/*
+	2015
+	Author: Pavel Yakovlev.
+*/
+
+#define LIB_NAME "library"
+#define NO_LIBIMPORT_FUNC
+
+#include "coff.h"
+
+#include <kolibri.c>
+#include <stdlib.c>
+
+struct_import *array_list_func;
+dword ADR_FUNC_LIST=0;
+dword ADR_LIB_LIST=0;
+
+dword init_list_function_adr();
+
+typedef struct
+{
+	dword key;
+	dword value;
+} array;
+
+void strtolower(char *text)
+{
+	--text;
+	while(*++text)if((*text>='A')&&(*text<='Z'))*text+='a'-'A';
+}
+
+static array*(* _stdcall array_set_key_string)(array *ary,char *key,void *data);
+static void*(* _stdcall array_get_key_string)(array *ary,char *key);
+
+static char*(* _stdcall get_full_path)(char *path);
+byte init_check_fs = 0;
+byte init_fs()
+{
+	if(init_check_fs)return 1;
+	char *name = "/sys/lib/fs.obj";
+	array_list_func = cofflib_load(name);
+	if (!array_list_func) exit();
+	
+	get_full_path = (void *)cofflib_procload (array_list_func, "fs.get_full_path");
+	if (!get_full_path) exit();
+	
+	init_check_fs = 1;
+	
+	array_set_key_string(&ADR_LIB_LIST,name,array_list_func);
+	return init_list_function_adr();
+}
+
+byte init_check_array = 0;
+byte init_array()
+{
+	if(init_check_array)return 1;
+	
+	char *name = "/sys/lib/array.obj";
+	array_list_func = cofflib_load(name);
+	if (!array_list_func) exit();
+	
+	array_set_key_string = (void *)cofflib_procload (array_list_func, "array.key_string_set");
+	if (!array_set_key_string) exit();
+	
+	array_get_key_string = (void *)cofflib_procload (array_list_func, "array.key_string_get");
+	if (!array_get_key_string) exit();
+	
+	init_check_array = 1;
+	
+	array_set_key_string(&ADR_LIB_LIST,name,array_list_func);
+	init_list_function_adr();
+	return init_fs();
+}
+
+int load_dll2(dword dllname,struct_import* import_table, byte need_init)
+{
+	struct_import* import_table1 = cofflib_load(dllname);
+	if(import_table1)return -1;
+	
+	dword i=0,ii=0;
+	dword name = import_table1[i].name;
+	dword name1 = import_table[ii].name;
+	while(name)
+	{
+		if(!strcmp(name,name1))
+		{
+			import_table[ii].data=import_table1[i].data;
+			name1 = import_table[++ii].name;
+		}
+		name = import_table1[++i].name;
+	}
+	if(need_init) dll_init(import_table1[0].data);
+	return 0;
+}
+
+static void (* lib_init_eval)(dword,dword,dword,dword);
+
+void dll_init(dword data)
+{
+	lib_init_eval = data;
+	lib_init_eval(&malloc,&free,&realloc,&load_dll2);
+}
+
+byte first_load = 0;
+
+dword load(char *name)
+{
+	init_array();
+	name = get_full_path(name);
+	strtolower(name);
+	if(array_get_key_string(&ADR_LIB_LIST,name))return 1;
+	array_list_func = cofflib_load(name);
+	if(!array_list_func) return 0;
+	array_set_key_string(&ADR_LIB_LIST,name,array_list_func);
+	return init_list_function_adr();
+}
+
+dword get(char *name)
+{
+	return (dword)array_get_key_string(&ADR_FUNC_LIST,name);
+}
+
+static void (* _stdcall eval_set_pointer)(dword,dword);
+
+dword init_list_function_adr()
+{
+	dword i=0,data;
+	char *name = 0;
+	LOOP:
+		name = array_list_func[i].name;
+		if(!name) return 1;
+		data = array_list_func[i++].data;
+		if(!strcmp("lib_init",name)) 
+		{
+			dll_init(data);
+			goto LOOP;
+		}
+		if(!strcmp("lib_pointer_library",name))
+		{
+			eval_set_pointer = data;
+			eval_set_pointer(&load,&get);
+			goto LOOP;
+		}
+		array_set_key_string(&ADR_FUNC_LIST,name,data);
+	goto LOOP;
+}
+
+EXPORT_
+	export(load)
+	export(get)
+_EXPORT