Fixup for MSVC 2013

Author: mgreter

src/ast.hpp

@@ -23,8 +23,9 @@
 #include "fn_utils.hpp"
 #include "memory_pool.hpp"
 #include "var_stack.hpp"
+#include "ordered_map.hpp"
 
-#include "ordered-map/ordered_map.h"
+// #include "ordered-map/ordered_map.h"
 
 namespace Sass {
 
@@ -524,10 +525,9 @@ namespace Sass {
   class Hashed {
 
 
-    using ordered_map_type = typename tsl::ordered_map<
+    using ordered_map_type = typename ordered_map<
       K, T, ObjHash, ObjEquality,
-      SassAllocator<std::pair<K, T>>,
-      sass::vector<std::pair<K, T>>
+      SassAllocator<std::pair<K, T>>
     >;
 
   protected:
@@ -567,7 +567,7 @@ namespace Sass {
     bool empty() const { return elements_.empty(); }
 
     bool has(K k) const          {
-      return elements_.count(k);
+      return elements_.count(k) == 1;
     }
 
     void reserve(size_t size)

src/environment.hpp

@@ -26,7 +26,7 @@
 
 // #include "../../hopscotch-map/include/tsl/hopscotch_map.h"
 // #include "../../hopscotch-map/include/tsl/hopscotch_set.h"
-#include "ordered-map/ordered_map.h"
+// #include "ordered-map/ordered_map.h"
 // #include "../../ordered-map/include/tsl/ordered_set.h"
 // #include "robin_hood.hpp"
 
@@ -54,18 +54,17 @@ namespace Sass {
   >;
 
   template<class T>
-  using NormalizedOMap = tsl::ordered_map<
+  using NormalizedOMap = ordered_map<
     EnvString, T,
     SassIgnoreDashPair,
     SassAllocator<std::pair<EnvString, T>>
   >;
 
   template<class T>
-  using KeywordMapOlder = tsl::ordered_map<
+  using KeywordMapOlder = ordered_map<
     EnvString, T,
     SassIgnoreDashPair,
-    SassAllocator<std::pair<EnvString, T>>,
-    sass::vector<std::pair<EnvString, T>>
+    SassAllocator<std::pair<EnvString, T>>
   >;
 
   using NormalizeSet = std::unordered_set<

src/extender.hpp

@@ -12,7 +12,7 @@
 #include "backtrace.hpp"
 #include "ordered_map.hpp"
 
-#include "ordered-map/ordered_map.h"
+// #include "ordered-map/ordered_map.h"
 
 namespace Sass {
 
@@ -49,7 +49,7 @@ namespace Sass {
     // SassAllocator<std::pair<SimpleSelectorObj, ExtListSelSet>>
   > ExtSelMap;
 
-  typedef tsl::ordered_map<
+  typedef ordered_map<
     ComplexSelectorObj,
     Extension,
     ObjHash,
@@ -117,7 +117,7 @@ namespace Sass {
     // This tracks the contexts in which each style rule is defined.
     // If a rule is defined at the top level, it doesn't have an entry.
     // ##########################################################################
-    tsl::ordered_map<
+    ordered_map<
       SelectorListObj,
       CssMediaRuleObj,
       ObjPtrHash,

src/file.cpp

@@ -16,6 +16,7 @@
 #include <cstdio>
 #include <vector>
 #include <algorithm>
+#include <unordered_map>
 #include <sys/stat.h>
 #include "file.hpp"
 #include "context.hpp"
@@ -75,7 +76,7 @@ namespace Sass {
     }
 
 
-    static thread_local std::unordered_map<
+    static /* thread_local */ std::unordered_map<
       sass::string, bool> cached;
 
     // test if path exists and is a file

src/memory_pool.hpp

@@ -10,7 +10,7 @@
 namespace Sass {
 
   // Move this to somewhere else, should be global
-  constexpr size_t SASS_MEM_ALIGN = sizeof(unsigned int);
+	#define SASS_MEM_ALIGN sizeof(unsigned int)
 
   inline static size_t align2(size_t n) {
     return (n + SASS_MEM_ALIGN - 1) & ~(SASS_MEM_ALIGN - 1);
@@ -54,25 +54,25 @@ namespace Sass {
 
 
   // The size of the memory pool arenas in bytes.
-  constexpr static size_t SassAllocatorArenaSize = 1024 * 256;
+  #define SassAllocatorArenaSize (1024 * 256)
 
   // How many buckets should we have for the freelist
   // Determines when allocations go directly to malloc/free
   // For maximum size of managed items multiply by alignment
-  constexpr static size_t SassAllocatorBuckets = 512;
+#define SassAllocatorBuckets 512
 
   // The alignment for the memory fragments. Must be a multiple
   // of `SASS_MEM_ALIGN` and should not be too big (maybe 1 or 2)
-  constexpr static size_t SassAllocatorAlignment = SASS_MEM_ALIGN * 2;
+#define SassAllocatorAlignment (SASS_MEM_ALIGN * 2)
 
   // The number of bytes we use for our book-keeping before every
   // memory fragment. Needed to know to which bucket we belongs on
   // deallocations, or if it should go directly to the `free` call.
-  constexpr size_t SassAllocatorBookSize = sizeof(unsigned int);
+#define SassAllocatorBookSize sizeof(unsigned int)
 
   // Bytes reserve for book-keeping on the arenas
   // Currently unused and for later optimization
-  constexpr size_t SassAllocatorArenaHeadSize = 0;
+#define SassAllocatorArenaHeadSize 0
 
   class MemoryPool {
 

src/ordered-map/ordered_hash.h

@@ -128,8 +128,8 @@ static T numeric_cast(U value, const char* error_message = "numeric_cast() faile
  * to represent a std::size_t on 32 and 64 bits platforms, and must be the same size on both platforms.
  */
 using slz_size_type = std::uint64_t;
-static_assert(std::numeric_limits<slz_size_type>::max() >= std::numeric_limits<std::size_t>::max(),
-              "slz_size_type must be >= std::size_t");
+// static_assert(std::numeric_limits<slz_size_type>::max() >= std::numeric_limits<std::size_t>::max(),
+//               "slz_size_type must be >= std::size_t");
 
 template<class T, class Deserializer>
 static T deserialize_value(Deserializer& deserializer) {

src/randomize.cpp

@@ -8,6 +8,9 @@
 
 namespace Sass {
 
+	typedef __int32 int32_t;
+	typedef unsigned __int32 uint32_t;
+
   // ToDo: this seems not thread safe!!
 
   // Just a static wrapped around random device

src/units.cpp

@@ -6,7 +6,7 @@
 #include "ordered_map.hpp"
 #include "error_handling.hpp"
 #include "environment.hpp" // For the hasher
-#include "ordered-map/ordered_map.h"
+// #include "ordered-map/ordered_map.h"
 
 namespace Sass {
 
@@ -289,10 +289,9 @@ namespace Sass {
     // we basically construct exponents for each unit
     // has the advantage that they will be pre-sorted
     // ToDo: use fast map implementation?
-    tsl::ordered_map<sass::string, int,
+    ordered_map<sass::string, int,
       SassIgnoreDashPair,
-      SassAllocator<std::pair<sass::string, int>>,
-      sass::vector<std::pair<sass::string, int>>
+      SassAllocator<std::pair<sass::string, int>>
     > exponents;
 
     // initialize by summing up occurences in unit vectors