code_gen_tool.h

Go to the documentation of this file.

 
#ifndef YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_CODE_GEN_TOOL_H_
#define YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_CODE_GEN_TOOL_H_
 
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "cli/service/resources/command_handler.h"
 
namespace yaze {
namespace cli {
namespace agent {
namespace tools {
 
struct AsmTemplate {
  std::string name;
  std::string code_template;  // Uses {{PLACEHOLDER}} syntax
  std::vector<std::string> required_params;
  std::string description;
};
 
struct FreeSpaceRegion {
  uint32_t start;
  uint32_t end;
  std::string description;
  int free_percent;  // Percentage of region that is 0x00/0xFF
 
  size_t Size() const { return end - start + 1; }
};
 
struct CodeGenerationDiagnostic {
  enum class Severity { kInfo, kWarning, kError };
 
  Severity severity;
  std::string message;
  uint32_t address = 0;
 
  std::string SeverityString() const {
    switch (severity) {
      case Severity::kInfo:
        return "info";
      case Severity::kWarning:
        return "warning";
      case Severity::kError:
        return "error";
    }
    return "unknown";
  }
};
 
struct CodeGenerationResult {
  bool success;
  std::string generated_code;
  std::vector<CodeGenerationDiagnostic> diagnostics;
  std::map<std::string, uint32_t> symbols;  // Label -> address
 
  void AddInfo(const std::string& message, uint32_t address = 0) {
    diagnostics.push_back({CodeGenerationDiagnostic::Severity::kInfo, message, address});
  }
 
  void AddWarning(const std::string& message, uint32_t address = 0) {
    diagnostics.push_back({CodeGenerationDiagnostic::Severity::kWarning, message, address});
  }
 
  void AddError(const std::string& message, uint32_t address = 0) {
    success = false;
    diagnostics.push_back({CodeGenerationDiagnostic::Severity::kError, message, address});
  }
};
 
class CodeGenToolBase : public resources::CommandHandler {
 protected:
  absl::Status ValidateHookAddress(Rom* rom, uint32_t address) const;
 
  std::vector<FreeSpaceRegion> DetectFreeSpace(Rom* rom, size_t min_size = 0x100) const;
 
  std::string SubstitutePlaceholders(
      const std::string& template_code,
      const std::map<std::string, std::string>& params) const;
 
  absl::StatusOr<AsmTemplate> GetTemplate(const std::string& name) const;
 
  const std::vector<AsmTemplate>& GetAllTemplates() const;
 
  std::string FormatResultAsJson(const CodeGenerationResult& result) const;
 
  std::string FormatResultAsText(const CodeGenerationResult& result) const;
 
  bool IsKnownHookLocation(uint32_t address) const;
 
  std::string GetHookLocationDescription(uint32_t address) const;
 
 private:
  static std::vector<AsmTemplate> InitializeTemplates();
  static const std::vector<AsmTemplate> kTemplates;
 
  // Known safe hook locations (routine_name -> address)
  static const std::map<std::string, uint32_t> kKnownHooks;
};
 
class CodeGenAsmHookTool : public CodeGenToolBase {
 public:
  std::string GetName() const override { return "codegen-asm-hook"; }
 
  std::string GetDescription() const {
    return "Generate ASM hook at ROM address";
  }
 
  std::string GetUsage() const override {
    return "codegen-asm-hook --address=0x008040 --label=MyHook [--nop-fill=N] [--format=<json|text>]";
  }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"address", "label"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
 
  bool RequiresRom() const override { return true; }
};
 
class CodeGenFreespacePatchTool : public CodeGenToolBase {
 public:
  std::string GetName() const override { return "codegen-freespace-patch"; }
 
  std::string GetDescription() const {
    return "Generate patch using detected free regions";
  }
 
  std::string GetUsage() const override {
    return "codegen-freespace-patch --label=MyCode --size=0x100 [--prefer-bank=N] [--format=<json|text>]";
  }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"label"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
 
  bool RequiresRom() const override { return true; }
};
 
class CodeGenSpriteTemplateTool : public CodeGenToolBase {
 public:
  std::string GetName() const override { return "codegen-sprite-template"; }
 
  std::string GetDescription() const {
    return "Generate sprite ASM from template";
  }
 
  std::string GetUsage() const override {
    return "codegen-sprite-template --name=MySprite [--init-code=\"...\"] [--main-code=\"...\"] [--format=<json|text>]";
  }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"name"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
 
  bool RequiresRom() const override { return false; }
};
 
class CodeGenEventHandlerTool : public CodeGenToolBase {
 public:
  std::string GetName() const override { return "codegen-event-handler"; }
 
  std::string GetDescription() const {
    return "Generate event handler code";
  }
 
  std::string GetUsage() const override {
    return "codegen-event-handler --type=<nmi|irq|reset> --label=MyHandler [--custom-code=\"...\"] [--format=<json|text>]";
  }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"type", "label"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
 
  bool RequiresRom() const override { return false; }
};
 
}  // namespace tools
}  // namespace agent
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_CODE_GEN_TOOL_H_