/[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 409 by william, Thu Jun 21 20:02:40 2012 UTC revision 410 by william, Thu Jun 21 20:45:35 2012 UTC
# Line 1079  namespace RomCheater.Docking Line 1079  namespace RomCheater.Docking
1079          }          }
1080          private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)          private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1081          {          {
1082              Stopwatch st = new Stopwatch();              try
             st.Start();  
   
             Stopwatch st_first_search = new Stopwatch();  
             Stopwatch st_nonrange_search = new Stopwatch();  
             Stopwatch st_ranged_search = new Stopwatch();  
   
             e.Result = st;  
             //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();  
             List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();  
             //const int ElementsBeforeDisplay = 100;  
             SearchArgs.LogSearchOptions();  
             uint STEP_SIZE = (uint)SearchArgs.DataType / 8;  
   
             bool unsigned = SearchArgs.IsUnsignedDataType;  
             SearchDataTypes sdt = SearchArgs.DataType;  
             //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G  
             logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));  
             resultsprogress.Value = 0;  
             resultsprogress.Message = string.Format("Search is Warming Up...Please Wait...");  
   
             Stopwatch provider_st = new Stopwatch();  
             provider_st.Start();  
             using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
             {  
                 provider.OpenProvider();  
                 int count = (int)(MemoryRangeSize - MemoryRangeStart) / (int)STEP_SIZE;  
                 SearchResultWriter writer = new SearchResultWriter(count);  
                 provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);  
                 provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);  
                 provider.CloseProvider();  
                 writer.Dispose();  
             }  
             provider_st.Stop();  
             logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);  
             //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }              
             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);  
             //    int count = (int)buffered_mem.Length / (int)STEP_SIZE;  
             //    #region using (SearchResultWriter writer = new SearchResultWriter(count))  
             //    using (SearchResultWriter writer = new SearchResultWriter(count))  
             //    {  
             //        //List<ResultType<object>> results_list = new List<ResultType<object>>();  
             //        //for (uint i = 0; i < buffered_mem.Length; i += STEP_SIZE)  
             //        //{  
             //        #region while (r_ms.BaseStream.Position < r_ms.BaseStream.Length)  
             //        while (r_ms.BaseStream.Position < r_ms.BaseStream.Length)  
             //        {  
             //            //using (ResultType<object> _tmp_result = new ResultType<object>())  
             //            //{  
             //            try  
             //            {  
             //                switch (sdt)  
             //                {  
             //                    case SearchDataTypes._8bits:  
             //                        if (unsigned) { writer.WriteResult<Byte>((uint)r_ms.BaseStream.Position, r_ms.ReadByte()); }  
             //                        else { writer.WriteResult<SByte>((uint)r_ms.BaseStream.Position, r_ms.ReadSByte()); } break;  
             //                    case SearchDataTypes._16bits:  
             //                        if (unsigned) { writer.WriteResult<UInt16>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt16()); }  
             //                        else { writer.WriteResult<Int16>((uint)r_ms.BaseStream.Position, r_ms.ReadInt16()); } break;  
             //                    case SearchDataTypes._32bits:  
             //                        if (unsigned) { writer.WriteResult<UInt32>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt32()); }  
             //                        else { writer.WriteResult<Int32>((uint)r_ms.BaseStream.Position, r_ms.ReadInt32()); } break;  
             //                    case SearchDataTypes._64bits:  
             //                        if (unsigned) { writer.WriteResult<UInt64>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt64()); }  
             //                        else { writer.WriteResult<Int64>((uint)r_ms.BaseStream.Position, r_ms.ReadInt64()); } break;  
             //                }  
             //            }  
             //            catch (EndOfStreamException)  
             //            {  
             //                //logger.VerboseError.WriteLine(ex.ToString());  
             //                break;  
             //            }  
             //            //results_list.Add(_tmp_result);  
             //            //SearchArgs.Results.Add(_tmp_result);  
             //            double double_percent_done = 100.0 * (double)((double)r_ms.BaseStream.Position / (double)r_ms.BaseStream.Length);  
             //            int int_percent_done = (int)double_percent_done;  
             //            if (int_percent_done != Last_Whole_Percent_Done)  
             //            {  
             //                if (int_percent_done <= 100)  
             //                {  
             //                    resultsprogress.Value = int_percent_done;  
             //                    resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", (r_ms.BaseStream.Position + MemoryRangeStart));  
             //                    Last_Whole_Percent_Done = int_percent_done;  
             //                }  
             //            }  
             //        }  
             //        if (SearchWorkerThread.CancellationPending == true)  
             //        {  
             //            e.Cancel = true;  
             //            return;  
             //        }  
             //        #endregion  
             //    }  
             //    #endregion  
             //    //}  
             //    //SearchArgs.Results.AddRange(results_list);  
             //    //results_list = null;  
             //    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);  
             //    Last_Whole_Percent_Done = 0;  
             //}  
             #endregion  
   
             #region Subsequent Searches  
             //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);  
   
   
             // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)  
             bool NeedToCompare = true;  
             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&  
                 SearchArgs.CompareType == SearchCompareTypes.Equal &&  
                 SearchArgs.IsFirstSearch)  
1083              {              {
1084                  NeedToCompare = false;                  Stopwatch st = new Stopwatch();
1085                  //second_tmp_Results = null; // Free Memory                  st.Start();
             }  
1086    
1087              if (NeedToCompare)                  Stopwatch st_first_search = new Stopwatch();
1088              {                  Stopwatch st_nonrange_search = new Stopwatch();
1089                  if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)                  Stopwatch st_ranged_search = new Stopwatch();
1090    
1091                    e.Result = st;
1092                    //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1093                    List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
1094                    //const int ElementsBeforeDisplay = 100;
1095                    SearchArgs.LogSearchOptions();
1096                    uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1097    
1098                    bool unsigned = SearchArgs.IsUnsignedDataType;
1099                    SearchDataTypes sdt = SearchArgs.DataType;
1100                    //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1101                    logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));
1102                    resultsprogress.Value = 0;
1103                    resultsprogress.Message = string.Format("Search is Warming Up...Please Wait...");
1104    
1105                    Stopwatch provider_st = new Stopwatch();
1106                    provider_st.Start();
1107                    using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1108                  {                  {
1109                      #region Non-Range Searches                      provider.OpenProvider();
1110                      st_nonrange_search.Start();                      int count = (int)(MemoryRangeSize - MemoryRangeStart) / (int)STEP_SIZE;
1111                      //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);                      SearchResultWriter writer = new SearchResultWriter(count);
1112                      ////second_tmp_Results.c                      provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1113                      try                      provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1114                        provider.CloseProvider();
1115                        writer.Dispose();
1116                    }
1117                    provider_st.Stop();
1118                    logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
1119                    //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }            
1120                    int Last_Whole_Percent_Done = 0;
1121    
1122    
1123                    #region Subsequent Searches
1124                    //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1125    
1126    
1127                    // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
1128                    bool NeedToCompare = true;
1129                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1130                        SearchArgs.CompareType == SearchCompareTypes.Equal &&
1131                        SearchArgs.IsFirstSearch)
1132                    {
1133                        NeedToCompare = false;
1134                        //second_tmp_Results = null; // Free Memory
1135                    }
1136    
1137                    if (NeedToCompare)
1138                    {
1139                        if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
1140                      {                      {
1141                          using (SearchResultReader reader = new SearchResultReader())                          #region Non-Range Searches
1142                            st_nonrange_search.Start();
1143                            //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1144                            ////second_tmp_Results.c
1145                            try
1146                          {                          {
1147                              for (int i = 0; i < reader.ResultCount; i += 1)                              using (SearchResultReader reader = new SearchResultReader())
1148                              {                              {
                                 object result_value = 0;  
                                 uint address = 0;  
                                 #region switch (SearchArgs.DataType)  
                                 switch (SearchArgs.DataType)  
                                 {  
                                     case SearchDataTypes._8bits: if (unsigned)  
                                         {  
                                             using (ResultType<byte> result = reader.GetNextResult<byte>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         }  
                                         else  
                                         {  
                                             using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         } break;  
                                     case SearchDataTypes._16bits: if (unsigned)  
                                         {  
                                             using (ResultType<ushort> result = reader.GetNextResult<ushort>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         }  
                                         else  
                                         {  
                                             using (ResultType<short> result = reader.GetNextResult<short>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         } break;  
                                     case SearchDataTypes._32bits: if (unsigned)  
                                         {  
                                             using (ResultType<uint> result = reader.GetNextResult<uint>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         }  
                                         else  
                                         {  
                                             using (ResultType<int> result = reader.GetNextResult<int>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         } break;  
                                     case SearchDataTypes._64bits: if (unsigned)  
                                         {  
                                             using (ResultType<ulong> result = reader.GetNextResult<ulong>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         }  
                                         else  
                                         {  
                                             using (ResultType<long> result = reader.GetNextResult<long>())  
                                             {  
                                                 address = result.Address;  
                                                 result_value = result.Value;  
                                             }  
                                         } break;  
                                 }  
                                 #endregion  
                                 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
1149                                  try                                  try
1150                                  {                                  {
1151                                      //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);                                      for (int i = 0; i < reader.ResultCount; i += 1)
1152                                  }                                      {
1153                                  catch (Exception)                                          object result_value = 0;
1154                                  {                                          uint address = 0;
1155                                      throw;                                          #region switch (SearchArgs.DataType)
1156                                  }                                          switch (SearchArgs.DataType)
                                 switch (SearchArgs.DataType)  
                                 {  
                                     #region Comparer Support  
                                     #region case SearchDataTypes._8bits:  
                                     case SearchDataTypes._8bits:  
                                         if (SearchArgs.IsUnsignedDataType)  
1157                                          {                                          {
1158                                              byte lookup_value = 0;                                              case SearchDataTypes._8bits: if (unsigned)
                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                             _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);  
                                             byte value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToByte(result_value);  
                                                 comparer.Value = value;  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                 comparer.Value = value;  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1159                                                  {                                                  {
1160                                                      second_tmp_Results.Add(_tmp_result);                                                      using (ResultType<byte> result = reader.GetNextResult<byte>())
1161                                                        {
1162                                                            address = result.Address;
1163                                                            result_value = result.Value;
1164                                                        }
1165                                                  }                                                  }
1166                                              }                                                  else
1167                                              comparer = null; // free memory                                                  {
1168                                          }                                                      using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
1169                                          else                                                      {
1170                                          {                                                          address = result.Address;
1171                                              sbyte lookup_value = 0;                                                          result_value = result.Value;
1172                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }                                                      }
1173                                              _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);                                                  } break;
1174                                              sbyte value = 0;                                              case SearchDataTypes._16bits: if (unsigned)
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToSByte(result_value);  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1175                                                  {                                                  {
1176                                                      second_tmp_Results.Add(_tmp_result);                                                      using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1177                                                        {
1178                                                            address = result.Address;
1179                                                            result_value = result.Value;
1180                                                        }
1181                                                  }                                                  }
1182                                              }                                                  else
1183                                              comparer = null; // free memory                                                  {
1184                                          }                                                      using (ResultType<short> result = reader.GetNextResult<short>())
1185                                          break;                                                      {
1186                                      #endregion                                                          address = result.Address;
1187                                      #region case SearchDataTypes._16bits:                                                          result_value = result.Value;
1188                                      case SearchDataTypes._16bits:                                                      }
1189                                          if (SearchArgs.IsUnsignedDataType)                                                  } break;
1190                                          {                                              case SearchDataTypes._32bits: if (unsigned)
                                             ushort lookup_value = 0;  
                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                             _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);  
                                             ushort value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToUInt16(result_value);  
                                                 comparer.Value = value;  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                 comparer.Value = value;  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1191                                                  {                                                  {
1192                                                      second_tmp_Results.Add(_tmp_result);                                                      using (ResultType<uint> result = reader.GetNextResult<uint>())
1193                                                        {
1194                                                            address = result.Address;
1195                                                            result_value = result.Value;
1196                                                        }
1197                                                  }                                                  }
1198                                              }                                                  else
1199                                              comparer = null; // free memory                                                  {
1200                                          }                                                      using (ResultType<int> result = reader.GetNextResult<int>())
1201                                          else                                                      {
1202                                          {                                                          address = result.Address;
1203                                              short lookup_value = 0;                                                          result_value = result.Value;
1204                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }                                                      }
1205                                              _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);                                                  } break;
1206                                              short value = 0;                                              case SearchDataTypes._64bits: if (unsigned)
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToInt16(result_value);  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1207                                                  {                                                  {
1208                                                      second_tmp_Results.Add(_tmp_result);                                                      using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1209                                                        {
1210                                                            address = result.Address;
1211                                                            result_value = result.Value;
1212                                                        }
1213                                                  }                                                  }
1214                                              }                                                  else
1215                                              comparer = null; // free memory                                                  {
1216                                                        using (ResultType<long> result = reader.GetNextResult<long>())
1217                                                        {
1218                                                            address = result.Address;
1219                                                            result_value = result.Value;
1220                                                        }
1221                                                    } break;
1222                                          }                                          }
1223                                          break;                                          #endregion
1224                                      #endregion                                          if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1225                                      #region case SearchDataTypes._32bits:                                          try
                                     case SearchDataTypes._32bits:  
                                         if (SearchArgs.IsUnsignedDataType)  
1226                                          {                                          {
1227                                              uint lookup_value = 0;                                              //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1228                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                          }
1229                                              {                                          catch (Exception)
1230                                                  try                                          {
1231                                                throw;
1232                                            }
1233                                            switch (SearchArgs.DataType)
1234                                            {
1235                                                #region Comparer Support
1236                                                #region case SearchDataTypes._8bits:
1237                                                case SearchDataTypes._8bits:
1238                                                    if (SearchArgs.IsUnsignedDataType)
1239                                                  {                                                  {
1240                                                      gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider();                                                      byte lookup_value = 0;
1241                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1242                                                        lookup_value = Convert.ToByte(result_value);
1243                                                        using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))
1244                                                        {
1245                                                            byte value = 0;
1246                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1247                                                            {
1248                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1249                                                                {
1250                                                                    try
1251                                                                    {
1252                                                                        gmp.OpenProvider();
1253                                                                        gmp.ReadMemory(address, out value);
1254                                                                        gmp.CloseProvider();
1255                                                                    }
1256                                                                    catch (Exception ex)
1257                                                                    {
1258                                                                        logger.VerboseError.WriteLine(ex.ToString());
1259                                                                    }
1260                                                                }
1261                                                                comparer.Value = value;
1262                                                            }
1263                                                            else
1264                                                            {
1265                                                                value = Convert.ToByte(SearchArgs.CompareStartValue);
1266                                                                comparer.Value = value;
1267                                                            }
1268                                                            if (comparer.Compare(lookup_value, value))
1269                                                            {
1270                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1271                                                            }
1272                                                        }
1273                                                  }                                                  }
1274                                                  catch (Exception ex)                                                  else
1275                                                  {                                                  {
1276                                                      throw;                                                      sbyte lookup_value = 0;
1277                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1278                                                        lookup_value = Convert.ToSByte(result_value);
1279                                                        using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address))
1280                                                        {
1281                                                            sbyte value = 0;
1282                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1283                                                            {
1284                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1285                                                                {
1286                                                                    try
1287                                                                    {
1288                                                                        gmp.OpenProvider();
1289                                                                        gmp.ReadMemory(address, out value);
1290                                                                        gmp.CloseProvider();
1291                                                                    }
1292                                                                    catch (Exception ex)
1293                                                                    {
1294                                                                        logger.VerboseError.WriteLine(ex.ToString());
1295                                                                    }
1296                                                                }
1297                                                                comparer.Value = value;
1298                                                            }
1299                                                            else
1300                                                            {
1301                                                                value = Convert.ToSByte(SearchArgs.CompareStartValue);
1302                                                            }
1303                                                            if (comparer.Compare(lookup_value, value))
1304                                                            {
1305                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1306                                                            }
1307                                                        }
1308                                                  }                                                  }
1309                                              }                                                  break;
1310                                              _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);                                              #endregion
1311                                              uint value = 0;                                              #region case SearchDataTypes._16bits:
1312                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                              case SearchDataTypes._16bits:
1313                                              {                                                  if (SearchArgs.IsUnsignedDataType)
                                                 value = Convert.ToUInt32(result_value);  
                                                 comparer.Value = value;  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                 comparer.Value = value;  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1314                                                  {                                                  {
1315                                                      second_tmp_Results.Add(_tmp_result);                                                      ushort lookup_value = 0;
1316                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1317                                                        lookup_value = Convert.ToUInt16(result_value);
1318                                                        using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address))
1319                                                        {
1320                                                            ushort value = 0;
1321                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1322                                                            {
1323                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1324                                                                {
1325                                                                    try
1326                                                                    {
1327                                                                        gmp.OpenProvider();
1328                                                                        gmp.ReadMemory(address, out value);
1329                                                                        gmp.CloseProvider();
1330                                                                    }
1331                                                                    catch (Exception ex)
1332                                                                    {
1333                                                                        logger.VerboseError.WriteLine(ex.ToString());
1334                                                                    }
1335                                                                }
1336                                                                comparer.Value = value;
1337                                                            }
1338                                                            else
1339                                                            {
1340                                                                value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1341                                                                comparer.Value = value;
1342                                                            }
1343                                                            if (comparer.Compare(lookup_value, value))
1344                                                            {
1345                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1346                                                            }
1347                                                        }
1348                                                  }                                                  }
1349                                              }                                                  else
                                             comparer = null; // free memory  
                                         }  
                                         else  
                                         {  
                                             int lookup_value = 0;  
                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                             _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);  
                                             int value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToInt32(result_value);  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1350                                                  {                                                  {
1351                                                      second_tmp_Results.Add(_tmp_result);                                                      short lookup_value = 0;
1352                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1353                                                        lookup_value = Convert.ToInt16(result_value);
1354                                                        using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address))
1355                                                        {
1356                                                            short value = 0;
1357                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1358                                                            {
1359                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1360                                                                {
1361                                                                    try
1362                                                                    {
1363                                                                        gmp.OpenProvider();
1364                                                                        gmp.ReadMemory(address, out value);
1365                                                                        gmp.CloseProvider();
1366                                                                    }
1367                                                                    catch (Exception ex)
1368                                                                    {
1369                                                                        logger.VerboseError.WriteLine(ex.ToString());
1370                                                                    }
1371                                                                }
1372                                                                comparer.Value = value;
1373                                                            }
1374                                                            else
1375                                                            {
1376                                                                value = Convert.ToInt16(SearchArgs.CompareStartValue);
1377                                                            }
1378                                                            if (comparer.Compare(lookup_value, value))
1379                                                            {
1380                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1381                                                            }
1382                                                        }
1383                                                  }                                                  }
1384                                              }                                                  break;
1385                                              comparer = null; // free memory                                              #endregion
1386                                          }                                              #region case SearchDataTypes._32bits:
1387                                          break;                                              case SearchDataTypes._32bits:
1388                                      #endregion                                                  if (SearchArgs.IsUnsignedDataType)
                                     #region case SearchDataTypes._64bits:  
                                     case SearchDataTypes._64bits:  
                                         if (SearchArgs.IsUnsignedDataType)  
                                         {  
                                             ulong lookup_value = 0;  
                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                             _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);  
                                             ulong value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToUInt64(result_value);  
                                                 comparer.Value = value;  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                 comparer.Value = value;  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))  
1389                                                  {                                                  {
1390                                                      second_tmp_Results.Add(_tmp_result);                                                      uint lookup_value = 0;
1391                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1392                                                        lookup_value = Convert.ToUInt32(result_value);
1393                                                        using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address))
1394                                                        {
1395                                                            uint value = 0;
1396                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1397                                                            {
1398                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1399                                                                {
1400                                                                    try
1401                                                                    {
1402                                                                        gmp.OpenProvider();
1403                                                                        gmp.ReadMemory(address, out value);
1404                                                                        gmp.CloseProvider();
1405                                                                    }
1406                                                                    catch (Exception ex)
1407                                                                    {
1408                                                                        logger.VerboseError.WriteLine(ex.ToString());
1409                                                                    }
1410                                                                }
1411                                                                comparer.Value = value;
1412                                                            }
1413                                                            else
1414                                                            {
1415                                                                value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1416                                                                comparer.Value = value;
1417                                                            }
1418                                                            if (comparer.Compare(lookup_value, value))
1419                                                            {
1420                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1421                                                            }
1422                                                        }
1423                                                  }                                                  }
1424                                              }                                                  else
1425                                              comparer = null; // free memory                                                  {
1426                                          }                                                      int lookup_value = 0;
1427                                          else                                                      //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1428                                          {                                                      lookup_value = Convert.ToInt32(result_value);
1429                                              long lookup_value = 0;                                                      using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address))
1430                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }                                                      {
1431                                              _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);                                                          int value = 0;
1432                                              long value = 0;                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1433                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          {
1434                                              {                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1435                                                  value = Convert.ToInt64(result_value);                                                              {
1436                                              }                                                                  try
1437                                              else                                                                  {
1438                                              {                                                                      gmp.OpenProvider();
1439                                                  value = Convert.ToInt64(SearchArgs.CompareStartValue);                                                                      gmp.ReadMemory(address, out value);
1440                                              }                                                                      gmp.CloseProvider();
1441                                              if (comparer.Compare(lookup_value, value))                                                                  }
1442                                              {                                                                  catch (Exception ex)
1443                                                  using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))                                                                  {
1444                                                                        logger.VerboseError.WriteLine(ex.ToString());
1445                                                                    }
1446                                                                }
1447                                                                comparer.Value = value;
1448                                                            }
1449                                                            else
1450                                                            {
1451                                                                value = Convert.ToInt32(SearchArgs.CompareStartValue);
1452                                                            }
1453                                                            if (comparer.Compare(lookup_value, value))
1454                                                            {
1455                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1456                                                            }
1457                                                        }
1458                                                    }
1459                                                    break;
1460                                                #endregion
1461                                                #region case SearchDataTypes._64bits:
1462                                                case SearchDataTypes._64bits:
1463                                                    if (SearchArgs.IsUnsignedDataType)
1464                                                    {
1465                                                        ulong lookup_value = 0;
1466                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1467                                                        lookup_value = Convert.ToUInt64(result_value);
1468                                                        using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address))
1469                                                        {
1470                                                            ulong value = 0;
1471                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1472                                                            {
1473                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1474                                                                {
1475                                                                    try
1476                                                                    {
1477                                                                        gmp.OpenProvider();
1478                                                                        gmp.ReadMemory(address, out value);
1479                                                                        gmp.CloseProvider();
1480                                                                    }
1481                                                                    catch (Exception ex)
1482                                                                    {
1483                                                                        logger.VerboseError.WriteLine(ex.ToString());
1484                                                                    }
1485                                                                }
1486                                                                comparer.Value = value;
1487                                                            }
1488                                                            else
1489                                                            {
1490                                                                value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1491                                                                comparer.Value = value;
1492                                                            }
1493                                                            if (comparer.Compare(lookup_value, value))
1494                                                            {
1495                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1496                                                            }
1497                                                        }
1498                                                    }
1499                                                    else
1500                                                  {                                                  {
1501                                                      second_tmp_Results.Add(_tmp_result);                                                      long lookup_value = 0;
1502                                                        //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1503                                                        lookup_value = Convert.ToInt64(result_value);
1504                                                        using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address))
1505                                                        {
1506                                                            long value = 0;
1507                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1508                                                            {
1509                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1510                                                                {
1511                                                                    try
1512                                                                    {
1513                                                                        gmp.OpenProvider();
1514                                                                        gmp.ReadMemory(address, out value);
1515                                                                        gmp.CloseProvider();
1516                                                                    }
1517                                                                    catch (Exception ex)
1518                                                                    {
1519                                                                        logger.VerboseError.WriteLine(ex.ToString());
1520                                                                    }
1521                                                                }
1522                                                                comparer.Value = value;
1523                                                            }
1524                                                            else
1525                                                            {
1526                                                                value = Convert.ToInt64(SearchArgs.CompareStartValue);
1527                                                            }
1528                                                            if (comparer.Compare(lookup_value, value))
1529                                                            {
1530                                                                second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1531                                                            }
1532                                                        }
1533                                                  }                                                  }
1534                                                    break;
1535                                                #endregion
1536                                                #endregion
1537                                            }
1538                                            double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1539                                            int int_percent_done = (int)double_percent_done;
1540                                            if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)
1541                                            {
1542                                                if (int_percent_done <= 100)
1543                                                {
1544                                                    resultsprogress.Value = int_percent_done;
1545                                                    resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1546                                                    Last_Whole_Percent_Done = int_percent_done;
1547                                              }                                              }
                                             comparer = null; // free memory  
1548                                          }                                          }
1549                                          break;                                      }
                                     #endregion  
                                     #endregion  
1550                                  }                                  }
1551                                  double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);                                  catch (Exception ex)
                                 int int_percent_done = (int)double_percent_done;  
                                 if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)  
1552                                  {                                  {
1553                                      if (int_percent_done <= 100)                                      throw;
                                     {  
                                         resultsprogress.Value = int_percent_done;  
                                         resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);  
                                         Last_Whole_Percent_Done = int_percent_done;  
                                         if (int_percent_done == 11)  
                                         {  
                                             int local_k = 0;  
                                         }  
                                     }  
1554                                  }                                  }
1555                              }                              }
1556                          }                          }
1557                            catch (Exception ex)
1558                            {
1559                                throw;
1560                            }
1561                            st_nonrange_search.Stop();
1562                            logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
1563                            Last_Whole_Percent_Done = 0;
1564                            #endregion
1565                      }                      }
1566                      catch (Exception ex)                      #region Ranged Searches
                     {  
                         throw;  
                     }  
                     st_nonrange_search.Stop();  
                     logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);  
                     Last_Whole_Percent_Done = 0;  
                     #endregion  
                 }  
                 #region Ranged Searches  
1567  #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT  #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
1568                  if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)                      if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
                 {  
                     st_ranged_search.Start();  
                     object start, end;  
   
                     start = SearchArgs.CompareStartValue;  
                     end = SearchArgs.CompareEndValue;  
                     using (SearchResultReader reader = new SearchResultReader())  
1569                      {                      {
1570                          for (int i = 0; i < reader.ResultCount; i += 1)                          st_ranged_search.Start();
1571                            object start, end;
1572    
1573                            start = SearchArgs.CompareStartValue;
1574                            end = SearchArgs.CompareEndValue;
1575                            using (SearchResultReader reader = new SearchResultReader())
1576                          {                          {
1577                              uint address = 0;                              for (int i = 0; i < reader.ResultCount; i += 1)
                             #region switch (SearchArgs.DataType)  
                             switch (SearchArgs.DataType)  
                             {  
                                 case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }  
                                     else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;  
                                 case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }  
                                     else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;  
                                 case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }  
                                     else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;  
                                 case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }  
                                     else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;  
                             }  
                             #endregion  
                               
                             if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                             //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                             if (SearchArgs.CompareType == SearchCompareTypes.Between)  
1578                              {                              {
1579                                  InRangeComparer comparer = new InRangeComparer(address, 0);                                  uint address = 0;
1580                                  if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))                                  #region switch (SearchArgs.DataType)
1581                                    switch (SearchArgs.DataType)
1582                                  {                                  {
1583                                      using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))                                      case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }
1584                                            else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;
1585                                        case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }
1586                                            else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;
1587                                        case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }
1588                                            else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;
1589                                        case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }
1590                                            else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;
1591                                    }
1592                                    #endregion
1593    
1594                                    if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1595                                    //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1596                                    if (SearchArgs.CompareType == SearchCompareTypes.Between)
1597                                    {
1598                                        using (InRangeComparer comparer = new InRangeComparer(address, 0))
1599                                      {                                      {
1600                                          second_tmp_Results.Add(_tmp_result);                                          if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1601                                            {
1602                                                using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1603                                                {
1604                                                    second_tmp_Results.Add(_tmp_result);
1605                                                }
1606                                            }
1607                                      }                                      }
1608                                  }                                  }
1609                                  comparer = null;                                  else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
                             }  
                             else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)  
                             {  
                                 NotInRangeComparer comparer = new NotInRangeComparer(address, 0);  
                                 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))  
1610                                  {                                  {
1611                                      using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))                                      using (NotInRangeComparer comparer = new NotInRangeComparer(address, 0))
1612                                      {                                      {
1613                                          second_tmp_Results.Add(_tmp_result);                                          if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1614                                            {
1615                                                using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1616                                                {
1617                                                    second_tmp_Results.Add(_tmp_result);
1618                                                }
1619                                            }
1620                                      }                                      }
1621                                  }                                  }
1622                                  comparer = null;                                  else
                             }  
                             else  
                             {  
                                 throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);  
                             }  
                             double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);  
                             int int_percent_done = (int)double_percent_done;  
                             if (int_percent_done != Last_Whole_Percent_Done)  
                             {  
                                 if (int_percent_done <= 100)  
1623                                  {                                  {
1624                                      resultsprogress.Value = int_percent_done;                                      throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
                                     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);  
                                     Last_Whole_Percent_Done = int_percent_done;  
1625                                  }                                  }
1626                                  if (int_percent_done == 11)                                  double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1627                                    int int_percent_done = (int)double_percent_done;
1628                                    if (int_percent_done != Last_Whole_Percent_Done)
1629                                  {                                  {
1630                                      int local_k = 0;                                      if (int_percent_done <= 100)
1631                                        {
1632                                            resultsprogress.Value = int_percent_done;
1633                                            resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1634                                            Last_Whole_Percent_Done = int_percent_done;
1635                                        }
1636                                  }                                  }
1637                              }                              }
1638                          }                          }
1639                            st_ranged_search.Stop();
1640                            logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
1641                      }                      }
                     st_ranged_search.Stop();  
                     logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);  
                 }  
1642  #endif  #endif
1643                  #endregion                      #endregion
1644    
1645              }                  }
1646              #endregion                  #endregion
1647              // leave SearchArgs.Results alone, if false                  // leave SearchArgs.Results alone, if false
1648              if (NeedToCompare)                  if (NeedToCompare)
             {  
                 // fix addresses when memory start is not zero  
                 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; } }  
                 using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count))  
1649                  {                  {
1650                      for (int i = 0; i < second_tmp_Results.Count; i++)                      // fix addresses when memory start is not zero
1651                        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; } }
1652                        using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count))
1653                      {                      {
1654                          switch (sdt)                          for (int i = 0; i < second_tmp_Results.Count; i++)
1655                          {                          {
1656                              case SearchDataTypes._8bits:                              switch (sdt)
1657                                  if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }                              {
1658                                  else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;                                  case SearchDataTypes._8bits:
1659                              case SearchDataTypes._16bits:                                      if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }
1660                                  if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }                                      else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
1661                                  else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;                                  case SearchDataTypes._16bits:
1662                              case SearchDataTypes._32bits:                                      if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }
1663                                  if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }                                      else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
1664                                  else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;                                  case SearchDataTypes._32bits:
1665                              case SearchDataTypes._64bits:                                      if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }
1666                                  if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }                                      else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;
1667                                  else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;                                  case SearchDataTypes._64bits:
1668                                        if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }
1669                                        else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
1670                                }
1671                          }                          }
1672                      }                      }
1673                        second_tmp_Results = null; // free memory                      
1674                  }                  }
1675                  second_tmp_Results = null; // free memory                                    }
1676                catch (Exception ex)
1677                {
1678                    throw;
1679              }              }
1680          }          }
1681    

Legend:
Removed from v.409  
changed lines
  Added in v.410

  ViewVC Help
Powered by ViewVC 1.1.22