khanat-code-old/code/nel/src/gui/lua_object.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//#include "stdpch.h"
#include "nel/gui/lua_object.h"
#include "nel/gui/lua_ihm.h"
//#include "lua_ihm_ryzom.h"
#include "nel/gui/lua_helper.h"
using namespace NLGUI;
//
//#include "interface_manager.h"

////////////////
// CLuaObject //
////////////////

// *************************************************
CLuaObject::CLuaObject(CLuaState &state, const char *id)
{
	pop(state, id);
}

// *************************************************
CLuaObject::CLuaObject(CLuaState &state, const std::string &id)
{
	pop(state, id.c_str());
}


// *************************************************
bool CLuaObject::isValid() const
{
	return getLuaState() != NULL;
}

// *************************************************
CLuaState *CLuaObject::getLuaState() const
{
	return _LuaState;
}

// *************************************************
CLuaObject::CLuaObject(const CLuaObject &other)
{
	if (other.isValid())
	{
		other.push();
		nlassert(other.getLuaState());
		pop(*other.getLuaState());
		_Id = other._Id;
	}
	// else ... copy of an invalid CLuaObject( is an invalid CLuaObject
}

// *************************************************
CLuaObject &CLuaObject::operator=(const CLuaObject &other)
{
	if (!other.isValid())
	{
		release();
		return *this;
	}
	other.push();
	pop(*other.getLuaState());
	_Id = other._Id;
	return *this;
}

// *************************************************
bool CLuaObject::rawEqual(const CLuaObject &other) const
{
	nlassert(other.getLuaState() == getLuaState());
	push();
	other.push();
	bool equal = other.getLuaState()->rawEqual(-1, -2);
	getLuaState()->pop(2);
	return equal;
}

// *************************************************
CLuaObject::~CLuaObject()
{
	release();
}

// *************************************************
void CLuaObject::release()
{
	if (_LuaState)
	{
		CLuaStackChecker lsc(_LuaState);
		_LuaState->pushLightUserData((void *) this);
		_LuaState->pushNil();
		_LuaState->setTable(LUA_REGISTRYINDEX);
		_LuaState = NULL;
	}
}

// *************************************************
void CLuaObject::pop(CLuaState &luaState, const char *id)
{
	release();
	nlassert(luaState.getTop() >= 1);
	{
		CLuaStackChecker lsc(&luaState);
		luaState.pushLightUserData((void *) this);
		luaState.pushValue(-2); // copy original object
		luaState.setTable(LUA_REGISTRYINDEX);
	}
	luaState.pop();
	_LuaState = &luaState;
	_Id = id;
}

// *************************************************
void CLuaObject::push() const
{
	nlassert(isValid());
	_LuaState->pushLightUserData((void *) this);
	_LuaState->getTable(LUA_REGISTRYINDEX);
}

// *************************************************
int CLuaObject::type() const
{
	push();
	int type = _LuaState->type();
	_LuaState->pop();
	return type;
}

// *************************************************
const char *CLuaObject::getTypename() const
{
	push();
	const char *typeName = _LuaState->getTypename(-1);
	_LuaState->pop();
	return typeName;
}

// *************************************************
bool CLuaObject::isNil() const           { push(); bool result = _LuaState->isNil();           _LuaState->pop(); return result; }
bool CLuaObject::isNumber() const        { push(); bool result = _LuaState->isNumber();        _LuaState->pop(); return result; }
bool CLuaObject::isBoolean() const        { push(); bool result = _LuaState->isBoolean();      _LuaState->pop(); return result; }
bool CLuaObject::isString() const        { push(); bool result = _LuaState->isString();        _LuaState->pop(); return result; }
bool CLuaObject::isFunction() const      { push(); bool result = _LuaState->isFunction();      _LuaState->pop(); return result; }
bool CLuaObject::isCFunction() const     { push(); bool result = _LuaState->isCFunction();     _LuaState->pop(); return result; }
bool CLuaObject::isTable() const         { push(); bool result = _LuaState->isTable();         _LuaState->pop(); return result; }
bool CLuaObject::isUserData() const      { push(); bool result = _LuaState->isUserData();      _LuaState->pop(); return result; }
bool CLuaObject::isLightUserData() const { push(); bool result = _LuaState->isLightUserData(); _LuaState->pop(); return result; }
bool CLuaObject::isRGBA() const
{
	if (!isUserData()) return false;
	push();
	NLMISC::CRGBA dummy;
	return CLuaIHM::pop(*_LuaState, dummy);
}

// *************************************************
bool            CLuaObject::toBoolean() const    {	push(); bool          result  = _LuaState->toBoolean();   _LuaState->pop(); return result; }
lua_Number		CLuaObject::toNumber() const     {	push(); lua_Number    result  = _LuaState->toNumber();    _LuaState->pop(); return result; }
std::string		CLuaObject::toString() const
{
	push();
	const char *str = _LuaState->toString();
	std::string result = str ? str : "";
    _LuaState->pop();
	return result;
}
lua_CFunction	CLuaObject::toCFunction() const  {	push(); lua_CFunction result  = _LuaState->toCFunction(); _LuaState->pop(); return result; }
void			*CLuaObject::toUserData() const  {  push(); void          *result = _LuaState->toUserData();  _LuaState->pop(); return result; }
const void		*CLuaObject::toPointer() const   {  push(); const void    *result = _LuaState->toPointer();   _LuaState->pop(); return result; }
NLMISC::CRGBA CLuaObject::toRGBA() const
{
	NLMISC::CRGBA result;
	push();
	if (CLuaIHM::pop(*_LuaState, result))
	{
		return result;
	}
	return NLMISC::CRGBA::Black;
}

// *************************************************
CLuaObject::operator bool() const         { return toBoolean(); }
CLuaObject::operator float() const        { return (float) toNumber(); }
CLuaObject::operator double() const       { return (double) toNumber(); }
CLuaObject::operator std::string() const  { return toString(); }


// *************************************************
bool CLuaObject::isEnumerable() const
{
	if (isTable()) return true;
	CLuaStackRestorer lsr(_LuaState, _LuaState->getTop());
	push();
	if (_LuaState->getMetaTable(-1))
	{
		_LuaState->remove(-2);
		_LuaState->push("__next");
		_LuaState->getTable(-2);
		return _LuaState->isFunction();
	}
	return false;
}

// *************************************************
CLuaEnumeration CLuaObject::enumerate() throw(ELuaNotATable)
{
	if (!isEnumerable())
	{
		throw ELuaNotATable(NLMISC::toString("Called CLuaObject::enumerate on an object that has no enumeration (not a table or no '__next' method in the metatable). Object is '%s' with type '%s'", getId().c_str(), getTypename()).c_str());
	}
	return CLuaEnumeration(*this);
}

// *************************************************
CLuaObject CLuaObject::operator[](const char *key) const
{
	nlassert(key);
	nlassert(isValid());
	if (!isEnumerable())
	{
		_LuaState->pushNil();
		CLuaObject result(*_LuaState);
		return result;
	}
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->getTable(-2);
	CLuaObject subObject(*_LuaState, concatId(getId(), key));
	_LuaState->pop(); // pop the sub object
	return subObject;
}

// *************************************************
CLuaObject CLuaObject::operator[](double key) const
{
	nlassert(isValid());
	if (!isEnumerable())
	{
		_LuaState->pushNil();
		CLuaObject result(*_LuaState);
		return result;
	}
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->getTable(-2);
	CLuaObject subObject(*_LuaState, concatId(getId(), NLMISC::toString(key)));
	_LuaState->pop(); // pop the sub object
	return subObject;
}

// *************************************************
CLuaObject CLuaObject::at(const char *key) const throw(ELuaNotATable)
{
	if (!isEnumerable()) throw ELuaNotATable(NLMISC::toString("Can't get key '%s' in object '%s' because type is '%s', it is not a table.", key, getId().c_str(), getTypename()).c_str());
	return operator[](key);
}

// *************************************************
bool CLuaObject::hasKey(const char *key) const
{
	if (!isEnumerable()) throw ELuaNotATable(NLMISC::toString("Trying to access key '%s' on object '%s' of type %s.", key, getId().c_str(), getTypename()).c_str());
	CLuaObject value = operator[](key);
	return (!value.isNil());
}

// *************************************************
CLuaObject CLuaObject::newTable(const char *tableName) throw(ELuaNotATable)
{
	nlassert(tableName);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to create a subtable '%s' on object '%s' of type %s (not a table).", tableName, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(tableName);
	_LuaState->newTable();
	_LuaState->setTable(-3);
	_LuaState->pop();
	return at(tableName); //\TODO nico double copy here ...
}

// *************************************************
void CLuaObject::setValue(const char *key,  const CLuaObject &value) throw(ELuaNotATable)
{
	nlassert(key);
	nlassert(isValid());
	nlassert(value.isValid());
	nlassert(getLuaState() == value.getLuaState());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a value '%s' on object '%s' of type %s (not a table).", key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	value.push();
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::setNil(const char *key) throw(ELuaNotATable)
{
	nlassert(key);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a value 'nil' at key %s on object '%s' of type %s (not a table).", key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->pushNil();
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::setValue(const char *key,  const char *value) throw(ELuaNotATable)
{
	nlassert(value);
	nlassert(key);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a value '%s' at key %s on object '%s' of type %s (not a table).", value, key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->push(value);
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::setValue(const char *key,  const std::string &value) throw(ELuaNotATable)
{
	setValue(key, value.c_str());
}

// *************************************************
void CLuaObject::setValue(const char *key, bool value) throw(ELuaNotATable)
{
	nlassert(key);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a value '%s' at key %s on object '%s' of type %s (not a table).", value ? "true" : "false", key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->push(value);
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::setValue(const char *key, TLuaWrappedFunction value) throw(ELuaNotATable)
{
	nlassert(key);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a function value '%p' at key %s on object '%s' of type %s (not a table).", value, key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->push(value);
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::setValue(const char *key,  double value) throw(ELuaNotATable)
{
	nlassert(key);
	nlassert(isValid());
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a value '%lf' at key %s on object '%s' of type %s (not a table).", value, key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->push(value);
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
void CLuaObject::eraseValue(const char *key) throw(ELuaNotATable)
{
	nlassert(isValid());
	nlassert(key);
	if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to erase a value with key '%s' on object '%s' of type %s (not a table).", key, getId().c_str(), getTypename()));
	CLuaStackChecker lsc(_LuaState);
	push();
	_LuaState->push(key);
	_LuaState->pushNil();
	_LuaState->setTable(-3);
	_LuaState->pop();
}

// *************************************************
bool CLuaObject::callNoThrow(int numArgs, int numRet)
{
	nlassert(isValid());
	if (!isFunction())
	{
		nlwarning("Calling a non function object (id = %s, type = %s)", getId().c_str(), getTypename());
		_LuaState->pop(numArgs);
		return false;
	}
	// TMP TMP
	static volatile bool dumpFunction = false;
	if (dumpFunction)
	{
		CLuaStackRestorer lsr(_LuaState, _LuaState->getTop());
		push();
		lua_Debug ar;
		lua_getinfo (_LuaState->getStatePointer(), ">lS", &ar);
		nlwarning((std::string(ar.what) + ", at line " + NLMISC::toString(ar.linedefined) + " in " + std::string(ar.source)).c_str());
	}
	push();
	_LuaState->insert(-1 - numArgs); // put the function before its arguments
	int result = _LuaState->pcall(numArgs, numRet);
	switch (result)
	{
		case LUA_ERRRUN:
		case LUA_ERRMEM:
		case LUA_ERRERR:
			nlwarning(_LuaState->toString(-1));
			_LuaState->pop();
			return false;
		break;
		case 0:
			return true;
		break;
		default:
			nlassert(0);
		break;
	}
	return false;
}

// *************************************************
bool CLuaObject::callMethodByNameNoThrow(const char *name, int numArgs, int numRet)
{
	nlassert(isValid());
	int initialStackSize = _LuaState->getTop();
	if (!isTable() && !isUserData())
	{
		nlwarning("Can't call method : object is not a table (id = %s)", getId().c_str());
		_LuaState->setTop(std::max(0, initialStackSize - numArgs));
		return false;
	}
	CLuaObject method = (*this)[name];
	push();				  // the 'self' parameter
	_LuaState->insert(-1 - numArgs); // put 'self' before the arguments
	if (method.callNoThrow(numArgs + 1, numRet))
	{
		return true;
	}
	_LuaState->setTop(std::max(0, initialStackSize - numArgs));
	return false;
}

/////////////////////
// CLuaEnumeration //
/////////////////////

// *************************************************
CLuaEnumeration::CLuaEnumeration(CLuaObject &table)
{
	nlassert(table.isEnumerable());
	CLuaState *luaState = table.getLuaState();
	CLuaStackChecker lsc(luaState);
	// get pointer to the 'next' function
	luaState->pushValue(LUA_GLOBALSINDEX);
	_NextFunction = CLuaObject(*luaState)["next"];
	//
	nlassert(luaState);
	table.push();
	luaState->pushNil();
	_HasNext = false;
	if (_NextFunction.callNoThrow(2, 2))
	{
		_Value.pop(*luaState);
		_Key.pop(*luaState);
		_HasNext = !_Key.isNil();
		_Value.setId(CLuaObject::concatId(table.getId(), _Key.toString()));
		_Table = table;
	}

}

// *************************************************
const CLuaObject &CLuaEnumeration::nextKey() const
{
	nlassert(_HasNext);
	return _Key;
}

// *************************************************
CLuaObject &CLuaEnumeration::nextValue()
{
	nlassert(_HasNext);
	return _Value;
}

// *************************************************
CLuaObject CLuaObject::getMetaTable() const
{
	nlassert(isValid());
	CLuaStackChecker lsc(_LuaState);
	push();
	if (_LuaState->getMetaTable(-1))
	{
		_LuaState->remove(-2);
		return CLuaObject(*_LuaState);
	}
	_LuaState->pop();
	_LuaState->pushNil();
	return CLuaObject(*_LuaState);
}

// *************************************************
bool CLuaObject::setMetaTable(CLuaObject &metatable)
{
	nlassert(isValid());
	nlassert(metatable.isValid());
	nlassert(this->getLuaState() == metatable.getLuaState());
	CLuaStackChecker lsc(_LuaState);
	push();
	metatable.push();
	bool ok = _LuaState->setMetaTable(-2);
	_LuaState->pop(1);
	return ok;
}

// *************************************************
std::string CLuaObject::toStringRecurse(uint depth /*=0*/, uint maxDepth /*= 20*/,  std::set<const void *> *alreadySeen /*= NULL */) const
{
	if (maxDepth != 0 && depth > maxDepth) return "";
	const uint INDENT_NUM_BLANK = 2;
	std::string indentStr(depth * INDENT_NUM_BLANK, ' ');
	nlassert(_LuaState);
	if (isEnumerable()) // is enumeration possible on that object ?
	{
		std::string result;
		if (alreadySeen)
		{
			if (alreadySeen->count(toPointer())) // avoid cyclic graph (infinite recursion else)
			{
				result += indentStr +"<cycle>";
				return result;
			}
			alreadySeen->insert(toPointer());
		}
		result += indentStr + "{\n";
		CLuaObject *table = const_cast<CLuaObject *>(this);
		uint numElem = 0;
		ENUM_LUA_TABLE(*table, it)
		{
			//nlwarning("entering table %s", it.nextKey().toString().c_str());
			result += std::string((depth + 1) * INDENT_NUM_BLANK, ' ') + it.nextKey().toString() + " = ";
			if (it.nextValue().isEnumerable())
			{
				result += "\n" + it.nextValue().toStringRecurse(depth + 1, maxDepth, alreadySeen);
			}
			else
			{
				result += it.nextValue().toStringRecurse();
			}
			result += ",\n";
			++ numElem;
			if (numElem > 4000)
			{
				throw NLMISC::Exception("possible infinite loop, aborting enumeration");
			}
		}
		result += indentStr + "}";
		return result;
	}
	else if (isNil())
	{
		return (indentStr + "nil").c_str();
	}
	else if (isString())
	{
		return (indentStr + "\"" + toString() + "\"").c_str();
	}
	else if (isFunction())
	{
		return (indentStr + "<function>").c_str();
	}
	else
	{
		return ((indentStr + toString()).c_str());
	}
}

// *************************************************
void CLuaObject::dump(uint maxDepth /*= 20*/, std::set<const void *> *alreadySeen /*= NULL */) const
{
	try
	{
		std::string str = toStringRecurse(0, maxDepth, alreadySeen);
		std::vector<std::string> res;
		NLMISC::explode(str, std::string("\n"), res);
		for(uint k = 0; k < res.size(); ++k)
		{
			NLMISC::InfoLog->forceDisplayRaw((res[k] + "\n") .c_str());
		}
	}
	catch(const std::exception &e)
	{
		//CLuaIHMRyzom::dumpCallStack();
		nlwarning(e.what());
	}
}

// *************************************************
std::string CLuaObject::concatId(const std::string &left,const std::string &right)
{
	if (!right.empty() && isdigit(right[0]))
	{
		if (left.empty()) return "[" + right + "]";
		return left + "[" + right + "]";
	}
	if (left.empty()) return right;
	return left + "." + right;

}

// *************************************************
void CLuaEnumeration::next()
{
	nlassert(_HasNext);
	CLuaState *luaState = _Table.getLuaState();
	nlassert(luaState);
	CLuaStackChecker lsc(luaState);
	_Table.push();
	_Key.push();
	_HasNext = false;
	if (_NextFunction.callNoThrow(2, 2))
	{
		_Value.pop(*luaState);
		_Key.pop(*luaState);
		_HasNext = !_Key.isNil();
		_Value.setId(_Table.getId() + "." + _Key.toString());
	}
}