C++ LuaState类代码示例

void outputFunc(std::string file, std::string func, const std::string& str, std::vector<any> args)
{
    LuaState ls;
    openUtilExtendLibs(ls.getState());

    int err = ls.parseFile(file);
    if (0 != err)
    {
        printLine(luaGetError(ls.getState(), err));
        return;
    }

    luaGetGlobal(ls.getState(), func);

    luaPushString(ls.getState(), str);
    for (size_t i=0; i<args.size(); ++i)
        luaPushAny(ls.getState(), args[i]);

    err = luaCallFunc(ls.getState(), 1 + args.size() , 0);
    if (0 != err)
    {
        printLine(luaGetError(ls.getState(), err));
        return;
    }

    luaPop(ls.getState(), -1);
}

void CCallStackDlg::Update()
{
	m_list.DeleteAllItems();

	LuaState* state = theApp.GetDocument()->GetState();

	LuaObject callStackTableObj = state->GetGlobals()[ "CallStack" ];
	if (callStackTableObj.IsTable())
	{
		int index = 1;
		while (true)
		{
			LuaObject callTableObj = callStackTableObj.GetByIndex(index++);
			if (callTableObj.IsNil())
				break;
			LuaObject nameObj = callTableObj.GetByIndex(1);
			LuaObject typeObj = callTableObj.GetByIndex(2);
			LuaObject lineNumberObj = callTableObj.GetByIndex(3);

			CString str;
			if (lineNumberObj.GetInteger() != -1)
				str.Format(_T(" line %d"), lineNumberObj.GetInteger());
			str = nameObj.GetString() + str + _T(" (") + typeObj.GetString() + _T(")");
			m_list.InsertItem(m_list.GetItemCount(), str);
		}
	}
}

		void LuaTable::toLua(LuaState& lua) const {
			lua.createTable(intKeys.size(), stringKeys.size());

			std::for_each(std::begin(intKeys), std::end(intKeys),
				[&](std::pair<const int, unsigned> intKey)->void {

				lua.pushStack(intKey.first);

				pushAnyValue(lua, types[intKey.second], values[intKey.second]);

				lua.setTable();

			});

			std::for_each(std::begin(stringKeys), std::end(stringKeys),
				[&](std::pair<const std::string, unsigned> stringKey)->void {

				lua.pushStack(stringKey.first);

				pushAnyValue(lua, types[stringKey.second], values[stringKey.second]);

				lua.setTable();

			});

		}

		void LuaTable::fromLua(LuaState& lua) {
			
			std::for_each(std::begin(intKeys), std::end(intKeys),
				[&](std::pair<const int, unsigned> intKey)->void {

				int x = 0;

				lua.getTable(intKey.first);

				pullAnyValue(lua, types[intKey.second], values[intKey.second]);

				lua.popStack();

			});

			std::for_each(std::begin(stringKeys), std::end(stringKeys),
				[&](std::pair<const std::string, unsigned> stringKey)->void {

				lua.getTable(stringKey.first);

				pullAnyValue(lua, types[stringKey.second], values[stringKey.second]);

				lua.popStack();

			});

		}

/*static*/ LuaState* LuaState::Create(bool initStandardLibrary)
{
	LuaState* state = LuaState::Create();
	if (initStandardLibrary)
		state->OpenLibs();
	return state;
}

/**
	Go to the next entry in the table.

	\return Returns true if the iteration is done.
**/
bool LuaStackTableIterator::Next()
{
	// This function is only active if Reset() has been called head.
	luaplus_assert( IsValid() );

	// This is a local helper variable so we don't waste space in the class
	// definition.
	LuaState* state = m_tableObj.GetState();

	// Do any stack management operations.
	if ( m_autoStackManagement )
	{
		state->SetTop( m_startStackIndex + 1 );
	}
	else
	{
		// If this luaplus_assert fires, then you left something on the stack.
		luaplus_assert( state->GetTop() == m_startStackIndex + 1 );
	}

	// Do the Lua table iteration.
	if ( state->Next( m_tableObj ) == 0 )
	{
		// Invalidate the iterator.
		m_startStackIndex = -1;
		return false;
	}

	// The iterator is still valid.
	return true;
}

int LuaState::LuaError(lua_State* luaState)
{
	LuaState* wrapper = LuaState::GetWrapper(luaState);
	assert(wrapper);
	wrapper->OnError();
	return 0;
}

/*static*/ LuaState* LuaState::CreateMT(bool initStandardLibrary)
{
	lua_Alloc reallocFunc;
	void* data;
	lua_getdefaultallocfunction(&reallocFunc, &data);
	LuaState* state = (LuaState*)(*reallocFunc)(data, NULL, 0, sizeof(LuaState), "LuaState", 0);
	::new(state) LuaState(true);
	state->OpenLibs();
	return state;
}

int main(int argc, char** argv)
{
	LuaState* pstate = LuaState::Create(true);	

	pstate->GetGlobals().Register("TestFunc", TestFunc);	

	const char* szCmd = "TestFunc('hahhahhahh');";
	pstate->DoString(szCmd);

	LuaState::Destroy(pstate);
	return 0;
}

LuaState* LuaState::luaForThread( sys::Thread& thread, unsigned int id, const char* init )
{
    sys::LockEnterLeave lock( s_lock );
    
    //
    //  create new lua state for new thread
    //  
    LuaState* lua = Leda::instance()->newLua();
    lua->load( id, false, init );
    thread.setData( lua ); 
    
    return lua;
}

	/*bool TileType::loadFromDef(JsonValue value)
	{
		if (value.has("fullName", JV_STR))
		{
			mFullName = value["fullName"].getCStr();
		}
		return true;
	}*/
	bool TileType::loadFromDef(LuaState &lua)
	{
		if (!lua_istable(lua, -1))
		{
			return false;
		}
		if (lua.isTableString("fullName"))
		{
			mFullName = lua_tostring(lua, -1);
			lua.pop(1);
		}
		return true;
	}

	bool TestLuaTileSet::testSimple() {
		LuaState lua;
		
		assert(lua.loadString("TileSet = import(\"TileSet\")\n"
			"set = TileSet.new(\"testTileSet\")\n"
			"function getName()\n"
			"	return set:name()\n"
			"end\n"
			"function getFullName()\n"
			"	return set:full_name()\n"
			"end\n"
			"function setFullName(name)\n"
			"	set:full_name(name)\n"
			"end\n"
			));

		assert(lua.hasGlobalFunction("getName"));
		lua_acall(lua, 0, 1);
		am_equalsStr("testTileSet", lua_tostring(lua, -1));
		lua.pop(1);

		assert(lua.hasGlobalFunction("setFullName"));
		lua.push("New Full Name");
		lua_acall(lua, 1, 0);
		
		assert(lua.hasGlobalFunction("getFullName"));
		lua_acall(lua, 0, 1);
		am_equalsStr("New Full Name", lua_tostring(lua, -1));
		lua.pop(1);

		return true;
	}

void LuaPlusGCFunction(void* s)
{
	GCState* st = (GCState*)s;
	LuaState* state = (LuaState*)lua_getstateuserdata(st->L);
	if (!state)
		return;

	LuaObject* curObj = state->GetHeadObject()->m_next;
	while (curObj != state->GetTailObject())
	{
		markobject(st, &curObj->m_object);
		curObj = curObj->m_next;		
	}
}

/**
	Start iteration at the beginning of the table.
**/
void LuaStackTableIterator::Reset()
{
	// Start afresh...
	LuaState* state = m_tableObj.GetState();
	m_startStackIndex = state->GetTop();

	// Push the head stack entry.
	state->PushNil();

	// Start the iteration.  If the return value is 0, then the iterator
	// will be invalid.
	if ( state->Next( m_tableObj ) == 0 )
		m_startStackIndex = -1;
}

extern "C" LUAMODULE_API int luaopen_bit(lua_State* L)
{
	LuaState* state = LuaState::CastState(L);
	LuaObject obj = state->GetGlobals().CreateTable( "bit" );
	obj.Register("bnot", int_bnot);
	obj.Register("band", int_band);
	obj.Register("bor", int_bor);
	obj.Register("bxor", int_bxor);
	obj.Register("lshift", int_lshift);
	obj.Register("rshift", int_rshift);
	obj.Register("arshift", int_arshift);
	obj.Register("mod", int_mod);
	obj.Register("help", LS_help);
	return 0;
}