/[RomCheater]/trunk/RomCheater/Docking/FloatingMemorySearcher.cs
ViewVC logotype

Annotation of /trunk/RomCheater/Docking/FloatingMemorySearcher.cs

Parent Directory Parent Directory | Revision Log Revision Log


Revision 523 - (hide annotations) (download)
Wed Jun 5 07:27:44 2013 UTC (7 years, 4 months ago) by william
File size: 205894 byte(s)

1 william 414 #region Logging Defines
2     // include this any class or method that required logging, and comment-out what is not needed
3 william 415
4 william 414 #region Enabled logging levels
5     #define LOGGING_ENABLE_INFO
6     #define LOGGING_ENABLE_WARN
7     #define LOGGING_ENABLE_DEBUG
8     #define LOGGING_ENABLE_VERBOSEDEBUG
9     #define LOGGING_ENABLE_ERROR
10     #define LOGGING_ENABLE_VERBOSEERROR
11     #define LOGGING_ENABLE_PROFILER
12     #endregion
13     #endregion
14     //#define USE_AUTOMATIC_MEMORY_SEARCH_RANGE // when defined will automatically choose the best starting address and size for memory search otherwise it will use the constants defined in MemorySizeConstants
15 william 289 #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
16 william 287 #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
17 william 289 #endif
18 william 452 #define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
19 william 280 #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8
20     //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze
21 william 229 using System;
22 william 227 using System.Collections.Generic;
23     using System.ComponentModel;
24     using System.Data;
25     using System.Drawing;
26     using System.Linq;
27     using System.Text;
28     using System.Windows.Forms;
29     using WeifenLuo.WinFormsUI.Docking;
30     using RomCheater.PluginFramework.Interfaces;
31     using System.Diagnostics;
32 william 229 using RomCheater.Docking.MemorySearch;
33     using libWin32.Win32.Threading;
34 william 230 using System.Threading;
35     using RomCheater.Logging;
36     using System.IO;
37 william 242 using Sojaner.MemoryScanner.MemoryProviers;
38 william 275 using RomCheater.PluginFramework.Events;
39 william 287 using System.Reflection;
40 william 292 using Sojaner.MemoryScanner;
41 william 399 using System.Collections;
42 william 401 using RomCheater.Serialization;
43 william 511 using RomCheater.Core;
44 william 227
45     namespace RomCheater.Docking
46     {
47 william 228 public partial class FloatingMemorySearcher : DockContent,
48 william 243 IAcceptsPlugin<IConfigPlugin>,
49 william 477 IAcceptsProcess<Process>,
50 william 243 IAcceptsProcessAndConfig,
51 william 275 ISearchInProgress,
52 william 287 IAcceptsBrowseMemoryRegion,
53     IAcceptsMemoryRange
54 william 227 {
55 william 280 #if INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY
56     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x2701; // 10,000 results
57     #else
58     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
59     #endif
60    
61 william 452 const bool USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE = false;
62 william 457 const bool USE_NONRANGE_SEARCH_RESULT_READER = false;
63 william 229 private bool DefaultUnsignedState = true; // set unsigned to true
64 william 477 public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
65 william 227 public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
66 william 477 public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
67 william 227
68 william 462 //new Action<int, string>(UpdateProgress) to use this as a delegate
69 william 511
70     private void thread_UpdateProgress(object o)
71 william 461 {
72 william 511 IProgressMessage pm = (o as IProgressMessage);
73     if (pm == null) { return; }
74     resultsprogress.Value = pm.Progress;
75 william 517 resultsprogress.Message = pm.Message;
76 william 461 }
77    
78 william 511 private void UpdateProgress(int progress, string message)
79     {
80     // detach the progress update from execution within the current thread (so it does not block a cpu-intensive or long running sequence)
81     Thread t = new Thread(new ParameterizedThreadStart(thread_UpdateProgress));
82 william 517 t.SetApartmentState(ApartmentState.STA);
83 william 511 t.Start(new ProgressMessage(progress, message));
84 william 517 //resultsprogress.Value = progress;
85     //resultsprogress.Message = message;
86 william 511 }
87    
88 william 237 #region IAcceptsProcess<Process> Members
89 william 477 private Process _AcceptedProcess;
90     public Process AcceptedProcess { get { return _AcceptedProcess; } set { _AcceptedProcess = value; UpdateAcceptedProcess(value); } }
91 william 227 #endregion
92     #region IAcceptsPlugin<IConfigPlugin> Members
93 william 243 private IConfigPlugin _AcceptedPlugin;
94 william 305 public IConfigPlugin AcceptedPlugin { get { return _AcceptedPlugin; } set { _AcceptedPlugin = value; UpdateAcceptedPlugin(value); } }
95 william 227 #endregion
96 william 275 #region IAcceptsBrowseMemoryRegion members
97 william 287 public event BaseEventHandler<BrowseMemoryRegionEvent> OnBrowseMemoryRegion;
98 william 275 #endregion
99    
100 william 305 private void UpdateAcceptedPlugin(IConfigPlugin config)
101 william 243 {
102     this.lstResults.AcceptedPlugin = config;
103     this.lstPatchList.AcceptedPlugin = config;
104 william 389 if (config != null)
105     {
106     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
107     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
108     }
109 william 305 }
110 william 477 private void UpdateAcceptedProcess(Process process)
111     {
112     this.lstResults.AcceptedProcess = process;
113     this.lstPatchList.AcceptedProcess = process;
114 william 287 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && FORCE_USE_OF_MEMORYSIZECONSTANTS
115     logger.Warn.WriteLine("FloatingMemorySearcher.UpdateAcceptedProcessAndConfig(IConfigPlugin config, Process process):");
116     logger.Warn.WriteLine("Both USE_AUTOMATIC_MEMORY_SEARCH_RANGE and FORCE_USE_OF_MEMORYSIZECONSTANTS are defined");
117     logger.Warn.WriteLine("FORCE_USE_OF_MEMORYSIZECONSTANTS will take precedence and will ignore the values supplied in the memeory search range");
118 william 289 #endif
119     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
120     // force use of MemorySizeConstants
121 william 349 txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
122 william 401 txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
123 william 287 #endif
124     #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && !FORCE_USE_OF_MEMORYSIZECONSTANTS
125 william 318 ////// code to automatically choose the best starting memory address and size
126     //if (process != null)
127     //{
128     // string filename = process.MainModule.FileName;
129     // //string filename = @"c:\Windows\notepad.exe";
130     // PEReader peReader = new PEReader(filename);
131     //}
132     //else
133     //{
134 william 389 //txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
135     //txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
136 william 318 //}
137 william 389 if (AcceptedPlugin != null)
138     {
139     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
140     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
141     }
142    
143 william 287 #endif
144    
145 william 243 }
146 william 228 #region ISearchInProgress members
147 william 399 private bool _SearchInProgess;
148     public bool SearchInProgess
149     {
150     get { return _SearchInProgess; }
151     private set
152     {
153     _SearchInProgess = value;
154     if (this.AcceptedPlugin != null)
155     this.AcceptedPlugin.SetMemorySearchReference(this);
156     }
157     }
158 william 444 private Guid _SearchGuid;
159     public Guid SearchGuid
160     {
161     get { return _SearchGuid; }
162     private set { _SearchGuid = value; }
163     }
164 william 228 #endregion
165 william 229
166 william 287 #region IAcceptsMemoryRange
167     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
168 william 389 private uint _MemoryRangeStart;
169 william 287 private uint _MemoryRangeSize;
170     #endif
171 william 378 public uint MemoryRangeStart
172 william 287 {
173     get
174     {
175     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
176 william 349 return MemorySizeConstants.MinimumSearchAddress;
177 william 287 #else
178     return _MemoryRangeStart;
179     #endif
180     }
181     set
182     {
183     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
184     _MemoryRangeStart = value;
185 william 389 txtMemoryRangeStart.Value = value;
186 william 287 #endif
187     }
188     }
189     public uint MemoryRangeSize
190     {
191     get
192     {
193     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
194 william 401 return MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
195 william 287 #else
196     return _MemoryRangeSize;
197     #endif
198     }
199     set
200     {
201     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
202     _MemoryRangeSize = value;
203 william 389 txtMemoryRangeSize.Value = value;
204 william 287 #endif
205     }
206     }
207     #endregion
208 william 229
209     public void Reload()
210     {
211     chkUnsigned.Checked = DefaultUnsignedState;
212     radio_8bits.Checked = true;
213     radiocompare_equal.Checked = true;
214     radio_oldvalue.Checked = true;
215 william 230 chkRefreshResults.Checked = true;
216 william 229 }
217 william 230 public enum eListViewResults
218     {
219     SEARCH_RESULTS_LIST = 0x3000,
220     PATCH_RESULTS_LIST = 0x3001,
221     UKNOWN_RESULTS_LIST = 0x3001
222     }
223 william 280 bool IsFirstSearch = true;
224 william 277 SearchType SearchArgs;
225 william 272 static int col_Found_Address = 1;
226     static int col_Found_Value = 2;
227 william 419 //static int col_Found_Frozen = 3; /* unused */
228 william 272 static int col_Added_Address = 1;
229     static int col_Added_Value = 2;
230 william 419 //static int col_Added_Frozen = 3; /* unused */
231 william 230 List<ListViewItem> ResultItems = new List<ListViewItem>();
232     List<ListViewItem> AddedItems = new List<ListViewItem>();
233     private bool _PatchedValue_NeedsUpdate;
234     bool PatchedValue_NeedsUpdate
235     {
236     get { if (_PatchedValue_NeedsUpdate) this.ThawResultsUpdate(); return _PatchedValue_NeedsUpdate; }
237     set { _PatchedValue_NeedsUpdate = value; if (value) this.ThawResultsUpdate(); }
238     }
239     private delegate ListViewItem ThreadSafe_GetResultItem(int index, int lv_type);
240     private ListViewItem GetResultItem(int index, int lv_type)
241     {
242     try
243     {
244     AddressValuePairList lv = null;
245     switch (lv_type)
246     {
247     case (int)eListViewResults.SEARCH_RESULTS_LIST: lv = lstResults; break;
248     case (int)eListViewResults.PATCH_RESULTS_LIST: lv = lstPatchList; break;
249     default: throw new IndexOutOfRangeException("Detected: " + Enum.GetName(typeof(eListViewResults), eListViewResults.UKNOWN_RESULTS_LIST) + " with value: " + lv_type.ToString("x4"));
250     }
251     ListViewItem item = new ListViewItem();
252     item = (ListViewItem)lv.Items[index].Clone();
253     return item;
254     }
255     catch (Exception)
256     {
257     return null;
258     }
259     }
260 william 229 private void radiocompare_equal_CheckedChanged(object sender, EventArgs e)
261     {
262     //if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
263     //{
264     if (radio_oldvalue.Checked)
265     {
266     txtStartAddr.ReadOnly = true;
267     txtEndAddr.ReadOnly = true;
268     }
269     if (radio_specificvalue.Checked)
270     {
271     txtStartAddr.ReadOnly = false;
272     txtEndAddr.ReadOnly = true;
273     }
274     //}
275     }
276    
277     private void radiocompare_between_CheckedChanged(object sender, EventArgs e)
278     {
279     if (!radiocompare_equal.Checked &&
280     !radiocompare_greaterthan.Checked &&
281     !radiocompare_greaterthan.Checked &&
282     !radiocompare_lessthan.Checked &&
283     !radiocompare_greaterthan_orequal.Checked &&
284     !radiocompare_lessthan_orequal.Checked &&
285     !radiocompare_notequal.Checked)
286     if (radiocompare_between.Checked)
287     {
288     txtStartAddr.ReadOnly = false;
289     txtEndAddr.ReadOnly = false;
290     return;
291     }
292     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
293     {
294     if (radio_oldvalue.Checked)
295     {
296     txtStartAddr.ReadOnly = true;
297     txtEndAddr.ReadOnly = true;
298     }
299     if (radio_specificvalue.Checked)
300     {
301     txtStartAddr.ReadOnly = false;
302     txtEndAddr.ReadOnly = true;
303     }
304     }
305     }
306    
307     private void radiocompare_notbetween_CheckedChanged(object sender, EventArgs e)
308     {
309     if (!radiocompare_equal.Checked &&
310     !radiocompare_greaterthan.Checked &&
311     !radiocompare_greaterthan.Checked &&
312     !radiocompare_lessthan.Checked &&
313     !radiocompare_greaterthan_orequal.Checked &&
314     !radiocompare_lessthan_orequal.Checked &&
315     !radiocompare_notequal.Checked)
316     if (radiocompare_notbetween.Checked)
317     {
318     txtStartAddr.ReadOnly = false;
319     txtEndAddr.ReadOnly = false;
320     return;
321     }
322     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
323     {
324     if (radio_oldvalue.Checked)
325     {
326     txtStartAddr.ReadOnly = true;
327     txtEndAddr.ReadOnly = true;
328     }
329     if (radio_specificvalue.Checked)
330     {
331     txtStartAddr.ReadOnly = false;
332     txtEndAddr.ReadOnly = true;
333     }
334     }
335     }
336    
337     private void radio_8bits_CheckedChanged(object sender, EventArgs e)
338     {
339     if (chkUnsigned.Checked)
340     {
341     txtStartAddr.CreateTypeSize<byte>();
342     txtEndAddr.CreateTypeSize<byte>();
343     }
344     else
345     {
346     txtStartAddr.CreateTypeSize<sbyte>();
347     txtEndAddr.CreateTypeSize<sbyte>();
348     }
349     }
350    
351     private void radio_16bits_CheckedChanged(object sender, EventArgs e)
352     {
353     if (chkUnsigned.Checked)
354     {
355     txtStartAddr.CreateTypeSize<ushort>();
356     txtEndAddr.CreateTypeSize<ushort>();
357     }
358     else
359     {
360     txtStartAddr.CreateTypeSize<short>();
361     txtEndAddr.CreateTypeSize<short>();
362     }
363     }
364    
365     private void radio_32bits_CheckedChanged(object sender, EventArgs e)
366     {
367    
368     if (chkUnsigned.Checked)
369     {
370     txtStartAddr.CreateTypeSize<uint>();
371     txtEndAddr.CreateTypeSize<uint>();
372     }
373     else
374     {
375     txtStartAddr.CreateTypeSize<int>();
376     txtEndAddr.CreateTypeSize<int>();
377     }
378     }
379    
380     private void radio_64bits_CheckedChanged(object sender, EventArgs e)
381     {
382    
383     if (chkUnsigned.Checked)
384     {
385     txtStartAddr.CreateTypeSize<ulong>();
386     txtEndAddr.CreateTypeSize<ulong>();
387     }
388     else
389     {
390     txtStartAddr.CreateTypeSize<long>();
391     txtEndAddr.CreateTypeSize<long>();
392     }
393     }
394    
395     private void radio_oldvalue_CheckedChanged(object sender, EventArgs e)
396     {
397     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
398     {
399     txtStartAddr.ReadOnly = true;
400     txtEndAddr.ReadOnly = true;
401     }
402     }
403    
404     private void radio_specificvalue_CheckedChanged(object sender, EventArgs e)
405     {
406     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
407     {
408     txtStartAddr.ReadOnly = false;
409     txtEndAddr.ReadOnly = true;
410     }
411     }
412    
413     private void chkRefreshResults_CheckedChanged(object sender, EventArgs e)
414     {
415     if (chkRefreshResults.Checked)
416     {
417     timer_update_results.Enabled = true;
418     }
419     else
420     {
421     timer_update_results.Enabled = false;
422     ResultsUpdateWorkerThread.CancelAsync();
423     }
424     }
425    
426     private void timer_update_results_Tick(object sender, EventArgs e)
427     {
428     if (chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
429     {
430     ResultsUpdateWorkerThread.RunWorkerAsync();
431     }
432     }
433 william 230 private bool ShouldUpdateResults()
434     {
435 william 477 if (this.AcceptedProcess == null) return false;
436 william 230 if (SearchWorkerThread.IsBusy) return false;
437     //if (JokerSearchWorker.IsBusy) return false;
438     if (this.IsResultsUpdateFrozen) return false;
439     if (mnuAddedResults.Visible) return false;
440     if (mnuResults.Visible) return false;
441 william 477 if (Process.GetProcessById(this.AcceptedProcess.Id) == null) return false;
442 william 230 if (lstResults.Items.Count > 0) return true;
443     if (lstPatchList.Items.Count > 0) return true;
444     return false;
445     }
446 william 229 private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e)
447     {
448 william 230 Thread.Sleep(250); // keep thread from blocking
449     if (!this.ShouldUpdateResults()) return;
450     ////if (SearchArgs == null) return;
451     ////if (this.IsResultsUpdateFrozen) return;
452     ////// put thread to sleep for 500ms
453     ////System.Threading.Thread.Sleep(500);
454     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
455     //byte[] buffered_mem = provider.GetMemory();
456     //MemoryStream ms = new MemoryStream(buffered_mem);
457     //BinaryReader r_ms = new BinaryReader(ms);
458 william 229
459 william 230 #region Update Results List
460     ResultItems = new List<ListViewItem>();
461     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
462     for (int i = 0; i < lstResults.Items.Count; i++)
463     {
464     if (this.lstResults.InvokeRequired)
465     {
466     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
467     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.SEARCH_RESULTS_LIST });
468     if (item != null)
469     ResultItems.Add((ListViewItem)item);
470     }
471     else
472     {
473     ResultItems.Add(lstResults.Items[i]);
474     }
475    
476     }
477     for (int i = 0; i < ResultItems.Count; i++)
478     {
479     if (ResultsUpdateWorkerThread.CancellationPending == true)
480     {
481     e.Cancel = true;
482     return;
483     }
484 william 249 int Address = 0;
485 william 230 ResultDataType _result = (ResultDataType)ResultItems[i].Tag;
486    
487 william 249 Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
488 william 242 //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
489 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
490 william 230 {
491 william 398 provider.OpenProvider();
492     int bytesReadSize;
493     byte[] data;
494     uint bytesToRead = 0;
495     switch (_result.ValueType)
496     {
497     case SearchDataTypes._8bits:
498     bytesToRead = 1;
499     break;
500     case SearchDataTypes._16bits:
501     bytesToRead = 2;
502     break;
503     case SearchDataTypes._32bits:
504     bytesToRead = 4;
505     break;
506     case SearchDataTypes._64bits:
507     bytesToRead = 8;
508     break;
509     }
510     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
511     using (MemoryStream ms = new MemoryStream(data))
512     {
513     using (BinaryReader r_ms = new BinaryReader(ms))
514     {
515     switch (_result.ValueType)
516     {
517     case SearchDataTypes._8bits:
518     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
519     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
520     break;
521     case SearchDataTypes._16bits:
522     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
523     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
524     break;
525     case SearchDataTypes._32bits:
526     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
527     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
528     break;
529     case SearchDataTypes._64bits:
530     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
531     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
532     break;
533     }
534     r_ms.Close();
535     }
536     }
537 william 424 provider.CloseProvider();
538 william 230 }
539 william 398 //Application.DoEvents();
540 william 230 }
541     #endregion
542    
543     #region Update Added Results List
544     AddedItems = new List<ListViewItem>();
545     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
546     for (int i = 0; i < lstPatchList.Items.Count; i++)
547     {
548     if (this.lstResults.InvokeRequired)
549     {
550     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
551     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.PATCH_RESULTS_LIST });
552     if (item != null)
553     AddedItems.Add((ListViewItem)item);
554     }
555     else
556     {
557     AddedItems.Add(lstPatchList.Items[i]);
558     }
559    
560     }
561     for (int i = 0; i < AddedItems.Count; i++)
562     {
563     if (ResultsUpdateWorkerThread.CancellationPending == true)
564     {
565     e.Cancel = true;
566     return;
567     }
568 william 249 int Address = 0;
569 william 230 ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
570 william 249 Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
571 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
572 william 230 {
573 william 398 provider.OpenProvider();
574     int bytesReadSize;
575     byte[] data;
576     uint bytesToRead = 0;
577     switch (_result.ValueType)
578     {
579     case SearchDataTypes._8bits:
580     bytesToRead = 1;
581     break;
582     case SearchDataTypes._16bits:
583     bytesToRead = 2;
584     break;
585     case SearchDataTypes._32bits:
586     bytesToRead = 4;
587     break;
588     case SearchDataTypes._64bits:
589     bytesToRead = 8;
590     break;
591     }
592     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
593 william 424 provider.CloseProvider();
594 william 398 using (MemoryStream ms = new MemoryStream(data))
595     {
596     using (BinaryReader r_ms = new BinaryReader(ms))
597     {
598     switch (_result.ValueType)
599     {
600     case SearchDataTypes._8bits:
601     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
602     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
603     break;
604     case SearchDataTypes._16bits:
605     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
606     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
607     break;
608     case SearchDataTypes._32bits:
609     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
610     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
611     break;
612     case SearchDataTypes._64bits:
613     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
614     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
615     break;
616     }
617     r_ms.Close();
618     }
619     }
620 william 230 }
621 william 398 //Application.DoEvents();
622 william 230 }
623     #endregion
624    
625    
626 william 229 }
627    
628     private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
629     {
630 william 230 try
631     {
632     //if ((lstResults.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate ) return;
633     //if ((lstPatchList.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate) return;
634     if (!this.ShouldUpdateResults()) return;
635     if (ResultItems.Count > 0)
636     {
637     //lstResults.Items.Clear();
638     //lstResults.Items.AddRange(ResultItems.ToArray());
639 william 229
640 william 230 for (int i = 0; i < ResultItems.Count; i++)
641     {
642     lstResults.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
643     ResultItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
644     }
645    
646     }
647     if (AddedItems.Count > 0)
648     {
649     //lstPatchList.Items.Clear();
650     //lstPatchList.Items.AddRange(AddedItems.ToArray());
651    
652     for (int i = 0; i < AddedItems.Count; i++)
653     {
654     lstPatchList.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
655     AddedItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
656     }
657    
658     }
659     PatchedValue_NeedsUpdate = false;
660     }
661     catch { }
662 william 229 }
663    
664     private void btnImportFile_Click(object sender, EventArgs e)
665     {
666     this.FreezeResultsUpdate();
667     if (!lstPatchList.ImportFromFile())
668     {
669     MessageBox.Show("Failed to Import Patch List from File.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
670     this.ThawResultsUpdate();
671     return;
672     }
673     else
674     {
675     MessageBox.Show("Succesfully Imported Patch List from File.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
676     this.ThawResultsUpdate();
677     return;
678     }
679     }
680     bool g_isFrozen = false;
681     private bool IsResultsUpdateFrozen
682     {
683     get { return g_isFrozen; }
684     set { g_isFrozen = value; }
685     }
686     private void ThawResultsUpdate()
687     {
688     this.IsResultsUpdateFrozen = false;
689 william 477 if (this.AcceptedProcess != null)
690 william 229 {
691     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
692 william 477 ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
693 william 229 #endif
694     }
695     }
696    
697     private void FreezeResultsUpdate()
698     {
699     this.IsResultsUpdateFrozen = true;
700 william 285 //this.IsResultsUpdateFrozen = false;
701 william 477 if (this.AcceptedProcess != null)
702 william 229 {
703     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
704 william 477 ThreadControl.SuspendProcess(this.AcceptedProcess.Id);
705 william 229 #endif
706     }
707     }
708    
709     private void btnExportFile_Click(object sender, EventArgs e)
710     {
711     this.FreezeResultsUpdate();
712     if (!lstPatchList.ExportToFile())
713     {
714     MessageBox.Show("Failed to Export Patch List to File.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
715     this.ThawResultsUpdate();
716     return;
717     }
718     else
719     {
720     MessageBox.Show("Succesfully Exported Patch List to File.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
721     this.ThawResultsUpdate();
722     return;
723     }
724     }
725    
726     private void btnImportClipboard_Click(object sender, EventArgs e)
727     {
728     this.FreezeResultsUpdate();
729     if (!lstPatchList.ImportFromClipboard())
730     {
731     MessageBox.Show("Failed to Import Patch List from Clipboard.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
732     this.ThawResultsUpdate();
733     return;
734     }
735     else
736     {
737     MessageBox.Show("Succesfully Import Patch List from Clipboard.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
738     this.ThawResultsUpdate();
739     }
740     }
741    
742     private void btnExportClipboard_Click(object sender, EventArgs e)
743     {
744     this.FreezeResultsUpdate();
745     if (!lstPatchList.ExportToClipboard())
746     {
747     MessageBox.Show("Failed to Export Patch List to Clipboard.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
748     this.ThawResultsUpdate();
749     return;
750     }
751     else
752     {
753     MessageBox.Show("Succesfully Exported Patch List to Clipboard.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
754     this.ThawResultsUpdate();
755     return;
756     }
757     }
758    
759     private void btnAddPatchAddress_Click(object sender, EventArgs e)
760     {
761 william 245 PatchAdder adder = new PatchAdder((IAcceptsProcessAndConfig)this);
762 william 229 adder.ShowDialog();
763     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
764     }
765    
766     private void btnAddAddressRange_Click(object sender, EventArgs e)
767     {
768 william 245 PatchRangeAdder adder = new PatchRangeAdder((IAcceptsProcessAndConfig)this);
769 william 229 adder.ShowDialog();
770     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
771     }
772     private void AddToPatchList(List<ResultDataType> item) { foreach (ResultDataType data in item) { AddToPatchList(data); } }
773     private void AddToPatchList(ResultDataType item)
774     {
775     ResultItem item2 = null;
776     switch (item.ValueType)
777     {
778     case SearchDataTypes._8bits:
779     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToByte(item.Value)); }
780     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToSByte(item.Value)); }
781     break;
782     case SearchDataTypes._16bits:
783     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt16(item.Value)); }
784     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt16(item.Value)); }
785     break;
786     case SearchDataTypes._32bits:
787     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt32(item.Value)); }
788     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt32(item.Value)); }
789     break;
790     case SearchDataTypes._64bits:
791     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt64(item.Value)); }
792     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt64(item.Value)); }
793     break;
794     }
795     this.AddToPatchList(item2);
796     }
797     private void AddToPatchList(ListViewItem item)
798     {
799     try
800     {
801     ResultDataType _result = (ResultDataType)item.Tag;
802     this.AddToPatchList(_result);
803     }
804     catch (InvalidCastException ex)
805     {
806     // unable to cast
807     MessageBox.Show(ex.Message, "Invalid Cast Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
808     }
809     catch (Exception ex)
810     {
811     // other exception
812     MessageBox.Show(ex.Message, "Unhandled Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
813     }
814     }
815     private void AddToPatchList(ResultItem item)
816     {
817     if (!lstPatchList.Items.Contains(item)) lstPatchList.Items.Add(item);
818     }
819     private void AddToPatchList(string address, SearchDataTypes bitsize, bool IsUnsigned)
820     {
821 william 245 ResultItemState state = new ResultItemState(address, bitsize, IsUnsigned, (IAcceptsProcessAndConfig)this);
822 william 229 ResultItem item = new ResultItem(state.Address, state.Value, state.Frozen, state.ValueType, state.IsUnsigned);
823     this.AddToPatchList(item);
824     }
825 william 230
826     private void mnuItemAddToPatchList_Click(object sender, EventArgs e)
827     {
828     if (!(lstResults.SelectedItems.Count > 0)) return;
829     //if (SearchArgs == null) return;
830    
831     try
832     {
833     for (int i = 0; i < lstResults.SelectedIndices.Count; i++)
834     {
835     //ResultDataType result = (ResultDataType)lstResults.Items[selected_index].Tag;
836     ListViewItem item = lstResults.Items[lstResults.SelectedIndices[i]];
837     this.AddToPatchList(item);
838     }
839     }
840     catch (Exception ex)
841     {
842     logger.Error.WriteLine(ex.ToString());
843     }
844     }
845    
846     private void mnuItemRemoveResult_Click(object sender, EventArgs e)
847     {
848     if (!(lstPatchList.SelectedItems.Count > 0)) return;
849     //if (SearchArgs == null) return;
850     try
851     {
852     this.FreezeResultsUpdate();
853     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
854     {
855     //lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
856     lstPatchList.Items[lstPatchList.SelectedIndices[i]].Remove();
857     }
858     this.ThawResultsUpdate();
859     }
860     catch (Exception ex)
861     {
862     Debug.WriteLine(ex.ToString());
863     }
864     }
865     private void PatchRange(bool SingleEntry)
866     {
867     //if (SearchArgs == null) return;
868     #region Patch Selected Address
869     // stop ResultsUpdate Thread
870     ResultsUpdateWorkerThread.CancelAsync();
871    
872     List<ResultDataType> patch_list = new List<ResultDataType>();
873     List<int> SelectedIndexes = new List<int>();
874    
875     if (SingleEntry)
876     {
877     SelectedIndexes.Add(lstPatchList.SelectedIndices[0]);
878     }
879     else
880     {
881     foreach (int index in lstPatchList.SelectedIndices)
882     {
883     SelectedIndexes.Add(index);
884     }
885     }
886     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
887     foreach (int index in SelectedIndexes)
888     {
889     if (SingleEntry)
890     {
891     SearchPatcher patcher = null;
892     uint Address = 0;
893     ListViewItem item = lstPatchList.Items[index];
894     ResultDataType _result = (ResultDataType)item.Tag;
895     Address = Convert.ToUInt32(item.SubItems[col_Found_Address].Text, 16);
896     switch (_result.ValueType)
897     {
898     case SearchDataTypes._8bits:
899     if (_result.IsUnsigned)
900     {
901     byte value = Convert.ToByte(item.SubItems[col_Found_Value].Text, 16);
902 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
903 william 230 timer_update_results.Enabled = false;
904     patcher.ShowDialog();
905     timer_update_results.Enabled = true;
906     PatchedValue_NeedsUpdate = true;
907     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
908     ResultsUpdateWorkerThread.RunWorkerAsync();
909     }
910     else
911     {
912     sbyte value = Convert.ToSByte(item.SubItems[col_Found_Value].Text, 16);
913 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
914 william 230 timer_update_results.Enabled = false;
915     patcher.ShowDialog();
916     timer_update_results.Enabled = true;
917     PatchedValue_NeedsUpdate = true;
918     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
919     ResultsUpdateWorkerThread.RunWorkerAsync();
920     }
921     break;
922     case SearchDataTypes._16bits:
923     if (_result.IsUnsigned)
924     {
925     ushort value = Convert.ToUInt16(item.SubItems[col_Found_Value].Text, 16);
926 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
927 william 230 timer_update_results.Enabled = false;
928     patcher.ShowDialog();
929     timer_update_results.Enabled = true;
930     PatchedValue_NeedsUpdate = true;
931     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
932     ResultsUpdateWorkerThread.RunWorkerAsync();
933     }
934     else
935     {
936     short value = Convert.ToInt16(item.SubItems[col_Found_Value].Text, 16);
937 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
938 william 230 timer_update_results.Enabled = false;
939     patcher.ShowDialog();
940     timer_update_results.Enabled = true;
941     PatchedValue_NeedsUpdate = true;
942     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
943     ResultsUpdateWorkerThread.RunWorkerAsync();
944     }
945     break;
946     case SearchDataTypes._32bits:
947     if (_result.IsUnsigned)
948     {
949     uint value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
950 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
951 william 230 timer_update_results.Enabled = false;
952     patcher.ShowDialog();
953     timer_update_results.Enabled = true;
954     PatchedValue_NeedsUpdate = true;
955     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
956     ResultsUpdateWorkerThread.RunWorkerAsync();
957     }
958     else
959     {
960     int value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
961 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
962 william 230 timer_update_results.Enabled = false;
963     patcher.ShowDialog();
964     timer_update_results.Enabled = true;
965     PatchedValue_NeedsUpdate = true;
966     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
967     ResultsUpdateWorkerThread.RunWorkerAsync();
968     }
969     break;
970     case SearchDataTypes._64bits:
971     if (_result.IsUnsigned)
972     {
973     ulong value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
974 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
975 william 230 timer_update_results.Enabled = false;
976     patcher.ShowDialog();
977     timer_update_results.Enabled = true;
978     PatchedValue_NeedsUpdate = true;
979     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
980     ResultsUpdateWorkerThread.RunWorkerAsync();
981     }
982     else
983     {
984     long value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
985 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
986 william 230 timer_update_results.Enabled = false;
987     patcher.ShowDialog();
988     timer_update_results.Enabled = true;
989     PatchedValue_NeedsUpdate = true;
990     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
991     ResultsUpdateWorkerThread.RunWorkerAsync();
992     }
993     break;
994     }
995     }
996     else
997     {
998    
999     ListViewItem item = lstPatchList.Items[index];
1000     ResultDataType _result = (ResultDataType)item.Tag;
1001     patch_list.Add(_result);
1002     }
1003     }
1004    
1005     if (patch_list.Count > 0)
1006     {
1007 william 243 SearchRangePatcher rangePatcher = new SearchRangePatcher((IAcceptsProcessAndConfig)this, patch_list);
1008 william 230 rangePatcher.ShowDialog();
1009     }
1010    
1011     #endregion
1012     }
1013     private void mnuItemPatchSelectedEntry_Click(object sender, EventArgs e)
1014     {
1015     if (!(lstPatchList.SelectedItems.Count == 1)) return;
1016     PatchRange(true);
1017     }
1018    
1019     private void mnuItemPatchSelectedRange_Click(object sender, EventArgs e)
1020     {
1021     if (!(lstPatchList.SelectedItems.Count >= 1)) return;
1022     PatchRange(false);
1023     }
1024    
1025     private void mnuItemFreezeSelectedPatches_Click(object sender, EventArgs e)
1026     {
1027     if (!(lstPatchList.SelectedItems.Count > 0)) return;
1028     //if (SearchArgs == null) return;
1029     try
1030     {
1031 william 477 lstPatchList.ProcessID = this.AcceptedProcess.Id;
1032 william 230 this.FreezeResultsUpdate();
1033     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1034     {
1035     lstPatchList.FreezeItem(lstPatchList.SelectedIndices[i]);
1036     }
1037     // force thaw and update
1038     this.ThawResultsUpdate();
1039     this.Update();
1040     }
1041     catch (Exception ex)
1042     {
1043     Debug.WriteLine(ex.ToString());
1044     }
1045     }
1046    
1047     private void mnuItemThawSelectedPatches_Click(object sender, EventArgs e)
1048     {
1049     if (!(lstPatchList.SelectedItems.Count > 0)) return;
1050     //if (SearchArgs == null) return;
1051     try
1052     {
1053 william 477 lstPatchList.ProcessID = this.AcceptedProcess.Id;
1054 william 230 this.FreezeResultsUpdate();
1055     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1056     {
1057     lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
1058     }
1059     // force thaw and update
1060     this.ThawResultsUpdate();
1061     this.Update();
1062     }
1063     catch (Exception ex)
1064     {
1065     Debug.WriteLine(ex.ToString());
1066     }
1067     }
1068 william 474
1069 william 511 #region old-code: private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1070     //private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1071     //{
1072     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1073     // SearchDataTypes sdt = SearchArgs.DataType;
1074     // bool unsigned = SearchArgs.IsUnsignedDataType;
1075     // //int Last_Whole_Percent_Done = 0;
1076     // uint CurrentIndex = e.CurrentIndex;
1077     // if (e.UserState != null)
1078     // {
1079     // SearchResultWriter writer = (e.UserState as SearchResultWriter);
1080     // if (writer == null)
1081     // throw new InvalidOperationException("writer cannot be null");
1082     // using (MemoryStream ms = new MemoryStream(e.Data))
1083     // {
1084     // using (BinaryReader br = new BinaryReader(ms))
1085     // {
1086     // while (br.BaseStream.Position < br.BaseStream.Length)
1087     // {
1088     // try
1089     // {
1090     // switch (sdt)
1091     // {
1092     // case SearchDataTypes._8bits:
1093     // if (unsigned)
1094     // {
1095     // #region 8bits - unsigned
1096     // var Value = br.ReadByte();
1097     // using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1098     // {
1099     // byte value = 0;
1100     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1101     // {
1102     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1103     // {
1104     // try
1105     // {
1106     // gmp.OpenProvider();
1107     // gmp.ReadMemory(CurrentIndex, out value);
1108     // gmp.CloseProvider();
1109     // }
1110     // catch (Exception ex)
1111     // {
1112     // logger.VerboseError.WriteLine(ex.ToString());
1113     // }
1114     // }
1115     // comparer.Value = value;
1116     // }
1117     // else
1118     // {
1119     // value = Convert.ToByte(SearchArgs.CompareStartValue);
1120     // comparer.Value = value;
1121     // }
1122     // if (comparer.Compare(Convert.ToByte(Value), value))
1123     // {
1124     // writer.WriteResult<byte>(comparer.Address, comparer.Value);
1125     // }
1126     // }
1127     // #endregion
1128     // }
1129     // else
1130     // {
1131     // #region 8bits - signed
1132     // var Value = br.ReadSByte();
1133     // using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1134     // {
1135     // sbyte value = 0;
1136     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1137     // {
1138     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1139     // {
1140     // try
1141     // {
1142     // gmp.OpenProvider();
1143     // gmp.ReadMemory(CurrentIndex, out value);
1144     // gmp.CloseProvider();
1145     // }
1146     // catch (Exception ex)
1147     // {
1148     // logger.VerboseError.WriteLine(ex.ToString());
1149     // }
1150     // }
1151     // comparer.Value = value;
1152     // }
1153     // else
1154     // {
1155     // value = Convert.ToSByte(SearchArgs.CompareStartValue);
1156     // comparer.Value = value;
1157     // }
1158     // if (comparer.Compare(Convert.ToSByte(Value), value))
1159     // {
1160     // writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1161     // }
1162     // }
1163     // #endregion
1164     // } break;
1165     // case SearchDataTypes._16bits:
1166     // if (unsigned)
1167     // {
1168     // #region 16bits - unsigned
1169     // var Value = br.ReadUInt16();
1170     // using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1171     // {
1172     // ushort value = 0;
1173     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1174     // {
1175     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1176     // {
1177     // try
1178     // {
1179     // gmp.OpenProvider();
1180     // gmp.ReadMemory(CurrentIndex, out value);
1181     // gmp.CloseProvider();
1182     // }
1183     // catch (Exception ex)
1184     // {
1185     // logger.VerboseError.WriteLine(ex.ToString());
1186     // }
1187     // }
1188     // comparer.Value = value;
1189     // }
1190     // else
1191     // {
1192     // value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1193     // comparer.Value = value;
1194     // }
1195     // if (comparer.Compare(Convert.ToUInt16(Value), value))
1196     // {
1197     // writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1198     // }
1199     // }
1200     // #endregion
1201     // }
1202     // else
1203     // {
1204     // #region 16bits - signed
1205     // var Value = br.ReadInt16();
1206     // using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1207     // {
1208     // short value = 0;
1209     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1210     // {
1211     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1212     // {
1213     // try
1214     // {
1215     // gmp.OpenProvider();
1216     // gmp.ReadMemory(CurrentIndex, out value);
1217     // gmp.CloseProvider();
1218     // }
1219     // catch (Exception ex)
1220     // {
1221     // logger.VerboseError.WriteLine(ex.ToString());
1222     // }
1223     // }
1224     // comparer.Value = value;
1225     // }
1226     // else
1227     // {
1228     // value = Convert.ToInt16(SearchArgs.CompareStartValue);
1229     // comparer.Value = value;
1230     // }
1231     // if (comparer.Compare(Convert.ToSByte(Value), value))
1232     // {
1233     // writer.WriteResult<short>(comparer.Address, comparer.Value);
1234     // }
1235     // }
1236     // #endregion
1237     // } break;
1238     // case SearchDataTypes._32bits:
1239     // if (unsigned)
1240     // {
1241     // #region 32bits - unsigned
1242     // var Value = br.ReadUInt32();
1243     // using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1244     // {
1245     // uint value = 0;
1246     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1247     // {
1248     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1249     // {
1250     // try
1251     // {
1252     // gmp.OpenProvider();
1253     // gmp.ReadMemory(CurrentIndex, out value);
1254     // gmp.CloseProvider();
1255     // }
1256     // catch (Exception ex)
1257     // {
1258     // logger.VerboseError.WriteLine(ex.ToString());
1259     // }
1260     // }
1261     // comparer.Value = value;
1262     // }
1263     // else
1264     // {
1265     // value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1266     // comparer.Value = value;
1267     // }
1268     // if (comparer.Compare(Convert.ToUInt32(Value), value))
1269     // {
1270     // writer.WriteResult<uint>(comparer.Address, comparer.Value);
1271     // }
1272     // }
1273     // #endregion
1274     // }
1275     // else
1276     // {
1277     // #region 32bits - signed
1278     // var Value = br.ReadInt32();
1279     // using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1280     // {
1281     // int value = 0;
1282     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1283     // {
1284     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1285     // {
1286     // try
1287     // {
1288     // gmp.OpenProvider();
1289     // gmp.ReadMemory(CurrentIndex, out value);
1290     // gmp.CloseProvider();
1291     // }
1292     // catch (Exception ex)
1293     // {
1294     // logger.VerboseError.WriteLine(ex.ToString());
1295     // }
1296     // }
1297     // comparer.Value = value;
1298     // }
1299     // else
1300     // {
1301     // value = Convert.ToInt32(SearchArgs.CompareStartValue);
1302     // comparer.Value = value;
1303     // }
1304     // if (comparer.Compare(Convert.ToInt32(Value), value))
1305     // {
1306     // writer.WriteResult<int>(comparer.Address, comparer.Value);
1307     // }
1308     // }
1309     // #endregion
1310     // } break;
1311     // case SearchDataTypes._64bits:
1312     // if (unsigned)
1313     // {
1314     // #region 64bits - unsigned
1315     // var Value = br.ReadUInt64();
1316     // using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1317     // {
1318     // ulong value = 0;
1319     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1320     // {
1321     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1322     // {
1323     // try
1324     // {
1325     // gmp.OpenProvider();
1326     // gmp.ReadMemory(CurrentIndex, out value);
1327     // gmp.CloseProvider();
1328     // }
1329     // catch (Exception ex)
1330     // {
1331     // logger.VerboseError.WriteLine(ex.ToString());
1332     // }
1333     // }
1334     // comparer.Value = value;
1335     // }
1336     // else
1337     // {
1338     // value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1339     // comparer.Value = value;
1340     // }
1341     // if (comparer.Compare(Convert.ToUInt64(Value), value))
1342     // {
1343     // writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1344     // }
1345     // }
1346     // #endregion
1347     // }
1348     // else
1349     // {
1350     // #region 64bits - signed
1351     // var Value = br.ReadInt64();
1352     // using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1353     // {
1354     // long value = 0;
1355     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1356     // {
1357     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1358     // {
1359     // try
1360     // {
1361     // gmp.OpenProvider();
1362     // gmp.ReadMemory(CurrentIndex, out value);
1363     // gmp.CloseProvider();
1364     // }
1365     // catch (Exception ex)
1366     // {
1367     // logger.VerboseError.WriteLine(ex.ToString());
1368     // }
1369     // }
1370     // comparer.Value = value;
1371     // }
1372     // else
1373     // {
1374     // value = Convert.ToInt64(SearchArgs.CompareStartValue);
1375     // comparer.Value = value;
1376     // }
1377     // if (comparer.Compare(Convert.ToInt64(Value), value))
1378     // {
1379     // writer.WriteResult<long>(comparer.Address, comparer.Value);
1380     // }
1381     // }
1382     // #endregion
1383     // } break;
1384     // }
1385     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1386     // }
1387     // catch (EndOfStreamException) { }
1388     // if (e.ReportProgress)
1389     // {
1390     // double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1391     // int int_percent_done = (int)double_percent_done;
1392     // //if (CurrentIndex % 10 == 0)
1393     // //{
1394     // // if (int_percent_done <= 100)
1395     // // {
1396     // new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Index: 0x{0:x8} of 0x{1:x8}", CurrentIndex, e.TotalCount));
1397     // // }
1398     // // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1399     // //}
1400     // }
1401     // //switch (sdt)
1402     // //{
1403     // // case SearchDataTypes._8bits:
1404     // // CurrentIndex += sizeof(byte);
1405     // // break;
1406     // // case SearchDataTypes._16bits:
1407     // // CurrentIndex += sizeof(ushort);
1408     // // break;
1409     // // case SearchDataTypes._32bits:
1410     // // CurrentIndex += sizeof(uint);
1411     // // break;
1412     // // case SearchDataTypes._64bits:
1413     // // CurrentIndex += sizeof(ulong);
1414     // // break;
1415     // //}
1416     // }
1417     // }
1418     // }
1419     // }
1420     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1421     //}
1422     #endregion
1423    
1424 william 523 #region old-code: private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1425     //private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1426     //{
1427     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1428     // SearchDataTypes sdt = SearchArgs.DataType;
1429     // bool unsigned = SearchArgs.IsUnsignedDataType;
1430     // int Last_Whole_Percent_Done = 0;
1431     // uint CurrentIndex = e.CurrentIndex;
1432     // if (e.UserState != null)
1433     // {
1434     // SearchResultWriter writer = (e.UserState as SearchResultWriter);
1435     // if (writer == null)
1436     // throw new InvalidOperationException("writer cannot be null");
1437     // using (MemoryStream ms = new MemoryStream(e.Data))
1438     // {
1439     // using (BinaryReader br = new BinaryReader(ms))
1440     // {
1441     // while (br.BaseStream.Position < br.BaseStream.Length)
1442     // {
1443     // try
1444     // {
1445     // //if (e.ReportProgress)
1446     // //{
1447     // // double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1448     // // int int_percent_done = (int)double_percent_done;
1449     // // int align_base = 100;
1450     // // int align_power = 1;
1451     // // int align = align_base * align_power;
1452     // // if (int_percent_done != Last_Whole_Percent_Done && (CurrentIndex % align) == 0)
1453     // // {
1454     // // string message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));
1455     // // UpdateProgress((int)double_percent_done, message);
1456     // // //new Action<int, string>(UpdateProgress).Invoke(int_percent_done, message);
1457     // // Last_Whole_Percent_Done = int_percent_done;
1458     // // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1459     // // }
1460     // //}
1461 william 513
1462 william 523 // switch (sdt)
1463     // {
1464     // case SearchDataTypes._8bits:
1465     // if (unsigned)
1466     // {
1467     // #region 8bits - unsigned
1468     // var Value = br.ReadByte();
1469     // using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1470     // {
1471     // byte value = 0;
1472     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1473     // {
1474     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1475     // {
1476     // try
1477     // {
1478     // gmp.OpenProvider();
1479     // gmp.ReadMemory(CurrentIndex, out value);
1480     // gmp.CloseProvider();
1481     // }
1482     // catch (Exception ex)
1483     // {
1484     // logger.VerboseError.WriteLine(ex.ToString());
1485     // }
1486     // }
1487     // comparer.Value = value;
1488     // }
1489     // else
1490     // {
1491     // value = Convert.ToByte(SearchArgs.CompareStartValue);
1492     // comparer.Value = value;
1493     // }
1494     // if (comparer.Compare(Convert.ToByte(Value), value))
1495     // {
1496     // writer.WriteResult<byte>(comparer.Address, comparer.Value);
1497     // }
1498     // }
1499     // #endregion
1500     // }
1501     // else
1502     // {
1503     // #region 8bits - signed
1504     // var Value = br.ReadSByte();
1505     // using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1506     // {
1507     // sbyte value = 0;
1508     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1509     // {
1510     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1511     // {
1512     // try
1513     // {
1514     // gmp.OpenProvider();
1515     // gmp.ReadMemory(CurrentIndex, out value);
1516     // gmp.CloseProvider();
1517     // }
1518     // catch (Exception ex)
1519     // {
1520     // logger.VerboseError.WriteLine(ex.ToString());
1521     // }
1522     // }
1523     // comparer.Value = value;
1524     // }
1525     // else
1526     // {
1527     // value = Convert.ToSByte(SearchArgs.CompareStartValue);
1528     // comparer.Value = value;
1529     // }
1530     // if (comparer.Compare(Convert.ToSByte(Value), value))
1531     // {
1532     // writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1533     // }
1534     // }
1535     // #endregion
1536     // } break;
1537     // case SearchDataTypes._16bits:
1538     // if (unsigned)
1539     // {
1540     // #region 16bits - unsigned
1541     // var Value = br.ReadUInt16();
1542     // using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1543     // {
1544     // ushort value = 0;
1545     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1546     // {
1547     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1548     // {
1549     // try
1550     // {
1551     // gmp.OpenProvider();
1552     // gmp.ReadMemory(CurrentIndex, out value);
1553     // gmp.CloseProvider();
1554     // }
1555     // catch (Exception ex)
1556     // {
1557     // logger.VerboseError.WriteLine(ex.ToString());
1558     // }
1559     // }
1560     // comparer.Value = value;
1561     // }
1562     // else
1563     // {
1564     // value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1565     // comparer.Value = value;
1566     // }
1567     // if (comparer.Compare(Convert.ToUInt16(Value), value))
1568     // {
1569     // writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1570     // }
1571     // }
1572     // #endregion
1573     // }
1574     // else
1575     // {
1576     // #region 16bits - signed
1577     // var Value = br.ReadInt16();
1578     // using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1579     // {
1580     // short value = 0;
1581     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1582     // {
1583     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1584     // {
1585     // try
1586     // {
1587     // gmp.OpenProvider();
1588     // gmp.ReadMemory(CurrentIndex, out value);
1589     // gmp.CloseProvider();
1590     // }
1591     // catch (Exception ex)
1592     // {
1593     // logger.VerboseError.WriteLine(ex.ToString());
1594     // }
1595     // }
1596     // comparer.Value = value;
1597     // }
1598     // else
1599     // {
1600     // value = Convert.ToInt16(SearchArgs.CompareStartValue);
1601     // comparer.Value = value;
1602     // }
1603     // if (comparer.Compare(Convert.ToSByte(Value), value))
1604     // {
1605     // writer.WriteResult<short>(comparer.Address, comparer.Value);
1606     // }
1607     // }
1608     // #endregion
1609     // } break;
1610     // case SearchDataTypes._32bits:
1611     // if (unsigned)
1612     // {
1613     // #region 32bits - unsigned
1614     // var Value = br.ReadUInt32();
1615     // using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1616     // {
1617     // uint value = 0;
1618     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1619     // {
1620     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1621     // {
1622     // try
1623     // {
1624     // gmp.OpenProvider();
1625     // gmp.ReadMemory(CurrentIndex, out value);
1626     // gmp.CloseProvider();
1627     // }
1628     // catch (Exception ex)
1629     // {
1630     // logger.VerboseError.WriteLine(ex.ToString());
1631     // }
1632     // }
1633     // comparer.Value = value;
1634     // }
1635     // else
1636     // {
1637     // value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1638     // comparer.Value = value;
1639     // }
1640     // if (comparer.Compare(Convert.ToUInt32(Value), value))
1641     // {
1642     // writer.WriteResult<uint>(comparer.Address, comparer.Value);
1643     // }
1644     // }
1645     // #endregion
1646     // }
1647     // else
1648     // {
1649     // #region 32bits - signed
1650     // var Value = br.ReadInt32();
1651     // using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1652     // {
1653     // int value = 0;
1654     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1655     // {
1656     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1657     // {
1658     // try
1659     // {
1660     // gmp.OpenProvider();
1661     // gmp.ReadMemory(CurrentIndex, out value);
1662     // gmp.CloseProvider();
1663     // }
1664     // catch (Exception ex)
1665     // {
1666     // logger.VerboseError.WriteLine(ex.ToString());
1667     // }
1668     // }
1669     // comparer.Value = value;
1670     // }
1671     // else
1672     // {
1673     // value = Convert.ToInt32(SearchArgs.CompareStartValue);
1674     // comparer.Value = value;
1675     // }
1676     // if (comparer.Compare(Convert.ToInt32(Value), value))
1677     // {
1678     // writer.WriteResult<int>(comparer.Address, comparer.Value);
1679     // }
1680     // }
1681     // #endregion
1682     // } break;
1683     // case SearchDataTypes._64bits:
1684     // if (unsigned)
1685     // {
1686     // #region 64bits - unsigned
1687     // var Value = br.ReadUInt64();
1688     // using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1689     // {
1690     // ulong value = 0;
1691     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1692     // {
1693     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1694     // {
1695     // try
1696     // {
1697     // gmp.OpenProvider();
1698     // gmp.ReadMemory(CurrentIndex, out value);
1699     // gmp.CloseProvider();
1700     // }
1701     // catch (Exception ex)
1702     // {
1703     // logger.VerboseError.WriteLine(ex.ToString());
1704     // }
1705     // }
1706     // comparer.Value = value;
1707     // }
1708     // else
1709     // {
1710     // value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1711     // comparer.Value = value;
1712     // }
1713     // if (comparer.Compare(Convert.ToUInt64(Value), value))
1714     // {
1715     // writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1716     // }
1717     // }
1718     // #endregion
1719     // }
1720     // else
1721     // {
1722     // #region 64bits - signed
1723     // var Value = br.ReadInt64();
1724     // using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1725     // {
1726     // long value = 0;
1727     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1728     // {
1729     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1730     // {
1731     // try
1732     // {
1733     // gmp.OpenProvider();
1734     // gmp.ReadMemory(CurrentIndex, out value);
1735     // gmp.CloseProvider();
1736     // }
1737     // catch (Exception ex)
1738     // {
1739     // logger.VerboseError.WriteLine(ex.ToString());
1740     // }
1741     // }
1742     // comparer.Value = value;
1743     // }
1744     // else
1745     // {
1746     // value = Convert.ToInt64(SearchArgs.CompareStartValue);
1747     // comparer.Value = value;
1748     // }
1749     // if (comparer.Compare(Convert.ToInt64(Value), value))
1750     // {
1751     // writer.WriteResult<long>(comparer.Address, comparer.Value);
1752     // }
1753     // }
1754     // #endregion
1755     // } break;
1756     // }
1757     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1758     // }
1759     // catch (EndOfStreamException) { }
1760    
1761     // uint size = 0;
1762     // BitTools.SizeOf(sdt, out size);
1763     // CurrentIndex += size;
1764     // }
1765     // }
1766     // }
1767     // }
1768     // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1769     //}
1770     #endregion
1771 william 520
1772 william 230 private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1773     {
1774 william 410 try
1775 william 483 {
1776 william 410 Stopwatch st = new Stopwatch();
1777     st.Start();
1778 william 392
1779 william 410 Stopwatch st_first_search = new Stopwatch();
1780     Stopwatch st_nonrange_search = new Stopwatch();
1781     Stopwatch st_ranged_search = new Stopwatch();
1782 william 392
1783 william 410 e.Result = st;
1784     //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1785 william 476 List<ResultType<ulong>> second_tmp_Results = new List<ResultType<ulong>>();
1786 william 410 //const int ElementsBeforeDisplay = 100;
1787     SearchArgs.LogSearchOptions();
1788     uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1789 william 399
1790 william 410 bool unsigned = SearchArgs.IsUnsignedDataType;
1791     SearchDataTypes sdt = SearchArgs.DataType;
1792     //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1793     logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));
1794 william 517 UpdateProgress(0, string.Format("Search is Warming Up...Please Wait..."));
1795     //new Action<int, string>(UpdateProgress).Invoke(0, string.Format("Search is Warming Up...Please Wait..."));
1796 william 410 Stopwatch provider_st = new Stopwatch();
1797     provider_st.Start();
1798     using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1799     {
1800 william 483
1801 william 459 if (SearchArgs.IsFirstSearch)
1802     {
1803 william 460 provider.OpenProvider();
1804     int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1805     SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1806 william 521 //provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1807     //provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1808    
1809    
1810     Stopwatch st_profiler = new Stopwatch();
1811     st_profiler.Start();
1812     //int Last_Whole_Percent_Done = 0;
1813     uint size = STEP_SIZE * 4096;
1814     for (uint i = MemoryRangeStart; i < MemoryRangeSize; i+=size)
1815     {
1816    
1817     int bytesRead=0;
1818     byte[] data = new byte[size];
1819     //provider.ReadProcessMemory(i, size, out bytesRead, out data);
1820    
1821     provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1822    
1823     //OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, i, MemoryRangeSize, true);
1824     //search_provider_OnBytesRead(t_args);
1825     //t_args = null;
1826    
1827     string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1828     double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1829     //int int_percent_done = (int)double_percent_done;
1830     if ((i % 10000) == 0)
1831     {
1832     UpdateProgress((int)double_percent_done, message);
1833     logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation has taken {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
1834     //Last_Whole_Percent_Done = int_percent_done;
1835     }
1836    
1837    
1838     #region comparison and serialization
1839     switch (sdt)
1840     {
1841     case SearchDataTypes._8bits:
1842     if (unsigned)
1843     {
1844     #region 8bits - unsigned
1845     var t_data = BitTools.ConvertByteArray<byte>(data);
1846     foreach (var Value in t_data)
1847     {
1848     if (SearchWorkerThread.CancellationPending) { break; }
1849     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, i))
1850     {
1851     byte value = 0;
1852     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1853     {
1854     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1855     {
1856     try
1857     {
1858     gmp.OpenProvider();
1859     gmp.ReadMemory(i, out value);
1860     gmp.CloseProvider();
1861     }
1862     catch (Exception ex)
1863     {
1864     logger.VerboseError.WriteLine(ex.ToString());
1865     }
1866     }
1867     comparer.Value = value;
1868     }
1869     else
1870     {
1871     value = Convert.ToByte(SearchArgs.CompareStartValue);
1872     comparer.Value = value;
1873     }
1874     if (comparer.Compare(Convert.ToByte(Value), value))
1875     {
1876     writer.WriteResult<byte>(comparer.Address, comparer.Value);
1877     }
1878     }
1879     }
1880     #endregion
1881     }
1882     else
1883     {
1884     #region 8bits - signed
1885     var t_data = BitTools.ConvertByteArray<sbyte>(data);
1886     foreach (var Value in t_data)
1887     {
1888     if (SearchWorkerThread.CancellationPending) { break; }
1889     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, i))
1890     {
1891     sbyte value = 0;
1892     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1893     {
1894     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1895     {
1896     try
1897     {
1898     gmp.OpenProvider();
1899     gmp.ReadMemory(i, out value);
1900     gmp.CloseProvider();
1901     }
1902     catch (Exception ex)
1903     {
1904     logger.VerboseError.WriteLine(ex.ToString());
1905     }
1906     }
1907     comparer.Value = value;
1908     }
1909     else
1910     {
1911     value = Convert.ToSByte(SearchArgs.CompareStartValue);
1912     comparer.Value = value;
1913     }
1914     if (comparer.Compare(Convert.ToSByte(Value), value))
1915     {
1916     writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1917     }
1918     }
1919     }
1920     #endregion
1921     } break;
1922     case SearchDataTypes._16bits:
1923     if (unsigned)
1924     {
1925     #region 16bits - unsigned
1926     var t_data = BitTools.ConvertByteArray<ushort>(data);
1927     foreach (var Value in t_data)
1928     {
1929     if (SearchWorkerThread.CancellationPending) { break; }
1930     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, i))
1931     {
1932     ushort value = 0;
1933     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1934     {
1935     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1936     {
1937     try
1938     {
1939     gmp.OpenProvider();
1940     gmp.ReadMemory(i, out value);
1941     gmp.CloseProvider();
1942     }
1943     catch (Exception ex)
1944     {
1945     logger.VerboseError.WriteLine(ex.ToString());
1946     }
1947     }
1948     comparer.Value = value;
1949     }
1950     else
1951     {
1952     value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1953     comparer.Value = value;
1954     }
1955     if (comparer.Compare(Convert.ToUInt16(Value), value))
1956     {
1957     writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1958     }
1959     }
1960     }
1961     #endregion
1962     }
1963     else
1964     {
1965     #region 16bits - signed
1966     var t_data = BitTools.ConvertByteArray<short>(data);
1967     foreach (var Value in t_data)
1968     {
1969     if (SearchWorkerThread.CancellationPending) { break; }
1970     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, i))
1971     {
1972     short value = 0;
1973     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1974     {
1975     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1976     {
1977     try
1978     {
1979     gmp.OpenProvider();
1980     gmp.ReadMemory(i, out value);
1981     gmp.CloseProvider();
1982     }
1983     catch (Exception ex)
1984     {
1985     logger.VerboseError.WriteLine(ex.ToString());
1986     }
1987     }
1988     comparer.Value = value;
1989     }
1990     else
1991     {
1992     value = Convert.ToInt16(SearchArgs.CompareStartValue);
1993     comparer.Value = value;
1994     }
1995     if (comparer.Compare(Convert.ToSByte(Value), value))
1996     {
1997     writer.WriteResult<short>(comparer.Address, comparer.Value);
1998     }
1999     }
2000     }
2001     #endregion
2002     } break;
2003     case SearchDataTypes._32bits:
2004     if (unsigned)
2005     {
2006     #region 32bits - unsigned
2007     var t_data = BitTools.ConvertByteArray<uint>(data);
2008     foreach (var Value in t_data)
2009     {
2010     if (SearchWorkerThread.CancellationPending) { break; }
2011     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, i))
2012     {
2013     uint value = 0;
2014     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2015     {
2016     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2017     {
2018     try
2019     {
2020     gmp.OpenProvider();
2021     gmp.ReadMemory(i, out value);
2022     gmp.CloseProvider();
2023     }
2024     catch (Exception ex)
2025     {
2026     logger.VerboseError.WriteLine(ex.ToString());
2027     }
2028     }
2029     comparer.Value = value;
2030     }
2031     else
2032     {
2033     value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2034     comparer.Value = value;
2035     }
2036     if (comparer.Compare(Convert.ToUInt32(Value), value))
2037     {
2038     writer.WriteResult<uint>(comparer.Address, comparer.Value);
2039     }
2040     }
2041     }
2042     #endregion
2043     }
2044     else
2045     {
2046     #region 32bits - signed
2047     var t_data = BitTools.ConvertByteArray<int>(data);
2048     foreach (var Value in t_data)
2049     {
2050     if (SearchWorkerThread.CancellationPending) { break; }
2051     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, i))
2052     {
2053     int value = 0;
2054     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2055     {
2056     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2057     {
2058     try
2059     {
2060     gmp.OpenProvider();
2061     gmp.ReadMemory(i, out value);
2062     gmp.CloseProvider();
2063     }
2064     catch (Exception ex)
2065     {
2066     logger.VerboseError.WriteLine(ex.ToString());
2067     }
2068     }
2069     comparer.Value = value;
2070     }
2071     else
2072     {
2073     value = Convert.ToInt32(SearchArgs.CompareStartValue);
2074     comparer.Value = value;
2075     }
2076     if (comparer.Compare(Convert.ToInt32(Value), value))
2077     {
2078     writer.WriteResult<int>(comparer.Address, comparer.Value);
2079     }
2080     }
2081     }
2082     #endregion
2083     } break;
2084     case SearchDataTypes._64bits:
2085     if (unsigned)
2086     {
2087     #region 64bits - unsigned
2088     var t_data = BitTools.ConvertByteArray<ulong>(data);
2089     foreach (var Value in t_data)
2090     {
2091     if (SearchWorkerThread.CancellationPending) { break; }
2092     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, i))
2093     {
2094     ulong value = 0;
2095     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2096     {
2097     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2098     {
2099     try
2100     {
2101     gmp.OpenProvider();
2102     gmp.ReadMemory(i, out value);
2103     gmp.CloseProvider();
2104     }
2105     catch (Exception ex)
2106     {
2107     logger.VerboseError.WriteLine(ex.ToString());
2108     }
2109     }
2110     comparer.Value = value;
2111     }
2112     else
2113     {
2114     value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2115     comparer.Value = value;
2116     }
2117     if (comparer.Compare(Convert.ToUInt64(Value), value))
2118     {
2119     writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2120     }
2121     }
2122     }
2123     #endregion
2124     }
2125     else
2126     {
2127     #region 64bits - signed
2128     var t_data = BitTools.ConvertByteArray<long>(data);
2129     foreach (var Value in t_data)
2130     {
2131     if (SearchWorkerThread.CancellationPending) { break; }
2132     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, i))
2133     {
2134     long value = 0;
2135     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2136     {
2137     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2138     {
2139     try
2140     {
2141     gmp.OpenProvider();
2142     gmp.ReadMemory(i, out value);
2143     gmp.CloseProvider();
2144     }
2145     catch (Exception ex)
2146     {
2147     logger.VerboseError.WriteLine(ex.ToString());
2148     }
2149     }
2150     comparer.Value = value;
2151     }
2152     else
2153     {
2154     value = Convert.ToInt64(SearchArgs.CompareStartValue);
2155     comparer.Value = value;
2156     }
2157     if (comparer.Compare(Convert.ToInt64(Value), value))
2158     {
2159     writer.WriteResult<long>(comparer.Address, comparer.Value);
2160     }
2161     }
2162     }
2163     #endregion
2164     } break;
2165     }
2166    
2167     //using (MemoryStream ms = new MemoryStream(data))
2168     //{
2169     // using (BinaryReader br = new BinaryReader(ms))
2170     // {
2171     // while (br.BaseStream.Position < br.BaseStream.Length)
2172     // {
2173     // if (SearchWorkerThread.CancellationPending)
2174     // {
2175     // break;
2176     // }
2177     // }
2178     // }
2179     //}
2180     #endregion
2181    
2182    
2183     if (SearchWorkerThread.CancellationPending)
2184     {
2185     st_profiler.Stop();
2186     provider_st.Stop();
2187     st.Stop();
2188     writer.CancelRequest();
2189     writer.Dispose();
2190     writer = null;
2191     e.Result = true;
2192     provider.CloseProvider();
2193     logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2194     return;
2195     }
2196     }
2197    
2198     st_profiler.Stop();
2199    
2200     logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2201    
2202 william 460 if (SearchWorkerThread.CancellationPending)
2203     {
2204     provider_st.Stop();
2205     st.Stop();
2206     writer.CancelRequest();
2207     writer.Dispose();
2208     writer = null;
2209     e.Result = true;
2210     provider.CloseProvider();
2211     return;
2212     }
2213     writer.Dispose();
2214     writer = null;
2215     provider.CloseProvider();
2216 william 459 }
2217     else
2218     {
2219 william 496
2220 william 505 #region action_onbytesread :: custom in-line delegate for processing read bytes
2221     // custom in-line delegate for processing read bytes
2222     Action<OnBytesReadEventArgs> action_onbytesread = delegate(OnBytesReadEventArgs obre)
2223 william 472 {
2224 william 505 SearchDataTypes obre_sdt = SearchArgs.DataType;
2225     bool obre_unsigned = SearchArgs.IsUnsignedDataType;
2226     uint obre_CurrentIndex = obre.CurrentIndex; // this should represent the address
2227     SearchResultReader reader = null;
2228     if (obre.UserState != null)
2229 william 459 {
2230 william 505 reader = (obre.UserState as SearchResultReader);
2231     if (reader == null)
2232     throw new InvalidOperationException("writer cannot be null");
2233     }
2234     else
2235     {
2236     throw new ArgumentNullException("UserState", "UserState cannot be null, it must be an instance of a SearchResultReader");
2237     }
2238     using (MemoryStream ms = new MemoryStream(obre.Data))
2239     {
2240     using (BinaryReader br = new BinaryReader(ms))
2241 william 497 {
2242 william 505 while (br.BaseStream.Position < br.BaseStream.Length)
2243 william 499 {
2244 william 505 ISerializedResult sr = (reader as ISerializedResult);
2245     if (sr == null)
2246     {
2247     throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
2248     }
2249     int sr_index = 0;
2250 william 508 try
2251 william 505 {
2252 william 508 if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
2253 william 505 {
2254 william 508 StructResultType<ulong> result = StructResultType<ulong>.Empty;
2255 william 509 sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
2256 william 508 if (Debugger.IsAttached)
2257     {
2258     Debugger.Break();
2259     }
2260    
2261 william 505 }
2262     }
2263 william 508 catch (Exception ex)
2264     {
2265     throw ex;
2266     }
2267 william 505 switch (obre_sdt)
2268 william 496 {
2269 william 505 case SearchDataTypes._8bits:
2270     if (obre_unsigned)
2271     {
2272     #region 8bit - unsigned
2273     var new_value = br.ReadByte(); // this should contain the updated value from memory
2274     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, obre_CurrentIndex))
2275 william 496 {
2276 william 505 byte value = 0; // this is the vaule we want to compare against
2277     value = Convert.ToByte(SearchArgs.CompareStartValue);
2278     comparer.Value = value;
2279     if (comparer.Compare(new_value, value))
2280 william 496 {
2281 william 505 //writer.WriteResult<byte>(comparer.Address, comparer.Value);
2282 william 496 }
2283     }
2284 william 505 #endregion
2285     }
2286     else
2287     {
2288     }
2289     break;
2290     case SearchDataTypes._16bits:
2291     if (obre_unsigned)
2292     {
2293     }
2294     else
2295     {
2296     }
2297     break;
2298     case SearchDataTypes._32bits:
2299     if (obre_unsigned)
2300     {
2301     }
2302     else
2303     {
2304     }
2305     break;
2306     case SearchDataTypes._64bits:
2307     if (obre_unsigned)
2308     {
2309     }
2310     else
2311     {
2312     }
2313     break;
2314 william 496 }
2315 william 505 uint size = 0;
2316     BitTools.SizeOf(obre_sdt, out size);
2317     obre_CurrentIndex += size;
2318 william 474 }
2319 william 460 }
2320 william 505 }
2321     };
2322     #endregion
2323     // need to get the address list
2324 william 506 using (SearchResultReader reader = new SearchResultReader(SearchGuid, false)) // delete the file on dispose
2325 william 505 {
2326    
2327 william 496
2328     provider.OpenProvider();
2329     //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
2330     //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
2331     provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(action_onbytesread);
2332 william 505 provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), reader);
2333 william 496 if (SearchWorkerThread.CancellationPending)
2334     {
2335     provider_st.Stop();
2336     st.Stop();
2337     e.Result = true;
2338     provider.CloseProvider();
2339     return;
2340 william 472 }
2341 william 496 provider.CloseProvider();
2342    
2343     //byte[] guid = SearchGuid.ToByteArray();
2344     //guid[guid.Length - 1]++; // increment the search guid by 1
2345     //Guid new_SearchGuid = new Guid(guid);
2346     ////const int item_count = 0x100;
2347     //using (SearchResultWriter writer = new SearchResultWriter((int)(reader.ResultCount), new_SearchGuid))
2348     //{
2349     // var items = reader.GetSearchAddressValueMatches((IAcceptsProcessAndConfig)this, SearchArgs, new Action<int, string>(UpdateProgress));
2350     // reader.Dispose(); // delete the result file, if allowed
2351     // foreach (var item in items)
2352     // {
2353     // switch (SearchArgs.DataType)
2354     // {
2355     // case SearchDataTypes._8bits:
2356     // if (SearchArgs.IsUnsignedDataType)
2357     // {
2358     // writer.WriteResult<byte>(item.Address, Convert.ToByte(item.Value));
2359     // }
2360     // else
2361     // {
2362     // writer.WriteResult<sbyte>(item.Address, Convert.ToSByte(item.Value));
2363     // }
2364     // break;
2365     // case SearchDataTypes._16bits:
2366     // if (SearchArgs.IsUnsignedDataType)
2367     // {
2368     // writer.WriteResult<ushort>(item.Address, Convert.ToUInt16(item.Value));
2369     // }
2370     // else
2371     // {
2372     // writer.WriteResult<short>(item.Address, Convert.ToInt16(item.Value));
2373     // }
2374     // break;
2375     // case SearchDataTypes._32bits:
2376     // if (SearchArgs.IsUnsignedDataType)
2377     // {
2378     // writer.WriteResult<uint>(item.Address, Convert.ToUInt32(item.Value));
2379     // }
2380     // else
2381     // {
2382     // writer.WriteResult<int>(item.Address, Convert.ToInt32(item.Value));
2383     // }
2384     // break;
2385     // case SearchDataTypes._64bits:
2386     // if (SearchArgs.IsUnsignedDataType)
2387     // {
2388     // writer.WriteResult<ulong>(item.Address, Convert.ToUInt64(item.Value));
2389     // }
2390     // else
2391     // {
2392     // writer.WriteResult<long>(item.Address, Convert.ToInt64(item.Value));
2393     // }
2394     // break;
2395     // }
2396     // }
2397     //}
2398     //SearchGuid = new_SearchGuid;
2399 william 459 }
2400     }
2401 william 410 }
2402     provider_st.Stop();
2403     logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
2404     //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
2405 william 456 //int Last_Whole_Percent_Done = 0;
2406 william 408
2407    
2408 william 410 #region Subsequent Searches
2409     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
2410 william 408
2411    
2412 william 410 // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
2413     bool NeedToCompare = true;
2414     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
2415     SearchArgs.CompareType == SearchCompareTypes.Equal &&
2416     SearchArgs.IsFirstSearch)
2417     {
2418     NeedToCompare = false;
2419     //second_tmp_Results = null; // Free Memory
2420     }
2421 william 408
2422 william 410 if (NeedToCompare)
2423 william 280 {
2424 william 410 if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
2425 william 280 {
2426 william 410 #region Non-Range Searches
2427 william 457 if (USE_NONRANGE_SEARCH_RESULT_READER)
2428 william 398 {
2429 william 457 st_nonrange_search.Start();
2430     //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
2431     ////second_tmp_Results.c
2432     try
2433 william 398 {
2434 william 457 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2435 william 398 {
2436 william 457 try
2437     {
2438 william 453
2439 william 457 #region new comparator-support
2440 william 476 //second_tmp_Results = new List<StructResultType<object>>(reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress)));
2441 william 457 #endregion
2442 william 452
2443 william 457 #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE
2444     if (USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE)
2445 william 452 {
2446 william 457 for (int i = 0; i < reader.ResultCount; i += 1)
2447 william 452 {
2448 william 457 object result_value = 0;
2449     uint address = 0;
2450     #region switch (SearchArgs.DataType)
2451     switch (SearchArgs.DataType)
2452     {
2453     case SearchDataTypes._8bits: if (unsigned)
2454 william 452 {
2455 william 457 using (ResultType<byte> result = reader.GetNextResult<byte>())
2456     {
2457     address = result.Address;
2458     result_value = result.Value;
2459     }
2460 william 452 }
2461 william 457 else
2462 william 452 {
2463 william 457 using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
2464     {
2465     address = result.Address;
2466     result_value = result.Value;
2467     }
2468     } break;
2469     case SearchDataTypes._16bits: if (unsigned)
2470 william 452 {
2471 william 457 using (ResultType<ushort> result = reader.GetNextResult<ushort>())
2472     {
2473     address = result.Address;
2474     result_value = result.Value;
2475     }
2476 william 452 }
2477 william 457 else
2478 william 452 {
2479 william 457 using (ResultType<short> result = reader.GetNextResult<short>())
2480     {
2481     address = result.Address;
2482     result_value = result.Value;
2483     }
2484     } break;
2485     case SearchDataTypes._32bits: if (unsigned)
2486 william 452 {
2487 william 457 using (ResultType<uint> result = reader.GetNextResult<uint>())
2488     {
2489     address = result.Address;
2490     result_value = result.Value;
2491     }
2492 william 452 }
2493 william 457 else
2494 william 452 {
2495 william 457 using (ResultType<int> result = reader.GetNextResult<int>())
2496     {
2497     address = result.Address;
2498     result_value = result.Value;
2499     }
2500     } break;
2501     case SearchDataTypes._64bits: if (unsigned)
2502 william 452 {
2503 william 457 using (ResultType<ulong> result = reader.GetNextResult<ulong>())
2504     {
2505     address = result.Address;
2506     result_value = result.Value;
2507     }
2508 william 452 }
2509 william 457 else
2510 william 452 {
2511 william 457 using (ResultType<long> result = reader.GetNextResult<long>())
2512     {
2513     address = result.Address;
2514     result_value = result.Value;
2515     }
2516     } break;
2517     }
2518     #endregion
2519     if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
2520     try
2521