/[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 453 by william, Sun Jun 2 23:07:04 2013 UTC revision 454 by william, Mon Jun 3 00:34:31 2013 UTC
# Line 1067  namespace RomCheater.Docking Line 1067  namespace RomCheater.Docking
1067                                  switch (sdt)                                  switch (sdt)
1068                                  {                                  {
1069                                      case SearchDataTypes._8bits:                                      case SearchDataTypes._8bits:
1070                                          if (unsigned) { writer.WriteResult<Byte>((uint)CurrentIndex, br.ReadByte()); }                                          if (unsigned)
1071                                          else { writer.WriteResult<SByte>((uint)CurrentIndex, br.ReadSByte()); } break;                                          {
1072                                                #region 8bits - unsigned
1073                                                var Value = br.ReadByte();
1074                                                using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1075                                                {
1076                                                    byte value = 0;
1077                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1078                                                    {
1079                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1080                                                        {
1081                                                            try
1082                                                            {
1083                                                                gmp.OpenProvider();
1084                                                                gmp.ReadMemory(CurrentIndex, out value);
1085                                                                gmp.CloseProvider();
1086                                                            }
1087                                                            catch (Exception ex)
1088                                                            {
1089                                                                logger.VerboseError.WriteLine(ex.ToString());
1090                                                            }
1091                                                        }
1092                                                        comparer.Value = value;
1093                                                    }
1094                                                    else
1095                                                    {
1096                                                        value = Convert.ToByte(SearchArgs.CompareStartValue);
1097                                                        comparer.Value = value;
1098                                                    }
1099                                                    if (comparer.Compare(Convert.ToByte(Value), value))
1100                                                    {
1101                                                        writer.WriteResult<byte>(comparer.Address, comparer.Value);
1102                                                    }
1103                                                }
1104                                                #endregion                                            
1105                                            }
1106                                            else
1107                                            {
1108                                                #region 8bits - signed
1109                                                var Value = br.ReadSByte();
1110                                                using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1111                                                {
1112                                                    sbyte value = 0;
1113                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1114                                                    {
1115                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1116                                                        {
1117                                                            try
1118                                                            {
1119                                                                gmp.OpenProvider();
1120                                                                gmp.ReadMemory(CurrentIndex, out value);
1121                                                                gmp.CloseProvider();
1122                                                            }
1123                                                            catch (Exception ex)
1124                                                            {
1125                                                                logger.VerboseError.WriteLine(ex.ToString());
1126                                                            }
1127                                                        }
1128                                                        comparer.Value = value;
1129                                                    }
1130                                                    else
1131                                                    {
1132                                                        value = Convert.ToSByte(SearchArgs.CompareStartValue);
1133                                                        comparer.Value = value;
1134                                                    }
1135                                                    if (comparer.Compare(Convert.ToSByte(Value), value))
1136                                                    {
1137                                                        writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1138                                                    }
1139                                                }
1140                                                #endregion                                              
1141                                            } break;
1142                                      case SearchDataTypes._16bits:                                      case SearchDataTypes._16bits:
1143                                          if (unsigned) { writer.WriteResult<UInt16>((uint)CurrentIndex, br.ReadUInt16()); }                                          if (unsigned)
1144                                          else { writer.WriteResult<Int16>((uint)CurrentIndex, br.ReadInt16()); } break;                                          {
1145                                                #region 16bits - unsigned
1146                                                var Value = br.ReadUInt16();
1147                                                using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1148                                                {
1149                                                    ushort value = 0;
1150                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1151                                                    {
1152                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1153                                                        {
1154                                                            try
1155                                                            {
1156                                                                gmp.OpenProvider();
1157                                                                gmp.ReadMemory(CurrentIndex, out value);
1158                                                                gmp.CloseProvider();
1159                                                            }
1160                                                            catch (Exception ex)
1161                                                            {
1162                                                                logger.VerboseError.WriteLine(ex.ToString());
1163                                                            }
1164                                                        }
1165                                                        comparer.Value = value;
1166                                                    }
1167                                                    else
1168                                                    {
1169                                                        value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1170                                                        comparer.Value = value;
1171                                                    }
1172                                                    if (comparer.Compare(Convert.ToUInt16(Value), value))
1173                                                    {
1174                                                        writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1175                                                    }
1176                                                }
1177                                                #endregion
1178                                                writer.WriteResult<ushort>(CurrentIndex, br.ReadUInt16());
1179                                            }
1180                                            else
1181                                            {
1182                                                #region 16bits - signed
1183                                                var Value = br.ReadInt16();
1184                                                using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1185                                                {
1186                                                    short value = 0;
1187                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1188                                                    {
1189                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1190                                                        {
1191                                                            try
1192                                                            {
1193                                                                gmp.OpenProvider();
1194                                                                gmp.ReadMemory(CurrentIndex, out value);
1195                                                                gmp.CloseProvider();
1196                                                            }
1197                                                            catch (Exception ex)
1198                                                            {
1199                                                                logger.VerboseError.WriteLine(ex.ToString());
1200                                                            }
1201                                                        }
1202                                                        comparer.Value = value;
1203                                                    }
1204                                                    else
1205                                                    {
1206                                                        value = Convert.ToInt16(SearchArgs.CompareStartValue);
1207                                                        comparer.Value = value;
1208                                                    }
1209                                                    if (comparer.Compare(Convert.ToSByte(Value), value))
1210                                                    {
1211                                                        writer.WriteResult<short>(comparer.Address, comparer.Value);
1212                                                    }
1213                                                }
1214                                                #endregion
1215                                                writer.WriteResult<short>(CurrentIndex, br.ReadInt16());
1216                                            } break;
1217                                      case SearchDataTypes._32bits:                                      case SearchDataTypes._32bits:
1218                                          if (unsigned) { writer.WriteResult<UInt32>((uint)CurrentIndex, br.ReadUInt32()); }                                          if (unsigned)
1219                                          else { writer.WriteResult<Int32>((uint)CurrentIndex, br.ReadInt32()); } break;                                          {
1220                                                #region 32bits - unsigned
1221                                                var Value = br.ReadUInt32();
1222                                                using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1223                                                {
1224                                                    uint value = 0;
1225                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1226                                                    {
1227                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1228                                                        {
1229                                                            try
1230                                                            {
1231                                                                gmp.OpenProvider();
1232                                                                gmp.ReadMemory(CurrentIndex, out value);
1233                                                                gmp.CloseProvider();
1234                                                            }
1235                                                            catch (Exception ex)
1236                                                            {
1237                                                                logger.VerboseError.WriteLine(ex.ToString());
1238                                                            }
1239                                                        }
1240                                                        comparer.Value = value;
1241                                                    }
1242                                                    else
1243                                                    {
1244                                                        value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1245                                                        comparer.Value = value;
1246                                                    }
1247                                                    if (comparer.Compare(Convert.ToUInt32(Value), value))
1248                                                    {
1249                                                        writer.WriteResult<uint>(comparer.Address, comparer.Value);
1250                                                    }
1251                                                }
1252                                                #endregion                                            
1253                                            }
1254                                            else
1255                                            {
1256                                                #region 32bits - signed
1257                                                var Value = br.ReadInt32();
1258                                                using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1259                                                {
1260                                                    int value = 0;
1261                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1262                                                    {
1263                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1264                                                        {
1265                                                            try
1266                                                            {
1267                                                                gmp.OpenProvider();
1268                                                                gmp.ReadMemory(CurrentIndex, out value);
1269                                                                gmp.CloseProvider();
1270                                                            }
1271                                                            catch (Exception ex)
1272                                                            {
1273                                                                logger.VerboseError.WriteLine(ex.ToString());
1274                                                            }
1275                                                        }
1276                                                        comparer.Value = value;
1277                                                    }
1278                                                    else
1279                                                    {
1280                                                        value = Convert.ToInt32(SearchArgs.CompareStartValue);
1281                                                        comparer.Value = value;
1282                                                    }
1283                                                    if (comparer.Compare(Convert.ToInt32(Value), value))
1284                                                    {
1285                                                        writer.WriteResult<int>(comparer.Address, comparer.Value);
1286                                                    }
1287                                                }
1288                                                #endregion
1289                                            } break;
1290                                      case SearchDataTypes._64bits:                                      case SearchDataTypes._64bits:
1291                                          if (unsigned) { writer.WriteResult<UInt64>((uint)CurrentIndex, br.ReadUInt64()); }                                          if (unsigned)
1292                                          else { writer.WriteResult<Int64>((uint)CurrentIndex, br.ReadInt64()); } break;                                          {
1293                                                #region 64bits - unsigned
1294                                                var Value = br.ReadUInt64();
1295                                                using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1296                                                {
1297                                                    ulong value = 0;
1298                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1299                                                    {
1300                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1301                                                        {
1302                                                            try
1303                                                            {
1304                                                                gmp.OpenProvider();
1305                                                                gmp.ReadMemory(CurrentIndex, out value);
1306                                                                gmp.CloseProvider();
1307                                                            }
1308                                                            catch (Exception ex)
1309                                                            {
1310                                                                logger.VerboseError.WriteLine(ex.ToString());
1311                                                            }
1312                                                        }
1313                                                        comparer.Value = value;
1314                                                    }
1315                                                    else
1316                                                    {
1317                                                        value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1318                                                        comparer.Value = value;
1319                                                    }
1320                                                    if (comparer.Compare(Convert.ToUInt64(Value), value))
1321                                                    {
1322                                                        writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1323                                                    }
1324                                                }
1325                                                #endregion                                            
1326                                            }
1327                                            else
1328                                            {
1329                                                #region 64bits - signed
1330                                                var Value = br.ReadInt64();
1331                                                using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1332                                                {
1333                                                    long value = 0;
1334                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1335                                                    {
1336                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1337                                                        {
1338                                                            try
1339                                                            {
1340                                                                gmp.OpenProvider();
1341                                                                gmp.ReadMemory(CurrentIndex, out value);
1342                                                                gmp.CloseProvider();
1343                                                            }
1344                                                            catch (Exception ex)
1345                                                            {
1346                                                                logger.VerboseError.WriteLine(ex.ToString());
1347                                                            }
1348                                                        }
1349                                                        comparer.Value = value;
1350                                                    }
1351                                                    else
1352                                                    {
1353                                                        value = Convert.ToInt64(SearchArgs.CompareStartValue);
1354                                                        comparer.Value = value;
1355                                                    }
1356                                                    if (comparer.Compare(Convert.ToInt64(Value), value))
1357                                                    {
1358                                                        writer.WriteResult<long>(comparer.Address, comparer.Value);
1359                                                    }
1360                                                }
1361                                                #endregion
1362                                            } break;
1363                                  }                                  }
1364                                  if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }                                  if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1365                              }                              }
# Line 1188  namespace RomCheater.Docking Line 1470  namespace RomCheater.Docking
1470                              {                              {
1471                                  try                                  try
1472                                  {                                  {
                                     reader.GetResults(SearchArgs, (IAcceptsProcessAndConfig)this);  
1473    
1474                                      #region new comparator-support                                      #region new comparator-support
1475                                      switch (SearchArgs.DataType)                                      second_tmp_Results = reader.GetResults(SearchArgs, (IAcceptsProcessAndConfig)this, resultsprogress);
                                     {  
                                         case SearchDataTypes._8bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 8bits - unsigned  
                                                 var list_results = reader.GetResults<byte>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         byte value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 8bits - signed  
                                                 var list_results = reader.GetResults<sbyte>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         sbyte value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             break;  
                                         case SearchDataTypes._16bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 16bits - unsigned  
                                                 var list_results = reader.GetResults<ushort>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         ushort value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 16bits - signed  
                                                 var list_results = reader.GetResults<short>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         short value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             break;  
                                         case SearchDataTypes._32bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 32bits - unsigned  
                                                 var list_results = reader.GetResults<uint>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         uint value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 32bits - signed  
                                                 var list_results = reader.GetResults<int>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         int value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             break;  
                                         case SearchDataTypes._64bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 64bits - unsigned  
                                                 var list_results = reader.GetResults<ulong>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         ulong value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 64bits - signed  
                                                 var list_results = reader.GetResults<long>(resultsprogress);  
                                                 foreach (var list_result in list_results)  
                                                 {  
                                                     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, list_result.Address))  
                                                     {  
                                                         long value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(list_result.Address, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(list_result.Value, value))  
                                                         {  
                                                             second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));  
                                                         }  
                                                     }  
                                                 }  
                                                 #endregion  
                                             }  
                                             break;  
                                     }  
1476                                      #endregion                                      #endregion
1477    
1478                                      #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE                                      #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE

Legend:
Removed from v.453  
changed lines
  Added in v.454

  ViewVC Help
Powered by ViewVC 1.1.22