Subversion Repositories Kolibri OS

Rev

Rev 7399 | 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 __limitAllocSize = 0;
  41. :dword __sizeFullAllocMemory = 0;
  42. :dword malloc(dword size)
  43. {
  44.         dword orderSize = 1;
  45.         dword order = 0;
  46.         dword stackAlloc = 0;
  47.         dword stackKey = 0;
  48.         dword result = 0;
  49.         IF(!__offsetAllocData) __offsetAllocData = mallocSystem(4*40);
  50.         size+=4;
  51.         order = __offsetAllocData;
  52.         WHILE(orderSize<size)
  53.         {
  54.                 orderSize<<=1;
  55.                 order+=4;
  56.         }
  57.         __sizeFullAllocMemory += orderSize;
  58.         IF(!DSDWORD[order])
  59.         {
  60.                 stackAlloc = mallocSystem(4*50);
  61.                 DSDWORD[order] = stackAlloc;
  62.                 DSDWORD[stackAlloc] = stackAlloc;
  63.         }
  64.         ELSE stackAlloc = DSDWORD[order];
  65.        
  66.         stackKey = DSDWORD[stackAlloc];
  67.         IF(stackKey == stackAlloc)
  68.         {
  69.                 result = mallocSystem(orderSize);
  70.                 DSDWORD[result] = orderSize;
  71.                 return result+4;
  72.         }
  73.         ELSE
  74.         {
  75.                 result = DSDWORD[stackKey];
  76.                 DSDWORD[stackAlloc] = stackKey-4;
  77.                 return result+4;
  78.         }
  79. }
  80.  
  81. :dword free(dword ptr)
  82. {
  83.         dword array = 0;
  84.         dword orderSize = 1;
  85.         dword order = 0;
  86.         dword stackAlloc = 0;
  87.         dword stackKey = 0;
  88.         dword result = 0;
  89.         dword size = 0;
  90.         IF(!__offsetAllocData) return 0;
  91.         size = DSDWORD[ptr-4];
  92.         order = __offsetAllocData;
  93.         WHILE(orderSize!=size)
  94.         {
  95.                 orderSize<<=1;
  96.                 order+=4;
  97.         }
  98.         stackAlloc = DSDWORD[order];
  99.         DSDWORD[stackAlloc] += 4;
  100.         stackKey = DSDWORD[stackAlloc];
  101.         DSDWORD[stackKey] = ptr-4;
  102. }
  103.  
  104. :dword realloc(dword oldMem,size)
  105. {
  106.         dword newMem = 0;
  107.         dword oldSize = 0;
  108.         dword ptr1 = 0;
  109.         dword ptr2 = 0;
  110.         IF(!oldMem) RETURN malloc(size);
  111.         newMem = malloc(size);
  112.         oldSize = DSDWORD[oldMem-4] - 4;
  113.         ptr1 = oldMem;
  114.         ptr2 = newMem;
  115.         WHILE(oldSize)
  116.         {
  117.                 DSBYTE[ptr2] = DSBYTE[ptr1];
  118.                 ptr1++;
  119.                 ptr2++;
  120.                 oldSize--;
  121.         }
  122.         free(oldMem);
  123.         RETURN newMem;
  124. }
  125.  
  126. void main()
  127. {
  128.         dword o1 = 0;
  129.         dword o2 = 0;
  130.         dword o3 = 0;
  131.         while(1)
  132.         {
  133.                 o1 = malloc(1000);
  134.                 o2 = malloc(10000);
  135.                 o3 = malloc(1000);
  136.                 o1 = realloc(o3,2000);
  137.                 free(o2);
  138.                 free(o1);
  139.                 free(o3);
  140.         }
  141.        
  142.         EAX = -1;
  143.         $int 0x40;
  144. }
  145.  
  146.  
  147. ______STOP______: