src/lua/disassemble.cpp

   1 #include "lua/internal.hpp"
   2 #include "interface/disassembler.hpp"
   3 #include "interface/romtype.hpp"
   4 #include "library/hex.hpp"
   5 #include "library/memoryspace.hpp"
   6 #include "core/instance.hpp"
   7 #include "core/memorymanip.hpp"
   8 #include "core/moviedata.hpp"
   9
  10 namespace
  11 {
  12         int disassemble(lua::state& L, lua::parameters& P)
  13         {
  14                 std::string kind;
  15                 uint64_t addr, count;
  16
  17                 P(kind, addr, P.optional(count, 1));
  18
  19                 disassembler* d;
  20                 d = &disassembler::byname(kind);
  21                 L.newtable();
  22                 uint64_t laddr = addr;
  23                 for(uint64_t i = 1; i <= count; i++) {
  24                         uint64_t bytes = 0;
  25                         L.pushnumber(i);
  26                         L.newtable();
  27                         L.pushstring("addr");
  28                         L.pushnumber(laddr);
  29                         L.settable(-3);
  30
  31                         L.pushstring("disasm");
  32                         L.pushlstring(d->disassemble(laddr, [&bytes, laddr]() -> unsigned char {
  33                                 return CORE().memory->read<uint8_t>(laddr + bytes++);
  34                         }));
  35                         L.settable(-3);
  36
  37                         std::vector<unsigned char> tmp;
  38                         tmp.resize(bytes);
  39                         CORE().memory->read_range(laddr, &tmp[0], bytes);
  40                         L.pushstring("bytes");
  41                         L.pushlstring(hex::b_to(&tmp[0], bytes));
  42                         L.settable(-3);
  43                         L.settable(-3);
  44                         laddr += bytes;
  45                 }
  46                 return 1;
  47         }
  48
  49         int getregister(lua::state& L, lua::parameters& P)
  50         {
  51                 std::string r;
  52
  53                 P(r);
  54
  55                 const interface_device_reg* regs = our_rom.rtype->get_registers();
  56                 if(!regs) {
  57                         L.pushnil();
  58                         return 1;
  59                 }
  60                 for(size_t i = 0; regs[i].name; i++) {
  61                         if(r != regs[i].name)
  62                                 continue;
  63                         if(regs[i].boolean)
  64                                 L.pushboolean(regs[i].read() != 0);
  65                         else
  66                                 L.pushnumber(regs[i].read());
  67                         return 1;
  68                 }
  69                 L.pushnil();
  70                 return 1;
  71         }
  72
  73         int getregisters(lua::state& L, lua::parameters& P)
  74         {
  75                 const interface_device_reg* regs = our_rom.rtype->get_registers();
  76                 if(!regs) {
  77                         L.pushnil();
  78                         return 1;
  79                 }
  80                 L.newtable();
  81                 for(size_t i = 0; regs[i].name; i++) {
  82                         L.pushlstring(regs[i].name);
  83                         if(regs[i].boolean)
  84                                 L.pushboolean(regs[i].read() != 0);
  85                         else
  86                                 L.pushnumber(regs[i].read());
  87                         L.settable(-3);
  88                 }
  89                 return 1;
  90         }
  91
  92         int setregister(lua::state& L, lua::parameters& P)
  93         {
  94                 std::string r;
  95
  96                 P(r);
  97
  98                 const interface_device_reg* regs = our_rom.rtype->get_registers();
  99                 if(!regs) {
 100                         return 0;
 101                 }
 102                 for(size_t i = 0; regs[i].name; i++) {
 103                         if(r != regs[i].name)
 104                                 continue;
 105                         if(!regs[i].write)
 106                                 break;
 107                         if(regs[i].boolean)
 108                                 regs[i].write(P.arg<bool>() ? 1 : 0);
 109                         else
 110                                 regs[i].write(P.arg<uint64_t>());
 111                         return 0;
 112                 }
 113                 return 0;
 114         }
 115
 116         lua::functions LUA_disasm_fns(lua_func_misc, "memory", {
 117                 {"disassemble", disassemble},
 118                 {"getregister", getregister},
 119                 {"getregisters", getregisters},
 120                 {"setregister", setregister},
 121         });
 122 }