sassc4 2.4.0

data/ext/libsass/src/eval.hpp

@@ -0,0 +1,110 @@
+#ifndef SASS_EVAL_H
+#define SASS_EVAL_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include "ast.hpp"
+
+#include "context.hpp"
+#include "listize.hpp"
+#include "operation.hpp"
+#include "environment.hpp"
+
+namespace Sass {
+
+  class Expand;
+  class Context;
+
+  class Eval : public Operation_CRTP<Expression*, Eval> {
+
+   public:
+    Expand& exp;
+    Context& ctx;
+    Backtraces& traces;
+    Eval(Expand& exp);
+    ~Eval();
+
+    bool force;
+    bool is_in_comment;
+    bool is_in_selector_schema;
+
+    Boolean_Obj bool_true;
+    Boolean_Obj bool_false;
+
+    Env* environment();
+    EnvStack& env_stack();
+    const sass::string cwd();
+    CalleeStack& callee_stack();
+    struct Sass_Inspect_Options& options();
+    struct Sass_Compiler* compiler();
+
+    // for evaluating function bodies
+    Expression* operator()(Block*);
+    Expression* operator()(Assignment*);
+    Expression* operator()(If*);
+    Expression* operator()(ForRule*);
+    Expression* operator()(EachRule*);
+    Expression* operator()(WhileRule*);
+    Expression* operator()(Return*);
+    Expression* operator()(WarningRule*);
+    Expression* operator()(ErrorRule*);
+    Expression* operator()(DebugRule*);
+
+    Expression* operator()(List*);
+    Expression* operator()(Map*);
+    Expression* operator()(Binary_Expression*);
+    Expression* operator()(Unary_Expression*);
+    Expression* operator()(Function_Call*);
+    Expression* operator()(Variable*);
+    Expression* operator()(Number*);
+    Expression* operator()(Color_RGBA*);
+    Expression* operator()(Color_HSLA*);
+    Expression* operator()(Boolean*);
+    Expression* operator()(String_Schema*);
+    Expression* operator()(String_Quoted*);
+    Expression* operator()(String_Constant*);
+    Media_Query* operator()(Media_Query*);
+    Expression* operator()(Media_Query_Expression*);
+    Expression* operator()(At_Root_Query*);
+    Expression* operator()(SupportsOperation*);
+    Expression* operator()(SupportsNegation*);
+    Expression* operator()(SupportsDeclaration*);
+    Expression* operator()(Supports_Interpolation*);
+    Expression* operator()(Null*);
+    Expression* operator()(Argument*);
+    Expression* operator()(Arguments*);
+    Expression* operator()(Comment*);
+
+    // these will return selectors
+    SelectorList* operator()(SelectorList*);
+    SelectorList* operator()(ComplexSelector*);
+    CompoundSelector* operator()(CompoundSelector*);
+    SelectorComponent* operator()(SelectorComponent*);
+    SimpleSelector* operator()(SimpleSelector* s);
+    PseudoSelector* operator()(PseudoSelector* s);
+
+    // they don't have any specific implementation (yet)
+    IDSelector* operator()(IDSelector* s) { return s; };
+    ClassSelector* operator()(ClassSelector* s) { return s; };
+    TypeSelector* operator()(TypeSelector* s) { return s; };
+    AttributeSelector* operator()(AttributeSelector* s) { return s; };
+    PlaceholderSelector* operator()(PlaceholderSelector* s) { return s; };
+
+    // actual evaluated selectors
+    SelectorList* operator()(Selector_Schema*);
+    Expression* operator()(Parent_Reference*);
+
+    // generic fallback
+    template <typename U>
+    Expression* fallback(U x)
+    { return Cast<Expression>(x); }
+
+  private:
+    void interpolation(Context& ctx, sass::string& res, ExpressionObj ex, bool into_quotes, bool was_itpl = false);
+
+  };
+
+}
+
+#endif

data/ext/libsass/src/eval_selectors.cpp

@@ -0,0 +1,75 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include "expand.hpp"
+#include "eval.hpp"
+#include "ast.hpp"
+
+
+namespace Sass {
+
+  SelectorList* Eval::operator()(SelectorList* s)
+  {
+    sass::vector<SelectorListObj> rv;
+    SelectorListObj sl = SASS_MEMORY_NEW(SelectorList, s->pstate());
+    for (size_t i = 0, iL = s->length(); i < iL; ++i) {
+      rv.push_back(operator()(s->get(i)));
+    }
+
+    // we should actually permutate parent first
+    // but here we have permutated the selector first
+    size_t round = 0;
+    while (round != sass::string::npos) {
+      bool abort = true;
+      for (size_t i = 0, iL = rv.size(); i < iL; ++i) {
+        if (rv[i]->length() > round) {
+          sl->append((*rv[i])[round]);
+          abort = false;
+        }
+      }
+      if (abort) {
+        round = sass::string::npos;
+      }
+      else {
+        ++round;
+      }
+
+    }
+    return sl.detach();
+  }
+
+  SelectorComponent* Eval::operator()(SelectorComponent* s)
+  {
+    return {};
+  }
+
+  SelectorList* Eval::operator()(ComplexSelector* s)
+  {
+    bool implicit_parent = !exp.old_at_root_without_rule;
+    if (is_in_selector_schema) exp.pushNullSelector();
+    SelectorListObj other = s->resolve_parent_refs(
+      exp.getOriginalStack(), traces, implicit_parent);
+    if (is_in_selector_schema) exp.popNullSelector();
+
+    for (size_t i = 0; i < other->length(); i++) {
+      ComplexSelectorObj sel = other->at(i);
+      for (size_t n = 0; n < sel->length(); n++) {
+        if (CompoundSelectorObj comp = Cast<CompoundSelector>(sel->at(n))) {
+          sel->at(n) = operator()(comp);
+        }
+      }
+    }
+
+    return other.detach();
+  }
+
+  CompoundSelector* Eval::operator()(CompoundSelector* s)
+  {
+    for (size_t i = 0; i < s->length(); i++) {
+      SimpleSelector* ss = s->at(i);
+      // skip parents here (called via resolve_parent_refs)
+      s->at(i) = Cast<SimpleSelector>(ss->perform(this));
+    }
+    return s;
+  }
+}