hex_commands.cc

Go to the documentation of this file.

#include "cli/handlers/graphics/hex_commands.h"
 
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include <cctype>
 
namespace yaze {
namespace cli {
namespace handlers {
 
absl::Status HexReadCommandHandler::Execute(Rom* rom, const resources::ArgumentParser& parser,
                      resources::OutputFormatter& formatter) {
  auto address_str = parser.GetString("address").value();
  auto length = parser.GetInt("length").value_or(16);
  auto format = parser.GetString("format").value_or("both");
  
  // Parse address
  uint32_t address;
  try {
    size_t pos;
    address = std::stoul(address_str, &pos, 16);
    if (pos != address_str.size()) {
      return absl::InvalidArgumentError("Invalid hex address format");
    }
  } catch (const std::exception& e) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Failed to parse address '%s': %s", address_str, e.what()));
  }
  
  // Validate range
  if (address + length > rom->size()) {
    return absl::OutOfRangeError(
        absl::StrFormat("Read beyond ROM: 0x%X+%d > %zu",
                       address, length, rom->size()));
  }
  
  // Read and format data
  const uint8_t* data = rom->data() + address;
  
  formatter.BeginObject("Hex Read");
  formatter.AddHexField("address", address, 6);
  formatter.AddField("length", length);
  formatter.AddField("format", format);
  
  // Format hex data
  std::string hex_data;
  for (int i = 0; i < length; ++i) {
    absl::StrAppendFormat(&hex_data, "%02X", data[i]);
    if (i < length - 1) hex_data += " ";
  }
  formatter.AddField("hex_data", hex_data);
  
  // Format ASCII data
  std::string ascii_data;
  for (int i = 0; i < length; ++i) {
    char c = static_cast<char>(data[i]);
    ascii_data += (std::isprint(c) ? c : '.');
  }
  formatter.AddField("ascii_data", ascii_data);
  formatter.EndObject();
  
  return absl::OkStatus();
}
 
absl::Status HexWriteCommandHandler::Execute(Rom* rom, const resources::ArgumentParser& parser,
                      resources::OutputFormatter& formatter) {
  auto address_str = parser.GetString("address").value();
  auto data_str = parser.GetString("data").value();
  
  // Parse address
  uint32_t address;
  try {
    size_t pos;
    address = std::stoul(address_str, &pos, 16);
    if (pos != address_str.size()) {
      return absl::InvalidArgumentError("Invalid hex address format");
    }
  } catch (const std::exception& e) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Failed to parse address '%s': %s", address_str, e.what()));
  }
  
  // Parse data bytes
  std::vector<std::string> byte_strs = absl::StrSplit(data_str, ' ');
  std::vector<uint8_t> bytes;
  
  for (const auto& byte_str : byte_strs) {
    if (byte_str.empty()) continue;
    try {
      uint8_t value = static_cast<uint8_t>(std::stoul(byte_str, nullptr, 16));
      bytes.push_back(value);
    } catch (const std::exception& e) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Invalid byte '%s': %s", byte_str, e.what()));
    }
  }
  
  // Validate range
  if (address + bytes.size() > rom->size()) {
    return absl::OutOfRangeError(
        absl::StrFormat("Write beyond ROM: 0x%X+%zu > %zu",
                       address, bytes.size(), rom->size()));
  }
  
  // Write data
  for (size_t i = 0; i < bytes.size(); ++i) {
    rom->WriteByte(address + i, bytes[i]);
  }
  
  // Format written data
  std::string hex_data;
  for (size_t i = 0; i < bytes.size(); ++i) {
    absl::StrAppendFormat(&hex_data, "%02X", bytes[i]);
    if (i < bytes.size() - 1) hex_data += " ";
  }
  
  formatter.BeginObject("Hex Write");
  formatter.AddHexField("address", address, 6);
  formatter.AddField("bytes_written", static_cast<int>(bytes.size()));
  formatter.AddField("hex_data", hex_data);
  formatter.EndObject();
  
  return absl::OkStatus();
}
 
absl::Status HexSearchCommandHandler::Execute(Rom* rom, const resources::ArgumentParser& parser,
                      resources::OutputFormatter& formatter) {
  auto pattern_str = parser.GetString("pattern").value();
  auto start_str = parser.GetString("start").value_or("0x000000");
  auto end_str = parser.GetString("end").value_or(
      absl::StrFormat("0x%06X", static_cast<int>(rom->size())));
  
  // Parse addresses
  uint32_t start_address, end_address;
  try {
    start_address = std::stoul(start_str, nullptr, 16);
    end_address = std::stoul(end_str, nullptr, 16);
  } catch (const std::exception& e) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Invalid address format: %s", e.what()));
  }
  
  // Parse pattern
  std::vector<std::string> byte_strs = absl::StrSplit(pattern_str, ' ');
  std::vector<std::pair<uint8_t, bool>> pattern;  // (value, is_wildcard)
  
  for (const auto& byte_str : byte_strs) {
    if (byte_str.empty()) continue;
    if (byte_str == "??" || byte_str == "**") {
      pattern.push_back({0, true});  // Wildcard
    } else {
      try {
        uint8_t value = static_cast<uint8_t>(std::stoul(byte_str, nullptr, 16));
        pattern.push_back({value, false});
      } catch (const std::exception& e) {
        return absl::InvalidArgumentError(
            absl::StrFormat("Invalid pattern byte '%s': %s", byte_str, e.what()));
      }
    }
  }
  
  if (pattern.empty()) {
    return absl::InvalidArgumentError("Empty pattern");
  }
  
  // Search for pattern
  std::vector<uint32_t> matches;
  const uint8_t* rom_data = rom->data();
  
  for (uint32_t i = start_address; i <= end_address - pattern.size(); ++i) {
    bool match = true;
    for (size_t j = 0; j < pattern.size(); ++j) {
      if (!pattern[j].second &&  // If not wildcard
          rom_data[i + j] != pattern[j].first) {
        match = false;
        break;
      }
    }
    if (match) {
      matches.push_back(i);
    }
  }
  
  formatter.BeginObject("Hex Search Results");
  formatter.AddField("pattern", pattern_str);
  formatter.AddHexField("start_address", start_address, 6);
  formatter.AddHexField("end_address", end_address, 6);
  formatter.AddField("matches_found", static_cast<int>(matches.size()));
  
  formatter.BeginArray("matches");
  for (uint32_t match : matches) {
    formatter.AddArrayItem(absl::StrFormat("0x%06X", match));
  }
  formatter.EndArray();
  formatter.EndObject();
  
  return absl::OkStatus();
}
 
}  // namespace handlers
}  // namespace cli
}  // namespace yaze