Function formatMemoryToString

Source/Common/MemoryCommon.cpp:514–790

ppcBranchOrigin = 0 means relative branch, non-zero means absolute branch will be shown

// ppcBranchOrigin = 0 means relative branch, non-zero means absolute branch will be shown
std::string formatMemoryToString(const char* memory, const MemType type, const size_t length,
                                 const MemBase base, const bool isUnsigned, const bool withBSwap,
                                 const u32 ppcBranchOrigin)
{
  std::stringstream ss;
  switch (base)
  {
  case Common::MemBase::base_octal:
    ss << std::oct;
    break;
  case Common::MemBase::base_decimal:
    ss << std::dec;
    break;
  case Common::MemBase::base_hexadecimal:
    ss << std::hex << std::uppercase;
    break;
  default:
    break;
  }

  switch (type)
  {
  case Common::MemType::type_byte:
  {
    if (isUnsigned || base == Common::MemBase::base_binary)
    {
      u8 unsignedByte = 0;
      std::memcpy(&unsignedByte, memory, sizeof(u8));
      if (base == Common::MemBase::base_binary)
        return std::bitset<sizeof(u8) * 8>(unsignedByte).to_string();
      // This has to be converted to an integer type because printing a uint8_t would resolve to a
      // char and print a single character.
      ss << static_cast<unsigned int>(unsignedByte);
      return ss.str();
    }

    s8 aByte = 0;
    std::memcpy(&aByte, memory, sizeof(s8));
    // This has to be converted to an integer type because printing a uint8_t would resolve to a
    // char and print a single character.  Additionaly, casting a signed type to a larger signed
    // type will extend the sign to match the size of the destination type, this is required for
    // signed values in decimal, but must be bypassed for other bases, this is solved by first
    // casting to u8 then to signed int.
    if (base == Common::MemBase::base_decimal)
      ss << static_cast<int>(aByte);
    else
      ss << static_cast<int>(static_cast<u8>(aByte));
    return ss.str();
  }
  case Common::MemType::type_halfword:
  {
    char* memoryCopy = new char[sizeof(u16)];
    std::memcpy(memoryCopy, memory, sizeof(u16));
    if (withBSwap)
    {
      u16 halfword = 0;
      std::memcpy(&halfword, memoryCopy, sizeof(u16));
      halfword = Common::bSwap16(halfword);