1 /******************************************************************************
2 *
3 * Copyright (C) 2004-2008, The Gentee Group. All rights reserved.
4 * This file is part of the Gentee open source project - http://www.gentee.com.
5 *
6 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE GENTEE LICENSE ("AGREEMENT").
7 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE CONSTITUTES RECIPIENTS
8 * ACCEPTANCE OF THE AGREEMENT.
9 *
10 * Author: Alexander Krivonogov ( algen )
11 *
12 ******************************************************************************/
13
14 /*-----------------------------------------------------------------------------
15 * Id: system L "System"
16 *
17 * Summary: System functions.
18 *
19 * List: *,max,min,
20 *Callback and search features,callback,freecallback,getid,
21 *Type functions,destroy,new,sizeof,type_delete,type_hasdelete,
22 type_hasinit,type_init
23 *
24 -----------------------------------------------------------------------------*/
25
26 define <export>
27 {
28 /*-----------------------------------------------------------------------------
29 * Id: getidflags D
30 *
31 * Summary: Flags for getid function.
32 *
33 -----------------------------------------------------------------------------*/
34 GETID_METHOD = 0x01 // Search method. Specify the main type of the /
35 // method as the first parameter in the collection.
36 GETID_OPERATOR = 0x02 // Search operator. You can specify the operator in /
37 // name as is. For example, #b(+=).
38 GETID_OFTYPE = 0x04 // Specify this flag if you want to describe /
39 // parameters with types of items (of type). In this case, /
40 // collection must contains pairs - idtype and idoftype.
41 //-----------------------------------------------------------------------------
42 }
43
44 /*-----------------------------------------------------------------------------
45 * Id: max F
46 *
47 * Summary: Determining the largest of two numbers.
48 *
49 * Params: left - The first compared number of the uint type.
50 right - The second compared number of the uint type.
51 *
52 * Return: The largest of two numbers.
53 *
54 -----------------------------------------------------------------------------*/
55
56 func uint max( uint left, uint right )
57 {
58 return ?( left > right, left, right )
59 }
60
61 /*-----------------------------------------------------------------------------
62 * Id: min F
63 *
64 * Summary: Determining the smallest of two numbers.
65 *
66 * Params: left - The first compared number of the uint type.
67 right - The second compared number of the uint type.
68 *
69 * Return: The smallest of two numbers.
70 *
71 -----------------------------------------------------------------------------*/
72
73 func uint min( uint left, uint right )
74 {
75 return ?( left < right, left, right )
76 }
77
78 /*-----------------------------------------------------------------------------
79 * Id: max_1 F8
80 *
81 * Summary: Determining the largest of two int numbers.
82 *
83 * Params: left - The first compared number of the int type.
84 right - The second compared number of the int type.
85 *
86 * Return: The largest of two int numbers.
87 *
88 -----------------------------------------------------------------------------*/
89
90 func uint max( int left, int right )
91 {
92 return ?( left > right, left, right )
93 }
94
95 /*-----------------------------------------------------------------------------
96 * Id: min_1 F8
97 *
98 * Summary: Determining the smallest of two int numbers.
99 *
100 * Params: left - The first compared number of the int type.
101 right - The second compared number of the int type.
102 *
103 * Return: The smallest of two int numbers.
104 *
105 -----------------------------------------------------------------------------*/
106
107 func uint min( int left, int right )
108 {
109 return ?( left < right, left, right )
110 }
111
112 /*-----------------------------------------------------------------------------
113 * Id: new F
114 *
115 * Summary: Creating an object. The function creates an object of the specified
116 type.
117 *
118 * Params: objtype - The identifier or the name of a type.
119 *
120 * Return: The pointer to the created object.
121 *
122 -----------------------------------------------------------------------------*/
123
124 func uint new( uint objtype )
125 {
126 return new( objtype, 0 )
127 }
128
129 /*-----------------------------------------------------------------------------
130 * Id: new_1 F8
131 *
132 * Summary: The function creates an object with specifing the count and the
133 type of its items.
134 *
135 * Params: objtype - The identifier or the name of a type.
136 oftype - The type of object's items.
137 count - The initial count of object's items.
138 *
139 * Return: The pointer to the created object.
140 *
141 -----------------------------------------------------------------------------*/
142
143 func uint new( uint objtype, uint oftype, uint count )
144 {
145 uint ret funcof
146
147 ret = new( objtype, 0 )
148 if oftype && funcof = getid("oftype", 1 /*GETID_METHOD*/,
149 %{ objtype, uint } )
150 {
151 funcof->func( ret, oftype )
152 }
153 if count && funcof = getid("array", 1 /*GETID_METHOD*/, %{ objtype, uint } )
154 {
155 funcof->func( ret, count )
156 }
157 return ret
158 }
159
160 /*
161 50 push eax
162 55 push ebp
163 53 push ebx
164 8B DC mov ebx, esp
165 83 C3 XX add ebx, ( parsize * 4 + 0Ch )
166 8B EB mov ebp, ebx
167 83 ED XX sub ebp, ( parsize * 4 )
168 3B EB cmp ebp, ebx
169 74 08 je endcopy
170 8B 03 mov eax, [ebx]
171 50 push eax
172 83 EB 04 sub ebx, 4
173 EB F4 jmp copy
174 83 ED 04 sub ebp, 4
175 55 push ebp
176 68 01 01 00 00 push id
177 ba XX XX XX XX mov edx, &ge_call
178 ff d2 call edx
179 83 C4 XX add esp, ( parsize + 2 )* 4
180 5B pop ebx
181 5D pop ebp
182 58 pop eax
183 C2 XX ret ( parsize * 4 )
184 00
185 */
186
187 import "kernel32.dll"
188 {
189 uint VirtualAlloc( uint, uint, uint, uint )
190 uint VirtualFree( uint, uint, uint )
191 }
192
193 /*-----------------------------------------------------------------------------
194 * Id: callback F
195 *
196 * Summary: Create a callback function. This function allows you to use gentee
197 functions as callback functions. For example, gentee function
198 can be specified as a message handler for windows.
199 *
200 * Params: idfunc - Identifier ( address ) of gentee function that will be /
201 callback function.
202 parsize - The summary size of parameters (number of uint values). /
203 One parameter uint = 1 (uint = 1). uint + uint = 2, uint + long = 3.
204 *
205 * Return: You can use the return value as the callback address. You have to
206 free it with #a(freecallback) function when you don't need this
207 callback function.
208 *
209 -----------------------------------------------------------------------------*/
210
211 func uint callback( uint idfunc, uint parsize )
212 {
213 buf bc = '\h
214 50
215 55
216 53
217 8B DC
218 83 C3 \(byte( parsize * 4 + 0x0C ))
219 8B EB
220 83 ED \(byte( parsize * 4 ))
221 3B EB
222 74 08
223 8B 03
224 50
225 83 EB 04
226 EB F4
227 83 ED 04
228 55
229 68 \( idfunc )
230 b8 \( calladdr() )
231 ff d0
232 83 C4 \(byte( ( parsize + 2 )* 4 ))
233 5B
234 5D
235 58
236 C2 \( parsize * 4 )
237 00
238 '
239 // ba \( calladdr() ) till 12.01.09
240 // ff d2
241 uint pmem
242 pmem = VirtualAlloc( 0, *bc, 0x3000, 0x40 )
243 //print( "mem = \(hex2strl(pmem))\n" )
244 mcopy( pmem, bc.ptr(), *bc )
245 return pmem
246
247 }
248
249 /*-----------------------------------------------------------------------------
250 ** Id: freecallback F
251 *
252 * Summary: Free a created callback function.
253 *
254 * Params: pmem - The pointer that was returned by #a(callback) function.
255 *
256 -----------------------------------------------------------------------------*/
257
258 func freecallback( uint pmem )
259 {
260 VirtualFree( pmem, 0, 0x8000 )
261 }
262
263
264