sdongles/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

Libraries for compiling Python programs!

Browse Source 
git-svn-id: svn://kolibrios.org@7301 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
pavelyakov 2018-07-13 17:30:22 +00:00
parent 321ff86117
commit 6909c317ef
4 changed files with 719 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
programs/cmm/pythonLibraryCompiler/function.h Normal file
View File

@ -0,0 +1,60 @@
:void _stdout(dword txt)
{
dword addr = txt;
while(DSBYTE[addr]) addr++;
CreateFile(addr-txt,txt,"/sys/stdout");
}
:dword stdcall std_stdout(dword count)
{
_stdout(_str(popFast()));
}
:dword stdcall std_str(dword c,v)
{
dword n = 0;
dword m = 0;
dword l = 0;
if(DSBYTE[v+4] == PY_STR)
{
return v;
}
n = malloc(30);
m = malloc(MEMBUF);
DSDWORD[n] = m;
DSBYTE[n+4] = PY_STR;
DSDWORD[n+9] = MEMBUF;
DSDWORD[n+13] = HASH;
HASH++;
switch(DSBYTE[v+4])
{
case PY_BOOL:
if(DSDWORD[v])
{
strlcpy(m,"True",4);
DSDWORD[n+5] = 4;
}
else
{
strlcpy(m,"False",5);
DSDWORD[n+5] = 5;
}
break;
case PY_INT:
l = itoa(DSDWORD[v],m);
DSDWORD[n+5] = l;
break;
case PY_NONE:
strlcpy(m,"None",4);
DSDWORD[n+5] = 4;
break;
}
return n;
}

64
programs/cmm/pythonLibraryCompiler/head.h Normal file
View File

@ -0,0 +1,64 @@
#pragma option OST
#pragma option ON
#pragma option cri-
#pragma option -CPA
#initallvar 0
#jumptomain FALSE
#startaddress 65536
#code32 TRUE
#define PY_NONE 0
#define PY_BOOL 1
#define PY_INT 2
#define PY_FLT 3
#define PY_STR 4
#define PY_FNC 6
#define PY_CPL 7
#define PY_LST 8
#define PY_TPL 9
#define PY_RNG 10
#define PY_BTS 11
#define PY_BTA 12
#define PY_MVW 13
#define PY_SET 14
#define PY_FST 15
#define PY_DCT 16
#define PY_ADD 0
#define PY_POW 1
#define PY_MUL 2
#define PY_SUB 3
#define PY_DIV 4
#define PY_MOD 5
#define PY_XOR 6
#define PY_AND 7
#define PY__OR 8
#define PY_LSH 9
#define PY_RSH 10
#define MEMBUF 0xF
char os_name[8] = {'M','E','N','U','E','T','0','1'};
dword os_version = 0x00000001;
dword start_addr = #______INIT______;
dword final_addr = #______STOP______+32;
dword alloc_mem = 160000;
dword x86esp_reg = 160000;
dword I_Param = #param;
dword I_Path = #program_path;
char param[4096]={0};
char program_path[4096]={0};
dword HASH = 0;
:struct f70{
dword func;
dword param1;
dword param2;
dword param3;
dword param4;
char rezerv;
dword name;
};

221
programs/cmm/pythonLibraryCompiler/init.h Normal file
View File

@ -0,0 +1,221 @@
void ExitProcess()
{
EAX = -1;
$int 0x40
}
:f70 write_file_70;
:int CreateFile(dword data_size, buffer, file_path)
{
write_file_70.func = 2;
write_file_70.param1 = 0;
write_file_70.param2 = 0;
write_file_70.param3 = data_size;
write_file_70.param4 = buffer;
write_file_70.rezerv = 0;
write_file_70.name = file_path;
$mov eax,70
$mov ebx,#write_file_70.func
$int 0x40
}
dword malloc(dword size)
{
$push ebx
$push ecx
$mov eax, 68
$mov ebx, 12
$mov ecx, size
$int 0x40
$pop ecx
$pop ebx
return EAX;
}
dword free(dword mptr)
{
$push ebx
$push ecx
$mov eax, 68
$mov ebx, 13
$mov ecx, mptr
$test ecx, ecx
$jz end0
$int 0x40
@end0:
$pop ecx
$pop ebx
return 0;
}
:dword sleep(dword x)
{
EAX = 5;
EBX = x;
$int 0x40
}
:dword mem_init()
{
$push ebx
$mov eax, 68
$mov ebx, 11
$int 0x40
$pop ebx
return EAX;
}
:dword itoa(signed long number,dword p)
{
dword ret=0;
byte cmd=0;
long mask=0;
long tmp=0;
IF(!number)
{
DSBYTE[p] = '0';
p++;
DSBYTE[p] = 0;
return 1;
}
mask = 1000000000;
cmd = 1;
if(!number){
ESBYTE[p] = '0';
ESBYTE[p+1] = 0;
return p;
}
ret = p;
if(number<0)
{
$neg number
ESBYTE[p] = '-';
$inc p
}
while(mask)
{
tmp = number / mask;
tmp = tmp%10;
if(cmd){
if(tmp){
ESBYTE[p] = tmp + '0';
$inc p
cmd = 0;
}
}
else {
ESBYTE[p] = tmp + '0';
$inc p
}
mask /= 10;
}
ESBYTE[p] = 0;
return p - ret;
}
:void strlcpy(dword s1,s2,l)
{
WHILE(l)
{
DSBYTE[s1] = DSBYTE[s2];
s1++;
s2++;
l--;
}
}
:dword _str(dword v)
{
switch(DSBYTE[v+4])
{
case PY_STR:
return DSDWORD[v];
break;
case PY_BOOL:
if(DSDWORD[v])return "True";
return "False";
break;
}
}
:dword stack = 0;
:dword popStack()
{
stack-=4;
return DSDWORD[stack];
}
:void pushStack(dword x)
{
DSDWORD[stack] = x;
stack+=4;
}
:dword stackFast = 0;
:dword popFast()
{
stackFast-=4;
return DSDWORD[stackFast];
}
:void pushFast(dword x)
{
DSDWORD[stackFast] = x;
stackFast+=4;
}
:dword stackWhile = 0;
:dword popWhile()
{
stackWhile-=4;
return DSDWORD[stackWhile];
}
:void pushWhile(dword x)
{
DSDWORD[stackWhile] = x;
stackWhile+=4;
}
:void checkType(dword x,y)
{
if(DSBYTE[x+4]!=DSBYTE[y+4])
{
stdout("Error type!");
ExitProcess();
}
}
:byte BUFTST[15] = {0};
:void test(dword x,c)
{
if(c)
{
itoa(x,#BUFTST);
_stdout(#BUFTST);
}
else _stdout(x);
EAX = -1;
$int 0x40;
}
void ______INIT______()
{
mem_init();
HASH = 0;
stack = malloc(1000);
stackFast = malloc(1000);
stackWhile = malloc(1000);
main();
ExitProcess();
}
void ______STOP______()
{
ExitProcess();
}

374
programs/cmm/pythonLibraryCompiler/opcode.h Normal file
View File

@ -0,0 +1,374 @@
#define buffer 1024
:struct VAR
{
dword data;
byte type;
dword length;
dword stack;
};
:void load_const(dword data,type,length)
{
dword m = 0;
dword v = 0;
dword i = 0;
dword b = 0;
dword o = 0;
dword t = 0;
v = malloc(30);
switch(type)
{
case PY_STR:
b = length+MEMBUF;
m = malloc(b);
t = m;
i = 0;
while(i<length)
{
DSBYTE[t] = DSBYTE[data];
t++;
data++;
i++;
}
DSDWORD[v] = m;
DSDWORD[v+5] = length;
DSDWORD[v+9] = b;
break;
case PY_INT:
DSDWORD[v] = data;
break;
case PY_BOOL:
case PY_FNC:
DSDWORD[v] = data;
break;
default:
DSDWORD[v] = 0;
break;
}
DSBYTE[v+4] = type;
DSDWORD[v+13] = HASH;
HASH++;
pushStack(v);
}
:void compare_op(byte cmd)
{
dword n = 0;
dword y = popStack();
dword x = popStack();
dword dx = 0;
dword dy = 0;
dword i = 0;
checkType(x,y);
n = malloc(30);
DSDWORD[n+13] = HASH;
HASH++;
DSDWORD[n+4] = PY_BOOL;
IF(DSBYTE[x+4] == PY_STR)
{
IF(DSDWORD[x+5] == DSDWORD[y+5])
{
dx = DSDWORD[x];
dy = DSDWORD[y];
i = DSDWORD[x+5];
WHILE(i)
{
IF(DSBYTE[dx]!=DSBYTE[dy]) BREAK;
dx++;
dy++;
i--;
}
IF(!i) DSDWORD[n] = 1;
}
pushStack(n);
return;
}
SWITCH(cmd)
{
CASE 0:
IF(DSDWORD[x] == DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
CASE 1:
IF(DSDWORD[x] != DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
CASE 2:
IF(DSDWORD[x] >= DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
CASE 3:
IF(DSDWORD[x] <= DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
CASE 4:
IF(DSDWORD[x] > DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
CASE 5:
IF(DSDWORD[x] < DSDWORD[y]) DSDWORD[n] = 1;
BREAK;
}
pushStack(n);
}
:byte pop_jump_if(byte cmd)
{
dword x = 0;
x = popStack();
//test(DSDWORD[x+4],1);
SWITCH(DSBYTE[x+4])
{
CASE PY_INT:
CASE PY_BOOL:
IF(cmd){ IF (DSDWORD[x]) RETURN 1;}
IF(!cmd){ IF (!DSDWORD[x]) RETURN 1;}
BREAK;
CASE PY_STR:
IF(cmd){ IF (DSDWORD[x+5]) RETURN 1;}
IF(!cmd){ IF (!DSDWORD[x+5]) RETURN 1;}
BREAK;
}
RETURN 0;
}
:void pop_block()
{
stackWhile-=4;
}
:void binary(byte cmd)
{
dword x = 0;
dword y = 0;
dword l1 = 0;
dword l2 = 0;
dword i = 0;
dword n = 0;
byte type = 0;
dword buffer = 0;
dword length = 0;
dword position = 0;
y = popStack();
x = popStack();
IF(cmd==PY_ADD) checkType(x,y);
n = malloc(30);
type = DSBYTE[x+4];
DSBYTE[n+4] = type;
if(type==PY_STR)
{
l1 = DSDWORD[x+5];
IF(cmd==PY_ADD) l2 = DSDWORD[y+5];
ELSE
{
i = DSDWORD[y];
l2 = i*l1;
}
length = l1+l2;
buffer = length+MEMBUF;
position = malloc(buffer);
DSDWORD[n] = position;
DSDWORD[n+5] = length;
DSDWORD[n+9] = buffer;
IF(cmd==PY_ADD)
{
strlcpy(position,DSDWORD[x],l1);
strlcpy(position+l1,DSDWORD[y],l2);
}
ELSE IF(cmd==PY_POW)
{
WHILE(i)
{
strlcpy(position,DSDWORD[x],l1);
position+=l1;
i--;
}
}
goto RETURN_BINARY;
}
if(type==PY_INT)
{
IF(cmd==PY_ADD)
{
DSDWORD[n] = DSDWORD[x] + DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_POW)
{
length = DSDWORD[y];
position = DSDWORD[x];
DSDWORD[n] = 1;
WHILE(length) {DSDWORD[n]*=position; length--;}
goto RETURN_BINARY;
}
IF(cmd==PY_SUB)
{
DSDWORD[n] = DSDWORD[x] - DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_MUL)
{
DSDWORD[n] = DSDWORD[x] * DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_MOD)
{
DSDWORD[n] = DSDWORD[x] % DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_XOR)
{
DSDWORD[n] = DSDWORD[x] ^ DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_AND)
{
DSDWORD[n] = DSDWORD[x] & DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY__OR)
{
DSDWORD[n] = DSDWORD[x] | DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_LSH)
{
DSDWORD[n] = DSDWORD[x] << DSDWORD[y];
goto RETURN_BINARY;
}
IF(cmd==PY_RSH)
{
DSDWORD[n] = DSDWORD[x] >> DSDWORD[y];
goto RETURN_BINARY;
}
}
RETURN_BINARY:
pushStack(n);
}
:byte del(dword x)
{
IF(x)
{
IF(DSDWORD[x+9]) free(DSDWORD[x]);
free(x);
RETURN 1;
}
RETURN 0;
}
:void make_function()
{
stack-=4;
}
:dword store_name(dword x)
{
dword z = 0;
dword y = 0;
y = popStack();
z = DSDWORD[x];
IF(z) IF(y != z) del(z);
DSDWORD[x] = y;
RETURN y;
}
:void load_name(dword addr)
{
pushStack(addr);
}
:void pop_top()
{
stack-=4;
}
:void load_fast(dword addr)
{
popFast();
DSDWORD[addr] = EAX;
pushStack(EAX);
}
:void call_function(dword arg)
{
dword x = 0;
dword c = arg;
dword o = 0;
dword v = 0;
WHILE(c)
{
popStack();
pushFast(EAX);
c--;
}
v = popStack();
IF(DSBYTE[v+4]!=PY_FNC) test("No function!",0);
v = DSDWORD[v];
IF(!v)
{
test(1,1);
pushStack(0);
return;
}
v(arg);
pushStack(EAX);
}
/*
:void call_function(dword arg)
{
dword x = 0;
dword c = arg;
dword o = 0;
dword v = 0;
WHILE(c)
{
o+=4;
popStack();
$push eax
c--;
}
$push arg
v = popStack();
IF(DSBYTE[v+4]!=PY_FNC) test("No function!",0);
v = DSDWORD[v];
IF(!v)
{
test(1,1);
pushStack(0);
return;
}
$call v
ESP+=o;
pushStack(EAX);
}
*/