ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/RomCheater/trunk/RomCheater/Docking/FloatingMemorySearcher.cs

Comparing trunk/RomCheater/Docking/FloatingMemorySearcher.cs (file contents):
Revision 526 by william, Wed Jun 5 08:03:28 2013 UTC vs.
Revision 527 by william, Wed Jun 5 08:09:59 2013 UTC

#	Line 2191 | Line 2191 | namespace RomCheater.Docking
2191		}
2192		else
2193		{
2194	+	Guid new_SearchGuid = SearchGuid;
2195		// need to get the address list
2196		using (SearchResultReader reader = new SearchResultReader(SearchGuid, false)) // delete the file on dispose
2197		{
#	Line 2267 | Line 2268 | namespace RomCheater.Docking
2268		//}
2269		//SearchGuid = new_SearchGuid;
2270		#endregion
2271	<
2272	<	byte[] guid = SearchGuid.ToByteArray();
2273	<	guid[guid.Length - 1]++; // increment the search guid by 1
2274	<	Guid new_SearchGuid = new Guid(guid);
2275	<
2275	<	foreach(var k in reader.GetResults(SearchArgs.IsUnsignedDataType,SearchArgs.DataType,new Action<int,string>(UpdateProgress)))
2276	<	{
2277	<	provider.OpenProvider();
2278	<	int bytesRead=0;
2279	<	byte[] data = new byte[STEP_SIZE];
2280	<	provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);
2281	<	provider.CloseProvider();
2282	<
2283	<	uint address_index = k.Address;
2284	<	#region comparison and serialization
2285	<	switch (sdt)
2271	>
2272	>	new_SearchGuid = GuidTools.IncrementGuid(SearchGuid);
2273	>	using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))
2274	>	{
2275	>	foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress)))
2276		{
2277	<	case SearchDataTypes._8bits:
2278	<	if (unsigned)
2279	<	{
2280	<	#region 8bits - unsigned
2281	<	var t_data = BitTools.ConvertByteArray<byte>(data);
2282	<	foreach (var Value in t_data)
2277	>	provider.OpenProvider();
2278	>	int bytesRead = 0;
2279	>	byte[] data = new byte[STEP_SIZE];
2280	>	provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);
2281	>	provider.CloseProvider();
2282	>
2283	>	uint address_index = k.Address;
2284	>	#region comparison and serialization
2285	>	switch (sdt)
2286	>	{
2287	>	case SearchDataTypes._8bits:
2288	>	if (unsigned)
2289		{
2290	<	if (SearchWorkerThread.CancellationPending) { break; }
2291	<	using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
2290	>	#region 8bits - unsigned
2291	>	var t_data = BitTools.ConvertByteArray<byte>(data);
2292	>	foreach (var Value in t_data)
2293		{
2294	<	byte value = 0;
2295	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2294	>	if (SearchWorkerThread.CancellationPending) { break; }
2295	>	using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
2296		{
2297	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2297	>	byte value = 0;
2298	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2299		{
2300	<	try
2300	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2301		{
2302	<	gmp.OpenProvider();
2303	<	gmp.ReadMemory(address_index, out value);
2304	<	gmp.CloseProvider();
2305	<	}
2306	<	catch (Exception ex)
2307	<	{
2308	<	logger.VerboseError.WriteLine(ex.ToString());
2302	>	try
2303	>	{
2304	>	gmp.OpenProvider();
2305	>	gmp.ReadMemory(address_index, out value);
2306	>	gmp.CloseProvider();
2307	>	}
2308	>	catch (Exception ex)
2309	>	{
2310	>	logger.VerboseError.WriteLine(ex.ToString());
2311	>	}
2312		}
2313	+	comparer.Value = value;
2314	+	}
2315	+	else
2316	+	{
2317	+	value = Convert.ToByte(SearchArgs.CompareStartValue);
2318	+	comparer.Value = value;
2319	+	}
2320	+	if (comparer.Compare(Convert.ToByte(Value), value))
2321	+	{
2322	+	writer.WriteResult<byte>(comparer.Address, comparer.Value);
2323		}
2313	–	comparer.Value = value;
2314	–	}
2315	–	else
2316	–	{
2317	–	value = Convert.ToByte(SearchArgs.CompareStartValue);
2318	–	comparer.Value = value;
2319	–	}
2320	–	if (comparer.Compare(Convert.ToByte(Value), value))
2321	–	{
2322	–	writer.WriteResult<byte>(comparer.Address, comparer.Value);
2324		}
2325	+	address_index += STEP_SIZE;
2326		}
2327	<	address_index += STEP_SIZE;
2327	>	#endregion
2328		}
2329	<	#endregion
2328	<	}
2329	<	else
2330	<	{
2331	<	#region 8bits - signed
2332	<	var t_data = BitTools.ConvertByteArray<sbyte>(data);
2333	<	foreach (var Value in t_data)
2329	>	else
2330		{
2331	<	if (SearchWorkerThread.CancellationPending) { break; }
2332	<	using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
2331	>	#region 8bits - signed
2332	>	var t_data = BitTools.ConvertByteArray<sbyte>(data);
2333	>	foreach (var Value in t_data)
2334		{
2335	<	sbyte value = 0;
2336	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2335	>	if (SearchWorkerThread.CancellationPending) { break; }
2336	>	using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
2337		{
2338	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2338	>	sbyte value = 0;
2339	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2340		{
2341	<	try
2341	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2342		{
2343	<	gmp.OpenProvider();
2344	<	gmp.ReadMemory(address_index, out value);
2345	<	gmp.CloseProvider();
2346	<	}
2347	<	catch (Exception ex)
2348	<	{
2349	<	logger.VerboseError.WriteLine(ex.ToString());
2343	>	try
2344	>	{
2345	>	gmp.OpenProvider();
2346	>	gmp.ReadMemory(address_index, out value);
2347	>	gmp.CloseProvider();
2348	>	}
2349	>	catch (Exception ex)
2350	>	{
2351	>	logger.VerboseError.WriteLine(ex.ToString());
2352	>	}
2353		}
2354	+	comparer.Value = value;
2355	+	}
2356	+	else
2357	+	{
2358	+	value = Convert.ToSByte(SearchArgs.CompareStartValue);
2359	+	comparer.Value = value;
2360	+	}
2361	+	if (comparer.Compare(Convert.ToSByte(Value), value))
2362	+	{
2363	+	writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
2364		}
2354	–	comparer.Value = value;
2355	–	}
2356	–	else
2357	–	{
2358	–	value = Convert.ToSByte(SearchArgs.CompareStartValue);
2359	–	comparer.Value = value;
2360	–	}
2361	–	if (comparer.Compare(Convert.ToSByte(Value), value))
2362	–	{
2363	–	writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
2365		}
2366	+	address_index += STEP_SIZE;
2367		}
2368	<	address_index += STEP_SIZE;
2369	<	}
2370	<	#endregion
2371	<	} break;
2370	<	case SearchDataTypes._16bits:
2371	<	if (unsigned)
2372	<	{
2373	<	#region 16bits - unsigned
2374	<	var t_data = BitTools.ConvertByteArray<ushort>(data);
2375	<	foreach (var Value in t_data)
2368	>	#endregion
2369	>	} break;
2370	>	case SearchDataTypes._16bits:
2371	>	if (unsigned)
2372		{
2373	<	if (SearchWorkerThread.CancellationPending) { break; }
2374	<	using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
2373	>	#region 16bits - unsigned
2374	>	var t_data = BitTools.ConvertByteArray<ushort>(data);
2375	>	foreach (var Value in t_data)
2376		{
2377	<	ushort value = 0;
2378	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2377	>	if (SearchWorkerThread.CancellationPending) { break; }
2378	>	using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
2379		{
2380	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2380	>	ushort value = 0;
2381	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2382		{
2383	<	try
2386	<	{
2387	<	gmp.OpenProvider();
2388	<	gmp.ReadMemory(address_index, out value);
2389	<	gmp.CloseProvider();
2390	<	}
2391	<	catch (Exception ex)
2383	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2384		{
2385	<	logger.VerboseError.WriteLine(ex.ToString());
2385	>	try
2386	>	{
2387	>	gmp.OpenProvider();
2388	>	gmp.ReadMemory(address_index, out value);
2389	>	gmp.CloseProvider();
2390	>	}
2391	>	catch (Exception ex)
2392	>	{
2393	>	logger.VerboseError.WriteLine(ex.ToString());
2394	>	}
2395		}
2396	+	comparer.Value = value;
2397	+	}
2398	+	else
2399	+	{
2400	+	value = Convert.ToUInt16(SearchArgs.CompareStartValue);
2401	+	comparer.Value = value;
2402	+	}
2403	+	if (comparer.Compare(Convert.ToUInt16(Value), value))
2404	+	{
2405	+	writer.WriteResult<ushort>(comparer.Address, comparer.Value);
2406		}
2396	–	comparer.Value = value;
2397	–	}
2398	–	else
2399	–	{
2400	–	value = Convert.ToUInt16(SearchArgs.CompareStartValue);
2401	–	comparer.Value = value;
2402	–	}
2403	–	if (comparer.Compare(Convert.ToUInt16(Value), value))
2404	–	{
2405	–	writer.WriteResult<ushort>(comparer.Address, comparer.Value);
2407		}
2408	+	address_index += STEP_SIZE;
2409		}
2410	<	address_index += STEP_SIZE;
2410	>	#endregion
2411		}
2412	<	#endregion
2411	<	}
2412	<	else
2413	<	{
2414	<	#region 16bits - signed
2415	<	var t_data = BitTools.ConvertByteArray<short>(data);
2416	<	foreach (var Value in t_data)
2412	>	else
2413		{
2414	<	if (SearchWorkerThread.CancellationPending) { break; }
2415	<	using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
2414	>	#region 16bits - signed
2415	>	var t_data = BitTools.ConvertByteArray<short>(data);
2416	>	foreach (var Value in t_data)
2417		{
2418	<	short value = 0;
2419	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2418	>	if (SearchWorkerThread.CancellationPending) { break; }
2419	>	using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
2420		{
2421	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2421	>	short value = 0;
2422	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2423		{
2424	<	try
2427	<	{
2428	<	gmp.OpenProvider();
2429	<	gmp.ReadMemory(address_index, out value);
2430	<	gmp.CloseProvider();
2431	<	}
2432	<	catch (Exception ex)
2424	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2425		{
2426	<	logger.VerboseError.WriteLine(ex.ToString());
2426	>	try
2427	>	{
2428	>	gmp.OpenProvider();
2429	>	gmp.ReadMemory(address_index, out value);
2430	>	gmp.CloseProvider();
2431	>	}
2432	>	catch (Exception ex)
2433	>	{
2434	>	logger.VerboseError.WriteLine(ex.ToString());
2435	>	}
2436		}
2437	+	comparer.Value = value;
2438	+	}
2439	+	else
2440	+	{
2441	+	value = Convert.ToInt16(SearchArgs.CompareStartValue);
2442	+	comparer.Value = value;
2443	+	}
2444	+	if (comparer.Compare(Convert.ToSByte(Value), value))
2445	+	{
2446	+	writer.WriteResult<short>(comparer.Address, comparer.Value);
2447		}
2437	–	comparer.Value = value;
2438	–	}
2439	–	else
2440	–	{
2441	–	value = Convert.ToInt16(SearchArgs.CompareStartValue);
2442	–	comparer.Value = value;
2443	–	}
2444	–	if (comparer.Compare(Convert.ToSByte(Value), value))
2445	–	{
2446	–	writer.WriteResult<short>(comparer.Address, comparer.Value);
2448		}
2449	+	address_index += STEP_SIZE;
2450		}
2451	<	address_index += STEP_SIZE;
2452	<	}
2453	<	#endregion
2454	<	} break;
2453	<	case SearchDataTypes._32bits:
2454	<	if (unsigned)
2455	<	{
2456	<	#region 32bits - unsigned
2457	<	var t_data = BitTools.ConvertByteArray<uint>(data);
2458	<	foreach (var Value in t_data)
2451	>	#endregion
2452	>	} break;
2453	>	case SearchDataTypes._32bits:
2454	>	if (unsigned)
2455		{
2456	<	if (SearchWorkerThread.CancellationPending) { break; }
2457	<	using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
2456	>	#region 32bits - unsigned
2457	>	var t_data = BitTools.ConvertByteArray<uint>(data);
2458	>	foreach (var Value in t_data)
2459		{
2460	<	uint value = 0;
2461	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2460	>	if (SearchWorkerThread.CancellationPending) { break; }
2461	>	using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
2462		{
2463	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2463	>	uint value = 0;
2464	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2465		{
2466	<	try
2469	<	{
2470	<	gmp.OpenProvider();
2471	<	gmp.ReadMemory(address_index, out value);
2472	<	gmp.CloseProvider();
2473	<	}
2474	<	catch (Exception ex)
2466	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2467		{
2468	<	logger.VerboseError.WriteLine(ex.ToString());
2468	>	try
2469	>	{
2470	>	gmp.OpenProvider();
2471	>	gmp.ReadMemory(address_index, out value);
2472	>	gmp.CloseProvider();
2473	>	}
2474	>	catch (Exception ex)
2475	>	{
2476	>	logger.VerboseError.WriteLine(ex.ToString());
2477	>	}
2478		}
2479	+	comparer.Value = value;
2480	+	}
2481	+	else
2482	+	{
2483	+	value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2484	+	comparer.Value = value;
2485	+	}
2486	+	if (comparer.Compare(Convert.ToUInt32(Value), value))
2487	+	{
2488	+	writer.WriteResult<uint>(comparer.Address, comparer.Value);
2489		}
2479	–	comparer.Value = value;
2480	–	}
2481	–	else
2482	–	{
2483	–	value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2484	–	comparer.Value = value;
2485	–	}
2486	–	if (comparer.Compare(Convert.ToUInt32(Value), value))
2487	–	{
2488	–	writer.WriteResult<uint>(comparer.Address, comparer.Value);
2490		}
2491	+	address_index += STEP_SIZE;
2492		}
2493	<	address_index += STEP_SIZE;
2493	>	#endregion
2494		}
2495	<	#endregion
2494	<	}
2495	<	else
2496	<	{
2497	<	#region 32bits - signed
2498	<	var t_data = BitTools.ConvertByteArray<int>(data);
2499	<	foreach (var Value in t_data)
2495	>	else
2496		{
2497	<	if (SearchWorkerThread.CancellationPending) { break; }
2498	<	using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
2497	>	#region 32bits - signed
2498	>	var t_data = BitTools.ConvertByteArray<int>(data);
2499	>	foreach (var Value in t_data)
2500		{
2501	<	int value = 0;
2502	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2501	>	if (SearchWorkerThread.CancellationPending) { break; }
2502	>	using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
2503		{
2504	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2504	>	int value = 0;
2505	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2506		{
2507	<	try
2510	<	{
2511	<	gmp.OpenProvider();
2512	<	gmp.ReadMemory(address_index, out value);
2513	<	gmp.CloseProvider();
2514	<	}
2515	<	catch (Exception ex)
2507	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2508		{
2509	<	logger.VerboseError.WriteLine(ex.ToString());
2509	>	try
2510	>	{
2511	>	gmp.OpenProvider();
2512	>	gmp.ReadMemory(address_index, out value);
2513	>	gmp.CloseProvider();
2514	>	}
2515	>	catch (Exception ex)
2516	>	{
2517	>	logger.VerboseError.WriteLine(ex.ToString());
2518	>	}
2519		}
2520	+	comparer.Value = value;
2521	+	}
2522	+	else
2523	+	{
2524	+	value = Convert.ToInt32(SearchArgs.CompareStartValue);
2525	+	comparer.Value = value;
2526	+	}
2527	+	if (comparer.Compare(Convert.ToInt32(Value), value))
2528	+	{
2529	+	writer.WriteResult<int>(comparer.Address, comparer.Value);
2530		}
2520	–	comparer.Value = value;
2521	–	}
2522	–	else
2523	–	{
2524	–	value = Convert.ToInt32(SearchArgs.CompareStartValue);
2525	–	comparer.Value = value;
2526	–	}
2527	–	if (comparer.Compare(Convert.ToInt32(Value), value))
2528	–	{
2529	–	writer.WriteResult<int>(comparer.Address, comparer.Value);
2531		}
2532	+	address_index += STEP_SIZE;
2533		}
2534	<	address_index += STEP_SIZE;
2535	<	}
2536	<	#endregion
2537	<	} break;
2536	<	case SearchDataTypes._64bits:
2537	<	if (unsigned)
2538	<	{
2539	<	#region 64bits - unsigned
2540	<	var t_data = BitTools.ConvertByteArray<ulong>(data);
2541	<	foreach (var Value in t_data)
2534	>	#endregion
2535	>	} break;
2536	>	case SearchDataTypes._64bits:
2537	>	if (unsigned)
2538		{
2539	<	if (SearchWorkerThread.CancellationPending) { break; }
2540	<	using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
2539	>	#region 64bits - unsigned
2540	>	var t_data = BitTools.ConvertByteArray<ulong>(data);
2541	>	foreach (var Value in t_data)
2542		{
2543	<	ulong value = 0;
2544	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2543	>	if (SearchWorkerThread.CancellationPending) { break; }
2544	>	using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
2545		{
2546	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2546	>	ulong value = 0;
2547	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2548		{
2549	<	try
2549	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2550		{
2551	<	gmp.OpenProvider();
2552	<	gmp.ReadMemory(address_index, out value);
2553	<	gmp.CloseProvider();
2554	<	}
2555	<	catch (Exception ex)
2556	<	{
2557	<	logger.VerboseError.WriteLine(ex.ToString());
2551	>	try
2552	>	{
2553	>	gmp.OpenProvider();
2554	>	gmp.ReadMemory(address_index, out value);
2555	>	gmp.CloseProvider();
2556	>	}
2557	>	catch (Exception ex)
2558	>	{
2559	>	logger.VerboseError.WriteLine(ex.ToString());
2560	>	}
2561		}
2562	+	comparer.Value = value;
2563	+	}
2564	+	else
2565	+	{
2566	+	value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2567	+	comparer.Value = value;
2568	+	}
2569	+	if (comparer.Compare(Convert.ToUInt64(Value), value))
2570	+	{
2571	+	writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2572		}
2562	–	comparer.Value = value;
2563	–	}
2564	–	else
2565	–	{
2566	–	value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2567	–	comparer.Value = value;
2568	–	}
2569	–	if (comparer.Compare(Convert.ToUInt64(Value), value))
2570	–	{
2571	–	writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2573		}
2574	+	address_index += STEP_SIZE;
2575		}
2576	<	address_index += STEP_SIZE;
2576	>	#endregion
2577		}
2578	<	#endregion
2577	<	}
2578	<	else
2579	<	{
2580	<	#region 64bits - signed
2581	<	var t_data = BitTools.ConvertByteArray<long>(data);
2582	<	foreach (var Value in t_data)
2578	>	else
2579		{
2580	<	if (SearchWorkerThread.CancellationPending) { break; }
2581	<	using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
2580	>	#region 64bits - signed
2581	>	var t_data = BitTools.ConvertByteArray<long>(data);
2582	>	foreach (var Value in t_data)
2583		{
2584	<	long value = 0;
2585	<	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2584	>	if (SearchWorkerThread.CancellationPending) { break; }
2585	>	using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
2586		{
2587	<	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2587	>	long value = 0;
2588	>	if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2589		{
2590	<	try
2593	<	{
2594	<	gmp.OpenProvider();
2595	<	gmp.ReadMemory(address_index, out value);
2596	<	gmp.CloseProvider();
2597	<	}
2598	<	catch (Exception ex)
2590	>	using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2591		{
2592	<	logger.VerboseError.WriteLine(ex.ToString());
2592	>	try
2593	>	{
2594	>	gmp.OpenProvider();
2595	>	gmp.ReadMemory(address_index, out value);
2596	>	gmp.CloseProvider();
2597	>	}
2598	>	catch (Exception ex)
2599	>	{
2600	>	logger.VerboseError.WriteLine(ex.ToString());
2601	>	}
2602		}
2603	+	comparer.Value = value;
2604	+	}
2605	+	else
2606	+	{
2607	+	value = Convert.ToInt64(SearchArgs.CompareStartValue);
2608	+	comparer.Value = value;
2609	+	}
2610	+	if (comparer.Compare(Convert.ToInt64(Value), value))
2611	+	{
2612	+	writer.WriteResult<long>(comparer.Address, comparer.Value);
2613		}
2603	–	comparer.Value = value;
2604	–	}
2605	–	else
2606	–	{
2607	–	value = Convert.ToInt64(SearchArgs.CompareStartValue);
2608	–	comparer.Value = value;
2609	–	}
2610	–	if (comparer.Compare(Convert.ToInt64(Value), value))
2611	–	{
2612	–	writer.WriteResult<long>(comparer.Address, comparer.Value);
2614		}
2615	+	address_index += STEP_SIZE;
2616		}
2617	<	address_index += STEP_SIZE;
2618	<	}
2617	<	#endregion
2618	<	} break;
2617	>	#endregion
2618	>	} break;
2619
2620	<	}
2621	<	#endregion
2622	<
2623	<	}
2620	>	}
2621	>	#endregion
2622
2623	+	}
2624
2626	–	//ISerializedResult sr = (reader as ISerializedResult);
2627	–	//if (sr == null)
2628	–	//{
2629	–	//    throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
2630	–	//}
2631	–	//int sr_index = 0;
2632	–	//try
2633	–	//{
2634	–	//    if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
2635	–	//    {
2636	–	//        StructResultType<ulong> result = StructResultType<ulong>.Empty;
2637	–	//        sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
2638	–	//        if (Debugger.IsAttached)
2639	–	//        {
2640	–	//            Debugger.Break();
2641	–	//        }
2642	–	//    }
2643	–	//}
2625
2626	+	//ISerializedResult sr = (reader as ISerializedResult);
2627	+	//if (sr == null)
2628	+	//{
2629	+	//    throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
2630	+	//}
2631	+	//int sr_index = 0;
2632	+	//try
2633	+	//{
2634	+	//    if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
2635	+	//    {
2636	+	//        StructResultType<ulong> result = StructResultType<ulong>.Empty;
2637	+	//        sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
2638	+	//        if (Debugger.IsAttached)
2639	+	//        {
2640	+	//            Debugger.Break();
2641	+	//        }
2642	+	//    }
2643	+	//}
2644
2645	+	}
2646
2647		}
2648	+	SearchGuid = new_SearchGuid; // update with out new guid
2649		}
2650		}
2651		provider_st.Stop();

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines