include/core/lua-int.hpp

   1 #ifndef _lua_int__hpp__included__
   2 #define _lua_int__hpp__included__
   3
   4 #include "lua.hpp"
   5 #include <cstdio>
   6 #include <cstdlib>
   7 extern "C"
   8 {
   9 #include <lua.h>
  10 }
  11
  12 std::string get_string_argument(lua_State* LS, unsigned argindex, const char* fname);
  13 bool get_boolean_argument(lua_State* LS, unsigned argindex, const char* fname);
  14 void push_keygroup_parameters(lua_State* LS, const struct keygroup::parameters& p);
  15 extern lua_render_context* lua_render_ctx;
  16 extern controller_frame* lua_input_controllerdata;
  17 extern bool lua_booted_flag;
  18 extern uint64_t lua_idle_hook_time;
  19 extern uint64_t lua_timer_hook_time;
  20
  21 template<typename T>
  22 T get_numeric_argument(lua_State* LS, unsigned argindex, const char* fname)
  23 {
  24         if(lua_isnone(LS, argindex) || !lua_isnumber(LS, argindex)) {
  25                 char buffer[1024];
  26                 sprintf(buffer, "argument #%i to %s must be numeric", argindex, fname);
  27                 lua_pushstring(LS, buffer);
  28                 lua_error(LS);
  29         }
  30         return static_cast<T>(lua_tonumber(LS, argindex));
  31 }
  32
  33 template<typename T>
  34 void get_numeric_argument(lua_State* LS, unsigned argindex, T& value, const char* fname)
  35 {
  36         if(lua_isnoneornil(LS, argindex))
  37                 return;
  38         if(lua_isnone(LS, argindex) || !lua_isnumber(LS, argindex)) {
  39                 char buffer[1024];
  40                 sprintf(buffer, "argument #%i to %s must be numeric if present", argindex, fname);
  41                 lua_pushstring(LS, buffer);
  42                 lua_error(LS);
  43         }
  44         value = static_cast<T>(lua_tonumber(LS, argindex));
  45 }
  46
  47
  48 template<typename T> struct lua_obj_pin
  49 {
  50         lua_obj_pin(lua_State* LS, T* _object)
  51         {
  52                 lua_pushlightuserdata(LS, this);
  53                 lua_pushvalue(LS, -2);
  54                 lua_rawset(LS, LUA_REGISTRYINDEX);
  55                 state = LS;
  56                 obj = _object;
  57         }
  58         ~lua_obj_pin()
  59         {
  60                 lua_pushlightuserdata(state, this);
  61                 lua_pushnil(state);
  62                 lua_rawset(state, LUA_REGISTRYINDEX);
  63         }
  64         T* object() { return obj; }
  65 private:
  66         T* obj;
  67         lua_State* state;
  68         lua_obj_pin(const lua_obj_pin&);
  69         lua_obj_pin& operator=(const lua_obj_pin&);
  70 };
  71
  72 template<class T> class lua_class;
  73
  74 template<class T> lua_class<T>& objclass();
  75
  76 template<class T> class lua_class
  77 {
  78 public:
  79         lua_class(const std::string& _name)
  80         {
  81                 name = _name;
  82         }
  83
  84         template<typename... U> T* _create(lua_State* LS, U... args)
  85         {
  86                 void* obj = lua_newuserdata(LS, sizeof(T));
  87                 load_metatable(LS);
  88                 lua_setmetatable(LS, -2);
  89                 T* _obj = reinterpret_cast<T*>(obj);
  90                 new(_obj) T(args...);
  91                 return _obj;
  92         }
  93
  94         template<typename... U> static T* create(lua_State* LS, U... args)
  95         {
  96                 return objclass<T>()._create(LS, args...);
  97         }
  98
  99         void bind(lua_State* LS)
 100         {
 101                 load_metatable(LS);
 102                 lua_pushvalue(LS, -3);
 103                 lua_pushvalue(LS, -3);
 104                 lua_rawset(LS, -3);
 105         }
 106
 107         void bind(lua_State* LS, const char* keyname)
 108         {
 109                 load_metatable(LS);
 110                 lua_pushstring(LS, keyname);
 111                 lua_pushvalue(LS, -3);
 112                 lua_rawset(LS, -3);
 113         }
 114
 115         T* _get(lua_State* LS, int arg, const char* fname, bool optional = false)
 116         {
 117                 if(lua_type(LS, arg) == LUA_TNONE || lua_type(LS, arg) == LUA_TNIL) {
 118                         if(optional)
 119                                 return NULL;
 120                         else
 121                                 goto badtype;
 122                 }
 123                 load_metatable(LS);
 124                 if(!lua_getmetatable(LS, arg))
 125                         goto badtype;
 126                 if(!lua_rawequal(LS, -1, -2))
 127                         goto badtype;
 128                 lua_pop(LS, 2);
 129                 return reinterpret_cast<T*>(lua_touserdata(LS, arg));
 130 badtype:
 131                 char buffer[2048];
 132                 sprintf(buffer, "argument #%i to %s must be %s", arg, fname, name.c_str());
 133                 lua_pushstring(LS, buffer);
 134                 lua_error(LS);
 135         }
 136
 137         static T* get(lua_State* LS, int arg, const char* fname, bool optional = false)
 138         {
 139                 return objclass<T>()._get(LS, arg, fname, optional);
 140         }
 141
 142         bool _is(lua_State* LS, int arg)
 143         {
 144                 if(lua_type(LS, arg) != LUA_TUSERDATA)
 145                         return false;
 146                 load_metatable(LS);
 147                 if(!lua_getmetatable(LS, arg)) {
 148                         lua_pop(LS, 1);
 149                         return false;
 150                 }
 151                 bool ret = lua_rawequal(LS, -1, -2);
 152                 lua_pop(LS, 2);
 153                 return ret;
 154         }
 155
 156         static bool is(lua_State* LS, int arg)
 157         {
 158                 return objclass<T>()._is(LS, arg);
 159         }
 160
 161         lua_obj_pin<T>* _pin(lua_State* LS, int arg, const char* fname)
 162         {
 163                 T* obj = get(LS, arg, fname);
 164                 lua_pushvalue(LS, arg);
 165                 return new lua_obj_pin<T>(LS, obj);
 166         }
 167
 168         static lua_obj_pin<T>* pin(lua_State* LS, int arg, const char* fname)
 169         {
 170                 return objclass<T>()._pin(LS, arg, fname);
 171         }
 172 private:
 173         static int dogc(lua_State* LS)
 174         {
 175                 T* obj = reinterpret_cast<T*>(lua_touserdata(LS, 1));
 176                 obj->~T();
 177         }
 178
 179         void load_metatable(lua_State* LS)
 180         {
 181 again:
 182                 lua_pushlightuserdata(LS, this);
 183                 lua_rawget(LS, LUA_REGISTRYINDEX);
 184                 if(lua_type(LS, -1) == LUA_TNIL) {
 185                         lua_pop(LS, 1);
 186                         lua_pushlightuserdata(LS, this);
 187                         lua_newtable(LS);
 188                         lua_pushstring(LS, "__gc");
 189                         lua_pushcfunction(LS, &lua_class<T>::dogc);
 190                         lua_rawset(LS, -3);
 191                         lua_rawset(LS, LUA_REGISTRYINDEX);
 192                         goto again;
 193                 }
 194         }
 195         std::string name;
 196         lua_class(const lua_class<T>&);
 197         lua_class& operator=(const lua_class<T>&);
 198 };
 199
 200 #define DECLARE_LUACLASS(x, X) template<> lua_class< x >& objclass() { static lua_class< x > clazz( X ); \
 201         return clazz; }
 202
 203
 204
 205 #endif