mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-27 17:46:18 +00:00
422 lines
12 KiB
C++
422 lines
12 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/>.
|
|
|
|
#ifndef RZ_INCLUDE_LUA_HELPER_INLINE
|
|
#error "don't include directly, include lua_helper.h instead"
|
|
#endif
|
|
|
|
|
|
/////////////////////
|
|
// CLuaStackChecker //
|
|
//////////////////////
|
|
|
|
//================================================================================
|
|
inline CLuaStackChecker::CLuaStackChecker(CLuaState *state, int numWantedResults)
|
|
{
|
|
nlassert(state);
|
|
_State = state;
|
|
_FinalWantedSize = state->getTop() + numWantedResults;
|
|
}
|
|
|
|
|
|
///////////////
|
|
// CLuaState //
|
|
///////////////
|
|
|
|
//================================================================================
|
|
inline void CLuaState::checkIndex(int index)
|
|
{
|
|
// NB : more restrictive test that in the documentation there, because
|
|
// we don't expose the check stack function
|
|
nlassert( (index!=0 && abs(index) <= getTop())
|
|
|| index == LUA_REGISTRYINDEX
|
|
|| index == LUA_GLOBALSINDEX
|
|
);
|
|
}
|
|
|
|
//================================================================================
|
|
inline int CLuaState::getTop()
|
|
{
|
|
return lua_gettop(_State);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::setTop(int index)
|
|
{
|
|
// if index is strictly negative, this is a "pop". ensure that the user don't pop more than allowed
|
|
if (index < 0)
|
|
{
|
|
checkIndex(index);
|
|
}
|
|
// if index is positive and is more than the current top
|
|
else if ( index>getTop() )
|
|
{
|
|
// must ensure that we have enough stack space
|
|
nlverify( lua_checkstack(_State, index-getTop()) );
|
|
}
|
|
|
|
// set top
|
|
lua_settop(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::pushValue(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_pushvalue(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::remove(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_remove(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::insert(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_insert(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::replace(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_replace(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::pop(int numElem /* = 1 */)
|
|
{
|
|
nlassert(numElem <= getTop());
|
|
lua_pop(_State, numElem);
|
|
}
|
|
|
|
//================================================================================
|
|
inline int CLuaState::type(int index /* = -1 */)
|
|
{
|
|
checkIndex(index);
|
|
return lua_type(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline const char *CLuaState::getTypename(int type)
|
|
{
|
|
return lua_typename(_State, type);
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isNil(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isnil(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isBoolean(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isboolean(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isNumber(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isnumber(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isString(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isstring(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isTable(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_istable(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isFunction(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isfunction(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isCFunction(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_iscfunction(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isUserData(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_isuserdata(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::isLightUserData(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_islightuserdata(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::toBoolean(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_toboolean(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline lua_Number CLuaState::toNumber(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_tonumber(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline const char *CLuaState::toString(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_tostring(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::toString(int index, std::string &str)
|
|
{
|
|
checkIndex(index);
|
|
const char *pc= lua_tostring(_State, index);
|
|
if(pc)
|
|
str= pc;
|
|
else
|
|
str.clear();
|
|
}
|
|
|
|
//================================================================================
|
|
inline size_t CLuaState::strlen(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_strlen(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline lua_CFunction CLuaState::toCFunction(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_tocfunction(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void *CLuaState::toUserData(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_touserdata(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline const void *CLuaState::toPointer(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_topointer(_State, index);
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(bool value)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushboolean(_State, (int) value);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(lua_Number value)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushnumber(_State, value);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(const char *str)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushstring(_State, str);
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(const char *str, int length)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushlstring(_State, str, length);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(const std::string &str)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
push(str.c_str());
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::pushNil()
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushnil(_State);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::push(lua_CFunction f)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushcfunction(_State, f);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::pushLightUserData(void *ptr)
|
|
{
|
|
nlverify( lua_checkstack(_State, 1) );
|
|
lua_pushlightuserdata(_State, ptr);
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::equal(int index1, int index2)
|
|
{
|
|
checkIndex(index1);
|
|
checkIndex(index2);
|
|
return lua_equal(_State, index1, index2) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::getMetaTable(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_getmetatable(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::setMetaTable(int index)
|
|
{
|
|
checkIndex(index);
|
|
return lua_setmetatable(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::rawEqual(int index1, int index2)
|
|
{
|
|
checkIndex(index1);
|
|
checkIndex(index2);
|
|
return lua_rawequal(_State, index1, index2) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::lessThan(int index1, int index2)
|
|
{
|
|
checkIndex(index1);
|
|
checkIndex(index2);
|
|
return lua_lessthan(_State, index1, index2) != 0;
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
inline void CLuaState::concat(int numElem)
|
|
{
|
|
nlassert(numElem <= getTop());
|
|
lua_concat(_State, numElem);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::getTable(int index)
|
|
{
|
|
checkIndex(index);
|
|
nlassert(isTable(index) || isUserData(index));
|
|
lua_gettable(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::rawGet(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_rawget(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::setTable(int index)
|
|
{
|
|
checkIndex(index);
|
|
nlassert(getTop() >= 2);
|
|
nlassert(isTable(index));
|
|
lua_settable(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::rawSet(int index)
|
|
{
|
|
checkIndex(index);
|
|
lua_rawset(_State, index);
|
|
}
|
|
|
|
//================================================================================
|
|
inline bool CLuaState::next(int index)
|
|
{
|
|
//H_AUTO(Lua_CLuaState_next)
|
|
checkIndex(index);
|
|
return lua_next(_State, index) != 0;
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::rawSetI(int index, int n)
|
|
{
|
|
//H_AUTO(Lua_CLuaState_rawSetI)
|
|
checkIndex(index);
|
|
lua_rawseti(_State, index, n);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::rawGetI(int index, int n)
|
|
{
|
|
checkIndex(index);
|
|
lua_rawgeti(_State, index, n);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void CLuaState::call(int nargs, int nresults)
|
|
{
|
|
nlassert(getTop() >= nargs);
|
|
lua_call(_State, nargs, nresults);
|
|
}
|
|
|
|
//================================================================================
|
|
inline int CLuaState::pcall(int nargs, int nresults, int errfunc)
|
|
{
|
|
return lua_pcall(_State, nargs, nresults, errfunc);
|
|
}
|
|
|
|
//================================================================================
|
|
inline void *CLuaState::newUserData(uint size)
|
|
{
|
|
nlassert(size>0);
|
|
return lua_newuserdata(_State, size);
|
|
}
|