Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. void ExitProcess()
  2. {
  3.         EAX = -1;
  4.         $int 0x40
  5. }
  6.  
  7. :f70 write_file_70;
  8. :int CreateFile(dword data_size, buffer, file_path)
  9. {
  10.         write_file_70.func = 2;
  11.         write_file_70.param1 = 0;
  12.         write_file_70.param2 = 0;
  13.         write_file_70.param3 = data_size;
  14.         write_file_70.param4 = buffer;
  15.         write_file_70.rezerv = 0;
  16.         write_file_70.name = file_path;
  17.         $mov eax,70
  18.         $mov ebx,#write_file_70.func
  19.         $int 0x40
  20. }
  21.  
  22. dword malloc(dword size)
  23. {
  24.         $push    ebx
  25.         $push    ecx
  26.  
  27.         $mov     eax, 68
  28.         $mov     ebx, 12
  29.         $mov     ecx, size
  30.         $int     0x40
  31.        
  32.         $pop     ecx
  33.         $pop     ebx
  34.         return  EAX;
  35. }
  36. dword free(dword mptr)
  37. {
  38.         $push    ebx
  39.         $push    ecx
  40.        
  41.         $mov     eax, 68
  42.         $mov     ebx, 13
  43.         $mov     ecx, mptr
  44.         $test    ecx, ecx
  45.         $jz      end0
  46.         $int     0x40
  47.    @end0:
  48.         $pop     ecx
  49.         $pop     ebx
  50.         return 0;
  51. }
  52. :dword sleep(dword x)
  53. {
  54.         EAX = 5;
  55.         EBX = x;
  56.         $int 0x40
  57. }
  58. :dword mem_init()
  59. {
  60.         $push    ebx
  61.         $mov     eax, 68
  62.         $mov     ebx, 11
  63.         $int     0x40
  64.    
  65.         $pop     ebx
  66.         return  EAX;
  67. }
  68.  
  69.  
  70. :dword itoa(signed long number,dword p)
  71. {
  72.         dword ret=0;
  73.         byte cmd=0;
  74.         long mask=0;
  75.         long tmp=0;
  76.         IF(!number)
  77.         {
  78.                 DSBYTE[p] = '0';
  79.                 p++;
  80.                 DSBYTE[p] = 0;
  81.                 return 1;
  82.         }
  83.         mask = 1000000000;
  84.         cmd = 1;
  85.         if(!number){
  86.                         ESBYTE[p] = '0';
  87.                         ESBYTE[p+1] = 0;
  88.                         return p;
  89.         }
  90.         ret = p;
  91.         if(number<0)
  92.         {
  93.                         $neg number
  94.                         ESBYTE[p] = '-';
  95.                         $inc p
  96.         }
  97.         while(mask)
  98.         {
  99.                         tmp = number / mask;
  100.                         tmp = tmp%10;
  101.                    
  102.                         if(cmd){
  103.                                         if(tmp){
  104.                                                         ESBYTE[p] = tmp + '0';
  105.                                                         $inc p
  106.                                                         cmd = 0;
  107.                                         }
  108.                         }
  109.                         else {
  110.                                         ESBYTE[p] = tmp + '0';
  111.                                         $inc p
  112.                         }
  113.                         mask /= 10;
  114.         }
  115.         ESBYTE[p] = 0;
  116.         return p - ret;
  117. }
  118.  
  119. :void strlcpy(dword s1,s2,l)
  120. {
  121.         WHILE(l)
  122.         {
  123.                 DSBYTE[s1] = DSBYTE[s2];
  124.                 s1++;
  125.                 s2++;
  126.                 l--;
  127.         }
  128. }
  129.  
  130. :dword _str(dword v)
  131. {
  132.         switch(DSBYTE[v+4])
  133.         {
  134.                 case PY_STR:
  135.                         return DSDWORD[v];
  136.                 break;
  137.                 case PY_BOOL:
  138.                         if(DSDWORD[v])return "True";
  139.                         return "False";
  140.                 break;
  141.                
  142.         }
  143. }
  144.  
  145. :dword stack = 0;
  146. :dword popStack()
  147. {
  148.         IF(!stack) RETURN 0;
  149.         stack-=4;
  150.         RETURN DSDWORD[stack];
  151. }
  152. :void pushStack(dword x)
  153. {
  154.         DSDWORD[stack] = x;
  155.         stack+=4;
  156. }
  157.  
  158. :dword stackFast = 0;
  159. :dword beginStackFast = 0;
  160. :dword popFast()
  161. {
  162.         IF(!stackFast) RETURN 0;
  163.         stackFast-=4;
  164.         RETURN DSDWORD[stackFast];
  165. }
  166. :void pushFast(dword x)
  167. {
  168.         DSDWORD[stackFast] = x;
  169.         stackFast+=4;
  170. }
  171.  
  172. :dword stackLoop = 0;
  173. :dword popLoop()
  174. {
  175.         stackLoop-=4;
  176.         RETURN DSDWORD[stackLoop];
  177. }
  178. :void pushLoop(dword x)
  179. {
  180.         DSDWORD[stackLoop] = x;
  181.         stackLoop+=4;
  182. }
  183.  
  184. :void checkType(dword x,y)
  185. {
  186.         if(DSBYTE[x+4]!=DSBYTE[y+4])
  187.         {
  188.                 _stdout("Error type!");
  189.                 ExitProcess();
  190.         }
  191. }
  192.  
  193.  
  194. :byte BUFTST[15] = {0};
  195. :void test(dword x,c)
  196. {
  197.         if(c)
  198.         {
  199.                 itoa(x,#BUFTST);
  200.                 _stdout(#BUFTST);
  201.         }
  202.         else _stdout(x);
  203.         EAX = -1;
  204.         $int 0x40;
  205. }
  206.  
  207. void ______INIT______()
  208. {
  209.         mem_init();
  210.        
  211.         HASH = 0;
  212.        
  213.         stack = malloc(1000);
  214.         stackFast = malloc(1000);
  215.         beginStackFast = stackFast;
  216.         stackLoop = malloc(1000);
  217.         TEMP = malloc(100);
  218.        
  219.         main();
  220.         ExitProcess();
  221. }
  222.  
  223. void ______STOP______()
  224. {
  225.         ExitProcess();
  226. }