/[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 448 by william, Sun Jun 2 20:22:04 2013 UTC revision 452 by william, Sun Jun 2 22:30:23 2013 UTC
# Line 15  Line 15 
15  #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE  #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
16  #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range  #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
17  #endif  #endif
18  //#define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented  #define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
19  #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8  #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8
20  //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze  //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze
21  using System;  using System;
# Line 57  namespace RomCheater.Docking Line 57  namespace RomCheater.Docking
57          const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results          const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
58  #endif  #endif
59    
60            const bool USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE = false;
61    
62          private bool DefaultUnsignedState = true; // set unsigned to true          private bool DefaultUnsignedState = true; // set unsigned to true
63          public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }          public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
64          public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }          public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
# Line 1186  namespace RomCheater.Docking Line 1188  namespace RomCheater.Docking
1188                              {                              {
1189                                  try                                  try
1190                                  {                                  {
1191                                      for (int i = 0; i < reader.ResultCount; i += 1)                                      #region new comparator-support
1192                                        switch (SearchArgs.DataType)
1193                                      {                                      {
1194                                          object result_value = 0;                                          case SearchDataTypes._8bits:
1195                                          uint address = 0;                                              if (unsigned)
1196                                          #region switch (SearchArgs.DataType)                                              {
1197                                          switch (SearchArgs.DataType)                                                  #region 8bits - unsigned
1198                                          {                                                  var list_results = reader.GetResults<byte>();
1199                                              case SearchDataTypes._8bits: if (unsigned)                                                  foreach (var list_result in list_results)
                                                 {  
                                                     using (ResultType<byte> result = reader.GetNextResult<byte>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 }  
                                                 else  
                                                 {  
                                                     using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 } break;  
                                             case SearchDataTypes._16bits: if (unsigned)  
                                                 {  
                                                     using (ResultType<ushort> result = reader.GetNextResult<ushort>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 }  
                                                 else  
                                                 {  
                                                     using (ResultType<short> result = reader.GetNextResult<short>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 } break;  
                                             case SearchDataTypes._32bits: if (unsigned)  
                                                 {  
                                                     using (ResultType<uint> result = reader.GetNextResult<uint>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 }  
                                                 else  
                                                 {  
                                                     using (ResultType<int> result = reader.GetNextResult<int>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 } break;  
                                             case SearchDataTypes._64bits: if (unsigned)  
                                                 {  
                                                     using (ResultType<ulong> result = reader.GetNextResult<ulong>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 }  
                                                 else  
                                                 {  
                                                     using (ResultType<long> result = reader.GetNextResult<long>())  
                                                     {  
                                                         address = result.Address;  
                                                         result_value = result.Value;  
                                                     }  
                                                 } break;  
                                         }  
                                         #endregion  
                                         if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                                         try  
                                         {  
                                             //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                                         }  
                                         catch (Exception)  
                                         {  
                                             throw;  
                                         }  
                                         switch (SearchArgs.DataType)  
                                         {  
                                             #region Comparer Support  
                                             #region case SearchDataTypes._8bits:  
                                             case SearchDataTypes._8bits:  
                                                 if (SearchArgs.IsUnsignedDataType)  
1200                                                  {                                                  {
1201                                                      byte lookup_value = 0;                                                      using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToByte(result_value);  
                                                     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))  
1202                                                      {                                                      {
1203                                                          byte value = 0;                                                          byte value = 0;
1204                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1288  namespace RomCheater.Docking Line 1208  namespace RomCheater.Docking
1208                                                                  try                                                                  try
1209                                                                  {                                                                  {
1210                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1211                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1212                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1213                                                                  }                                                                  }
1214                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1303  namespace RomCheater.Docking Line 1223  namespace RomCheater.Docking
1223                                                              value = Convert.ToByte(SearchArgs.CompareStartValue);                                                              value = Convert.ToByte(SearchArgs.CompareStartValue);
1224                                                              comparer.Value = value;                                                              comparer.Value = value;
1225                                                          }                                                          }
1226                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1227                                                          {                                                          {
1228                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1229                                                          }                                                          }
1230                                                      }                                                      }
1231                                                  }                                                  }
1232                                                  else                                                  #endregion
1233                                                }
1234                                                else
1235                                                {
1236                                                    #region 8bits - signed
1237                                                    var list_results = reader.GetResults<sbyte>();
1238                                                    foreach (var list_result in list_results)
1239                                                  {                                                  {
1240                                                      sbyte lookup_value = 0;                                                      using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToSByte(result_value);  
                                                     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address))  
1241                                                      {                                                      {
1242                                                          sbyte value = 0;                                                          sbyte value = 0;
1243                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1324  namespace RomCheater.Docking Line 1247  namespace RomCheater.Docking
1247                                                                  try                                                                  try
1248                                                                  {                                                                  {
1249                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1250                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1251                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1252                                                                  }                                                                  }
1253                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1337  namespace RomCheater.Docking Line 1260  namespace RomCheater.Docking
1260                                                          else                                                          else
1261                                                          {                                                          {
1262                                                              value = Convert.ToSByte(SearchArgs.CompareStartValue);                                                              value = Convert.ToSByte(SearchArgs.CompareStartValue);
1263                                                                comparer.Value = value;
1264                                                          }                                                          }
1265                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1266                                                          {                                                          {
1267                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1268                                                          }                                                          }
1269                                                      }                                                      }
1270                                                  }                                                  }
1271                                                  break;                                                  #endregion
1272                                              #endregion                                              }
1273                                              #region case SearchDataTypes._16bits:                                              break;
1274                                              case SearchDataTypes._16bits:                                          case SearchDataTypes._16bits:
1275                                                  if (SearchArgs.IsUnsignedDataType)                                              if (unsigned)
1276                                                {
1277                                                    #region 16bits - unsigned
1278                                                    var list_results = reader.GetResults<ushort>();
1279                                                    foreach (var list_result in list_results)
1280                                                  {                                                  {
1281                                                      ushort lookup_value = 0;                                                      using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToUInt16(result_value);  
                                                     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address))  
1282                                                      {                                                      {
1283                                                          ushort value = 0;                                                          ushort value = 0;
1284                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1363  namespace RomCheater.Docking Line 1288  namespace RomCheater.Docking
1288                                                                  try                                                                  try
1289                                                                  {                                                                  {
1290                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1291                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1292                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1293                                                                  }                                                                  }
1294                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1378  namespace RomCheater.Docking Line 1303  namespace RomCheater.Docking
1303                                                              value = Convert.ToUInt16(SearchArgs.CompareStartValue);                                                              value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1304                                                              comparer.Value = value;                                                              comparer.Value = value;
1305                                                          }                                                          }
1306                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1307                                                          {                                                          {
1308                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1309                                                          }                                                          }
1310                                                      }                                                      }
1311                                                  }                                                  }
1312                                                  else                                                  #endregion
1313                                                }
1314                                                else
1315                                                {
1316                                                    #region 16bits - signed
1317                                                    var list_results = reader.GetResults<short>();
1318                                                    foreach (var list_result in list_results)
1319                                                  {                                                  {
1320                                                      short lookup_value = 0;                                                      using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToInt16(result_value);  
                                                     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address))  
1321                                                      {                                                      {
1322                                                          short value = 0;                                                          short value = 0;
1323                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1399  namespace RomCheater.Docking Line 1327  namespace RomCheater.Docking
1327                                                                  try                                                                  try
1328                                                                  {                                                                  {
1329                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1330                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1331                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1332                                                                  }                                                                  }
1333                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1412  namespace RomCheater.Docking Line 1340  namespace RomCheater.Docking
1340                                                          else                                                          else
1341                                                          {                                                          {
1342                                                              value = Convert.ToInt16(SearchArgs.CompareStartValue);                                                              value = Convert.ToInt16(SearchArgs.CompareStartValue);
1343                                                                comparer.Value = value;
1344                                                          }                                                          }
1345                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1346                                                          {                                                          {
1347                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1348                                                          }                                                          }
1349                                                      }                                                      }
1350                                                  }                                                  }
1351                                                  break;                                                  #endregion
1352                                              #endregion                                              }
1353                                              #region case SearchDataTypes._32bits:                                              break;
1354                                              case SearchDataTypes._32bits:                                          case SearchDataTypes._32bits:
1355                                                  if (SearchArgs.IsUnsignedDataType)                                              if (unsigned)
1356                                                {
1357                                                    #region 32bits - unsigned
1358                                                    var list_results = reader.GetResults<uint>();
1359                                                    foreach (var list_result in list_results)
1360                                                  {                                                  {
1361                                                      uint lookup_value = 0;                                                      using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToUInt32(result_value);                                                      
                                                     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address))  
1362                                                      {                                                      {
1363                                                          uint value = 0;                                                          uint value = 0;
1364                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1438  namespace RomCheater.Docking Line 1368  namespace RomCheater.Docking
1368                                                                  try                                                                  try
1369                                                                  {                                                                  {
1370                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1371                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1372                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1373                                                                  }                                                                  }
1374                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1453  namespace RomCheater.Docking Line 1383  namespace RomCheater.Docking
1383                                                              value = Convert.ToUInt32(SearchArgs.CompareStartValue);                                                              value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1384                                                              comparer.Value = value;                                                              comparer.Value = value;
1385                                                          }                                                          }
1386                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1387                                                          {                                                          {
1388                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1389                                                          }                                                          }
1390                                                      }                                                      }
1391                                                  }                                                  }
1392                                                  else                                                  #endregion
1393                                                }
1394                                                else
1395                                                {
1396                                                    #region 32bits - signed
1397                                                    var list_results = reader.GetResults<int>();
1398                                                    foreach (var list_result in list_results)
1399                                                  {                                                  {
1400                                                      int lookup_value = 0;                                                      using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToInt32(result_value);  
                                                     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address))  
1401                                                      {                                                      {
1402                                                          int value = 0;                                                          int value = 0;
1403                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1474  namespace RomCheater.Docking Line 1407  namespace RomCheater.Docking
1407                                                                  try                                                                  try
1408                                                                  {                                                                  {
1409                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1410                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1411                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1412                                                                  }                                                                  }
1413                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1487  namespace RomCheater.Docking Line 1420  namespace RomCheater.Docking
1420                                                          else                                                          else
1421                                                          {                                                          {
1422                                                              value = Convert.ToInt32(SearchArgs.CompareStartValue);                                                              value = Convert.ToInt32(SearchArgs.CompareStartValue);
1423                                                                comparer.Value = value;
1424                                                          }                                                          }
1425                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1426                                                          {                                                          {
1427                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1428                                                          }                                                          }
1429                                                      }                                                      }
1430                                                  }                                                  }
1431                                                  break;                                                  #endregion
1432                                              #endregion                                              }
1433                                              #region case SearchDataTypes._64bits:                                              break;
1434                                              case SearchDataTypes._64bits:                                          case SearchDataTypes._64bits:
1435                                                  if (SearchArgs.IsUnsignedDataType)                                              if (unsigned)
1436                                                {
1437                                                    #region 64bits - unsigned
1438                                                    var list_results = reader.GetResults<ulong>();
1439                                                    foreach (var list_result in list_results)
1440                                                  {                                                  {
1441                                                      ulong lookup_value = 0;                                                      using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToUInt64(result_value);  
                                                     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address))  
1442                                                      {                                                      {
1443                                                          ulong value = 0;                                                          ulong value = 0;
1444                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1513  namespace RomCheater.Docking Line 1448  namespace RomCheater.Docking
1448                                                                  try                                                                  try
1449                                                                  {                                                                  {
1450                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1451                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1452                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1453                                                                  }                                                                  }
1454                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1528  namespace RomCheater.Docking Line 1463  namespace RomCheater.Docking
1463                                                              value = Convert.ToUInt64(SearchArgs.CompareStartValue);                                                              value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1464                                                              comparer.Value = value;                                                              comparer.Value = value;
1465                                                          }                                                          }
1466                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1467                                                          {                                                          {
1468                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1469                                                          }                                                          }
1470                                                      }                                                      }
1471                                                  }                                                  }
1472                                                  else                                                  #endregion
1473                                                }
1474                                                else
1475                                                {
1476                                                    #region 64bits - signed
1477                                                    var list_results = reader.GetResults<long>();
1478                                                    foreach (var list_result in list_results)
1479                                                  {                                                  {
1480                                                      long lookup_value = 0;                                                      using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, list_result.Address))
                                                     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }  
                                                     lookup_value = Convert.ToInt64(result_value);  
                                                     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address))  
1481                                                      {                                                      {
1482                                                          long value = 0;                                                          long value = 0;
1483                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                                          if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
# Line 1549  namespace RomCheater.Docking Line 1487  namespace RomCheater.Docking
1487                                                                  try                                                                  try
1488                                                                  {                                                                  {
1489                                                                      gmp.OpenProvider();                                                                      gmp.OpenProvider();
1490                                                                      gmp.ReadMemory(address, out value);                                                                      gmp.ReadMemory(list_result.Address, out value);
1491                                                                      gmp.CloseProvider();                                                                      gmp.CloseProvider();
1492                                                                  }                                                                  }
1493                                                                  catch (Exception ex)                                                                  catch (Exception ex)
# Line 1562  namespace RomCheater.Docking Line 1500  namespace RomCheater.Docking
1500                                                          else                                                          else
1501                                                          {                                                          {
1502                                                              value = Convert.ToInt64(SearchArgs.CompareStartValue);                                                              value = Convert.ToInt64(SearchArgs.CompareStartValue);
1503                                                                comparer.Value = value;
1504                                                          }                                                          }
1505                                                          if (comparer.Compare(lookup_value, value))                                                          if (comparer.Compare(list_result.Value, value))
1506                                                          {                                                          {
1507                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));                                                              second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1508                                                          }                                                          }
1509                                                      }                                                      }
1510                                                  }                                                  }
1511                                                  break;                                                  #endregion
1512                                              #endregion                                              }
1513                                              #endregion                                              break;
1514                                          }                                      }
1515                                          double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);                                      #endregion
1516                                          int int_percent_done = (int)double_percent_done;  
1517                                          if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)                                      #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE
1518                                        if (USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE)
1519                                        {
1520                                            for (int i = 0; i < reader.ResultCount; i += 1)
1521                                          {                                          {
1522                                                object result_value = 0;
1523                                                uint address = 0;
1524                                                #region switch (SearchArgs.DataType)
1525                                                switch (SearchArgs.DataType)
1526                                                {
1527                                                    case SearchDataTypes._8bits: if (unsigned)
1528                                                        {
1529                                                            using (ResultType<byte> result = reader.GetNextResult<byte>())
1530                                                            {
1531                                                                address = result.Address;
1532                                                                result_value = result.Value;
1533                                                            }
1534                                                        }
1535                                                        else
1536                                                        {
1537                                                            using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
1538                                                            {
1539                                                                address = result.Address;
1540                                                                result_value = result.Value;
1541                                                            }
1542                                                        } break;
1543                                                    case SearchDataTypes._16bits: if (unsigned)
1544                                                        {
1545                                                            using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1546                                                            {
1547                                                                address = result.Address;
1548                                                                result_value = result.Value;
1549                                                            }
1550                                                        }
1551                                                        else
1552                                                        {
1553                                                            using (ResultType<short> result = reader.GetNextResult<short>())
1554                                                            {
1555                                                                address = result.Address;
1556                                                                result_value = result.Value;
1557                                                            }
1558                                                        } break;
1559                                                    case SearchDataTypes._32bits: if (unsigned)
1560                                                        {
1561                                                            using (ResultType<uint> result = reader.GetNextResult<uint>())
1562                                                            {
1563                                                                address = result.Address;
1564                                                                result_value = result.Value;
1565                                                            }
1566                                                        }
1567                                                        else
1568                                                        {
1569                                                            using (ResultType<int> result = reader.GetNextResult<int>())
1570                                                            {
1571                                                                address = result.Address;
1572                                                                result_value = result.Value;
1573                                                            }
1574                                                        } break;
1575                                                    case SearchDataTypes._64bits: if (unsigned)
1576                                                        {
1577                                                            using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1578                                                            {
1579                                                                address = result.Address;
1580                                                                result_value = result.Value;
1581                                                            }
1582                                                        }
1583                                                        else
1584                                                        {
1585                                                            using (ResultType<long> result = reader.GetNextResult<long>())
1586                                                            {
1587                                                                address = result.Address;
1588                                                                result_value = result.Value;
1589                                                            }
1590                                                        } break;
1591                                                }
1592                                                #endregion
1593                                                if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1594                                                try
1595                                                {
1596                                                    //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1597                                                }
1598                                                catch (Exception)
1599                                                {
1600                                                    throw;
1601                                                }
1602                                                switch (SearchArgs.DataType)
1603                                                {
1604                                                    #region Comparer Support
1605                                                    #region case SearchDataTypes._8bits:
1606                                                    case SearchDataTypes._8bits:
1607                                                        if (SearchArgs.IsUnsignedDataType)
1608                                                        {
1609                                                            byte lookup_value = 0;
1610                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1611                                                            lookup_value = Convert.ToByte(result_value);
1612                                                            using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))
1613                                                            {
1614                                                                byte value = 0;
1615                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1616                                                                {
1617                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1618                                                                    {
1619                                                                        try
1620                                                                        {
1621                                                                            gmp.OpenProvider();
1622                                                                            gmp.ReadMemory(address, out value);
1623                                                                            gmp.CloseProvider();
1624                                                                        }
1625                                                                        catch (Exception ex)
1626                                                                        {
1627                                                                            logger.VerboseError.WriteLine(ex.ToString());
1628                                                                        }
1629                                                                    }
1630                                                                    comparer.Value = value;
1631                                                                }
1632                                                                else
1633                                                                {
1634                                                                    value = Convert.ToByte(SearchArgs.CompareStartValue);
1635                                                                    comparer.Value = value;
1636                                                                }
1637                                                                if (comparer.Compare(lookup_value, value))
1638                                                                {
1639                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1640                                                                }
1641                                                            }
1642                                                        }
1643                                                        else
1644                                                        {
1645                                                            sbyte lookup_value = 0;
1646                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1647                                                            lookup_value = Convert.ToSByte(result_value);
1648                                                            using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address))
1649                                                            {
1650                                                                sbyte value = 0;
1651                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1652                                                                {
1653                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1654                                                                    {
1655                                                                        try
1656                                                                        {
1657                                                                            gmp.OpenProvider();
1658                                                                            gmp.ReadMemory(address, out value);
1659                                                                            gmp.CloseProvider();
1660                                                                        }
1661                                                                        catch (Exception ex)
1662                                                                        {
1663                                                                            logger.VerboseError.WriteLine(ex.ToString());
1664                                                                        }
1665                                                                    }
1666                                                                    comparer.Value = value;
1667                                                                }
1668                                                                else
1669                                                                {
1670                                                                    value = Convert.ToSByte(SearchArgs.CompareStartValue);
1671                                                                }
1672                                                                if (comparer.Compare(lookup_value, value))
1673                                                                {
1674                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1675                                                                }
1676                                                            }
1677                                                        }
1678                                                        break;
1679                                                    #endregion
1680                                                    #region case SearchDataTypes._16bits:
1681                                                    case SearchDataTypes._16bits:
1682                                                        if (SearchArgs.IsUnsignedDataType)
1683                                                        {
1684                                                            ushort lookup_value = 0;
1685                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1686                                                            lookup_value = Convert.ToUInt16(result_value);
1687                                                            using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address))
1688                                                            {
1689                                                                ushort value = 0;
1690                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1691                                                                {
1692                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1693                                                                    {
1694                                                                        try
1695                                                                        {
1696                                                                            gmp.OpenProvider();
1697                                                                            gmp.ReadMemory(address, out value);
1698                                                                            gmp.CloseProvider();
1699                                                                        }
1700                                                                        catch (Exception ex)
1701                                                                        {
1702                                                                            logger.VerboseError.WriteLine(ex.ToString());
1703                                                                        }
1704                                                                    }
1705                                                                    comparer.Value = value;
1706                                                                }
1707                                                                else
1708                                                                {
1709                                                                    value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1710                                                                    comparer.Value = value;
1711                                                                }
1712                                                                if (comparer.Compare(lookup_value, value))
1713                                                                {
1714                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1715                                                                }
1716                                                            }
1717                                                        }
1718                                                        else
1719                                                        {
1720                                                            short lookup_value = 0;
1721                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1722                                                            lookup_value = Convert.ToInt16(result_value);
1723                                                            using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address))
1724                                                            {
1725                                                                short value = 0;
1726                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1727                                                                {
1728                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1729                                                                    {
1730                                                                        try
1731                                                                        {
1732                                                                            gmp.OpenProvider();
1733                                                                            gmp.ReadMemory(address, out value);
1734                                                                            gmp.CloseProvider();
1735                                                                        }
1736                                                                        catch (Exception ex)
1737                                                                        {
1738                                                                            logger.VerboseError.WriteLine(ex.ToString());
1739                                                                        }
1740                                                                    }
1741                                                                    comparer.Value = value;
1742                                                                }
1743                                                                else
1744                                                                {
1745                                                                    value = Convert.ToInt16(SearchArgs.CompareStartValue);
1746                                                                }
1747                                                                if (comparer.Compare(lookup_value, value))
1748                                                                {
1749                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1750                                                                }
1751                                                            }
1752                                                        }
1753                                                        break;
1754                                                    #endregion
1755                                                    #region case SearchDataTypes._32bits:
1756                                                    case SearchDataTypes._32bits:
1757                                                        if (SearchArgs.IsUnsignedDataType)
1758                                                        {
1759                                                            uint lookup_value = 0;
1760                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1761                                                            lookup_value = Convert.ToUInt32(result_value);
1762                                                            using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address))
1763                                                            {
1764                                                                uint value = 0;
1765                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1766                                                                {
1767                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1768                                                                    {
1769                                                                        try
1770                                                                        {
1771                                                                            gmp.OpenProvider();
1772                                                                            gmp.ReadMemory(address, out value);
1773                                                                            gmp.CloseProvider();
1774                                                                        }
1775                                                                        catch (Exception ex)
1776                                                                        {
1777                                                                            logger.VerboseError.WriteLine(ex.ToString());
1778                                                                        }
1779                                                                    }
1780                                                                    comparer.Value = value;
1781                                                                }
1782                                                                else
1783                                                                {
1784                                                                    value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1785                                                                    comparer.Value = value;
1786                                                                }
1787                                                                if (comparer.Compare(lookup_value, value))
1788                                                                {
1789                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1790                                                                }
1791                                                            }
1792                                                        }
1793                                                        else
1794                                                        {
1795                                                            int lookup_value = 0;
1796                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1797                                                            lookup_value = Convert.ToInt32(result_value);
1798                                                            using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address))
1799                                                            {
1800                                                                int value = 0;
1801                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1802                                                                {
1803                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1804                                                                    {
1805                                                                        try
1806                                                                        {
1807                                                                            gmp.OpenProvider();
1808                                                                            gmp.ReadMemory(address, out value);
1809                                                                            gmp.CloseProvider();
1810                                                                        }
1811                                                                        catch (Exception ex)
1812                                                                        {
1813                                                                            logger.VerboseError.WriteLine(ex.ToString());
1814                                                                        }
1815                                                                    }
1816                                                                    comparer.Value = value;
1817                                                                }
1818                                                                else
1819                                                                {
1820                                                                    value = Convert.ToInt32(SearchArgs.CompareStartValue);
1821                                                                }
1822                                                                if (comparer.Compare(lookup_value, value))
1823                                                                {
1824                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1825                                                                }
1826                                                            }
1827                                                        }
1828                                                        break;
1829                                                    #endregion
1830                                                    #region case SearchDataTypes._64bits:
1831                                                    case SearchDataTypes._64bits:
1832                                                        if (SearchArgs.IsUnsignedDataType)
1833                                                        {
1834                                                            ulong lookup_value = 0;
1835                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1836                                                            lookup_value = Convert.ToUInt64(result_value);
1837                                                            using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address))
1838                                                            {
1839                                                                ulong value = 0;
1840                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1841                                                                {
1842                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1843                                                                    {
1844                                                                        try
1845                                                                        {
1846                                                                            gmp.OpenProvider();
1847                                                                            gmp.ReadMemory(address, out value);
1848                                                                            gmp.CloseProvider();
1849                                                                        }
1850                                                                        catch (Exception ex)
1851                                                                        {
1852                                                                            logger.VerboseError.WriteLine(ex.ToString());
1853                                                                        }
1854                                                                    }
1855                                                                    comparer.Value = value;
1856                                                                }
1857                                                                else
1858                                                                {
1859                                                                    value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1860                                                                    comparer.Value = value;
1861                                                                }
1862                                                                if (comparer.Compare(lookup_value, value))
1863                                                                {
1864                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1865                                                                }
1866                                                            }
1867                                                        }
1868                                                        else
1869                                                        {
1870                                                            long lookup_value = 0;
1871                                                            //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1872                                                            lookup_value = Convert.ToInt64(result_value);
1873                                                            using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address))
1874                                                            {
1875                                                                long value = 0;
1876                                                                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1877                                                                {
1878                                                                    using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1879                                                                    {
1880                                                                        try
1881                                                                        {
1882                                                                            gmp.OpenProvider();
1883                                                                            gmp.ReadMemory(address, out value);
1884                                                                            gmp.CloseProvider();
1885                                                                        }
1886                                                                        catch (Exception ex)
1887                                                                        {
1888                                                                            logger.VerboseError.WriteLine(ex.ToString());
1889                                                                        }
1890                                                                    }
1891                                                                    comparer.Value = value;
1892                                                                }
1893                                                                else
1894                                                                {
1895                                                                    value = Convert.ToInt64(SearchArgs.CompareStartValue);
1896                                                                }
1897                                                                if (comparer.Compare(lookup_value, value))
1898                                                                {
1899                                                                    second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1900                                                                }
1901                                                            }
1902                                                        }
1903                                                        break;
1904                                                    #endregion
1905                                                    #endregion
1906                                                }
1907                                                double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1908                                                int int_percent_done = (int)double_percent_done;
1909                                                //if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)
1910                                                //{
1911                                              if (int_percent_done <= 100)                                              if (int_percent_done <= 100)
1912                                              {                                              {
1913                                                  resultsprogress.Value = int_percent_done;                                                  resultsprogress.Value = int_percent_done;
1914                                                  resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);                                                  resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1915                                                  Last_Whole_Percent_Done = int_percent_done;                                                  //Last_Whole_Percent_Done = int_percent_done;
1916                                              }                                              }
1917                                                //}
1918                                                //this.Refresh();
1919                                          }                                          }
1920                                      }                                      }
1921                                        #endregion
1922                                  }                                  }
1923                                  catch (Exception ex)                                  catch (Exception ex)
1924                                  {                                  {

Legend:
Removed from v.448  
changed lines
  Added in v.452

  ViewVC Help
Powered by ViewVC 1.1.22