Avoid extern lifetime for thread local allocator

*Fingers crossed*

Author: mgreter

src/allocator.cpp

@@ -17,7 +17,16 @@ namespace Sass {
 
   void deallocateMem(void* ptr, size_t size)
   {
+
+    // It seems thread_local variable might be discharged!?
+    // But the destructors of e.g. static strings is still
+    // called, although their memory was discharged too.
+    // Fine with me as long as address sanitizer is happy.
+    if (pool == nullptr) { return; }
+    if (allocations == 0) { return; }
+
     pool->deallocate(ptr);
+    // ToDo: change to empty()
     if (--allocations == 0) {
       delete pool;
       pool = nullptr;
@@ -27,9 +36,10 @@ namespace Sass {
 
   void* allocateMem(size_t size)
   {
-    if (allocations++ == 0) {
+    if (pool == nullptr) {
       pool = new MemoryPool();
     }
+    allocations++;
     return pool->allocate(size);
   }
 

src/error_handling.cpp

@@ -8,20 +8,12 @@
 #include "error_handling.hpp"
 
 #include <iostream>
+#include <string.h>
 
 namespace Sass {
 
   namespace Exception {
 
-    sass::string def_msg("Invalid sass detected");
-    sass::string def_op_msg("Undefined operation");
-    sass::string def_op_null_msg("Invalid null operation");
-    sass::string def_nesting_limit("Code too deeply neested");
-
-    sass::string msg_recursion_limit =
-      "Too deep recursion detected. This can be caused by too deep level nesting.\n"
-      "LibSass will abort here in order to avoid a possible stack overflow.\n";
-
     Base::Base(SourceSpan pstate, sass::string msg, Backtraces traces)
     : std::runtime_error(msg.c_str()), msg(msg),
       prefix("Error"), pstate(pstate), traces(traces)
@@ -100,7 +92,7 @@ namespace Sass {
     UndefinedOperation::UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
     : OperationError(), lhs(lhs), rhs(rhs), op(op)
     {
-      msg = def_op_msg + " \"" +
+      msg = "Undefined operation \"" +
         lhs->to_string({ NESTED, 5 }) +
         " " + sass_op_separator(op) + " " +
         rhs->to_string({ TO_SASS, 5 }) +

src/error_handling.hpp

@@ -21,12 +21,13 @@ namespace Sass {
 
   namespace Exception {
 
-    extern sass::string def_msg;
-    extern sass::string def_op_msg;
-    extern sass::string def_op_null_msg;
-    extern sass::string def_nesting_limit;
+    const sass::string def_msg("Invalid sass detected");
+    const sass::string def_op_null_msg("Invalid null operation");
+    const sass::string def_nesting_limit("Code too deeply neested");
 
-    extern sass::string msg_recursion_limit;
+    const sass::string msg_recursion_limit =
+      "Too deep recursion detected. This can be caused by too deep level nesting.\n"
+      "LibSass will abort here in order to avoid a possible stack overflow.\n";
 
     class Base : public std::runtime_error {
       protected:
@@ -137,7 +138,7 @@ namespace Sass {
       protected:
         sass::string msg;
       public:
-        OperationError(sass::string msg = def_op_msg)
+        OperationError(sass::string msg = sass::string("Undefined operation"))
         : std::runtime_error(msg.c_str()), msg(msg)
         {};
       public:

src/file.cpp

@@ -2,6 +2,12 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
+#if defined (_MSC_VER) // Visual studio
+#define thread_local __declspec( thread )
+#elif defined (__GCC__) // GCC
+#define thread_local __thread
+#endif
+
 #ifdef _WIN32
 # ifdef __MINGW32__
 #  ifndef off64_t

src/memory_pool.hpp

@@ -112,7 +112,7 @@ namespace Sass {
     ~MemoryPool() {
       // The memory will not be used anymore
       // If you kill the pool to early go figure
-      // std::cerr << "MEMORY POOL DESTRUCTOR\n";
+      // std::cerr << "MEMORY POOL DESTROYED\n";
       // Cant just throw them out, some might still want
       // to be destructed. Those will fail greatly.
       for (auto arena : arenas) {