Improve compiler compatibility for early gcc versions

Author: mgreter

src/ast.cpp

@@ -47,27 +47,23 @@ namespace Sass {
     return &lhs && &rhs && *lhs == *rhs;
   }
 
-  std::string & str_ltrim(std::string & str)
+  void str_rtrim(std::string& s, const std::string& delimiters = " \f\n\r\t\v" )
   {
-    auto it2 =  std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
-    str.erase( str.begin() , it2);
-    return str;
+     s.erase( s.find_last_not_of( delimiters ) + 1 );
   }
 
-  std::string & str_rtrim(std::string & str)
+  void str_ltrim(std::string& s,  const std::string& delimiters = " \f\n\r\t\v" )
   {
-    auto it1 =  std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
-    str.erase( it1.base() , str.end() );
-    return str;
+     s.erase( 0, s.find_first_not_of( delimiters ) );
   }
 
   void String_Constant::rtrim()
   {
-    value_ = str_rtrim(value_);
+    str_rtrim(value_);
   }
   void String_Constant::ltrim()
   {
-    value_ = str_ltrim(value_);
+    str_ltrim(value_);
   }
   void String_Constant::trim()
   {
@@ -175,15 +171,15 @@ namespace Sass {
 
   bool Compound_Selector::has_parent_ref()
   {
-    for (Simple_Selector_Obj s : *this) {
+    for (Simple_Selector_Obj s : elements()) {
       if (s && s->has_parent_ref()) return true;
     }
     return false;
   }
 
   bool Compound_Selector::has_real_parent_ref()
   {
-    for (Simple_Selector_Obj s : *this) {
+    for (Simple_Selector_Obj s : elements()) {
       if (s && s->has_real_parent_ref()) return true;
     }
     return false;

src/ast.hpp

@@ -344,7 +344,7 @@ namespace Sass {
     virtual void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { }
   public:
     Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression_Obj>())
-    { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }
+    { list_.reserve(s); reset_duplicate_key(); }
     virtual ~Hashed();
     size_t length() const                  { return list_.size(); }
     bool empty() const                     { return list_.empty(); }
@@ -1464,7 +1464,7 @@ namespace Sass {
       if (hash_ == 0) {
         hash_ = std::hash<std::string>()(name());
         for (auto argument : arguments()->elements())
-          hash_combine(hash_, argument->hash());
+        { hash_combine(hash_, argument->hash()); }
       }
       return hash_;
     }
@@ -1619,9 +1619,9 @@ namespace Sass {
       if (hash_ == 0) {
         hash_ = std::hash<double>()(value_);
         for (const auto numerator : numerator_units())
-          hash_combine(hash_, std::hash<std::string>()(numerator));
+        { hash_combine(hash_, std::hash<std::string>()(numerator)); }
         for (const auto denominator : denominator_units())
-          hash_combine(hash_, std::hash<std::string>()(denominator));
+        { hash_combine(hash_, std::hash<std::string>()(denominator)); }
       }
       return hash_;
     }
@@ -1809,7 +1809,7 @@ namespace Sass {
     {
       if (hash_ == 0) {
         for (auto string : elements())
-          hash_combine(hash_, string->hash());
+        { hash_combine(hash_, string->hash()); }
       }
       return hash_;
     }

src/context.cpp

@@ -98,10 +98,10 @@ namespace Sass {
     collect_plugin_paths(c_options.plugin_paths);
 
     // load plugins and register custom behaviors
-    for(auto plug : plugin_paths) plugins.load_plugins(plug);
-    for(auto fn : plugins.get_headers()) c_headers.push_back(fn);
-    for(auto fn : plugins.get_importers()) c_importers.push_back(fn);
-    for(auto fn : plugins.get_functions()) c_functions.push_back(fn);
+    for(auto plug : plugin_paths) { plugins.load_plugins(plug); }
+    for(auto fn : plugins.get_headers()) { c_headers.push_back(fn); }
+    for(auto fn : plugins.get_importers()) { c_importers.push_back(fn); }
+    for(auto fn : plugins.get_functions()) { c_functions.push_back(fn); }
 
     // sort the items by priority (lowest first)
     sort (c_headers.begin(), c_headers.end(), sort_importers);

src/eval.cpp

@@ -335,15 +335,16 @@ namespace Sass {
     // try to use generic function
     if (env->has("@warn[f]")) {
 
-      // add call stack entry
-      ctx.callee_stack.push_back({
+      struct Sass_Callee callee = {
         "@warn",
         w->pstate().path,
         w->pstate().line + 1,
         w->pstate().column + 1,
         SASS_CALLEE_FUNCTION,
         { env }
-      });
+      };
+      // add call stack entry
+      ctx.callee_stack.push_back(callee);
 
       Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@warn[f]"]);
       // Block_Obj          body   = def->block();
@@ -382,15 +383,16 @@ namespace Sass {
     // try to use generic function
     if (env->has("@error[f]")) {
 
-      // add call stack entry
-      ctx.callee_stack.push_back({
+      struct Sass_Callee callee = {
         "@error",
         e->pstate().path,
         e->pstate().line + 1,
         e->pstate().column + 1,
         SASS_CALLEE_FUNCTION,
         { env }
-      });
+      };
+      // add call stack entry
+      ctx.callee_stack.push_back(callee);
 
       Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@error[f]"]);
       // Block_Obj          body   = def->block();
@@ -426,15 +428,16 @@ namespace Sass {
     // try to use generic function
     if (env->has("@debug[f]")) {
 
-      // add call stack entry
-      ctx.callee_stack.push_back({
+      struct Sass_Callee callee = {
         "@debug",
         d->pstate().path,
         d->pstate().line + 1,
         d->pstate().column + 1,
         SASS_CALLEE_FUNCTION,
         { env }
-      });
+      };
+      // add call stack entry
+      ctx.callee_stack.push_back(callee);
 
       Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@debug[f]"]);
       // Block_Obj          body   = def->block();
@@ -908,14 +911,15 @@ namespace Sass {
       bind(std::string("Function"), c->name(), params, args, &ctx, &fn_env, this);
       Backtrace here(backtrace(), c->pstate(), ", in function `" + c->name() + "`");
       exp.backtrace_stack.push_back(&here);
-      ctx.callee_stack.push_back({
+      struct Sass_Callee callee = {
         c->name().c_str(),
         c->pstate().path,
         c->pstate().line + 1,
         c->pstate().column + 1,
         SASS_CALLEE_FUNCTION,
         { env }
-      });
+      };
+      ctx.callee_stack.push_back(callee);
 
       // eval the body if user-defined or special, invoke underlying CPP function if native
       if (body /* && !Prelexer::re_special_fun(name.c_str()) */) {
@@ -949,14 +953,15 @@ namespace Sass {
 
       Backtrace here(backtrace(), c->pstate(), ", in function `" + c->name() + "`");
       exp.backtrace_stack.push_back(&here);
-      ctx.callee_stack.push_back({
+      struct Sass_Callee callee = {
         c->name().c_str(),
         c->pstate().path,
         c->pstate().line + 1,
         c->pstate().column + 1,
         SASS_CALLEE_C_FUNCTION,
         { env }
-      });
+      };
+      ctx.callee_stack.push_back(callee);
 
       To_C to_c;
       union Sass_Value* c_args = sass_make_list(params->length(), SASS_COMMA, false);
@@ -1160,7 +1165,7 @@ namespace Sass {
       List_Obj ll = SASS_MEMORY_NEW(List, l->pstate(), 0, l->separator());
       // this fixes an issue with bourbon sample, not really sure why
       // if (l->size() && dynamic_cast<Null_Ptr>((*l)[0])) { res += ""; }
-      for(Expression_Obj item : *l) {
+      for(Expression_Obj item : l->elements()) {
         item->is_interpolant(l->is_interpolant());
         std::string rl(""); interpolation(ctx, rl, &item, into_quotes, l->is_interpolant());
         bool is_null = dynamic_cast<Null_Ptr>(&item) != 0; // rl != ""

src/expand.cpp

@@ -708,14 +708,15 @@ namespace Sass {
     Arguments_Obj args = SASS_MEMORY_CAST(Arguments, rv);
     Backtrace new_bt(backtrace(), c->pstate(), ", in mixin `" + c->name() + "`");
     backtrace_stack.push_back(&new_bt);
-    ctx.callee_stack.push_back({
+    struct Sass_Callee callee = {
       c->name().c_str(),
       c->pstate().path,
       c->pstate().line + 1,
       c->pstate().column + 1,
       SASS_CALLEE_MIXIN,
       { env }
-    });
+    };
+    ctx.callee_stack.push_back(callee);
 
     Env new_env(def->environment());
     env_stack.push_back(&new_env);

src/extend.cpp

@@ -1948,7 +1948,7 @@ namespace Sass {
           recseen.insert(*cur->head());
           // create a copy since we add multiple items if stuff get unwrapped
           Compound_Selector_Obj cpy_head = SASS_MEMORY_NEW(Compound_Selector, cur->pstate());
-          for (Simple_Selector_Obj hs : *cur->head()) {
+          for (Simple_Selector_Obj hs : cur->head()->elements()) {
             if (Wrapped_Selector_Obj ws = SASS_MEMORY_CAST(Wrapped_Selector, hs)) {
               ws->selector(SASS_MEMORY_CLONE(ws->selector()));
               if (Selector_List_Obj sl = SASS_MEMORY_CAST(Selector_List, ws->selector())) {
@@ -2079,7 +2079,8 @@ namespace Sass {
     // we set `extended` flag on extended selectors
     if (b->is_root()) {
       // debug_subset_map(subset_map);
-      for(auto const &it : subset_map.values()) {
+      auto values = subset_map.values();
+      for(auto it : values) {
         Complex_Selector_Ptr sel = it.first ? &it.first->first() : NULL;
         Compound_Selector_Ptr ext = it.second ? &it.second : NULL;
         if (ext && (ext->extended() || ext->is_optional())) continue;

src/functions.cpp

@@ -30,6 +30,24 @@
 #include "wincrypt.h"
 #endif
 
+#if defined __GNUC__ && ! defined __llvm__
+  #define GCC_VERSION (__GNUC__ * 10000 \
+                       + __GNUC_MINOR__ * 100 \
+                       + __GNUC_PATCHLEVEL__)
+  #if GCC_VERSION < 40500
+    #include <tr1/random>
+    #define IMPLEMENT_TR1
+    #define tr1ns std::tr1
+    #define uniform_real_distribution uniform_real
+  #else
+    #include <random>
+    #define tr1ns std
+  #endif
+#else
+  #include <random>
+  #define tr1ns std
+#endif
+
 #define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, backtrace)
 #define ARGR(argname, argtype, lo, hi) get_arg_r(argname, env, sig, pstate, lo, hi, backtrace)
 #define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, pstate, backtrace, ctx)
@@ -212,9 +230,43 @@ namespace Sass {
     // random_device degrades sharply once the entropy pool
     // is exhausted. For practical use, random_device is
     // generally only used to seed a PRNG such as mt19937.
-    static std::mt19937 rand(static_cast<unsigned int>(GetSeed()));
+    static tr1ns::mt19937 rand(static_cast<unsigned int>(GetSeed()));
+
+    tr1ns::uniform_real_distribution<> std_dist(0, 1);
+    #ifdef IMPLEMENT_TR1
+      tr1ns::variate_generator <
+        tr1ns::mt19937,
+        tr1ns::uniform_real_distribution <double>
+      > gen_std_dist(rand, std_dist);
+    #endif
+
+    // Using ULONG_MAX here seems to fail on Mac OSX Clang!?
+    tr1ns::uniform_real_distribution<> full_dist(0, 4294967296);
+    #ifdef IMPLEMENT_TR1
+      tr1ns::variate_generator <
+        tr1ns::mt19937,
+        tr1ns::uniform_real_distribution <double>
+      > gen_full_dist(rand, full_dist);
+    #endif
+
+    // helper function to retrieve a random number in interval
+    // works around some compiler issues with older gcc versions
+    static double random(double min, double max)
+    {
+      tr1ns::uniform_real_distribution<> distributor(min, max);
+      #ifdef IMPLEMENT_TR1
+        tr1ns::variate_generator <
+          tr1ns::mt19937,
+          tr1ns::uniform_real_distribution <>
+        > gen(rand, distributor);
+        distributor(rand);
+        return gen();
+      #else
+        return distributor(rand);
+      #endif
+    }
 
-    // features
+    // supported features lookup table
     static std::set<std::string> features {
       "global-variable-shadowing",
       "extend-selector-pseudoclass",
@@ -1199,13 +1251,19 @@ namespace Sass {
           err << "Expected $limit to be an integer but got " << v << " for `random'";
           error(err.str(), pstate);
         }
-        std::uniform_real_distribution<> distributor(1, v + 1);
-        uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+        // std::uniform_real_distribution<> distributor(1, v + 1);
+        // uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+        uint_fast32_t distributed = random(1, v + 1);
         return SASS_MEMORY_NEW(Number, pstate, (double)distributed);
       }
       else if (b) {
-        std::uniform_real_distribution<> distributor(0, 1);
-        double distributed = static_cast<double>(distributor(rand));
+        // std::uniform_real_distribution<> distributor(0, 1);
+        // double distributed = static_cast<double>(distributor(rand));
+        #ifdef IMPLEMENT_TR1
+          double distributed = gen_std_dist();
+        #else
+          double distributed = std_dist(rand);
+        #endif
         return SASS_MEMORY_NEW(Number, pstate, distributed);
       } else if (v) {
         throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number", v);
@@ -1989,8 +2047,11 @@ namespace Sass {
     BUILT_IN(unique_id)
     {
       std::stringstream ss;
-      std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
-      uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+      #ifdef IMPLEMENT_TR1
+        uint_fast32_t distributed = gen_full_dist();
+      #else
+        uint_fast32_t distributed = full_dist(rand);
+      #endif
       ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
       return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
     }

src/parser.cpp

@@ -307,7 +307,7 @@ namespace Sass {
     do {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
-        to_import.push_back(std::pair<std::string,Function_Call_Obj>(std::string(lexed), 0));
+        to_import.push_back(std::pair<std::string,Function_Call_Obj>(std::string(lexed), (Function_Call*) NULL));
       }
       else if (lex< uri_prefix >()) {
         Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);

src/subset_map.cpp

@@ -26,7 +26,7 @@ namespace Sass {
         continue;
       }
       const std::vector<std::pair<Compound_Selector_Obj, size_t> >& subsets = hash_[(*sel)[i]];
-      for (const std::pair<Compound_Selector_Obj, size_t>& item : subsets) {
+      for (const auto& item : subsets) {
         bool include = true;
         for (const Simple_Selector_Obj& it : item.first->elements()) {
           auto found = dict.find(it);