/[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 401 by william, Thu Jun 21 05:14:38 2012 UTC revision 402 by william, Thu Jun 21 06:30:33 2012 UTC
# Line 1036  namespace RomCheater.Docking Line 1036  namespace RomCheater.Docking
1036              e.Result = st;              e.Result = st;
1037              //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();              //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1038              List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();              List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
1039              const int ElementsBeforeDisplay = 100;              //const int ElementsBeforeDisplay = 100;
1040              SearchArgs.LogSearchOptions();              SearchArgs.LogSearchOptions();
1041              uint STEP_SIZE = (uint)SearchArgs.DataType / 8;              uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1042    
# Line 1130  namespace RomCheater.Docking Line 1130  namespace RomCheater.Docking
1130                          SearchArgs.IsFirstSearch)                          SearchArgs.IsFirstSearch)
1131                      {                      {
1132                          NeedToCompare = false;                          NeedToCompare = false;
1133                          second_tmp_Results = null; // Free Memory                          //second_tmp_Results = null; // Free Memory
1134                      }                      }
1135    
1136                      if (NeedToCompare)                      if (NeedToCompare)
# Line 1141  namespace RomCheater.Docking Line 1141  namespace RomCheater.Docking
1141                              st_nonrange_search.Start();                              st_nonrange_search.Start();
1142                              //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);                              //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1143                              ////second_tmp_Results.c                              ////second_tmp_Results.c
1144                              for (int i = 0; i < SearchArgs.Results.Count; i += 1)  
1145                                using (SearchResultReader reader = new SearchResultReader())
1146                              {                              {
1147                                  uint address = SearchArgs.Results[i].Address;                                  for (int i = 0; i < reader.ResultCount; i += 1)
                                 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                                 r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                                 switch (SearchArgs.DataType)  
1148                                  {                                  {
1149                                      #region Comparer Support                                      uint address = reader.CurrentAddress();
1150                                      #region case SearchDataTypes._8bits:                                      if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1151                                      case SearchDataTypes._8bits:                                      r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1152                                          if (SearchArgs.IsUnsignedDataType)                                      switch (SearchArgs.DataType)
1153                                          {                                      {
1154                                              byte lookup_value = r_ms.ReadByte();                                          #region Comparer Support
1155                                              _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);                                          #region case SearchDataTypes._8bits:
1156                                              byte value = 0;                                          case SearchDataTypes._8bits:
1157                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                              if (SearchArgs.IsUnsignedDataType)
1158                                              {                                              {
1159                                                  value = Convert.ToByte(SearchArgs.Results[i].Value);                                                  byte lookup_value = r_ms.ReadByte();
1160                                                  comparer.Value = value;                                                  _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);
1161                                              }                                                  byte value = 0;
1162                                              else                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1163                                              {                                                  {
1164                                                  value = Convert.ToByte(SearchArgs.CompareStartValue);                                                      value = reader.CurrentResult<byte>();
1165                                                  comparer.Value = value;                                                      comparer.Value = value;
1166                                              }                                                  }
1167                                              if (comparer.Compare(lookup_value, value))                                                  else
1168                                              {                                                  {
1169                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                          value = Convert.ToByte(SearchArgs.CompareStartValue);
1170                                                  //second_tmp_Results.Add(_tmp_result);                                                      comparer.Value = value;
1171                                                  //_tmp_result = null; // free memory                                                  }
1172                                                  //SearchArgs.Results.RemoveAt(i);                                                  if (comparer.Compare(lookup_value, value))
1173                                                  SearchArgs.Results[i].Value = comparer.Value;                                                  {
1174                                                  second_tmp_Results.Add(SearchArgs.Results[i]);                                                      ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1175                                              }                                                      second_tmp_Results.Add(_tmp_result);
1176                                              comparer = null; // free memory                                                  }
1177                                          }                                                  comparer = null; // free memory
                                         else  
                                         {  
                                             sbyte lookup_value = r_ms.ReadSByte();  
                                             _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);  
                                             sbyte value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToSByte(SearchArgs.Results[i].Value);  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                                 //second_tmp_Results.Add(_tmp_result);  
                                                 //_tmp_result = null; // free memory  
                                                 //SearchArgs.Results.RemoveAt(i);  
                                                 SearchArgs.Results[i].Value = comparer.Value;  
                                                 second_tmp_Results.Add(SearchArgs.Results[i]);  
                                             }  
                                             comparer = null; // free memory  
                                         }  
                                         break;  
                                     #endregion  
                                     #region case SearchDataTypes._16bits:  
                                     case SearchDataTypes._16bits:  
                                         if (SearchArgs.IsUnsignedDataType)  
                                         {  
                                             ushort lookup_value = r_ms.ReadUInt16();  
                                             _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);  
                                             ushort value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToUInt16(SearchArgs.Results[i].Value);  
                                                 comparer.Value = value;  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                 comparer.Value = value;  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                                 //second_tmp_Results.Add(_tmp_result);  
                                                 //_tmp_result = null; // free memory  
                                                 //SearchArgs.Results.RemoveAt(i);  
                                                 SearchArgs.Results[i].Value = comparer.Value;  
                                                 second_tmp_Results.Add(SearchArgs.Results[i]);  
                                             }  
                                             comparer = null; // free memory  
                                         }  
                                         else  
                                         {  
                                             short lookup_value = r_ms.ReadInt16();  
                                             _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);  
                                             short value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToInt16(SearchArgs.Results[i].Value);  
                                             }  
                                             else  
                                             {  
                                                 value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                             }  
                                             if (comparer.Compare(lookup_value, value))  
                                             {  
                                                 //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                      
                                                 //second_tmp_Results.Add(_tmp_result);  
                                                 //_tmp_result = null; // free memory  
                                                 //SearchArgs.Results.RemoveAt(i);  
                                                 SearchArgs.Results[i].Value = comparer.Value;  
                                                 second_tmp_Results.Add(SearchArgs.Results[i]);  
                                             }  
                                             comparer = null; // free memory  
                                         }  
                                         break;  
                                     #endregion  
                                     #region case SearchDataTypes._32bits:  
                                     case SearchDataTypes._32bits:  
                                         if (SearchArgs.IsUnsignedDataType)  
                                         {  
                                             uint lookup_value = r_ms.ReadUInt32();  
                                             _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);  
                                             uint value = 0;  
                                             if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                             {  
                                                 value = Convert.ToUInt32(SearchArgs.Results[i].Value);  
                                                 comparer.Value = value;  
1178                                              }                                              }
1179                                              else                                              else
1180                                              {                                              {
1181                                                  value = Convert.ToUInt32(SearchArgs.CompareStartValue);                                                  sbyte lookup_value = r_ms.ReadSByte();
1182                                                  comparer.Value = value;                                                  _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);
1183                                              }                                                  sbyte value = 0;
1184                                              if (comparer.Compare(lookup_value, value))                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1185                                              {                                                  {
1186                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                          value = reader.CurrentResult<sbyte>();
1187                                                  //second_tmp_Results.Add(_tmp_result);                                                  }
1188                                                  //_tmp_result = null; // free memory                                                  else
1189                                                  //SearchArgs.Results.RemoveAt(i);                                                  {
1190                                                  SearchArgs.Results[i].Value = comparer.Value;                                                      value = Convert.ToSByte(SearchArgs.CompareStartValue);
1191                                                  second_tmp_Results.Add(SearchArgs.Results[i]);                                                  }
1192                                              }                                                  if (comparer.Compare(lookup_value, value))
1193                                              comparer = null; // free memory                                                  {
1194                                          }                                                      ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1195                                          else                                                      second_tmp_Results.Add(_tmp_result);
1196                                          {                                                  }
1197                                              int lookup_value = r_ms.ReadInt32();                                                  comparer = null; // free memory
1198                                              _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);                                              }
1199                                              int value = 0;                                              break;
1200                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                          #endregion
1201                                              {                                          #region case SearchDataTypes._16bits:
1202                                                  value = Convert.ToInt32(SearchArgs.Results[i].Value);                                          case SearchDataTypes._16bits:
1203                                                if (SearchArgs.IsUnsignedDataType)
1204                                                {
1205                                                    ushort lookup_value = r_ms.ReadUInt16();
1206                                                    _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);
1207                                                    ushort value = 0;
1208                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1209                                                    {
1210                                                        value = reader.CurrentResult<ushort>();
1211                                                        comparer.Value = value;
1212                                                    }
1213                                                    else
1214                                                    {
1215                                                        value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1216                                                        comparer.Value = value;
1217                                                    }
1218                                                    if (comparer.Compare(lookup_value, value))
1219                                                    {
1220                                                        ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1221                                                        second_tmp_Results.Add(_tmp_result);
1222                                                    }
1223                                                    comparer = null; // free memory
1224                                              }                                              }
1225                                              else                                              else
1226                                              {                                              {
1227                                                  value = Convert.ToInt32(SearchArgs.CompareStartValue);                                                  short lookup_value = r_ms.ReadInt16();
1228                                              }                                                  _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);
1229                                              if (comparer.Compare(lookup_value, value))                                                  short value = 0;
1230                                              {                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1231                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                      {
1232                                                  //second_tmp_Results.Add(_tmp_result);                                                      value = reader.CurrentResult<short>();
1233                                                  //_tmp_result = null; // free memory                                                  }
1234                                                  //SearchArgs.Results.RemoveAt(i);                                                  else
1235                                                  SearchArgs.Results[i].Value = comparer.Value;                                                  {
1236                                                  second_tmp_Results.Add(SearchArgs.Results[i]);                                                      value = Convert.ToInt16(SearchArgs.CompareStartValue);
1237                                              }                                                  }
1238                                              comparer = null; // free memory                                                  if (comparer.Compare(lookup_value, value))
1239                                          }                                                  {
1240                                          break;                                                      ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1241                                      #endregion                                                      second_tmp_Results.Add(_tmp_result);
1242                                      #region case SearchDataTypes._64bits:                                                  }
1243                                      case SearchDataTypes._64bits:                                                  comparer = null; // free memory
1244                                          if (SearchArgs.IsUnsignedDataType)                                              }
1245                                          {                                              break;
1246                                              ulong lookup_value = r_ms.ReadUInt64();                                          #endregion
1247                                              _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);                                          #region case SearchDataTypes._32bits:
1248                                              ulong value = 0;                                          case SearchDataTypes._32bits:
1249                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                              if (SearchArgs.IsUnsignedDataType)
1250                                              {                                              {
1251                                                  value = Convert.ToUInt64(SearchArgs.Results[i].Value);                                                  uint lookup_value = reader.CurrentResult<uint>();
1252                                                  comparer.Value = value;                                                  _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);
1253                                                    uint value = 0;
1254                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1255                                                    {
1256                                                        value = reader.CurrentResult<uint>();
1257                                                        comparer.Value = value;
1258                                                    }
1259                                                    else
1260                                                    {
1261                                                        value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1262                                                        comparer.Value = value;
1263                                                    }
1264                                                    if (comparer.Compare(lookup_value, value))
1265                                                    {
1266                                                        ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1267                                                        second_tmp_Results.Add(_tmp_result);
1268                                                    }
1269                                                    comparer = null; // free memory
1270                                              }                                              }
1271                                              else                                              else
1272                                              {                                              {
1273                                                  value = Convert.ToUInt64(SearchArgs.CompareStartValue);                                                  int lookup_value = r_ms.ReadInt32();
1274                                                  comparer.Value = value;                                                  _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);
1275                                              }                                                  int value = 0;
1276                                              if (comparer.Compare(lookup_value, value))                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1277                                              {                                                  {
1278                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                          value = reader.CurrentResult<int>();
1279                                                  //second_tmp_Results.Add(_tmp_result);                                                  }
1280                                                  //_tmp_result = null; // free memory                                                  else
1281                                                  //SearchArgs.Results.RemoveAt(i);                                                  {
1282                                                  SearchArgs.Results[i].Value = comparer.Value;                                                      value = Convert.ToInt32(SearchArgs.CompareStartValue);
1283                                                  second_tmp_Results.Add(SearchArgs.Results[i]);                                                  }
1284                                              }                                                  if (comparer.Compare(lookup_value, value))
1285                                              comparer = null; // free memory                                                  {
1286                                          }                                                      ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1287                                          else                                                      second_tmp_Results.Add(_tmp_result);
1288                                          {                                                  }
1289                                              long lookup_value = r_ms.ReadInt64();                                                  comparer = null; // free memory
1290                                              _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);                                              }
1291                                              long value = 0;                                              break;
1292                                              if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)                                          #endregion
1293                                              {                                          #region case SearchDataTypes._64bits:
1294                                                  value = Convert.ToInt64(SearchArgs.Results[i].Value);                                          case SearchDataTypes._64bits:
1295                                                if (SearchArgs.IsUnsignedDataType)
1296                                                {
1297                                                    ulong lookup_value = r_ms.ReadUInt64();
1298                                                    _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);
1299                                                    ulong value = 0;
1300                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1301                                                    {
1302                                                        value = reader.CurrentResult<ulong>();
1303                                                        comparer.Value = value;
1304                                                    }
1305                                                    else
1306                                                    {
1307                                                        value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1308                                                        comparer.Value = value;
1309                                                    }
1310                                                    if (comparer.Compare(lookup_value, value))
1311                                                    {
1312                                                        ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1313                                                        second_tmp_Results.Add(_tmp_result);
1314                                                    }
1315                                                    comparer = null; // free memory
1316                                              }                                              }
1317                                              else                                              else
1318                                              {                                              {
1319                                                  value = Convert.ToInt64(SearchArgs.CompareStartValue);                                                  long lookup_value = r_ms.ReadInt64();
1320                                              }                                                  _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);
1321                                              if (comparer.Compare(lookup_value, value))                                                  long value = 0;
1322                                              {                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1323                                                  //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                                                                      {
1324                                                  //second_tmp_Results.Add(_tmp_result);                                                      value = reader.CurrentResult<long>();
1325                                                  //_tmp_result = null; // free memory                                                  }
1326                                                  //SearchArgs.Results.RemoveAt(i);                                                  else
1327                                                  SearchArgs.Results[i].Value = comparer.Value;                                                  {
1328                                                  second_tmp_Results.Add(SearchArgs.Results[i]);                                                      value = Convert.ToInt64(SearchArgs.CompareStartValue);
1329                                              }                                                  }
1330                                              comparer = null; // free memory                                                  if (comparer.Compare(lookup_value, value))
1331                                          }                                                  {
1332                                          break;                                                      ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1333                                      #endregion                                                      second_tmp_Results.Add(_tmp_result);
1334                                      #endregion                                                  }
1335                                  }                                                  comparer = null; // free memory
1336                                                }
1337                                                break;
1338                                            #endregion
1339                                            #endregion
1340                                        }
1341    
1342                                  double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);                                      double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1343                                  int int_percent_done = (int)double_percent_done;                                      int int_percent_done = (int)double_percent_done;
1344                                  if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)                                      if (int_percent_done != Last_Whole_Percent_Done)
1345                                  {                                      {
1346                                      resultsprogress.Value = int_percent_done;                                          resultsprogress.Value = int_percent_done;
1347                                      resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);                                          resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1348                                      Last_Whole_Percent_Done = int_percent_done;                                          Last_Whole_Percent_Done = int_percent_done;
1349                                      //Application.DoEvents();                                          //Application.DoEvents();
1350                                  }                                      }
1351    
1352                                    }
1353                              }                              }
1354                              st_nonrange_search.Stop();                              st_nonrange_search.Stop();
1355                              logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);                              logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
# Line 1392  namespace RomCheater.Docking Line 1364  namespace RomCheater.Docking
1364    
1365                              start = SearchArgs.CompareStartValue;                              start = SearchArgs.CompareStartValue;
1366                              end = SearchArgs.CompareEndValue;                              end = SearchArgs.CompareEndValue;
1367                              for (int i = 0; i < SearchArgs.Results.Count; i += 1)                              using (SearchResultReader reader = new SearchResultReader())
1368                              {                              {
1369                                  uint address = SearchArgs.Results[i].Address;                                  for (int i = 0; i < reader.ResultCount; i += 1)
                                 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }  
                                 r_ms.BaseStream.Seek(address, SeekOrigin.Begin);  
                                 if (SearchArgs.CompareType == SearchCompareTypes.Between)  
1370                                  {                                  {
1371                                      InRangeComparer comparer = new InRangeComparer(address, 0);                                      uint address = reader.CurrentAddress();
1372                                      if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))                                      if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1373                                        r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1374                                        if (SearchArgs.CompareType == SearchCompareTypes.Between)
1375                                      {                                      {
1376                                          SearchArgs.Results[i].Value = comparer.Value;                                          InRangeComparer comparer = new InRangeComparer(address, 0);
1377                                          second_tmp_Results.Add(SearchArgs.Results[i]);                                          if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
1378                                            {
1379                                                ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1380                                                second_tmp_Results.Add(_tmp_result);
1381                                            }
1382                                            comparer = null;
1383                                      }                                      }
1384                                      comparer = null;                                      else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
                                 }  
                                 else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)  
                                 {  
                                     NotInRangeComparer comparer = new NotInRangeComparer(address, 0);  
                                     if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))  
1385                                      {                                      {
1386                                          SearchArgs.Results[i].Value = comparer.Value;                                          NotInRangeComparer comparer = new NotInRangeComparer(address, 0);
1387                                          second_tmp_Results.Add(SearchArgs.Results[i]);                                          if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
1388                                            {
1389                                                ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);
1390                                                second_tmp_Results.Add(_tmp_result);
1391                                            }
1392                                            comparer = null;
1393                                        }
1394                                        else
1395                                        {
1396                                            throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
1397                                        }
1398                                        double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1399                                        int int_percent_done = (int)double_percent_done;
1400                                        if (int_percent_done != Last_Whole_Percent_Done)
1401                                        {
1402                                            resultsprogress.Value = int_percent_done;
1403                                            resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1404                                            Last_Whole_Percent_Done = int_percent_done;
1405                                            //Application.DoEvents();
1406                                      }                                      }
                                     comparer = null;  
                                 }  
                                 else  
                                 {  
                                     throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);  
                                 }  
                                 double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);  
                                 int int_percent_done = (int)double_percent_done;  
                                 if (int_percent_done != Last_Whole_Percent_Done && i % ElementsBeforeDisplay == 0)  
                                 {  
                                     resultsprogress.Value = int_percent_done;  
                                     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);  
                                     Last_Whole_Percent_Done = int_percent_done;  
                                     //Application.DoEvents();  
1407                                  }                                  }
1408                              }                              }
1409                              st_ranged_search.Stop();                              st_ranged_search.Stop();
# Line 1442  namespace RomCheater.Docking Line 1417  namespace RomCheater.Docking
1417                      // leave SearchArgs.Results alone, if false                      // leave SearchArgs.Results alone, if false
1418                      if (NeedToCompare)                      if (NeedToCompare)
1419                      {                      {
                         SearchArgs.Results = second_tmp_Results.GetRange(0, second_tmp_Results.Count);  
1420                          // fix addresses when memory start is not zero                          // fix addresses when memory start is not zero
1421                          if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch) { for (int i = 0; i < SearchArgs.Results.Count; i++) { SearchArgs.Results[i].Address = SearchArgs.Results[i].Address + MemoryRangeStart; } }                          if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch)
1422                          second_tmp_Results = null; // free memory                          {
1423                                using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count))
1424                                {
1425                                    for (int i = 0; i < second_tmp_Results.Count; i++)
1426                                    {
1427                                        second_tmp_Results[i].Address = second_tmp_Results[i].Address + MemoryRangeStart;
1428                                        switch (sdt)
1429                                        {
1430                                            case SearchDataTypes._8bits:
1431                                                if (unsigned) { writer.WriteResult<Byte>((uint)i, Convert.ToByte(second_tmp_Results[i].Value)); }
1432                                                else { writer.WriteResult<SByte>((uint)i, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
1433                                            case SearchDataTypes._16bits:
1434                                                if (unsigned) { writer.WriteResult<UInt16>((uint)i, Convert.ToUInt16(second_tmp_Results[i].Value)); }
1435                                                else { writer.WriteResult<Int16>((uint)i, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
1436                                            case SearchDataTypes._32bits:
1437                                                if (unsigned) { writer.WriteResult<UInt32>((uint)i, Convert.ToUInt32(second_tmp_Results[i].Value)); }
1438                                                else { writer.WriteResult<Int32>((uint)i,Convert.ToInt32(second_tmp_Results[i].Value)); } break;
1439                                            case SearchDataTypes._64bits:
1440                                                if (unsigned) { writer.WriteResult<UInt64>((uint)i, Convert.ToUInt64(second_tmp_Results[i].Value)); }
1441                                                else { writer.WriteResult<Int64>((uint)i, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
1442                                        }
1443                                    }
1444                                }
1445                            }
1446                            second_tmp_Results = null; // free memory                      
1447                      }                      }
1448    
1449                      r_ms.Close();                      r_ms.Close();
# Line 1472  namespace RomCheater.Docking Line 1470  namespace RomCheater.Docking
1470              }              }
1471                            
1472              resultsprogress.Value = 100;              resultsprogress.Value = 100;
             logger.Debug.WriteLine(string.Format("Results Count -> 0x{0:x8}", SearchArgs.Results.Count));  
1473    
1474              if (SearchArgs.Results.Count == 1) // debug message for 1 result using 32bit unsigned              using (SearchResultReader reader = new SearchResultReader())
1475                  logger.Debug.WriteLine(string.Format("Debug: Found 1 result -> Address: 0x{0:x8} Value: 0x{1:x8}", SearchArgs.Results[0].Address, SearchArgs.Results[0].Value));              {
1476    
1477             logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", SearchArgs.Results.Count));                  logger.Debug.WriteLine(string.Format("Results Count -> 0x{0:x8}", reader.ResultCount));
1478    
1479              if (SearchArgs.Results.Count <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)  
1480              {                  if (reader.ResultCount == 1) // debug message for 1 result using 32bit unsigned
1481                  lstResults.Items.Clear();                      logger.Debug.WriteLine(string.Format("Debug: Found 1 result -> Address: 0x{0:x8} Value: 0x{1:x16}", reader.CurrentAddress(), reader.CurrentResult<ulong>()));
1482                  List<ResultItem> items = new List<ResultItem>();  
1483                  for (int i = 0; i < SearchArgs.Results.Count; i++)                  logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", reader.ResultCount));
1484    
1485                    if (reader.ResultCount <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
1486                  {                  {
1487                      ResultItem item = new ResultItem(0, false);                      lstResults.Items.Clear();
1488                      //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);                      List<ResultItem> items = new List<ResultItem>();
1489                      //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));                      for (int i = 0; i < reader.ResultCount; i++)
                     switch (SearchArgs.DataType)  
1490                      {                      {
1491                            ResultItem item = new ResultItem(0, false);
1492                            //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);
1493                            //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));
1494                            switch (SearchArgs.DataType)
1495                            {
1496    
1497                          case SearchDataTypes._8bits:                              case SearchDataTypes._8bits:
1498                              if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToByte(SearchArgs.Results[i].Value)); }                                  if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<byte>()); }
1499                              else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToSByte(SearchArgs.Results[i].Value)); }                                  else { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<sbyte>()); }
1500                              break;                                  break;
1501                          case SearchDataTypes._16bits:                              case SearchDataTypes._16bits:
1502                              if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt16(SearchArgs.Results[i].Value)); }                                  if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<ushort>()); }
1503                              else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt16(SearchArgs.Results[i].Value)); }                                  else { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<short>()); }
1504                              break;                                  break;
1505                          case SearchDataTypes._32bits:                              case SearchDataTypes._32bits:
1506                              if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt32(SearchArgs.Results[i].Value)); }                                  if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<uint>()); }
1507                              else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt32(SearchArgs.Results[i].Value)); }                                  else { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<int>()); }
1508                              break;                                  break;
1509                          case SearchDataTypes._64bits:                              case SearchDataTypes._64bits:
1510                              if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt64(SearchArgs.Results[i].Value)); }                                  if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<ulong>()); }
1511                              else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt64(SearchArgs.Results[i].Value)); }                                  else { item = new ResultItem(reader.CurrentAddress(), false, reader.CurrentResult<long>()); }
1512                              break;                                  break;
1513                      }                          }
1514    
1515                      if (!items.Contains(item))                          if (!items.Contains(item))
1516                          items.Add(item);                              items.Add(item);
1517                        }
1518                        lstResults.Items.AddRange(items.ToArray());
1519                  }                  }
                 lstResults.Items.AddRange(items.ToArray());  
1520              }              }
1521    
1522              this.DoSearchDoneSpecific();              this.DoSearchDoneSpecific();
# Line 1675  namespace RomCheater.Docking Line 1679  namespace RomCheater.Docking
1679              if (!args.IsFirstSearch && SearchArgs != null)              if (!args.IsFirstSearch && SearchArgs != null)
1680              {              {
1681                  //args.Results.AddRange(SearchArgs.Results.ToArray());                  //args.Results.AddRange(SearchArgs.Results.ToArray());
1682                  args.Results = SearchArgs.Results;                  //args.Results = SearchArgs.Results;
1683              }              }
1684              SearchArgs = args;              SearchArgs = args;
1685  #if DONOT_HAVE_RANGED_SEARCH_SUPPORT  #if DONOT_HAVE_RANGED_SEARCH_SUPPORT
# Line 1705  namespace RomCheater.Docking Line 1709  namespace RomCheater.Docking
1709              //btnCancel.Enabled = false;              //btnCancel.Enabled = false;
1710              this.DoResetSpecific();              this.DoResetSpecific();
1711              lstResults.Items.Clear();              lstResults.Items.Clear();
1712              try { SearchArgs.Results = new List<ResultType<object>>(); }              //try { SearchArgs.Results = new List<ResultType<object>>(); }
1713              catch { }              //catch { }
1714          }          }
1715    
1716          private void btnCancel_Click(object sender, EventArgs e)          private void btnCancel_Click(object sender, EventArgs e)

Legend:
Removed from v.401  
changed lines
  Added in v.402

  ViewVC Help
Powered by ViewVC 1.1.22