Subversion Repositories Kolibri OS

Rev

Rev 7399 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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