Improve compiler compatibility for early gcc versions

Author: mgreter

src/ast.cpp

@@ -28,27 +28,23 @@ namespace Sass {
           dynamic_cast<Supports_Operator*>(cond);
   }
 
-  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()
   {
@@ -156,15 +152,15 @@ namespace Sass {
 
   bool SimpleSequence_Selector::has_parent_ref()
   {
-    for (Simple_Selector* s : *this) {
+    for (Simple_Selector* s : elements()) {
       if (s && s->has_parent_ref()) return true;
     }
     return false;
   }
 
   bool SimpleSequence_Selector::has_real_parent_ref()
   {
-    for (Simple_Selector* s : *this) {
+    for (Simple_Selector* s : elements()) {
       if (s && s->has_real_parent_ref()) return true;
     }
     return false;
@@ -527,12 +523,12 @@ namespace Sass {
   }
 
   SimpleSequence_Selector* Id_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
-  {
-    for (size_t i = 0, L = rhs->length(); i < L; ++i)
     {
-      Simple_Selector* rhs_i = (*rhs)[i];
+      for (size_t i = 0, L = rhs->length(); i < L; ++i)
+      {
+        Simple_Selector* rhs_i = (*rhs)[i];
       if (typeid(*rhs_i) == typeid(Id_Selector) && static_cast<Id_Selector*>(rhs_i)->name() != name()) {
-        return 0;
+          return 0;
       }
     }
     rhs->has_line_break(has_line_break());
@@ -1120,7 +1116,7 @@ namespace Sass {
 
   CommaSequence_Selector* CommaSequence_Selector::resolve_parent_refs(Context& ctx, CommaSequence_Selector* ps, bool implicit_parent)
   {
-    if (!this->has_parent_ref()/* && !implicit_parent*/) return this;
+    if (!this->has_parent_ref()) return this;
     CommaSequence_Selector* ss = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {
       CommaSequence_Selector* list = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
@@ -1143,7 +1139,7 @@ namespace Sass {
       return retval;
     }
 
-    // first resolve_parent_refs the tail (which may return an expanded list)
+    // first parentize the tail (which may return an expanded list)
     CommaSequence_Selector* tails = tail ? tail->resolve_parent_refs(ctx, parents, implicit_parent) : 0;
 
     if (head && head->length() > 0) {
@@ -1244,7 +1240,7 @@ namespace Sass {
         retval = this->tails(ctx, tails);
       }
 
-      for (Simple_Selector* ss : *head) {
+      for (Simple_Selector* ss : head->elements()) {
         if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
           if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
             if (parents) ws->selector(sl->resolve_parent_refs(ctx, parents, implicit_parent));
@@ -1413,7 +1409,7 @@ namespace Sass {
   }
 
   /* not used anymore - remove?
-  Placeholder_Selector* Selector::find_placeholder()
+  Selector_Placeholder* Selector::find_placeholder()
   {
     return 0;
   }*/
@@ -1445,15 +1441,15 @@ namespace Sass {
 
   bool CommaSequence_Selector::has_parent_ref()
   {
-    for (Sequence_Selector* s : *this) {
+    for (Sequence_Selector* s : elements()) {
       if (s && s->has_parent_ref()) return true;
     }
     return false;
   }
 
   bool CommaSequence_Selector::has_real_parent_ref()
   {
-    for (Sequence_Selector* s : *this) {
+    for (Sequence_Selector* s : elements()) {
       if (s && s->has_real_parent_ref()) return true;
     }
     return false;
@@ -1542,7 +1538,7 @@ namespace Sass {
       }
     }
 
-    // Creates the final CommaSequence_Selector by combining all the complex selectors
+    // Creates the final Selector_List by combining all the complex selectors
     CommaSequence_Selector* final_result = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     for (auto itr = unified_complex_selectors.begin(); itr != unified_complex_selectors.end(); ++itr) {
       *final_result << *itr;
@@ -1695,8 +1691,8 @@ namespace Sass {
 
   bool Ruleset::is_invisible() const {
     if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(selector())) {
-      for (size_t i = 0, L = sl->length(); i < L; ++i)
-        if (!(*sl)[i]->has_placeholder()) return false;
+    for (size_t i = 0, L = sl->length(); i < L; ++i)
+      if (!(*sl)[i]->has_placeholder()) return false;
     }
     return true;
   }

src/ast.hpp

@@ -311,7 +311,7 @@ namespace Sass {
     virtual void adjust_after_pushing(std::pair<Expression*, Expression*> p) { }
   public:
     Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression*>())
-    { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }
+    { /* elements_.reserve(s); */ list_.reserve(s); reset_duplicate_key(); }
     virtual ~Hashed();
     size_t length() const                  { return list_.size(); }
     bool empty() const                     { return list_.empty(); }
@@ -1224,7 +1224,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_;
     }
@@ -1352,10 +1352,12 @@ namespace Sass {
     {
       if (hash_ == 0) {
         hash_ = std::hash<double>()(value_);
-        for (const auto numerator : numerator_units())
+        for (const auto numerator : numerator_units()) {
           hash_combine(hash_, std::hash<std::string>()(numerator));
-        for (const auto denominator : denominator_units())
+        }
+        for (const auto denominator : denominator_units()) {
           hash_combine(hash_, std::hash<std::string>()(denominator));
+        }
       }
       return hash_;
     }
@@ -1506,7 +1508,7 @@ namespace Sass {
     {
       if (hash_ == 0) {
         for (auto string : elements())
-          hash_combine(hash_, string->hash());
+        { hash_combine(hash_, string->hash()); }
       }
       return hash_;
     }

src/check_nesting.cpp

@@ -69,7 +69,7 @@ namespace Sass {
     }
 
     if (b) {
-      for (auto n : *b) {
+      for (auto n : b->elements()) {
         n->perform(this);
       }
     }

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/debugger.hpp

@@ -394,7 +394,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     // std::vector<std::string>         files_;
-    for (auto imp : block->urls()) debug_ast(imp, ind + "@: ", env);
+    for (auto imp : block->urls()) { debug_ast(imp, ind + "@: ", env); }
     debug_ast(block->media_queries(), ind + "@@ ");
   } else if (dynamic_cast<Assignment*>(node)) {
     Assignment* block = dynamic_cast<Assignment*>(node);

src/eval.cpp

@@ -1053,7 +1053,7 @@ namespace Sass {
 
     if (Arguments* args = dynamic_cast<Arguments*>(ex)) {
       List* ll = SASS_MEMORY_NEW(ctx.mem, List, args->pstate(), 0, SASS_COMMA);
-      for(auto arg : *args) {
+      for(auto arg : args->elements()) {
         *ll << arg->value();
       }
       ll->is_interpolant(args->is_interpolant());
@@ -1089,7 +1089,7 @@ namespace Sass {
       List* ll = SASS_MEMORY_NEW(ctx.mem, List, l->pstate(), 0, l->separator());
       // this fixes an issue with bourbon sample, not really sure why
       // if (l->size() && dynamic_cast<Null*>((*l)[0])) { res += ""; }
-      for(auto item : *l) {
+      for(auto 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*>(item) != 0; // rl != ""
@@ -1351,11 +1351,11 @@ namespace Sass {
                                       true);
 
       if (ls && ls->is_arglist()) {
-        for (auto as : *ls) *arglist << as;
+        for (auto as : ls->elements()) { *arglist << as; }
       } else if (ms) {
         *aa << SASS_MEMORY_NEW(ctx.mem, Argument, splat->pstate(), ms, "", false, true);
       } else if (ls) {
-        for (auto as : *ls) *arglist << as;
+        for (auto as : ls->elements()) { *arglist << as; }
       } else {
         *arglist << splat;
       }

src/expand.cpp

@@ -238,7 +238,7 @@ namespace Sass {
     Expression* value = d->value()->perform(&eval);
     Block* bb = ab ? ab->perform(this)->block() : 0;
     if (!bb) {
-      if (!value || (value->is_invisible() && !d->is_important())) return 0;
+    if (!value || (value->is_invisible() && !d->is_important())) return 0;
     }
     Declaration* decl = SASS_MEMORY_NEW(ctx.mem, Declaration,
                                         d->pstate(),
@@ -615,7 +615,7 @@ namespace Sass {
         if (schema->has_parent_ref()) s = eval(schema);
       }
       if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
-        for (Sequence_Selector* cs : *sl) {
+        for (Sequence_Selector* cs : sl->elements()) {
           if (cs != NULL && cs->head() != NULL) {
             cs->head()->media_block(media_block_stack.back());
           }
@@ -699,7 +699,7 @@ namespace Sass {
 
 
     block_stack.push_back(trace_block);
-    for (auto bb : *body) {
+    for (auto bb : body->elements()) {
       Statement* ith = bb->perform(this);
       if (ith) *trace->block() << ith;
     }