Merge pull request #1320 from xzyfer/perf/misc-improvements

Adds various performance improvements

Author: xzyfer

ast.cpp

@@ -681,17 +681,17 @@ namespace Sass {
 
   string Number::unit() const
   {
-    stringstream u;
+    string u;
     for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-      if (i) u << '*';
-      u << numerator_units_[i];
+      if (i) u += '*';
+      u += numerator_units_[i];
     }
-    if (!denominator_units_.empty()) u << '/';
+    if (!denominator_units_.empty()) u += '/';
     for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-      if (i) u << '*';
-      u << denominator_units_[i];
+      if (i) u += '*';
+      u += denominator_units_[i];
     }
-    return u.str();
+    return u;
   }
 
   bool Number::is_unitless()
@@ -882,17 +882,11 @@ namespace Sass {
 
   bool Number::operator== (Expression* rhs) const
   {
-    try
-    {
-      Number l(pstate_, value_, unit());
-      Number& r = dynamic_cast<Number&>(*rhs);
-      l.normalize(find_convertible_unit());
-      r.normalize(find_convertible_unit());
-      return l.unit() == r.unit() &&
-             l.value() == r.value();
+    if (Number* r = static_cast<Number*>(rhs)) {
+      return (value() == r->value()) &&
+             (numerator_units_ == r->numerator_units_) &&
+             (denominator_units_ == r->denominator_units_);
     }
-    catch (std::bad_cast&) {}
-    catch (...) { throw; }
     return false;
   }
 

ast.hpp

@@ -1698,7 +1698,7 @@ namespace Sass {
   /////////////////////////////////////////
   // Abstract base class for CSS selectors.
   /////////////////////////////////////////
-  class Selector : public AST_Node {
+  class Selector : public Expression {
     ADD_PROPERTY(bool, has_reference)
     ADD_PROPERTY(bool, has_placeholder)
     // line break before list separator
@@ -1712,14 +1712,14 @@ namespace Sass {
     ADD_PROPERTY(Media_Block*, media_block)
   public:
     Selector(ParserState pstate, bool r = false, bool h = false)
-    : AST_Node(pstate),
+    : Expression(pstate),
       has_reference_(r),
       has_placeholder_(h),
       has_line_feed_(false),
       has_line_break_(false),
       is_optional_(false),
       media_block_(0)
-    { }
+    { concrete_type(SELECTOR); }
     virtual ~Selector() = 0;
     // virtual Selector_Placeholder* find_placeholder();
     virtual unsigned long specificity() {

cssize.cpp

@@ -136,6 +136,11 @@ namespace Sass {
     return rules;
   }
 
+  Statement* Cssize::operator()(Null* m)
+  {
+    return 0;
+  }
+
   Statement* Cssize::operator()(Media_Block* m)
   {
     if (parent()->statement_type() == Statement::RULESET)
@@ -243,7 +248,6 @@ namespace Sass {
     At_Root_Block* mm = new (ctx.mem) At_Root_Block(m->pstate(),
                                                     wrapper_block,
                                                     m->expression());
-
     Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
     return bubble;
   }

cssize.hpp

@@ -56,6 +56,7 @@ namespace Sass {
     // Statement* operator()(Definition*);
     // Statement* operator()(Mixin_Call*);
     // Statement* operator()(Content*);
+    Statement* operator()(Null*);
 
     Statement* parent();
     vector<pair<bool, Block*>> slice_by_bubble(Statement*);

environment.hpp

@@ -1,29 +1,31 @@
 #ifndef SASS_ENVIRONMENT_H
 #define SASS_ENVIRONMENT_H
 
-#include <map>
 #include <string>
 #include <iostream>
+#include <unordered_map>
 
 #include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"
 #include "memory_manager.hpp"
 
 namespace Sass {
   using std::string;
-  using std::map;
+  using std::unordered_map;
   using std::cerr;
   using std::endl;
 
   template <typename T>
   class Environment {
     // TODO: test with unordered_map
-    map<string, T> local_frame_;
+    unordered_map<string, T> local_frame_;
     ADD_PROPERTY(Environment*, parent)
 
   public:
     Memory_Manager<AST_Node> mem;
-    Environment() : local_frame_(map<string, T>()), parent_(0) { }
+    Environment() : local_frame_(unordered_map<string, T>()), parent_(0) { }
+    Environment(Environment* env) : local_frame_(unordered_map<string, T>()), parent_(env) { }
+    Environment(Environment& env) : local_frame_(unordered_map<string, T>()), parent_(&env) { }
 
     // link parent to create a stack
     void link(Environment& env) { parent_ = &env; }
@@ -47,12 +49,12 @@ namespace Sass {
 
     // scope operates on the current frame
 
-    map<string, T>& local_frame() {
+    unordered_map<string, T>& local_frame() {
       return local_frame_;
     }
 
     bool has_local(const string& key) const
-    { return local_frame_.count(key); }
+    { return local_frame_.find(key) != local_frame_.end(); }
 
     T& get_local(const string& key)
     { return local_frame_[key]; }
@@ -147,7 +149,7 @@ namespace Sass {
     #ifdef DEBUG
     void print()
     {
-      for (typename map<string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
+      for (typename unordered_map<string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
         cerr << i->first << endl;
       }
       if (parent_) {

eval.cpp

@@ -829,12 +829,7 @@ namespace Sass {
 
   Expression* Eval::operator()(Number* n)
   {
-    n->normalize();
-    // behave according to as ruby sass (add leading zero)
-    return new (ctx.mem) Number(n->pstate(),
-                                n->value(),
-                                n->unit(),
-                                true);
+    return n;
   }
 
   Expression* Eval::operator()(Boolean* b)
@@ -1109,8 +1104,11 @@ namespace Sass {
       } break;
 
       case Expression::NUMBER: {
-        return *static_cast<Number*>(lhs) ==
-               *static_cast<Number*>(rhs);
+        Number* l = static_cast<Number*>(lhs);
+        Number* r = static_cast<Number*>(rhs);
+        return (l->value() == r->value()) &&
+               (l->numerator_units() == r->numerator_units()) &&
+               (l->denominator_units() == r->denominator_units());
       } break;
 
       case Expression::COLOR: {

lexer.hpp

@@ -142,26 +142,69 @@ namespace Sass {
     // Tries supplied matchers in order.
     // Succeeds if one of them succeeds.
     // Regex equivalent: /(?:FOO|BAR)/
-    template <prelexer... mxs>
+    template <const prelexer mx>
     const char* alternatives(const char* src) {
       const char* rslt;
-      for (prelexer mx : { mxs... }) {
-        if ((rslt = mx(src))) return rslt;
-      }
+      if ((rslt = mx(src))) return rslt;
       return 0;
     }
+    template <const prelexer mx1, const prelexer mx2>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      if ((rslt = mx1(src))) return rslt;
+      if ((rslt = mx2(src))) return rslt;
+      return 0;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer mx3>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      if ((rslt = mx1(src))) return rslt;
+      if ((rslt = mx2(src))) return rslt;
+      if ((rslt = mx3(src))) return rslt;
+      return 0;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer mx3, const prelexer mx4, const prelexer... mxs>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      if ((rslt = mx1(src))) return rslt;
+      if ((rslt = mx2(src))) return rslt;
+      if ((rslt = mx3(src))) return rslt;
+      return alternatives<mx4, mxs...>(src);
+    }
 
     // Tries supplied matchers in order.
     // Succeeds if all of them succeeds.
     // Regex equivalent: /(?:FOO)(?:BAR)/
-    template <prelexer... mxs>
+    template <const prelexer mx1>
     const char* sequence(const char* src) {
       const char* rslt = src;
-      for (prelexer mx : { mxs... }) {
-        if (!(rslt = mx(rslt))) return 0;
-      }
+      if (!(rslt = mx1(rslt))) return 0;
       return rslt;
     }
+    template <const prelexer mx1, const prelexer mx2>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      if (!(rslt = mx1(rslt))) return 0;
+      if (!(rslt = mx2(rslt))) return 0;
+      return rslt;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer mx3>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      if (!(rslt = mx1(rslt))) return 0;
+      if (!(rslt = mx2(rslt))) return 0;
+      if (!(rslt = mx3(rslt))) return 0;
+      return rslt;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer mx3, const prelexer mx4, const prelexer... mxs>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      if (!(rslt = mx1(rslt))) return 0;
+      if (!(rslt = mx2(rslt))) return 0;
+      if (!(rslt = mx3(rslt))) return 0;
+      return sequence<mx4, mxs...>(rslt);
+    }
+
 
     // Match a pattern or not. Always succeeds.
     // Regex equivalent: /(?:literal)?/

output.cpp

@@ -221,10 +221,8 @@ namespace Sass {
     q->perform(this);
     append_scope_opener();
 
-    Selector* e = f->selector();
-    if (e && b->has_non_hoistable()) {
+    if (b->has_non_hoistable()) {
       // JMA - hoisted, output the non-hoistable in a nested block, followed by the hoistable
-      e->perform(this);
       append_scope_opener();
 
       for (size_t i = 0, L = b->length(); i < L; ++i) {

parser.cpp

@@ -511,11 +511,17 @@ namespace Sass {
     return ruleset;
   }
 
+  // parse a selector schema that will be evaluated in the eval stage
+  // uses a string schema internally to do the actual schema handling
+  // in the eval stage we will be re-parse it into an actual selector
   Selector_Schema* Parser::parse_selector_schema(const char* end_of_selector)
   {
+    // move up to the start
     lex< optional_spaces >();
     const char* i = position;
+    // selector schema re-uses string schema implementation
     String_Schema* schema = new (ctx.mem) String_Schema(pstate);
+    // process until end
     while (i < end_of_selector) {
       // try to parse mutliple interpolants
       if (const char* p = find_first_in_interval< exactly<hash_lbrace> >(i, end_of_selector)) {
@@ -525,25 +531,34 @@ namespace Sass {
         if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
           css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
         }
+        // skip over all nested inner interpolations up to our own delimiter
         const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p + 2, end_of_selector);
+        // pass inner expression to the parser to resolve nested interpolations
         Expression* interpolant = Parser::from_c_str(p+2, j, ctx, pstate).parse_list();
+        // set status on the list expression
         interpolant->is_interpolant(true);
+        // add to the string schema
         (*schema) << interpolant;
+        // advance position
         i = j;
       }
       // no more interpolants have been found
       // add the last segment if there is one
       else {
+        // make sure to add the last bits of the string up to the end (if any)
         if (i < end_of_selector) (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, end_of_selector));
         break;
       }
     }
+    // EO until eos
     position = end_of_selector;
     Selector_Schema* selector_schema = new (ctx.mem) Selector_Schema(pstate, schema);
     selector_schema->media_block(last_media_block);
     selector_schema->last_block(block_stack.back());
+    // return parsed result
     return selector_schema;
   }
+  // EO parse_selector_schema
 
   Selector_List* Parser::parse_selector_group()
   {