asar_wrapper.h

Go to the documentation of this file.

#ifndef YAZE_CORE_ASAR_WRAPPER_H
#define YAZE_CORE_ASAR_WRAPPER_H
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
namespace core {
 
struct AsarSymbol {
  std::string name;     // Symbol name
  uint32_t address;     // Memory address
  std::string opcode;   // Associated opcode if available
  std::string file;     // Source file
  int line;             // Line number in source
  std::string comment;  // Optional comment
};
 
struct AsarPatchResult {
  bool success;                       // Whether patch was successful
  std::vector<std::string> errors;    // Error messages if any
  std::vector<std::string> warnings;  // Warning messages
  std::vector<AsarSymbol> symbols;    // Extracted symbols
  uint32_t rom_size;                  // Final ROM size after patching
  uint32_t crc32;                     // CRC32 checksum of patched ROM
};
 
class AsarWrapper {
 public:
  AsarWrapper();
  ~AsarWrapper();
 
  AsarWrapper(const AsarWrapper&) = delete;
  AsarWrapper& operator=(const AsarWrapper&) = delete;
 
  AsarWrapper(AsarWrapper&&) = default;
  AsarWrapper& operator=(AsarWrapper&&) = default;
 
  absl::Status Initialize();
  void Shutdown();
  bool IsInitialized() const { return initialized_; }
 
  std::string GetVersion() const;
  int GetApiVersion() const;
 
  absl::StatusOr<AsarPatchResult> ApplyPatch(
      const std::string& patch_path, std::vector<uint8_t>& rom_data,
      const std::vector<std::string>& include_paths = {});
 
  absl::StatusOr<AsarPatchResult> ApplyPatchFromString(
      const std::string& patch_content, std::vector<uint8_t>& rom_data,
      const std::string& base_path = "");
 
  absl::StatusOr<std::vector<AsarSymbol>> ExtractSymbols(
      const std::string& asm_path,
      const std::vector<std::string>& include_paths = {});
 
  absl::Status LoadSymbolsFromFile(const std::string& symbol_path);
 
  std::map<std::string, AsarSymbol> GetSymbolTable() const;
  std::optional<AsarSymbol> FindSymbol(const std::string& name) const;
  std::vector<AsarSymbol> GetSymbolsAtAddress(uint32_t address) const;
 
  void Reset();
 
  std::vector<std::string> GetLastErrors() const { return last_errors_; }
  std::vector<std::string> GetLastWarnings() const { return last_warnings_; }
 
  absl::Status CreatePatch(const std::vector<uint8_t>& original_rom,
                           const std::vector<uint8_t>& modified_rom,
                           const std::string& patch_path);
 
  absl::Status ValidateAssembly(const std::string& asm_path);
 
 private:
  absl::StatusOr<AsarPatchResult> ApplyPatchWithBinary(
      const std::string& patch_path, std::vector<uint8_t>& rom_data,
      const std::vector<std::string>& include_paths);
 
  absl::StatusOr<AsarPatchResult> ApplyPatchWithLibrary(
      const std::string& patch_path, std::vector<uint8_t>& rom_data,
      const std::vector<std::string>& include_paths);
 
  std::optional<std::string> ResolveAsarBinary() const;
 
  bool initialized_;
  bool library_enabled_;
  std::map<std::string, AsarSymbol> symbol_table_;
  std::vector<std::string> last_errors_;
  std::vector<std::string> last_warnings_;
 
  void ProcessErrors();
  void ProcessWarnings();
  void ExtractSymbolsFromLastOperation();
  AsarSymbol ConvertAsarSymbol(const void* asar_symbol_data) const;
};
 
}  // namespace core
}  // namespace yaze
 
#endif  // YAZE_CORE_ASAR_WRAPPER_H