rom_commands.cc

Go to the documentation of this file.

#include "cli/handlers/rom/rom_commands.h"
 
#include <cctype>
#include <filesystem>
#include <fstream>
 
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include "cli/handlers/game/overworld_sprite_edit_commands.h"
#include "cli/util/hex_util.h"
#include "rom/rom.h"
#include "util/macro.h"
#include "zelda3/overworld/overworld.h"
 
namespace yaze {
namespace cli {
namespace handlers {
 
using util::ParseHexString;
 
absl::Status RomReadCommandHandler::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);
  std::string data_format = "both";
  if (auto fmt = parser.GetString("data-format"); fmt.has_value()) {
    data_format = *fmt;
  } else if (auto fmt = parser.GetString("format"); fmt.has_value()) {
    if (*fmt == "hex" || *fmt == "ascii" || *fmt == "both" ||
        *fmt == "binary") {
      data_format = *fmt;
    }
  }
 
  uint32_t address = 0;
  if (!ParseHexString(address_str, &address)) {
    return absl::InvalidArgumentError("Invalid hex address format");
  }
  if (length <= 0) {
    return absl::InvalidArgumentError("Length must be greater than 0");
  }
  if (address + static_cast<uint32_t>(length) > rom->size()) {
    return absl::OutOfRangeError(absl::StrFormat(
        "Read beyond ROM: 0x%X+%d > %zu", address, length, rom->size()));
  }
 
  const uint8_t* data = rom->data() + address;
 
  formatter.AddHexField("address", address, 6);
  formatter.AddField("length", length);
 
  bool include_hex = (data_format == "hex" || data_format == "both");
  bool include_ascii = (data_format == "ascii" || data_format == "both");
 
  if (include_hex) {
    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("data", hex_data);
  }
 
  if (include_ascii) {
    std::string ascii_data;
    ascii_data.reserve(length);
    for (int i = 0; i < length; ++i) {
      char c = static_cast<char>(data[i]);
      ascii_data += (std::isprint(static_cast<unsigned char>(c)) ? c : '.');
    }
    formatter.AddField("ascii", ascii_data);
  }
 
  formatter.AddField("format", data_format);
  return absl::OkStatus();
}
 
absl::Status RomWriteCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto address_str = parser.GetString("address").value();
  auto data_str = parser.GetString("data").value();
 
  uint32_t address = 0;
  if (!ParseHexString(address_str, &address)) {
    return absl::InvalidArgumentError("Invalid hex address format");
  }
 
  std::vector<std::string> byte_strs = absl::StrSplit(data_str, ' ');
  std::vector<uint8_t> bytes;
  bytes.reserve(byte_strs.size());
 
  for (const auto& byte_str : byte_strs) {
    if (byte_str.empty())
      continue;
    int value = 0;
    if (!ParseHexString(byte_str, &value)) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Invalid byte '%s'", byte_str));
    }
    if (value < 0 || value > 0xFF) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Byte out of range: %s", byte_str));
    }
    bytes.push_back(static_cast<uint8_t>(value));
  }
 
  return ApplyRawRomWrite(rom, address, bytes, parser, formatter);
}
 
namespace {
 
std::string HexBytes(const std::vector<uint8_t>& bytes) {
  std::string out;
  for (size_t i = 0; i < bytes.size(); ++i) {
    if (i > 0) {
      out += ' ';
    }
    absl::StrAppendFormat(&out, "%02X", bytes[i]);
  }
  return out;
}
 
}  // namespace
 
absl::Status ApplyRawRomWrite(Rom* rom, uint32_t address,
                              const std::vector<uint8_t>& bytes,
                              const resources::ArgumentParser& parser,
                              resources::OutputFormatter& formatter) {
  if (rom == nullptr || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (bytes.empty()) {
    return absl::InvalidArgumentError("No data bytes provided");
  }
  if (address + bytes.size() > rom->size()) {
    return absl::OutOfRangeError(
        absl::StrFormat("Write beyond ROM: 0x%X+%zu > %zu", address,
                        bytes.size(), rom->size()));
  }
  const bool do_write = parser.HasFlag("write");
  const bool mock_rom = parser.HasFlag("mock-rom");
  if (do_write && !mock_rom && !parser.HasFlag("allow-project-rom") &&
      IsOracleProjectRomPath(std::filesystem::path(rom->filename()))) {
    return absl::PermissionDeniedError(absl::StrFormat(
        "Refusing --write to %s: it is inside an Oracle of Secrets checkout. "
        "Write a copy, or pass --allow-project-rom deliberately.",
        rom->filename()));
  }
 
  std::vector<uint8_t> before(bytes.size());
  for (size_t i = 0; i < bytes.size(); ++i) {
    ASSIGN_OR_RETURN(before[i], rom->ReadByte(address + i));
  }
  formatter.AddHexField("address", address, 6);
  formatter.AddField("byte_count", static_cast<int>(bytes.size()));
  formatter.AddField("before", HexBytes(before));
  formatter.AddField("after", HexBytes(bytes));
  formatter.AddField("mode", do_write ? "write" : "dry-run");
  if (!do_write) {
    formatter.AddField("write_status", "dry-run");
    return absl::OkStatus();
  }
 
  RETURN_IF_ERROR(rom->CheckLayoutWritable());
  for (size_t i = 0; i < bytes.size(); ++i) {
    RETURN_IF_ERROR(rom->WriteByte(address + i, bytes[i]));
  }
  if (mock_rom) {
    formatter.AddField("save_status", "mock-rom-skipped");
    return absl::OkStatus();
  }
  Rom::SaveSettings save_settings;
  save_settings.require_backup = true;
  RETURN_IF_ERROR(rom->SaveToFile(save_settings));
  formatter.AddField("save_status", "saved");
 
  Rom reopened;
  RETURN_IF_ERROR(reopened.LoadFromFile(rom->filename()));
  if (reopened.vector() != rom->vector()) {
    return absl::DataLossError(
        "Saved ROM file differs from the written image; restore the backup");
  }
  formatter.AddField("verified_reload", true);
  return absl::OkStatus();
}
 
absl::Status RomInfoCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  if (!rom || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM must be loaded");
  }
 
  formatter.AddField("title", rom->title());
  formatter.AddField("size", absl::StrFormat("0x%X", rom->size()));
  formatter.AddField("size_bytes", static_cast<int>(rom->size()));
  // size/size_bytes exclude a stripped copier header; saves write it back.
  const size_t header_size = rom->copier_header().size();
  formatter.AddField("copier_header", rom->has_copier_header());
  formatter.AddField("copier_header_size", static_cast<int>(header_size));
  formatter.AddField("copier_header_detection",
                     CopierHeaderReasonName(rom->copier_header_reason()));
  formatter.AddField("file_size",
                     absl::StrFormat("0x%X", rom->size() + header_size));
 
  const auto profile = zelda3::DetectOverworldRomProfile(*rom);
  const auto& layout = profile.lyra_layout;
  const char* format_name = "legacy";
  if (profile.layout_kind ==
      zelda3::OverworldRomProfile::LayoutKind::kOlderTailEa) {
    format_name = "older_tail_ea";
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kLyraOffline) {
    format_name = "lyra_descriptor";
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kZScreamPerSheet) {
    format_name = "zscream_per_sheet";
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kUnknownCustom) {
    format_name = "unknown_custom";
  }
  formatter.AddField("overworld_format", format_name);
  formatter.AddField("zscream_layout",
                     zelda3::zscream::LayoutName(profile.zscream_layout));
  formatter.AddField("zscream_raw_marker",
                     static_cast<int>(profile.asm_version));
  formatter.AddField("tail_expansion_layout_compatible",
                     zelda3::zscream::CanUseTailExpansion(*rom));
  formatter.AddField(
      "overworld_format_valid",
      layout.presence != yaze::rom::LyraLayoutPresence::kInvalid);
  formatter.AddField("overworld_format_revision", layout.revision);
  const int area_capacity =
      layout.presence == yaze::rom::LyraLayoutPresence::kAbsent
          ? profile.editable_map_count
          : layout.capacity;
  const int active_areas =
      layout.presence == yaze::rom::LyraLayoutPresence::kAbsent
          ? profile.editable_map_count
          : layout.active_count;
  formatter.AddField("overworld_area_capacity", area_capacity);
  formatter.AddField("overworld_active_areas", active_areas);
  formatter.AddField("overworld_write_supported", layout.write_supported);
  if (!layout.error.empty()) {
    formatter.AddField("overworld_format_error", layout.error);
  }
 
  return absl::OkStatus();
}
 
absl::Status RomValidateCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  if (!rom || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM must be loaded");
  }
 
  bool all_ok = true;
  std::vector<std::string> validation_results;
 
  // Basic ROM validation - check if ROM is loaded and has reasonable size
  if (rom->is_loaded() && rom->size() > 0) {
    validation_results.push_back("checksum: PASSED");
  } else {
    validation_results.push_back("checksum: FAILED");
    all_ok = false;
  }
 
  // Header validation
  if (rom->title() == "THE LEGEND OF ZELDA") {
    validation_results.push_back("header: PASSED");
  } else {
    validation_results.push_back(
        "header: FAILED (Invalid title: " + rom->title() + ")");
    all_ok = false;
  }
 
  const auto layout = rom->InspectLyraLayout();
  if (layout.presence != yaze::rom::LyraLayoutPresence::kAbsent) {
    const bool layout_valid =
        layout.presence == yaze::rom::LyraLayoutPresence::kValid;
    all_ok = all_ok && layout_valid;
    validation_results.push_back(layout_valid ? "lyra_descriptor: PASSED"
                                              : "lyra_descriptor: FAILED (" +
                                                    layout.error + ")");
  }
 
  formatter.AddField("validation_passed", all_ok);
  std::string results_str;
  for (const auto& result : validation_results) {
    if (!results_str.empty())
      results_str += "; ";
    results_str += result;
  }
  formatter.AddField("results", results_str);
 
  return layout.presence == yaze::rom::LyraLayoutPresence::kInvalid
             ? absl::FailedPreconditionError(
                   "Invalid Lyra overworld ROM layout: " + layout.error)
             : absl::OkStatus();
}
 
absl::Status RomDiffCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto rom_a_opt = parser.GetString("rom_a");
  auto rom_b_opt = parser.GetString("rom_b");
 
  if (!rom_a_opt.has_value()) {
    return absl::InvalidArgumentError("Missing required argument: rom_a");
  }
  if (!rom_b_opt.has_value()) {
    return absl::InvalidArgumentError("Missing required argument: rom_b");
  }
 
  std::string rom_a_path = rom_a_opt.value();
  std::string rom_b_path = rom_b_opt.value();
 
  Rom rom_a;
  auto status_a = rom_a.LoadFromFile(rom_a_path);
  if (!status_a.ok()) {
    return status_a;
  }
 
  Rom rom_b;
  auto status_b = rom_b.LoadFromFile(rom_b_path);
  if (!status_b.ok()) {
    return status_b;
  }
 
  if (rom_a.size() != rom_b.size()) {
    formatter.AddField("size_match", false);
    formatter.AddField("size_a", static_cast<int>(rom_a.size()));
    formatter.AddField("size_b", static_cast<int>(rom_b.size()));
    return absl::OkStatus();
  }
 
  int differences = 0;
  std::vector<std::string> diff_details;
 
  for (size_t i = 0; i < rom_a.size(); ++i) {
    if (rom_a.vector()[i] != rom_b.vector()[i]) {
      differences++;
      if (differences <= 10) {  // Limit output to first 10 differences
        diff_details.push_back(absl::StrFormat("0x%08X: 0x%02X vs 0x%02X", i,
                                               rom_a.vector()[i],
                                               rom_b.vector()[i]));
      }
    }
  }
 
  formatter.AddField("identical", differences == 0);
  formatter.AddField("differences_count", differences);
  if (!diff_details.empty()) {
    std::string diff_str;
    for (const auto& diff : diff_details) {
      if (!diff_str.empty())
        diff_str += "; ";
      diff_str += diff;
    }
    formatter.AddField("differences", diff_str);
  }
 
  return absl::OkStatus();
}
 
absl::Status RomGenerateGoldenCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto rom_opt = parser.GetString("rom_file");
  auto golden_opt = parser.GetString("golden_file");
 
  if (!rom_opt.has_value()) {
    return absl::InvalidArgumentError("Missing required argument: rom_file");
  }
  if (!golden_opt.has_value()) {
    return absl::InvalidArgumentError("Missing required argument: golden_file");
  }
 
  std::string rom_path = rom_opt.value();
  std::string golden_path = golden_opt.value();
 
  Rom source_rom;
  auto status = source_rom.LoadFromFile(rom_path);
  if (!status.ok()) {
    return status;
  }
 
  std::ofstream file(golden_path, std::ios::binary);
  if (!file.is_open()) {
    return absl::NotFoundError("Could not open file for writing: " +
                               golden_path);
  }
 
  file.write(reinterpret_cast<const char*>(source_rom.vector().data()),
             source_rom.size());
 
  formatter.AddField("status", "success");
  formatter.AddField("golden_file", golden_path);
  formatter.AddField("source_file", rom_path);
  formatter.AddField("size", static_cast<int>(source_rom.size()));
 
  return absl::OkStatus();
}
 
absl::Status RomResolveAddressCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto address_str = parser.GetString("address").value();
  auto max_offset = parser.GetInt("max-offset").value_or(0x100);
 
  uint32_t address = 0;
  if (!ParseHexString(address_str, &address)) {
    return absl::InvalidArgumentError("Invalid hex address format");
  }
 
  if (symbol_provider_ == nullptr || !symbol_provider_->HasSymbols()) {
    formatter.AddField("status", "no_symbols_loaded");
    formatter.AddHexField("address", address, 6);
    return absl::OkStatus();
  }
 
  auto symbols = symbol_provider_->GetSymbolsAtAddress(address);
  if (!symbols.empty()) {
    formatter.AddField("status", "success");
    formatter.AddField("match_type", "exact");
    if (symbols.size() == 1) {
      formatter.AddField("name", symbols[0].name);
      if (!symbols[0].file.empty()) {
        formatter.AddField("file", symbols[0].file);
        formatter.AddField("line", symbols[0].line);
      }
    } else {
      formatter.BeginArray("names");
      for (const auto& sym : symbols) {
        formatter.AddArrayItem(sym.name);
      }
      formatter.EndArray();
    }
    formatter.AddHexField("address", address, 6);
  } else {
    auto nearest = symbol_provider_->GetNearestSymbol(address);
    if (nearest) {
      uint32_t offset = address - nearest->address;
      if (offset <= static_cast<uint32_t>(max_offset)) {
        formatter.AddField("status", "success");
        formatter.AddField("match_type", "nearest");
        formatter.AddField("name", nearest->name);
        formatter.AddHexField("symbol_address", nearest->address, 6);
        formatter.AddHexField("offset", offset);
        formatter.AddField("formatted",
                           absl::StrFormat("%s+$%X", nearest->name, offset));
      } else {
        formatter.AddField("status", "not_found");
        formatter.AddField("message", "Nearest symbol too far away");
      }
    } else {
      formatter.AddField("status", "not_found");
    }
  }
 
  formatter.AddHexField("requested_address", address, 6);
  return absl::OkStatus();
}
 
absl::Status RomFindSymbolCommandHandler::Execute(
    Rom* rom, const resources::ArgumentParser& parser,
    resources::OutputFormatter& formatter) {
  auto name = parser.GetString("name").value();
 
  if (symbol_provider_ == nullptr || !symbol_provider_->HasSymbols()) {
    return absl::FailedPreconditionError(
        "No symbols loaded. Provide a ROM with .mlb/.sym file.");
  }
 
  auto symbol = symbol_provider_->FindSymbol(name);
  if (symbol) {
    formatter.AddField("status", "success");
    formatter.AddField("name", symbol->name);
    formatter.AddHexField("address", symbol->address, 6);
    if (!symbol->file.empty()) {
      formatter.AddField("file", symbol->file);
      formatter.AddField("line", symbol->line);
    }
  } else {
    // Try wildcard search
    auto matches = symbol_provider_->FindSymbolsMatching(name);
    if (!matches.empty()) {
      formatter.AddField("status", "success");
      formatter.AddField("match_type", "partial");
      formatter.BeginArray("matches");
      for (const auto& m : matches) {
        formatter.BeginObject();
        formatter.AddField("name", m.name);
        formatter.AddHexField("address", m.address, 6);
        formatter.EndObject();
      }
      formatter.EndArray();
    } else {
      formatter.AddField("status", "not_found");
    }
  }
 
  return absl::OkStatus();
}
 
}  // namespace handlers
}  // namespace cli
}  // namespace yaze