Subversion Repositories Kolibri OS

Rev

Rev 7399 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
7399 pavelyakov 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 
 
7401 pavelyakov 39 
:dword __offsetAllocData = 0;
40 
:dword __limitAllocSize = 0;
41 
:dword __sizeFullAllocMemory = 0;
7399 pavelyakov 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;
7401 pavelyakov 49 
	IF(!__offsetAllocData) __offsetAllocData = mallocSystem(4*40);
7399 pavelyakov 50 
	size+=4;
7401 pavelyakov 51 
	order = __offsetAllocData;
7399 pavelyakov 52 
	WHILE(orderSize
53 
	{
54 
		orderSize<<=1;
7401 pavelyakov 55 
		order+=4;
7399 pavelyakov 56 
	}
7401 pavelyakov 57 
	__sizeFullAllocMemory += orderSize;
7399 pavelyakov 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;
7401 pavelyakov 90 
	IF(!__offsetAllocData) return 0;
7399 pavelyakov 91 
	size = DSDWORD[ptr-4];
7401 pavelyakov 92 
	order = __offsetAllocData;
7399 pavelyakov 93 
	WHILE(orderSize!=size)
94 
	{
95 
		orderSize<<=1;
7401 pavelyakov 96 
		order+=4;
7399 pavelyakov 97 
	}
98 
	stackAlloc = DSDWORD[order];
99 
	DSDWORD[stackAlloc] += 4;
100 
	stackKey = DSDWORD[stackAlloc];
101 
	DSDWORD[stackKey] = ptr-4;
102 
}
103 
 
7401 pavelyakov 104 
:dword realloc(dword oldMem,size)
7399 pavelyakov 105 
{
106 
	dword newMem = 0;
107 
	dword oldSize = 0;
108 
	dword ptr1 = 0;
109 
	dword ptr2 = 0;
7401 pavelyakov 110 
	IF(!oldMem) RETURN malloc(size);
7399 pavelyakov 111 
	newMem = malloc(size);
7401 pavelyakov 112 
	oldSize = DSDWORD[oldMem-4] - 4;
113 
	ptr1 = oldMem;
7399 pavelyakov 114 
	ptr2 = newMem;
115 
	WHILE(oldSize)
116 
	{
117 
		DSBYTE[ptr2] = DSBYTE[ptr1];
118 
		ptr1++;
119 
		ptr2++;
120 
		oldSize--;
121 
	}
7401 pavelyakov 122 
	free(oldMem);
7399 pavelyakov 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______: