Mercurial > vba-clojure

comparison src/common/CheatSearch.cpp @ 1:f9f4f1b99eed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importing src directory
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:31:27 -0600
parents
children
comparison
equal deleted inserted replaced
0:8ced16adf2e1 1:f9f4f1b99eed
1 #include <cstdlib>
2 #include <cstring>
3
4 #include "CheatSearch.h"
5
6 CheatSearchBlock cheatSearchBlocks[4];
7
8 CheatSearchData cheatSearchData = {
9 0,
10 cheatSearchBlocks
11 };
12
13 static bool cheatSearchEQ(u32 a, u32 b)
14 {
15 return a == b;
16 }
17
18 static bool cheatSearchNE(u32 a, u32 b)
19 {
20 return a != b;
21 }
22
23 static bool cheatSearchLT(u32 a, u32 b)
24 {
25 return a < b;
26 }
27
28 static bool cheatSearchLE(u32 a, u32 b)
29 {
30 return a <= b;
31 }
32
33 static bool cheatSearchGT(u32 a, u32 b)
34 {
35 return a > b;
36 }
37
38 static bool cheatSearchGE(u32 a, u32 b)
39 {
40 return a >= b;
41 }
42
43 static bool cheatSearchSignedEQ(s32 a, s32 b)
44 {
45 return a == b;
46 }
47
48 static bool cheatSearchSignedNE(s32 a, s32 b)
49 {
50 return a != b;
51 }
52
53 static bool cheatSearchSignedLT(s32 a, s32 b)
54 {
55 return a < b;
56 }
57
58 static bool cheatSearchSignedLE(s32 a, s32 b)
59 {
60 return a <= b;
61 }
62
63 static bool cheatSearchSignedGT(s32 a, s32 b)
64 {
65 return a > b;
66 }
67
68 static bool cheatSearchSignedGE(s32 a, s32 b)
69 {
70 return a >= b;
71 }
72
73 static bool (*cheatSearchFunc[])(u32, u32) = {
74 cheatSearchEQ,
75 cheatSearchNE,
76 cheatSearchLT,
77 cheatSearchLE,
78 cheatSearchGT,
79 cheatSearchGE
80 };
81
82 static bool (*cheatSearchSignedFunc[])(s32, s32) = {
83 cheatSearchSignedEQ,
84 cheatSearchSignedNE,
85 cheatSearchSignedLT,
86 cheatSearchSignedLE,
87 cheatSearchSignedGT,
88 cheatSearchSignedGE
89 };
90
91 void cheatSearchSetSavedAndBits(CheatSearchBlock *block)
92 {
93 if (!block->saved)
94 {
95 block->saved = (u8 *)malloc(block->size);
96 memcpy(block->saved, block->data, block->size);
97 }
98 if (!block->bits)
99 {
100 block->bits = (u8 *)malloc(block->size >> 3);
101 memset(block->bits, 0xff, block->size >> 3);
102 }
103 }
104
105 void cheatSearchZeroBlock(CheatSearchBlock *block)
106 {
107 block->data = 0;
108 block->offset = 0;
109 block->size = 0;
110 free(block->saved);
111 free(block->bits);
112 block->saved = 0;
113 block->bits = 0;
114 }
115
116 void cheatSearchCleanup(CheatSearchData *cs)
117 {
118 int count = cs->count;
119
120 for (int i = 0; i < count; i++)
121 {
122 CheatSearchBlock &block = cs->blocks[i];
123 free(block.saved);
124 free(block.bits);
125 block.saved = 0;
126 block.bits = 0;
127 }
128 cs->count = 0;
129 }
130
131 void cheatSearchStart(const CheatSearchData *cs)
132 {
133 int count = cs->count;
134
135 for (int i = 0; i < count; i++)
136 {
137 CheatSearchBlock *block = &cs->blocks[i];
138
139 memset(block->bits, 0xff, block->size >> 3);
140 memcpy(block->saved, block->data, block->size);
141 }
142 }
143
144 s32 cheatSearchSignedRead(u8 *data, int off, int size)
145 {
146 u32 res = data[off++];
147
148 switch (size)
149 {
150 case BITS_8:
151 res <<= 24;
152 return ((s32)res) >> 24;
153 case BITS_16:
154 res |= ((u32)data[off++])<<8;
155 res <<= 16;
156 return ((s32)res) >> 16;
157 case BITS_32:
158 res |= ((u32)data[off++])<<8;
159 res |= ((u32)data[off++])<<16;
160 res |= ((u32)data[off++])<<24;
161 return (s32)res;
162 }
163 return (s32)res;
164 }
165
166 u32 cheatSearchRead(u8 *data, int off, int size)
167 {
168 u32 res = data[off++];
169 if (size == BITS_16)
170 res |= ((u32)data[off++])<<8;
171 else if (size == BITS_32)
172 {
173 res |= ((u32)data[off++])<<8;
174 res |= ((u32)data[off++])<<16;
175 res |= ((u32)data[off++])<<24;
176 }
177 return res;
178 }
179
180 void cheatSearch(const CheatSearchData *cs, int compare, int size,
181 bool isSigned)
182 {
183 if (compare < 0 || compare > SEARCH_GE)
184 return;
185 int inc = 1;
186 if (size == BITS_16)
187 inc = 2;
188 else if (size == BITS_32)
189 inc = 4;
190
191 if (isSigned)
192 {
193 bool (*func)(s32, s32) = cheatSearchSignedFunc[compare];
194
195 for (int i = 0; i < cs->count; i++)
196 {
197 CheatSearchBlock *block = &cs->blocks[i];
198 int size2 = block->size;
199 u8 *bits = block->bits;
200 u8 *data = block->data;
201 u8 *saved = block->saved;
202
203 for (int j = 0; j < size2; j += inc)
204 {
205 if (IS_BIT_SET(bits, j))
206 {
207 s32 a = cheatSearchSignedRead(data, j, size);
208 s32 b = cheatSearchSignedRead(saved, j, size);
209
210 if (!func(a, b))
211 {
212 CLEAR_BIT(bits, j);
213 if (size == BITS_16)
214 CLEAR_BIT(bits, j+1);
215 if (size == BITS_32)
216 {
217 CLEAR_BIT(bits, j+2);
218 CLEAR_BIT(bits, j+3);
219 }
220 }
221 }
222 }
223 }
224 }
225 else
226 {
227 bool (*func)(u32, u32) = cheatSearchFunc[compare];
228
229 for (int i = 0; i < cs->count; i++)
230 {
231 CheatSearchBlock *block = &cs->blocks[i];
232 int size2 = block->size;
233 u8 *bits = block->bits;
234 u8 *data = block->data;
235 u8 *saved = block->saved;
236
237 for (int j = 0; j < size2; j += inc)
238 {
239 if (IS_BIT_SET(bits, j))
240 {
241 u32 a = cheatSearchRead(data, j, size);
242 u32 b = cheatSearchRead(saved, j, size);
243
244 if (!func(a, b))
245 {
246 CLEAR_BIT(bits, j);
247 if (size == BITS_16)
248 CLEAR_BIT(bits, j+1);
249 if (size == BITS_32)
250 {
251 CLEAR_BIT(bits, j+2);
252 CLEAR_BIT(bits, j+3);
253 }
254 }
255 }
256 }
257 }
258 }
259 }
260
261 void cheatSearchValue(const CheatSearchData *cs, int compare, int size,
262 bool isSigned, u32 value)
263 {
264 if (compare < 0 || compare > SEARCH_GE)
265 return;
266 int inc = 1;
267 if (size == BITS_16)
268 inc = 2;
269 else if (size == BITS_32)
270 inc = 4;
271
272 if (isSigned)
273 {
274 bool (*func)(s32, s32) = cheatSearchSignedFunc[compare];
275
276 for (int i = 0; i < cs->count; i++)
277 {
278 CheatSearchBlock *block = &cs->blocks[i];
279 int size2 = block->size;
280 u8 *bits = block->bits;
281 u8 *data = block->data;
282
283 for (int j = 0; j < size2; j += inc)
284 {
285 if (IS_BIT_SET(bits, j))
286 {
287 s32 a = cheatSearchSignedRead(data, j, size);
288 s32 b = (s32)value;
289
290 if (!func(a, b))
291 {
292 CLEAR_BIT(bits, j);
293 if (size == BITS_16)
294 CLEAR_BIT(bits, j+1);
295 if (size == BITS_32)
296 {
297 CLEAR_BIT(bits, j+2);
298 CLEAR_BIT(bits, j+3);
299 }
300 }
301 }
302 }
303 }
304 }
305 else
306 {
307 bool (*func)(u32, u32) = cheatSearchFunc[compare];
308
309 for (int i = 0; i < cs->count; i++)
310 {
311 CheatSearchBlock *block = &cs->blocks[i];
312 int size2 = block->size;
313 u8 *bits = block->bits;
314 u8 *data = block->data;
315
316 for (int j = 0; j < size2; j += inc)
317 {
318 if (IS_BIT_SET(bits, j))
319 {
320 u32 a = cheatSearchRead(data, j, size);
321
322 if (!func(a, value))
323 {
324 CLEAR_BIT(bits, j);
325 if (size == BITS_16)
326 CLEAR_BIT(bits, j+1);
327 if (size == BITS_32)
328 {
329 CLEAR_BIT(bits, j+2);
330 CLEAR_BIT(bits, j+3);
331 }
332 }
333 }
334 }
335 }
336 }
337 }
338
339 int cheatSearchGetCount(const CheatSearchData *cs, int size)
340 {
341 int res = 0;
342 int inc = 1;
343 if (size == BITS_16)
344 inc = 2;
345 else if (size == BITS_32)
346 inc = 4;
347
348 for (int i = 0; i < cs->count; i++)
349 {
350 CheatSearchBlock *block = &cs->blocks[i];
351
352 int size2 = block->size;
353 u8 *bits = block->bits;
354 for (int j = 0; j < size2; j += inc)
355 {
356 if (IS_BIT_SET(bits, j))
357 res++;
358 }
359 }
360 return res;
361 }
362
363 void cheatSearchUpdateValues(const CheatSearchData *cs)
364 {
365 for (int i = 0; i < cs->count; i++)
366 {
367 CheatSearchBlock *block = &cs->blocks[i];
368
369 memcpy(block->saved, block->data, block->size);
370 }
371 }