/[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 504 by william, Tue Jun 4 20:15:03 2013 UTC revision 505 by william, Tue Jun 4 20:19:31 2013 UTC
# Line 1803  namespace RomCheater.Docking Line 1803  namespace RomCheater.Docking
1803                      }                      }
1804                      else                      else
1805                      {                      {
                         
1806    
1807                          // need to get the address list                          #region action_onbytesread :: custom in-line delegate for processing read bytes
1808                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, false)) // delete the file on dispose                          // custom in-line delegate for processing read bytes
1809                            Action<OnBytesReadEventArgs> action_onbytesread = delegate(OnBytesReadEventArgs obre)
1810                          {                          {
1811                              #region action_onbytesread :: custom in-line delegate for processing read bytes                              SearchDataTypes obre_sdt = SearchArgs.DataType;
1812                              // custom in-line delegate for processing read bytes                              bool obre_unsigned = SearchArgs.IsUnsignedDataType;
1813                              Action<OnBytesReadEventArgs> action_onbytesread = delegate(OnBytesReadEventArgs obre)                              uint obre_CurrentIndex = obre.CurrentIndex; // this should represent the address
1814                                SearchResultReader reader = null;
1815                                if (obre.UserState != null)
1816                              {                              {
1817                                  SearchDataTypes obre_sdt = SearchArgs.DataType;                                  reader = (obre.UserState as SearchResultReader);
1818                                  bool obre_unsigned = SearchArgs.IsUnsignedDataType;                                  if (reader == null)
1819                                  uint obre_CurrentIndex = obre.CurrentIndex; // this should represent the address                                      throw new InvalidOperationException("writer cannot be null");
1820                                }
1821                                else
1822                                {
1823                                  ISerializedResult sr = (reader as ISerializedResult);                                  throw new ArgumentNullException("UserState", "UserState cannot be null, it must be an instance of a SearchResultReader");
1824                                  if (sr == null)                              }
1825                                  {                              using (MemoryStream ms = new MemoryStream(obre.Data))
1826                                      throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));                              {
1827                                  }                                  using (BinaryReader br = new BinaryReader(ms))
                                 int sr_index = 0;  
                                 if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))  
                                 {  
                                     StructResultType<ulong> result = StructResultType<ulong>.Empty;  
                                     sr.GetResultAtAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);  
                                     if (Debugger.IsAttached)  
                                     {  
                                         Debugger.Break();  
                                     }  
                                       
                                 }  
   
                                 //// walk through each address in the reader  
                                 //foreach (var k in reader.GetResults(obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress)))  
                                 //{  
                                 //    if (obre_CurrentIndex == k.Address)  
                                 //    {  
                                 //        if (Debugger.IsAttached)  
                                 //        {  
                                 //            Debugger.Break();  
                                 //        }  
                                 //    }  
                                 //}  
                                   
                                   
   
                                 using (MemoryStream ms = new MemoryStream(obre.Data))  
1828                                  {                                  {
1829                                      using (BinaryReader br = new BinaryReader(ms))                                      while (br.BaseStream.Position < br.BaseStream.Length)
1830                                      {                                      {
1831                                          while (br.BaseStream.Position < br.BaseStream.Length)                                          ISerializedResult sr = (reader as ISerializedResult);
1832                                            if (sr == null)
1833                                          {                                          {
1834                                              switch (obre_sdt)                                              throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
1835                                            }
1836                                            int sr_index = 0;
1837                                            if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
1838                                            {
1839                                                StructResultType<ulong> result = StructResultType<ulong>.Empty;
1840                                                sr.GetResultAtAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
1841                                                if (Debugger.IsAttached)
1842                                              {                                              {
1843                                                  case SearchDataTypes._8bits:                                                  Debugger.Break();
1844                                                      if (obre_unsigned)                                              }
1845                                                      {  
1846                                                          #region 8bit - unsigned                                          }
1847                                                          var new_value = br.ReadByte(); // this should contain the updated value from memory                                          switch (obre_sdt)
1848                                                          using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, obre_CurrentIndex))                                          {
1849                                                case SearchDataTypes._8bits:
1850                                                    if (obre_unsigned)
1851                                                    {
1852                                                        #region 8bit - unsigned
1853                                                        var new_value = br.ReadByte(); // this should contain the updated value from memory
1854                                                        using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, obre_CurrentIndex))
1855                                                        {
1856                                                            byte value = 0; // this is the vaule we want to compare against
1857                                                            value = Convert.ToByte(SearchArgs.CompareStartValue);
1858                                                            comparer.Value = value;
1859                                                            if (comparer.Compare(new_value, value))
1860                                                          {                                                          {
1861                                                              byte value = 0; // this is the vaule we want to compare against                                                              //writer.WriteResult<byte>(comparer.Address, comparer.Value);
                                                             value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                             comparer.Value = value;  
                                                             if (comparer.Compare(new_value, value))  
                                                             {  
                                                                 //writer.WriteResult<byte>(comparer.Address, comparer.Value);  
                                                             }  
1862                                                          }                                                          }
                                                         #endregion  
                                                     }  
                                                     else  
                                                     {  
                                                     }  
                                                     break;  
                                                 case SearchDataTypes._16bits:  
                                                     if (obre_unsigned)  
                                                     {  
                                                     }  
                                                     else  
                                                     {  
                                                     }  
                                                     break;  
                                                 case SearchDataTypes._32bits:  
                                                     if (obre_unsigned)  
                                                     {  
1863                                                      }                                                      }
1864                                                      else                                                      #endregion
1865                                                      {                                                  }
1866                                                      }                                                  else
1867                                                      break;                                                  {
1868                                                  case SearchDataTypes._64bits:                                                  }
1869                                                      if (obre_unsigned)                                                  break;
1870                                                      {                                              case SearchDataTypes._16bits:
1871                                                      }                                                  if (obre_unsigned)
1872                                                      else                                                  {
1873                                                      {                                                  }
1874                                                      }                                                  else
1875                                                      break;                                                  {
1876                                              }                                                  }
1877                                              uint size = 0;                                                  break;
1878                                              BitTools.SizeOf(obre_sdt, out size);                                              case SearchDataTypes._32bits:
1879                                              obre_CurrentIndex += size;                                                  if (obre_unsigned)
1880                                                    {
1881                                                    }
1882                                                    else
1883                                                    {
1884                                                    }
1885                                                    break;
1886                                                case SearchDataTypes._64bits:
1887                                                    if (obre_unsigned)
1888                                                    {
1889                                                    }
1890                                                    else
1891                                                    {
1892                                                    }
1893                                                    break;
1894                                          }                                          }
1895                                            uint size = 0;
1896                                            BitTools.SizeOf(obre_sdt, out size);
1897                                            obre_CurrentIndex += size;
1898                                      }                                      }
1899                                  }                                  }
1900                              };                              }
1901                              #endregion                          };
1902                            #endregion
1903                            // need to get the address list
1904                            using (SearchResultReader reader = new SearchResultReader(SearchGuid, true)) // delete the file on dispose
1905                            {
1906                              
1907    
1908                              provider.OpenProvider();                              provider.OpenProvider();
1909                              //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);                              //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1910                              //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                              //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1911                              provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(action_onbytesread);                              provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(action_onbytesread);
1912                              provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), null);                              provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), reader);
1913                              if (SearchWorkerThread.CancellationPending)                              if (SearchWorkerThread.CancellationPending)
1914                              {                              {
1915                                  provider_st.Stop();                                  provider_st.Stop();

Legend:
Removed from v.504  
changed lines
  Added in v.505

  ViewVC Help
Powered by ViewVC 1.1.22