Subversion Repositories Kolibri OS

Rev

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

  1. #pragma option OST
  2. #pragma option ON
  3. #pragma option cri-
  4. #pragma option -CPA
  5. #initallvar 0
  6. #jumptomain FALSE
  7.  
  8. #startaddress 0x0000
  9.  
  10. #code32 TRUE
  11.  
  12. char   os_name[8]   = {'M','E','N','U','E','T','0','1'};
  13. dword  os_version   = 0x00000001;
  14. dword  start_addr   = #main;
  15. dword  final_addr   = #______STOP______+32;
  16. dword  alloc_mem    = 20000;
  17. dword  x86esp_reg   = 20000;
  18. dword  I_Param      = #param;
  19. dword  I_Path       = #program_path;
  20. char param[4096] ={0};
  21. char program_path[4096] = {0};
  22.  
  23.  
  24. :dword mallocSystem(dword size)
  25. {
  26.         $push ebx
  27.         $push ecx
  28.        
  29.         $mov     eax, 68
  30.         $mov     ebx, 12
  31.         $mov     ecx, size
  32.         $int     0x40
  33.        
  34.         $pop ecx
  35.         $pop ebx
  36.         return  EAX;
  37. }
  38.  
  39. :dword offsetAllocData = 0;
  40. :dword malloc(dword size)
  41. {
  42.         dword array = 0;
  43.         dword orderSize = 1;
  44.         dword order = 0;
  45.         dword stackAlloc = 0;
  46.         dword stackKey = 0;
  47.         dword result = 0;
  48.         size+=4;
  49.         IF(!offsetAllocData) offsetAllocData = mallocSystem(4*32);
  50.        
  51.         WHILE(orderSize<size)
  52.         {
  53.                 orderSize<<=1;
  54.                 order++;
  55.         }
  56.         order<<=2;
  57.         order += offsetAllocData;
  58.        
  59.         IF(!DSDWORD[order])
  60.         {
  61.                 stackAlloc = mallocSystem(4*50);
  62.                 DSDWORD[order] = stackAlloc;
  63.                 DSDWORD[stackAlloc] = stackAlloc;
  64.         }
  65.         ELSE stackAlloc = DSDWORD[order];
  66.        
  67.         stackKey = DSDWORD[stackAlloc];
  68.         IF(stackKey == stackAlloc)
  69.         {
  70.                 result = mallocSystem(orderSize);
  71.                 DSDWORD[result] = orderSize;
  72.                 return result+4;
  73.         }
  74.         ELSE
  75.         {
  76.                 result = DSDWORD[stackKey];
  77.                 DSDWORD[stackAlloc] = stackKey-4;
  78.                 return result+4;
  79.         }
  80. }
  81.  
  82. /*:dword freeSystem(dword mptr)
  83. {
  84.         $push    eax
  85.         $push    ebx
  86.         $push    ecx
  87.        
  88.         $mov     eax, 68
  89.         $mov     ebx, 13
  90.         $mov     ecx, mptr
  91.         $test    ecx, ecx
  92.         $jz      end0
  93.         $int     0x40
  94.    @end0:
  95.         $pop     ecx
  96.         $pop     ebx
  97.         $pop     eax
  98.         return 0;
  99. }*/
  100.  
  101. :dword free(dword ptr)
  102. {
  103.         dword array = 0;
  104.         dword orderSize = 1;
  105.         dword order = 0;
  106.         dword stackAlloc = 0;
  107.         dword stackKey = 0;
  108.         dword result = 0;
  109.         dword size = 0;
  110.         size = DSDWORD[ptr-4];
  111.         IF(!offsetAllocData) return 0;
  112.        
  113.         WHILE(orderSize!=size)
  114.         {
  115.                 orderSize<<=1;
  116.                 order++;
  117.         }
  118.         order<<=2;
  119.         order += offsetAllocData;
  120.         stackAlloc = DSDWORD[order];
  121.         DSDWORD[stackAlloc] += 4;
  122.         stackKey = DSDWORD[stackAlloc];
  123.         order = ptr;
  124.         orderSize -= 4;
  125.         WHILE(orderSize)
  126.         {
  127.                 DSBYTE[order] = 0;
  128.                 order++;
  129.                 orderSize--;
  130.         }
  131.         DSDWORD[stackKey] = ptr-4;
  132. }
  133.  
  134. :dword realloc(dword ptr,size)
  135. {
  136.         dword newMem = 0;
  137.         dword oldSize = 0;
  138.         dword ptr1 = 0;
  139.         dword ptr2 = 0;
  140.         newMem = malloc(size);
  141.         oldSize = DSDWORD[ptr-4] - 4;
  142.         ptr1 = ptr;
  143.         ptr2 = newMem;
  144.         WHILE(oldSize)
  145.         {
  146.                 DSBYTE[ptr2] = DSBYTE[ptr1];
  147.                 ptr1++;
  148.                 ptr2++;
  149.                 oldSize--;
  150.         }
  151.         free(ptr);
  152.         RETURN newMem;
  153. }
  154.  
  155. void main()
  156. {
  157.         dword o1 = 0;
  158.         dword o2 = 0;
  159.         dword o3 = 0;
  160.         while(1)
  161.         {
  162.                 o1 = malloc(1000);
  163.                 o2 = malloc(10000);
  164.                 o3 = malloc(1000);
  165.                 o1 = realloc(o3,2000);
  166.                 free(o2);
  167.                 free(o1);
  168.                 free(o3);
  169.         }
  170.        
  171.         EAX = -1;
  172.         $int 0x40;
  173. }
  174.  
  175.  
  176. ______STOP______: