using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

using System.Windows.Forms;

using Ionic.Zip;



using FTDIUSBGecko;



namespace GeckoApp

{

    public enum SearchSize

    {

        Bit8,

        Bit16,

        Bit32,

        Single

    }



    public enum SearchType

    {

        Exact,

        Unknown,

        Old,

        Diff

    }



    public enum ComparisonType

    {

        Equal,

        NotEqual,

        Lower,

        LowerEqual,

        Greater,

        GreaterEqual,

        DifferentBy,

        DifferentByLess,

        DifferentByMore

    }



    public class SearchComparisonInfo

    {

        public ComparisonType comparisonType;

        public UInt32 value;

        public SearchType searchType;



        public SearchComparisonInfo()

        {

            comparisonType = ComparisonType.Equal;

            value = 0;

            searchType = SearchType.Exact;

        }



        public SearchComparisonInfo(ComparisonType ctype, UInt32 searchValue, SearchType stype)

        {

            comparisonType = ctype;

            value = searchValue;

            searchType = stype;

        }

    }



    [Serializable()]

    public class SearchResult 

    {

        private UInt32 PAddress;

        private UInt32 PValue;

        private UInt32 POldValue;



        public UInt32 address { get { return PAddress; } }

        public UInt32 value { get { return PValue; } }

        public UInt32 oldValue { get { return POldValue; } }



        public SearchResult(UInt32 address,UInt32 value,UInt32 old) 

        {

            PAddress = address;

            PValue = value;

            POldValue = old;

        }

    }



    public class DumpRange

    {

        public UInt32 rangeLength;

        public UInt32 streamOffset;



        private UInt32 PStartAddress;

        private UInt32 PEndAddress;



        public UInt32 startAddress 

        { 

            get 

            { 

                return PStartAddress; 

            }

            set

            {

                PStartAddress = value;

            }

        }

        public UInt32 endAddress { 

            get 

            { 

                return PEndAddress; 

            }

            set

            {

                PEndAddress = value;

            }

        }



        public DumpRange()

        {

        }



        public DumpRange(UInt32 startAddress)

        {

            PStartAddress = startAddress;

        }



        public DumpRange(UInt32 startAddress, UInt32 endAddress)

        {

            PStartAddress = startAddress;

            PEndAddress = endAddress;

        }

    }



    public struct StringResult

    {

        public String SAddress;

        public String SValue;

        public String SOldValue;

    }

    

    public class MemSearch

    {

        const int pageSize = 256;



        //private List<SearchResult> resList;

        private List<UInt32> resultAddressList;

        private SearchSize sSize;

        private int cPage;

        private int cPages;

        private int oldSelectedRow;

        private bool InitialSearch;



        public SearchSize searchSize

            { get { return sSize; } }

        

        private bool UnknownStart;

        private UInt32 UnknownLAddress;

        private UInt32 UnknownHAddress;



        private USBGecko gecko;

        private DataGridView gView;

        private Button prvButton;

        private Button nxButton;

        private Label resLab;

        private NumericUpDown pageUpDown;



        private MemoryStream orgStream;

        private MemoryStream cmpStream;

        public Dump oldDump;

        public Dump newDump;

        private Dump undoDump;

        private List<UInt32> undoList;

        private int dumpNum;

        public int DumpNum

        {

            get { return dumpNum; }

        }

        private SearchHistoryManager searchHistory;



        private bool NewSearch = true;



        private ExceptionHandler exceptionHandling;



        private bool PBlockDump;

        private UInt32 PTotalBlockSize;

        private UInt32 PBlocksDumpedSize;

        private int PBlockID;

        private int PBlockCount;

        private UInt32 PBlockStart;

        private UInt32 PBlockEnd;

        private String displayType;

        public String DisplayType

        {

            get { return displayType; }

            set { displayType = value; }

        }

        public bool blockDump

        { get { return PBlockDump; } }

        public UInt32 totalBlockSize

        { get { return PTotalBlockSize; } }

        public UInt32 blocksDumpedSize

        { get { return PBlocksDumpedSize; } }

        public int blockID

        { get { return PBlockID; } }

        public int blockCount

        { get { return PBlockCount; } }

        public UInt32 blockStart

        { get { return PBlockStart; } }

        public UInt32 blockEnd

        { get { return PBlockEnd; } }

        



        public MemSearch(USBGecko uGecko,DataGridView uGView,Button uPrvButton,Button uNxButton,

            Label UResLab, NumericUpDown UPageUpDown, ExceptionHandler UEHandler)

        {

            exceptionHandling = UEHandler;



            gecko = uGecko;

            gView = uGView;



            prvButton = uPrvButton;

            nxButton = uNxButton;

            resLab = UResLab;

            pageUpDown = UPageUpDown;



            pageUpDown.ValueChanged += UpDownValueChanged;

            nxButton.Click += nextPage;

            prvButton.Click += previousPage;



            //resList = new List<SearchResult>();

            resultAddressList = new List<uint>();

            undoList = new List<uint>();



            PBlockDump = false;



            dumpNum = 0;



            searchHistory = new SearchHistoryManager();



        }



        void UpDownValueChanged(object sender, EventArgs e)

        {

            cPage = Convert.ToInt32(pageUpDown.Value) - 1;

            PrintPageAlt();

        }



        //private void PrintPage()

        //{

        //    // Make sure we don't go before the first page...

        //    if (cPage <= 0)

        //    {

        //        cPage = 0;

        //        prvButton.Enabled = false;

        //    }

        //    else

        //    {

        //        // Only enable previous button if current page is > 0

        //        prvButton.Enabled = true;

        //    }



        //    // ...or after the last page

        //    if (cPage >= cPages - 1)

        //    {

        //        cPage = cPages - 1;

        //        if (cPage < 0) cPage = 0;

        //        nxButton.Enabled = false;

        //    }

        //    else

        //    {

        //        // Only enable next button if there are multiple pages and we aren't on the last page

        //        nxButton.Enabled = (cPages > 1);

        //    }



        //    resLab.Text = resList.Count.ToString() + " results (page "

        //     + (cPage + 1).ToString() + "/"

        //     + cPages.ToString() + ")";



        //    int i = 0;

        //    String addr, value, oldv, diff;



        //    int strLength;

        //    switch (sSize)

        //    {

        //        case SearchSize.Bit8: strLength = 2; break;

        //        case SearchSize.Bit16: strLength = 4; break;

        //        default: strLength = 8; break;

        //    }



        //    //gView.Rows.Clear();

        //    int start = cPage * pageSize;

        //    int end = Math.Min(cPage * pageSize + pageSize, resList.Count);

        //    int count = end - start;

        //    if (count < gView.Rows.Count)

        //    {

        //        gView.Rows.Clear();

        //    }

        //    int addCount = count - gView.Rows.Count;

        //    if (addCount > 0)

        //    {

        //        gView.Rows.Add(addCount);

        //    }



        //    for (int j = start; j < end; j++)

        //    {

        //        SearchResult result = resList[j];



        //        addr = fixString(Convert.ToString(result.address, 16).ToUpper(), 8);

        //        if (displayType == "Hex")

        //        {

        //            value = fixString(Convert.ToString(result.value, 16).ToUpper(), strLength);

        //            oldv = fixString(Convert.ToString(result.oldValue, 16).ToUpper(), strLength);

        //            diff = fixString(Convert.ToString(result.value - result.oldValue, 16).ToUpper(), strLength);

        //        }

        //        else if (displayType == "Dec")

        //        {

        //            value = ((int)result.value).ToString();

        //            oldv = ((int)result.oldValue).ToString();

        //            diff = ((int)(result.value - result.oldValue)).ToString();

        //        }

        //        else

        //        {

        //            value = GlobalFunctions.UIntToSingle(result.value).ToString("g5");

        //            oldv = GlobalFunctions.UIntToSingle(result.oldValue).ToString("g5");

        //            diff = GlobalFunctions.UIntToSingle(result.value - result.oldValue).ToString("g5");

        //        }

        //        gView.Rows[i].Cells[0].Value = addr;

        //        if (!InitialSearch)

        //        {

        //            gView.Rows[i].Cells[1].Value = oldv;

        //            gView.Rows[i].Cells[3].Value = diff;

        //        }

        //        else

        //        {

        //            gView.Rows[i].Cells[1].Value = "";

        //            gView.Rows[i].Cells[3].Value = "";

        //        }

        //        gView.Rows[i].Cells[2].Value = value;

        //        i++;

        //    }

        //}



        private void PrintPageAlt()

        {

            // Make sure we don't go before the first page...

            if (cPage <= 0)

            {

                cPage = 0;

                prvButton.Enabled = false;

            }

            else

            {

                // Only enable previous button if current page is > 0

                prvButton.Enabled = true;

            }



            // ...or after the last page

            if (cPage >= cPages - 1)

            {

                cPage = cPages - 1;

                if (cPage < 0) cPage = 0;

                nxButton.Enabled = false;

            }

            else

            {

                // Only enable next button if there are multiple pages and we aren't on the last page

                nxButton.Enabled = (cPages > 1);

            }



            resLab.Text = resultAddressList.Count.ToString() + " results ("

             + cPages.ToString() + " pages)";



            int i = 0;

            String addr, value, oldv, diff;



            int strLength;

            switch (sSize)

            {

                case SearchSize.Bit8: strLength = 2; break;

                case SearchSize.Bit16: strLength = 4; break;

                default: strLength = 8; break;

            }



            int searchBytes = strLength / 2;



            //gView.Rows.Clear();

            int start = cPage * pageSize;

            int end = Math.Min(cPage * pageSize + pageSize, resultAddressList.Count);

            int count = end - start;

            if (count < gView.Rows.Count)

            {

                gView.Rows.Clear();

            }

            int addCount = count - gView.Rows.Count;

            if (addCount > 0)

            {

                gView.Rows.Add(addCount);

            }



            for (int j = start; j < end; j++)

            {

                SearchResult result;

                if (oldDump == null)

                {

                    result = new SearchResult(resultAddressList[j],

                        newDump.ReadAddress(resultAddressList[j], searchBytes),

                        0);

                }

                else

                {

                    result = new SearchResult(resultAddressList[j],

                        newDump.ReadAddress(resultAddressList[j], searchBytes),

                        oldDump.ReadAddress(resultAddressList[j], searchBytes));

                }



                addr = fixString(Convert.ToString(result.address, 16).ToUpper(), 8);

                if (displayType == "Hex")

                {

                    value = fixString(Convert.ToString(result.value, 16).ToUpper(), strLength);

                    oldv = fixString(Convert.ToString(result.oldValue, 16).ToUpper(), strLength);

                    diff = fixString(Convert.ToString(result.value - result.oldValue, 16).ToUpper(), strLength);

                }

                else if (displayType == "Dec")

                {

                    value = ((int)result.value).ToString();

                    oldv = ((int)result.oldValue).ToString();

                    diff = ((int)(result.value - result.oldValue)).ToString();

                }

                else

                {

                    float floatVal = GlobalFunctions.UIntToSingle(result.value);

                    float floatOldVal = GlobalFunctions.UIntToSingle(result.oldValue);



                    value = floatVal.ToString("g5");

                    oldv = floatOldVal.ToString("g5");

                    diff = (floatVal - floatOldVal).ToString("g5");

                }

                gView.Rows[i].Cells[0].Value = addr;



                if (InitialSearch)

                {

                    gView.Rows[i].Cells[1].Value = "";

                    gView.Rows[i].Cells[3].Value = "";



                }

                else if (resultAddressList[i] < oldDump.StartAddress || resultAddressList[i] > oldDump.EndAddress - searchBytes)

                {

                    gView.Rows[i].Cells[1].Value = "N/A";

                    gView.Rows[i].Cells[3].Value = "N/A";

                }

                else

                {

                    gView.Rows[i].Cells[1].Value = oldv;

                    gView.Rows[i].Cells[3].Value = diff;

                }

                gView.Rows[i].Cells[2].Value = value;

                i++;

            }

        }



        private void nextPage(object sender, EventArgs e)

        {

            //cPage++;

            //PrintPage();

            // Add 2, 1 because we're going to the next page,

            // and another because the upDown is 1-based instead of 0-based like cPage

            pageUpDown.Value = Convert.ToDecimal(cPage + 2);

        }



        private void previousPage(object sender, EventArgs e)

        {

            //cPage--;

            //PrintPage();

            // Since cPage is 0-based, we don't need to subtract 1

            pageUpDown.Value = Convert.ToDecimal(cPage);

        }



        private String fixString(String input, int length)

        {

            String parse = input;

            if (parse.Length > length)

                parse =

                    parse.Substring(parse.Length - length, length);



            while (parse.Length < length)

                parse = "0" + parse;



            return parse;

        }



        public UInt32 GetAddress(int index)

        {

            return resultAddressList[cPage * pageSize + index];

        }



        public StringResult GetResult(int index)

        {

            UInt32 resultAddress = GetAddress(index);



            int strLength;

            switch (sSize)

            {

                case (SearchSize.Bit8): strLength = 2; break;

                case (SearchSize.Bit16): strLength = 4; break;

                default: strLength = 8; break;

            }

            StringResult result;

            result.SAddress = fixString(Convert.ToString(resultAddress, 16).ToUpper(), 8);

            result.SValue = fixString(Convert.ToString(newDump.ReadAddress32(resultAddress), 16).ToUpper(), strLength);

            if (oldDump != null)

            {

                result.SOldValue = fixString(Convert.ToString(oldDump.ReadAddress32(resultAddress), 16).ToUpper(), strLength);

            }

            else

            {

                result.SOldValue = "";

            }

            return result;

        }



        public UInt32 GetNewValueFromAddress(UInt32 resultAddress)

        {

            return newDump.ReadAddress(resultAddress, 4);

        }



        public static UInt32 ReadStream(Stream input, int blength)

        {

            Byte[] buffer = new Byte[blength];

            UInt32 result;



            input.Read(buffer, 0, blength);

            

            switch(blength)

            {

                 case 1: result = (UInt32)buffer[0]; break;

                 case 2: result = (UInt32)ByteSwap.Swap((UInt16)BitConverter.ToUInt16(buffer, 0)); break;

                default: result = (UInt32)ByteSwap.Swap(BitConverter.ToUInt32(buffer, 0)); break;

            }



            return result;

        }



        private void PerformBlockSearch(Dump blockDump, List<DumpRange> dumpranges)

        {

            PBlockDump = true;



            PTotalBlockSize = 0;

            PBlocksDumpedSize = 0;

            for (int i = 0; i < dumpranges.Count; i++)

                PTotalBlockSize += dumpranges[i].rangeLength;



            PBlockCount = dumpranges.Count;



            // This is only here to satisfy the for loop condition, dump sets this to false too

            gecko.CancelDump = false;



            //Stream backupStream = blockDump.getOutputStream();

            //Stream[] streams = { stream, backupStream };

            //Stream[] streams = { stream };



            //stream.Seek(0, SeekOrigin.Begin);



            for (int i = 0; i < dumpranges.Count && !gecko.CancelDump; i++)

            {

                PBlockID = i + 1;

                PBlockStart = dumpranges[i].startAddress;

                PBlockEnd = dumpranges[i].endAddress;



                // Seek in the seek-able stream...

                //stream.Seek(dumpranges[i].streamOffset, SeekOrigin.Begin);

                //int fillCount = (int)(dumpranges[i].streamOffset - backupStream.Position);

                //byte[] zeroes = new byte[fillCount];

                

                // ZipOutputStream can't seek, so fill with zeroes

                //backupStream.Write(zeroes, 0, fillCount);



                //gecko.Dump(dumpranges[i].startAddress, dumpranges[i].endAddress, streams);

                SafeDump(dumpranges[i].startAddress, dumpranges[i].endAddress, blockDump);



                



                PBlocksDumpedSize += dumpranges[i].rangeLength;

            }



            //backupStream.Dispose();



            PBlockDump = false;

        }



        private List<DumpRange> FindDumpRanges(UInt32 startAddress, Byte valueLength, int lowIndex, int highIndex)

        {

            const UInt32 blockSize = 0x3E000;



            List<DumpRange> dumpranges = new List<DumpRange>();



            UInt32 lastAddress;



            if (resultAddressList.Count > 0)

            {

                lastAddress = resultAddressList[lowIndex];

            }

            else

            {

                lastAddress = startAddress;   

            }

            

            DumpRange addRange = new DumpRange(lastAddress);

            addRange.streamOffset = lastAddress - startAddress;



            // Check from lowIndex to highIndex in resultAddressList for dump ranges

            for (int i = lowIndex + 1; i <= highIndex; i++)

            {

                if (resultAddressList[i] >= lastAddress + blockSize)

                {

                    addRange.endAddress = lastAddress + valueLength;

                    addRange.rangeLength =

                        addRange.endAddress - addRange.startAddress;

                    dumpranges.Add(addRange);

                    lastAddress = resultAddressList[i];

                    addRange = new DumpRange(lastAddress);

                    addRange.streamOffset = lastAddress - startAddress;

                }

                lastAddress = resultAddressList[i];

            }

            addRange.endAddress = lastAddress + valueLength;

            addRange.rangeLength =

                addRange.endAddress - addRange.startAddress;

            dumpranges.Add(addRange);

            return dumpranges;

        }



        private bool Compare(UInt32 given, UInt32 loExpected, UInt32 hiExpected, bool useHigh,

            ComparisonType cType, UInt32 diffBy, bool floatCompare)

        {

            if (floatCompare)

            {

                Single givenSingle = GlobalFunctions.UIntToSingle(given),

                    loExpectedSingle = GlobalFunctions.UIntToSingle(loExpected),

                    diffBySingle = GlobalFunctions.UIntToSingle(diffBy);

                // Bail if any of the inputs are Not a Number

                if (Single.IsNaN(givenSingle) || Single.IsNaN(loExpectedSingle) || Single.IsNaN(diffBySingle))

                {

                    return false;

                }



                switch (cType)

                {

                    case ComparisonType.Equal: return (givenSingle == loExpectedSingle);

                    case ComparisonType.NotEqual: return (givenSingle != loExpectedSingle);

                    case ComparisonType.Greater: return (givenSingle > loExpectedSingle);

                    case ComparisonType.GreaterEqual: return (givenSingle >= loExpectedSingle);

                    case ComparisonType.Lower: return (givenSingle < loExpectedSingle);

                    case ComparisonType.LowerEqual: return (givenSingle <= loExpectedSingle);

                    case ComparisonType.DifferentBy: return (loExpectedSingle - diffBySingle == givenSingle || loExpectedSingle + diffBySingle == givenSingle);

                    case ComparisonType.DifferentByLess: return (loExpectedSingle - diffBySingle < givenSingle && givenSingle < loExpectedSingle + diffBySingle);

                    case ComparisonType.DifferentByMore: return (givenSingle < loExpectedSingle - diffBySingle || givenSingle > loExpectedSingle + diffBySingle);

                    default: return (givenSingle == loExpectedSingle);

                }

            }

            else if (useHigh)

            {

                switch (cType)

                {

                    case ComparisonType.Equal: return (given >= loExpected && given <= hiExpected);

                    case ComparisonType.NotEqual: return (given < loExpected || given > hiExpected);

                    case ComparisonType.Greater: return (given > hiExpected);

                    case ComparisonType.GreaterEqual: return (given >= hiExpected);

                    case ComparisonType.Lower: return (given < loExpected);

                    case ComparisonType.LowerEqual: return (given <= loExpected);

                    default: return (given >= loExpected && given <= hiExpected);

                }

            }

            else

            {

                switch (cType)

                {

                    case ComparisonType.Equal: return (given == loExpected);

                    case ComparisonType.NotEqual: return (given != loExpected);

                    case ComparisonType.Greater: return (given > loExpected);

                    case ComparisonType.GreaterEqual: return (given >= loExpected);

                    case ComparisonType.Lower: return (given < loExpected);

                    case ComparisonType.LowerEqual: return (given <= loExpected);

                    case ComparisonType.DifferentBy: return (loExpected - diffBy == given || loExpected + diffBy == given);

                    // Are these right?  How are they supposed to work?

                    // Would ByLess with given 6 and expected 8 with diffBy 3 be true...

                    // 8 - 3 = 5 < 6 OR 8 + 3 = 11 > 6 (shouldn't this be and?)

                    // ByMore, using DiffBy 1 should be true...

                    // 8 - 1 = 7 > 6 AND 8 + 1 = 9 < 6 (shouldn't this be or?)



                    // I'm changing these because I'm pretty sure I'm right...

                    case ComparisonType.DifferentByLess: return (loExpected - diffBy < given && given < loExpected + diffBy);

                    case ComparisonType.DifferentByMore: return (given < loExpected - diffBy || given > loExpected + diffBy);

                    default: return (given == loExpected);

                }

            }

        }



        //private bool CompareRefactored(UInt32 given, UInt32 loExpected, List<SearchComparisonInfo> comparisons, bool floatCompare, SearchType sType)

        private bool CompareRefactored(UInt32 newDumpVal, UInt32 oldDumpVal, UInt32 UndoDumpVal, List<SearchComparisonInfo> comparisons, bool floatCompare)

        {

            bool success = true;

            int others = 0;    // 0 = did not run, -1 = ran and failed, 1 = ran and succeeded

            int GT = 0;

            int LT = 0;

            bool reverseGTLT = false;

            UInt32 GTValue = 0, LTValue = 0;

            foreach (SearchComparisonInfo comp in comparisons)

            {

                UInt32 LHS = newDumpVal;

                UInt32 RHS = comp.value;



                SearchType sType = comp.searchType;



                if (sType == SearchType.Unknown)

                {

                    RHS = oldDumpVal;

                }

                else if (sType == SearchType.Old)

                {

                    RHS = UndoDumpVal;

                }

                else if (sType == SearchType.Diff)

                {

                    LHS = newDumpVal - oldDumpVal;

                }

                

                success = CompareRefactored(LHS, RHS, comp.comparisonType, comp.value, floatCompare);



                if (comp.comparisonType == ComparisonType.Equal)

                {

                    // If any individual equals comparisons succeed, win immediately

                    if (success) return true;

                }

                else if (comp.comparisonType == ComparisonType.GreaterEqual || comp.comparisonType == ComparisonType.Greater)

                {

                    // Store this in case we need to do a reverseGTLT

                    GTValue = comp.value;



                    // Indicate both that we tested (by being non-zero) and success (positive/negative)

                    if (success) GT = 1;

                    else GT = -1;



                    // If some LT test before us ran, and we're reversed, take note

                    if (LT != 0 && GTValue > LTValue)

                    {

                        reverseGTLT = true;

                    }

                }

                else if (comp.comparisonType == ComparisonType.Lower || comp.comparisonType == ComparisonType.LowerEqual)

                {

                    LTValue = comp.value;



                    if (success) LT = 1;

                    else LT = -1;



                    if (GT != 0 && GTValue > LTValue)

                    {

                        reverseGTLT = true;

                    }

                }

                else

                {

                    // all other comparisons must all be true

                    // therefore, any failed fails them all



                    // as long as we didn't fail yet, and we are succeeding, note that we ran and were successful

                    // however, if we ever fail once, then it will fail forever

                    if (others != -1 && success) others = 1;

                    else others = -1;

                }

            }



            // if we got here, none of the equals have succeeded



            // if any of the others are ever false, fail

            if (others < 0) return false;



            // if at least one LT or GT are true, we have some more checks to do...

            if (LT > 0 || GT > 0)

            {

                // if it was a reversed GTLT, then only one must be true

                // if it wasn't reversed, then both must not fail

                if (reverseGTLT)

                {

                    return true;

                }

                else

                {

                    return LT > -1 && GT > -1;

                }

            }



            // if we got this far, then there were no GT/LT checks, or neither passed

            // any failed GT/LT checks fail the compare, but untested checks can continue

            if (LT < 0 || GT < 0) return false;



            // Now there are no GT/LT checks, pass or fail

            // if there was any successful others tests, succeed, otherwise no tests ever succeeded

            return (others > 0);

        }



        private bool CompareRefactored(UInt32 given, UInt32 loExpected, ComparisonType cType, UInt32 diffBy, bool floatCompare)

        {

            if (floatCompare)

            {

                Single givenSingle = GlobalFunctions.UIntToSingle(given),

                    loExpectedSingle = GlobalFunctions.UIntToSingle(loExpected),

                    diffBySingle = GlobalFunctions.UIntToSingle(diffBy);

                // Fail if any of the inputs are Not a Number

                if (Single.IsNaN(givenSingle) || Single.IsNaN(loExpectedSingle) || Single.IsNaN(diffBySingle))

                {

                    return false;

                }



                switch (cType)

                {

                    case ComparisonType.Equal: return (givenSingle == loExpectedSingle);

                    case ComparisonType.NotEqual: return (givenSingle != loExpectedSingle);

                    case ComparisonType.Greater: return (givenSingle > loExpectedSingle);

                    case ComparisonType.GreaterEqual: return (givenSingle >= loExpectedSingle);

                    case ComparisonType.Lower: return (givenSingle < loExpectedSingle);

                    case ComparisonType.LowerEqual: return (givenSingle <= loExpectedSingle);

                    case ComparisonType.DifferentBy: return (loExpectedSingle - diffBySingle == givenSingle || loExpectedSingle + diffBySingle == givenSingle);

                    case ComparisonType.DifferentByLess: return (loExpectedSingle - diffBySingle < givenSingle && givenSingle < loExpectedSingle + diffBySingle);

                    case ComparisonType.DifferentByMore: return (givenSingle < loExpectedSingle - diffBySingle || givenSingle > loExpectedSingle + diffBySingle);

                    default: return (givenSingle == loExpectedSingle);

                }

            }

            else

            {

                switch (cType)

                {

                    case ComparisonType.Equal: return (given == loExpected);

                    case ComparisonType.NotEqual: return (given != loExpected);

                    case ComparisonType.Greater: return (given > loExpected);

                    case ComparisonType.GreaterEqual: return (given >= loExpected);

                    case ComparisonType.Lower: return (given < loExpected);

                    case ComparisonType.LowerEqual: return (given <= loExpected);

                    case ComparisonType.DifferentBy: return (loExpected - diffBy == given || loExpected + diffBy == given);

                    // Are these right?  How are they supposed to work?

                    // Would ByLess with given 6 and expected 8 with diffBy 3 be true...

                    // 8 - 3 = 5 < 6 OR 8 + 3 = 11 > 6 (shouldn't this be and?)

                    // ByMore, using DiffBy 1 should be true...

                    // 8 - 1 = 7 > 6 AND 8 + 1 = 9 < 6 (shouldn't this be or?)



                    // I'm changing these because I'm pretty sure I'm right...

                    case ComparisonType.DifferentByLess: return (loExpected - diffBy < given && given < loExpected + diffBy);

                    case ComparisonType.DifferentByMore: return (given < loExpected - diffBy || given > loExpected + diffBy);

                    default: return (given == loExpected);

                }

            }

        }



        private void FindPairs(UInt32 sAddress, UInt32 eAddress, Byte valSize, out UInt32 firstAddress, out UInt32 lastAddress, out int firstAddressIndex, out int lastAddressIndex)

        {

            // TODO what is this function doing?

            firstAddress = sAddress;

            lastAddress = eAddress;

            firstAddressIndex = 0;

            lastAddressIndex = resultAddressList.Count - 1;

            for (int i = 0; i < resultAddressList.Count; i++)

            {

                if (sAddress <= resultAddressList[i])

                {

                    firstAddress = resultAddressList[i];

                    firstAddressIndex = i;

                    break;

                }

            }

            for (int i = resultAddressList.Count - 1; i >= 0; i--)

            {

                if (eAddress >= resultAddressList[i] + valSize)

                {

                    lastAddress = resultAddressList[i] + valSize;

                    lastAddressIndex = i;

                    break;

                }

            }

        }



        public void Reset()

        {

            NewSearch = true;

            InitialSearch = false;

            nxButton.Enabled = false;

            prvButton.Enabled = false;

            resLab.Text = "";

            //resList.Clear();

            resultAddressList.Clear();

            undoList.Clear();

            gView.Rows.Clear();

            if (newDump != null)

            {

                //newDump.dumpStream.Close();

                //newDump.dumpStream.Dispose();

                newDump = null;

            }

            if (oldDump != null)

            {

                //oldDump.dumpStream.Close();

                //oldDump.dumpStream.Dispose();

                oldDump = null;

            }

            if (undoDump != null)

            {

                //undoDump.dumpStream.Close();

                //undoDump.dumpStream.Dispose();

                undoDump = null;

            }



            dumpNum = 0;

        }



        public bool Search(UInt32 sAddress, UInt32 eAddress, UInt32 lValue, UInt32 hValue,

            bool useHValue, SearchType sType, SearchSize sSize, ComparisonType cType,

            UInt32 differentBy)

        {

            PBlockDump = false;



            resLab.Text = "Searching";

            Byte bufferlength = 0;



            switch (sSize)

            {

                case (SearchSize.Bit8): bufferlength = 1; break;

                case (SearchSize.Bit16): bufferlength = 2; break;

                default: bufferlength = 4; break;

            }



            bool floatCompare = sSize == SearchSize.Single;



            int oldSortedColumn = 0;

            SortOrder oldSortOrder = SortOrder.Ascending;

            SearchResultComparer comparer = new SearchResultComparer();

            // Search process requires list to be in order by address

            // We will restore the sort order afterward

            if (gView.SortedColumn != null)

            {

                oldSortedColumn = gView.SortedColumn.Index;

                oldSortOrder = gView.SortOrder;

            }

            if (oldSortedColumn != 0 || oldSortOrder != SortOrder.Ascending)

            {

                comparer.sortedColumn = 0;

                comparer.descending = false;

                resultAddressList.Sort(comparer);

            }



            // Do we need to do this?  Clearing the grid view makes it suck...

            //gView.Rows.Clear();

            this.sSize = sSize;



            // Pause Gecko - while changing blocks during block search

            // the game will sometimes move forward a few frames

            //bool WasRunning = (gecko.status() == WiiStatus.Running);

            //bool WTF = WasRunning;

            //while (WTF)

            //{

            //    gecko.Pause();

            //    System.Threading.Thread.Sleep(100);

            //    // Sometimes, the game doesn't actually pause...

            //    // So loop repeatedly until it does!

            //    WTF = (gecko.status() == WiiStatus.Running);

            //}

            //gecko.SafePause();



            bool doBlockSearch = false;

            bool doCompare = false;



            Dump searchDump;

            UInt32 dumpStart, dumpEnd, dumpOffset;



            dumpStart = sAddress;

            dumpEnd = eAddress;

            dumpOffset = 0;



            if (NewSearch || (UnknownStart && sType == SearchType.Exact))

            {

                // if an unknown search is followed by an exact search, it should be treated as an initial search

                InitialSearch = true;

                dumpNum = 0;



                // Dispose of any old dumps and lists

                if (newDump != null)

                {

                    //newDump.dumpStream.Dispose();

                    newDump = null;

                }

                resultAddressList.Clear();

                if (oldDump != null)

                {

                    //oldDump.dumpStream.Dispose();

                    oldDump = null;

                }



                // only do compares if it's an exact search

                if (sType == SearchType.Exact)

                {

                    doCompare = true;

                }

                else

                {

                    // Otherwise, it's an unknown search

                    UnknownLAddress = sAddress;

                    UnknownHAddress = eAddress;

                    UnknownStart = true;

                    NewSearch = false;      // I don't think we need this...

                }

            }

            else

            {

                // This is a second search...

                InitialSearch = false;

                doCompare = true;   // will always do a comparison

                if (UnknownStart)

                {

                    // if it's the search after an unknown search, check every address

                    // although double-check the start and end addresses, just in case they changed

                    dumpStart = Math.Max(UnknownLAddress, sAddress);

                    dumpEnd = Math.Min(UnknownHAddress, eAddress);

                    dumpOffset = dumpStart - UnknownLAddress;

                }

                else

                {

                    // otherwise, do a block search to avoid transferring useless data

                    doBlockSearch = true;

                }

            }



            // Clear out any old dumps before caching the current dumps

            if (undoDump != null)

            {

                //undoDump.dumpStream.Dispose();

            }

            undoDump = oldDump;

            oldDump = newDump;



            if (undoList != resultAddressList)

            {

                undoList.Clear();

            }

            undoList = resultAddressList;



            // Dump the contents of memory for the search, by either using a full dump or a block-search-dump

            try

            {

                if (doBlockSearch)

                {

                    UInt32 startAddress, endAddress;

                    int startAddressIndex, endAddressIndex;

                    FindPairs(sAddress, eAddress, bufferlength, out startAddress, out endAddress, out startAddressIndex, out endAddressIndex);

                    List<DumpRange> dumpRanges = FindDumpRanges(startAddress, bufferlength, startAddressIndex, endAddressIndex);

                    //orgStream = new MemoryStream((int)(fAddr - sAddr));

                    newDump = new Dump(startAddress, endAddress, dumpNum);

                    PerformBlockSearch(newDump, dumpRanges);

                    //newDump.WriteStreamToDisk();

                }

                else

                {

                    newDump = new Dump(dumpStart, dumpEnd, dumpNum);

                    gecko.Dump(newDump);

                }

            }

            catch (EUSBGeckoException e)

            {

                exceptionHandling.HandleException(e);

            }



            if (doCompare)

            {

                // The "original stream" is always the one we just read from the USB Gecko

                //Stream originalStream, compareStream;

                //originalStream = newDump.dumpStream;

                //compareStream = newDump.dumpStream;

                //// dumpOffset is 0 if sType = exact

                //originalStream.Seek(dumpOffset, SeekOrigin.Begin);



                // if sType != exact, compare against the previous dump

                if (sType != SearchType.Exact && sType != SearchType.Diff)

                {

                    //compareStream = oldDump.dumpStream;

                    //compareStream.Seek(0, SeekOrigin.Begin);

                    hValue = 0;

                    useHValue = false;

                }



                UInt32 val, cmpVal;

                // assume that it's exact and change it if not

                cmpVal = lValue;



                if (resultAddressList.Count > 0)

                {

                    // We have a working list so we will only check the values in that list

                    // Create a temporary list to write to while we read from the old one

                    List<UInt32> tempAddressList = new List<uint>();

                    foreach (UInt32 compareAddress in resultAddressList)

                    {

                        val = newDump.ReadAddress(compareAddress, bufferlength);

                        if (sType == SearchType.Unknown)

                        {

                            cmpVal = oldDump.ReadAddress(compareAddress, bufferlength);

                        }

                        else if (sType == SearchType.Old)

                        {

                            cmpVal = undoDump.ReadAddress(compareAddress, bufferlength);

                        }

                        else if (sType == SearchType.Diff)

                        {

                            val = val - oldDump.ReadAddress(compareAddress, bufferlength);

                        }



                        if (Compare(val, cmpVal, hValue, useHValue, cType, differentBy, floatCompare))

                        {

                            tempAddressList.Add(compareAddress);

                        }

                    }



                    // Copy the temporary list over

                    resultAddressList = tempAddressList;

                }

                else

                {

                    for (UInt32 i = newDump.StartAddress; i < newDump.EndAddress; i += bufferlength)

                    {

                        //// There are no pre-existing addresses to compare to!  compare all addresses

                        //while (originalStream.Position + bufferlength < originalStream.Length)

                        //{

                        //    val = ReadStream(originalStream, bufferlength);



                        // This will either happen on the very first search if it is specific,

                        // or the second search if the first search was unknown

                        // In either case, there cannot be an Old or Diff passed in

                        val = newDump.ReadAddress(i, bufferlength);

                        if (sType != SearchType.Exact)

                        {

                            //cmpVal = ReadStream(compareStream, bufferlength);

                            cmpVal = oldDump.ReadAddress(i, bufferlength);

                        }



                        if (Compare(val, cmpVal, hValue, useHValue, cType, differentBy, floatCompare))

                        {

                            resultAddressList.Add(i);

                        }

                    }

                }

            }





            //SearchHistoryItem item = new SearchHistoryItem();



            //item.searchDump = newDump;

            //item.resultsList = resultAddressList;





            //DateTime startTime = Logger.WriteLineTimedStarted("serializing search items");



            //searchHistory.SaveSearchBackground(dumpNum, resultAddressList, newDump);

            ////item.WriteCompressedZipBackground("foo.zip");



            //Logger.WriteLineTimedFinished("serializing search items", startTime);



            //startTime = Logger.WriteLineTimedStarted("deserializing search items");



            ////item.ReadCompressedZip("foo.zip");



            //Dump testDump = searchHistory.LoadSearchDump(dumpNum);



            //List<UInt32> testList = searchHistory.LoadSearchList(dumpNum);



            //Logger.WriteLineTimedFinished("deserializing search items", startTime);





            if (UnknownStart && !InitialSearch)

            {

                // clear UnknownStart if InitialSearch is false

                UnknownStart = false;

            }



            dumpNum++;





            //if (NewSearch || (UnknownStart && sType == SearchType.Exact))

            //{

            //    bool abort = false;

            //    InitialSearch = true;

            //    //orgStream = new MemoryStream((int)(eAddress - sAddress));

            //    Dump myDump = new Dump(sAddress, eAddress);

            //    resList.Clear();

            //    resultAddressList.Clear();

            //    try

            //    {

            //        gecko.CancelDump = false;

            //        //gecko.Dump(sAddress, eAddress, orgStream);

            //        gecko.Dump(myDump);

            //        orgStream = myDump.dumpStream;

            //        FileStream foo = new FileStream(Environment.CurrentDirectory + @"\searchdumps\dump0.ful", FileMode.Create);

            //        orgStream.WriteTo(foo);

            //        foo.Close();

            //        foo.Dispose();

            //        oldDump = null;

            //        newDump = myDump;

            //        orgStream.Seek(0, SeekOrigin.Begin);

            //        if (!gecko.CancelDump)

            //        {

            //            if (sType == SearchType.Exact)

            //            {

            //                //                         orgStream.Seek(0, SeekOrigin.Begin);

            //                UInt32 val;

            //                while (orgStream.Position + bufferlength < orgStream.Length)

            //                {

            //                    val = ReadStream(orgStream, bufferlength);

            //                    if (Compare(val, lValue, hValue, useHValue, cType, differentBy, floatCompare))

            //                    {

            //                        //resList.Add(new SearchResult(sAddress + (UInt32)orgStream.Position - bufferlength, val, 0));

            //                        resultAddressList.Add(sAddress + (UInt32)orgStream.Position - bufferlength);

            //                    }

            //                }

            //            }

            //            else

            //            {

            //                UnknownLAddress = sAddress;

            //                UnknownHAddress = eAddress;

            //                UnknownStart = true;

            //                NewSearch = false;

            //                abort = true;

            //            }

            //        }

            //        orgStream = null;

            //    }

            //    catch (EUSBGeckoException e)

            //    {

            //        Reset();

            //        exceptionHandling.HandleException(e);

            //        abort = true;

            //    }

            //}

            //else 

            //{

            //    InitialSearch = false;

            //    try

            //    {

            //        // This branch is only executed once, the search after an unknown search

            //        if (UnknownStart)

            //        {

            //            UnknownStart = false;

            //            UInt32 sAddr = Math.Max(UnknownLAddress, sAddress);

            //            UInt32 fAddr = Math.Min(UnknownHAddress, eAddress);

            //            UInt32 offset = sAddr - UnknownLAddress;



            //            cmpStream = new MemoryStream((int)(fAddr - sAddr));

            //            try

            //            {

            //                gecko.CancelDump = false;

            //                gecko.Dump(sAddr, fAddr, cmpStream);

            //                if (!gecko.CancelDump)

            //                {

            //                    orgStream.Seek(offset, SeekOrigin.Begin);

            //                    cmpStream.Seek(0, SeekOrigin.Begin);



            //                    UInt32 oldValue, newValue;

            //                    while (cmpStream.Position + bufferlength < cmpStream.Length)

            //                    {

            //                        newValue = ReadStream(cmpStream, bufferlength);

            //                        oldValue = ReadStream(orgStream, bufferlength);

            //                        if (Compare(newValue, oldValue, 0, false, cType, differentBy, floatCompare))

            //                            resList.Add(new SearchResult(sAddr + (UInt32)cmpStream.Position - bufferlength, newValue, oldValue));

            //                    }

            //                }

            //                else

            //                {

            //                    UnknownStart = true;

            //                    NewSearch = false;

            //                    return true;

            //                }

            //            }

            //            finally

            //            {

            //                cmpStream.Close();

            //                cmpStream = null;

            //            }

            //        }

            //        else

            //        {

            //            UInt32 sAddr, fAddr;

            //            UInt32 cmpV = lValue;

            //            bool useUpper = useHValue;

            //            bool lastV = false;

            //            List<SearchResult> tempList = new List<SearchResult>();

            //            if (sType == SearchType.Unknown)

            //            {

            //                useUpper = false;

            //                lastV = true;

            //            }

            //            int lV, hV;

            //            FindPairs(sAddress, eAddress, bufferlength, out sAddr, out fAddr, out lV, out hV);

            //            orgStream = new MemoryStream((int)(fAddr - sAddr));

            //            //Insert block based search here

            //            PerformBlockSearch(sAddr, fAddr, bufferlength, lV, hV, orgStream);

            //            //gecko.Dump(sAddr, fAddr, orgStream);

            //            //end

            //            UInt32 val;



            //            // Compare the two dumps

            //            for (int i = lV; i <= hV && !gecko.CancelDump; i++)

            //            {

            //                if (lastV)

            //                    cmpV = resList[i].value;

            //                orgStream.Seek(resList[i].address - sAddr, SeekOrigin.Begin);

            //                val = ReadStream(orgStream, bufferlength);

            //                if (Compare(val, cmpV, hValue, useUpper, cType, differentBy, floatCompare))

            //                    tempList.Add(

            //                        new SearchResult(sAddr + (UInt32)orgStream.Position - bufferlength, val, resList[i].value));

            //            }



            //            // If this was canceled, don't update the results list

            //            if (!gecko.CancelDump)

            //            {

            //                resList.Clear();

            //                resList = null;

            //                resList = tempList;

            //            }

            //        }

            //    }

            //    catch (EUSBGeckoException e)

            //    {

            //        Reset();

            //        exceptionHandling.HandleException(e);

            //        return false;

            //    }

            //}



            //// If we were running, go back to running

            //// If we *weren't* running, *don't* go back to running

            //if (WasRunning)

            //{

            //    gecko.SafeResume();

            //}



            //if (orgStream != null)

            //{

            //    orgStream.Close();

            //}

            //orgStream = null;



            //if (resList.Count == 0 && resultAddressList.Count == 0)

            if (resultAddressList.Count == 0 && !UnknownStart)

            {

                NewSearch = true;

                nxButton.Enabled = false;

                prvButton.Enabled = false;

                resLab.Text = "No results found";

                Reset();

                return false;

            }



            NewSearch = false;



            //int PageCount = resList.Count / 256;

            //if (resList.Count % 256 != 0) PageCount++;



            //cPage = 0;

            //cPages = PageCount;



            //PrintPage();



            UpdateGridViewPage(true);



            return true;

        }



        public bool SearchRefactored(UInt32 sAddress, UInt32 eAddress, List<SearchComparisonInfo> comparisons, SearchSize searchSize)

        {

            PBlockDump = false;



            resLab.Text = "Searching";

            Byte bufferlength = 0;



            switch (searchSize)

            {

                case (SearchSize.Bit8): bufferlength = 1; break;

                case (SearchSize.Bit16): bufferlength = 2; break;

                default: bufferlength = 4; break;

            }



            this.sSize = searchSize;



            bool floatCompare = searchSize == SearchSize.Single;



            int oldSortedColumn = 0;

            SortOrder oldSortOrder = SortOrder.Ascending;

            SearchResultComparer comparer = new SearchResultComparer();

            // Search process requires list to be in order by address

            // We will restore the sort order afterward

            if (gView.SortedColumn != null)

            {

                oldSortedColumn = gView.SortedColumn.Index;

                oldSortOrder = gView.SortOrder;

            }

            if (oldSortedColumn != 0 || oldSortOrder != SortOrder.Ascending)

            {

                comparer.sortedColumn = 0;

                comparer.descending = false;

                resultAddressList.Sort(comparer);

            }



            SearchType sType = comparisons[0].searchType;



            bool doBlockSearch = false;

            bool doCompare = false;



            Dump searchDump;

            UInt32 dumpStart, dumpEnd, dumpOffset;



            dumpStart = sAddress;

            dumpEnd = eAddress;

            dumpOffset = 0;



            if (NewSearch || (UnknownStart && sType == SearchType.Exact))

            {

                // if an unknown search is followed by an exact search, it should be treated as an initial search

                InitialSearch = true;

                dumpNum = 0;



                // Dispose of any old dumps and lists

                if (newDump != null)

                {

                    //newDump.dumpStream.Dispose();

                    newDump = null;

                }

                resultAddressList.Clear();

                if (oldDump != null)

                {

                    //oldDump.dumpStream.Dispose();

                    oldDump = null;

                }



                // only do compares if it's an exact search

                if (sType == SearchType.Exact)

                {

                    doCompare = true;

                }

                else

                {

                    // Otherwise, it's an unknown search

                    UnknownLAddress = sAddress;

                    UnknownHAddress = eAddress;

                    UnknownStart = true;

                    NewSearch = false;      // I don't think we need this...

                }

            }

            else

            {

                // This is a second search...

                InitialSearch = false;

                doCompare = true;   // will always do a comparison

                if (UnknownStart)

                {

                    // if it's the search after an unknown search, check every address

                    // although double-check the start and end addresses, just in case they changed

                    dumpStart = Math.Max(UnknownLAddress, sAddress);

                    dumpEnd = Math.Min(UnknownHAddress, eAddress);

                    dumpOffset = dumpStart - UnknownLAddress;

                }

                else

                {

                    // otherwise, do a block search to avoid transferring useless data

                    doBlockSearch = true;

                }

            }



            // Clear out any old dumps before caching the current dumps

            undoDump = oldDump;

            oldDump = newDump;

            undoList = resultAddressList;



            // Dump the contents of memory for the search, by either using a full dump or a block-search-dump

            if (doBlockSearch)

            {

                UInt32 startAddress, endAddress;

                int startAddressIndex, endAddressIndex;

                FindPairs(dumpStart, dumpEnd, bufferlength, out startAddress, out endAddress, out startAddressIndex, out endAddressIndex);

                List<DumpRange> dumpRanges = FindDumpRanges(startAddress, bufferlength, startAddressIndex, endAddressIndex);

                newDump = new Dump(startAddress, endAddress, dumpNum);

                PerformBlockSearch(newDump, dumpRanges);

            }

            else

            {

                newDump = new Dump(dumpStart, dumpEnd, dumpNum);

                SafeDump(dumpStart, dumpEnd, newDump);

            }



            if (doCompare)

            {

                UInt32 val, cmpVal;

                // assume that it's exact and change it if not

                cmpVal = comparisons[0].value;



                if (resultAddressList.Count > 0)

                {

                    // We have a working list so we will only check the values in that list

                    // Create a temporary list to write to while we read from the old one

                    List<UInt32> tempAddressList = new List<uint>();

                    foreach (UInt32 compareAddress in resultAddressList)

                    {

                        UInt32 newDumpVal = newDump.ReadAddress(compareAddress, bufferlength);

                        UInt32 oldDumpVal = oldDump.ReadAddress(compareAddress, bufferlength);

                        UInt32 UndoDumpVal;

                        if (undoDump != null)

                        {

                            UndoDumpVal = undoDump.ReadAddress(compareAddress, bufferlength);

                        }

                        else

                        {

                            UndoDumpVal = oldDumpVal;

                        }

                        if (CompareRefactored(newDumpVal, oldDumpVal, UndoDumpVal, comparisons, floatCompare))

                        {

                            tempAddressList.Add(compareAddress);

                        }

                    }



                    // Copy the temporary list over

                    resultAddressList = tempAddressList;

                }

                else

                {

                    for (UInt32 i = newDump.StartAddress; i < newDump.EndAddress; i += bufferlength)

                    {

                        // There are no pre-existing addresses to compare to!  compare all addresses



                        // This will either happen on the very first search if it is specific,

                        // or the second search if the first search was unknown

                        // In either case, there cannot be an Old or Diff passed in

                        UInt32 newDumpVal = newDump.ReadAddress(i, bufferlength);

                        UInt32 oldDumpVal = newDumpVal;

                        UInt32 UndoDumpVal = newDumpVal;

                        if (sType != SearchType.Exact)

                        {

                            oldDumpVal = oldDump.ReadAddress(i, bufferlength);

                            UndoDumpVal = oldDumpVal;

                        }



                        //if (Compare(val, cmpVal, hValue, useHValue, cType, differentBy, floatCompare))

                        if (CompareRefactored(newDumpVal, oldDumpVal, UndoDumpVal, comparisons, floatCompare))

                        {

                            resultAddressList.Add(i);

                        }

                    }

                }

            }



            if (UnknownStart && !InitialSearch)

            {

                // clear UnknownStart if InitialSearch is false

                UnknownStart = false;

            }



            dumpNum++;



            if (resultAddressList.Count == 0 && !UnknownStart)

            {

                DialogResult result = MessageBox.Show(null, "No search results!\n\nTo undo, press Yes\nTo restart, press No", "No search results!", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);

                bool UndoSuccess = false;

                if (result == DialogResult.Yes)

                {

                    UndoSuccess = UndoSearch();

                    if (!UndoSuccess)

                    {

                        MessageBox.Show("Could not undo!  Restarting search");

                    }

                }



                if (!UndoSuccess)

                {

                    NewSearch = true;

                    nxButton.Enabled = false;

                    prvButton.Enabled = false;

                    resLab.Text = "No results found";

                    Reset();

                    return false;

                }

            }



            NewSearch = false;



            UpdateGridViewPage(true);



            return true;

        }



        public void SafeDump(UInt32 startdump, UInt32 enddump, Dump memdump)

        {

            bool finished = false;

            while (!finished)

            {

                try

                {

                    gecko.Dump(startdump, enddump, memdump);

                    finished = true;

                }

                catch (EUSBGeckoException e)

                {

                    exceptionHandling.HandleException(e);

                    if (startdump == memdump.ReadCompletedAddress)

                    {

                        // failed to get any more data; something is probably really wrong so let's just quit

                        finished = true;

                    }

                    else

                    {

                        startdump = memdump.ReadCompletedAddress;

                    }

                }

            }

        }







        public bool UndoSearch()

        {

            if (newDump == null || oldDump == null || undoDump == null)

            {

                return false;

            }

            //newDump.dumpStream.Dispose();

            newDump = oldDump;

            oldDump = undoDump;

            undoDump = null;

            resultAddressList.Clear();

            resultAddressList = new List<uint>(undoList);



            UpdateGridViewPage(true);

            return true;

        }



        public bool SaveSearch(string path)

        {

            return SaveSearch(path, true);

        }



        public bool SaveSearch(string path, bool compressed)

        {

            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializeResults = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();



            if (!compressed)

            {

                FileStream resultFile = new FileStream(path, FileMode.Create);

                serializeResults.Serialize(resultFile, sSize);

                //serializeResults.Serialize(resultFile, resList);

                // TODO SAVING SEARCHES TO FILE

                resultFile.Close();

                return true;

            }



            ZipOutputStream resultStream = new ZipOutputStream(path);

            resultStream.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;

            resultStream.PutNextEntry("ResList");



            // good first guess

            //MemoryStream resultStream = new MemoryStream(12 * resList.Count);