mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-24 16:16:14 +00:00
651 lines
20 KiB
C++
651 lines
20 KiB
C++
// 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 "nel/gui/lua_object.h"
|
|
#include "nel/gui/lua_ihm.h"
|
|
#include "nel/gui/lua_helper.h"
|
|
|
|
namespace NLGUI
|
|
{
|
|
|
|
// *************************************************
|
|
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());
|
|
}
|
|
}
|
|
|
|
}
|