Improve compiler compatibility for early gcc versions

mgreter · mgreter · commit f348f716cebc · 2016-07-03T01:34:38.000+02:00
diff --git a/src/ast.cpp b/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()
   {
@@ -151,7 +147,7 @@ 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;
@@ -508,12 +504,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());
@@ -1093,7 +1089,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());
@@ -1110,7 +1106,7 @@ namespace Sass {
     Sequence_Selector* tail = this->tail();
     SimpleSequence_Selector* head = this->head();
 
-    // 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) {
@@ -1189,7 +1185,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));
@@ -1358,7 +1354,7 @@ namespace Sass {
   }
 
   /* not used anymore - remove?
-  Placeholder_Selector* Selector::find_placeholder()
+  Selector_Placeholder* Selector::find_placeholder()
   {
     return 0;
   }*/
@@ -1390,7 +1386,7 @@ 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;
@@ -1470,7 +1466,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;
diff --git a/src/ast.hpp b/src/ast.hpp
@@ -309,7 +309,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(); }
@@ -1231,7 +1231,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_;
     }
@@ -1359,10 +1359,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_;
     }
@@ -1512,7 +1514,7 @@ namespace Sass {
     {
       if (hash_ == 0) {
         for (auto string : elements())
-          hash_combine(hash_, string->hash());
+        { hash_combine(hash_, string->hash()); }
       }
       return hash_;
     }
diff --git a/src/check_nesting.cpp b/src/check_nesting.cpp
@@ -69,7 +69,7 @@ namespace Sass {
     }
 
     if (b) {
-      for (auto n : *b) {
+      for (auto n : b->elements()) {
         n->perform(this);
       }
     }
diff --git a/src/context.cpp b/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);
diff --git a/src/debugger.hpp b/src/debugger.hpp
@@ -387,7 +387,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);
diff --git a/src/eval.cpp b/src/eval.cpp
@@ -1036,7 +1036,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());
@@ -1072,7 +1072,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 != ""
@@ -1333,11 +1333,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;
       }
diff --git a/src/expand.cpp b/src/expand.cpp
@@ -234,7 +234,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(),
@@ -611,7 +611,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());
           }
@@ -689,7 +689,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;
     }
diff --git a/src/extend.cpp b/src/extend.cpp
@@ -94,7 +94,7 @@ namespace Sass {
     return os;
   }
 
-  // Print a string representation of a SimpleSequence_Selector
+  // Print a string representation of a Compound_Selector
   static void printSimpleSelector(Simple_Selector* pSimpleSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
@@ -112,12 +112,12 @@ namespace Sass {
     }
   }
 
-  // Print a string representation of a SimpleSequence_Selector
+  // Print a string representation of a Compound_Selector
     typedef std::pair<SimpleSequence_Selector*, Sequence_Selector*> SelsNewSeqPair;
     typedef std::vector<SelsNewSeqPair> SelsNewSeqPairCollection;
 
 
-  // Print a string representation of a SimpleSequence_Selector
+  // Print a string representation of a Compound_Selector
   static void printCompoundSelector(SimpleSequence_Selector* pCompoundSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
@@ -169,7 +169,7 @@ namespace Sass {
   }
 
 
-  // Print a string representation of a Sequence_Selector
+  // Print a string representation of a Complex_Selector
   static void printComplexSelector(Sequence_Selector* pComplexSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
@@ -288,7 +288,7 @@ namespace Sass {
 #endif
 
   static bool parentSuperselector(Sequence_Selector* pOne, Sequence_Selector* pTwo, Context& ctx) {
-    // TODO: figure out a better way to create a Sequence_Selector from scratch
+    // TODO: figure out a better way to create a Complex_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
     Position noPosition(-1, -1, -1);
     Element_Selector fakeParent(ParserState("[FAKE]"), "temp");
@@ -651,7 +651,7 @@ namespace Sass {
 
 
   static bool parentSuperselector(const Node& one, const Node& two, Context& ctx) {
-    // TODO: figure out a better way to create a Sequence_Selector from scratch
+    // TODO: figure out a better way to create a Complex_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
     Position noPosition(-1, -1, -1);
     Element_Selector fakeParent(ParserState("[FAKE]"), "temp");
@@ -1588,7 +1588,7 @@ namespace Sass {
       Sequence_Selector* pExtComplexSelector = &seq;    // The selector up to where the @extend is (ie, the thing to merge)
       SimpleSequence_Selector* pExtCompoundSelector = pSels; // All the simple selectors to be replaced from the current compound selector from all extensions
 
-      // TODO: This can return a SimpleSequence_Selector with no elements. Should that just be returning NULL?
+      // TODO: This can return a Compound_Selector with no elements. Should that just be returning NULL?
       // RUBY: self_without_sel = Sass::Util.array_minus(members, sels)
       SimpleSequence_Selector* pSelectorWithoutExtendSelectors = pSelector->minus(pExtCompoundSelector, ctx);
 
@@ -1618,8 +1618,8 @@ namespace Sass {
       // next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?
 
       // TODO: This seems a little fishy to me. See if it causes any problems. From the ruby, we should be able to just
-      // get rid of the last SimpleSequence_Selector and replace it with this one. I think the reason this code is more
-      // complex is that Sequence_Selector contains a combinator, but in ruby combinators have already been filtered
+      // get rid of the last Compound_Selector and replace it with this one. I think the reason this code is more
+      // complex is that Complex_Selector contains a combinator, but in ruby combinators have already been filtered
       // out and aren't operated on.
       Sequence_Selector* pNewSelector = pExtComplexSelector->cloneFully(ctx); // ->first();
 
@@ -1642,7 +1642,7 @@ namespace Sass {
 
 
       // if (pSelector && pSelector->has_line_feed()) pNewInnerMost->has_line_feed(true);
-      // Set the sources on our new Sequence_Selector to the sources of this simple sequence plus the thing we're extending.
+      // Set the sources on our new Complex_Selector to the sources of this simple sequence plus the thing we're extending.
       DEBUG_PRINTLN(EXTEND_COMPOUND, "SOURCES SETTING ON NEW SEQ: " << complexSelectorToNode(pNewSelector, ctx))
 
       DEBUG_EXEC(EXTEND_COMPOUND, SourcesSet oldSet = pNewSelector->sources(); printSourcesSet(oldSet, ctx, "SOURCES NEW SEQ BEGIN: "))
@@ -1723,7 +1723,7 @@ namespace Sass {
 
       if (pHead) {
         if (seen.find(*pHead) == seen.end()) {
-          for (Simple_Selector* pSimple : *pHead) {
+          for (Simple_Selector* pSimple : pHead->elements()) {
             if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(pSimple)) {
               if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
                 for (Sequence_Selector* cs : sl->elements()) {
@@ -1809,7 +1809,7 @@ namespace Sass {
       // RUBY: next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
       if (!sseqOrOp.isSelector()) {
         // Wrap our Combinator in two collections to match ruby. This is essentially making a collection Node
-        // with one collection child. The collection child represents a Sequence_Selector that is only a combinator.
+        // with one collection child. The collection child represents a Complex_Selector that is only a combinator.
         Node outer = Node::createCollection();
         Node inner = Node::createCollection();
         outer.collection()->push_back(inner);
@@ -1826,7 +1826,7 @@ namespace Sass {
       DEBUG_PRINTLN(EXTEND_COMPLEX, "EXTENDED: " << extended)
 
 
-      // Prepend the SimpleSequence_Selector based on the choices logic; choices seems to be extend but with an ruby Array instead of a Sequence
+      // Prepend the Compound_Selector based on the choices logic; choices seems to be extend but with an ruby Array instead of a Sequence
       // due to the member mapping: choices = extended.map {|seq| seq.members}
       Sequence_Selector* pJustCurrentCompoundSelector = sseqOrOp.selector();
 
@@ -1961,7 +1961,7 @@ namespace Sass {
     pNewSelectors = remove_placeholders.remove_placeholders(pNewSelectors);
 
     // unwrap all wrapped selectors with inner lists
-    for (Sequence_Selector* cur : *pNewSelectors) {
+    for (Sequence_Selector* cur : pNewSelectors->elements()) {
       // process tails
       while (cur) {
         // process header
@@ -1970,7 +1970,7 @@ namespace Sass {
           recseen.insert(*cur->head());
           // create a copy since we add multiple items if stuff get unwrapped
           SimpleSequence_Selector* cpy_head = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, cur->pstate());
-          for (Simple_Selector* hs : *cur->head()) {
+          for (Simple_Selector* hs : cur->head()->elements()) {
             if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(hs)) {
               if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
                 // special case for ruby ass
@@ -2092,7 +2092,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) {
         Sequence_Selector* sel = it.first ? it.first->first() : NULL;
         SimpleSequence_Selector* ext = it.second ? it.second : NULL;
         if (ext && (ext->extended() || ext->is_optional())) continue;
@@ -2127,7 +2128,7 @@ namespace Sass {
 
   void Extend::operator()(Directive* a)
   {
-    // CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(a->selector());
+    // Selector_List* ls = dynamic_cast<Selector_List*>(a->selector());
     // selector_stack.push_back(ls);
     if (a->block()) a->block()->perform(this);
     // exp.selector_stack.pop_back();
diff --git a/src/functions.cpp b/src/functions.cpp
diff --git a/src/parser.cpp b/src/parser.cpp
diff --git a/src/remove_placeholders.cpp b/src/remove_placeholders.cpp

Original file line number	Diff line number	Diff line change
`@@ -28,27 +28,23 @@ namespace Sass {`
`28`	`28`	`dynamic_cast<Supports_Operator*>(cond);`
`29`	`29`	`}`
`30`	`30`
`31`		`- std::string & str_ltrim(std::string & str)`
	`31`	`+ void str_rtrim(std::string& s, const std::string& delimiters = " \f\n\r\t\v" )`
`32`	`32`	`{`
`33`		`- auto it2 = std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );`
`34`		`- str.erase( str.begin() , it2);`
`35`		`- return str;`
	`33`	`+ s.erase( s.find_last_not_of( delimiters ) + 1 );`
`36`	`34`	`}`
`37`	`35`
`38`		`- std::string & str_rtrim(std::string & str)`
	`36`	`+ void str_ltrim(std::string& s, const std::string& delimiters = " \f\n\r\t\v" )`
`39`	`37`	`{`
`40`		`- auto it1 = std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );`
`41`		`- str.erase( it1.base() , str.end() );`
`42`		`- return str;`
	`38`	`+ s.erase( 0, s.find_first_not_of( delimiters ) );`
`43`	`39`	`}`
`44`	`40`
`45`	`41`	`void String_Constant::rtrim()`
`46`	`42`	`{`
`47`		`- value_ = str_rtrim(value_);`
	`43`	`+ str_rtrim(value_);`
`48`	`44`	`}`
`49`	`45`	`void String_Constant::ltrim()`
`50`	`46`	`{`
`51`		`- value_ = str_ltrim(value_);`
	`47`	`+ str_ltrim(value_);`
`52`	`48`	`}`
`53`	`49`	`void String_Constant::trim()`
`54`	`50`	`{`
`@@ -151,7 +147,7 @@ namespace Sass {`
`151`	`147`
`152`	`148`	`bool SimpleSequence_Selector::has_parent_ref()`
`153`	`149`	`{`
`154`		`- for (Simple_Selector* s : *this) {`
	`150`	`+ for (Simple_Selector* s : elements()) {`
`155`	`151`	`if (s && s->has_parent_ref()) return true;`
`156`	`152`	`}`
`157`	`153`	`return false;`
`@@ -508,12 +504,12 @@ namespace Sass {`
`508`	`504`	`}`
`509`	`505`
`510`	`506`	`SimpleSequence_Selector* Id_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)`
`511`		`- {`
`512`		`- for (size_t i = 0, L = rhs->length(); i < L; ++i)`
`513`	`507`	`{`
`514`		`- Simple_Selector* rhs_i = (*rhs)[i];`
	`508`	`+ for (size_t i = 0, L = rhs->length(); i < L; ++i)`
	`509`	`+ {`
	`510`	`+ Simple_Selector* rhs_i = (*rhs)[i];`
`515`	`511`	`if (typeid(rhs_i) == typeid(Id_Selector) && static_cast<Id_Selector>(rhs_i)->name() != name()) {`
`516`		`- return 0;`
	`512`	`+ return 0;`
`517`	`513`	`}`
`518`	`514`	`}`
`519`	`515`	`rhs->has_line_break(has_line_break());`
`@@ -1093,7 +1089,7 @@ namespace Sass {`
`1093`	`1089`
`1094`	`1090`	`CommaSequence_Selector* CommaSequence_Selector::resolve_parent_refs(Context& ctx, CommaSequence_Selector* ps, bool implicit_parent)`
`1095`	`1091`	`{`
`1096`		`- if (!this->has_parent_ref()/* && !implicit_parent*/) return this;`
	`1092`	`+ if (!this->has_parent_ref()) return this;`
`1097`	`1093`	`CommaSequence_Selector* ss = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());`
`1098`	`1094`	`for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {`
`1099`	`1095`	`CommaSequence_Selector* list = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());`
`@@ -1110,7 +1106,7 @@ namespace Sass {`
`1110`	`1106`	`Sequence_Selector* tail = this->tail();`
`1111`	`1107`	`SimpleSequence_Selector* head = this->head();`
`1112`	`1108`
`1113`		`- // first resolve_parent_refs the tail (which may return an expanded list)`
	`1109`	`+ // first parentize the tail (which may return an expanded list)`
`1114`	`1110`	`CommaSequence_Selector* tails = tail ? tail->resolve_parent_refs(ctx, parents, implicit_parent) : 0;`
`1115`	`1111`
`1116`	`1112`	`if (head && head->length() > 0) {`
`@@ -1189,7 +1185,7 @@ namespace Sass {`
`1189`	`1185`	`retval = this->tails(ctx, tails);`
`1190`	`1186`	`}`
`1191`	`1187`
`1192`		`- for (Simple_Selector* ss : *head) {`
	`1188`	`+ for (Simple_Selector* ss : head->elements()) {`
`1193`	`1189`	`if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {`
`1194`	`1190`	`if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {`
`1195`	`1191`	`if (parents) ws->selector(sl->resolve_parent_refs(ctx, parents, implicit_parent));`
`@@ -1358,7 +1354,7 @@ namespace Sass {`
`1358`	`1354`	`}`
`1359`	`1355`
`1360`	`1356`	`/* not used anymore - remove?`
`1361`		`- Placeholder_Selector* Selector::find_placeholder()`
	`1357`	`+ Selector_Placeholder* Selector::find_placeholder()`
`1362`	`1358`	`{`
`1363`	`1359`	`return 0;`
`1364`	`1360`	`}*/`
`@@ -1390,7 +1386,7 @@ namespace Sass {`
`1390`	`1386`
`1391`	`1387`	`bool CommaSequence_Selector::has_parent_ref()`
`1392`	`1388`	`{`
`1393`		`- for (Sequence_Selector* s : *this) {`
	`1389`	`+ for (Sequence_Selector* s : elements()) {`
`1394`	`1390`	`if (s && s->has_parent_ref()) return true;`
`1395`	`1391`	`}`
`1396`	`1392`	`return false;`
`@@ -1470,7 +1466,7 @@ namespace Sass {`
`1470`	`1466`	`}`
`1471`	`1467`	`}`
`1472`	`1468`
`1473`		`- // Creates the final CommaSequence_Selector by combining all the complex selectors`
	`1469`	`+ // Creates the final Selector_List by combining all the complex selectors`
`1474`	`1470`	`CommaSequence_Selector* final_result = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());`
`1475`	`1471`	`for (auto itr = unified_complex_selectors.begin(); itr != unified_complex_selectors.end(); ++itr) {`
`1476`	`1472`	`final_result << itr;`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ namespace Sass {`
`309`	`309`	`virtual void adjust_after_pushing(std::pair<Expression, Expression> p) { }`
`310`	`310`	`public:`
`311`	`311`	`Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression*>())`
`312`		`- { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }`
	`312`	`+ { /* elements_.reserve(s); */ list_.reserve(s); reset_duplicate_key(); }`
`313`	`313`	`virtual ~Hashed();`
`314`	`314`	`size_t length() const { return list_.size(); }`
`315`	`315`	`bool empty() const { return list_.empty(); }`
`@@ -1231,7 +1231,7 @@ namespace Sass {`
`1231`	`1231`	`if (hash_ == 0) {`
`1232`	`1232`	`hash_ = std::hash<std::string>()(name());`
`1233`	`1233`	`for (auto argument : arguments()->elements())`
`1234`		`- hash_combine(hash_, argument->hash());`
	`1234`	`+ { hash_combine(hash_, argument->hash()); }`
`1235`	`1235`	`}`
`1236`	`1236`	`return hash_;`
`1237`	`1237`	`}`
`@@ -1359,10 +1359,12 @@ namespace Sass {`
`1359`	`1359`	`{`
`1360`	`1360`	`if (hash_ == 0) {`
`1361`	`1361`	`hash_ = std::hash<double>()(value_);`
`1362`		`- for (const auto numerator : numerator_units())`
	`1362`	`+ for (const auto numerator : numerator_units()) {`
`1363`	`1363`	`hash_combine(hash_, std::hash<std::string>()(numerator));`
`1364`		`- for (const auto denominator : denominator_units())`
	`1364`	`+ }`
	`1365`	`+ for (const auto denominator : denominator_units()) {`
`1365`	`1366`	`hash_combine(hash_, std::hash<std::string>()(denominator));`
	`1367`	`+ }`
`1366`	`1368`	`}`
`1367`	`1369`	`return hash_;`
`1368`	`1370`	`}`
`@@ -1512,7 +1514,7 @@ namespace Sass {`
`1512`	`1514`	`{`
`1513`	`1515`	`if (hash_ == 0) {`
`1514`	`1516`	`for (auto string : elements())`
`1515`		`- hash_combine(hash_, string->hash());`
	`1517`	`+ { hash_combine(hash_, string->hash()); }`
`1516`	`1518`	`}`
`1517`	`1519`	`return hash_;`
`1518`	`1520`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ namespace Sass {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`if (b) {`
`72`		`- for (auto n : *b) {`
	`72`	`+ for (auto n : b->elements()) {`
`73`	`73`	`n->perform(this);`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ namespace Sass {`
`234`	`234`	`Expression* value = d->value()->perform(&eval);`
`235`	`235`	`Block* bb = ab ? ab->perform(this)->block() : 0;`
`236`	`236`	`if (!bb) {`
`237`		`- if (!value \|\| (value->is_invisible() && !d->is_important())) return 0;`
	`237`	`+ if (!value \|\| (value->is_invisible() && !d->is_important())) return 0;`
`238`	`238`	`}`
`239`	`239`	`Declaration* decl = SASS_MEMORY_NEW(ctx.mem, Declaration,`
`240`	`240`	`d->pstate(),`
`@@ -611,7 +611,7 @@ namespace Sass {`
`611`	`611`	`if (schema->has_parent_ref()) s = eval(schema);`
`612`	`612`	`}`
`613`	`613`	`if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {`
`614`		`- for (Sequence_Selector* cs : *sl) {`
	`614`	`+ for (Sequence_Selector* cs : sl->elements()) {`
`615`	`615`	`if (cs != NULL && cs->head() != NULL) {`
`616`	`616`	`cs->head()->media_block(media_block_stack.back());`
`617`	`617`	`}`
`@@ -689,7 +689,7 @@ namespace Sass {`
`689`	`689`
`690`	`690`
`691`	`691`	`block_stack.push_back(trace_block);`
`692`		`- for (auto bb : *body) {`
	`692`	`+ for (auto bb : body->elements()) {`
`693`	`693`	`Statement* ith = bb->perform(this);`
`694`	`694`	`if (ith) *trace->block() << ith;`
`695`	`695`	`}`