StarMirror/sol2
1
0
Fork 0
mirror of https://github.com/ThePhD/sol2.git synced 2024-03-22 13:10:44 +08:00
Code Issues Projects Releases Wiki Activity

Fix leak issues and some ordering in state(view) move operations. Closes #336.

Browse Source
This commit is contained in:
ThePhD 2017-02-15 05:42:44 -05:00
parent fe8b1c1c10
commit 85194e0135
7 changed files with 1279 additions and 1183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -71,3 +71,4 @@ LuaJIT-2.1.0/
lua-5.3.3-cxx/
lua-5.3.3.vcxproj-cxx.filters
sol.pyproj
lua-5.3.3.dll

79
single/sol/sol.hpp
View File

@ -20,8 +20,8 @@
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// This file was generated with a script.
// Generated 2017-02-01 11:49:07.483904 UTC
// This header was generated with sol v2.15.7 (revision 8d6f304)
// Generated 2017-02-15 10:41:27.152230 UTC
// This header was generated with sol v2.15.7 (revision fe8b1c1)
// https://github.com/ThePhD/sol2
#ifndef SOL_SINGLE_INCLUDE_HPP
@ -3953,6 +3953,9 @@ namespace sol {
}
reference& operator=(reference&& o) noexcept {
if (valid()) {
deref();
}
luastate = o.luastate;
ref = o.ref;
@ -4610,7 +4613,39 @@ namespace sol {
namespace sol {
namespace detail {
#ifdef _MSC_VER
#if defined(__GNUC__) || defined(__clang__)
template <typename T, class seperator_mark = int>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
std::string name = __PRETTY_FUNCTION__;
std::size_t start = name.find_first_of('[');
start = name.find_first_of('=', start);
std::size_t end = name.find_last_of(']');
if (end == std::string::npos)
end = name.size();
if (start == std::string::npos)
start = 0;
if (start < name.size() - 1)
start += 1;
name = name.substr(start, end - start);
start = name.rfind("seperator_mark");
if (start != std::string::npos) {
name.erase(start - 2, name.length());
}
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#elif defined(_MSC_VER)
template <typename T>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 7> removals = { { "public:", "private:", "protected:", "struct ", "class ", "`anonymous-namespace'", "`anonymous namespace'" } };
@ -4641,38 +4676,6 @@ namespace sol {
}
}
return name;
}
#elif defined(__GNUC__) || defined(__clang__)
template <typename T, class seperator_mark = int>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
std::string name = __PRETTY_FUNCTION__;
std::size_t start = name.find_first_of('[');
start = name.find_first_of('=', start);
std::size_t end = name.find_last_of(']');
if (end == std::string::npos)
end = name.size();
if (start == std::string::npos)
start = 0;
if (start < name.size() - 1)
start += 1;
name = name.substr(start, end - start);
start = name.rfind("seperator_mark");
if (start != std::string::npos) {
name.erase(start - 2, name.length());
}
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#else
@ -12885,7 +12888,11 @@ namespace sol {
state(const state&) = delete;
state(state&&) = default;
state& operator=(const state&) = delete;
state& operator=(state&&) = default;
state& operator=(state&& that) {
state_view::operator=(std::move(that));
unique_base::operator=(std::move(that));
return *this;
}
using state_view::get;

316
sol/demangle.hpp
View File

@ -1,158 +1,158 @@
// The MIT License (MIT)
// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_DEMANGLE_HPP
#define SOL_DEMANGLE_HPP
#include <string>
#include <array>
#include <cctype>
namespace sol {
namespace detail {
#ifdef _MSC_VER
template <typename T>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 7> removals = { { "public:", "private:", "protected:", "struct ", "class ", "`anonymous-namespace'", "`anonymous namespace'" } };
std::string name = __FUNCSIG__;
std::size_t start = name.find("get_type_name");
if (start == std::string::npos)
start = 0;
else
start += 13;
if (start < name.size() - 1)
start += 1;
std::size_t end = name.find_last_of('>');
if (end == std::string::npos)
end = name.size();
name = name.substr(start, end - start);
if (name.find("struct", 0) == 0)
name.replace(0, 6, "", 0);
if (name.find("class", 0) == 0)
name.replace(0, 5, "", 0);
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#elif defined(__GNUC__) || defined(__clang__)
template <typename T, class seperator_mark = int>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
std::string name = __PRETTY_FUNCTION__;
std::size_t start = name.find_first_of('[');
start = name.find_first_of('=', start);
std::size_t end = name.find_last_of(']');
if (end == std::string::npos)
end = name.size();
if (start == std::string::npos)
start = 0;
if (start < name.size() - 1)
start += 1;
name = name.substr(start, end - start);
start = name.rfind("seperator_mark");
if (start != std::string::npos) {
name.erase(start - 2, name.length());
}
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#else
#error Compiler not supported for demangling
#endif // compilers
template <typename T>
inline std::string demangle_once() {
std::string realname = ctti_get_type_name<T>();
return realname;
}
template <typename T>
inline std::string short_demangle_once() {
std::string realname = ctti_get_type_name<T>();
// This isn't the most complete but it'll do for now...?
static const std::array<std::string, 10> ops = { { "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" } };
int level = 0;
std::ptrdiff_t idx = 0;
for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
if (level == 0 && realname[idx] == ':') {
break;
}
bool isleft = realname[idx] == '<';
bool isright = realname[idx] == '>';
if (!isleft && !isright)
continue;
bool earlybreak = false;
for (const auto& op : ops) {
std::size_t nisop = realname.rfind(op, idx);
if (nisop == std::string::npos)
continue;
std::size_t nisopidx = idx - op.size() + 1;
if (nisop == nisopidx) {
idx = static_cast<std::ptrdiff_t>(nisopidx);
earlybreak = true;
}
break;
}
if (earlybreak) {
continue;
}
level += isleft ? -1 : 1;
}
if (idx > 0) {
realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
}
return realname;
}
template <typename T>
inline const std::string& demangle() {
static const std::string d = demangle_once<T>();
return d;
}
template <typename T>
inline const std::string& short_demangle() {
static const std::string d = short_demangle_once<T>();
return d;
}
} // detail
} // sol
#endif // SOL_DEMANGLE_HPP
// The MIT License (MIT)
// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_DEMANGLE_HPP
#define SOL_DEMANGLE_HPP
#include <string>
#include <array>
#include <cctype>
namespace sol {
namespace detail {
#if defined(__GNUC__) || defined(__clang__)
template <typename T, class seperator_mark = int>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
std::string name = __PRETTY_FUNCTION__;
std::size_t start = name.find_first_of('[');
start = name.find_first_of('=', start);
std::size_t end = name.find_last_of(']');
if (end == std::string::npos)
end = name.size();
if (start == std::string::npos)
start = 0;
if (start < name.size() - 1)
start += 1;
name = name.substr(start, end - start);
start = name.rfind("seperator_mark");
if (start != std::string::npos) {
name.erase(start - 2, name.length());
}
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#elif defined(_MSC_VER)
template <typename T>
inline std::string ctti_get_type_name() {
const static std::array<std::string, 7> removals = { { "public:", "private:", "protected:", "struct ", "class ", "`anonymous-namespace'", "`anonymous namespace'" } };
std::string name = __FUNCSIG__;
std::size_t start = name.find("get_type_name");
if (start == std::string::npos)
start = 0;
else
start += 13;
if (start < name.size() - 1)
start += 1;
std::size_t end = name.find_last_of('>');
if (end == std::string::npos)
end = name.size();
name = name.substr(start, end - start);
if (name.find("struct", 0) == 0)
name.replace(0, 6, "", 0);
if (name.find("class", 0) == 0)
name.replace(0, 5, "", 0);
while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
while (!name.empty() && std::isblank(name.back())) name.pop_back();
for (std::size_t r = 0; r < removals.size(); ++r) {
auto found = name.find(removals[r]);
while (found != std::string::npos) {
name.erase(found, removals[r].size());
found = name.find(removals[r]);
}
}
return name;
}
#else
#error Compiler not supported for demangling
#endif // compilers
template <typename T>
inline std::string demangle_once() {
std::string realname = ctti_get_type_name<T>();
return realname;
}
template <typename T>
inline std::string short_demangle_once() {
std::string realname = ctti_get_type_name<T>();
// This isn't the most complete but it'll do for now...?
static const std::array<std::string, 10> ops = { { "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" } };
int level = 0;
std::ptrdiff_t idx = 0;
for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
if (level == 0 && realname[idx] == ':') {
break;
}
bool isleft = realname[idx] == '<';
bool isright = realname[idx] == '>';
if (!isleft && !isright)
continue;
bool earlybreak = false;
for (const auto& op : ops) {
std::size_t nisop = realname.rfind(op, idx);
if (nisop == std::string::npos)
continue;
std::size_t nisopidx = idx - op.size() + 1;
if (nisop == nisopidx) {
idx = static_cast<std::ptrdiff_t>(nisopidx);
earlybreak = true;
}
break;
}
if (earlybreak) {
continue;
}
level += isleft ? -1 : 1;
}
if (idx > 0) {
realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
}
return realname;
}
template <typename T>
inline const std::string& demangle() {
static const std::string d = demangle_once<T>();
return d;
}
template <typename T>
inline const std::string& short_demangle() {
static const std::string d = short_demangle_once<T>();
return d;
}
} // detail
} // sol
#endif // SOL_DEMANGLE_HPP

385
sol/reference.hpp
View File

@ -1,191 +1,194 @@
// The MIT License (MIT)
// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_REFERENCE_HPP
#define SOL_REFERENCE_HPP
#include "types.hpp"
#include "stack_reference.hpp"
namespace sol {
namespace stack {
template <bool top_level>
struct push_popper_n {
lua_State* L;
int t;
push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) { }
~push_popper_n() { lua_pop(L, t); }
};
template <>
struct push_popper_n<true> {
push_popper_n(lua_State*, int) { }
};
template <bool top_level, typename T>
struct push_popper {
T t;
push_popper(T x) : t(x) { t.push(); }
~push_popper() { t.pop(); }
};
template <typename T>
struct push_popper<true, T> {
push_popper(T) {}
~push_popper() {}
};
template <bool top_level = false, typename T>
push_popper<top_level, T> push_pop(T&& x) {
return push_popper<top_level, T>(std::forward<T>(x));
}
template <bool top_level = false>
push_popper_n<top_level> pop_n(lua_State* L, int x) {
return push_popper_n<top_level>(L, x);
}
} // stack
namespace detail {
struct global_tag { } const global_{};
} // detail
class reference {
private:
lua_State* luastate = nullptr; // non-owning
int ref = LUA_NOREF;
int copy() const noexcept {
if (ref == LUA_NOREF)
return LUA_NOREF;
push();
return luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
protected:
reference(lua_State* L, detail::global_tag) noexcept : luastate(L) {
lua_pushglobaltable(lua_state());
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
int stack_index() const noexcept {
return -1;
}
void deref() const noexcept {
luaL_unref(lua_state(), LUA_REGISTRYINDEX, ref);
}
public:
reference() noexcept = default;
reference(lua_nil_t) noexcept : reference() {}
reference(const stack_reference& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
reference(stack_reference&& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
reference(lua_State* L, int index = -1) noexcept : luastate(L) {
lua_pushvalue(lua_state(), index);
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
reference(lua_State* L, ref_index index) noexcept : luastate(L) {
lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
~reference() noexcept {
deref();
}
reference(reference&& o) noexcept {
luastate = o.luastate;
ref = o.ref;
o.luastate = nullptr;
o.ref = LUA_NOREF;
}
reference& operator=(reference&& o) noexcept {
luastate = o.luastate;
ref = o.ref;
o.luastate = nullptr;
o.ref = LUA_NOREF;
return *this;
}
reference(const reference& o) noexcept {
luastate = o.luastate;
ref = o.copy();
}
reference& operator=(const reference& o) noexcept {
luastate = o.luastate;
deref();
ref = o.copy();
return *this;
}
int push() const noexcept {
return push(lua_state());
}
int push(lua_State* Ls) const noexcept {
lua_rawgeti(Ls, LUA_REGISTRYINDEX, ref);
return 1;
}
void pop() const noexcept {
pop(lua_state());
}
void pop(lua_State* Ls, int n = 1) const noexcept {
lua_pop(Ls, n);
}
int registry_index() const noexcept {
return ref;
}
bool valid() const noexcept {
return !(ref == LUA_NOREF || ref == LUA_REFNIL);
}
explicit operator bool() const noexcept {
return valid();
}
type get_type() const noexcept {
auto pp = stack::push_pop(*this);
int result = lua_type(lua_state(), -1);
return static_cast<type>(result);
}
lua_State* lua_state() const noexcept {
return luastate;
}
};
inline bool operator== (const reference& l, const reference& r) {
auto ppl = stack::push_pop(l);
auto ppr = stack::push_pop(r);
return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
}
inline bool operator!= (const reference& l, const reference& r) {
return !operator==(l, r);
}
} // sol
#endif // SOL_REFERENCE_HPP
// The MIT License (MIT)
// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_REFERENCE_HPP
#define SOL_REFERENCE_HPP
#include "types.hpp"
#include "stack_reference.hpp"
namespace sol {
namespace stack {
template <bool top_level>
struct push_popper_n {
lua_State* L;
int t;
push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) { }
~push_popper_n() { lua_pop(L, t); }
};
template <>
struct push_popper_n<true> {
push_popper_n(lua_State*, int) { }
};
template <bool top_level, typename T>
struct push_popper {
T t;
push_popper(T x) : t(x) { t.push(); }
~push_popper() { t.pop(); }
};
template <typename T>
struct push_popper<true, T> {
push_popper(T) {}
~push_popper() {}
};
template <bool top_level = false, typename T>
push_popper<top_level, T> push_pop(T&& x) {
return push_popper<top_level, T>(std::forward<T>(x));
}
template <bool top_level = false>
push_popper_n<top_level> pop_n(lua_State* L, int x) {
return push_popper_n<top_level>(L, x);
}
} // stack
namespace detail {
struct global_tag { } const global_{};
} // detail
class reference {
private:
lua_State* luastate = nullptr; // non-owning
int ref = LUA_NOREF;
int copy() const noexcept {
if (ref == LUA_NOREF)
return LUA_NOREF;
push();
return luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
protected:
reference(lua_State* L, detail::global_tag) noexcept : luastate(L) {
lua_pushglobaltable(lua_state());
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
int stack_index() const noexcept {
return -1;
}
void deref() const noexcept {
luaL_unref(lua_state(), LUA_REGISTRYINDEX, ref);
}
public:
reference() noexcept = default;
reference(lua_nil_t) noexcept : reference() {}
reference(const stack_reference& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
reference(stack_reference&& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
reference(lua_State* L, int index = -1) noexcept : luastate(L) {
lua_pushvalue(lua_state(), index);
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
reference(lua_State* L, ref_index index) noexcept : luastate(L) {
lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
}
~reference() noexcept {
deref();
}
reference(reference&& o) noexcept {
luastate = o.luastate;
ref = o.ref;
o.luastate = nullptr;
o.ref = LUA_NOREF;
}
reference& operator=(reference&& o) noexcept {
if (valid()) {
deref();
}
luastate = o.luastate;
ref = o.ref;
o.luastate = nullptr;
o.ref = LUA_NOREF;
return *this;
}
reference(const reference& o) noexcept {
luastate = o.luastate;
ref = o.copy();
}
reference& operator=(const reference& o) noexcept {
luastate = o.luastate;
deref();
ref = o.copy();
return *this;
}
int push() const noexcept {
return push(lua_state());
}
int push(lua_State* Ls) const noexcept {
lua_rawgeti(Ls, LUA_REGISTRYINDEX, ref);
return 1;
}
void pop() const noexcept {
pop(lua_state());
}
void pop(lua_State* Ls, int n = 1) const noexcept {
lua_pop(Ls, n);
}
int registry_index() const noexcept {
return ref;
}
bool valid() const noexcept {
return !(ref == LUA_NOREF || ref == LUA_REFNIL);
}
explicit operator bool() const noexcept {
return valid();
}
type get_type() const noexcept {
auto pp = stack::push_pop(*this);
int result = lua_type(lua_state(), -1);
return static_cast<type>(result);
}
lua_State* lua_state() const noexcept {
return luastate;
}
};
inline bool operator== (const reference& l, const reference& r) {
auto ppl = stack::push_pop(l);
auto ppr = stack::push_pop(r);
return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
}
inline bool operator!= (const reference& l, const reference& r) {
return !operator==(l, r);
}
} // sol
#endif // SOL_REFERENCE_HPP

6
sol/state.hpp
View File

@ -78,7 +78,11 @@ namespace sol {
state(const state&) = delete;
state(state&&) = default;
state& operator=(const state&) = delete;
state& operator=(state&&) = default;
state& operator=(state&& that) {
state_view::operator=(std::move(that));
unique_base::operator=(std::move(that));
return *this;
}
using state_view::get;

7
test_usertypes.cpp
View File

@ -1246,10 +1246,10 @@ TEST_CASE("usertype/shared-ptr-regression", "usertype metatables should not scre
REQUIRE(destroyed == 1);
}
TEST_CASE("usertype/double-deleter-guards", "usertype metatables internally must not rely on internal ") {
TEST_CASE("usertype/double-deleter-guards", "usertype metatables internally must not rely on C++ state") {
struct c_a { int x; };
struct c_b { int y; };
REQUIRE_NOTHROW( {
auto routine = []() {
sol::state lua;
lua.new_usertype<c_a>("c_a", "x", &c_a::x);
lua.new_usertype<c_b>("c_b", "y", &c_b::y);
@ -1257,7 +1257,8 @@ TEST_CASE("usertype/double-deleter-guards", "usertype metatables internally must
lua.new_usertype<c_a>("c_a", "x", &c_a::x);
lua.new_usertype<c_b>("c_b", "y", &c_b::y);
lua = sol::state();
});
};
REQUIRE_NOTHROW(routine());
}
TEST_CASE("usertype/vars", "usertype vars can bind various class items") {

1668
tests.cpp
View File

File diff suppressed because it is too large Load Diff