/[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 541 by william, Wed Jun 5 11:06:36 2013 UTC revision 542 by william, Wed Jun 5 21:00:53 2013 UTC
# Line 1491  namespace RomCheater.Docking Line 1491  namespace RomCheater.Docking
1491                      else                      else
1492                      {                      {
1493                          Guid new_SearchGuid = SearchGuid;                          Guid new_SearchGuid = SearchGuid;
1494                            int Last_Whole_Percent_Done = 0;
1495                          // need to get the address list                          // need to get the address list
1496                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, true)) // delete the file on dispose                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, true)) // delete the file on dispose
1497                          {                          {
1498                              new_SearchGuid = GuidTools.IncrementGuid(SearchGuid);                              new_SearchGuid = GuidTools.IncrementGuid(SearchGuid);
1499                              using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))                              using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))
1500                              {                              {
1501                                  int index = 0;                                  //int index = 0;
1502                                  foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))  
1503                                    const int ChunkCount = 0x100;
1504                                    for (int ResultIndex = 0; ResultIndex < reader.ResultCount; ResultIndex += ChunkCount)
1505                                  {                                  {
1506                                      if (SearchWorkerThread.CancellationPending)                                      StructResultType<ulong>[] ChunkResults = new StructResultType<ulong>[ChunkCount];
1507                                        for (int ChunkIndex = 0; ChunkIndex < ChunkCount; ChunkIndex++)
1508                                      {                                      {
1509                                          provider_st.Stop();                                          int ResultChunkIndex = (ResultIndex + ChunkIndex);
1510                                          st.Stop();                                          StructResultType<ulong> result = StructResultType<ulong>.Empty;
1511                                          writer.CancelRequest();                                          reader.GetResultAtIndex(ResultChunkIndex, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), out result, new Func<bool>(ShouldCancelAnySearchOperation));
1512                                          writer.Dispose();                                          ChunkResults[ChunkIndex] = result;
                                         e.Result = true;  
                                         return;  
1513                                      }                                      }
1514                                      //int Last_Whole_Percent_Done = 0;                                      // Get update value(s) for each chunk result
1515                                      provider.OpenProvider();                                      ISerializedResult sr = (reader as ISerializedResult);
1516                                      int bytesRead = 0;                                      if(sr == null)
                                     byte[] data = new byte[STEP_SIZE];  
                                     provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);  
                                     provider.CloseProvider();  
                                     if (SearchWorkerThread.CancellationPending)  
1517                                      {                                      {
1518                                          provider_st.Stop();                                          throw new ArgumentNullException("sr",string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name,typeof(ISerializedResult).Name));
                                         st.Stop();  
                                         writer.CancelRequest();  
                                         writer.Dispose();  
                                         e.Result = true;  
                                         return;  
1519                                      }                                      }
                                     uint address_index = k.Address;  
1520    
1521                                      string message = string.Format(" -> Reading Address 0x{0:x8} from index 0x{1}", k.Address, index.ToString("X"));                                      Stopwatch st_memory_results_updater = new Stopwatch();
1522                                      double double_percent_done = 100.0 * (double)((double)index / (double)reader.ResultCount);                                      st_memory_results_updater.Start();
1523                                        sr.UpdateResultValuesFromMemory(ref ChunkResults, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation), (IAcceptsProcessAndConfig)this);
1524                                        st_memory_results_updater.Stop();
1525                                        logger.Profiler.WriteLine("sr.UpdateResultValuesFromMemory [ResultIndex=0x{0} ChunkCount=0x{1}] took a total of {2} seconds to complete", ResultIndex.ToString("X"), ChunkCount.ToString("X"), st_memory_results_updater.Elapsed.TotalSeconds.ToString());
1526    
1527                                        // ChunkResults should have had thier values updated from memory
1528    
1529    
1530                                        string message = string.Format(" -> Updateing values from index 0x{0} to 0x{1}", ResultIndex.ToString("X"), ChunkCount.ToString("X"));
1531                                        double double_percent_done = 100.0 * (double)((double)ResultIndex / (double)reader.ResultCount);
1532                                      int int_percent_done = (int)double_percent_done;                                      int int_percent_done = (int)double_percent_done;
1533                                      //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)                                      //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)
1534                                      //{                                      //{
1535                                      //    UpdateProgress((int)double_percent_done, message);                                      //    UpdateProgress((int)double_percent_done, message);
1536                                      //    Last_Whole_Percent_Done = int_percent_done;                                      //    Last_Whole_Percent_Done = int_percent_done;
1537                                      //}                                      //}
1538                                      if ((index % 10000) == 0)                                      if ((ResultIndex % 10000) == 0)
1539                                      {                                      {
1540                                          UpdateProgress((int)double_percent_done, message);                                          UpdateProgress((int)double_percent_done, message);
1541                                          //Last_Whole_Percent_Done = int_percent_done;                                          Last_Whole_Percent_Done = int_percent_done;
                                     }  
                                     #region comparison and serialization  
                                     switch (sdt)  
                                     {  
                                         case SearchDataTypes._8bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 8bits - unsigned  
                                                 var t_data = data;  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         byte value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<byte>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 8bits - signed  
                                                 var t_data = data;  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         sbyte value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<sbyte>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             } break;  
                                         case SearchDataTypes._16bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 16bits - unsigned  
                                                 var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         ushort value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt16(Value), value))  
                                                         {  
                                                             writer.WriteResult<ushort>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 16bits - signed  
                                                 var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         short value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                         {  
                                                             writer.WriteResult<short>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             } break;  
                                         case SearchDataTypes._32bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 32bits - unsigned  
                                                 var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         uint value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt32(Value), value))  
                                                         {  
                                                             writer.WriteResult<uint>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 32bits - signed  
                                                 var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         int value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToInt32(Value), value))  
                                                         {  
                                                             writer.WriteResult<int>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             } break;  
                                         case SearchDataTypes._64bits:  
                                             if (unsigned)  
                                             {  
                                                 #region 64bits - unsigned  
                                                 var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         ulong value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToUInt64(Value), value))  
                                                         {  
                                                             writer.WriteResult<ulong>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             }  
                                             else  
                                             {  
                                                 #region 64bits - signed  
                                                 var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                                 foreach (var Value in t_data)  
                                                 {  
                                                     if (SearchWorkerThread.CancellationPending) { break; }  
                                                     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))  
                                                     {  
                                                         long value = 0;  
                                                         if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                         {  
                                                             using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                             {  
                                                                 try  
                                                                 {  
                                                                     gmp.OpenProvider();  
                                                                     gmp.ReadMemory(address_index, out value);  
                                                                     gmp.CloseProvider();  
                                                                 }  
                                                                 catch (Exception ex)  
                                                                 {  
                                                                     logger.VerboseError.WriteLine(ex.ToString());  
                                                                 }  
                                                             }  
                                                             comparer.Value = value;  
                                                         }  
                                                         else  
                                                         {  
                                                             value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                         }  
                                                         if (comparer.Compare(Convert.ToInt64(Value), value))  
                                                         {  
                                                             writer.WriteResult<long>(comparer.Address, comparer.Value);  
                                                         }  
                                                     }  
                                                     address_index += STEP_SIZE;  
                                                 }  
                                                 #endregion  
                                             } break;  
   
1542                                      }                                      }
                                     #endregion  
1543    
                                     index++;  
1544                                  }                                  }
1545    
1546                                    #region old-code
1547                                    //foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1548                                    //{
1549                                    //    if (SearchWorkerThread.CancellationPending)
1550                                    //    {
1551                                    //        provider_st.Stop();
1552                                    //        st.Stop();
1553                                    //        writer.CancelRequest();
1554                                    //        writer.Dispose();
1555                                    //        e.Result = true;
1556                                    //        return;
1557                                    //    }
1558                                    //    //int Last_Whole_Percent_Done = 0;
1559                                    //    provider.OpenProvider();
1560                                    //    int bytesRead = 0;
1561                                    //    byte[] data = new byte[STEP_SIZE];
1562                                    //    provider.ReadProcessMemory(k.Address, STEP_SIZE, out bytesRead, out data);
1563                                    //    provider.CloseProvider();
1564                                    //    if (SearchWorkerThread.CancellationPending)
1565                                    //    {
1566                                    //        provider_st.Stop();
1567                                    //        st.Stop();
1568                                    //        writer.CancelRequest();
1569                                    //        writer.Dispose();
1570                                    //        e.Result = true;
1571                                    //        return;
1572                                    //    }
1573                                    //    uint address_index = k.Address;
1574                                    //    string message = string.Format(" -> Reading Address 0x{0:x8} from index 0x{1}", k.Address, index.ToString("X"));
1575                                    //    double double_percent_done = 100.0 * (double)((double)index / (double)reader.ResultCount);
1576                                    //    int int_percent_done = (int)double_percent_done;
1577                                    //    //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)
1578                                    //    //{
1579                                    //    //    UpdateProgress((int)double_percent_done, message);
1580                                    //    //    Last_Whole_Percent_Done = int_percent_done;
1581                                    //    //}
1582                                    //    if ((index % 10000) == 0)
1583                                    //    {
1584                                    //        UpdateProgress((int)double_percent_done, message);
1585                                    //        //Last_Whole_Percent_Done = int_percent_done;
1586                                    //    }
1587                                    //    #region comparison and serialization
1588                                    //    switch (sdt)
1589                                    //    {
1590                                    //        case SearchDataTypes._8bits:
1591                                    //            if (unsigned)
1592                                    //            {
1593                                    //                #region 8bits - unsigned
1594                                    //                var t_data = data;
1595                                    //                foreach (var Value in t_data)
1596                                    //                {
1597                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1598                                    //                    using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
1599                                    //                    {
1600                                    //                        byte value = 0;
1601                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1602                                    //                        {
1603                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1604                                    //                            {
1605                                    //                                try
1606                                    //                                {
1607                                    //                                    gmp.OpenProvider();
1608                                    //                                    gmp.ReadMemory(address_index, out value);
1609                                    //                                    gmp.CloseProvider();
1610                                    //                                }
1611                                    //                                catch (Exception ex)
1612                                    //                                {
1613                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1614                                    //                                }
1615                                    //                            }
1616                                    //                            comparer.Value = value;
1617                                    //                        }
1618                                    //                        else
1619                                    //                        {
1620                                    //                            value = Convert.ToByte(SearchArgs.CompareStartValue);
1621                                    //                            comparer.Value = value;
1622                                    //                        }
1623                                    //                        if (comparer.Compare(Convert.ToByte(Value), value))
1624                                    //                        {
1625                                    //                            writer.WriteResult<byte>(comparer.Address, comparer.Value);
1626                                    //                        }
1627                                    //                    }
1628                                    //                    address_index += STEP_SIZE;
1629                                    //                }
1630                                    //                #endregion
1631                                    //            }
1632                                    //            else
1633                                    //            {
1634                                    //                #region 8bits - signed
1635                                    //                var t_data = data;
1636                                    //                foreach (var Value in t_data)
1637                                    //                {
1638                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1639                                    //                    using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
1640                                    //                    {
1641                                    //                        sbyte value = 0;
1642                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1643                                    //                        {
1644                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1645                                    //                            {
1646                                    //                                try
1647                                    //                                {
1648                                    //                                    gmp.OpenProvider();
1649                                    //                                    gmp.ReadMemory(address_index, out value);
1650                                    //                                    gmp.CloseProvider();
1651                                    //                                }
1652                                    //                                catch (Exception ex)
1653                                    //                                {
1654                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1655                                    //                                }
1656                                    //                            }
1657                                    //                            comparer.Value = value;
1658                                    //                        }
1659                                    //                        else
1660                                    //                        {
1661                                    //                            value = Convert.ToSByte(SearchArgs.CompareStartValue);
1662                                    //                            comparer.Value = value;
1663                                    //                        }
1664                                    //                        if (comparer.Compare(Convert.ToSByte(Value), value))
1665                                    //                        {
1666                                    //                            writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1667                                    //                        }
1668                                    //                    }
1669                                    //                    address_index += STEP_SIZE;
1670                                    //                }
1671                                    //                #endregion
1672                                    //            } break;
1673                                    //        case SearchDataTypes._16bits:
1674                                    //            if (unsigned)
1675                                    //            {
1676                                    //                #region 16bits - unsigned
1677                                    //                var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1678                                    //                foreach (var Value in t_data)
1679                                    //                {
1680                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1681                                    //                    using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1682                                    //                    {
1683                                    //                        ushort value = 0;
1684                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1685                                    //                        {
1686                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1687                                    //                            {
1688                                    //                                try
1689                                    //                                {
1690                                    //                                    gmp.OpenProvider();
1691                                    //                                    gmp.ReadMemory(address_index, out value);
1692                                    //                                    gmp.CloseProvider();
1693                                    //                                }
1694                                    //                                catch (Exception ex)
1695                                    //                                {
1696                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1697                                    //                                }
1698                                    //                            }
1699                                    //                            comparer.Value = value;
1700                                    //                        }
1701                                    //                        else
1702                                    //                        {
1703                                    //                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1704                                    //                            comparer.Value = value;
1705                                    //                        }
1706                                    //                        if (comparer.Compare(Convert.ToUInt16(Value), value))
1707                                    //                        {
1708                                    //                            writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1709                                    //                        }
1710                                    //                    }
1711                                    //                    address_index += STEP_SIZE;
1712                                    //                }
1713                                    //                #endregion
1714                                    //            }
1715                                    //            else
1716                                    //            {
1717                                    //                #region 16bits - signed
1718                                    //                var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1719                                    //                foreach (var Value in t_data)
1720                                    //                {
1721                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1722                                    //                    using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1723                                    //                    {
1724                                    //                        short value = 0;
1725                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1726                                    //                        {
1727                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1728                                    //                            {
1729                                    //                                try
1730                                    //                                {
1731                                    //                                    gmp.OpenProvider();
1732                                    //                                    gmp.ReadMemory(address_index, out value);
1733                                    //                                    gmp.CloseProvider();
1734                                    //                                }
1735                                    //                                catch (Exception ex)
1736                                    //                                {
1737                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1738                                    //                                }
1739                                    //                            }
1740                                    //                            comparer.Value = value;
1741                                    //                        }
1742                                    //                        else
1743                                    //                        {
1744                                    //                            value = Convert.ToInt16(SearchArgs.CompareStartValue);
1745                                    //                            comparer.Value = value;
1746                                    //                        }
1747                                    //                        if (comparer.Compare(Convert.ToSByte(Value), value))
1748                                    //                        {
1749                                    //                            writer.WriteResult<short>(comparer.Address, comparer.Value);
1750                                    //                        }
1751                                    //                    }
1752                                    //                    address_index += STEP_SIZE;
1753                                    //                }
1754                                    //                #endregion
1755                                    //            } break;
1756                                    //        case SearchDataTypes._32bits:
1757                                    //            if (unsigned)
1758                                    //            {
1759                                    //                #region 32bits - unsigned
1760                                    //                var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1761                                    //                foreach (var Value in t_data)
1762                                    //                {
1763                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1764                                    //                    using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1765                                    //                    {
1766                                    //                        uint value = 0;
1767                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1768                                    //                        {
1769                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1770                                    //                            {
1771                                    //                                try
1772                                    //                                {
1773                                    //                                    gmp.OpenProvider();
1774                                    //                                    gmp.ReadMemory(address_index, out value);
1775                                    //                                    gmp.CloseProvider();
1776                                    //                                }
1777                                    //                                catch (Exception ex)
1778                                    //                                {
1779                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1780                                    //                                }
1781                                    //                            }
1782                                    //                            comparer.Value = value;
1783                                    //                        }
1784                                    //                        else
1785                                    //                        {
1786                                    //                            value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1787                                    //                            comparer.Value = value;
1788                                    //                        }
1789                                    //                        if (comparer.Compare(Convert.ToUInt32(Value), value))
1790                                    //                        {
1791                                    //                            writer.WriteResult<uint>(comparer.Address, comparer.Value);
1792                                    //                        }
1793                                    //                    }
1794                                    //                    address_index += STEP_SIZE;
1795                                    //                }
1796                                    //                #endregion
1797                                    //            }
1798                                    //            else
1799                                    //            {
1800                                    //                #region 32bits - signed
1801                                    //                var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1802                                    //                foreach (var Value in t_data)
1803                                    //                {
1804                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1805                                    //                    using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1806                                    //                    {
1807                                    //                        int value = 0;
1808                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1809                                    //                        {
1810                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1811                                    //                            {
1812                                    //                                try
1813                                    //                                {
1814                                    //                                    gmp.OpenProvider();
1815                                    //                                    gmp.ReadMemory(address_index, out value);
1816                                    //                                    gmp.CloseProvider();
1817                                    //                                }
1818                                    //                                catch (Exception ex)
1819                                    //                                {
1820                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1821                                    //                                }
1822                                    //                            }
1823                                    //                            comparer.Value = value;
1824                                    //                        }
1825                                    //                        else
1826                                    //                        {
1827                                    //                            value = Convert.ToInt32(SearchArgs.CompareStartValue);
1828                                    //                            comparer.Value = value;
1829                                    //                        }
1830                                    //                        if (comparer.Compare(Convert.ToInt32(Value), value))
1831                                    //                        {
1832                                    //                            writer.WriteResult<int>(comparer.Address, comparer.Value);
1833                                    //                        }
1834                                    //                    }
1835                                    //                    address_index += STEP_SIZE;
1836                                    //                }
1837                                    //                #endregion
1838                                    //            } break;
1839                                    //        case SearchDataTypes._64bits:
1840                                    //            if (unsigned)
1841                                    //            {
1842                                    //                #region 64bits - unsigned
1843                                    //                var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1844                                    //                foreach (var Value in t_data)
1845                                    //                {
1846                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1847                                    //                    using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1848                                    //                    {
1849                                    //                        ulong value = 0;
1850                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1851                                    //                        {
1852                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1853                                    //                            {
1854                                    //                                try
1855                                    //                                {
1856                                    //                                    gmp.OpenProvider();
1857                                    //                                    gmp.ReadMemory(address_index, out value);
1858                                    //                                    gmp.CloseProvider();
1859                                    //                                }
1860                                    //                                catch (Exception ex)
1861                                    //                                {
1862                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1863                                    //                                }
1864                                    //                            }
1865                                    //                            comparer.Value = value;
1866                                    //                        }
1867                                    //                        else
1868                                    //                        {
1869                                    //                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1870                                    //                            comparer.Value = value;
1871                                    //                        }
1872                                    //                        if (comparer.Compare(Convert.ToUInt64(Value), value))
1873                                    //                        {
1874                                    //                            writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1875                                    //                        }
1876                                    //                    }
1877                                    //                    address_index += STEP_SIZE;
1878                                    //                }
1879                                    //                #endregion
1880                                    //            }
1881                                    //            else
1882                                    //            {
1883                                    //                #region 64bits - signed
1884                                    //                var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1885                                    //                foreach (var Value in t_data)
1886                                    //                {
1887                                    //                    if (SearchWorkerThread.CancellationPending) { break; }
1888                                    //                    using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
1889                                    //                    {
1890                                    //                        long value = 0;
1891                                    //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1892                                    //                        {
1893                                    //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1894                                    //                            {
1895                                    //                                try
1896                                    //                                {
1897                                    //                                    gmp.OpenProvider();
1898                                    //                                    gmp.ReadMemory(address_index, out value);
1899                                    //                                    gmp.CloseProvider();
1900                                    //                                }
1901                                    //                                catch (Exception ex)
1902                                    //                                {
1903                                    //                                    logger.VerboseError.WriteLine(ex.ToString());
1904                                    //                                }
1905                                    //                            }
1906                                    //                            comparer.Value = value;
1907                                    //                        }
1908                                    //                        else
1909                                    //                        {
1910                                    //                            value = Convert.ToInt64(SearchArgs.CompareStartValue);
1911                                    //                            comparer.Value = value;
1912                                    //                        }
1913                                    //                        if (comparer.Compare(Convert.ToInt64(Value), value))
1914                                    //                        {
1915                                    //                            writer.WriteResult<long>(comparer.Address, comparer.Value);
1916                                    //                        }
1917                                    //                    }
1918                                    //                    address_index += STEP_SIZE;
1919                                    //                }
1920                                    //                #endregion
1921                                    //            } break;
1922                                    //    }
1923                                    //    #endregion
1924                                    //    index++;
1925                                    //}
1926                                    #endregion
1927    
1928                                  //ISerializedResult sr = (reader as ISerializedResult);                                  //ISerializedResult sr = (reader as ISerializedResult);
1929                                  //if (sr == null)                                  //if (sr == null)

Legend:
Removed from v.541  
changed lines
  Added in v.542

  ViewVC Help
Powered by ViewVC 1.1.22