/programs/cmm/python/static/array.h |
---|
0,0 → 1,266 |
:dword arrayInit(dword len) |
{ |
dword alloc = 0; |
dword position = 0; |
alloc = malloc(len*4+MEMBUF); |
position = alloc; |
DSDWORD[position] = 0; |
position+=4; |
DSDWORD[position] = len; |
return alloc; |
} |
:dword ReallocArray(dword array,nMem) |
{ |
dword NEW = 0; |
dword OLD = 0; |
dword FLEN = 0; |
dword LEN = 0; |
//test2("relloc",0); |
OLD = array; |
FLEN = nMem*4+8; |
LEN = DSDWORD[array]; |
NEW = arrayInit(nMem); |
array+=8; |
while(LEN) |
{ |
A = DSDWORD[array]; |
IF(A) |
{ |
arraySet(#NEW,DSDWORD[A],DSDWORD[A+4]); |
free(A); |
} |
LEN--; |
array+=4; |
} |
free(OLD); |
return NEW; |
} |
:byte arraySet(dword array,key,value) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword FLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
dword OST = 0; |
dword BEGIN = 0; |
dword gArray = 0; |
gArray = DSDWORD[array]; |
IF(gArray) |
{ |
LEN = DSDWORD[gArray]; |
OST = DSDWORD[gArray+4]; |
} |
ELSE |
{ |
LEN = 0; |
OST = 8; |
} |
IF(LEN) |
{ |
IF(!(LEN%OST)) |
{ |
gArray = ReallocArray(gArray,OST<<1); |
DSDWORD[array] = gArray; |
} |
} |
ELSE |
{ |
gArray = arrayInit(OST); |
DSDWORD[array] = gArray; |
} |
BEGIN = gArray; |
gArray+=4; |
FLEN = DSDWORD[gArray]; |
gArray+=4; |
POSITION = key%FLEN*4+gArray; |
FULL = FLEN*4+gArray; |
LOOP_COL2: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) |
{ |
NEW = malloc(8); |
DSDWORD[NEW] = key; |
DSDWORD[NEW+4] = value; |
DSDWORD[POSITION] = NEW; |
DSDWORD[BEGIN] = DSDWORD[BEGIN]+1; |
return 1; |
} |
IF(DSDWORD[VKEY] == key) |
{ |
DSDWORD[VKEY+4] = value; |
return 2; |
} |
// collision |
POSITION+=4; |
IF(POSITION>FULL) POSITION = gArray+8; |
goto LOOP_COL2; |
return 3; |
} |
:dword arrayGet(dword array,key) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword MEMLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
LEN = DSDWORD[array]; |
array+=4; |
MEMLEN = DSDWORD[array]; |
array+=4; |
POSITION = key%MEMLEN*4+array; |
FULL = LEN*4+array; |
Z = 2; |
LOOP_COL1: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) return 0; |
IF(DSDWORD[VKEY] == key) return DSDWORD[VKEY+4]; |
// collision |
POSITION+=4; |
IF(POSITION>FULL) |
{ |
POSITION = array+8; |
Z--; |
IF(!Z) return 0; |
} |
goto LOOP_COL1; |
} |
:dword arrayDelete(dword array,key) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword MEMLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
dword TMP = 0; |
LEN = DSDWORD[array]; |
array+=4; |
MEMLEN = DSDWORD[array]; |
array+=4; |
POSITION = key%MEMLEN*4+array; |
FULL = LEN*4+array; |
Z = 2; |
LOOP_COL1: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) return 0; |
IF(DSDWORD[VKEY] == key) |
{ |
TMP = DSDWORD[VKEY+4]; |
free(VKEY); |
DSDWORD[POSITION] = 0; |
DSDWORD[array] = DSDWORD[array]-1; |
return TMP; |
} |
// collision |
POSITION+=4; |
IF(POSITION>FULL) |
{ |
POSITION = array+8; |
Z--; |
IF(!Z) return 0; |
} |
goto LOOP_COL1; |
} |
// dict |
:dword hash(dword str) |
{ |
byte S = 0; |
dword s1 = 0; |
dword s2 = 0; |
S = DSBYTE[str]; |
WHILE(S) |
{ |
s1 += S; |
s2 += s1; |
S = DSBYTE[str]; |
str++; |
} |
s1<<=16; |
RETURN s1|s2; |
} |
:byte dictSet(dword array,key,data) |
{ |
RETURN arraySet(array,hash(key),data); |
} |
:byte dictDel(dword array,key) |
{ |
RETURN arrayDelete(array,hash(key)); |
} |
:dword dictGet(dword array,key) |
{ |
RETURN arrayGet(array,hash(key)); |
} |
// list |
:void listAppend(dword position,data) // TODO Fixed!! |
{ |
dword len = 0; |
dword flen = 0; |
dword news = 0; |
dword array = 0; |
dword i = 0; |
array = DSDWORD[position]; |
len = DSDWORD[array]; |
flen = DSDWORD[array+4]; |
IF(len>=flen) |
{ |
news = malloc(flen<<3+8); |
DSDWORD[position] = news; |
i = flen<<1+2; |
while(i) |
{ |
DSDWORD[news] = DSDWORD[array]; |
news+=4; |
array+=4; |
i--; |
} |
array = news; |
} |
DSDWORD[len*4+array+8] = data; |
DSDWORD[array] = DSDWORD[array]+1; |
} |
:dword listGet(dword array,key) |
{ |
return DSDWORD[key*4+array+8]; |
} |
/programs/cmm/python/static/function.h |
---|
0,0 → 1,114 |
:void copyVariable(dword x) |
{ |
load_const(DSDWORD[x],DSBYTE[x+4],DSDWORD[x+5]); |
} |
:dword LenStdout = 0; |
:void _stdout(dword txt) |
{ |
dword addr = txt; |
WHILE(DSBYTE[addr]) addr++; |
IF(!LenStdout) |
{ |
LenStdout = addr-txt; |
CreateFile(LenStdout,txt,"/sys/stdout"); |
} |
ELSE |
{ |
AddFile(LenStdout,addr-txt,txt,"/sys/stdout"); |
LenStdout+=addr-txt; |
} |
} |
:dword std__stdStr(dword count) |
{ |
return _str(popFast()); |
} |
:dword stdcall std__stdout(dword count) |
{ |
std__str(count); |
popStack(); |
_stdout(DSDWORD[EAX]); |
} |
:dword stdcall std__len(dword c) |
{ |
popFast(); |
load_const(DSDWORD[EAX+5],PY_INT,0); |
RETURN 0; |
} |
:dword stdcall std__INT40(dword c) |
{ |
X = popFast(); |
Y = DSDWORD[X+5]; |
X = DSDWORD[X]; |
X = DSDWORD[X]; |
X = DSDWORD[X]; |
test(X,1); |
RETURN 0; |
} |
:void hexAddress(dword x,y) |
{ |
dword i = 0; |
i = 8; |
WHILE(i) |
{ |
DSBYTE[x] = DSBYTE[y&0xF+#arraySymbolHEX]; |
y>>=4; |
x--; |
i--; |
} |
} |
#define rSize DSBYTE[#RDATA+5] |
#define rData DSBYTE[#RDATA] |
#define rType DSBYTE[#RDATA+4] |
:dword stdcall std__str(dword c) |
{ |
dword n = 0; |
dword m = 0; |
dword l = 0; |
dword v = 0; |
dword f = "<function a at 0x00000000>"; |
dword t = 0; |
dword o = 0; |
v = popFast(); |
IF(DSBYTE[v+4] == PY_STR) |
{ |
copyVariable(v); |
return 0; |
} |
switch(DSBYTE[v+4]) |
{ |
case PY_BOOL: |
if(DSDWORD[v]) |
{ |
load_const("True",PY_STR,4); |
return 0; |
} |
load_const("False",PY_STR,5); |
return 0; |
break; |
case PY_INT: |
m = malloc(MEMBUF); |
l = itoa(DSDWORD[v],m); |
load_const(m,PY_STR,l); |
return 0; |
break; |
case PY_NONE: |
load_const("None",PY_STR,4); |
return 0; |
break; |
case PY_FNC: |
hexAddress(f+24,v); |
load_const(f,PY_STR,26); |
return 0; |
break; |
} |
} |
/programs/cmm/python/static/gui.h |
---|
--- static/head.h (nonexistent) |
+++ static/head.h (revision 7309) |
@@ -0,0 +1,100 @@ |
+#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_CLS 17 |
+#define PY_MDL 18 |
+ |
+#define PY_STD_FNC 30 |
+ |
+#define PY_NA_STR 32 |
+#define PY_SYM_STR 33 |
+ |
+ |
+#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 PY_FDV 11 |
+#define PY_TDV 12 |
+ |
+#define MEMBUF 0xF |
+#define MEMARR 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 arraySymbolHEX = "0123456789ABCDEF"; |
+:dword libPath = "/sys/lib/"; |
+:dword HASH = 0; |
+:dword TEMP = 0; |
+:dword RDATA[30] = {0}; |
+ |
+// global variable |
+:dword X = 0; |
+:dword Y = 0; |
+:dword Z = 0; |
+:dword A = 0; |
+:dword B = 0; |
+:dword C = 0; |
+:dword D = 0; |
+:dword E = 0; |
+:dword F = 0; |
+ |
+:dword beginStack = 0; |
+ |
+:dword COUNT_CONST = 0; |
+ |
+:byte std__STRING = 0; |
+:byte std__INTEGER = 1; |
+ |
+:byte S = 0; |
+//-------------- |
+ |
+:struct f70{ |
+ dword func; |
+ dword param1; |
+ dword param2; |
+ dword param3; |
+ dword param4; |
+ char rezerv; |
+ dword name; |
+}; |
/programs/cmm/python/static/init.h |
---|
0,0 → 1,375 |
: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 |
} |
:int AddFile(dword begin,data_size, buffer, file_path) |
{ |
write_file_70.func = 3; |
write_file_70.param1 = begin; |
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; |
} |
stdcall dword realloc(dword mptr, size) |
{ |
$push ebx |
$push ecx |
$push edx |
$mov eax, 68 |
$mov ebx, 20 |
$mov ecx, size |
$mov edx, mptr |
$int 0x40 |
$pop edx |
$pop ecx |
$pop ebx |
return EAX; |
} |
:void memcpy(dword x,y,size) |
{ |
dword ost = 0; |
dword del = 0; |
del = size/4; |
ost = size%4; |
WHILE(del) |
{ |
DSDWORD[x] = DSDWORD[y]; |
del--; |
x+=4; |
y+=4; |
} |
IF(ost>1) |
{ |
DSWORD[x] = DSWORD[y]; |
x+=2; |
y+=2; |
ost-=2; |
} |
IF(ost==1) DSBYTE[x] = DSBYTE[y]; |
} |
:dword sleep(dword x) |
{ |
EAX = 5; |
EBX = x; |
$int 0x40 |
} |
:dword memInit() |
{ |
$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; |
} |
:dword strcpy(dword s1,s2) |
{ |
X = s1; |
WHILE(DSBYTE[s2]) |
{ |
DSBYTE[s1] = DSBYTE[s2]; |
s1++; |
s2++; |
} |
RETURN s1-X; |
} |
:dword strlcpy(dword s1,s2,l) |
{ |
X = l; |
WHILE(l) |
{ |
DSBYTE[s1] = DSBYTE[s2]; |
s1++; |
s2++; |
l--; |
} |
RETURN X; |
} |
:dword _str(dword v) |
{ |
SWITCH(DSBYTE[v+4]) |
{ |
CASE PY_STR: |
RETURN DSDWORD[v]; |
CASE PY_BOOL: |
IF(DSDWORD[v]) RETURN "True"; |
RETURN "False"; |
} |
} |
:dword stack = 0; |
:dword popStack() |
{ |
stack-=4; |
RETURN DSDWORD[stack]; |
} |
:void pushStack(dword x) |
{ |
dword tmp = 0; |
IF(!DSDWORD[stack]) tmp = malloc(30); |
ELSE tmp = DSDWORD[stack]; |
IF(x) memcpy(tmp,x,30); |
DSDWORD[stack] = tmp; |
stack+=4; |
} |
:dword stackFast = 0; |
:dword beginStackFast = 0; |
:dword popFast() |
{ |
stackFast-=4; |
RETURN DSDWORD[stackFast]; |
} |
:void pushFast(dword x) |
{ |
dword tmp = 0; |
IF(!DSDWORD[stackFast]) tmp = malloc(30); |
ELSE tmp = DSDWORD[stackFast]; |
IF(x) memcpy(tmp,x,30); |
DSDWORD[stackFast] = tmp; |
stackFast+=4; |
} |
:dword stackLoop = 0; |
:dword popLoop() |
{ |
stackLoop-=4; |
RETURN DSDWORD[stackLoop]; |
} |
:void pushLoop(dword x) |
{ |
DSDWORD[stackLoop] = x; |
stackLoop+=4; |
} |
:void checkType(dword x,y) |
{ |
IF(DSBYTE[x+4]!=DSBYTE[y+4]) |
{ |
_stdout("Error type!"); |
ExitProcess(); |
} |
} |
:void sprintf(dword str, ...) |
{ |
//S = DSBYTE[format]; |
X = DSDWORD[ESP]-ESP-8; |
X += ESP; |
A = DSDWORD[X]; |
X-=4; |
B = DSDWORD[X]; |
S = DSBYTE[B]; |
while(S) |
{ |
if(S=='%') |
{ |
B++; |
S = DSBYTE[B]; |
IF(S=='s') |
{ |
X-=4; |
strcpy(A,DSDWORD[X]); |
A+=EAX; |
B++; |
S = DSBYTE[B]; |
continue; |
} |
IF(S=='c') |
{ |
X-=4; |
EAX = DSDWORD[X]; |
test(EAX,1); |
A++; |
B++; |
S = DSBYTE[B]; |
continue; |
} |
ELSE IF(S=='d') |
{ |
} |
ELSE |
{ |
DSBYTE[A] = S; |
A++; |
} |
} |
else |
{ |
DSBYTE[A] = S; |
A++; |
} |
B++; |
S = DSBYTE[B]; |
} |
} |
:byte BUFTST[15] = {0}; |
:void test1(dword x,y) |
{ |
IF(y) |
{ |
itoa(x,#BUFTST); |
_stdout(#BUFTST); |
} |
ELSE _stdout(x); |
EAX = -1; |
$int 0x40; |
} |
:void test2(dword x,y) |
{ |
_stdout("["); |
IF(y) |
{ |
itoa(x,#BUFTST); |
_stdout(#BUFTST); |
} |
ELSE _stdout(x); |
_stdout("]"); |
} |
:void ______INIT______() |
{ |
dword o = 0; |
dword o2 = 0; |
memInit(); |
stack = malloc(1000); |
beginStack = stack; |
stackFast = malloc(1000); |
beginStackFast = stackFast; |
stackLoop = malloc(1000); |
TEMP = malloc(500); |
//o = malloc(16*4); |
//memcpy(o,"test123456789",9); |
//test(123); |
//sprintf(TEMP,"asd%sa=%c123","ok",123); |
//test(TEMP,0); |
//importLibrary("console"); |
main(); |
ExitProcess(); |
} |
:void ______STOP______() |
{ |
ExitProcess(); |
} |
/programs/cmm/python/static/lib.h |
---|
0,0 → 1,201 |
:dword strcmp(dword str1,str2) |
{ |
LOOPCMP: |
IF(DSBYTE[str1]!=DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
IF(!DSBYTE[str1]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
IF(!DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
str1++; |
str2++; |
GOTO LOOPCMP; |
} |
/* |
void dll_Load() { |
asm { |
push ebp |
mov ebp, esp |
mov esi, SSDWORD[EBP+8] |
@next_lib: |
mov edx, DSDWORD[ESI] |
or edx, edx |
jz exit |
push esi |
mov esi, DSDWORD[ESI+4] |
mov edi, #libPath |
add edi,9 |
@loc01: |
lodsb |
stosb |
or al, al |
jnz loc01 |
mov eax, 68 |
mov ebx, 19 |
mov ecx, #libPath |
int 0x40 |
or eax, eax |
jz fail |
push edx |
push eax |
call dll_Link |
push eax |
mov eax, DSDWORD[eax] |
cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed.. |
pop eax |
jnz loc02 |
push DSDWORD[EAX+4] |
call dll_Init |
@loc02: |
pop esi |
add esi, 8 |
jmp next_lib |
@exit: |
xor eax, eax |
leave |
ret 4 |
@fail: |
add esp, 4 |
xor eax, eax |
inc eax |
leave |
ret 4 |
} |
} |
void dll_GetProcAddress(){ |
asm { |
push ebp |
mov ebp, esp |
mov edx, CSDWORD[EBP+8] |
xor eax, eax |
@next: |
or edx, edx |
jz end |
cmp CSDWORD[edx], 0 |
jz end |
push CSDWORD[EBP+12] |
push CSDWORD[EDX] |
call dll_StrCmp |
test eax, eax |
jz ok |
add edx, 8 |
jmp next |
@ok: |
mov eax, DSDWORD[EDX+4] |
@end: |
leave |
ret 8 |
} |
} |
void dll_StrCmp() { |
asm { |
push ebp |
mov ebp, esp |
push esi |
push edi |
mov esi, CSDWORD[EBP+8] |
mov edi, CSDWORD[EBP+12] |
xor eax, eax |
@label1: |
lodsb |
scasb |
jne fail |
or al, al |
jnz label1 |
jmp label_ok |
@fail: |
or eax, -1 |
@label_ok: |
pop edi |
pop esi |
leave |
ret 8 |
} |
} |
void dll_Link() { |
asm { |
push ebp |
mov ebp, esp |
push eax |
mov esi, SSDWORD[EBP+12] |
test esi, esi |
jz done |
@next: |
lodsd |
test eax, eax |
jz done |
push eax |
push SSDWORD[EBP+8] |
call dll_GetProcAddress |
or eax, eax |
jz loc03 |
mov DSDWORD[esi-4], eax |
jmp next |
@loc03: |
mov SSDWORD[esp], 0 |
@done: |
pop eax |
leave |
ret 8 |
} |
} |
void dll_Init() { |
asm { |
push ebp |
mov ebp, esp |
pushad |
mov eax, #malloc |
mov ebx, #free; |
mov ecx, #realloc; |
mov edx, #dll_Load; |
call SSDWORD[EBP+8] |
popad |
leave |
ret 4 |
} |
} |
*/ |
:dword importLibrary(dword name) |
{ |
dword l = 0; |
dword i = 0; |
dword list = 0; |
dword key = 0; |
dword data = 0; |
dword ret = 0; |
i = malloc(1000); |
l = strcpy(TEMP,#libPath); |
l += strcpy(TEMP+l,name); |
memcpy(TEMP+l,".obj",5); |
EAX = 68; |
EBX = 19; |
ECX = TEMP; |
$int 0x40; |
list = EAX; |
while(DSDWORD[list]) |
{ |
test2(DSDWORD[list],0); |
IF(!strcmp(DSDWORD[list],"con_init")) |
{ |
//dll_Init(DSDWORD[list+4]); |
} |
ELSE dictSet(ret,DSDWORD[list],DSDWORD[list+4]); |
list+=8; |
} |
EAX = DSDWORD[i+92]; |
i = malloc(10); |
strcpy(i,"test"); |
i = realloc(i,19); |
test1(i,0); |
} |
/programs/cmm/python/static/opcode.h |
---|
0,0 → 1,717 |
#define buffer 1024 |
:struct VAR |
{ |
dword data; |
byte type; |
dword length; |
dword stack; |
}; |
:dword build_map(dword count) |
{ |
dword o = 0; |
dword a1 = 0; |
dword a2 = 0; |
IF(count>8) o = arrayInit(count); |
ELSE o = arrayInit(8); |
WHILE(count) |
{ |
a1 = popStack(); |
a2 = popStack(); |
SWITCH(DSBYTE[a2+4]) |
{ |
CASE PY_STR: |
dictSet(#o,DSDWORD[a2],a1); |
BREAK; |
CASE PY_INT: |
arraySet(#o,1,a1); |
BREAK; |
} |
count--; |
} |
load_const(o,PY_DCT,0); |
} |
:void load_const(dword data,type,length) |
{ |
DSDWORD[#RDATA] = data; |
DSBYTE[#RDATA+4] = type; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = 0; |
pushStack(#RDATA); |
} |
: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); |
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) load_const(1,PY_BOOL,0); |
ELSE load_const(0,PY_BOOL,0); |
} |
return; |
} |
IF(!cmd)IF(DSDWORD[x] == DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==1)IF(DSDWORD[x] != DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==2)IF(DSDWORD[x] >= DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==3)IF(DSDWORD[x] <= DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==4)IF(DSDWORD[x] > DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==5)IF(DSDWORD[x] < DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
load_const(0,PY_BOOL,0); |
} |
: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() |
{ |
stackLoop-=4; |
} |
:void unary_invert() |
{ |
dword x = 0; |
x = DSDWORD[stack-4]; |
EAX = DSDWORD[x]; |
$not eax; |
DSDWORD[x] = EAX; |
} |
:void inplace(byte cmd) |
{ |
dword buffer = 0; |
dword length = 0; |
Y = popStack(); |
X = DSDWORD[stack-4]; |
IF(cmd==PY_ADD) checkType(X,Y); |
E = DSBYTE[X+4]; |
if(E==PY_STR) |
{ |
A = DSDWORD[X+5]; |
IF(cmd==PY_ADD) B = DSDWORD[Y+5]; |
ELSE |
{ |
C = DSDWORD[Y]; |
B = C*A; |
} |
length = A+B; |
buffer = length+MEMBUF; |
D = malloc(buffer); |
IF(cmd==PY_ADD) |
{ |
memcpy(D,DSDWORD[X],A); |
memcpy(D+A,DSDWORD[Y],B); |
} |
ELSE IF(cmd==PY_MUL) |
{ |
B = D; |
E = DSDWORD[X]; |
WHILE(C) |
{ |
memcpy(B,E,A); |
B+=4; |
C--; |
} |
} |
DSDWORD[#RDATA] = D; |
DSBYTE[#RDATA+4] = PY_STR; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = buffer; |
pushStack(#RDATA); |
return; |
} |
if(E==PY_INT) |
{ |
switch(cmd) |
{ |
case PY_ADD: |
DSDWORD[X] += DSDWORD[Y]; |
break; |
case PY_POW: |
length = DSDWORD[Y]; |
D = DSDWORD[X]; |
DSDWORD[X] = 1; |
WHILE(length) {DSDWORD[X]*=D; length--;} |
break; |
case PY_SUB: |
DSDWORD[X] -= DSDWORD[Y]; |
break; |
case PY_MUL: |
DSDWORD[X] *= DSDWORD[Y]; |
break; |
case PY_MOD: |
DSDWORD[X] = DSDWORD[X]%DSDWORD[Y]; |
break; |
case PY_XOR: |
DSDWORD[X] ^= DSDWORD[Y]; |
break; |
case PY_AND: |
DSDWORD[X] &= DSDWORD[Y]; |
break; |
case PY__OR: |
DSDWORD[X] |= DSDWORD[Y]; |
break; |
case PY_LSH: |
DSDWORD[X] <<= DSDWORD[Y]; |
break; |
case PY_RSH: |
DSDWORD[X] >>= DSDWORD[Y]; |
break; |
case PY_FDV: |
DSDWORD[X] /= DSDWORD[Y]; |
break; |
case PY_TDV: |
DSDWORD[X] /= DSDWORD[Y]; |
break; |
} |
} |
} |
:void binary(byte cmd) |
{ |
dword buffer = 0; |
dword length = 0; |
Y = popStack(); |
X = popStack(); |
IF(cmd==PY_ADD) checkType(X,Y); |
E = DSBYTE[X+4]; |
if(E==PY_STR) |
{ |
A = DSDWORD[X+5]; |
IF(cmd==PY_ADD) B = DSDWORD[Y+5]; |
ELSE |
{ |
C = DSDWORD[Y]; |
B = C*A; |
} |
length = A+B; |
buffer = length+MEMBUF; |
D = malloc(buffer); |
IF(cmd==PY_ADD) |
{ |
memcpy(D,DSDWORD[X],A); |
memcpy(D+A,DSDWORD[Y],B); |
} |
ELSE IF(cmd==PY_MUL) |
{ |
B = D; |
E = DSDWORD[X]; |
WHILE(C) |
{ |
memcpy(B,E,A); |
B+=4; |
C--; |
} |
} |
DSDWORD[#RDATA] = D; |
DSBYTE[#RDATA+4] = PY_STR; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = buffer; |
pushStack(#RDATA); |
return; |
} |
if(E==PY_INT) |
{ |
switch(cmd) |
{ |
case PY_ADD: |
A = DSDWORD[X] + DSDWORD[Y]; |
break; |
case PY_POW: |
length = DSDWORD[Y]; |
D = DSDWORD[X]; |
DSDWORD[Z] = 1; |
WHILE(length) {A*=D; length--;} |
break; |
case PY_SUB: |
A = DSDWORD[X] - DSDWORD[Y]; |
break; |
case PY_MUL: |
A = DSDWORD[X] * DSDWORD[Y]; |
break; |
case PY_MOD: |
A = DSDWORD[X] % DSDWORD[Y]; |
break; |
case PY_XOR: |
A = DSDWORD[X] ^ DSDWORD[Y]; |
break; |
case PY_AND: |
A = DSDWORD[X] & DSDWORD[Y]; |
break; |
case PY__OR: |
A = DSDWORD[X] | DSDWORD[Y]; |
break; |
case PY_LSH: |
A = DSDWORD[X] << DSDWORD[Y]; |
break; |
case PY_RSH: |
A = DSDWORD[X] >> DSDWORD[Y]; |
break; |
case PY_FDV: |
A = DSDWORD[X] / DSDWORD[Y]; |
break; |
case PY_TDV: |
A = DSDWORD[X] / DSDWORD[Y]; |
break; |
} |
load_const(A,PY_INT,0); |
} |
} |
:byte del(dword v) |
{ |
dword x = 0; |
x = DSDWORD[v]; |
IF(x) |
{ |
IF(DSDWORD[x+9]) free(DSDWORD[x]); |
free(x); |
DSDWORD[v] = 0; |
RETURN 1; |
} |
RETURN 0; |
} |
:void build_class(dword count) |
{ |
dword name = 0; |
dword func = 0; |
func = popFast(); |
name = popFast(); |
load_const(func,PY_CLS,0); |
} |
:void load_build_class() |
{ |
load_const(#build_class,PY_FNC,0); |
} |
:void make_function() |
{ |
stack-=4; |
} |
:void store_name(dword x) |
{ |
dword tmp = 0; |
dword stk = 0; |
stk = popStack(); |
IF(!DSDWORD[x]) |
{ |
tmp = malloc(30); |
memcpy(tmp,stk,30); |
DSDWORD[x] = tmp; |
return; |
} |
memcpy(DSDWORD[x],stk,30); |
} |
:void rot(dword x,y) |
{ |
EAX = DSDWORD[stack-8]; |
DSDWORD[stack-8] = DSDWORD[stack-4]; |
DSDWORD[stack-4] = EAX; |
} |
:void build_tuple(dword len) |
{ |
dword tuple = 0; |
dword buf = 0; |
dword l = 0; |
l = len; |
tuple = malloc(4*len+MEMBUF); |
buf = tuple; |
WHILE(len) |
{ |
DSDWORD[buf] = popStack(); |
buf+=4; |
len--; |
} |
load_const(tuple,PY_TPL,l); |
} |
:void unpack_sequence(dword len) |
{ |
dword tuple = 0; |
dword x = 0; |
popStack(); |
tuple = DSDWORD[EAX]; |
WHILE(len) |
{ |
pushStack(DSDWORD[tuple]); |
tuple+=4; |
len--; |
} |
} |
:void rot_two() |
{ |
rot(DSDWORD[stack-8],DSDWORD[stack-4]); |
} |
:void rot_three() |
{ |
rot(DSDWORD[stack-12],DSDWORD[stack-4]); |
rot(DSDWORD[stack-8],DSDWORD[stack-4]); |
} |
:void load_name(dword addr) |
{ |
pushStack(addr); |
} |
:void load_global(dword addr) |
{ |
pushStack(addr); |
} |
:dword strlen(dword txt) |
{ |
dword i = 0; |
i = txt; |
WHILE(DSBYTE[i]) i++; |
RETURN i - txt; |
} |
:dword hashString(dword x) |
{ |
dword l = 0; |
dword h = 0; |
l = x; |
WHILE(DSBYTE[x]) |
{ |
h+=DSBYTE[x]; |
h<<=1; |
x++; |
h/=x-l; |
} |
return h; |
} |
:void pop_top() |
{ |
stack-=4; |
} |
:void load_fast(dword addr) |
{ |
dword x = 0; |
IF(!DSDWORD[addr]) |
{ |
x = popFast(); |
DSDWORD[addr] = x; |
} |
ELSE x = DSDWORD[addr]; |
pushStack(x); |
} |
:void call_function(dword arg) |
{ |
dword count = 0; |
dword func = 0; |
byte type = 0; |
dword stackRet = 0; |
count = arg; |
WHILE(count) |
{ |
pushFast(popStack()); |
count--; |
} |
func = popStack(); |
//IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0); |
type = DSBYTE[func+4]; |
func = DSDWORD[func]; |
IF(!func) |
{ |
test1("Null function!",0); |
pushStack(0); |
return; |
} |
IF(type==PY_FNC) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
ELSE IF(type==PY_CLS) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
stackFast = beginStackFast; |
} |
:void call_method(dword arg) |
{ |
dword count = 0; |
dword func = 0; |
byte type = 0; |
dword stackRet = 0; |
count = arg; |
WHILE(count) |
{ |
pushFast(popStack()); |
count--; |
} |
func = popStack(); |
//IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0); |
type = DSBYTE[func+4]; |
func = DSDWORD[func]; |
IF(!func) |
{ |
test1("Null function!",0); |
pushStack(0); |
return; |
} |
IF(type==PY_FNC) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
ELSE IF(type==PY_CLS) |
{ |
func(arg); |
pushStack(EAX); |
} |
stackFast = beginStackFast; |
} |
:void load_method(dword name) |
{ |
dword x = 0; |
dword data = 0; |
dword get = 0; |
x = popStack(); |
data = DSDWORD[x]; |
get = dictGet(DSDWORD[data],name); |
pushStack(get); |
} |
:void append(dword count) |
{ |
dword x = 0; |
dword y = 0; |
x = popFast(); |
y = popFast(); |
test1(DSBYTE[x+4],1); |
} |
:void build_list(dword count) |
{ |
dword n = 0; |
dword mem = 0; |
dword i = 0; |
dword tmp = 0; |
dword method = 0; |
mem = malloc(count*4+MEMBUF); |
i = count; |
n = i*4+mem+4; |
load_const(#append,PY_FNC,0); |
dictSet(#method,"append",popStack()); |
DSDWORD[mem] = method; |
WHILE(i) |
{ |
n-=4; |
tmp = malloc(30); |
memcpy(tmp,popStack(),30); |
DSDWORD[n] = tmp; |
i--; |
} |
load_const(mem,PY_LST,count); |
} |
:dword store_fast() |
{ |
return popStack(); |
} |
:void binary_subscr() |
{ |
dword x = 0; |
dword y = 0; |
dword l1 = 0; |
dword l2 = 0; |
dword tmp = 0; |
dword ret = 0; |
byte t = 0; |
x = popStack(); |
y = popStack(); |
//IF(DSBYTE[x+4]!=PY_INT) error type; |
l1 = DSDWORD[y+5]; |
t = DSBYTE[y+4]; |
IF(t==PY_LST) |
{ |
IF(l1<=x) test1("error max list",0); |
IF(0>l1) test1("error min list",0); |
y = DSDWORD[y]; |
pushStack(DSDWORD[x*4+y]); |
return; |
} |
IF(t==PY_DCT) |
{ |
y = DSDWORD[y]; // data object |
SWITCH(DSBYTE[x+4]) |
{ |
CASE PY_INT: |
test1(DSDWORD[y],1); |
x = arrayGet(DSDWORD[y],DSDWORD[x]); |
BREAK; |
CASE PY_STR: |
x = dictGet(DSDWORD[y],DSDWORD[x]); |
BREAK; |
} |
pushStack(x); |
//test1(DSBYTE[x+4],1); |
return; |
} |
IF(t==PY_STR) |
{ |
x = DSDWORD[x]; |
IF (l1<=x)||(l1<0) test1("IndexError: string index out of range",0); |
y = DSDWORD[y]; |
tmp = malloc(MEMBUF); |
ret = malloc(30); |
DSBYTE[tmp] = DSBYTE[x+y]; |
DSDWORD[ret] = tmp; |
DSBYTE[ret+4] = PY_STR; |
DSDWORD[ret+5] = 1; |
DSDWORD[ret+9] = MEMBUF; |
pushStack(ret); |
return; |
} |
} |
:void build_slice(dword count) |
{ |
} |
/* |
: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); |
} |
*/ |