thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-10-30 22:07:18 +01:00
Code Releases Activity

Remove traces of noexcept from the binding library. This would've impaired the exception handling required by the binding system and cause a program termination for even the slightest error that occured from the script.

Browse Source
This commit is contained in:
Sandu Liviu Catalin
2018-10-23 21:29:28 +03:00
parent 52611bdb80
commit 464821592c
6 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
include/sqrat/sqratFunction.h
View File

@@ -50,17 +50,17 @@ struct Function {
HSQOBJECT mEnv, mObj;
// Default constructor (null)
Function() noexcept {
Function() {
sq_resetobject(&mEnv);
sq_resetobject(&mObj);
}
// Copy constructor
Function(const Function& sf) noexcept : mEnv(sf.mEnv), mObj(sf.mObj) {
Function(const Function& sf) : mEnv(sf.mEnv), mObj(sf.mObj) {
sq_addref(DefaultVM::Get_(), &mEnv);
sq_addref(DefaultVM::Get_(), &mObj);
}
// Move constructor
Function(Function&& sf) noexcept : mEnv(sf.mEnv), mObj(sf.mObj) {
Function(Function&& sf) : mEnv(sf.mEnv), mObj(sf.mObj) {
sq_resetobject(&sf.GetEnv());
sq_resetobject(&sf.GetFunc());
}
@@ -93,7 +93,7 @@ struct Function {
#endif
}
// Constructs a Function from two Squirrel objects (one is the environment object and the other is the function object)
Function(HSQUIRRELVM vm, HSQOBJECT e, HSQOBJECT o) noexcept : mEnv(e), mObj(o) {
Function(HSQUIRRELVM vm, HSQOBJECT e, HSQOBJECT o) : mEnv(e), mObj(o) {
sq_addref(vm, &mEnv);
sq_addref(vm, &mObj);
}
@@ -102,7 +102,7 @@ struct Function {
Release();
}
// Copy Assignment operator
Function& operator=(const Function& sf) noexcept {
Function& operator=(const Function& sf) {
Release();
mEnv = sf.mEnv;
mObj = sf.mObj;
@@ -113,7 +113,7 @@ struct Function {
return *this;
}
// Move Assignment operator
Function& operator=(Function&& sf) noexcept {
Function& operator=(Function&& sf) {
Release();
mEnv = sf.mEnv;
mObj = sf.mObj;
@@ -122,31 +122,31 @@ struct Function {
return *this;
}
// Checks whether the Function is null
bool IsNull() const noexcept {
bool IsNull() const {
return sq_isnull(mObj);
}
// Gets the Squirrel environment object for this Function (copy)
HSQOBJECT GetEnv() const noexcept {
HSQOBJECT GetEnv() const {
return mEnv;
}
// Gets the Squirrel environment object for this Function (reference)
HSQOBJECT& GetEnv() noexcept {
HSQOBJECT& GetEnv() {
return mEnv;
}
// Gets the Squirrel function object for this Function (copy)
HSQOBJECT GetFunc() const noexcept {
HSQOBJECT GetFunc() const {
return mObj;
}
// Gets the Squirrel function object for this Function (reference)
HSQOBJECT& GetFunc() noexcept {
HSQOBJECT& GetFunc() {
return mObj;
}
// Gets the Squirrel VM for this Function
HSQUIRRELVM GetVM() const noexcept {
HSQUIRRELVM GetVM() const {
return DefaultVM::Get_();
}
// Sets the Function to null (removing its references to underlying Squirrel objects)
void Release() noexcept {
void Release() {
if(!IsNull()) {
sq_release(DefaultVM::Get_(), &mEnv);
sq_release(DefaultVM::Get_(), &mObj);
@@ -157,7 +157,7 @@ struct Function {
// Sets the Function to null (removing its references to underlying Squirrel objects)
// This doesn't call release if the reference count is 1.
// Workaround for some weird squirrel behavior that generates an assert in debug mode.
void ReleaseGently() noexcept {
void ReleaseGently() {
if(!IsNull()) {
sq_release(DefaultVM::Get_(), &mEnv);
if (sq_getrefcount(DefaultVM::Get_(), &mObj) > 1) {
@@ -256,7 +256,7 @@ template<> struct Var<Function> {
Var(HSQUIRRELVM vm, SQInteger idx) : value(vm, idx) {
}
// Called by Sqrat::PushVar to put a Function on the stack
static void push(HSQUIRRELVM vm, const Function& value) noexcept {
static void push(HSQUIRRELVM vm, const Function& value) {
sq_pushobject(vm, value.GetFunc());
}
};

24
include/sqrat/sqratGlobalMethods.h
View File

@@ -94,12 +94,12 @@ template <> struct SqGlobalProxy<void> {
};
template<bool> struct SqGlobalParamCheck {
static inline bool Invalid(SQInteger top, SQInteger count) noexcept {
static inline bool Invalid(SQInteger top, SQInteger count) {
return top != count;
}
};
template<> struct SqGlobalParamCheck<true> {
static inline bool Invalid(SQInteger top, SQInteger count) noexcept {
static inline bool Invalid(SQInteger top, SQInteger count) {
return top < (count - 1);
}
};
@@ -109,8 +109,8 @@ template<> struct SqGlobalParamCheck<true> {
//
template <class R> struct SqGlobal {
// Function proxy
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), startIdx + sizeof...(A))) {
@@ -135,8 +135,8 @@ template <class R> struct SqGlobal {
template <class R> struct SqGlobal<R&> {
// Function proxy
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), startIdx + sizeof...(A))) {
@@ -161,8 +161,8 @@ template <class R> struct SqGlobal<R&> {
template <> struct SqGlobal<void> {
// Function proxy
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <SQInteger startIdx, bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), startIdx + sizeof...(A))) {
@@ -182,22 +182,22 @@ template <> struct SqGlobal<void> {
};
// Global Function Resolver
template <class R,class... A> SQFUNCTION SqGlobalFunc(R (* /*method*/)(A...)) noexcept {
template <class R,class... A> SQFUNCTION SqGlobalFunc(R (* /*method*/)(A...)) {
return SqGlobal<R>::template GetProxy<2, false, A...>();
}
// Global Function Resolver
template <class R,class... A> SQFUNCTION SqGlobalFunc(R& (* /*method*/)(A...)) noexcept {
template <class R,class... A> SQFUNCTION SqGlobalFunc(R& (* /*method*/)(A...)) {
return SqGlobal<R&>::template GetProxy<2, false, A...>();
}
// Member Global Function Resolver
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalFunc(R (* /*method*/)(T, A...)) noexcept {
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalFunc(R (* /*method*/)(T, A...)) {
return SqGlobal<R>::template GetProxy<1, false, T, A...>();
}
// Member Global Function Resolver
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalFunc(R& (* /*method*/)(T, A...)) noexcept {
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalFunc(R& (* /*method*/)(T, A...)) {
return SqGlobal<R&>::template GetProxy<1, false, T, A...>();
}

48
include/sqrat/sqratMemberMethods.h
View File

@@ -45,7 +45,7 @@ namespace Sqrat {
// Squirrel Member Functions
//
template <class C,class R> struct SqMemberProxy {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef R(C::*M)(A...);
@@ -58,7 +58,7 @@ template <class C,class R> struct SqMemberProxy {
});
return SQ_FAILED(a.mRes) ? a.mRes : 1;
}
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef R(C::*M)(A...) const;
@@ -78,7 +78,7 @@ template <class C,class R> struct SqMemberProxy {
//
template <class C, class R> struct SqMemberProxy<C,R&> {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef R&(C::*M)(A...);
@@ -91,7 +91,7 @@ template <class C, class R> struct SqMemberProxy<C,R&> {
});
return SQ_FAILED(a.mRes) ? a.mRes : 1;
}
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef R&(C::*M)(A...) const;
@@ -111,7 +111,7 @@ template <class C, class R> struct SqMemberProxy<C,R&> {
//
template <class C> struct SqMemberProxy<C, void> {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger Run(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef void(C::*M)(A...);
@@ -123,7 +123,7 @@ template <class C> struct SqMemberProxy<C, void> {
});
return SQ_FAILED(a.mRes) ? a.mRes : 0;
}
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) noexcept {
template <class... A> static SQInteger RunC(HSQUIRRELVM vm) {
ArgFwd<A...> a{SQ_OK};
a.Call(vm, 2, [](HSQUIRRELVM vm, A... a) {
typedef void(C::*M)(A...) const;
@@ -138,12 +138,12 @@ template <class C> struct SqMemberProxy<C, void> {
};
template<bool> struct SqMemberParamCheck {
static inline bool Invalid(SQInteger top, SQInteger count) noexcept {
static inline bool Invalid(SQInteger top, SQInteger count) {
return top != count;
}
};
template<> struct SqMemberParamCheck<true> {
static inline bool Invalid(SQInteger top, SQInteger count) noexcept {
static inline bool Invalid(SQInteger top, SQInteger count) {
return top < count;
}
};
@@ -153,8 +153,8 @@ template<> struct SqMemberParamCheck<true> {
//
template <class C,class R> struct SqMember {
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -172,8 +172,8 @@ template <class C,class R> struct SqMember {
};
}
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -198,8 +198,8 @@ template <class C,class R> struct SqMember {
template <class C, class R> struct SqMember<C,R&> {
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -217,8 +217,8 @@ template <class C, class R> struct SqMember<C,R&> {
};
}
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -244,8 +244,8 @@ template <class C, class R> struct SqMember<C,R&> {
template <class C> struct SqMember<C, void> {
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxy() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxy() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -263,8 +263,8 @@ template <class C> struct SqMember<C, void> {
};
}
// Function proxy
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() noexcept {
return +[](HSQUIRRELVM vm) noexcept -> SQInteger {
template <bool overloaded, class... A> static SQFUNCTION GetProxyC() {
return +[](HSQUIRRELVM vm) -> SQInteger {
#if !defined (SCRAT_NO_ERROR_CHECKING)
if (!SQRAT_CONST_CONDITION(overloaded) &&
SqGlobalParamCheck< ArgFwd<A...>::HASFMT >::Invalid(sq_gettop(vm), 2 + sizeof...(A))) {
@@ -284,22 +284,22 @@ template <class C> struct SqMember<C, void> {
};
// Member Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R (C::* /*method*/)(A...)) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R (C::* /*method*/)(A...)) {
return SqMember<C,R>::template GetProxy<false, A...>();
}
// Member Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R (C::* /*method*/)(A...) const) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R (C::* /*method*/)(A...) const) {
return SqMember<C,R>::template GetProxyC<false, A...>();
}
// Member Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R& (C::* /*method*/)(A...)) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R& (C::* /*method*/)(A...)) {
return SqMember<C,R&>::template GetProxy<false, A...>();
}
// Member Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R& (C::* /*method*/)(A...) const) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberFunc(R& (C::* /*method*/)(A...) const) {
return SqMember<C,R&>::template GetProxyC<false, A...>();
}

16
include/sqrat/sqratOverloadMethods.h
View File

@@ -152,42 +152,42 @@ public:
};
// Global Overloaded Function Resolver
template <class R,class... A> SQFUNCTION SqGlobalOverloadedFunc(R (* /*method*/)(A...)) noexcept {
template <class R,class... A> SQFUNCTION SqGlobalOverloadedFunc(R (* /*method*/)(A...)) {
return SqGlobal<R>::template GetProxy<2, true, A...>();
}
// Global Overloaded Function Resolver
template <class R,class... A> SQFUNCTION SqGlobalOverloadedFunc(R& (* /*method*/)(A...)) noexcept {
template <class R,class... A> SQFUNCTION SqGlobalOverloadedFunc(R& (* /*method*/)(A...)) {
return SqGlobal<R&>::template GetProxy<2, true, A...>();
}
// Member Global Overloaded Function Resolver
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalOverloadedFunc(R (* /*method*/)(T, A...)) noexcept {
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalOverloadedFunc(R (* /*method*/)(T, A...)) {
return SqGlobal<R>::template GetProxy<1, true, T, A...>();
}
// Member Global Overloaded Function Resolver
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalOverloadedFunc(R& (* /*method*/)(T, A...)) noexcept {
template <class R,class T,class... A> SQFUNCTION SqMemberGlobalOverloadedFunc(R& (* /*method*/)(T, A...)) {
return SqGlobal<R&>::template GetProxy<1, true, T, A...>();
}
// Member Overloaded Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R (C::* /*method*/)(A...)) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R (C::* /*method*/)(A...)) {
return SqMember<C,R>::template GetProxy<true, A...>();
}
// Member Overloaded Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R (C::* /*method*/)(A...) const) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R (C::* /*method*/)(A...) const) {
return SqMember<C,R>::template GetProxyC<true, A...>();
}
// Member Overloaded Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R& (C::* /*method*/)(A...)) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R& (C::* /*method*/)(A...)) {
return SqMember<C,R&>::template GetProxy<true, A...>();
}
// Member Overloaded Function Resolver
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R& (C::* /*method*/)(A...) const) noexcept {
template <class C, class R,class... A> SQFUNCTION SqMemberOverloadedFunc(R& (C::* /*method*/)(A...) const) {
return SqMember<C,R&>::template GetProxyC<true, A...>();
}

8
include/sqrat/sqratTypes.h
View File

@@ -1187,12 +1187,12 @@ template<> struct ArgFwdHasFmt<const StackStrF&> { static constexpr bool value =
/// Helper used to process formatted arguments when necessary.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<bool> struct ArgFwdFmt {
template<class T> static inline SQInteger Proc(T &, bool) noexcept { return SQ_OK; }
template<class T> static inline SQInteger Get(T &) noexcept { return SQ_OK; }
template<class T> static inline SQInteger Proc(T &, bool) { return SQ_OK; }
template<class T> static inline SQInteger Get(T &) { return SQ_OK; }
};
template<> struct ArgFwdFmt<true> {
static inline SQInteger Proc(StackStrF & s, bool dummy = false) noexcept { return s.Proc(true, dummy); }
static inline SQInteger Get(StackStrF & s) noexcept { return s.mRes; }
static inline SQInteger Proc(StackStrF & s, bool dummy = false) { return s.Proc(true, dummy); }
static inline SQInteger Get(StackStrF & s) { return s.mRes; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

38
include/sqrat/sqratUtil.h
View File

@@ -205,17 +205,17 @@ class WeakPtr;
// Helper class that defines a VM that can be used as a fallback VM in case no other one is given to a piece of code
class DefaultVM {
private:
static HSQUIRRELVM& StaticVM() noexcept {
static HSQUIRRELVM& StaticVM() {
static HSQUIRRELVM vm;
return vm;
}
public:
// Gets the default VM (copy)
static HSQUIRRELVM Get() noexcept {
static HSQUIRRELVM Get() {
return StaticVM();
}
// Gets the default VM (reference)
static HSQUIRRELVM & Get_() noexcept {
static HSQUIRRELVM & Get_() {
return StaticVM();
}
// Sets the default VM to a given VM
@@ -400,7 +400,7 @@ public:
/// \param msg A nice error message
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Exception(const SQChar * msg) noexcept : message(msg) {}
Exception(const SQChar * msg) : message(msg) {}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructs an exception
@@ -408,7 +408,7 @@ public:
/// \param msg A nice error message
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
explicit Exception(string && msg) noexcept : message(msg) {}
explicit Exception(string && msg) : message(msg) {}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructs an exception
@@ -416,7 +416,7 @@ public:
/// \param msg A nice error message
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
explicit Exception(const string& msg) noexcept : message(msg) {}
explicit Exception(const string& msg) : message(msg) {}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copy constructor
@@ -424,7 +424,7 @@ public:
/// \param ex Exception to copy
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Exception(const Exception& ex) noexcept : message(ex.message) {}
Exception(const Exception& ex) : message(ex.message) {}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Returns a string identifying the exception
@@ -432,7 +432,7 @@ public:
/// \return A nice error message
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const string& Message() const noexcept {
const string& Message() const {
return message;
}
@@ -442,7 +442,7 @@ public:
/// \return A nice error message
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const SQChar * what() const noexcept {
const SQChar * what() const {
return message.c_str();
}
@@ -575,7 +575,7 @@ private:
/// Assigns a new pointer.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Assign(T * ptr) noexcept
void Assign(T * ptr)
{
if (m_Ptr != ptr)
{
@@ -593,7 +593,7 @@ private:
/// Assigns a new pointer and counter.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Assign(T * ptr, Counter * ref) noexcept
void Assign(T * ptr, Counter * ref)
{
if (m_Ptr != ptr)
{
@@ -1098,7 +1098,7 @@ private:
/// Initializes the pointer and counter.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Initialize(T * ptr, Counter * ref) noexcept
void Initialize(T * ptr, Counter * ref)
{
if (ptr != NULL)
{
@@ -1118,7 +1118,7 @@ private:
/// Assigns a new pointer and counter.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Assign(T * ptr, Counter * ref) noexcept
void Assign(T * ptr, Counter * ref)
{
if (m_Ptr != ptr)
{
@@ -1551,7 +1551,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackStrF() noexcept
StackStrF()
: mPtr(_SC(""))
, mLen(0)
, mRes(SQ_OK)
@@ -1565,7 +1565,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Compile time string constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template < size_t N > StackStrF(const SQChar(&str)[N]) noexcept
template < size_t N > StackStrF(const SQChar(&str)[N])
: mPtr(str)
, mLen(N)
, mRes(SQ_OK)
@@ -1579,7 +1579,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackStrF(HSQUIRRELVM vm, SQInteger idx) noexcept
StackStrF(HSQUIRRELVM vm, SQInteger idx)
: mPtr(nullptr)
, mLen(SQ_ERROR)
, mRes(SQ_OK)
@@ -1597,7 +1597,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Move constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackStrF(StackStrF && o) noexcept
StackStrF(StackStrF && o)
: mPtr(o.mPtr)
, mLen(o.mLen)
, mRes(o.mRes)
@@ -1616,7 +1616,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~StackStrF() noexcept
~StackStrF()
{
if (mVM && !sq_isnull(mObj))
{
@@ -1637,7 +1637,7 @@ struct StackStrF
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Actual implementation.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SQRESULT Proc(bool fmt = false, bool dummy = false) noexcept
SQRESULT Proc(bool fmt = false, bool dummy = false)
{
// Reset the converted value object
sq_resetobject(&mObj);