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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 397 by william, Wed Jun 20 11:18:56 2012 UTC revision 398 by william, Wed Jun 20 12:16:34 2012 UTC
# Line 432  namespace RomCheater.Docking Line 432  namespace RomCheater.Docking
432                                    
433                  Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);                  Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
434                  //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);                                  //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);                
435                  GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);                  using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
436                  provider.OpenProvider();                  {
437                  int bytesReadSize;                      provider.OpenProvider();
438                  byte[] data;                          int bytesReadSize;
439                  uint bytesToRead = 0;                      byte[] data;
440                  switch (_result.ValueType)                      uint bytesToRead = 0;
441                  {                      switch (_result.ValueType)
442                      case SearchDataTypes._8bits:                      {
443                          bytesToRead = 1;                          case SearchDataTypes._8bits:
444                          break;                              bytesToRead = 1;
445                      case SearchDataTypes._16bits:                              break;
446                          bytesToRead = 2;                          case SearchDataTypes._16bits:
447                          break;                              bytesToRead = 2;
448                      case SearchDataTypes._32bits:                              break;
449                          bytesToRead = 4;                          case SearchDataTypes._32bits:
450                          break;                              bytesToRead = 4;
451                      case SearchDataTypes._64bits:                              break;
452                          bytesToRead = 8;                          case SearchDataTypes._64bits:
453                          break;                              bytesToRead = 8;
454                  }                              break;
455                  provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);                      }
456                  MemoryStream ms = new MemoryStream(data);                      provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
457                  BinaryReader r_ms = new BinaryReader(ms);                      using (MemoryStream ms = new MemoryStream(data))
458                  switch (_result.ValueType)                      {
459                  {                          using (BinaryReader r_ms = new BinaryReader(ms))
460                      case SearchDataTypes._8bits:                          {
461                          if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }                              switch (_result.ValueType)
462                          else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }                              {
463                          break;                                  case SearchDataTypes._8bits:
464                      case SearchDataTypes._16bits:                                      if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
465                          if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }                                      else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
466                          else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }                                      break;
467                          break;                                  case SearchDataTypes._16bits:
468                      case SearchDataTypes._32bits:                                      if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
469                          if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }                                      else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
470                          else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }                                      break;
471                          break;                                  case SearchDataTypes._32bits:
472                      case SearchDataTypes._64bits:                                      if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
473                          if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }                                      else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
474                          else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }                                      break;
475                          break;                                  case SearchDataTypes._64bits:
476                                        if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
477                                        else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
478                                        break;
479                                }
480                                r_ms.Close();
481                            }
482                        }
483                        provider.CloseProvider();
484                  }                  }
485                  r_ms.Close();                  //Application.DoEvents();
                 provider.CloseProvider();  
                 Application.DoEvents();  
486              }              }
487              #endregion              #endregion
488    
# Line 508  namespace RomCheater.Docking Line 514  namespace RomCheater.Docking
514                  int Address = 0;                  int Address = 0;
515                  ResultDataType _result = (ResultDataType)AddedItems[i].Tag;                  ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
516                  Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);                  Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
517                  GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);                  using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
518                  provider.OpenProvider();                  {
519                  int bytesReadSize;                      provider.OpenProvider();
520                  byte[] data;                      int bytesReadSize;
521                  uint bytesToRead = 0;                      byte[] data;
522                  switch (_result.ValueType)                      uint bytesToRead = 0;
523                  {                      switch (_result.ValueType)
524                      case SearchDataTypes._8bits:                      {
525                          bytesToRead = 1;                          case SearchDataTypes._8bits:
526                          break;                              bytesToRead = 1;
527                      case SearchDataTypes._16bits:                              break;
528                          bytesToRead = 2;                          case SearchDataTypes._16bits:
529                          break;                              bytesToRead = 2;
530                      case SearchDataTypes._32bits:                              break;
531                          bytesToRead = 4;                          case SearchDataTypes._32bits:
532                          break;                              bytesToRead = 4;
533                      case SearchDataTypes._64bits:                              break;
534                          bytesToRead = 8;                          case SearchDataTypes._64bits:
535                          break;                              bytesToRead = 8;
536                  }                              break;
537                  provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);                      }
538                  MemoryStream ms = new MemoryStream(data);                      provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
539                  BinaryReader r_ms = new BinaryReader(ms);                      provider.CloseProvider();
540                  switch (_result.ValueType)                      using (MemoryStream ms = new MemoryStream(data))
541                  {                      {
542                      case SearchDataTypes._8bits:                          using (BinaryReader r_ms = new BinaryReader(ms))
543                          if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }                          {
544                          else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }                              switch (_result.ValueType)
545                          break;                              {
546                      case SearchDataTypes._16bits:                                  case SearchDataTypes._8bits:
547                          if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }                                      if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
548                          else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }                                      else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
549                          break;                                      break;
550                      case SearchDataTypes._32bits:                                  case SearchDataTypes._16bits:
551                          if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }                                      if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
552                          else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }                                      else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
553                          break;                                      break;
554                      case SearchDataTypes._64bits:                                  case SearchDataTypes._32bits:
555                          if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }                                      if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
556                          else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }                                      else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
557                          break;                                      break;
558                                    case SearchDataTypes._64bits:
559                                        if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
560                                        else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
561                                        break;
562                                }
563                                r_ms.Close();
564                            }
565                        }
566                  }                  }
567                  r_ms.Close();                  //Application.DoEvents();
                 provider.CloseProvider();  
                 Application.DoEvents();  
568              }              }
569              #endregion              #endregion
570    
# Line 1020  namespace RomCheater.Docking Line 1032  namespace RomCheater.Docking
1032              //SearchArgs.Results.Clear();              //SearchArgs.Results.Clear();
1033              // log options              // log options
1034              SearchArgs.LogSearchOptions();              SearchArgs.LogSearchOptions();
1035              uint STEP_SIZE = (uint)SearchArgs.DataType / 8;                          uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
             GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);  
             provider.OpenProvider();  
             int bytes_read = 0;  
   
1036              byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G              byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1037              provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), out bytes_read, out buffered_mem);                      using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1038              provider.CloseProvider();              {
1039                          provider.OpenProvider();
1040                    int bytes_read = 0;              
1041                    provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), out bytes_read, out buffered_mem);
1042                    provider.CloseProvider();
1043                }
1044              if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }              if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
1045              MemoryStream ms = new MemoryStream(buffered_mem);              using (MemoryStream ms = new MemoryStream(buffered_mem))
1046              BinaryReader r_ms = new BinaryReader(ms);              {
1047              logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", buffered_mem.Length));                  using (BinaryReader r_ms = new BinaryReader(ms))
             int Last_Whole_Percent_Done = 0;  
   
             #region First Search  
             if (SearchArgs.IsFirstSearch)  
             {  
                 st_first_search.Start();  
                 SearchArgs.Results.Clear();  
                 r_ms.BaseStream.Seek(0, SeekOrigin.Begin);  
                 List<ResultType<object>> results_list = new List<ResultType<object>>();  
                 for (uint i = 0; i < buffered_mem.Length; i += STEP_SIZE)  
1048                  {                  {
1049                      ResultType<object> _tmp_result = new ResultType<object>();                      logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", buffered_mem.Length));
1050                      switch (SearchArgs.DataType)                      int Last_Whole_Percent_Done = 0;
1051    
1052                        #region First Search
1053                        if (SearchArgs.IsFirstSearch)
1054                      {                      {
1055                          case SearchDataTypes._8bits:                          st_first_search.Start();
1056                              if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>(i, r_ms.ReadByte()); }                          SearchArgs.Results.Clear();
1057                              else { _tmp_result = new ResultType<object>(i, r_ms.ReadSByte()); } break;                          r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1058                          case SearchDataTypes._16bits:                          //List<ResultType<object>> results_list = new List<ResultType<object>>();
1059                              if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>(i, r_ms.ReadUInt16()); }                          //for (uint i = 0; i < buffered_mem.Length; i += STEP_SIZE)
1060                              else { _tmp_result = new ResultType<object>(i,r_ms.ReadInt16()); } break;                          //{
1061                          case SearchDataTypes._32bits:                          while (r_ms.BaseStream.Position < r_ms.BaseStream.Length)
1062                              if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>(i, r_ms.ReadUInt32()); }                          {
1063                              else { _tmp_result = new ResultType<object>(i, r_ms.ReadInt32()); } break;                              using (ResultType<object> _tmp_result = new ResultType<object>())
1064                          case SearchDataTypes._64bits:                              {
1065                              if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>(i, r_ms.ReadUInt64()); }                                  switch (SearchArgs.DataType)
1066                              else { _tmp_result = new ResultType<object>(i, r_ms.ReadInt64()); } break;                                  {
1067                      }                                      case SearchDataTypes._8bits:
1068                      results_list.Add(_tmp_result);                                          if (SearchArgs.IsUnsignedDataType) { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadByte(); }
1069                      double double_percent_done = 100.0 * (double)((double)i / (double)buffered_mem.Length);                                          else { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadSByte(); } break;
1070                      int int_percent_done = (int)double_percent_done;                                      case SearchDataTypes._16bits:
1071                      if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)                                          if (SearchArgs.IsUnsignedDataType) { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadUInt16(); }
1072                      {                                          else { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadInt16(); } break;
1073                          resultsprogress.Value = int_percent_done;                                      case SearchDataTypes._32bits:
1074                          resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);                                          if (SearchArgs.IsUnsignedDataType) { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadUInt32(); }
1075                          Last_Whole_Percent_Done = int_percent_done;                                          else { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadInt32(); } break;
1076                                        case SearchDataTypes._64bits:
1077                                            if (SearchArgs.IsUnsignedDataType) { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadUInt64(); }
1078                                            else { _tmp_result.Address = (uint)r_ms.BaseStream.Position; _tmp_result.Value = r_ms.ReadInt64(); } break;
1079                                    }
1080                                    //results_list.Add(_tmp_result);
1081                                    SearchArgs.Results.Add(_tmp_result);
1082                                }
1083                                double double_percent_done = 100.0 * (double)((double)r_ms.BaseStream.Position / (double)buffered_mem.Length);
1084                                int int_percent_done = (int)double_percent_done;
1085                                if (int_percent_done != Last_Whole_Percent_Done && r_ms.BaseStream.Position % ElementsBeforeDisplay == 0)
1086                                {
1087                                    resultsprogress.Value = int_percent_done;
1088                                    resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", r_ms.BaseStream.Position);
1089                                    Last_Whole_Percent_Done = int_percent_done;
1090                                    //Application.DoEvents();
1091                                }
1092    
1093                                if (SearchWorkerThread.CancellationPending == true)
1094                                {
1095                                    e.Cancel = true;
1096                                    return;
1097                                }
1098                                //Application.DoEvents();
1099                            }
1100                            //}
1101                            //SearchArgs.Results.AddRange(results_list);
1102                            //results_list = null;
1103                            resultsprogress.Value = 100;
1104                            resultsprogress.Message = "";
1105                          //Application.DoEvents();                          //Application.DoEvents();
1106                            st_first_search.Stop();
1107                            logger.Profiler.WriteLine("First search took a total of {0} seconds to complete.", st_first_search.Elapsed.TotalSeconds);
1108                      }                      }
1109                        #endregion
1110    
1111                      if (SearchWorkerThread.CancellationPending == true)                      #region Subsequent Searches
1112                      {                      r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
                         e.Cancel = true;  
                         return;  
                     }  
                     //Application.DoEvents();  
                 }  
                 SearchArgs.Results.AddRange(results_list);  
                 resultsprogress.Value = 100;  
                 resultsprogress.Message = "";  
                 //Application.DoEvents();  
                 st_first_search.Stop();  
                 logger.Profiler.WriteLine("First search took a total of {0} seconds to complete.", st_first_search.Elapsed.TotalSeconds);  
             }  
             #endregion  
1113    
             #region Subsequent Searches  
             r_ms.BaseStream.Seek(0, SeekOrigin.Begin);  
1114    
1115                        // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
1116                        bool NeedToCompare = true;
1117                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1118                            SearchArgs.CompareType == SearchCompareTypes.Equal &&
1119                            SearchArgs.IsFirstSearch)
1120                        {
1121                            NeedToCompare = false;
1122                            second_tmp_Results = null; // Free Memory
1123                        }
1124    
1125              // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)                      if (NeedToCompare)
1126              bool NeedToCompare = true;                      {
1127              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&                          if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
                 SearchArgs.CompareType == SearchCompareTypes.Equal &&  
                 SearchArgs.IsFirstSearch)  
             {  
                 NeedToCompare = false;  
                 second_tmp_Results = null; // Free Memory  
             }  
   
             if (NeedToCompare)  
             {  
                 if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)  
                 {  
                     #region Non-Range Searches  
                     st_nonrange_search.Start();  
                     //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);  
                     ////second_tmp_Results.c  
                     for (int i = 0; i < SearchArgs.Results.Count; i += 1)  
                     {                          
                         uint address = SearchArgs.Results[i].Address;  
                         if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                         r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                         switch (SearchArgs.DataType)  
1128                          {                          {
1129                              #region Comparer Support                              #region Non-Range Searches
1130                              #region case SearchDataTypes._8bits:                              st_nonrange_search.Start();
1131                              case SearchDataTypes._8bits:                              //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1132                                  if (SearchArgs.IsUnsignedDataType)                              ////second_tmp_Results.c
1133                                for (int i = 0; i < SearchArgs.Results.Count; i += 1)
1134                                {
1135                                    uint address = SearchArgs.Results[i].Address;
1136                                    if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1137                                    r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1138                                    switch (SearchArgs.DataType)
1139                                  {                                  {
1140                                      byte lookup_value = r_ms.ReadByte();                                      #region Comparer Support
1141                                      _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);                                      #region case SearchDataTypes._8bits:
1142                                      byte value = 0;                                      case SearchDataTypes._8bits:
1143                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                          if (SearchArgs.IsUnsignedDataType)
1144                                      {                                          {
1145                                          value = Convert.ToByte(SearchArgs.Results[i].Value);                                              byte lookup_value = r_ms.ReadByte();
1146                                          comparer.Value = value;                                              _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);
1147                                      }                                              byte value = 0;
1148                                      else                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1149                                      {                                              {
1150                                          value = Convert.ToByte(SearchArgs.CompareStartValue);                                                  value = Convert.ToByte(SearchArgs.Results[i].Value);
1151                                          comparer.Value = value;                                                  comparer.Value = value;
1152                                      }                                              }
1153                                      if (comparer.Compare(lookup_value, value))                                              else
1154                                      {                                              {
1155                                          //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                      value = Convert.ToByte(SearchArgs.CompareStartValue);
1156                                          //second_tmp_Results.Add(_tmp_result);                                                  comparer.Value = value;
1157                                          //_tmp_result = null; // free memory                                              }
1158                                          //SearchArgs.Results.RemoveAt(i);                                              if (comparer.Compare(lookup_value, value))
1159                                          SearchArgs.Results[i].Value = comparer.Value;                                              {
1160                                          second_tmp_Results.Add(SearchArgs.Results[i]);                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1161                                      }                                                  //second_tmp_Results.Add(_tmp_result);
1162                                      comparer = null; // free memory                                                  //_tmp_result = null; // free memory
1163                                                    //SearchArgs.Results.RemoveAt(i);
1164                                                    SearchArgs.Results[i].Value = comparer.Value;
1165                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1166                                                }
1167                                                comparer = null; // free memory
1168                                            }
1169                                            else
1170                                            {
1171                                                sbyte lookup_value = r_ms.ReadSByte();
1172                                                _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);
1173                                                sbyte value = 0;
1174                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1175                                                {
1176                                                    value = Convert.ToSByte(SearchArgs.Results[i].Value);
1177                                                }
1178                                                else
1179                                                {
1180                                                    value = Convert.ToSByte(SearchArgs.CompareStartValue);
1181                                                }
1182                                                if (comparer.Compare(lookup_value, value))
1183                                                {
1184                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1185                                                    //second_tmp_Results.Add(_tmp_result);
1186                                                    //_tmp_result = null; // free memory
1187                                                    //SearchArgs.Results.RemoveAt(i);
1188                                                    SearchArgs.Results[i].Value = comparer.Value;
1189                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1190                                                }
1191                                                comparer = null; // free memory
1192                                            }
1193                                            break;
1194                                        #endregion
1195                                        #region case SearchDataTypes._16bits:
1196                                        case SearchDataTypes._16bits:
1197                                            if (SearchArgs.IsUnsignedDataType)
1198                                            {
1199                                                ushort lookup_value = r_ms.ReadUInt16();
1200                                                _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);
1201                                                ushort value = 0;
1202                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1203                                                {
1204                                                    value = Convert.ToUInt16(SearchArgs.Results[i].Value);
1205                                                    comparer.Value = value;
1206                                                }
1207                                                else
1208                                                {
1209                                                    value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1210                                                    comparer.Value = value;
1211                                                }
1212                                                if (comparer.Compare(lookup_value, value))
1213                                                {
1214                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1215                                                    //second_tmp_Results.Add(_tmp_result);
1216                                                    //_tmp_result = null; // free memory
1217                                                    //SearchArgs.Results.RemoveAt(i);
1218                                                    SearchArgs.Results[i].Value = comparer.Value;
1219                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1220                                                }
1221                                                comparer = null; // free memory
1222                                            }
1223                                            else
1224                                            {
1225                                                short lookup_value = r_ms.ReadInt16();
1226                                                _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);
1227                                                short value = 0;
1228                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1229                                                {
1230                                                    value = Convert.ToInt16(SearchArgs.Results[i].Value);
1231                                                }
1232                                                else
1233                                                {
1234                                                    value = Convert.ToInt16(SearchArgs.CompareStartValue);
1235                                                }
1236                                                if (comparer.Compare(lookup_value, value))
1237                                                {
1238                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1239                                                    //second_tmp_Results.Add(_tmp_result);
1240                                                    //_tmp_result = null; // free memory
1241                                                    //SearchArgs.Results.RemoveAt(i);
1242                                                    SearchArgs.Results[i].Value = comparer.Value;
1243                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1244                                                }
1245                                                comparer = null; // free memory
1246                                            }
1247                                            break;
1248                                        #endregion
1249                                        #region case SearchDataTypes._32bits:
1250                                        case SearchDataTypes._32bits:
1251                                            if (SearchArgs.IsUnsignedDataType)
1252                                            {
1253                                                uint lookup_value = r_ms.ReadUInt32();
1254                                                _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);
1255                                                uint value = 0;
1256                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1257                                                {
1258                                                    value = Convert.ToUInt32(SearchArgs.Results[i].Value);
1259                                                    comparer.Value = value;
1260                                                }
1261                                                else
1262                                                {
1263                                                    value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1264                                                    comparer.Value = value;
1265                                                }
1266                                                if (comparer.Compare(lookup_value, value))
1267                                                {
1268                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1269                                                    //second_tmp_Results.Add(_tmp_result);
1270                                                    //_tmp_result = null; // free memory
1271                                                    //SearchArgs.Results.RemoveAt(i);
1272                                                    SearchArgs.Results[i].Value = comparer.Value;
1273                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1274                                                }
1275                                                comparer = null; // free memory
1276                                            }
1277                                            else
1278                                            {
1279                                                int lookup_value = r_ms.ReadInt32();
1280                                                _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);
1281                                                int value = 0;
1282                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1283                                                {
1284                                                    value = Convert.ToInt32(SearchArgs.Results[i].Value);
1285                                                }
1286                                                else
1287                                                {
1288                                                    value = Convert.ToInt32(SearchArgs.CompareStartValue);
1289                                                }
1290                                                if (comparer.Compare(lookup_value, value))
1291                                                {
1292                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1293                                                    //second_tmp_Results.Add(_tmp_result);
1294                                                    //_tmp_result = null; // free memory
1295                                                    //SearchArgs.Results.RemoveAt(i);
1296                                                    SearchArgs.Results[i].Value = comparer.Value;
1297                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1298                                                }
1299                                                comparer = null; // free memory
1300                                            }
1301                                            break;
1302                                        #endregion
1303                                        #region case SearchDataTypes._64bits:
1304                                        case SearchDataTypes._64bits:
1305                                            if (SearchArgs.IsUnsignedDataType)
1306                                            {
1307                                                ulong lookup_value = r_ms.ReadUInt64();
1308                                                _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);
1309                                                ulong value = 0;
1310                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1311                                                {
1312                                                    value = Convert.ToUInt64(SearchArgs.Results[i].Value);
1313                                                    comparer.Value = value;
1314                                                }
1315                                                else
1316                                                {
1317                                                    value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1318                                                    comparer.Value = value;
1319                                                }
1320                                                if (comparer.Compare(lookup_value, value))
1321                                                {
1322                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1323                                                    //second_tmp_Results.Add(_tmp_result);
1324                                                    //_tmp_result = null; // free memory
1325                                                    //SearchArgs.Results.RemoveAt(i);
1326                                                    SearchArgs.Results[i].Value = comparer.Value;
1327                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1328                                                }
1329                                                comparer = null; // free memory
1330                                            }
1331                                            else
1332                                            {
1333                                                long lookup_value = r_ms.ReadInt64();
1334                                                _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);
1335                                                long value = 0;
1336                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1337                                                {
1338                                                    value = Convert.ToInt64(SearchArgs.Results[i].Value);
1339                                                }
1340                                                else
1341                                                {
1342                                                    value = Convert.ToInt64(SearchArgs.CompareStartValue);
1343                                                }
1344                                                if (comparer.Compare(lookup_value, value))
1345                                                {
1346                                                    //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1347                                                    //second_tmp_Results.Add(_tmp_result);
1348                                                    //_tmp_result = null; // free memory
1349                                                    //SearchArgs.Results.RemoveAt(i);
1350                                                    SearchArgs.Results[i].Value = comparer.Value;
1351                                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1352                                                }
1353                                                comparer = null; // free memory
1354                                            }
1355                                            break;
1356                                        #endregion
1357                                        #endregion
1358                                  }                                  }
1359                                  else  
1360                                    double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);
1361                                    int int_percent_done = (int)double_percent_done;
1362                                    if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)
1363                                  {                                  {
1364                                      sbyte lookup_value = r_ms.ReadSByte();                                      resultsprogress.Value = int_percent_done;
1365                                      _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);                                      resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);
1366                                      sbyte value = 0;                                      Last_Whole_Percent_Done = int_percent_done;
1367                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                      //Application.DoEvents();
                                     {  
                                         value = Convert.ToSByte(SearchArgs.Results[i].Value);  
                                     }  
                                     else  
                                     {  
                                         value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
                                         SearchArgs.Results[i].Value = comparer.Value;  
                                         second_tmp_Results.Add(SearchArgs.Results[i]);  
                                     }  
                                     comparer = null; // free memory  
1368                                  }                                  }
1369                                  break;  
1370                                }
1371                                st_nonrange_search.Stop();
1372                                logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
1373                              #endregion                              #endregion
1374                              #region case SearchDataTypes._16bits:                          }
1375                              case SearchDataTypes._16bits:                          #region Ranged Searches
1376                                  if (SearchArgs.IsUnsignedDataType)  #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
1377                                  {                          if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1378                                      ushort lookup_value = r_ms.ReadUInt16();                          {
1379                                      _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);                              st_ranged_search.Start();
1380                                      ushort value = 0;                              object start, end;
1381                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1382                                      {                              start = SearchArgs.CompareStartValue;
1383                                          value = Convert.ToUInt16(SearchArgs.Results[i].Value);                              end = SearchArgs.CompareEndValue;
1384                                          comparer.Value = value;                              for (int i = 0; i < SearchArgs.Results.Count; i += 1)
1385                                      }                              {
1386                                      else                                  uint address = SearchArgs.Results[i].Address;
1387                                      {                                  if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1388                                          value = Convert.ToUInt16(SearchArgs.CompareStartValue);                                  r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1389                                          comparer.Value = value;                                  if (SearchArgs.CompareType == SearchCompareTypes.Between)
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
                                         SearchArgs.Results[i].Value = comparer.Value;  
                                         second_tmp_Results.Add(SearchArgs.Results[i]);  
                                     }  
                                     comparer = null; // free memory  
                                 }  
                                 else  
1390                                  {                                  {
1391                                      short lookup_value = r_ms.ReadInt16();                                      InRangeComparer comparer = new InRangeComparer(address, 0);
1392                                      _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);                                      if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
                                     short value = 0;  
                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                     {  
                                         value = Convert.ToInt16(SearchArgs.Results[i].Value);  
                                     }  
                                     else  
1393                                      {                                      {
                                         value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
1394                                          SearchArgs.Results[i].Value = comparer.Value;                                          SearchArgs.Results[i].Value = comparer.Value;
1395                                          second_tmp_Results.Add(SearchArgs.Results[i]);                                          second_tmp_Results.Add(SearchArgs.Results[i]);
1396                                      }                                      }
1397                                      comparer = null; // free memory                                      comparer = null;
1398                                  }                                  }
1399                                  break;                                  else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
                             #endregion  
                             #region case SearchDataTypes._32bits:  
                             case SearchDataTypes._32bits:  
                                 if (SearchArgs.IsUnsignedDataType)  
1400                                  {                                  {
1401                                      uint lookup_value = r_ms.ReadUInt32();                                      NotInRangeComparer comparer = new NotInRangeComparer(address, 0);
1402                                      _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);                                      if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
                                     uint value = 0;  
                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                     {  
                                         value = Convert.ToUInt32(SearchArgs.Results[i].Value);  
                                         comparer.Value = value;  
                                     }  
                                     else  
                                     {  
                                         value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                         comparer.Value = value;  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
1403                                      {                                      {
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
1404                                          SearchArgs.Results[i].Value = comparer.Value;                                          SearchArgs.Results[i].Value = comparer.Value;
1405                                          second_tmp_Results.Add(SearchArgs.Results[i]);                                          second_tmp_Results.Add(SearchArgs.Results[i]);
1406                                      }                                      }
1407                                      comparer = null; // free memory                                      comparer = null;
1408                                  }                                  }
1409                                  else                                  else
1410                                  {                                  {
1411                                      int lookup_value = r_ms.ReadInt32();                                      throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
                                     _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);  
                                     int value = 0;  
                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                     {  
                                         value = Convert.ToInt32(SearchArgs.Results[i].Value);  
                                     }  
                                     else  
                                     {  
                                         value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
                                         SearchArgs.Results[i].Value = comparer.Value;  
                                         second_tmp_Results.Add(SearchArgs.Results[i]);  
                                     }  
                                     comparer = null; // free memory  
1412                                  }                                  }
1413                                  break;                                  double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);
1414                              #endregion                                  int int_percent_done = (int)double_percent_done;
1415                              #region case SearchDataTypes._64bits:                                  if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)
                             case SearchDataTypes._64bits:  
                                 if (SearchArgs.IsUnsignedDataType)  
1416                                  {                                  {
1417                                      ulong lookup_value = r_ms.ReadUInt64();                                      resultsprogress.Value = int_percent_done;
1418                                      _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);                                      resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);
1419                                      ulong value = 0;                                      Last_Whole_Percent_Done = int_percent_done;
1420                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                      //Application.DoEvents();
                                     {  
                                         value = Convert.ToUInt64(SearchArgs.Results[i].Value);  
                                         comparer.Value = value;  
                                     }  
                                     else  
                                     {  
                                         value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                         comparer.Value = value;  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
                                         SearchArgs.Results[i].Value = comparer.Value;  
                                         second_tmp_Results.Add(SearchArgs.Results[i]);  
                                     }  
                                     comparer = null; // free memory  
                                 }  
                                 else  
                                 {  
                                     long lookup_value = r_ms.ReadInt64();  
                                     _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);  
                                     long value = 0;  
                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                     {  
                                         value = Convert.ToInt64(SearchArgs.Results[i].Value);  
                                     }  
                                     else  
                                     {  
                                         value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                     }  
                                     if (comparer.Compare(lookup_value, value))  
                                     {  
                                         //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                         //second_tmp_Results.Add(_tmp_result);  
                                         //_tmp_result = null; // free memory  
                                         //SearchArgs.Results.RemoveAt(i);  
                                         SearchArgs.Results[i].Value = comparer.Value;  
                                         second_tmp_Results.Add(SearchArgs.Results[i]);  
                                     }  
                                     comparer = null; // free memory  
1421                                  }                                  }
1422                                  break;                              }
1423                              #endregion                              st_ranged_search.Stop();
1424                              #endregion                              logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
                         }  
   
                         double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);  
                         int int_percent_done = (int)double_percent_done;  
                         if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)  
                         {  
                             resultsprogress.Value = int_percent_done;  
                             resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);  
                             Last_Whole_Percent_Done = int_percent_done;  
                             //Application.DoEvents();  
1425                          }                          }
1426    #endif
1427                            #endregion
1428    
1429                      }                      }
                     st_nonrange_search.Stop();  
                     logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);  
1430                      #endregion                      #endregion
1431                  }                      // leave SearchArgs.Results alone, if false
1432                  #region Ranged Searches                      if (NeedToCompare)
1433  #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT                      {
1434                  if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)                          SearchArgs.Results = second_tmp_Results.GetRange(0, second_tmp_Results.Count);
1435                  {                          // fix addresses when memory start is not zero
1436                      st_ranged_search.Start();                          if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch) { for (int i = 0; i < SearchArgs.Results.Count; i++) { SearchArgs.Results[i].Address = SearchArgs.Results[i].Address + MemoryRangeStart; } }
1437                      object start, end;                          second_tmp_Results = null; // free memory
   
                     start = SearchArgs.CompareStartValue;  
                     end = SearchArgs.CompareEndValue;  
                     for (int i = 0; i < SearchArgs.Results.Count; i += 1)  
                     {  
                         uint address = SearchArgs.Results[i].Address;  
                         if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                         r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                         if (SearchArgs.CompareType == SearchCompareTypes.Between)  
                         {  
                             InRangeComparer comparer = new InRangeComparer(address, 0);  
                             if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))  
                             {  
                                 SearchArgs.Results[i].Value = comparer.Value;  
                                 second_tmp_Results.Add(SearchArgs.Results[i]);  
                             }  
                             comparer = null;  
                         }  
                         else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)  
                         {  
                             NotInRangeComparer comparer = new NotInRangeComparer(address, 0);  
                             if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))  
                             {  
                                 SearchArgs.Results[i].Value = comparer.Value;  
                                 second_tmp_Results.Add(SearchArgs.Results[i]);  
                             }  
                             comparer = null;  
                         }  
                         else  
                         {  
                             throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);  
                         }  
                         double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);  
                         int int_percent_done = (int)double_percent_done;  
                         if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)  
                         {  
                             resultsprogress.Value = int_percent_done;  
                             resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);  
                             Last_Whole_Percent_Done = int_percent_done;  
                             //Application.DoEvents();  
                         }  
1438                      }                      }
                     st_ranged_search.Stop();  
                     logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);  
                 }  
 #endif  
                 #endregion  
1439    
1440                        r_ms.Close();
1441                    }
1442              }              }
             #endregion  
             // leave SearchArgs.Results alone, if false  
             if (NeedToCompare)  
             {  
                 SearchArgs.Results = second_tmp_Results.GetRange(0, second_tmp_Results.Count);  
                 // fix addresses when memory start is not zero  
                 if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch) { for (int i = 0; i < SearchArgs.Results.Count; i++) { SearchArgs.Results[i].Address = SearchArgs.Results[i].Address + MemoryRangeStart; } }  
                 second_tmp_Results = null; // free memory  
             }  
   
             r_ms.Close();  
1443          }          }
1444    
1445          private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)          private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)

Legend:
Removed from v.397  
changed lines
  Added in v.398

  ViewVC Help
Powered by ViewVC 1.1.22