lua/hostmemory.cpp

   1 #include "lua-int.hpp"
   2 #include "moviedata.hpp"
   3
   4 namespace
   5 {
   6         template<typename U, typename S>
   7         int do_read(lua_State* LS, const std::string& fname)
   8         {
   9                 size_t address = get_numeric_argument<size_t>(LS, 1, fname.c_str());
  10                 auto& h = get_host_memory();
  11                 if(address + sizeof(U) > h.size()) {
  12                         lua_pushboolean(LS, 0);
  13                         return 1;
  14                 }
  15                 U ret = 0;
  16                 for(size_t i = 0; i < sizeof(U); i++)
  17                         ret = 256 * ret + static_cast<uint8_t>(h[address + i]);
  18                 lua_pushnumber(LS, static_cast<S>(ret));
  19                 return 1;
  20         }
  21
  22         template<typename U, typename S>
  23         int do_write(lua_State* LS, const std::string& fname)
  24         {
  25                 size_t address = get_numeric_argument<size_t>(LS, 1, fname.c_str());
  26                 U value = static_cast<U>(get_numeric_argument<S>(LS, 2, fname.c_str()));
  27                 auto& h = get_host_memory();
  28                 if(address + sizeof(U) > h.size())
  29                         h.resize(address + sizeof(U));
  30                 for(size_t i = sizeof(U) - 1; i < sizeof(U); i--) {
  31                         h[address + i] = value;
  32                         value >>= 8;
  33                 }
  34                 return 0;
  35         }
  36
  37         function_ptr_luafun hm_read("hostmemory.read", [](lua_State* LS, const std::string& fname) -> int {
  38                 return do_read<uint8_t, uint8_t>(LS, fname);
  39         });
  40
  41         function_ptr_luafun hm_write("hostmemory.write", [](lua_State* LS, const std::string& fname) -> int {
  42                 return do_write<uint8_t, uint8_t>(LS, fname);
  43         });
  44
  45         function_ptr_luafun hm_readb("hostmemory.readbyte", [](lua_State* LS, const std::string& fname) -> int {
  46                 return do_read<uint8_t, uint8_t>(LS, fname);
  47         });
  48
  49         function_ptr_luafun hm_writeb("hostmemory.writebyte", [](lua_State* LS, const std::string& fname) -> int {
  50                 return do_write<uint8_t, uint8_t>(LS, fname);
  51         });
  52
  53         function_ptr_luafun hm_readsb("hostmemory.readsbyte", [](lua_State* LS, const std::string& fname) -> int {
  54                 return do_read<uint8_t, int8_t>(LS, fname);
  55         });
  56
  57         function_ptr_luafun hm_writesb("hostmemory.writesbyte", [](lua_State* LS, const std::string& fname) -> int {
  58                 return do_write<uint8_t, int8_t>(LS, fname);
  59         });
  60
  61         function_ptr_luafun hm_readw("hostmemory.readword", [](lua_State* LS, const std::string& fname) -> int {
  62                 return do_read<uint16_t, uint16_t>(LS, fname);
  63         });
  64
  65         function_ptr_luafun hm_writew("hostmemory.writeword", [](lua_State* LS, const std::string& fname) -> int {
  66                 return do_write<uint16_t, uint16_t>(LS, fname);
  67         });
  68
  69         function_ptr_luafun hm_readsw("hostmemory.readsword", [](lua_State* LS, const std::string& fname) -> int {
  70                 return do_read<uint16_t, int16_t>(LS, fname);
  71         });
  72
  73         function_ptr_luafun hm_writesw("hostmemory.writesword", [](lua_State* LS, const std::string& fname) -> int {
  74                 return do_write<uint16_t, int16_t>(LS, fname);
  75         });
  76
  77         function_ptr_luafun hm_readd("hostmemory.readdword", [](lua_State* LS, const std::string& fname) -> int {
  78                 return do_read<uint32_t, uint32_t>(LS, fname);
  79         });
  80
  81         function_ptr_luafun hm_writed("hostmemory.writedword", [](lua_State* LS, const std::string& fname) -> int {
  82                 return do_write<uint32_t, uint32_t>(LS, fname);
  83         });
  84
  85         function_ptr_luafun hm_readsd("hostmemory.readsdword", [](lua_State* LS, const std::string& fname) -> int {
  86                 return do_read<uint32_t, int32_t>(LS, fname);
  87         });
  88
  89         function_ptr_luafun hm_writesd("hostmemory.writesdword", [](lua_State* LS, const std::string& fname) -> int {
  90                 return do_write<uint32_t, int32_t>(LS, fname);
  91         });
  92
  93         function_ptr_luafun hm_readq("hostmemory.readqword", [](lua_State* LS, const std::string& fname) -> int {
  94                 return do_read<uint64_t, uint64_t>(LS, fname);
  95         });
  96
  97         function_ptr_luafun hm_writeq("hostmemory.writeqword", [](lua_State* LS, const std::string& fname) -> int {
  98                 return do_write<uint64_t, uint64_t>(LS, fname);
  99         });
 100
 101         function_ptr_luafun hm_readsq("hostmemory.readsqword", [](lua_State* LS, const std::string& fname) -> int {
 102                 return do_read<uint64_t, int64_t>(LS, fname);
 103         });
 104
 105         function_ptr_luafun hm_writesq("hostmemory.writesqword", [](lua_State* LS, const std::string& fname) -> int {
 106                 return do_write<uint64_t, int64_t>(LS, fname);
 107         });
 108 }