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

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

Parent Directory Parent Directory | Revision Log Revision Log


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