Luna.hh

/*
** TowBowlTactics, a turn-based strategy football game.
**
** Copyright (C) 2009-2010 The TBT Team.
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or (at your option) any later version.
**
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
**
** The TBT Team consists of people listed in the `AUTHORS' file.
*/

#ifndef LUNA_HH_
# define LUNA_HH_

# include "Lua.hh"

# include <cstring>
# include <string>

template <typename T>
class Luna
{
  typedef struct { T *pT; } userdataType;

public:
  typedef int (T::*mfp)(lua_State *L);

  struct RegType {
    const char *name;
    mfp mfunc;
  };

  static void registerMethods(lua_State* l);
  
  static T* check(lua_State* l, int narg);

  static T* create(lua_State* l);

  static int getMethod(lua_State *l, const std::string& funcname);


private:
  Luna();  // hide default constructor

  // member function dispatcher
  static int thunk(lua_State *L);

  // create a new T object and
  // push onto the Lua stack a userdata containing a pointer to T object
  static int new_T(lua_State *L);

  // garbage collection metamethod
  static int gc_T(lua_State *L);

  static int tostring_T(lua_State *L);

  // add lua function to this userdata
  static int newindex(lua_State* l);
};

# define luna_method(class, name) { #name, &class::name }




//
// implementation of the Luna class
//


template <typename T>
inline void Luna<T>::registerMethods(lua_State *l)
{
  std::string name(T::className);
  size_t idx = name.find_last_of(".");
  std::string superclass(name.substr(0, idx));

  lua_newtable(l);
  int methods = lua_gettop(l);

  luaL_newmetatable(l, T::className);
  int metatable = lua_gettop(l);

  // store method table in globals so that
  // scripts can add functions written in Lua.
  if (idx != std::string::npos)
    lua_pushstring(l, name.substr(idx + 1).c_str());
  else
    lua_pushstring(l, T::className);
  lua_pushvalue(l, methods);
  lua_settable(l, LUA_GLOBALSINDEX);

  lua_pushliteral(l, "__metatable");
  lua_pushvalue(l, methods);
  lua_settable(l, metatable);  // hide metatable from Lua getmetatable()

  lua_pushcclosure(l, newindex, 0);
  lua_setfield(l, metatable, "__newindex");

  lua_pushvalue(l, methods);
  lua_setfield(l, metatable, "__index");

  lua_pushliteral(l, "__tostring");
  lua_pushcfunction(l, tostring_T);
  lua_settable(l, metatable);

  lua_pushliteral(l, "__gc");
  lua_pushcfunction(l, gc_T);
  lua_settable(l, metatable);

  lua_newtable(l);                // mt for method table
  int mt = lua_gettop(l);
  lua_pushliteral(l, "__call");
  lua_pushcfunction(l, new_T);
  lua_pushliteral(l, "new");
  lua_pushvalue(l, -2);           // dup new_T function
  lua_settable(l, methods);       // add new_T to method table
  lua_settable(l, mt);            // mt.__call = new_T
  lua_setmetatable(l, methods);

  // fill method table with methods from class T
  for (RegType *ll = T::methods; ll->name; ll++)
    {
      lua_pushstring(l, ll->name);
      lua_pushlightuserdata(l, (void*)ll);
      lua_pushcclosure(l, thunk, 1);
      lua_settable(l, methods);
    }

  // add methods from base class
  if (idx != std::string::npos)
    {
      luaL_getmetatable(l, superclass.c_str());
      if (!lua_istable(l, -1))
        luaL_error(l, "superclass '%s' not found", superclass.c_str());
      lua_getfield(l, -1, "__index");

      lua_pushnil(l);
      while (lua_next(l, -2))
        {
          if (strcmp(lua_tostring(l, -2), "new"))
            {
              lua_pushvalue(l, -2);
              lua_pushvalue(l, -2);
              lua_settable(l, methods);
            }
          lua_pop(l, 1);
        }
      lua_pop(l, 2);
    }

  lua_pop(l, 2);  // drop metatable and method table
}

template <typename T>
inline T* Luna<T>::check(lua_State *L, int narg)
{
  userdataType *ud;

  ud = static_cast<userdataType*>(luaL_checkudata(L, narg, T::className));
  if (!ud)
    luaL_typerror(L, narg, T::className);
  return ud->pT;  // pointer to T object
}

template <typename T>
inline T* Luna<T>::create(lua_State *l)
{
  lua_pushnil(l);
  lua_insert(l, 1);
  new_T(l);
  return check(l, -1);
}

template <typename T>
inline int Luna<T>::getMethod(lua_State *l, const std::string& funcname)
{
  luaL_getmetatable(l, T::className);
  lua_getfield(l, -1, "__index");
  lua_remove(l, -2);
  lua_getfield(l, -1, funcname.c_str());
  lua_remove(l, -2);

  if (!lua_isfunction(l, -1))
    {
      // not a function, pop it
      lua_pop(l, 1);
      return luaL_error(l, "method not found in %s: %s",
                        T::className, funcname.c_str());
    }

  // ok, push function
  return 1;
}



template <typename T>
inline int Luna<T>::thunk(lua_State *L)
{
  // stack has userdata, followed by method args
  T *obj = check(L, 1);  // get 'self', or if you prefer, 'this'
  lua_remove(L, 1);  // remove self so member function args start at index 1
  // get member function from upvalue
  RegType *l = static_cast<RegType*>(lua_touserdata(L, lua_upvalueindex(1)));
  return (obj->*(l->mfunc))(L);  // call member function
}

template <typename T>
inline int Luna<T>::new_T(lua_State *L)
{
  lua_remove(L, 1);  // use classname:new(), instead of classname.new()
  T *obj = new T(L);  // call constructor for T objects
  userdataType *ud =
    static_cast<userdataType*>(lua_newuserdata(L, sizeof(userdataType)));
  ud->pT = obj;  // store pointer to object in userdata
  luaL_getmetatable(L, T::className);  // lookup metatable in Lua registry
  lua_setmetatable(L, -2);
  return 1;  // userdata containing pointer to T object
}

template <typename T>
inline int Luna<T>::gc_T(lua_State *L)
{
  userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, 1));
  T *obj = ud->pT;
  delete obj;  // call destructor for T objects
  return 0;
}

template <typename T>
inline int Luna<T>::tostring_T (lua_State *L)
{
  userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, 1));
  T *obj = ud->pT;
  lua_pushfstring(L, "%s (%p)", T::className, obj);
  return 1;
}

template <typename T>
inline int Luna<T>::newindex(lua_State* l)
{
  if (!lua_isfunction(l, 3))
    return luaL_error(l, "attempt to set a value to class %s",
                      T::className);

  // HACK: add method to the base class
  std::string name(T::className);
  size_t idx = name.find_last_of(".");
  std::string superclass(name.substr(0, idx));

  // retrieve __index in this user metatable
  luaL_getmetatable(l, superclass.c_str());
  lua_getfield(l, -1, "__index");
  if (!lua_istable(l, -1))
    return luaL_error(l, "newindex: bug");

  // add the new function to the table
  lua_pushvalue(l, 2);
  lua_pushvalue(l, 3);
  lua_settable(l, -3);
  
  return 0;
}


#endif // LUNA_HH_