1 files changed, 392 insertions, 377 deletions

diff --git a/source/ManualBindings.cpp b/source/ManualBindings.cpp
index 5b2b6ff9e..b7d31a79d 100644
--- a/source/ManualBindings.cpp
+++ b/source/ManualBindings.cpp
@@ -13,6 +13,8 @@
 #include "WebAdmin.h"
 #include "StringMap.h"
 #include "ClientHandle.h"
+#include "ChestEntity.h"
+#include "FurnaceEntity.h"
 #include "md5/md5.h"
 
 
@@ -27,6 +29,54 @@ bool report_errors(lua_State* lua, int status);
 
 
 /****************************
+ * Better error reporting for Lua
+ **/
+int tolua_do_error(lua_State* L, const char * a_pMsg, tolua_Error * a_pToLuaError)
+{
+	// Retrieve current function name
+	lua_Debug entry;
+	ASSERT( lua_getstack(L, 0, &entry) );
+	ASSERT( lua_getinfo(L, "n", &entry) );
+
+	// Insert function name into error msg
+	AString msg(a_pMsg);
+	ReplaceString(msg, "#funcname#", entry.name?entry.name:"?");
+
+	// Send the error to Lua
+	tolua_error(L, msg.c_str(), a_pToLuaError);
+	return 0;
+}
+
+
+
+
+
+int lua_do_error(lua_State* L, const char * a_pFormat, ...)
+{
+	// Retrieve current function name
+	lua_Debug entry;
+	ASSERT( lua_getstack(L, 0, &entry) );
+	ASSERT( lua_getinfo(L, "n", &entry) );
+
+	// Insert function name into error msg
+	AString msg(a_pFormat);
+	ReplaceString(msg, "#funcname#", entry.name?entry.name:"?");
+
+	// Copied from luaL_error and modified
+	va_list argp;
+	va_start(argp, a_pFormat);
+	luaL_where(L, 1);
+	lua_pushvfstring(L, msg.c_str(), argp);
+	va_end(argp);
+	lua_concat(L, 2);
+	return lua_error(L);
+}
+
+
+
+
+
+/****************************
  * Lua bound functions with special return types
  **/
 
@@ -98,390 +148,360 @@ static int tolua_LOGERROR(lua_State* tolua_S)
 
 
 
-#define DEFINE_LUA_DOWITH(CONTAINER,ITEM,FOREACH,FNNAME) \
-static int FNNAME(lua_State * tolua_S) \
-{ \
-	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ \
-	if ((NumArgs != 2) && (NumArgs != 3)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Requires 2 or 3 arguments, got %i", NumArgs ); \
-		return 0; \
-	} \
-	\
-	CONTAINER * self = (CONTAINER *)  tolua_tousertype(tolua_S, 1, 0); \
-	\
-	const char * ItemName = tolua_tocppstring(tolua_S, 2, ""); \
-	if ((ItemName == NULL) || (ItemName[0] == 0)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Expected a non-empty string for parameter #1"); \
-		return 0; \
-	} \
-	if (!lua_isfunction( tolua_S, 3)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Expected a function for parameter #2"); \
-		return 0; \
-	} \
-	\
-	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ \
-	int TableRef = LUA_REFNIL; \
-	if (NumArgs == 3) \
-	{ \
-		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-		if (TableRef == LUA_REFNIL) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Could not get value reference of parameter #3"); \
-			return 0; \
-		} \
-	} \
-	\
-	/* table value is popped, and now function is on top of the stack */ \
-	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-	if (FuncRef == LUA_REFNIL) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Could not get function reference of parameter #2"); \
-		return 0; \
-	} \
-	\
-	class cLuaCallback : public cItemCallback<ITEM> \
-	{ \
-	public: \
-		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) \
-			: LuaState( a_LuaState ) \
-			, FuncRef( a_FuncRef ) \
-			, TableRef( a_TableRef ) \
-		{} \
-	\
-	private: \
-		virtual bool Item(ITEM * a_Item) override \
-		{ \
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ \
-			tolua_pushusertype(LuaState, a_Item, #ITEM); \
-			if (TableRef != LUA_REFNIL) \
-			{ \
-				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ \
-			} \
-			\
-			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); \
-			report_errors(LuaState, s); \
-			return true; \
-		} \
-		lua_State * LuaState; \
-		int FuncRef; \
-		int TableRef; \
-	} Callback(tolua_S, FuncRef, TableRef); \
-	\
-	bool bRetVal = self->FOREACH(ItemName, Callback); \
-	\
-	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); \
-	\
-	/* Push return value on stack */ \
-	tolua_pushboolean(tolua_S, bRetVal ); \
-	return 1; \
+template<
+	class Ty1,
+	class Ty2,
+	bool (Ty1::*Func1)(const AString &, cItemCallback<Ty2> &)
+	>
+static int tolua_DoWith(lua_State* tolua_S)
+{
+	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ 
+	if ((NumArgs != 2) && (NumArgs != 3)) 
+	{
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
+	} 
+
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0); 
+
+	const char * ItemName = tolua_tocppstring(tolua_S, 2, ""); 
+	if ((ItemName == NULL) || (ItemName[0] == 0)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1", NumArgs);
+	} 
+	if (!lua_isfunction( tolua_S, 3)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #2", NumArgs);
+	} 
+
+	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ 
+	int TableRef = LUA_REFNIL; 
+	if (NumArgs == 3) 
+	{ 
+		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+		if (TableRef == LUA_REFNIL) 
+		{ 
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get value reference of parameter #3", NumArgs);
+		} 
+	} 
+
+	/* table value is popped, and now function is on top of the stack */ 
+	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+	if (FuncRef == LUA_REFNIL) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #2", NumArgs);
+	} 
+
+	class cLuaCallback : public cItemCallback<Ty2> 
+	{
+	public: 
+		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) 
+			: LuaState( a_LuaState ) 
+			, FuncRef( a_FuncRef ) 
+			, TableRef( a_TableRef ) 
+		{} 
+
+	private: 
+		virtual bool Item(Ty2 * a_Item) override 
+		{ 
+			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ 
+			tolua_pushusertype(LuaState, a_Item, Ty2::GetClassStatic());
+			if (TableRef != LUA_REFNIL) 
+			{ 
+				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ 
+			} 
+
+			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); 
+			report_errors(LuaState, s); 
+			return true; 
+		} 
+		lua_State * LuaState; 
+		int FuncRef; 
+		int TableRef; 
+	} Callback(tolua_S, FuncRef, TableRef); 
+
+	
+	bool bRetVal = (self->*Func1)(ItemName, Callback);
+
+	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); 
+
+	/* Push return value on stack */ 
+	tolua_pushboolean(tolua_S, bRetVal ); 
+	return 1; 
 }
 
 
 
 
-#define DEFINE_LUA_DOWITH_XYZ(CONTAINER,ITEM,FOREACH,FNNAME) \
-	static int FNNAME(lua_State * tolua_S) \
-	{ \
-		int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ \
-		if ((NumArgs != 4) && (NumArgs != 5)) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Requires 4 or 5 arguments, got %i", NumArgs ); \
-			return 0; \
-		} \
-		\
-		CONTAINER * self = (CONTAINER *)  tolua_tousertype(tolua_S, 1, 0); \
-		if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3) || !lua_isnumber(tolua_S, 4)) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Expected a number for parameters #1, #2 and #3"); \
-			return 0; \
-		} \
-		\
-		int ItemX = ((int)tolua_tonumber(tolua_S, 2, 0)); \
-		int ItemY = ((int)tolua_tonumber(tolua_S, 3, 0)); \
-		int ItemZ = ((int)tolua_tonumber(tolua_S, 4, 0)); \
-		LOG("x %i y %i z %i", ItemX, ItemY, ItemZ ); \
-		if (!lua_isfunction( tolua_S, 5)) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Expected a function for parameter #2"); \
-			return 0; \
-		} \
-		\
-		/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ \
-		int TableRef = LUA_REFNIL; \
-		if (NumArgs == 5) \
-		{ \
-			TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-			if (TableRef == LUA_REFNIL) \
-			{ \
-			LOGWARN("Error in function call '" #FOREACH "': Could not get value reference of parameter #3"); \
-			return 0; \
-			} \
-		} \
-		\
-		/* table value is popped, and now function is on top of the stack */ \
-		int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-		if (FuncRef == LUA_REFNIL) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Could not get function reference of parameter #2"); \
-			return 0; \
-		} \
-		\
-		class cLuaCallback : public cItemCallback<ITEM> \
-		{ \
-		public: \
-			cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) \
-			: LuaState( a_LuaState ) \
-			, FuncRef( a_FuncRef ) \
-			, TableRef( a_TableRef ) \
-			{} \
-			\
-		private: \
-			virtual bool Item(ITEM * a_Item) override \
-			{ \
-				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ \
-				tolua_pushusertype(LuaState, a_Item, #ITEM); \
-				if (TableRef != LUA_REFNIL) \
-				{ \
-					lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ \
-				} \
-				\
-				int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); \
-				report_errors(LuaState, s); \
-				return true; \
-			} \
-			lua_State * LuaState; \
-			int FuncRef; \
-			int TableRef; \
-		} Callback(tolua_S, FuncRef, TableRef); \
-		\
-		bool bRetVal = self->FOREACH(ItemX, ItemY, ItemZ, Callback); \
-		\
-		/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ \
-		luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); \
-		luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); \
-		\
-		/* Push return value on stack */ \
-		tolua_pushboolean(tolua_S, bRetVal ); \
-		return 1; \
-	}
+
+template< class Ty1,
+          class Ty2,
+          bool (Ty1::*Func1)(int, int, int, cItemCallback<Ty2> &) >
+static int tolua_DoWithXYZ(lua_State* tolua_S)
+{
+	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ 
+	if ((NumArgs != 4) && (NumArgs != 5)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 4 or 5 arguments, got %i", NumArgs);
+	} 
+
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0); 
+	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3) || !lua_isnumber(tolua_S, 4)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1, #2 and #3");
+	} 
+
+	int ItemX = ((int)tolua_tonumber(tolua_S, 2, 0)); 
+	int ItemY = ((int)tolua_tonumber(tolua_S, 3, 0)); 
+	int ItemZ = ((int)tolua_tonumber(tolua_S, 4, 0)); 
+	LOG("x %i y %i z %i", ItemX, ItemY, ItemZ ); 
+	if (!lua_isfunction( tolua_S, 5)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #4");
+	} 
+
+	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ 
+	int TableRef = LUA_REFNIL; 
+	if (NumArgs == 5) 
+	{ 
+		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+		if (TableRef == LUA_REFNIL) 
+		{ 
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get value reference of parameter #5");
+		} 
+	} 
+
+	/* table value is popped, and now function is on top of the stack */ 
+	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+	if (FuncRef == LUA_REFNIL) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #4");
+	} 
+
+	class cLuaCallback : public cItemCallback<Ty2> 
+	{ 
+	public: 
+		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) 
+			: LuaState( a_LuaState ) 
+			, FuncRef( a_FuncRef ) 
+			, TableRef( a_TableRef ) 
+		{} 
+
+	private: 
+		virtual bool Item(Ty2 * a_Item) override 
+		{ 
+			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ 
+			tolua_pushusertype(LuaState, a_Item, Ty2::GetClassStatic()); 
+			if (TableRef != LUA_REFNIL) 
+			{ 
+				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ 
+			} 
+
+			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); 
+			report_errors(LuaState, s); 
+			return true; 
+		} 
+		lua_State * LuaState; 
+		int FuncRef; 
+		int TableRef; 
+	} Callback(tolua_S, FuncRef, TableRef); 
+
+	bool bRetVal = (self->*Func1)(ItemX, ItemY, ItemZ, Callback);
+
+	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); 
+
+	/* Push return value on stack */ 
+	tolua_pushboolean(tolua_S, bRetVal ); 
+	return 1; 
+}
 
 
 
 
 
-#define DEFINE_LUA_FOREACHINCHUNK(CONTAINER,ITEM,FOREACH,FNNAME) \
-static int FNNAME(lua_State * tolua_S) \
-{ \
-	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ \
-	if ((NumArgs != 3) && (NumArgs != 4)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Requires 3 or 4 arguments, got %i", NumArgs); \
-		return 0; \
-	} \
-	\
-	CONTAINER * self = (CONTAINER *)  tolua_tousertype(tolua_S, 1, 0); \
-	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3)) \
-	{ \
-		LOGWARN("Errorin function call '" #FOREACH "': Expected a number for parameters #1 and #2"); \
-		return 0; \
-	} \
-	\
-	int ChunkX = ((int)tolua_tonumber(tolua_S, 2, 0)); \
-	int ChunkZ = ((int)tolua_tonumber(tolua_S, 3, 0)); \
-	\
-	if (!lua_isfunction( tolua_S, 4)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Expected a function for parameter #3"); \
-		return 0; \
-	} \
-	\
-	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ \
-	int TableRef = LUA_REFNIL; \
-	if (NumArgs == 4) \
-	{ \
-		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-		if (TableRef == LUA_REFNIL) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Could not get value reference of parameter #4"); \
-			return 0; \
-		} \
-	} \
-	\
-	/* table value is popped, and now function is on top of the stack */ \
-	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-	if (FuncRef == LUA_REFNIL) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Could not get function reference of parameter #3"); \
-		return 0; \
-	} \
-	\
-	class cLuaCallback : public cItemCallback<ITEM> \
-	{ \
-	public: \
-		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) \
-			: LuaState( a_LuaState ) \
-			, FuncRef( a_FuncRef ) \
-			, TableRef( a_TableRef ) \
-		{} \
-	\
-	private: \
-		virtual bool Item(ITEM * a_Item) override \
-		{ \
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ \
-			tolua_pushusertype(LuaState, a_Item, #ITEM); \
-			if (TableRef != LUA_REFNIL) \
-			{ \
-				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ \
-			} \
-			\
-			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); \
-			if (report_errors(LuaState, s)) \
-			{ \
-				return true;  /* Abort enumeration */ \
-			} \
-			\
-			if (lua_isboolean(LuaState, -1)) \
-			{ \
-				return (tolua_toboolean( LuaState, -1, 0) > 0); \
-			} \
-			return false;  /* Continue enumeration */ \
-		} \
-		lua_State * LuaState; \
-		int FuncRef; \
-		int TableRef; \
-	} Callback(tolua_S, FuncRef, TableRef); \
-	\
-	bool bRetVal = self->FOREACH(ChunkX, ChunkZ, Callback); \
-	\
-	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); \
-	\
-	/* Push return value on stack */ \
-	tolua_pushboolean(tolua_S, bRetVal ); \
-	return 1; \
+template< class Ty1,
+          class Ty2,
+          bool (Ty1::*Func1)(int, int, cItemCallback<Ty2> &) >
+static int tolua_ForEachInChunk(lua_State* tolua_S)
+{
+	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ 
+	if ((NumArgs != 3) && (NumArgs != 4)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 3 or 4 arguments, got %i", NumArgs);
+	} 
+
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0); 
+	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1 and #2");
+	} 
+
+	int ChunkX = ((int)tolua_tonumber(tolua_S, 2, 0)); 
+	int ChunkZ = ((int)tolua_tonumber(tolua_S, 3, 0)); 
+
+	if (!lua_isfunction( tolua_S, 4)) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #3");
+	} 
+
+	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ 
+	int TableRef = LUA_REFNIL; 
+	if (NumArgs == 4) 
+	{ 
+		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+		if (TableRef == LUA_REFNIL) 
+		{ 
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get value reference of parameter #4");
+		} 
+	} 
+
+	/* table value is popped, and now function is on top of the stack */ 
+	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); 
+	if (FuncRef == LUA_REFNIL) 
+	{ 
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #3");
+	} 
+
+	class cLuaCallback : public cItemCallback<Ty2> 
+	{ 
+	public: 
+		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) 
+			: LuaState( a_LuaState ) 
+			, FuncRef( a_FuncRef ) 
+			, TableRef( a_TableRef ) 
+		{} 
+
+	private: 
+		virtual bool Item(Ty2 * a_Item) override 
+		{ 
+			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ 
+			tolua_pushusertype(LuaState, a_Item, Ty2::GetClassStatic()); 
+			if (TableRef != LUA_REFNIL) 
+			{ 
+				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ 
+			} 
+
+			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); 
+			if (report_errors(LuaState, s)) 
+			{ 
+				return true;  /* Abort enumeration */ 
+			} 
+
+			if (lua_isboolean(LuaState, -1)) 
+			{ 
+				return (tolua_toboolean( LuaState, -1, 0) > 0); 
+			} 
+			return false;  /* Continue enumeration */ 
+		} 
+		lua_State * LuaState; 
+		int FuncRef; 
+		int TableRef; 
+	} Callback(tolua_S, FuncRef, TableRef); 
+
+	bool bRetVal = (self->*Func1)(ChunkX, ChunkZ, Callback);
+
+	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); 
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); 
+
+	/* Push return value on stack */ 
+	tolua_pushboolean(tolua_S, bRetVal ); 
+	return 1; 
 }
 
 
 
 
 
-#define DEFINE_LUA_FOREACH(CONTAINER,ITEM,FOREACH,FNNAME) \
-static int FNNAME(lua_State * tolua_S) \
-{ \
-	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */ \
-	if( NumArgs != 1 && NumArgs != 2) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Requires 1 or 2 arguments, got %i", NumArgs ); \
-		return 0; \
-	} \
-	\
-	CONTAINER * self = (CONTAINER *)  tolua_tousertype(tolua_S, 1, 0); \
-	if (self == NULL) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Not called on an object instance"); \
-		return 0; \
-	} \
-	\
-	if (!lua_isfunction( tolua_S, 2)) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Expected a function for parameter #1"); \
-		return 0; \
-	} \
-	\
-	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */ \
-	int TableRef = LUA_REFNIL; \
-	if (NumArgs == 2) \
-	{ \
-		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-		if (TableRef == LUA_REFNIL) \
-		{ \
-			LOGWARN("Error in function call '" #FOREACH "': Could not get value reference of parameter #2"); \
-			return 0; \
-		} \
-	} \
-	\
-	/* table value is popped, and now function is on top of the stack */ \
-	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX); \
-	if (FuncRef == LUA_REFNIL) \
-	{ \
-		LOGWARN("Error in function call '" #FOREACH "': Could not get function reference of parameter #1"); \
-		return 0; \
-	} \
-	\
-	class cLuaCallback : public cItemCallback<ITEM> \
-	{ \
-	public: \
-		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef) \
-			: LuaState( a_LuaState ) \
-			, FuncRef( a_FuncRef ) \
-			, TableRef( a_TableRef ) \
-		{} \
-		\
-	private: \
-		virtual bool Item(ITEM * a_Item) override \
-		{ \
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */ \
-			tolua_pushusertype( LuaState, a_Item, #ITEM ); \
-			if (TableRef != LUA_REFNIL) \
-			{ \
-				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */ \
-			} \
-			\
-			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0); \
-			if (report_errors(LuaState, s)) \
-			{ \
-				return true;  /* Abort enumeration */ \
-			} \
-			\
-			if (lua_isboolean(LuaState, -1)) \
-			{ \
-				return (tolua_toboolean( LuaState, -1, 0) > 0); \
-			} \
-			return false;  /* Continue enumeration */ \
-		} \
-		lua_State * LuaState; \
-		int FuncRef; \
-		int TableRef; \
-	} Callback(tolua_S, FuncRef, TableRef); \
-	\
-	bool bRetVal = self->FOREACH(Callback); \
-	\
-	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */ \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef); \
-	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef); \
-	\
-	/* Push return value on stack */ \
-	tolua_pushboolean(tolua_S, bRetVal ); \
-	return 1; \
-}
+template< class Ty1,
+          class Ty2, 
+          bool (Ty1::*Func1)(cItemCallback<Ty2> &) >
+static int tolua_ForEach(lua_State * tolua_S)
+{
+	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */
+	if( NumArgs != 1 && NumArgs != 2)
+	{
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 1 or 2 arguments, got %i", NumArgs);
+	}
+
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	if (self == NULL)
+	{
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
+	}
+
+	if (!lua_isfunction( tolua_S, 2))
+	{
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #1");
+	}
 
+	/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */
+	int TableRef = LUA_REFNIL;
+	if (NumArgs == 2)
+	{
+		TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+		if (TableRef == LUA_REFNIL)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get value reference of parameter #2");
+		}
+	}
 
+	/* table value is popped, and now function is on top of the stack */
+	int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+	if (FuncRef == LUA_REFNIL)
+	{
+		return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #1");
+	}
 
+	class cLuaCallback : public cItemCallback<Ty2>
+	{
+	public:
+		cLuaCallback(lua_State* a_LuaState, int a_FuncRef, int a_TableRef)
+			: LuaState( a_LuaState )
+			, FuncRef( a_FuncRef )
+			, TableRef( a_TableRef )
+		{}
+
+	private:
+		virtual bool Item(Ty2 * a_Item) override
+		{
+			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
+			tolua_pushusertype( LuaState, a_Item, Ty2::GetClassStatic() );
+			if (TableRef != LUA_REFNIL)
+			{
+				lua_rawgeti( LuaState, LUA_REGISTRYINDEX, TableRef);  /* Push table reference */
+			}
 
+			int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0);
+			if (report_errors(LuaState, s))
+			{
+				return true;  /* Abort enumeration */
+			}
 
-// Define the DoWith enumerators: (they take a string and a callback class)
-DEFINE_LUA_DOWITH(cWorld, cPlayer, DoWithPlayer,        tolua_cWorld_DoWithPlayer);
-DEFINE_LUA_DOWITH(cWorld, cPlayer, FindAndDoWithPlayer, tolua_cWorld_FindAndDoWithPlayer);
-DEFINE_LUA_DOWITH(cRoot,  cPlayer, FindAndDoWithPlayer, tolua_cRoot_FindAndDoWithPlayer);
+			if (lua_isboolean(LuaState, -1))
+			{
+				return (tolua_toboolean( LuaState, -1, 0) > 0);
+			}
+			return false;  /* Continue enumeration */
+		}
+		lua_State * LuaState;
+		int FuncRef;
+		int TableRef;
+	} Callback(tolua_S, FuncRef, TableRef);
 
-// Define the DoWith...At enumerators: (takes one 3D coordinate and a callback class)
-DEFINE_LUA_DOWITH_XYZ(cWorld, cChestEntity, DoWithChestAt, tolua_cWorld_DoWithChestAt );
+	bool bRetVal = (self->*Func1)(Callback);
 
-// Define the ForEach enumerators:
-DEFINE_LUA_FOREACH(cWorld, cPlayer, ForEachPlayer, tolua_cWorld_ForEachPlayer);
-DEFINE_LUA_FOREACH(cWorld, cEntity, ForEachEntity, tolua_cWorld_ForEachEntity);
-DEFINE_LUA_FOREACH(cRoot,  cWorld,  ForEachWorld,  tolua_cRoot_ForEachWorld);
-DEFINE_LUA_FOREACH(cRoot,  cPlayer, ForEachPlayer, tolua_cRoot_ForEachPlayer);
+	/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef);
+	luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef);
 
-DEFINE_LUA_FOREACHINCHUNK(cWorld, cEntity,        ForEachEntityInChunk,  tolua_cWorld_ForEachEntityInChunk);
-DEFINE_LUA_FOREACHINCHUNK(cWorld, cChestEntity,   ForEachChestInChunk,   tolua_cWorld_ForEachChestInChunk);
-DEFINE_LUA_FOREACHINCHUNK(cWorld, cFurnaceEntity, ForEachFurnaceInChunk, tolua_cWorld_ForEachFurnaceInChunk);
+	/* Push return value on stack */
+	tolua_pushboolean(tolua_S, bRetVal );
+	return 1;
+}
 
 
 
@@ -786,12 +806,7 @@ static int tolua_cPlugin_NewLua_AddWebTab(lua_State * tolua_S)
 	}
 	else
 	{
-		if( tolua_err.type == 0 )
-		{
-			tolua_err.type = "function";
-		}
-		tolua_error(tolua_S,"#ferror in function 'AddWebTab'.",&tolua_err);
-		return 0;
+		return tolua_do_error(tolua_S, "#ferror calling function '#funcname#'", &tolua_err);
 	}
 
 	if( Reference != LUA_REFNIL )
@@ -1020,20 +1035,20 @@ void ManualBindings::Bind( lua_State* tolua_S )
 		tolua_function(tolua_S, "Log",         tolua_LOG); // Deprecated
 		
 		tolua_beginmodule(tolua_S, "cRoot");
-			tolua_function(tolua_S, "ForEachWorld", tolua_cRoot_ForEachWorld);
-			tolua_function(tolua_S, "FindAndDoWithPlayer", tolua_cRoot_FindAndDoWithPlayer);
-			tolua_function(tolua_S, "ForEachPlayer", tolua_cRoot_ForEachPlayer);
+			tolua_function(tolua_S, "ForEachWorld",        tolua_ForEach<cRoot, cWorld,  &cRoot::ForEachWorld>);
+			tolua_function(tolua_S, "FindAndDoWithPlayer", tolua_DoWith <cRoot, cPlayer, &cRoot::FindAndDoWithPlayer>);
+			tolua_function(tolua_S, "ForEachPlayer",       tolua_ForEach<cRoot, cPlayer, &cRoot::ForEachPlayer>);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cWorld");
-			tolua_function(tolua_S, "ForEachPlayer",         tolua_cWorld_ForEachPlayer);
-			tolua_function(tolua_S, "ForEachEntity",         tolua_cWorld_ForEachEntity);
-			tolua_function(tolua_S, "ForEachEntityInChunk",  tolua_cWorld_ForEachEntityInChunk);
-			tolua_function(tolua_S, "ForEachChestInChunk",   tolua_cWorld_ForEachChestInChunk);
-			tolua_function(tolua_S, "ForEachFurnaceInChunk", tolua_cWorld_ForEachFurnaceInChunk);
-			tolua_function(tolua_S, "DoWithPlayer",          tolua_cWorld_DoWithPlayer);
-			tolua_function(tolua_S, "FindAndDoWithPlayer",   tolua_cWorld_FindAndDoWithPlayer);
-			tolua_function(tolua_S, "DoWithChestAt",         tolua_cWorld_DoWithChestAt);
+			tolua_function(tolua_S, "ForEachPlayer",         tolua_ForEach<cWorld, cPlayer, &cWorld::ForEachPlayer>);
+			tolua_function(tolua_S, "ForEachEntity",         tolua_ForEach<cWorld, cEntity, &cWorld::ForEachEntity>);
+			tolua_function(tolua_S, "ForEachEntityInChunk",  tolua_ForEachInChunk<cWorld, cEntity,        &cWorld::ForEachEntityInChunk>);
+			tolua_function(tolua_S, "ForEachChestInChunk",   tolua_ForEachInChunk<cWorld, cChestEntity,   &cWorld::ForEachChestInChunk>);
+			tolua_function(tolua_S, "ForEachFurnaceInChunk", tolua_ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
+			tolua_function(tolua_S, "DoWithPlayer",          tolua_DoWith<cWorld, cPlayer, &cWorld::DoWithPlayer>);
+			tolua_function(tolua_S, "FindAndDoWithPlayer",   tolua_DoWith<cWorld, cPlayer, &cWorld::FindAndDoWithPlayer>);
+			tolua_function(tolua_S, "DoWithChestAt",         tolua_DoWithXYZ<cWorld, cChestEntity, &cWorld::DoWithChestAt>);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cPlugin");