Merge pull request #2338 from mgreter/perf-refactor/remove-textual

Remove Textual intermediate AST node

Author: mgreter

src/ast.cpp

@@ -1790,6 +1790,8 @@ namespace Sass {
 
   void Number::normalize(const std::string& prefered, bool strict)
   {
+    // no conversion if unit is empty
+    if (prefered.empty() && numerator_units_.size() == 0 && denominator_units_.size() == 0) return;
 
     // first make sure same units cancel each other out
     // it seems that a map table will fit nicely to do this
@@ -2428,7 +2430,6 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(Function_Call_Schema);
   IMPLEMENT_AST_OPERATORS(Block);
   IMPLEMENT_AST_OPERATORS(Content);
-  IMPLEMENT_AST_OPERATORS(Textual);
   IMPLEMENT_AST_OPERATORS(Trace);
   IMPLEMENT_AST_OPERATORS(Keyframe_Rule);
   IMPLEMENT_AST_OPERATORS(Bubble);

src/ast.hpp

@@ -1540,56 +1540,6 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  ////////////////////////////////////////////////////////////////////////////
-  // Textual (i.e., unevaluated) numeric data. Variants are distinguished with
-  // a type tag.
-  ////////////////////////////////////////////////////////////////////////////
-  class Textual : public Expression {
-  public:
-    enum Type { NUMBER, PERCENTAGE, DIMENSION, HEX };
-  private:
-    HASH_PROPERTY(Type, valtype)
-    HASH_CONSTREF(std::string, value)
-    size_t hash_;
-  public:
-    Textual(ParserState pstate, Type t, std::string val)
-    : Expression(pstate, DELAYED), valtype_(t), value_(val),
-      hash_(0)
-    { }
-    Textual(const Textual* ptr)
-    : Expression(ptr),
-      valtype_(ptr->valtype_),
-      value_(ptr->value_),
-      hash_(ptr->hash_)
-    { }
-
-    virtual bool operator==(const Expression& rhs) const
-    {
-      try
-      {
-        Textual_Ptr_Const e = Cast<Textual>(&rhs);
-        return e && value() == e->value() && type() == e->type();
-      }
-      catch (std::bad_cast&)
-      {
-        return false;
-      }
-      catch (...) { throw; }
-    }
-
-    virtual size_t hash()
-    {
-      if (hash_ == 0) {
-        hash_ = std::hash<std::string>()(value_);
-        hash_combine(hash_, std::hash<int>()(valtype_));
-      }
-      return hash_;
-    }
-
-    ATTACH_AST_OPERATIONS(Textual)
-    ATTACH_OPERATIONS()
-  };
-
   ////////////////////////////////////////////////
   // Numbers, percentages, dimensions, and colors.
   ////////////////////////////////////////////////

src/ast_fwd_decl.hpp

@@ -158,9 +158,6 @@ namespace Sass {
   class Variable;
   typedef Variable* Variable_Ptr;
   typedef Variable const* Variable_Ptr_Const;
-  class Textual;
-  typedef Textual* Textual_Ptr;
-  typedef Textual const* Textual_Ptr_Const;
   class Number;
   typedef Number* Number_Ptr;
   typedef Number const* Number_Ptr_Const;
@@ -321,7 +318,6 @@ namespace Sass {
   IMPL_MEM_OBJ(Custom_Warning);
   IMPL_MEM_OBJ(Custom_Error);
   IMPL_MEM_OBJ(Variable);
-  IMPL_MEM_OBJ(Textual);
   IMPL_MEM_OBJ(Number);
   IMPL_MEM_OBJ(Color);
   IMPL_MEM_OBJ(Boolean);

src/debugger.hpp

@@ -488,18 +488,6 @@ inline void debug_ast(AST_Node_Ptr node, std::string ind, Env* env)
     std::cerr << (block->is_invisible() ? " [INVISIBLE]" : "");
     std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
     for(const Statement_Obj& i : block->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Textual>(node)) {
-    Textual_Ptr expression = Cast<Textual>(node);
-    std::cerr << ind << "Textual " << expression;
-    std::cerr << " (" << pstate_source_position(node) << ")";
-    if (expression->valtype() == Textual::NUMBER) std::cerr << " [NUMBER]";
-    else if (expression->valtype() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
-    else if (expression->valtype() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
-    else if (expression->valtype() == Textual::HEX) std::cerr << " [HEX]";
-    std::cerr << " [" << expression->value() << "]";
-    std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
-    if (expression->is_delayed()) std::cerr << " [delayed]";
-    std::cerr << std::endl;
   } else if (Cast<Variable>(node)) {
     Variable_Ptr expression = Cast<Variable>(node);
     std::cerr << ind << "Variable " << expression;

src/eval.cpp

@@ -641,17 +641,15 @@ namespace Sass {
           std::string value(str->value());
           const char* start = value.c_str();
           if (Prelexer::sequence < Prelexer::dimension, Prelexer::end_of_file >(start) != 0) {
-            Textual_Obj l = SASS_MEMORY_NEW(Textual, b->pstate(), Textual::DIMENSION, str->value());
-            lhs = l->perform(this);
+            lhs = Parser::lexed_dimension(b->pstate(), str->value());
           }
         }
         // If possible upgrade RHS to a number (for string to number compare)
         if (String_Constant_Ptr str = Cast<String_Constant>(rhs)) {
           std::string value(str->value());
           const char* start = value.c_str();
           if (Prelexer::sequence < Prelexer::dimension, Prelexer::number >(start) != 0) {
-            Textual_Obj r = SASS_MEMORY_NEW(Textual, b->pstate(), Textual::DIMENSION, str->value());
-            rhs = r->perform(this);
+            rhs = Parser::lexed_dimension(b->pstate(), str->value());
           }
         }
       }
@@ -660,16 +658,6 @@ namespace Sass {
       Value_Obj v_l = Cast<Value>(lhs->perform(&to_value));
       Value_Obj v_r = Cast<Value>(rhs->perform(&to_value));
 
-      if (s2 && s2->has_interpolants() && s2->length()) {
-        Textual_Obj front = Cast<Textual>(s2->elements().front());
-        if (front && !front->is_interpolant())
-        {
-          // XXX: this is never hit via spec tests
-          schema_op = true;
-          rhs = front->perform(this);
-        }
-      }
-
       if (force_delay) {
         std::string str("");
         str += v_l->to_string(ctx.c_options);
@@ -1025,81 +1013,6 @@ namespace Sass {
     return value.detach();
   }
 
-  Expression_Ptr Eval::operator()(Textual_Ptr t)
-  {
-    using Prelexer::number;
-    Expression_Obj result = 0;
-    size_t L = t->value().length();
-    bool zero = !( (L > 0 && t->value().substr(0, 1) == ".") ||
-                   (L > 1 && t->value().substr(0, 2) == "0.") ||
-                   (L > 1 && t->value().substr(0, 2) == "-.")  ||
-                   (L > 2 && t->value().substr(0, 3) == "-0.")
-                 );
-
-    const std::string& text = t->value();
-    size_t num_pos = text.find_first_not_of(" \n\r\t");
-    if (num_pos == std::string::npos) num_pos = text.length();
-    size_t unit_pos = text.find_first_not_of("-+0123456789.", num_pos);
-    if (unit_pos == std::string::npos) unit_pos = text.length();
-    const std::string& num = text.substr(num_pos, unit_pos - num_pos);
-
-    switch (t->valtype())
-    {
-      case Textual::NUMBER:
-        result = SASS_MEMORY_NEW(Number,
-                                 t->pstate(),
-                                 sass_atof(num.c_str()),
-                                 "",
-                                 zero);
-        break;
-      case Textual::PERCENTAGE:
-        result = SASS_MEMORY_NEW(Number,
-                                 t->pstate(),
-                                 sass_atof(num.c_str()),
-                                 "%",
-                                 true);
-        break;
-      case Textual::DIMENSION:
-        result = SASS_MEMORY_NEW(Number,
-                                 t->pstate(),
-                                 sass_atof(num.c_str()),
-                                 Token(number(text.c_str())),
-                                 zero);
-        break;
-      case Textual::HEX: {
-        if (t->value().substr(0, 1) != "#") {
-          result = SASS_MEMORY_NEW(String_Quoted, t->pstate(), t->value());
-          break;
-        }
-        std::string hext(t->value().substr(1)); // chop off the '#'
-        if (hext.length() == 6) {
-          std::string r(hext.substr(0,2));
-          std::string g(hext.substr(2,2));
-          std::string b(hext.substr(4,2));
-          result = SASS_MEMORY_NEW(Color,
-                                   t->pstate(),
-                                   static_cast<double>(strtol(r.c_str(), NULL, 16)),
-                                   static_cast<double>(strtol(g.c_str(), NULL, 16)),
-                                   static_cast<double>(strtol(b.c_str(), NULL, 16)),
-                                   1, // alpha channel
-                                   t->value());
-        }
-        else {
-          result = SASS_MEMORY_NEW(Color,
-                                   t->pstate(),
-                                   static_cast<double>(strtol(std::string(2,hext[0]).c_str(), NULL, 16)),
-                                   static_cast<double>(strtol(std::string(2,hext[1]).c_str(), NULL, 16)),
-                                   static_cast<double>(strtol(std::string(2,hext[2]).c_str(), NULL, 16)),
-                                   1, // alpha channel
-                                   t->value());
-        }
-      } break;
-      default: break;
-    }
-    result->is_interpolant(t->is_interpolant());
-    return result.detach();
-  }
-
   Expression_Ptr Eval::operator()(Color_Ptr c)
   {
     return c;
@@ -1177,7 +1090,6 @@ namespace Sass {
     }
 
     // Value
-    // Textual
     // Function_Call
     // Selector_List
     // String_Quoted

src/eval.hpp

@@ -49,7 +49,6 @@ namespace Sass {
     Expression_Ptr operator()(Function_Call_Ptr);
     Expression_Ptr operator()(Function_Call_Schema_Ptr);
     Expression_Ptr operator()(Variable_Ptr);
-    Expression_Ptr operator()(Textual_Ptr);
     Expression_Ptr operator()(Number_Ptr);
     Expression_Ptr operator()(Color_Ptr);
     Expression_Ptr operator()(Boolean_Ptr);

src/inspect.cpp

@@ -519,11 +519,6 @@ namespace Sass {
     append_token(var->name(), var);
   }
 
-  void Inspect::operator()(Textual_Ptr txt)
-  {
-    append_token(txt->value(), txt);
-  }
-
   void Inspect::operator()(Number_Ptr n)
   {
 

src/inspect.hpp

@@ -56,7 +56,6 @@ namespace Sass {
     // virtual void operator()(Custom_Warning_Ptr);
     // virtual void operator()(Custom_Error_Ptr);
     virtual void operator()(Variable_Ptr);
-    virtual void operator()(Textual_Ptr);
     virtual void operator()(Number_Ptr);
     virtual void operator()(Color_Ptr);
     virtual void operator()(Boolean_Ptr);

src/operation.hpp

@@ -47,7 +47,6 @@ namespace Sass {
     virtual T operator()(Custom_Warning_Ptr x)         = 0;
     virtual T operator()(Custom_Error_Ptr x)           = 0;
     virtual T operator()(Variable_Ptr x)               = 0;
-    virtual T operator()(Textual_Ptr x)                = 0;
     virtual T operator()(Number_Ptr x)                 = 0;
     virtual T operator()(Color_Ptr x)                  = 0;
     virtual T operator()(Boolean_Ptr x)                = 0;
@@ -129,7 +128,6 @@ namespace Sass {
     T operator()(Custom_Warning_Ptr x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(Custom_Error_Ptr x)           { return static_cast<D*>(this)->fallback(x); }
     T operator()(Variable_Ptr x)               { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Textual_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(Number_Ptr x)                 { return static_cast<D*>(this)->fallback(x); }
     T operator()(Color_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
     T operator()(Boolean_Ptr x)                { return static_cast<D*>(this)->fallback(x); }