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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 544 - (hide annotations) (download)
Wed Jun 5 22:00:27 2013 UTC (7 years, 4 months ago) by william
File size: 142495 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 544 if (SearchWorkerThread.CancellationPending)
1514     {
1515     provider_st.Stop();
1516     st.Stop();
1517     writer.CancelRequest();
1518     writer.Dispose();
1519     e.Result = true;
1520     break;
1521     }
1522 william 532 }
1523 william 542 // Get update value(s) for each chunk result
1524     ISerializedResult sr = (reader as ISerializedResult);
1525     if(sr == null)
1526 william 534 {
1527 william 542 throw new ArgumentNullException("sr",string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name,typeof(ISerializedResult).Name));
1528 william 534 }
1529 william 530
1530 william 542 Stopwatch st_memory_results_updater = new Stopwatch();
1531     st_memory_results_updater.Start();
1532     sr.UpdateResultValuesFromMemory(ref ChunkResults, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation), (IAcceptsProcessAndConfig)this);
1533 william 544 if (SearchWorkerThread.CancellationPending) // catch a cancelled operation from UpdateResultValuesFromMemory
1534     {
1535     provider_st.Stop();
1536     st.Stop();
1537     writer.CancelRequest();
1538     writer.Dispose();
1539     e.Result = true;
1540     break;
1541     }
1542    
1543 william 542 st_memory_results_updater.Stop();
1544     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());
1545    
1546     // ChunkResults should have had thier values updated from memory
1547    
1548    
1549 william 544 string message = string.Format(" -> Updateing Values [ResultIndex=0x{0} of Total=0x{1}]", ResultIndex.ToString("X"), reader.ResultCount.ToString("X"));
1550 william 542 double double_percent_done = 100.0 * (double)((double)ResultIndex / (double)reader.ResultCount);
1551 william 530 int int_percent_done = (int)double_percent_done;
1552 william 541 //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)
1553     //{
1554     // UpdateProgress((int)double_percent_done, message);
1555     // Last_Whole_Percent_Done = int_percent_done;
1556     //}
1557 william 544 if (((double)ResultIndex % ((double)reader.ResultCount) * 0.25) == 0)
1558     //if ((ResultIndex % 10000) == 0)
1559 william 530 {
1560     UpdateProgress((int)double_percent_done, message);
1561 william 542 Last_Whole_Percent_Done = int_percent_done;
1562 william 530 }
1563 william 544 if (SearchWorkerThread.CancellationPending)
1564     {
1565     provider_st.Stop();
1566     st.Stop();
1567     writer.CancelRequest();
1568     writer.Dispose();
1569     e.Result = true;
1570     break;
1571     }
1572 william 460 }
1573 william 496
1574 william 542 #region old-code
1575     //foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1576     //{
1577     // if (SearchWorkerThread.CancellationPending)
1578     // {
1579     // provider_st.Stop();
1580     // st.Stop();
1581     // writer.CancelRequest();
1582     // writer.Dispose();
1583     // e.Result = true;
1584     // return;
1585     // }
1586     // //int Last_Whole_Percent_Done = 0;
1587     // provider.OpenProvider();
1588     // int bytesRead = 0;
1589     // byte[] data = new byte[STEP_SIZE];
1590     // provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);
1591     // provider.CloseProvider();
1592     // if (SearchWorkerThread.CancellationPending)
1593     // {
1594     // provider_st.Stop();
1595     // st.Stop();
1596     // writer.CancelRequest();
1597     // writer.Dispose();
1598     // e.Result = true;
1599     // return;
1600     // }
1601     // uint address_index = k.Address;
1602     // string message = string.Format(" -> Reading Address 0x{0:x8} from index 0x{1}", k.Address, index.ToString("X"));
1603     // double double_percent_done = 100.0 * (double)((double)index / (double)reader.ResultCount);
1604     // int int_percent_done = (int)double_percent_done;
1605     // //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)
1606     // //{
1607     // // UpdateProgress((int)double_percent_done, message);
1608     // // Last_Whole_Percent_Done = int_percent_done;
1609     // //}
1610     // if ((index % 10000) == 0)
1611     // {
1612     // UpdateProgress((int)double_percent_done, message);
1613     // //Last_Whole_Percent_Done = int_percent_done;
1614     // }
1615     // #region comparison and serialization
1616     // switch (sdt)
1617     // {
1618     // case SearchDataTypes._8bits:
1619     // if (unsigned)
1620     // {
1621     // #region 8bits - unsigned
1622     // var t_data = data;
1623     // foreach (var Value in t_data)
1624     // {
1625     // if (SearchWorkerThread.CancellationPending) { break; }
1626     // using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
1627     // {
1628     // byte value = 0;
1629     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1630     // {
1631     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1632     // {
1633     // try
1634     // {
1635     // gmp.OpenProvider();
1636     // gmp.ReadMemory(address_index, out value);
1637     // gmp.CloseProvider();
1638     // }
1639     // catch (Exception ex)
1640     // {
1641     // logger.VerboseError.WriteLine(ex.ToString());
1642     // }
1643     // }
1644     // comparer.Value = value;
1645     // }
1646     // else
1647     // {
1648     // value = Convert.ToByte(SearchArgs.CompareStartValue);
1649     // comparer.Value = value;
1650     // }
1651     // if (comparer.Compare(Convert.ToByte(Value), value))
1652     // {
1653     // writer.WriteResult<byte>(comparer.Address, comparer.Value);
1654     // }
1655     // }
1656     // address_index += STEP_SIZE;
1657     // }
1658     // #endregion
1659     // }
1660     // else
1661     // {
1662     // #region 8bits - signed
1663     // var t_data = data;
1664     // foreach (var Value in t_data)
1665     // {
1666     // if (SearchWorkerThread.CancellationPending) { break; }
1667     // using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
1668     // {
1669     // sbyte value = 0;
1670     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1671     // {
1672     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1673     // {
1674     // try
1675     // {
1676     // gmp.OpenProvider();
1677     // gmp.ReadMemory(address_index, out value);
1678     // gmp.CloseProvider();
1679     // }
1680     // catch (Exception ex)
1681     // {
1682     // logger.VerboseError.WriteLine(ex.ToString());
1683     // }
1684     // }
1685     // comparer.Value = value;
1686     // }
1687     // else
1688     // {
1689     // value = Convert.ToSByte(SearchArgs.CompareStartValue);
1690     // comparer.Value = value;
1691     // }
1692     // if (comparer.Compare(Convert.ToSByte(Value), value))
1693     // {
1694     // writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1695     // }
1696     // }
1697     // address_index += STEP_SIZE;
1698     // }
1699     // #endregion
1700     // } break;
1701     // case SearchDataTypes._16bits:
1702     // if (unsigned)
1703     // {
1704     // #region 16bits - unsigned
1705     // var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1706     // foreach (var Value in t_data)
1707     // {
1708     // if (SearchWorkerThread.CancellationPending) { break; }
1709     // using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1710     // {
1711     // ushort value = 0;
1712     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1713     // {
1714     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1715     // {
1716     // try
1717     // {
1718     // gmp.OpenProvider();
1719     // gmp.ReadMemory(address_index, out value);
1720     // gmp.CloseProvider();
1721     // }
1722     // catch (Exception ex)
1723     // {
1724     // logger.VerboseError.WriteLine(ex.ToString());
1725     // }
1726     // }
1727     // comparer.Value = value;
1728     // }
1729     // else
1730     // {
1731     // value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1732     // comparer.Value = value;
1733     // }
1734     // if (comparer.Compare(Convert.ToUInt16(Value), value))
1735     // {
1736     // writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1737     // }
1738     // }
1739     // address_index += STEP_SIZE;
1740     // }
1741     // #endregion
1742     // }
1743     // else
1744     // {
1745     // #region 16bits - signed
1746     // var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1747     // foreach (var Value in t_data)
1748     // {
1749     // if (SearchWorkerThread.CancellationPending) { break; }
1750     // using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1751     // {
1752     // short value = 0;
1753     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1754     // {
1755     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1756     // {
1757     // try
1758     // {
1759     // gmp.OpenProvider();
1760     // gmp.ReadMemory(address_index, out value);
1761     // gmp.CloseProvider();
1762     // }
1763     // catch (Exception ex)
1764     // {
1765     // logger.VerboseError.WriteLine(ex.ToString());
1766     // }
1767     // }
1768     // comparer.Value = value;
1769     // }
1770     // else
1771     // {
1772     // value = Convert.ToInt16(SearchArgs.CompareStartValue);
1773     // comparer.Value = value;
1774     // }
1775     // if (comparer.Compare(Convert.ToSByte(Value), value))
1776     // {
1777     // writer.WriteResult<short>(comparer.Address, comparer.Value);
1778     // }
1779     // }
1780     // address_index += STEP_SIZE;
1781     // }
1782     // #endregion
1783     // } break;
1784     // case SearchDataTypes._32bits:
1785     // if (unsigned)
1786     // {
1787     // #region 32bits - unsigned
1788     // var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1789     // foreach (var Value in t_data)
1790     // {
1791     // if (SearchWorkerThread.CancellationPending) { break; }
1792     // using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1793     // {
1794     // uint value = 0;
1795     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1796     // {
1797     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1798     // {
1799     // try
1800     // {
1801     // gmp.OpenProvider();
1802     // gmp.ReadMemory(address_index, out value);
1803     // gmp.CloseProvider();
1804     // }
1805     // catch (Exception ex)
1806     // {
1807     // logger.VerboseError.WriteLine(ex.ToString());
1808     // }
1809     // }
1810     // comparer.Value = value;
1811     // }
1812     // else
1813     // {
1814     // value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1815     // comparer.Value = value;
1816     // }
1817     // if (comparer.Compare(Convert.ToUInt32(Value), value))
1818     // {
1819     // writer.WriteResult<uint>(comparer.Address, comparer.Value);
1820     // }
1821     // }
1822     // address_index += STEP_SIZE;
1823     // }
1824     // #endregion
1825     // }
1826     // else
1827     // {
1828     // #region 32bits - signed
1829     // var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1830     // foreach (var Value in t_data)
1831     // {
1832     // if (SearchWorkerThread.CancellationPending) { break; }
1833     // using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1834     // {
1835     // int value = 0;
1836     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1837     // {
1838     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1839     // {
1840     // try
1841     // {
1842     // gmp.OpenProvider();
1843     // gmp.ReadMemory(address_index, out value);
1844     // gmp.CloseProvider();
1845     // }
1846     // catch (Exception ex)
1847     // {
1848     // logger.VerboseError.WriteLine(ex.ToString());
1849     // }
1850     // }
1851     // comparer.Value = value;
1852     // }
1853     // else
1854     // {
1855     // value = Convert.ToInt32(SearchArgs.CompareStartValue);
1856     // comparer.Value = value;
1857     // }
1858     // if (comparer.Compare(Convert.ToInt32(Value), value))
1859     // {
1860     // writer.WriteResult<int>(comparer.Address, comparer.Value);
1861     // }
1862     // }
1863     // address_index += STEP_SIZE;
1864     // }
1865     // #endregion
1866     // } break;
1867     // case SearchDataTypes._64bits:
1868     // if (unsigned)
1869     // {
1870     // #region 64bits - unsigned
1871     // var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1872     // foreach (var Value in t_data)
1873     // {
1874     // if (SearchWorkerThread.CancellationPending) { break; }
1875     // using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1876     // {
1877     // ulong value = 0;
1878     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1879     // {
1880     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1881     // {
1882     // try
1883     // {
1884     // gmp.OpenProvider();
1885     // gmp.ReadMemory(address_index, out value);
1886     // gmp.CloseProvider();
1887     // }
1888     // catch (Exception ex)
1889     // {
1890     // logger.VerboseError.WriteLine(ex.ToString());
1891     // }
1892     // }
1893     // comparer.Value = value;
1894     // }
1895     // else
1896     // {
1897     // value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1898     // comparer.Value = value;
1899     // }
1900     // if (comparer.Compare(Convert.ToUInt64(Value), value))
1901     // {
1902     // writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1903     // }
1904     // }
1905     // address_index += STEP_SIZE;
1906     // }
1907     // #endregion
1908     // }
1909     // else
1910     // {
1911     // #region 64bits - signed
1912     // var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1913     // foreach (var Value in t_data)
1914     // {
1915     // if (SearchWorkerThread.CancellationPending) { break; }
1916     // using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
1917     // {
1918     // long value = 0;
1919     // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1920     // {
1921     // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1922     // {
1923     // try
1924     // {
1925     // gmp.OpenProvider();
1926     // gmp.ReadMemory(address_index, out value);
1927     // gmp.CloseProvider();
1928     // }
1929     // catch (Exception ex)
1930     // {
1931     // logger.VerboseError.WriteLine(ex.ToString());
1932     // }
1933     // }
1934     // comparer.Value = value;
1935     // }
1936     // else
1937     // {
1938     // value = Convert.ToInt64(SearchArgs.CompareStartValue);
1939     // comparer.Value = value;
1940     // }
1941     // if (comparer.Compare(Convert.ToInt64(Value), value))
1942     // {
1943     // writer.WriteResult<long>(comparer.Address, comparer.Value);
1944     // }
1945     // }
1946     // address_index += STEP_SIZE;
1947     // }
1948     // #endregion
1949     // } break;
1950     // }
1951     // #endregion
1952     // index++;
1953     //}
1954     #endregion
1955 william 496
1956 william 527 //ISerializedResult sr = (reader as ISerializedResult);
1957     //if (sr == null)
1958     //{
1959     // throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
1960     //}
1961     //int sr_index = 0;
1962     //try
1963     //{
1964     // if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
1965     // {
1966     // StructResultType<ulong> result = StructResultType<ulong>.Empty;
1967     // sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
1968     // if (Debugger.IsAttached)
1969     // {
1970     // Debugger.Break();
1971     // }
1972     // }
1973     //}
1974 william 526
1975 william 527 }
1976 william 526
1977 william 459 }
1978 william 527 SearchGuid = new_SearchGuid; // update with out new guid
1979 william 459 }
1980 william 410 }
1981     provider_st.Stop();
1982     logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
1983     //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
1984 william 456 //int Last_Whole_Percent_Done = 0;
1985 william 408
1986    
1987 william 410 #region Subsequent Searches
1988     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1989 william 408
1990    
1991 william 410 // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
1992     bool NeedToCompare = true;
1993     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1994     SearchArgs.CompareType == SearchCompareTypes.Equal &&
1995     SearchArgs.IsFirstSearch)
1996     {
1997     NeedToCompare = false;
1998     //second_tmp_Results = null; // Free Memory
1999     }
2000 william 408
2001 william 410 if (NeedToCompare)
2002 william 535 {
2003 william 410 #region Ranged Searches
2004     #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
2005     if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
2006 william 409 {
2007 william 410 st_ranged_search.Start();
2008     object start, end;
2009 william 408
2010 william 410 start = SearchArgs.CompareStartValue;
2011     end = SearchArgs.CompareEndValue;
2012 william 444 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2013 william 402 {
2014 william 410 for (int i = 0; i < reader.ResultCount; i += 1)
2015 william 409 {
2016 william 410 uint address = 0;
2017 william 483 #region switch (SearchArgs.DataType)
2018 william 410 switch (SearchArgs.DataType)
2019 william 402 {
2020 william 410 case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }
2021     else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;
2022     case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }
2023     else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;
2024     case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }
2025     else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;
2026     case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }
2027     else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;
2028     }
2029     #endregion
2030    
2031     if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
2032     //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
2033     if (SearchArgs.CompareType == SearchCompareTypes.Between)
2034     {
2035     using (InRangeComparer comparer = new InRangeComparer(address, 0))
2036 william 409 {
2037 william 410 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
2038     {
2039     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
2040     {
2041     second_tmp_Results.Add(_tmp_result);
2042     }
2043     }
2044 william 409 }
2045 william 402 }
2046 william 410 else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
2047 william 408 {
2048 william 410 using (NotInRangeComparer comparer = new NotInRangeComparer(address, 0))
2049 william 409 {
2050 william 410 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
2051     {
2052     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
2053     {
2054     second_tmp_Results.Add(_tmp_result);
2055     }
2056     }
2057 william 409 }
2058 william 408 }
2059 william 410 else
2060 william 408 {
2061 william 410 throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
2062 william 408 }
2063 william 410 double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
2064     int int_percent_done = (int)double_percent_done;
2065     if (int_percent_done != Last_Whole_Percent_Done)
2066 william 409 {
2067 william 410 if (int_percent_done <= 100)
2068     {
2069     resultsprogress.Value = int_percent_done;
2070     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
2071     Last_Whole_Percent_Done = int_percent_done;
2072     }
2073 william 409 }
2074 william 408 }
2075     }
2076 william 410 st_ranged_search.Stop();
2077     logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
2078 william 280 }
2079 william 410 #endif
2080     #endregion
2081 william 408 }
2082     #endregion
2083 william 457 //// leave SearchArgs.Results alone, if false
2084     //if (NeedToCompare)
2085     //{
2086     // // fix addresses when memory start is not zero
2087     // 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; } }
2088     // using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count, SearchGuid))
2089     // {
2090     // for (int i = 0; i < second_tmp_Results.Count; i++)
2091     // {
2092     // switch (sdt)
2093     // {
2094     // case SearchDataTypes._8bits:
2095     // if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }
2096     // else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
2097     // case SearchDataTypes._16bits:
2098     // if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }
2099     // else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
2100     // case SearchDataTypes._32bits:
2101     // if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }
2102     // else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;
2103     // case SearchDataTypes._64bits:
2104     // if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }
2105     // else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
2106     // }
2107     // }
2108     // }
2109     // second_tmp_Results = null; // free memory
2110     //}
2111 william 280 }
2112 william 483 catch (OutOfMemoryException ex)
2113     {
2114     e.Result = true;
2115     logger.Error.WriteLine("Encounted {0} for search: {0}", ex.GetType().Name, SearchGuid.ToString());
2116     logger.VerboseError.WriteLine(ex.ToString());
2117     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);
2118     return;
2119     }
2120 william 410 catch (Exception ex)
2121     {
2122 william 419 throw ex;
2123 william 410 }
2124 william 230 }
2125    
2126 william 408
2127    
2128 william 230 private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
2129     {
2130 william 280 //if (SearchArgs.ProgressLogger != null)
2131     //{
2132     // resultsprogress.Value = e.ProgressPercentage;
2133     // //Application.DoEvents();
2134     //}
2135 william 230 }
2136    
2137     private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
2138     {
2139 william 463 try { if ((bool)e.Result) { logger.Warn.WriteLine("Search operation was cancelled.");
2140 william 517 //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
2141     UpdateProgress(0, string.Empty);
2142 william 463 return; }
2143     }
2144 william 446 catch (InvalidCastException) { }
2145     try
2146 william 286 {
2147 william 446 Stopwatch st = (Stopwatch)e.Result;
2148 william 286 st.Stop();
2149 william 392 logger.Profiler.WriteLine("Search took {0} seconds, overall, to complete.", st.Elapsed.TotalSeconds);
2150 william 286 }
2151 william 446 catch (InvalidCastException) { }
2152     catch (Exception ex) { throw ex; }
2153    
2154 william 517 UpdateProgress(100, String.Empty);
2155     //new Action<int, string>(UpdateProgress).Invoke(100, string.Empty);
2156 william 409 bool unsigned = SearchArgs.IsUnsignedDataType;
2157 william 444 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2158 william 402 {
2159     logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", reader.ResultCount));
2160    
2161     if (reader.ResultCount <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
2162 william 280 {
2163 william 402 lstResults.Items.Clear();
2164 william 538 List<ResultItem> items = new List<ResultItem>();
2165     foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
2166     {
2167     switch (SearchArgs.DataType)
2168     {
2169     case SearchDataTypes._8bits:
2170     if (SearchArgs.IsUnsignedDataType) { items.Add(new ResultItem(k.Address, false, Convert.ToByte(k.Value))); }
2171     else { items.Add(new ResultItem(k.Address, false, Convert.ToSByte(k.Value))); }
2172     break;
2173     case SearchDataTypes._16bits:
2174     if (SearchArgs.IsUnsignedDataType) { items.Add(new ResultItem(k.Address, false, Convert.ToUInt16(k.Value))); }
2175     else { items.Add(new ResultItem(k.Address, false, Convert.ToInt16(k.Value))); }
2176     break;
2177     case SearchDataTypes._32bits:
2178     if (SearchArgs.IsUnsignedDataType) { items.Add(new ResultItem(k.Address, false, Convert.ToUInt32(k.Value))); }
2179     else { items.Add(new ResultItem(k.Address, false, Convert.ToInt32(k.Value))); }
2180     break;
2181     case SearchDataTypes._64bits:
2182     if (SearchArgs.IsUnsignedDataType) { items.Add(new ResultItem(k.Address, false, Convert.ToUInt64(k.Value))); }
2183     else { items.Add(new ResultItem(k.Address, false, Convert.ToInt64(k.Value))); }
2184     break;
2185     }
2186     }
2187     lstResults.Items.AddRange(items.ToArray());
2188 william 280 }
2189     }
2190    
2191     this.DoSearchDoneSpecific();
2192     //System.Threading.Thread.Sleep(100);
2193     //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)
2194     this.ThawResultsUpdate();
2195     Application.DoEvents();
2196 william 230 }
2197 william 280 private void DoSearchDoneSpecific()
2198     {
2199     SearchWorkerThread.CancelAsync();
2200     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
2201     else { timer_update_results.Enabled = false; }
2202 william 230
2203 william 280 search_progress_updater.Enabled = false;
2204    
2205     btnCancel.Enabled = false;
2206     btnReset.Enabled = true;
2207     btnSearch.Enabled = true;
2208     grpCompareType.Enabled = true;
2209     grpCompareValue.Enabled = true;
2210 william 517 UpdateProgress(0, string.Empty);
2211     //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
2212 william 280 grpDataType.Enabled = false;
2213     // resume process on reset, incase it was suspended
2214 william 477 ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
2215 william 280 //Application.DoEvents();
2216     this.Refresh();
2217     }
2218    
2219     private void DoCancelSpecific()
2220     {
2221     this.DoSearchDoneSpecific();
2222     }
2223     private void DoResetSpecific()
2224     {
2225     this.DoCancelSpecific();
2226     IsFirstSearch = true;
2227     grpDataType.Enabled = true;
2228 william 447 btnReset.Enabled = false;
2229 william 448
2230     // delete any temporary search result files
2231     SearchResultWriter.CleanupTemporarySearchResultFiles();
2232    
2233 william 280 }
2234 william 230 private void search_progress_updater_Tick(object sender, EventArgs e)
2235     {
2236 william 477 if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)
2237 william 230 {
2238     SearchWorkerThread.CancelAsync();
2239     //JokerSearchWorker.CancelAsync();
2240     ResultsUpdateWorkerThread.CancelAsync();
2241     }
2242     }
2243    
2244 william 280 #region Search Button
2245 william 230 private void btnSearch_Click(object sender, EventArgs e)
2246     {
2247 william 444 if (this.SearchGuid == Guid.Empty)
2248     this.SearchGuid = Guid.NewGuid();
2249 william 485 chkMemoryRangeExpertMode.Enabled = false;
2250 william 271 this.SearchInProgess = true;
2251 william 447 btnCancel.Enabled = true;
2252 william 484 btnReset.Enabled = false; // disable during search
2253 william 447 btnSearch.Enabled = false;
2254 william 280 this.FreezeResultsUpdate();
2255     this.handle_btnSearch_Click();
2256     }
2257     private void handle_btnSearch_Click()
2258     {
2259     //this.FreezeResultsUpdate();
2260     lstResults.Items.Clear();
2261    
2262     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
2263 william 517 else { timer_update_results.Enabled = false; }
2264     UpdateProgress(0, string.Empty);
2265     //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
2266 william 280 bool _is_unsigned = chkUnsigned.Checked;
2267     SearchType search_type = new SearchType();
2268     SearchDataTypes _data_type = new SearchDataTypes();
2269     SearchCompareTypes _compare_type = new SearchCompareTypes();
2270     CompareValueTypes _compare_value_type = new CompareValueTypes();
2271     object start_value = 0;
2272     object end_value = 0;
2273     // get datatype
2274     if (radio_8bits.Checked) { _data_type = SearchDataTypes._8bits; }
2275     else if (radio_16bits.Checked) { _data_type = SearchDataTypes._16bits; }
2276     else if (radio_32bits.Checked) { _data_type = SearchDataTypes._32bits; }
2277     else if (radio_64bits.Checked) { _data_type = SearchDataTypes._64bits; }
2278     else { logger.Error.WriteLine("Could not determine search data type bit size. (was not 8/16/32/or 64bits)"); }
2279     // get compare type
2280     if (radiocompare_equal.Checked) { _compare_type = SearchCompareTypes.Equal; }
2281     else if (radiocompare_greaterthan.Checked) { _compare_type = SearchCompareTypes.GreaterThan; }
2282     else if (radiocompare_lessthan.Checked) { _compare_type = SearchCompareTypes.LessThan; }
2283     else if (radiocompare_greaterthan_orequal.Checked) { _compare_type = SearchCompareTypes.GreaterThanOrEqual; }
2284     else if (radiocompare_lessthan_orequal.Checked) { _compare_type = SearchCompareTypes.LessThanOrEqual; }
2285     else if (radiocompare_notequal.Checked) { _compare_type = SearchCompareTypes.NotEqual; }
2286     else if (radiocompare_between.Checked) { _compare_type = SearchCompareTypes.Between; }
2287     else if (radiocompare_notbetween.Checked) { _compare_type = SearchCompareTypes.NotBetween; }
2288     else { logger.Error.WriteLine("Could not determine search comparison type. (was not == > < >= <= != <> or !<>)"); }
2289     // get compare valure type
2290     if (radio_oldvalue.Checked) { _compare_value_type = CompareValueTypes.OldValue; }
2291     else if (radio_specificvalue.Checked) { _compare_value_type = CompareValueTypes.SpecificValue; }
2292     else { logger.Error.WriteLine("Could not determine search comparison type. (was not old or specific value"); }
2293    
2294     if (_compare_value_type == CompareValueTypes.SpecificValue || (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween))
2295     {
2296    
2297     switch (_data_type)
2298     {
2299     case SearchDataTypes._8bits:
2300     if (_is_unsigned) { start_value = txtStartAddr.ToByte(); }
2301     else { start_value = txtStartAddr.ToSByte(); }
2302     break;
2303     case SearchDataTypes._16bits:
2304     if (_is_unsigned) { start_value = txtStartAddr.ToUInt16(); }
2305     else { start_value = txtStartAddr.ToInt16(); }
2306     break;
2307     case SearchDataTypes._32bits:
2308     if (_is_unsigned) { start_value = txtStartAddr.ToUInt32(); }
2309     else { start_value = txtStartAddr.ToInt32(); }
2310     break;
2311     case SearchDataTypes._64bits:
2312     if (_is_unsigned) { start_value = txtStartAddr.ToUInt64(); }
2313     else { start_value = txtStartAddr.ToInt64(); }
2314     break;
2315     default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
2316     }
2317     }
2318     if (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween)
2319     {
2320     switch (_data_type)
2321     {
2322     case SearchDataTypes._8bits:
2323     if (_is_unsigned) { end_value = txtEndAddr.ToByte(); }
2324     else { end_value = txtEndAddr.ToSByte(); }
2325     break;
2326     case SearchDataTypes._16bits:
2327