Exception stuff

Sources/Plasma/Apps/plPageOptimizer/main.cpp

@@ -61,6 +61,9 @@ int main(int argc, char* argv[])
         plResManager* resMgr = new plResManager;
         hsgResMgr::Init(resMgr);
 #ifndef _DEBUG
+    } catch (std::exception &e) {
+        printf(" ***crashed on init: %s\n", e.what());
+        return 2;
     } catch (...) {
         puts(" ***crashed on init");
         return 2;
@@ -75,6 +78,10 @@ int main(int argc, char* argv[])
         optimizer.Optimize();
     }
 #ifndef _DEBUG
+    catch (std::exception &e) {
+        printf(" ***crashed on optimizing: %s\n", e.what());
+        return 2;
+    }
     catch (...) {
         puts(" ***crashed on optimizing");
         return 2;
@@ -92,6 +99,9 @@ int main(int argc, char* argv[])
 
         hsgResMgr::Shutdown();
 #ifndef _DEBUG
+    } catch (std::exception &e) {
+        printf(" ***crashed on shutdown: %s\n", e.what());
+        return 2;
     } catch (...) {
         puts(" ***crashed on shutdown");
         return 2;

Sources/Plasma/CoreLib/CMakeLists.txt

@@ -14,6 +14,7 @@ set(CoreLib_SOURCES
     hsBounds.cpp
     hsCpuID.cpp
     hsCritSect.cpp
+    hsExceptions.cpp
     hsExceptionStack.cpp
     hsFastMath.cpp
     hsGeometry3.cpp
@@ -59,6 +60,7 @@ set(CoreLib_HEADERS
     hsCpuID.h
     hsCritSect.h
     hsExceptions.h
+    hsExceptionStack.h
     hsFastMath.h
     hsGeometry3.h
     hsHashTable.h

Sources/Plasma/CoreLib/HeadSpin.h

@@ -130,6 +130,22 @@ typedef int32_t   hsError;
 #   define hsDeprecated(message)
 #endif
 
+#ifdef HAVE_OVERRIDE
+#   define HS_OVERRIDE  override
+#   define HS_FINAL     final
+#else
+#   define HS_OVERRIDE
+#   define HS_FINAL
+#endif
+
+#ifdef HAVE_NOEXCEPT
+#   define HS_NOEXCEPT          noexcept
+#   define HS_NOEXCEPT_IF(cond) noexcept(cond)
+#else
+#   define HS_NOEXCEPT          throw()
+#   define HS_NOEXCEPT_IF(cond)
+#endif
+
 //======================================
 // Endian swap funcitions
 //======================================

Sources/Plasma/CoreLib/hsExceptionStack.cpp

@@ -48,4 +48,4 @@ void hsExceptionStack::FreeInstance()
 {
     delete fExceptionStack;
     fExceptionStack = nil;
-}
+}

Sources/Plasma/CoreLib/hsExceptions.cpp

@@ -0,0 +1,22 @@
+#include "hsExceptions.h"
+
+#include <cstring>
+
+hsException::hsException(hsErrorEnum error, long param) HS_NOEXCEPT
+    : fError(error), fParam(param)
+{
+    static const char *kErrorNames[] = {
+        "kNo_hsError",
+        "kNilParam_hsError",
+        "kBadParam_hsError",
+        "kInternal_hsError",
+        "kOS_hsError"
+    };
+    static_assert(arrsize(kErrorNames) == hsErrorEnum_MAX,
+        "kErrorNames not in sync with hsErrorEnum");
+
+    if (fError >= 0 && fError < hsErrorEnum_MAX)
+        snprintf(fWhat, arrsize(fWhat), "%s (%ld)", kErrorNames[fError], fParam);
+    else
+        snprintf(fWhat, arrsize(fWhat), "Unknown hsException error %d (%ld)", fError, fParam);
+}

Sources/Plasma/CoreLib/hsExceptions.h

@@ -43,64 +43,52 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #define hsExceptionDefined
 
 #include "HeadSpin.h"
-
-// #define HS_NO_EXCEPTIONS -- this will turn off execptions you might want 
-// to do it with -D or equivalent instead of here since who knows who includes this.
-
-
+#include <exception>
 
 enum hsErrorEnum {
     kNo_hsError,
-    kBadAlloc_hsError,
     kNilParam_hsError,
     kBadParam_hsError,
     kInternal_hsError,
-    kOS_hsError
+    kOS_hsError,
+    hsErrorEnum_MAX
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
-class hsException {
+class hsException : public std::exception {
 public:
     hsErrorEnum fError;
-    long            fParam;
-
-    hsException(hsErrorEnum error, long param = 0) : fError(error), fParam(param) {}
-};
+    long        fParam;
+    char        fWhat[64];
 
-class hsBadAllocException : public hsException {
-public:
-    hsBadAllocException() : hsException(kBadAlloc_hsError) {}
+    hsException(hsErrorEnum error, long param = 0) HS_NOEXCEPT;
+    const char *what() const HS_NOEXCEPT HS_OVERRIDE { return fWhat; }
 };
 
 class hsNilParamException : public hsException {
 public:
-    hsNilParamException() : hsException(kNilParam_hsError) {}
+    hsNilParamException() HS_NOEXCEPT : hsException(kNilParam_hsError) {}
 };
 
 class hsBadParamException : public hsException {
 public:
-    hsBadParamException() : hsException(kBadParam_hsError) {}
+    hsBadParamException() HS_NOEXCEPT : hsException(kBadParam_hsError) {}
 };
 
 class hsInternalException : public hsException {
 public:
-    hsInternalException() : hsException(kInternal_hsError) {}
+    hsInternalException() HS_NOEXCEPT : hsException(kInternal_hsError) {}
 };
 
 class hsOSException : public hsException {
 public:
-    hsOSException(long error) : hsException(kOS_hsError, error) {}
+    hsOSException(long error) HS_NOEXCEPT : hsException(kOS_hsError, error) {}
 };
 
 /////////////////////////////////////////////////////////////////////////////////
 
-#ifndef HS_NO_EXCEPTIONS
-#define hsThrow(a) {hsAssert(0,#a);throw a;}
-#define hsCatch(a) catch (a)
-#define hsCatch2(a,b) catch (a b)
-
-#define hsTry try
+#define hsThrow(a) { hsAssert(0,#a); throw a; }
 
 inline void hsThrowIfNilParam(const void* p)
 {
@@ -165,48 +153,4 @@ inline void hsThrowIfFalse(bool condition, const char message[])
     }
 }
 
-#else
-#define hsThrow(a) {hsAssert(0,#a);}
-#define hsCatch(a) if(0)
-#define hsCatch2(a,b) if(0)
-#define hsTry 
-
-inline void hsThrowIfNilParam(const void* p)
-{
-    hsAssert(p!=nil,"hsThrowIfNilParam");
-}
-
-inline void hsThrowIfBadParam(bool trueIfBadParam)
-{
-    hsAssert(!trueIfBadParam,"hsThrowIfBadParam");
-}
-
-inline void hsThrowIfOSErr(long osErr)
-{
-    hsAssert(osErr==0,"hsThrowIfOSErr");
-}
-
-inline void hsThrowIfTrue(bool condition)
-{
-    hsAssert(!condition,"hsThrowIfTrue");
-}
-
-inline void hsThrowIfFalse(bool condition)
-{
-    hsAssert(condition,"hsThrowIfFalse");
-}
-
-inline void hsThrowIfTrue(bool condition, const char message[])
-{
-    hsAssert(!condition,message);
-}
-
-inline void hsThrowIfFalse(bool condition, const char message[])
-{
-    hsAssert(condition,message);
-}
-
-
-#endif
-
 #endif

Sources/Plasma/CoreLib/hsMemory.cpp

@@ -110,44 +110,6 @@ void HSMemory::Clear(void* m, uint32_t byteLen)
 
 //////////////////////////////////////////////////////////////////////////////////////
 
-#if 0
-template <class T> T* hsSoftNew(T*& obj)
-{
-    try {
-        obj = new T;
-    }
-    catch (...) {
-        obj = nil;
-    }
-    return obj;
-}
-
-inline template <class T> T* hsSoftNew(T*& obj, unsigned count)
-{
-    try {
-        obj = new T[count];
-    }
-    catch (...) {
-        obj = nil;
-    }
-    return obj;
-}
-#endif
-
-void* HSMemory::SoftNew(uint32_t size)
-{
-    uint32_t* p;
-
-    hsTry {
-        p = new uint32_t[(size + 3) >> 2];
-    } hsCatch(...) {
-        p = nil;
-    }
-    return p;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////
-
 struct hsPrivateChunk {
     hsPrivateChunk* fNext;
     char*           fAvailableAddr;
@@ -222,19 +184,6 @@ void* hsChunkAllocator::Allocate(uint32_t size, const void* data)
     return addr;
 }
 
-void* hsChunkAllocator::SoftAllocate(uint32_t size, const void* data)
-{
-    void*   addr;
-
-    hsTry {
-        addr = this->Allocate(size, data);
-    }
-    hsCatch(...) {
-        addr = nil;
-    }
-    return addr;
-}
-
 //////////////////////////////////////////////////////////////////////////////////////
 
 struct hsAppenderHead {

Sources/Plasma/CoreLib/hsMemory.h

@@ -56,8 +56,6 @@ class HSMemory {
     static void* New(uint32_t size);
     static void  Delete(void* block);
     static void* Copy(uint32_t length, const void* source);
-
-    static void* SoftNew(uint32_t size);   // returns nil if can't allocate
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -110,8 +108,7 @@ class hsChunkAllocator {
 
     void        Reset();
     void        SetChunkSize(uint32_t size);
-    void*   Allocate(uint32_t size, const void* data = nil);      // throws if fails
-    void*   SoftAllocate(uint32_t size, const void* data = nil);  // returns nil if fails
+    void*   Allocate(uint32_t size, const void* data = nil);
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////

Sources/Plasma/CoreLib/plString.cpp

@@ -489,23 +489,23 @@ plUnicodeBuffer plString::GetUnicodeArray() const
     return result;
 }
 
-int plString::ToInt(int base) const
+int plString::ToInt(int base) const HS_NOEXCEPT
 {
     return static_cast<int>(strtol(c_str(), nullptr, base));
 }
 
-unsigned int plString::ToUInt(int base) const
+unsigned int plString::ToUInt(int base) const HS_NOEXCEPT
 {
     return static_cast<unsigned int>(strtoul(c_str(), nullptr, base));
 }
 
-float plString::ToFloat() const
+float plString::ToFloat() const HS_NOEXCEPT
 {
     // strtof is C99, which MS doesn't support...
     return (float)strtod(c_str(), nullptr);
 }
 
-double plString::ToDouble() const
+double plString::ToDouble() const HS_NOEXCEPT
 {
     return strtod(c_str(), nullptr);
 }
@@ -550,7 +550,7 @@ plString plString::IFormat(const char *fmt, va_list vptr)
     return plString::FromUtf8(buffer, chars);
 }
 
-ssize_t plString::Find(char ch, CaseSensitivity sense) const
+ssize_t plString::Find(char ch, CaseSensitivity sense) const HS_NOEXCEPT
 {
     if (sense == kCaseSensitive) {
         const char *cp = strchr(c_str(), ch);
@@ -566,7 +566,7 @@ ssize_t plString::Find(char ch, CaseSensitivity sense) const
     }
 }
 
-ssize_t plString::FindLast(char ch, CaseSensitivity sense) const
+ssize_t plString::FindLast(char ch, CaseSensitivity sense) const HS_NOEXCEPT
 {
     if (IsEmpty())
         return -1;
@@ -586,7 +586,7 @@ ssize_t plString::FindLast(char ch, CaseSensitivity sense) const
     }
 }
 
-ssize_t plString::Find(const char *str, CaseSensitivity sense) const
+ssize_t plString::Find(const char *str, CaseSensitivity sense) const HS_NOEXCEPT
 {
     if (!str || !str[0])
         return -1;