Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 5935 → Rev 5936

/programs/develop/libraries/libs_v2/array.bat
0,0 → 1,0
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,0
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,0
 
/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/include
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property
/programs/develop/libraries/libs_v2/library.bat
0,0 → 1,0
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
/programs/develop/libraries/libs_v2
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property