#include "stdafx.h"
#include "MemoryScanner.h"

CMixed::TypeNameEntry CMixed::TypeNames[] = {
    { "uint8",   ValueType_uint8 },
    { "int8",    ValueType_int8 },
    { "uint16",  ValueType_uint16 },
    { "int16",   ValueType_int16 },
    { "uint32",  ValueType_uint32 },
    { "int32",   ValueType_int32 },
    { "uint64",  ValueType_uint64 },
    { "int64",   ValueType_int64 },
    { "float",   ValueType_float },
    { "double",  ValueType_double },
    { "char",    ValueType_string },
    { "char",    ValueType_unkstring },
    { "char",    ValueType_unkstring },
    { nullptr,      ValueType_invalid}
};

const char* CMixed::GetTypeName(void)
{
    switch (m_Type)
    {
    case ValueType_uint8:  return "uint8";
    case ValueType_int8:   return "int8";
    case ValueType_uint16: return "uint16";
    case ValueType_int16:  return "int16";
    case ValueType_uint32: return "uint32";
    case ValueType_int32:  return "int32";
    case ValueType_uint64: return "uint64";
    case ValueType_int64:  return "int64";
    case ValueType_float:  return "float";
    case ValueType_double: return "double";
    case ValueType_string:
    case ValueType_istring:
    case ValueType_unkstring:
        return "char";
    }

    return nullptr;
}

ValueType CMixed::GetTypeFromString(const char* name, int* charArrayLength)
{
    for (int i = 0; TypeNames[i].name != nullptr; i++)
    {
        if (strcmp(name, TypeNames[i].name) == 0)
        {
            *charArrayLength = 0;
            return TypeNames[i].type;
        }
    }

    if (sscanf(name, "char[%d]", charArrayLength) != 0)
    {
        return ValueType_string;
    }

    return ValueType_invalid;
}

int CMixed::GetTypeSize(void)
{
    switch (m_Type)
    {
    case ValueType_uint8:  return sizeof(uint8_t);
    case ValueType_int8:   return sizeof(int8_t);
    case ValueType_uint16: return sizeof(uint16_t);
    case ValueType_int16:  return sizeof(int16_t);
    case ValueType_uint32: return sizeof(uint32_t);
    case ValueType_int32:  return sizeof(int32_t);
    case ValueType_uint64: return sizeof(uint64_t);
    case ValueType_int64:  return sizeof(int64_t);
    case ValueType_float:  return sizeof(float);
    case ValueType_double: return sizeof(double);
    case ValueType_string:
    case ValueType_istring:
    case ValueType_unkstring:
        return m_StrLength;
    default:
        return 0;
    }
}

bool CMixed::IsStringType(void)
{
    switch (m_Type)
    {
    case ValueType_string:
    case ValueType_istring:
    case ValueType_unkstring:
        return true;
    }

    return false;
}

int CMixed::ToString(char* buffer, bool bHex, size_t size)
{
    if (bHex)
    {
        switch (m_Type)
        {
        case ValueType_uint8:
        case ValueType_int8:
            return snprintf(buffer, size, "0x%02X", m_Value._uint8);
        case ValueType_uint16:
        case ValueType_int16:
            return snprintf(buffer, size, "0x%04X", m_Value._uint16);
        case ValueType_uint32:
        case ValueType_int32:
        case ValueType_float:
            return snprintf(buffer, size, "0x%08X", m_Value._uint32);
        case ValueType_uint64:
        case ValueType_int64:
        case ValueType_double:
            return snprintf(buffer, size, "0x%016llX", m_Value._uint64);
        default:
            return snprintf(buffer, size, "?");
        }
    }

    switch (m_Type)
    {
    case ValueType_uint8:  return snprintf(buffer, size, "%d", m_Value._uint8);
    case ValueType_int8:   return snprintf(buffer, size, "%d", m_Value._sint8);
    case ValueType_uint16: return snprintf(buffer, size, "%d", m_Value._uint16);
    case ValueType_int16:  return snprintf(buffer, size, "%d", m_Value._sint16);
    case ValueType_uint32: return snprintf(buffer, size, "%lu", m_Value._uint32);
    case ValueType_int32:  return snprintf(buffer, size, "%d", m_Value._sint32);
    case ValueType_uint64: return snprintf(buffer, size, "%llu", m_Value._uint64);
    case ValueType_int64:  return snprintf(buffer, size, "%lld", m_Value._sint64);
    case ValueType_float:  return snprintf(buffer, size, "%f", m_Value._float);
    case ValueType_double: return snprintf(buffer, size, "%f", m_Value._double);
    default: return snprintf(buffer, size, "?");
    }
}

CScanResult::CScanResult(AddressType addressType, DisplayFormat displayFormat) :
    m_AddressType(addressType),
    m_Address(0),
    m_DisplayFormat(displayFormat),
    m_bSelected(false)
{
}

CScanResult::~CScanResult(void)
{
}

void CScanResult::SetDescription(const char* str)
{
    m_Description = str;
}

void CScanResult::DeleteDescription(void)
{
    m_Description.clear();
}

const char* CScanResult::GetDescription(void)
{
    return m_Description.c_str();
}

int CScanResult::GetValueString(char *buffer, size_t size)
{
    bool bHex = (m_DisplayFormat == DisplayHex);
    return ToString(buffer, bHex, size);
}

bool CScanResult::GetMemoryValue(CMixed* v)
{
    if (g_MMU == nullptr)
    {
        return false;
    }

    uint32_t paddr = m_Address & 0x1FFFFFFF;

    if (!CMemoryScanner::PAddrValid(paddr))
    {
        return false;
    }

    uint8_t* mem = CMemoryScanner::GetMemoryPool(paddr);

    uint64_t raw64 = 0;

    if (GetTypeSize() == 8)
    {
        raw64 = ((uint64_t)*(uint32_t*)&mem[paddr] << 32) | *(uint32_t*)&mem[paddr + 4];
    }

    switch (m_Type)
    {
    case ValueType_uint8:  v->Set(*(uint8_t*) &mem[paddr ^ 3]); break;
    case ValueType_int8:   v->Set(*(int8_t*)  &mem[paddr ^ 3]); break;
    case ValueType_uint16: v->Set(*(uint16_t*)&mem[paddr ^ 2]); break;
    case ValueType_int16:  v->Set(*(int16_t*) &mem[paddr ^ 2]); break;
    case ValueType_uint32: v->Set(*(uint32_t*)&mem[paddr]); break;
    case ValueType_int32:  v->Set(*(int32_t*)&mem[paddr]); break;
    case ValueType_uint64: v->Set(*(uint64_t*)&raw64); break;
    case ValueType_int64:  v->Set(*(int64_t*)&raw64); break;
    case ValueType_float:  v->Set(*(float*)&mem[paddr]); break;
    case ValueType_double: v->Set(*(double*)&raw64); break;
    default: return false; // (primitives only)
    }

    return true;
}

int CScanResult::GetMemoryValueString(char* buffer, size_t size, bool bIgnoreHex)
{
    if (g_MMU == nullptr)
    {
        sprintf(buffer, "?");
        return 1;
    }
    
    bool bHex = (m_DisplayFormat == DisplayHex) && !bIgnoreHex;

    uint32_t paddr = m_Address & 0x1FFFFFFF;

    if (!CMemoryScanner::PAddrValid(paddr))
    {
        return sprintf(buffer, "?");
    }

    uint8_t* mem = CMemoryScanner::GetMemoryPool(paddr);

    if (m_Type == ValueType_istring ||
        m_Type == ValueType_string  ||
        m_Type == ValueType_unkstring)
    {
        if (bHex)
        {
            char* out = buffer;

            for (int i = 0; i < m_StrLength; i++)
            {
                uint32_t ipaddr = (paddr + i) ^ 3;
                if (i != 0) out += sprintf(out, " ");
                out += sprintf(out, "%02X", mem[ipaddr]);
            }
            *out = '\0';
            return out - buffer;
        }
        else
        {
            for (int i = 0; i < m_StrLength; i++)
            {
                uint32_t ipaddr = (paddr + i) ^ 3;
                buffer[i] = mem[ipaddr];
            }
            buffer[m_StrLength] = '\0';
            return m_StrLength;
        }
    }

    CMixed memVal;
    if (!GetMemoryValue(&memVal))
    {
        return 0;
    }

    return memVal.ToString(buffer, bHex, size);
}

int CScanResult::GetAddressString(char *buffer)
{
    return sprintf(buffer, "0x%08X", m_Address);
}

uint32_t CScanResult::GetVirtualAddress(void)
{
    if (m_AddressType == AddressType_Virtual)
    {
        return m_Address;
    }
    else
    {
        // Convert physical to virtual kseg0
        return (m_Address | 0x80000000);
    }
}

bool CScanResult::SetMemoryValueFromString(const char* str)
{
    if (g_MMU == nullptr)
    {
        //sprintf(buffer, "?");
        return false;
    }

    bool bHex = (m_DisplayFormat == DisplayHex);

    uint32_t paddr = m_Address & 0x1FFFFFFF;

    if (!CMemoryScanner::PAddrValid(paddr))
    {
        return false;
    }

    uint8_t* mem = CMemoryScanner::GetMemoryPool(m_Address & 0x1FFFFFFF);

    char* endptr;
    uint64_t intVal = strtoull(str, &endptr, 0);
    double doubleVal = strtod(str, &endptr);

    switch (m_Type)
    {
    case ValueType_uint8:
    case ValueType_int8:
        mem[paddr ^ 3] = intVal & 0xFF;
        break;
    case ValueType_uint16:
    case ValueType_int16:
        *(uint16_t*)&mem[paddr ^ 2] = intVal & 0xFFFF;
        break;
    case ValueType_uint32:
    case ValueType_int32:
        *(uint32_t*)&mem[paddr] = intVal & 0xFFFFFFFF;
        break;
    case ValueType_uint64:
    case ValueType_int64:
        *(uint64_t*)&mem[paddr] = (intVal << 32) | (intVal >> 32);
        break;
    case ValueType_float:
        if (bHex)
        {
            *(uint32_t*)&mem[paddr] = intVal & 0xFFFFFFFF;
            break;
        }
        *(float*)&mem[paddr] = (float)doubleVal;
        break;
    case ValueType_double:
        if (bHex)
        {
            *(uint64_t*)&mem[paddr] = (intVal << 32) | (intVal >> 32);
            break;
        }
        intVal = *(uint64_t*)&doubleVal;
        *(uint64_t*)&mem[paddr] = (intVal << 32) | (intVal >> 32);
        break;
    case ValueType_string:
    case ValueType_istring:
    case ValueType_unkstring:
        if (bHex)
        {
            int size = CMemoryScanner::ParseHexString(nullptr, str);
            if (size == 0)
            {
                return false;
            }

            char* buff = new char[size];
            CMemoryScanner::ParseHexString(buff, str);

            for (int i = 0; i < m_StrLength; i++)
            {
                uint32_t ipaddr = (paddr + i) ^ 3;
                mem[ipaddr] = buff[i];
            }

            delete[] buff;
        }
        else
        {
            for (int i = 0; i < m_StrLength; i++)
            {
                uint32_t ipaddr = (paddr + i) ^ 3;
                mem[ipaddr] = str[i];
            }
        }
        break;
    }

    return true;
}

bool CScanResult::SetAddressSafe(uint32_t address)
{
    if (!g_MMU || !g_Rom)
    {
        return false;
    }

    uint32_t ramSize = g_MMU->RdramSize();
    uint32_t romSize = g_Rom->GetRomSize();

    uint32_t paddrStart = address & 0x1FFFFFFF;
    uint32_t paddrEnd = (paddrStart + GetTypeSize()) - 1;

    if (m_AddressType == AddressType_Virtual)
    {
        if (!CMemoryScanner::AddrCheck(address, 0x80000000, 0xBFFFFFFF))
        {
            return false;
        }
    }

    if (!CMemoryScanner::PAddrRangeValid(paddrStart, paddrEnd))
    {
        return false;
    }

    if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) &&
        !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) &&
        !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
    {
        return false;
    }

    m_Address = address;

    return true;
}

bool CScanResult::SetStrLengthSafe(int length)
{
    if (!g_MMU || !g_Rom)
    {
        return false;
    }

    uint32_t ramSize = g_MMU->RdramSize();
    uint32_t romSize = g_Rom->GetRomSize();

    uint32_t paddrStart = m_Address & 0x1FFFFFFF;
    uint32_t paddrEnd = (paddrStart + length) - 1;

    if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) &&
        !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) &&
        !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
    {
        return false;
    }

    m_StrLength = length;

    return true;
}

//bool CScanResult::IsSelected(void)
//{
//    return m_bSelected;
//}
//
//void CScanResult::SetSelected(bool bSelected)
//{
//    m_bSelected = bSelected;
//}

CMemoryScanner::CMemoryScanner(void) :
    m_DidFirstScan(false),
    m_ValueType(ValueType_uint8),
    m_StringValueLength(false),
    m_bDataTypePrimitive(true),
    m_SearchType(SearchType_ExactValue),
    m_AddressType(AddressType_Virtual),
    m_VAddrBits(0x80000000),
    m_Memory(nullptr)
{
    m_Value._uint64 = 0;
    SetAddressRange(0x80000000, 0x803FFFFF);
}

bool CMemoryScanner::RangeCheck(uint32_t addrStart, uint32_t addrEnd, uint32_t rangeStart, uint32_t rangeEnd)
{
    return (addrStart <= addrEnd) && (addrStart >= rangeStart) && (addrEnd <= rangeEnd);
}

bool CMemoryScanner::AddrCheck(uint32_t addr, uint32_t rangeStart, uint32_t rangeEnd)
{
    return (addr >= rangeStart) && (addr <= rangeEnd);
}

bool CMemoryScanner::PAddrValid(uint32_t physAddr)
{
    if (g_MMU == nullptr || g_Rom == nullptr)
    {
        g_Notify->BreakPoint(__FILE__, __LINE__);
    }

    uint32_t ramSize = g_MMU->RdramSize();
    uint32_t romSize = g_Rom->GetRomSize();

    return (AddrCheck(physAddr, 0x00000000, 0x00000000 + ramSize - 1) ||
        AddrCheck(physAddr, 0x10000000, 0x10000000 + romSize - 1) ||
        AddrCheck(physAddr, 0x04000000, 0x04001FFF));
}

bool CMemoryScanner::PAddrRangeValid(uint32_t physAddrStart, uint32_t physAddrEnd)
{
    return (RangeCheck(physAddrStart, physAddrEnd, 0x00000000, g_MMU->RdramSize()) ||
        RangeCheck(physAddrStart, physAddrEnd, 0x04000000, 0x04001FFF) ||
        RangeCheck(physAddrStart, physAddrEnd, 0x10000000, 0x15FFFFFF));
}

void CMemoryScanner::SetAddressType(AddressType addressType)
{
    m_AddressType = addressType;
}

void CMemoryScanner::Reset(void)
{
    m_DidFirstScan = false;

    m_ValueType = ValueType_uint8;
    m_SearchType = SearchType_ExactValue;
    
    m_Results.clear();
}

bool CMemoryScanner::SetAddressRange(uint32_t startAddress, uint32_t endAddress)
{
    if (!g_MMU || !g_Rom)
    {
        return false;
    }

    if(m_DidFirstScan)
    {
        return false;
    }

    if (m_AddressType == AddressType_Virtual)
    {
        m_VAddrBits = startAddress & 0xE0000000;

        // Don't allow TLB
        if (!RangeCheck(startAddress, endAddress, 0x80000000, 0xBFFFFFFF))
        {
            return false;
        }

        // Use physical addresses internally
        startAddress = startAddress & 0x1FFFFFFF;
        endAddress = endAddress & 0x1FFFFFFF;
    }
    else
    {
        m_VAddrBits = 0;
    }

    if (RangeCheck(startAddress, endAddress, 0x00000000, 0x007FFFFF))
    {
        if (endAddress >= g_MMU->RdramSize())
        {
            return false;
        }

        m_Memory = g_MMU->Rdram();
    }
    else if (RangeCheck(startAddress, endAddress, 0x04000000, 0x04001FFF))
    {
        m_Memory = g_MMU->Rdram();
    }
    else if (RangeCheck(startAddress, endAddress, 0x10000000, 0x10FFFFFF))
    {
        if ((endAddress - 0x10000000) >= g_Rom->GetRomSize())
        {
            return false;
        }

        m_Memory = (g_Rom->GetRomAddress() - 0x10000000);
    }
    else
    {
        return false; // Invalid range
    }
    
    m_Memory = GetMemoryPool(startAddress);

    m_RangeStartAddress = startAddress;
    m_RangeEndAddress = endAddress;
    return true;
}

uint8_t* CMemoryScanner::GetMemoryPool(uint32_t physAddr)
{
    if (!g_MMU || !g_Rom)
    {
        return nullptr;
    }

    if ((physAddr >= 0x00000000 && physAddr < g_MMU->RdramSize()) ||
        (physAddr >= 0x04000000 && physAddr <= 0x04001FFF))
    {
        return g_MMU->Rdram();
    }
    else if (physAddr >= 0x10000000 && physAddr <= 0x18000000)
    {
        return (g_Rom->GetRomAddress() - 0x10000000);
    }
    else
    {
        return nullptr;
    }

}

bool CMemoryScanner::SetValueType(ValueType type)
{
    if(m_DidFirstScan)
    {
        return false;
    }
    
    switch(type)
    {
    case ValueType_string:
    case ValueType_istring:
    case ValueType_unkstring:
        m_bDataTypePrimitive = false;
        break;
    default:
        m_bDataTypePrimitive = true;
        break;
    }
    
    m_ValueType = type;
    return true;
}

void CMemoryScanner::SetStringValueLength(int length)
{
    m_StringValueLength = length;
}

bool CMemoryScanner::SetSearchType(SearchType searchType)
{
    if(!m_bDataTypePrimitive)
    {
        return false;
    }
    
    switch(searchType)
    {
    case SearchType_UnknownValue:
    case SearchType_JalTo:
        if (m_DidFirstScan)
        {
            return false;
        }
        break;
    case SearchType_ChangedValue:
    case SearchType_UnchangedValue:
    case SearchType_IncreasedValue:
    case SearchType_DecreasedValue:
        if(!m_DidFirstScan)
        {
            return false;
        }
        break;
    }
    
    m_SearchType = searchType;
    return true;
}

bool CMemoryScanner::DidFirstScan(void)
{
    return m_DidFirstScan;
}

size_t CMemoryScanner::GetNumResults(void)
{
    return m_Results.size();
}

CScanResult* CMemoryScanner::GetResult(size_t index)
{
    if (index >= m_Results.size())
    {
        return nullptr;
    }

    return &m_Results[index];
}    

void CMemoryScanner::RemoveResult(size_t index)
{
    if (index >= m_Results.size())
    {
        return;
    }

    m_Results.erase(m_Results.begin() + index);
}

// Scan for text or hexadecimal array
void CMemoryScanner::FirstScanLoopString(DisplayFormat resultDisplayFormat)
{
    int length = m_StringValueLength;

    uint32_t startAddr = m_RangeStartAddress;
    uint32_t endAddr = (m_RangeEndAddress - length) + 1;

    CScanResult result(m_AddressType, resultDisplayFormat);
    result.SetStrLength(length);

    for (uint32_t addr = startAddr; addr <= endAddr; addr++)
    {
        for (int i = 0; i < length; i++)
        {
            uint32_t leAddr = (addr + i) ^ 3;
            if ((uint8_t)m_Value._string[i] != m_Memory[leAddr])
            {
                goto next_addr;
            }
        }

        result.m_Address = addr | m_VAddrBits;
        result.Set((const wchar_t*)nullptr);
        m_Results.push_back(result);
    next_addr:;
    }
}

// Scan for text (case-insensitive)
void CMemoryScanner::FirstScanLoopIString(DisplayFormat resultDisplayFormat)
{
    int length = m_StringValueLength;

    uint32_t startAddr = m_RangeStartAddress;
    uint32_t endAddr = m_RangeEndAddress - length;

    CScanResult result(m_AddressType, resultDisplayFormat);
    result.SetStrLength(length);

    for (uint32_t addr = startAddr; addr <= endAddr; addr++)
    {
        for (int i = 0; i < length; i++)
        {
            uint32_t leAddr = (addr + i) ^ 3;
            if (toupper((uint8_t)m_Value._string[i]) != toupper(m_Memory[leAddr]))
            {
                goto next_addr;
            }
        }

        result.m_Address = addr | m_VAddrBits;
        result.Set((const wchar_t*)nullptr);
        m_Results.push_back(result);
    next_addr:;
    }
}

// Scan for text of unknown single-byte encoding
void CMemoryScanner::FirstScanLoopUnkString(void)
{
    const char* str = stdstr().FromUTF16(m_Value._string).c_str();
    int length = m_StringValueLength;
    
    uint32_t startAddr = m_RangeStartAddress;
    uint32_t endAddr = m_RangeEndAddress - length;

    CScanResult result(m_AddressType, DisplayHex);
    result.SetStrLength(length);

    for (uint32_t addr = startAddr; addr <= endAddr; addr++)
    {
        uint32_t leAddr = addr ^ 3;

        char numberDiff = 0, lowercaseDiff = 0, uppercaseDiff = 0;
        bool haveNumberDiff = false, haveLowercaseDiff = false, haveUppercaseDiff = false;

        for (int i = 0; i < length; i++)
        {
            leAddr = (addr + i) ^ 3;

            if (!isalnum(str[i]))
            {
                continue;
            }

            if (str[i] >= 'a' && str[i] <= 'z')
            {
                if (!haveLowercaseDiff)
                {
                    lowercaseDiff = str[i] - m_Memory[leAddr];
                    haveLowercaseDiff = true;
                }
                else if (m_Memory[leAddr] + lowercaseDiff != str[i])
                {
                    goto next_addr;
                }
            }
            else if (str[i] >= 'A' && str[i] <= 'Z')
            {
                if (!haveUppercaseDiff)
                {
                    uppercaseDiff = str[i] - m_Memory[leAddr];
                    haveUppercaseDiff = true;
                }
                else if (m_Memory[leAddr] + uppercaseDiff != str[i])
                {
                    goto next_addr;
                }
            }
            else if (str[i] >= '0' && str[i] <= '9')
            {
                if (!haveNumberDiff)
                {
                    numberDiff = str[i] - m_Memory[leAddr];
                    haveNumberDiff = true;
                }
                else if (m_Memory[leAddr] + numberDiff != str[i])
                {
                    goto next_addr;
                }
            }
        }

        result.m_Address = addr | m_VAddrBits;
        result.Set((const wchar_t*)nullptr);
        m_Results.push_back(result);

    next_addr:;
    }
}

#define _FirstScanLoopPrimitive(T, Compare, resDisplayFormat) FirstScanLoopPrimitive<T>(Compare<T>, resDisplayFormat)
#define _FirstScanLoopPrimitive64(T, Compare, resDisplayFormat) FirstScanLoopPrimitive64<T>(Compare<T>, resDisplayFormat)

#define FIRST_SCAN_PRIMITIVES(CompareFunc) \
    switch(m_ValueType)                    \
    {                                      \
    case ValueType_uint8:  _FirstScanLoopPrimitive(uint8_t,  CompareFunc, resDisplayFormat); break; \
    case ValueType_int8:   _FirstScanLoopPrimitive(int8_t,   CompareFunc, resDisplayFormat); break; \
    case ValueType_uint16: _FirstScanLoopPrimitive(uint16_t, CompareFunc, resDisplayFormat); break; \
    case ValueType_int16:  _FirstScanLoopPrimitive(int16_t,  CompareFunc, resDisplayFormat); break; \
    case ValueType_uint32: _FirstScanLoopPrimitive(uint32_t, CompareFunc, resDisplayFormat); break; \
    case ValueType_int32:  _FirstScanLoopPrimitive(int32_t,  CompareFunc, resDisplayFormat); break; \
    case ValueType_uint64: _FirstScanLoopPrimitive64(uint64_t, CompareFunc, resDisplayFormat); break; \
    case ValueType_int64:  _FirstScanLoopPrimitive64(int64_t,  CompareFunc, resDisplayFormat); break; \
    case ValueType_float:  _FirstScanLoopPrimitive(float,    CompareFunc, resDisplayFormat); break; \
    case ValueType_double: _FirstScanLoopPrimitive64(double,   CompareFunc, resDisplayFormat); break; \
    }

bool CMemoryScanner::FirstScan(DisplayFormat resDisplayFormat)
{
    if (!g_MMU)
    {
        return false;
    }

    if (m_bDataTypePrimitive)
    {
        switch (m_SearchType)
        {
        case SearchType_UnknownValue:
            FIRST_SCAN_PRIMITIVES(NoCompare);
            break;
        case SearchType_ExactValue:
            FIRST_SCAN_PRIMITIVES(CompareEqual);
            break;
        case SearchType_JalTo:
            m_Value._uint32 = 0x0C000000 | ((m_Value._uint32 & 0x3FFFFFF) >> 2);
            FIRST_SCAN_PRIMITIVES(CompareEqual);
            break;
        case SearchType_LessThanValue:
            FIRST_SCAN_PRIMITIVES(CompareLessThan);
            break;
        case SearchType_GreaterThanValue:
            FIRST_SCAN_PRIMITIVES(CompareGreaterThan);
            break;
        case SearchType_LessThanOrEqualToValue:
            FIRST_SCAN_PRIMITIVES(CompareLessThanOrEqual);
            break;
        case SearchType_GreaterThanOrEqualToValue:
            FIRST_SCAN_PRIMITIVES(CompareGreaterThanOrEqual);
            break;
        }
    }
    else
    {
        switch (m_ValueType)
        {
        case ValueType_string:
            FirstScanLoopString(resDisplayFormat);
            break;
        case ValueType_istring:
            FirstScanLoopIString(resDisplayFormat);
            break;
        case ValueType_unkstring:
            FirstScanLoopUnkString();
            break;
        }
    }

    m_DidFirstScan = true;
    return true;
}

#define _NextScanLoopPrimitive(T, Compare) NextScanLoopPrimitive<T>(Compare<T>)
#define _NextScanLoopPrimitiveResults(T, Compare) NextScanLoopPrimitiveResults<T>(Compare<T>)
#define _NextScanLoopPrimitive64(T, Compare) NextScanLoopPrimitive64<T>(Compare<T>)
#define _NextScanLoopPrimitiveResults64(T, Compare) NextScanLoopPrimitiveResults64<T>(Compare<T>)

// Compare result's current value in memory against m_Value
#define NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareFunc) \
    switch(m_ValueType)                                 \
    {                                                   \
    case ValueType_uint8:  _NextScanLoopPrimitive(uint8_t,  CompareFunc); break; \
    case ValueType_int8:   _NextScanLoopPrimitive(int8_t,   CompareFunc); break; \
    case ValueType_uint16: _NextScanLoopPrimitive(uint16_t, CompareFunc); break; \
    case ValueType_int16:  _NextScanLoopPrimitive(int16_t,  CompareFunc); break; \
    case ValueType_uint32: _NextScanLoopPrimitive(uint32_t, CompareFunc); break; \
    case ValueType_int32:  _NextScanLoopPrimitive(int32_t,  CompareFunc); break; \
    case ValueType_uint64: _NextScanLoopPrimitive64(uint64_t, CompareFunc); break; \
    case ValueType_int64:  _NextScanLoopPrimitive64(int64_t,  CompareFunc); break; \
    case ValueType_float:  _NextScanLoopPrimitive(float,    CompareFunc); break; \
    case ValueType_double: _NextScanLoopPrimitive64(double,   CompareFunc); break; \
    }

// Compare result's current value in memory against result's old value
#define NEXT_SCAN_PRIMITIVES_AGAINST_RESULTS(CompareFunc) \
    switch(m_ValueType)                                   \
    {                                                     \
    case ValueType_uint8:  _NextScanLoopPrimitiveResults(uint8_t,  CompareFunc); break; \
    case ValueType_int8:   _NextScanLoopPrimitiveResults(int8_t,   CompareFunc); break; \
    case ValueType_uint16: _NextScanLoopPrimitiveResults(uint16_t, CompareFunc); break; \
    case ValueType_int16:  _NextScanLoopPrimitiveResults(int16_t,  CompareFunc); break; \
    case ValueType_uint32: _NextScanLoopPrimitiveResults(uint32_t, CompareFunc); break; \
    case ValueType_int32:  _NextScanLoopPrimitiveResults(int32_t,  CompareFunc); break; \
    case ValueType_uint64: _NextScanLoopPrimitiveResults64(uint64_t, CompareFunc); break; \
    case ValueType_int64:  _NextScanLoopPrimitiveResults64(int64_t,  CompareFunc); break; \
    case ValueType_float:  _NextScanLoopPrimitiveResults(float,    CompareFunc); break; \
    case ValueType_double: _NextScanLoopPrimitiveResults64(double,   CompareFunc); break; \
    }

bool CMemoryScanner::NextScan()
{
    if (!g_MMU || !m_DidFirstScan || !m_bDataTypePrimitive)
    {
        // NextScan does not support complex data
        return false;
    }
    
    switch(m_SearchType)
    {
    case SearchType_ExactValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareEqual);
        break;
    case SearchType_LessThanValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareLessThan);
        break;
    case SearchType_GreaterThanValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareGreaterThan);
        break;
    case SearchType_LessThanOrEqualToValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareLessThanOrEqual);
        break;
    case SearchType_GreaterThanOrEqualToValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_VALUE(CompareGreaterThanOrEqual);
        break;

    case SearchType_ChangedValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_RESULTS(CompareNotEqual);
        break;
    case SearchType_UnchangedValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_RESULTS(CompareEqual);
        break;
    case SearchType_IncreasedValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_RESULTS(CompareGreaterThan);
        break;
    case SearchType_DecreasedValue:
        NEXT_SCAN_PRIMITIVES_AGAINST_RESULTS(CompareLessThan);
        break;
    }
    
    return true;
}


int CMemoryScanner::HexDigitVal(char c)
{
    if (c >= '0' && c <= '9') return (c - '0');
    if (c >= 'A' && c <= 'F') return (c - 'A') + 0x0A;
    if (c >= 'a' && c <= 'f') return (c - 'a') + 0x0A;
    return 0;
}

int CMemoryScanner::ParseHexString(char *dst, const char* src)
{
    bool bHiNibble = true;
    uint8_t curByte = 0;
    int size = 0;

    for (int i = 0; src[i] != '\0'; i++)
    {
        if (!isxdigit(src[i]))
        {
            if (!bHiNibble)
            {
                return 0;
            }

            if (isspace(src[i]))
            {
                continue;
            }

            return 0;
        }

        if (bHiNibble)
        {
            curByte = (HexDigitVal(src[i]) << 4) & 0xF0;
            bHiNibble = false;
        }
        else
        {
            curByte |= HexDigitVal(src[i]);
            if (dst != nullptr)
            {
                dst[size] = curByte;
            }
            size++;
            bHiNibble = true;
        }
    }

    if (!bHiNibble)
    {
        return 0;
    }

    return size;
}