diff --git a/programs/cmm/python/static/array.h b/programs/cmm/python/static/array.h new file mode 100644 index 0000000000..dcc54b1526 --- /dev/null +++ b/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]; +} \ No newline at end of file diff --git a/programs/cmm/python/static/function.h b/programs/cmm/python/static/function.h new file mode 100644 index 0000000000..ed76eb0177 --- /dev/null +++ b/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 = ""; + 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; + } +} \ No newline at end of file diff --git a/programs/cmm/python/static/gui.h b/programs/cmm/python/static/gui.h new file mode 100644 index 0000000000..e69de29bb2 diff --git a/programs/cmm/python/static/head.h b/programs/cmm/python/static/head.h new file mode 100644 index 0000000000..fc93a459c5 --- /dev/null +++ b/programs/cmm/python/static/head.h @@ -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; +}; diff --git a/programs/cmm/python/static/init.h b/programs/cmm/python/static/init.h new file mode 100644 index 0000000000..9bcc0a78a4 --- /dev/null +++ b/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(); +} \ No newline at end of file diff --git a/programs/cmm/python/static/lib.h b/programs/cmm/python/static/lib.h new file mode 100644 index 0000000000..b1d3f3b042 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/programs/cmm/python/static/opcode.h b/programs/cmm/python/static/opcode.h new file mode 100644 index 0000000000..0b7d466e21 --- /dev/null +++ b/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); +} +*/ \ No newline at end of file