Subversion Repositories Kolibri OS

Rev

Rev 7399 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7399 Rev 7401
Line 34... Line 34...
34 
	$pop ecx
 34 
	$pop ecx
35 
	$pop ebx
 35 
	$pop ebx
36 
	return  EAX;
 36 
	return  EAX;
37 
}
 37 
}
Line 38... Line 38...
38 
 
 38 
 
- 
 
 39 
:dword __offsetAllocData = 0;
- 
 
 40 
:dword __limitAllocSize = 0;
39 
:dword offsetAllocData = 0;
 41 
:dword __sizeFullAllocMemory = 0;
40 
:dword malloc(dword size)
 42 
:dword malloc(dword size)
41 
{
 - 
 
42 
	dword array = 0;
 43 
{
43 
	dword orderSize = 1;
 44 
	dword orderSize = 1;
44 
	dword order = 0;
 45 
	dword order = 0;
45 
	dword stackAlloc = 0;
 46 
	dword stackAlloc = 0;
46 
	dword stackKey = 0;
 47 
	dword stackKey = 0;
- 
 
 48 
	dword result = 0;
47 
	dword result = 0;
 49 
	IF(!__offsetAllocData) __offsetAllocData = mallocSystem(4*40);
48 
	size+=4;
 50 
	size+=4;
49 
	IF(!offsetAllocData) offsetAllocData = mallocSystem(4*32);
 - 
 
50
51 
	order = __offsetAllocData;
51 
	WHILE(orderSize
 52 
	WHILE(orderSize
52 
	{
 53 
	{
53 
		orderSize<<=1;
 54 
		orderSize<<=1;
54 
		order++;
 55 
		order+=4;
55 
	}
 - 
 
56 
	order<<=2;
 56 
	}
57 
	order += offsetAllocData;
 - 
 
58
57 
	__sizeFullAllocMemory += orderSize;
59 
	IF(!DSDWORD[order])
58 
	IF(!DSDWORD[order])
60 
	{
 59 
	{
61 
		stackAlloc = mallocSystem(4*50);
 60 
		stackAlloc = mallocSystem(4*50);
62 
		DSDWORD[order] = stackAlloc;
 61 
		DSDWORD[order] = stackAlloc;
Line 77... Line 76...
77 
		DSDWORD[stackAlloc] = stackKey-4;
 76 
		DSDWORD[stackAlloc] = stackKey-4;
78 
		return result+4;
 77 
		return result+4;
79 
	}
 78 
	}
80 
}
 79 
}
Line 81... Line -...
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 
 
 80 
 
101 
:dword free(dword ptr)
 81 
:dword free(dword ptr)
102 
{
 82 
{
103 
	dword array = 0;
 83 
	dword array = 0;
104 
	dword orderSize = 1;
 84 
	dword orderSize = 1;
105 
	dword order = 0;
 85 
	dword order = 0;
106 
	dword stackAlloc = 0;
 86 
	dword stackAlloc = 0;
107 
	dword stackKey = 0;
 87 
	dword stackKey = 0;
108 
	dword result = 0;
 88 
	dword result = 0;
- 
 
 89 
	dword size = 0;
109 
	dword size = 0;
 90 
	IF(!__offsetAllocData) return 0;
110 
	size = DSDWORD[ptr-4];
 91 
	size = DSDWORD[ptr-4];
111 
	IF(!offsetAllocData) return 0;
 - 
 
112
92 
	order = __offsetAllocData;
113 
	WHILE(orderSize!=size)
 93 
	WHILE(orderSize!=size)
114 
	{
 94 
	{
115 
		orderSize<<=1;
 95 
		orderSize<<=1;
116 
		order++;
 96 
		order+=4;
117 
	}
 - 
 
118 
	order<<=2;
 - 
 
119 
	order += offsetAllocData;
 97 
	}
120 
	stackAlloc = DSDWORD[order];
 98 
	stackAlloc = DSDWORD[order];
121 
	DSDWORD[stackAlloc] += 4;
 99 
	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 
	}
 100 
	stackKey = DSDWORD[stackAlloc];
131 
	DSDWORD[stackKey] = ptr-4;
 101 
	DSDWORD[stackKey] = ptr-4;
Line 132... Line 102...
132 
}
 102 
}
133 
 
 103 
 
134 
:dword realloc(dword ptr,size)
 104 
:dword realloc(dword oldMem,size)
135 
{
 105 
{
136 
	dword newMem = 0;
 106 
	dword newMem = 0;
137 
	dword oldSize = 0;
 107 
	dword oldSize = 0;
- 
 
 108 
	dword ptr1 = 0;
138 
	dword ptr1 = 0;
 109 
	dword ptr2 = 0;
139 
	dword ptr2 = 0;
 110 
	IF(!oldMem) RETURN malloc(size);
140 
	newMem = malloc(size);
 111 
	newMem = malloc(size);
141 
	oldSize = DSDWORD[ptr-4] - 4;
 112 
	oldSize = DSDWORD[oldMem-4] - 4;
142 
	ptr1 = ptr;
 113 
	ptr1 = oldMem;
143 
	ptr2 = newMem;
 114 
	ptr2 = newMem;
144 
	WHILE(oldSize)
 115 
	WHILE(oldSize)
145 
	{
 116 
	{
146 
		DSBYTE[ptr2] = DSBYTE[ptr1];
 117 
		DSBYTE[ptr2] = DSBYTE[ptr1];
147 
		ptr1++;
 118 
		ptr1++;
148 
		ptr2++;
 119 
		ptr2++;
149 
		oldSize--;
 120 
		oldSize--;
150 
	}
 121 
	}
151 
	free(ptr);
 122 
	free(oldMem);
Line 152... Line 123...
152 
	RETURN newMem;
 123 
	RETURN newMem;
153 
}
 124 
}