/[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 557 by william, Thu Jun 6 03:17:53 2013 UTC revision 560 by william, Thu Jun 6 03:54:38 2013 UTC
# Line 1102  namespace RomCheater.Docking Line 1102  namespace RomCheater.Docking
1102    
1103                      if (SearchArgs.IsFirstSearch)                      if (SearchArgs.IsFirstSearch)
1104                      {                      {
1105                            #region FirstSearch
1106                          provider.OpenProvider();                          provider.OpenProvider();
1107                          int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);                          int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1108                          SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                                                                      SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1109                          int Last_Whole_Percent_Done = 0;                          int Last_Whole_Percent_Done = 0;
1110                          uint size = 0;                          uint size = 0;
1111                          const uint MB_SIZE = 16; /* MEM_1MB * MB_SIZE = MB_SIZE in megabytes */                          const uint MB_SIZE = 16; /* MEM_1MB * MB_SIZE = MB_SIZE in megabytes */
# Line 1116  namespace RomCheater.Docking Line 1117  namespace RomCheater.Docking
1117                              case SearchDataTypes._64bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;                              case SearchDataTypes._64bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1118                          }                          }
1119                          //uint size = STEP_SIZE * 4096;                          //uint size = STEP_SIZE * 4096;
1120                          for (uint i = MemoryRangeStart; i < MemoryRangeSize; i+=size)                          for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)
1121                          {                          {
1122                              
1123                              int bytesRead=0;                              int bytesRead = 0;
1124                              byte[] data = new byte[size];                              byte[] data = new byte[size];
1125                              provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);                              provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1126                              string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));                              string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1127                              double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);                              double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1128                              int int_percent_done = (int)double_percent_done;                              int int_percent_done = (int)double_percent_done;
1129                              if ( (int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)                              if ((int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)
1130                              {                              {
1131                                  UpdateProgress((int)double_percent_done, message);                                  UpdateProgress((int)double_percent_done, message);
1132                                  Last_Whole_Percent_Done = int_percent_done;                                  Last_Whole_Percent_Done = int_percent_done;
# Line 1223  namespace RomCheater.Docking Line 1224  namespace RomCheater.Docking
1224                                      {                                      {
1225                                          #region 16bits - unsigned                                          #region 16bits - unsigned
1226                                          var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1227                                            foreach (var Value in t_data)                                          foreach (var Value in t_data)
1228                                            {                                          {
1229                                                if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1230                                                using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))                                              using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1231                                                {                                              {
1232                                                    ushort value = 0;                                                  ushort value = 0;
1233                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1234                                                    {                                                  {
1235                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1236                                                        {                                                      {
1237                                                            try                                                          try
1238                                                            {                                                          {
1239                                                                gmp.OpenProvider();                                                              gmp.OpenProvider();
1240                                                                gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1241                                                                gmp.CloseProvider();                                                              gmp.CloseProvider();
1242                                                            }                                                          }
1243                                                            catch (Exception ex)                                                          catch (Exception ex)
1244                                                            {                                                          {
1245                                                                logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1246                                                            }                                                          }
1247                                                        }                                                      }
1248                                                        comparer.Value = value;                                                      comparer.Value = value;
1249                                                    }                                                  }
1250                                                    else                                                  else
1251                                                    {                                                  {
1252                                                        value = Convert.ToUInt16(SearchArgs.CompareStartValue);                                                      value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1253                                                        comparer.Value = value;                                                      comparer.Value = value;
1254                                                    }                                                  }
1255                                                    if (comparer.Compare(Convert.ToUInt16(Value), value))                                                  if (comparer.Compare(Convert.ToUInt16(Value), value))
1256                                                    {                                                  {
1257                                                        writer.WriteResult<ushort>(comparer.Address, comparer.Value);                                                      writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1258                                                    }                                                  }
1259                                                }                                              }
1260                                                address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1261                                            }                                          }
1262                                          #endregion                                          #endregion
1263                                      }                                      }
1264                                      else                                      else
1265                                      {                                      {
1266                                          #region 16bits - signed                                          #region 16bits - signed
1267                                          var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1268                                           foreach (var Value in t_data)                                          foreach (var Value in t_data)
1269                                           {                                          {
1270                                               if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1271                                               using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))                                              using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1272                                               {                                              {
1273                                                   short value = 0;                                                  short value = 0;
1274                                                   if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1275                                                   {                                                  {
1276                                                       using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1277                                                       {                                                      {
1278                                                           try                                                          try
1279                                                           {                                                          {
1280                                                               gmp.OpenProvider();                                                              gmp.OpenProvider();
1281                                                               gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1282                                                               gmp.CloseProvider();                                                              gmp.CloseProvider();
1283                                                           }                                                          }
1284                                                           catch (Exception ex)                                                          catch (Exception ex)
1285                                                           {                                                          {
1286                                                               logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1287                                                           }                                                          }
1288                                                       }                                                      }
1289                                                       comparer.Value = value;                                                      comparer.Value = value;
1290                                                   }                                                  }
1291                                                   else                                                  else
1292                                                   {                                                  {
1293                                                       value = Convert.ToInt16(SearchArgs.CompareStartValue);                                                      value = Convert.ToInt16(SearchArgs.CompareStartValue);
1294                                                       comparer.Value = value;                                                      comparer.Value = value;
1295                                                   }                                                  }
1296                                                   if (comparer.Compare(Convert.ToSByte(Value), value))                                                  if (comparer.Compare(Convert.ToSByte(Value), value))
1297                                                   {                                                  {
1298                                                       writer.WriteResult<short>(comparer.Address, comparer.Value);                                                      writer.WriteResult<short>(comparer.Address, comparer.Value);
1299                                                   }                                                  }
1300                                               }                                              }
1301                                               address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1302                                           }                                          }
1303                                          #endregion                                          #endregion
1304                                      } break;                                      } break;
1305                                  case SearchDataTypes._32bits:                                  case SearchDataTypes._32bits:
# Line 1306  namespace RomCheater.Docking Line 1307  namespace RomCheater.Docking
1307                                      {                                      {
1308                                          #region 32bits - unsigned                                          #region 32bits - unsigned
1309                                          var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1310                                           foreach (var Value in t_data)                                          foreach (var Value in t_data)
1311                                           {                                          {
1312                                               if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1313                                               using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))                                              using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1314                                               {                                              {
1315                                                   uint value = 0;                                                  uint value = 0;
1316                                                   if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1317                                                   {                                                  {
1318                                                       using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1319                                                       {                                                      {
1320                                                           try                                                          try
1321                                                           {                                                          {
1322                                                               gmp.OpenProvider();                                                              gmp.OpenProvider();
1323                                                               gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1324                                                               gmp.CloseProvider();                                                              gmp.CloseProvider();
1325                                                           }                                                          }
1326                                                           catch (Exception ex)                                                          catch (Exception ex)
1327                                                           {                                                          {
1328                                                               logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1329                                                           }                                                          }
1330                                                       }                                                      }
1331                                                       comparer.Value = value;                                                      comparer.Value = value;
1332                                                   }                                                  }
1333                                                   else                                                  else
1334                                                   {                                                  {
1335                                                       value = Convert.ToUInt32(SearchArgs.CompareStartValue);                                                      value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1336                                                       comparer.Value = value;                                                      comparer.Value = value;
1337                                                   }                                                  }
1338                                                   if (comparer.Compare(Convert.ToUInt32(Value), value))                                                  if (comparer.Compare(Convert.ToUInt32(Value), value))
1339                                                   {                                                  {
1340                                                       writer.WriteResult<uint>(comparer.Address, comparer.Value);                                                      writer.WriteResult<uint>(comparer.Address, comparer.Value);
1341                                                   }                                                  }
1342                                               }                                              }
1343                                               address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1344                                           }                                          }
1345                                          #endregion                                          #endregion
1346                                      }                                      }
1347                                      else                                      else
1348                                      {                                      {
1349                                          #region 32bits - signed                                          #region 32bits - signed
1350                                          var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1351                                           foreach (var Value in t_data)                                          foreach (var Value in t_data)
1352                                           {                                          {
1353                                               if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1354                                               using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))                                              using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1355                                               {                                              {
1356                                                   int value = 0;                                                  int value = 0;
1357                                                   if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1358                                                   {                                                  {
1359                                                       using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1360                                                       {                                                      {
1361                                                           try                                                          try
1362                                                           {                                                          {
1363                                                               gmp.OpenProvider();                                                              gmp.OpenProvider();
1364                                                               gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1365                                                               gmp.CloseProvider();                                                              gmp.CloseProvider();
1366                                                           }                                                          }
1367                                                           catch (Exception ex)                                                          catch (Exception ex)
1368                                                           {                                                          {
1369                                                               logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1370                                                           }                                                          }
1371                                                       }                                                      }
1372                                                       comparer.Value = value;                                                      comparer.Value = value;
1373                                                   }                                                  }
1374                                                   else                                                  else
1375                                                   {                                                  {
1376                                                       value = Convert.ToInt32(SearchArgs.CompareStartValue);                                                      value = Convert.ToInt32(SearchArgs.CompareStartValue);
1377                                                       comparer.Value = value;                                                      comparer.Value = value;
1378                                                   }                                                  }
1379                                                   if (comparer.Compare(Convert.ToInt32(Value), value))                                                  if (comparer.Compare(Convert.ToInt32(Value), value))
1380                                                   {                                                  {
1381                                                       writer.WriteResult<int>(comparer.Address, comparer.Value);                                                      writer.WriteResult<int>(comparer.Address, comparer.Value);
1382                                                   }                                                  }
1383                                               }                                              }
1384                                               address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1385                                           }                                          }
1386                                          #endregion                                          #endregion
1387                                      } break;                                      } break;
1388                                  case SearchDataTypes._64bits:                                  case SearchDataTypes._64bits:
# Line 1389  namespace RomCheater.Docking Line 1390  namespace RomCheater.Docking
1390                                      {                                      {
1391                                          #region 64bits - unsigned                                          #region 64bits - unsigned
1392                                          var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1393                                           foreach (var Value in t_data)                                          foreach (var Value in t_data)
1394                                           {                                          {
1395                                               if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1396                                               using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))                                              using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1397                                               {                                              {
1398                                                   ulong value = 0;                                                  ulong value = 0;
1399                                                   if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1400                                                   {                                                  {
1401                                                       using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1402                                                       {                                                      {
1403                                                           try                                                          try
1404                                                           {                                                          {
1405                                                               gmp.OpenProvider();                                                              gmp.OpenProvider();
1406                                                               gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1407                                                               gmp.CloseProvider();                                                              gmp.CloseProvider();
1408                                                           }                                                          }
1409                                                           catch (Exception ex)                                                          catch (Exception ex)
1410                                                           {                                                          {
1411                                                               logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1412                                                           }                                                          }
1413                                                       }                                                      }
1414                                                       comparer.Value = value;                                                      comparer.Value = value;
1415                                                   }                                                  }
1416                                                   else                                                  else
1417                                                   {                                                  {
1418                                                       value = Convert.ToUInt64(SearchArgs.CompareStartValue);                                                      value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1419                                                       comparer.Value = value;                                                      comparer.Value = value;
1420                                                   }                                                  }
1421                                                   if (comparer.Compare(Convert.ToUInt64(Value), value))                                                  if (comparer.Compare(Convert.ToUInt64(Value), value))
1422                                                   {                                                  {
1423                                                       writer.WriteResult<ulong>(comparer.Address, comparer.Value);                                                      writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1424                                                   }                                                  }
1425                                               }                                              }
1426                                               address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1427                                           }                                          }
1428                                          #endregion                                          #endregion
1429                                      }                                      }
1430                                      else                                      else
1431                                      {                                      {
1432                                          #region 64bits - signed                                          #region 64bits - signed
1433                                          var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                          var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1434                                           foreach (var Value in t_data)                                          foreach (var Value in t_data)
1435                                           {                                          {
1436                                               if (SearchWorkerThread.CancellationPending) { break; }                                              if (SearchWorkerThread.CancellationPending) { break; }
1437                                               using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))                                              using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
1438                                               {                                              {
1439                                                   long value = 0;                                                  long value = 0;
1440                                                   if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1441                                                   {                                                  {
1442                                                       using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1443                                                       {                                                      {
1444                                                           try                                                          try
1445                                                           {                                                          {
1446                                                               gmp.OpenProvider();                                                              gmp.OpenProvider();
1447                                                               gmp.ReadMemory(address_index, out value);                                                              gmp.ReadMemory(address_index, out value);
1448                                                               gmp.CloseProvider();                                                              gmp.CloseProvider();
1449                                                           }                                                          }
1450                                                           catch (Exception ex)                                                          catch (Exception ex)
1451                                                           {                                                          {
1452                                                               logger.VerboseError.WriteLine(ex.ToString());                                                              logger.VerboseError.WriteLine(ex.ToString());
1453                                                           }                                                          }
1454                                                       }                                                      }
1455                                                       comparer.Value = value;                                                      comparer.Value = value;
1456                                                   }                                                  }
1457                                                   else                                                  else
1458                                                   {                                                  {
1459                                                       value = Convert.ToInt64(SearchArgs.CompareStartValue);                                                      value = Convert.ToInt64(SearchArgs.CompareStartValue);
1460                                                       comparer.Value = value;                                                      comparer.Value = value;
1461                                                   }                                                  }
1462                                                   if (comparer.Compare(Convert.ToInt64(Value), value))                                                  if (comparer.Compare(Convert.ToInt64(Value), value))
1463                                                   {                                                  {
1464                                                       writer.WriteResult<long>(comparer.Address, comparer.Value);                                                      writer.WriteResult<long>(comparer.Address, comparer.Value);
1465                                                   }                                                  }
1466                                               }                                              }
1467                                               address_index += STEP_SIZE;                                              address_index += STEP_SIZE;
1468                                           }                                          }
1469                                          #endregion                                          #endregion
1470                                      } break;                                      } break;
1471                                        
1472                              }                              }
1473                              #endregion                              #endregion
1474    
# Line 1498  namespace RomCheater.Docking Line 1499  namespace RomCheater.Docking
1499                          writer.Dispose();                          writer.Dispose();
1500                          writer = null;                          writer = null;
1501                          provider.CloseProvider();                          provider.CloseProvider();
1502                            #endregion
1503                      }                      }
1504                      else                      else
1505                      {                      {
1506                          Guid new_SearchGuid = SearchGuid;                          #region SubsequentSearch
1507                            Guid new_SearchGuid = GuidTools.IncrementGuid(SearchGuid);
1508                          int Last_Whole_Percent_Done = 0;                          int Last_Whole_Percent_Done = 0;
1509                          // need to get the address list                          // need to get the address list
1510                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, true,SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation))) // delete the file on dispose                          uint[] reader_addresses = new uint[0];
1511                            #region Address pre-population
1512                            using (SearchResultReader reader = new SearchResultReader(SearchGuid, true, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation))) // delete the file on dispose
1513                          {                          {
1514                              uint[] reader_addresses = new uint[reader.ResultCount];                              reader_addresses = new uint[reader.ResultCount];
   
1515                              // pre-populate the addresses array                              // pre-populate the addresses array
1516                              Stopwatch st_profiler_reader_addresses = new Stopwatch();                              Stopwatch st_profiler_reader_addresses = new Stopwatch();
1517                              st_profiler_reader_addresses.Start();                              st_profiler_reader_addresses.Start();
1518                              int reader_address_index = 0;                              int reader_address_index = 0;
1519                              foreach (var k in reader)                              foreach (var k in reader)
1520                              {                              {
1521                                    
1522                                  if (SearchWorkerThread.CancellationPending) { st_profiler_reader_addresses.Stop(); break; }                                  if (SearchWorkerThread.CancellationPending) { st_profiler_reader_addresses.Stop(); break; }
1523                                  reader_addresses[reader_address_index] = k.Address;                                  reader_addresses[reader_address_index] = k.Address;
1524    
# Line 1532  namespace RomCheater.Docking Line 1536  namespace RomCheater.Docking
1536                              }                              }
1537                              st_profiler_reader_addresses.Stop();                              st_profiler_reader_addresses.Stop();
1538                              logger.Profiler.WriteLine("It took a total of {0} seconds to pre-populate the address array.", st_profiler_reader_addresses.Elapsed.TotalSeconds);                              logger.Profiler.WriteLine("It took a total of {0} seconds to pre-populate the address array.", st_profiler_reader_addresses.Elapsed.TotalSeconds);
1539                              new_SearchGuid = GuidTools.IncrementGuid(SearchGuid);                          }
1540                              using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))                          GC.Collect(); // force gc collection
1541                            #endregion
1542    
1543                            #region result writing
1544                            using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))
1545                            {
1546                                Last_Whole_Percent_Done = 0;
1547                                //int index = 0;
1548    
1549                                provider.OpenProvider();
1550                                //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1551                                //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                                
1552                                uint size = 0;
1553                                const uint MB_SIZE = 16; /* MEM_1MB * MB_SIZE = MB_SIZE in megabytes */
1554                                switch (sdt)
1555                                {
1556                                    case SearchDataTypes._8bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1557                                    case SearchDataTypes._16bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1558                                    case SearchDataTypes._32bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1559                                    case SearchDataTypes._64bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1560                                }
1561                                //size = STEP_SIZE * 4096;
1562                                for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)
1563                              {                              {
                                 Last_Whole_Percent_Done = 0;  
                                 //int index = 0;  
1564    
1565                                  provider.OpenProvider();                                  int bytesRead = 0;
1566                                  //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);                                  byte[] data = new byte[size];
1567                                  //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                                                                  provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1568                                  uint size = 0;                                  string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1569                                  const uint MB_SIZE = 16; /* MEM_1MB * MB_SIZE = MB_SIZE in megabytes */                                  double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1570                                  switch (sdt)                                  int int_percent_done = (int)double_percent_done;
1571                                    if ((int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)
1572                                  {                                  {
1573                                      case SearchDataTypes._8bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                      UpdateProgress((int)double_percent_done, message);
1574                                      case SearchDataTypes._16bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                      Last_Whole_Percent_Done = int_percent_done;
                                     case SearchDataTypes._32bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;  
                                     case SearchDataTypes._64bits: size = STEP_SIZE * MEM_1MB * (MB_SIZE / BitTools.SizeOf<uint>(sdt)); break;  
1575                                  }                                  }
                                 //size = STEP_SIZE * 4096;  
                                 for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)  
                                 {  
1576    
1577                                      int bytesRead = 0;                                  uint address_index = i;
1578                                      byte[] data = new byte[size];                                  #region comparison and serialization
1579                                      provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);                                  switch (sdt)
1580                                      string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));                                  {
1581                                      double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);                                      case SearchDataTypes._8bits:
1582                                      int int_percent_done = (int)double_percent_done;                                          if (unsigned)
1583                                      if ((int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)                                          {
1584                                      {                                              #region 8bits - unsigned
1585                                          UpdateProgress((int)double_percent_done, message);                                              var t_data = data;
1586                                          Last_Whole_Percent_Done = int_percent_done;                                              foreach (var Value in t_data)
                                     }  
   
                                     uint address_index = i;  
                                     #region comparison and serialization  
                                     switch (sdt)  
                                     {  
                                         case SearchDataTypes._8bits:  
                                             if (unsigned)  
1587                                              {                                              {
1588                                                  #region 8bits - unsigned                                                  if (SearchWorkerThread.CancellationPending) { break; }
1589                                                  var t_data = data;                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1590                                                  {                                                  {
1591                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1592                                                      if (!reader_addresses.Contains(address_index))                                                  }
1593                                                      {                                                  using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
1594                                                          continue;                                                  {
1595                                                      }                                                      byte value = 0;
1596                                                      using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1597                                                      {                                                      {
1598                                                          byte value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1599                                                          {                                                          {
1600                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1601                                                              {                                                              {
1602                                                                  try                                                                  gmp.OpenProvider();
1603                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1604                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1605                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1606                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1607                                                                  }                                                              {
1608                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1609                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<byte>(comparer.Address, comparer.Value);                                                            
1610                                                          }                                                          }
1611                                                            comparer.Value = value;
1612                                                        }
1613                                                        else
1614                                                        {
1615                                                            value = Convert.ToByte(SearchArgs.CompareStartValue);
1616                                                            comparer.Value = value;
1617                                                        }
1618                                                        if (comparer.Compare(Convert.ToByte(Value), value))
1619                                                        {
1620                                                            writer.WriteResult<byte>(comparer.Address, comparer.Value);
1621                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1622                                                  }                                                  }
1623                                                  #endregion                                                  address_index += STEP_SIZE;
1624                                              }                                              }
1625                                              else                                              #endregion
1626                                            }
1627                                            else
1628                                            {
1629                                                #region 8bits - signed
1630                                                var t_data = data;
1631                                                foreach (var Value in t_data)
1632                                              {                                              {
1633                                                  #region 8bits - signed                                                  if (SearchWorkerThread.CancellationPending) { break; }
1634                                                  var t_data = data;                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1635                                                  {                                                  {
1636                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1637                                                      if (!reader_addresses.Contains(address_index))                                                  }
1638                                                      {                                                  using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
1639                                                          continue;                                                  {
1640                                                      }                                                      sbyte value = 0;
1641                                                      using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1642                                                      {                                                      {
1643                                                          sbyte value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1644                                                          {                                                          {
1645                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1646                                                              {                                                              {
1647                                                                  try                                                                  gmp.OpenProvider();
1648                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1649                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1650                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1651                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1652                                                                  }                                                              {
1653                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1654                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<sbyte>(comparer.Address, comparer.Value);  
1655                                                          }                                                          }
1656                                                            comparer.Value = value;
1657                                                        }
1658                                                        else
1659                                                        {
1660                                                            value = Convert.ToSByte(SearchArgs.CompareStartValue);
1661                                                            comparer.Value = value;
1662                                                        }
1663                                                        if (comparer.Compare(Convert.ToSByte(Value), value))
1664                                                        {
1665                                                            writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1666                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1667                                                  }                                                  }
1668                                                  #endregion                                                  address_index += STEP_SIZE;
1669                                              } break;                                              }
1670                                          case SearchDataTypes._16bits:                                              #endregion
1671                                              if (unsigned)                                          } break;
1672                                        case SearchDataTypes._16bits:
1673                                            if (unsigned)
1674                                            {
1675                                                #region 16bits - unsigned
1676                                                var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1677                                                foreach (var Value in t_data)
1678                                              {                                              {
1679                                                  #region 16bits - unsigned                                                  if (SearchWorkerThread.CancellationPending) { break; }
1680                                                  var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1681                                                  {                                                  {
1682                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1683                                                      if (!reader_addresses.Contains(address_index))                                                  }
1684                                                      {                                                  using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1685                                                          continue;                                                  {
1686                                                      }                                                      ushort value = 0;
1687                                                      using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1688                                                      {                                                      {
1689                                                          ushort value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1690                                                          {                                                          {
1691                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1692                                                              {                                                              {
1693                                                                  try                                                                  gmp.OpenProvider();
1694                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1695                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1696                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1697                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1698                                                                  }                                                              {
1699                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1700                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt16(Value), value))  
                                                         {  
                                                             writer.WriteResult<ushort>(comparer.Address, comparer.Value);  
1701                                                          }                                                          }
1702                                                            comparer.Value = value;
1703                                                        }
1704                                                        else
1705                                                        {
1706                                                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1707                                                            comparer.Value = value;
1708                                                        }
1709                                                        if (comparer.Compare(Convert.ToUInt16(Value), value))
1710                                                        {
1711                                                            writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1712                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1713                                                  }                                                  }
1714                                                  #endregion                                                  address_index += STEP_SIZE;
1715                                              }                                              }
1716                                              else                                              #endregion
1717                                            }
1718                                            else
1719                                            {
1720                                                #region 16bits - signed
1721                                                var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1722                                                foreach (var Value in t_data)
1723                                              {                                              {
1724                                                  #region 16bits - signed                                                  if (SearchWorkerThread.CancellationPending) { break; }
1725                                                  var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1726                                                  {                                                  {
1727                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1728                                                      if (!reader_addresses.Contains(address_index))                                                  }
1729                                                      {                                                  using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1730                                                          continue;                                                  {
1731                                                      }                                                      short value = 0;
1732                                                      using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1733                                                      {                                                      {
1734                                                          short value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1735                                                          {                                                          {
1736                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1737                                                              {                                                              {
1738                                                                  try                                                                  gmp.OpenProvider();
1739                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1740                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1741                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1742                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1743                                                                  }                                                              {
1744                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1745                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<short>(comparer.Address, comparer.Value);  
1746                                                          }                                                          }
1747                                                            comparer.Value = value;
1748                                                        }
1749                                                        else
1750                                                        {
1751                                                            value = Convert.ToInt16(SearchArgs.CompareStartValue);
1752                                                            comparer.Value = value;
1753                                                        }
1754                                                        if (comparer.Compare(Convert.ToSByte(Value), value))
1755                                                        {
1756                                                            writer.WriteResult<short>(comparer.Address, comparer.Value);
1757                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1758                                                  }                                                  }
1759                                                  #endregion                                                  address_index += STEP_SIZE;
1760                                              } break;                                              }
1761                                          case SearchDataTypes._32bits:                                              #endregion
1762                                              if (unsigned)                                          } break;
1763                                        case SearchDataTypes._32bits:
1764                                            if (unsigned)
1765                                            {
1766                                                #region 32bits - unsigned
1767                                                var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1768                                                foreach (var Value in t_data)
1769                                              {                                              {
1770                                                  #region 32bits - unsigned                                                  if (SearchWorkerThread.CancellationPending) { break; }
1771                                                  var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1772                                                  {                                                  {
1773                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1774                                                      if (!reader_addresses.Contains(address_index))                                                  }
1775                                                      {                                                  using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1776                                                          continue;                                                  {
1777                                                      }                                                      uint value = 0;
1778                                                      using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1779                                                      {                                                      {
1780                                                          uint value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1781                                                          {                                                          {
1782                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1783                                                              {                                                              {
1784                                                                  try                                                                  gmp.OpenProvider();
1785                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1786                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1787                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1788                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1789                                                                  }                                                              {
1790                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1791                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt32(Value), value))  
                                                         {  
                                                             writer.WriteResult<uint>(comparer.Address, comparer.Value);  
1792                                                          }                                                          }
1793                                                            comparer.Value = value;
1794                                                        }
1795                                                        else
1796                                                        {
1797                                                            value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1798                                                            comparer.Value = value;
1799                                                        }
1800                                                        if (comparer.Compare(Convert.ToUInt32(Value), value))
1801                                                        {
1802                                                            writer.WriteResult<uint>(comparer.Address, comparer.Value);
1803                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1804                                                  }                                                  }
1805                                                  #endregion                                                  address_index += STEP_SIZE;
1806                                              }                                              }
1807                                              else                                              #endregion
1808                                            }
1809                                            else
1810                                            {
1811                                                #region 32bits - signed
1812                                                var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1813                                                foreach (var Value in t_data)
1814                                              {                                              {
1815                                                  #region 32bits - signed                                                  if (SearchWorkerThread.CancellationPending) { break; }
1816                                                  var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1817                                                  {                                                  {
1818                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1819                                                      if (!reader_addresses.Contains(address_index))                                                  }
1820                                                      {                                                  using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1821                                                          continue;                                                  {
1822                                                      }                                                      int value = 0;
1823                                                      using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1824                                                      {                                                      {
1825                                                          int value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1826                                                          {                                                          {
1827                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1828                                                              {                                                              {
1829                                                                  try                                                                  gmp.OpenProvider();
1830                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1831                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1832                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1833                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1834                                                                  }                                                              {
1835                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1836                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToInt32(Value), value))  
                                                         {  
                                                             writer.WriteResult<int>(comparer.Address, comparer.Value);  
1837                                                          }                                                          }
1838                                                            comparer.Value = value;
1839                                                        }
1840                                                        else
1841                                                        {
1842                                                            value = Convert.ToInt32(SearchArgs.CompareStartValue);
1843                                                            comparer.Value = value;
1844                                                        }
1845                                                        if (comparer.Compare(Convert.ToInt32(Value), value))
1846                                                        {
1847                                                            writer.WriteResult<int>(comparer.Address, comparer.Value);
1848                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1849                                                  }                                                  }
1850                                                  #endregion                                                  address_index += STEP_SIZE;
1851                                              } break;                                              }
1852                                          case SearchDataTypes._64bits:                                              #endregion
1853                                              if (unsigned)                                          } break;
1854                                        case SearchDataTypes._64bits:
1855                                            if (unsigned)
1856                                            {
1857                                                #region 64bits - unsigned
1858                                                var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1859                                                foreach (var Value in t_data)
1860                                              {                                              {
1861                                                  #region 64bits - unsigned                                                  if (SearchWorkerThread.CancellationPending) { break; }
1862                                                  var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1863                                                  {                                                  {
1864                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1865                                                      if (!reader_addresses.Contains(address_index))                                                  }
1866                                                      {                                                  using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1867                                                          continue;                                                  {
1868                                                      }                                                      ulong value = 0;
1869                                                      using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1870                                                      {                                                      {
1871                                                          ulong value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1872                                                          {                                                          {
1873                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1874                                                              {                                                              {
1875                                                                  try                                                                  gmp.OpenProvider();
1876                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1877                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1878                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1879                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1880                                                                  }                                                              {
1881                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1882                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt64(Value), value))  
                                                         {  
                                                             writer.WriteResult<ulong>(comparer.Address, comparer.Value);  
1883                                                          }                                                          }
1884                                                            comparer.Value = value;
1885                                                        }
1886                                                        else
1887                                                        {
1888                                                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1889                                                            comparer.Value = value;
1890                                                        }
1891                                                        if (comparer.Compare(Convert.ToUInt64(Value), value))
1892                                                        {
1893                                                            writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1894                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1895                                                  }                                                  }
1896                                                  #endregion                                                  address_index += STEP_SIZE;
1897                                              }                                              }
1898                                              else                                              #endregion
1899                                            }
1900                                            else
1901                                            {
1902                                                #region 64bits - signed
1903                                                var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1904                                                foreach (var Value in t_data)
1905                                              {                                              {
1906                                                  #region 64bits - signed                                                  if (SearchWorkerThread.CancellationPending) { break; }
1907                                                  var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                                  if (!reader_addresses.Contains(address_index))
                                                 foreach (var Value in t_data)  
1908                                                  {                                                  {
1909                                                      if (SearchWorkerThread.CancellationPending) { break; }                                                      continue;
1910                                                      if (!reader_addresses.Contains(address_index))                                                  }
1911                                                      {                                                  using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
1912                                                          continue;                                                  {
1913                                                      }                                                      long value = 0;
1914                                                      using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1915                                                      {                                                      {
1916                                                          long value = 0;                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1917                                                          {                                                          {
1918                                                              using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                              try
1919                                                              {                                                              {
1920                                                                  try                                                                  gmp.OpenProvider();
1921                                                                  {                                                                  gmp.ReadMemory(address_index, out value);
1922                                                                      gmp.OpenProvider();                                                                  gmp.CloseProvider();
1923                                                                      gmp.ReadMemory(address_index, out value);                                                              }
1924                                                                      gmp.CloseProvider();                                                              catch (Exception ex)
1925                                                                  }                                                              {
1926                                                                  catch (Exception ex)                                                                  logger.VerboseError.WriteLine(ex.ToString());
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
1927                                                              }                                                              }
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToInt64(Value), value))  
                                                         {  
                                                             writer.WriteResult<long>(comparer.Address, comparer.Value);  
1928                                                          }                                                          }
1929                                                            comparer.Value = value;
1930                                                        }
1931                                                        else
1932                                                        {
1933                                                            value = Convert.ToInt64(SearchArgs.CompareStartValue);
1934                                                            comparer.Value = value;
1935                                                        }
1936                                                        if (comparer.Compare(Convert.ToInt64(Value), value))
1937                                                        {
1938                                                            writer.WriteResult<long>(comparer.Address, comparer.Value);
1939                                                      }                                                      }
                                                     address_index += STEP_SIZE;  
1940                                                  }                                                  }
1941                                                  #endregion                                                  address_index += STEP_SIZE;
1942                                              } break;                                              }
1943                                                #endregion
1944                                      }                                          } break;
                                     #endregion  
1945    
                                     if (SearchWorkerThread.CancellationPending)  
                                     {  
                                         provider_st.Stop();  
                                         st.Stop();  
                                         writer.CancelRequest();  
                                         writer.Dispose();  
                                         e.Result = true;  
                                         provider.CloseProvider();  
                                         return;  
                                     }  
1946                                  }                                  }
                                 #region old-code2  
                                 //const int ChunkCount = 0x100;  
                                 //for (int ResultIndex = 0; ResultIndex < reader.ResultCount; ResultIndex += ChunkCount)  
                                 //{  
                                 //    StructResultType<ulong>[] ChunkResults = new StructResultType<ulong>[ChunkCount];  
                                 //    for (int ChunkIndex = 0; ChunkIndex < ChunkCount; ChunkIndex++)  
                                 //    {  
                                 //        int ResultChunkIndex = (ResultIndex + ChunkIndex);  
                                 //        StructResultType<ulong> result = StructResultType<ulong>.Empty;  
                                 //        reader.GetResultAtIndex(ResultChunkIndex, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), out result, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //        ChunkResults[ChunkIndex] = result;  
                                 //        if (SearchWorkerThread.CancellationPending)  
                                 //        {  
                                 //            provider_st.Stop();  
                                 //            st.Stop();  
                                 //            writer.CancelRequest();  
                                 //            writer.Dispose();  
                                 //            e.Result = true;  
                                 //            break;  
                                 //        }  
                                 //    }  
                                 //    // Get update value(s) for each chunk result  
                                 //    ISerializedResult sr = (reader as ISerializedResult);  
                                 //    if(sr == null)  
                                 //    {  
                                 //        throw new ArgumentNullException("sr",string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name,typeof(ISerializedResult).Name));  
                                 //    }  
                                 //    Stopwatch st_memory_results_updater = new Stopwatch();  
                                 //    st_memory_results_updater.Start();  
                                 //    sr.UpdateResultValuesFromMemory(ref ChunkResults, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation), (IAcceptsProcessAndConfig)this);  
                                 //    if (SearchWorkerThread.CancellationPending) // catch a cancelled operation from UpdateResultValuesFromMemory  
                                 //    {  
                                 //        provider_st.Stop();  
                                 //        st.Stop();  
                                 //        writer.CancelRequest();  
                                 //        writer.Dispose();  
                                 //        e.Result = true;  
                                 //        break;  
                                 //    }  
                                 //    st_memory_results_updater.Stop();  
                                 //    logger.Profiler.WriteLine("sr.UpdateResultValuesFromMemory [ResultIndex=0x{0} ChunkCount=0x{1}] took a total of {2} seconds to complete", ResultIndex.ToString("X"), ChunkCount.ToString("X"), st_memory_results_updater.Elapsed.TotalSeconds.ToString());  
                                 //    // ChunkResults should have had thier values updated from memory  
                                 //    string message = string.Format(" -> Updateing Values [ResultIndex=0x{0} of Total=0x{1}]", ResultIndex.ToString("X"), reader.ResultCount.ToString("X"));  
                                 //    double double_percent_done = 100.0 * (double)((double)ResultIndex / (double)reader.ResultCount);  
                                 //    int int_percent_done = (int)double_percent_done;  
                                 //    //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)  
                                 //    //{  
                                 //    //    UpdateProgress((int)double_percent_done, message);  
                                 //    //    Last_Whole_Percent_Done = int_percent_done;  
                                 //    //}  
                                 //    if (((double)ResultIndex % ((double)reader.ResultCount) * 0.25) == 0)  
                                 //    //if ((ResultIndex % 10000) == 0)  
                                 //    {  
                                 //        UpdateProgress((int)double_percent_done, message);  
                                 //        Last_Whole_Percent_Done = int_percent_done;  
                                 //    }  
                                 //    if (SearchWorkerThread.CancellationPending)  
                                 //    {  
                                 //        provider_st.Stop();  
                                 //        st.Stop();  
                                 //        writer.CancelRequest();  
                                 //        writer.Dispose();  
                                 //        e.Result = true;  
                                 //        break;  
                                 //    }  
                                 //}  
                                 #endregion  
   
                                 #region old-code1  
                                 //foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))  
                                 //{  
                                 //    if (SearchWorkerThread.CancellationPending)  
                                 //    {  
                                 //        provider_st.Stop();  
                                 //        st.Stop();  
                                 //        writer.CancelRequest();  
                                 //        writer.Dispose();  
                                 //        e.Result = true;  
                                 //        return;  
                                 //    }  
                                 //    //int Last_Whole_Percent_Done = 0;  
                                 //    provider.OpenProvider();  
                                 //    int bytesRead = 0;  
                                 //    byte[] data = new byte[STEP_SIZE];  
                                 //    provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);  
                                 //    provider.CloseProvider();  
                                 //    if (SearchWorkerThread.CancellationPending)  
                                 //    {  
                                 //        provider_st.Stop();  
                                 //        st.Stop();  
                                 //        writer.CancelRequest();  
                                 //        writer.Dispose();  
                                 //        e.Result = true;  
                                 //        return;  
                                 //    }  
                                 //    uint address_index = k.Address;  
                                 //    string message = string.Format(" -> Reading Address 0x{0:x8} from index 0x{1}", k.Address, index.ToString("X"));  
                                 //    double double_percent_done = 100.0 * (double)((double)index / (double)reader.ResultCount);  
                                 //    int int_percent_done = (int)double_percent_done;  
                                 //    //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)  
                                 //    //{  
                                 //    //    UpdateProgress((int)double_percent_done, message);  
                                 //    //    Last_Whole_Percent_Done = int_percent_done;  
                                 //    //}  
                                 //    if ((index % 10000) == 0)  
                                 //    {  
                                 //        UpdateProgress((int)double_percent_done, message);  
                                 //        //Last_Whole_Percent_Done = int_percent_done;  
                                 //    }  
                                 //    #region comparison and serialization  
                                 //    switch (sdt)  
                                 //    {  
                                 //        case SearchDataTypes._8bits:  
                                 //            if (unsigned)  
                                 //            {  
                                 //                #region 8bits - unsigned  
                                 //                var t_data = data;  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        byte value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToByte(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<byte>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            }  
                                 //            else  
                                 //            {  
                                 //                #region 8bits - signed  
                                 //                var t_data = data;  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        sbyte value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToSByte(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<sbyte>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            } break;  
                                 //        case SearchDataTypes._16bits:  
                                 //            if (unsigned)  
                                 //            {  
                                 //                #region 16bits - unsigned  
                                 //                var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        ushort value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToUInt16(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<ushort>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            }  
                                 //            else  
                                 //            {  
                                 //                #region 16bits - signed  
                                 //                var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        short value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToSByte(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<short>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            } break;  
                                 //        case SearchDataTypes._32bits:  
                                 //            if (unsigned)  
                                 //            {  
                                 //                #region 32bits - unsigned  
                                 //                var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        uint value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToUInt32(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<uint>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            }  
                                 //            else  
                                 //            {  
                                 //                #region 32bits - signed  
                                 //                var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        int value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToInt32(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<int>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            } break;  
                                 //        case SearchDataTypes._64bits:  
                                 //            if (unsigned)  
                                 //            {  
                                 //                #region 64bits - unsigned  
                                 //                var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        ulong value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToUInt64(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<ulong>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            }  
                                 //            else  
                                 //            {  
                                 //                #region 64bits - signed  
                                 //                var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                 //                foreach (var Value in t_data)  
                                 //                {  
                                 //                    if (SearchWorkerThread.CancellationPending) { break; }  
                                 //                    using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))  
                                 //                    {  
                                 //                        long value = 0;  
                                 //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                 //                        {  
                                 //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                 //                            {  
                                 //                                try  
                                 //                                {  
                                 //                                    gmp.OpenProvider();  
                                 //                                    gmp.ReadMemory(address_index, out value);  
                                 //                                    gmp.CloseProvider();  
                                 //                                }  
                                 //                                catch (Exception ex)  
                                 //                                {  
                                 //                                    logger.VerboseError.WriteLine(ex.ToString());  
                                 //                                }  
                                 //                            }  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        else  
                                 //                        {  
                                 //                            value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                 //                            comparer.Value = value;  
                                 //                        }  
                                 //                        if (comparer.Compare(Convert.ToInt64(Value), value))  
                                 //                        {  
                                 //                            writer.WriteResult<long>(comparer.Address, comparer.Value);  
                                 //                        }  
                                 //                    }  
                                 //                    address_index += STEP_SIZE;  
                                 //                }  
                                 //                #endregion  
                                 //            } break;  
                                 //    }  
                                 //    #endregion  
                                 //    index++;  
                                 //}  
1947                                  #endregion                                  #endregion
1948    
1949                                  #region reference-code (can be deleted - later)                                  if (SearchWorkerThread.CancellationPending)
1950                                  //ISerializedResult sr = (reader as ISerializedResult);                                  {
1951                                  //if (sr == null)                                      provider_st.Stop();
1952                                  //{                                      st.Stop();
1953                                  //    throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));                                      writer.CancelRequest();
1954                                  //}                                      writer.Dispose();
1955                                  //int sr_index = 0;                                      e.Result = true;
1956                                  //try                                      provider.CloseProvider();
1957                                  //{                                      return;
1958                                  //    if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))                                  }
                                 //    {  
                                 //        StructResultType<ulong> result = StructResultType<ulong>.Empty;  
                                 //        sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);  
                                 //        if (Debugger.IsAttached)  
                                 //        {  
                                 //            Debugger.Break();  
                                 //        }  
                                 //    }  
                                 //}  
                                 #endregion  
1959                              }                              }
   
1960                          }                          }
1961                            #endregion
1962    
1963                          SearchGuid = new_SearchGuid; // update with out new guid                          SearchGuid = new_SearchGuid; // update with out new guid
1964                            reader_addresses = null; // free memory used by address array
1965                            GC.Collect(); // force gc collection
1966                            #endregion
1967                      }                      }
1968                                                                  
1969                  }                  }
1970                  provider_st.Stop();                  provider_st.Stop();
1971                  logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);                  logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
# Line 2634  namespace RomCheater.Docking Line 2176  namespace RomCheater.Docking
2176                      lstResults.Items.AddRange(items.ToArray());                      lstResults.Items.AddRange(items.ToArray());
2177                  }                  }
2178              }              }
2179              GC.Collect();              GC.Collect(); // force gc collection
2180              this.DoSearchDoneSpecific();              this.DoSearchDoneSpecific();
2181              //System.Threading.Thread.Sleep(100);              //System.Threading.Thread.Sleep(100);
2182              //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)              //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)

Legend:
Removed from v.557  
changed lines
  Added in v.560

  ViewVC Help
Powered by ViewVC 1.1.22