sassc 1.11.4 → 1.12.0

data/ext/libsass/src/context.hpp

@@ -15,6 +15,7 @@
 #include "environment.hpp"
 #include "source_map.hpp"
 #include "subset_map.hpp"
+#include "backtrace.hpp"
 #include "output.hpp"
 #include "plugins.hpp"
 #include "file.hpp"
@@ -43,6 +44,9 @@ namespace Sass {
     Plugins plugins;
     Output emitter;
 
+    // generic ast node garbage container
+    // used to avoid possible circular refs
+    std::vector<AST_Node_Obj> ast_gc;
     // resources add under our control
     // these are guaranteed to be freed
     std::vector<char*> strings;
@@ -50,6 +54,8 @@ namespace Sass {
     std::map<const std::string, StyleSheet> sheets;
     Subset_Map subset_map;
     std::vector<Sass_Import_Entry> import_stack;
+    std::vector<Sass_Callee> callee_stack;
+    std::vector<Backtrace> traces;
 
     struct Sass_Compiler* c_compiler;
 
@@ -61,6 +67,7 @@ namespace Sass {
 
     std::vector<std::string> plugin_paths; // relative paths to load plugins
     std::vector<std::string> include_paths; // lookup paths for includes
+    std::vector<std::string> extensions; // lookup extensions for imports`
 
 
 
@@ -90,7 +97,8 @@ namespace Sass {
     virtual char* render(Block_Obj root);
     virtual char* render_srcmap();
 
-    void register_resource(const Include&, const Resource&, ParserState* = 0);
+    void register_resource(const Include&, const Resource&);
+    void register_resource(const Include&, const Resource&, ParserState&);
     std::vector<Include> find_includes(const Importer& import);
     Include load_import(const Importer&, ParserState pstate);
 
@@ -102,6 +110,8 @@ namespace Sass {
     void collect_plugin_paths(string_list* paths_array);
     void collect_include_paths(const char* paths_str);
     void collect_include_paths(string_list* paths_array);
+    void collect_extensions(const char* extensions_str);
+    void collect_extensions(string_list* extensions_array);
     std::string format_embedded_source_map();
     std::string format_source_mapping_url(const std::string& out_path);
 

data/ext/libsass/src/cssize.cpp

@@ -5,15 +5,14 @@
 
 #include "cssize.hpp"
 #include "context.hpp"
-#include "backtrace.hpp"
 
 namespace Sass {
 
-  Cssize::Cssize(Context& ctx, Backtrace* bt)
+  Cssize::Cssize(Context& ctx)
   : ctx(ctx),
+    traces(ctx.traces),
     block_stack(std::vector<Block_Ptr>()),
-    p_stack(std::vector<Statement_Ptr>()),
-    backtrace(bt)
+    p_stack(std::vector<Statement_Ptr>())
   { }
 
   Statement_Ptr Cssize::parent()
@@ -23,25 +22,28 @@ namespace Sass {
 
   Block_Ptr Cssize::operator()(Block_Ptr b)
   {
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
+    Block_Obj bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
     // bb->tabs(b->tabs());
     block_stack.push_back(bb);
     append_block(b, bb);
     block_stack.pop_back();
-    return bb;
+    return bb.detach();
   }
 
   Statement_Ptr Cssize::operator()(Trace_Ptr t)
   {
-    return t->block()->perform(this);
+    traces.push_back(Backtrace(t->pstate()));
+    auto result = t->block()->perform(this);
+    traces.pop_back();
+    return result;
   }
 
   Statement_Ptr Cssize::operator()(Declaration_Ptr d)
   {
-    String_Obj property = SASS_MEMORY_CAST(String, d->property());
+    String_Obj property = Cast<String>(d->property());
 
-    if (Declaration_Ptr dd = dynamic_cast<Declaration_Ptr>(parent())) {
-      String_Obj parent_property = SASS_MEMORY_CAST(String, dd->property());
+    if (Declaration_Ptr dd = Cast<Declaration>(parent())) {
+      String_Obj parent_property = Cast<String>(dd->property());
       property = SASS_MEMORY_NEW(String_Constant,
                                  d->property()->pstate(),
                                  parent_property->to_string() + "-" + property->to_string());
@@ -54,17 +56,18 @@ namespace Sass {
                                       d->pstate(),
                                       property,
                                       d->value(),
-                                      d->is_important());
+                                      d->is_important(),
+                                      d->is_custom_property());
     dd->is_indented(d->is_indented());
     dd->tabs(d->tabs());
 
-    p_stack.push_back(&dd);
-    Block_Obj bb = d->block() ? operator()(&d->block()) : NULL;
+    p_stack.push_back(dd);
+    Block_Obj bb = d->block() ? operator()(d->block()) : NULL;
     p_stack.pop_back();
 
     if (bb && bb->length()) {
       if (dd->value() && !dd->value()->is_invisible()) {
-        bb->unshift(&dd);
+        bb->unshift(dd);
       }
       return bb.detach();
     }
@@ -89,7 +92,7 @@ namespace Sass {
                                   r->pstate(),
                                   r->keyword(),
                                   r->selector(),
-                                  r->block() ? operator()(&r->block()) : 0);
+                                  r->block() ? operator()(r->block()) : 0);
     if (r->value()) rr->value(r->value());
     p_stack.pop_back();
 
@@ -99,10 +102,10 @@ namespace Sass {
       Statement_Obj s = r->block()->at(i);
       if (s->statement_type() != Statement::BUBBLE) directive_exists = true;
       else {
-        Bubble_Obj s_obj = SASS_MEMORY_CAST(Bubble, s);
+        Bubble_Obj s_obj = Cast<Bubble>(s);
         s = s_obj->node();
         if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
-        else directive_exists = (static_cast<Directive_Ptr>(&s)->keyword() == rr->keyword());
+        else directive_exists = (Cast<Directive>(s)->keyword() == rr->keyword());
       }
 
     }
@@ -110,12 +113,14 @@ namespace Sass {
     Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
-      Directive_Ptr empty_node = SASS_MEMORY_CAST(Directive, rr);
+      Directive_Ptr empty_node = Cast<Directive>(rr);
       empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
       result->append(empty_node);
     }
 
-    Block_Obj ss = debubble(rr->block() ? &rr->block() : SASS_MEMORY_NEW(Block, rr->pstate()), &rr);
+    Block_Obj db = rr->block();
+    if (db.isNull()) db = SASS_MEMORY_NEW(Block, rr->pstate());
+    Block_Obj ss = debubble(db, rr);
     for (size_t i = 0, L = ss->length(); i < L; ++i) {
       result->append(ss->at(i));
     }
@@ -129,10 +134,10 @@ namespace Sass {
 
     Keyframe_Rule_Obj rr = SASS_MEMORY_NEW(Keyframe_Rule,
                                         r->pstate(),
-                                        operator()(&r->block()));
-    if (&r->name()) rr->name(r->name());
+                                        operator()(r->block()));
+    if (!r->name().isNull()) rr->name(r->name());
 
-    return debubble(&rr->block(), &rr);
+    return debubble(rr->block(), rr);
   }
 
   Statement_Ptr Cssize::operator()(Ruleset_Ptr r)
@@ -142,11 +147,11 @@ namespace Sass {
     // string schema is not a statement!
     // r->block() is already a string schema
     // and that is comming from propset expand
-    Block_Ptr bb = operator()(&r->block());
+    Block_Ptr bb = operator()(r->block());
     // this should protect us (at least a bit) from our mess
     // fixing this properly is harder that it should be ...
-    if (dynamic_cast<Statement_Ptr>(bb) == NULL) {
-      error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate());
+    if (Cast<Statement>(bb) == NULL) {
+      error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate(), traces);
     }
     Ruleset_Obj rr = SASS_MEMORY_NEW(Ruleset,
                                   r->pstate(),
@@ -158,31 +163,31 @@ namespace Sass {
     p_stack.pop_back();
 
     if (!rr->block()) {
-      error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate());
+      error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate(), traces);
     }
 
     Block_Obj props = SASS_MEMORY_NEW(Block, rr->block()->pstate());
     Block_Ptr rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
     for (size_t i = 0, L = rr->block()->length(); i < L; i++)
     {
-      Statement_Ptr s = &rr->block()->at(i);
+      Statement_Ptr s = rr->block()->at(i);
       if (bubblable(s)) rules->append(s);
       if (!bubblable(s)) props->append(s);
     }
 
     if (props->length())
     {
-      Block_Obj bb = SASS_MEMORY_NEW(Block, rr->block()->pstate());
-      bb->concat(&props);
-      rr->block(bb);
+      Block_Obj pb = SASS_MEMORY_NEW(Block, rr->block()->pstate());
+      pb->concat(props);
+      rr->block(pb);
 
       for (size_t i = 0, L = rules->length(); i < L; i++)
       {
-        Statement_Ptr stm = &rules->at(i);
+        Statement_Ptr stm = rules->at(i);
         stm->tabs(stm->tabs() + 1);
       }
 
-      rules->unshift(&rr);
+      rules->unshift(rr);
     }
 
     Block_Ptr ptr = rules;
@@ -194,7 +199,7 @@ namespace Sass {
     }
 
     if (!(!rules->length() ||
-          !bubblable(&rules->last()) ||
+          !bubblable(rules->last()) ||
           parent()->statement_type() == Statement::RULESET))
     {
       rules->last()->group_end(true);
@@ -219,13 +224,13 @@ namespace Sass {
 
     Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
-                                      &m->media_queries(),
-                                      operator()(&m->block()));
+                                      m->media_queries(),
+                                      operator()(m->block()));
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
 
-    return debubble(&mm->block(), &mm);
+    return debubble(mm->block(), mm);
   }
 
   Statement_Ptr Cssize::operator()(Supports_Block_Ptr m)
@@ -240,13 +245,13 @@ namespace Sass {
 
     Supports_Block_Obj mm = SASS_MEMORY_NEW(Supports_Block,
                                        m->pstate(),
-                                       &m->condition(),
-                                       operator()(&m->block()));
+                                       m->condition(),
+                                       operator()(m->block()));
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
 
-    return debubble(&mm->block(), &mm);
+    return debubble(mm->block(), mm);
   }
 
   Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)
@@ -257,15 +262,15 @@ namespace Sass {
       tmp |= m->exclude_node(s);
     }
 
-    if (!tmp)
+    if (!tmp && m->block())
     {
-      Block_Ptr bb = operator()(&m->block());
+      Block_Ptr bb = operator()(m->block());
       for (size_t i = 0, L = bb->length(); i < L; ++i) {
         // (bb->elements())[i]->tabs(m->tabs());
         Statement_Obj stm = bb->at(i);
-        if (bubblable(&stm)) stm->tabs(stm->tabs() + m->tabs());
+        if (bubblable(stm)) stm->tabs(stm->tabs() + m->tabs());
       }
-      if (bb->length() && bubblable(&bb->last())) bb->last()->group_end(m->group_end());
+      if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());
       return bb;
     }
 
@@ -280,13 +285,13 @@ namespace Sass {
   Statement_Ptr Cssize::bubble(Directive_Ptr m)
   {
     Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
-    Has_Block_Obj new_rule = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(this->parent()));
+    Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
-    new_rule->block()->concat(&m->block());
+    new_rule->block()->concat(m->block());
 
     Block_Obj wrapper_block = SASS_MEMORY_NEW(Block, m->block() ? m->block()->pstate() : m->pstate());
-    wrapper_block->append(&new_rule);
+    wrapper_block->append(new_rule);
     Directive_Obj mm = SASS_MEMORY_NEW(Directive,
                                   m->pstate(),
                                   m->keyword(),
@@ -294,20 +299,23 @@ namespace Sass {
                                   wrapper_block);
     if (m->value()) mm->value(m->value());
 
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), &mm);
+    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
   Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)
   {
+    if (!m || !m->block()) return NULL;
     Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
-    Has_Block_Obj new_rule = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(this->parent()));
-    new_rule->block(bb);
-    new_rule->tabs(this->parent()->tabs());
-    new_rule->block()->concat(&m->block());
-
+    Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
     Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
-    wrapper_block->append(&new_rule);
+    if (new_rule) {
+      new_rule->block(bb);
+      new_rule->tabs(this->parent()->tabs());
+      new_rule->block()->concat(m->block());
+      wrapper_block->append(new_rule);
+    }
+
     At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,
                                         m->pstate(),
                                         wrapper_block,
@@ -318,7 +326,7 @@ namespace Sass {
 
   Statement_Ptr Cssize::bubble(Supports_Block_Ptr m)
   {
-    Ruleset_Obj parent = static_cast<Ruleset_Ptr>(SASS_MEMORY_COPY(this->parent()));
+    Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
 
     Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
     Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
@@ -326,13 +334,13 @@ namespace Sass {
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
-    new_rule->block()->concat(&m->block());
+    new_rule->block()->concat(m->block());
 
     Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
     Supports_Block_Ptr mm = SASS_MEMORY_NEW(Supports_Block,
                                        m->pstate(),
-                                       &m->condition(),
+                                       m->condition(),
                                        wrapper_block);
 
     mm->tabs(m->tabs());
@@ -343,7 +351,7 @@ namespace Sass {
 
   Statement_Ptr Cssize::bubble(Media_Block_Ptr m)
   {
-    Ruleset_Obj parent = static_cast<Ruleset_Ptr>(SASS_MEMORY_COPY(this->parent()));
+    Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
 
     Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
     Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
@@ -351,32 +359,31 @@ namespace Sass {
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
-    new_rule->block()->concat(&m->block());
+    new_rule->block()->concat(m->block());
 
     Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
     Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
-                                      &m->media_queries(),
-                                      wrapper_block,
-                                      0);
+                                      m->media_queries(),
+                                      wrapper_block);
 
     mm->tabs(m->tabs());
 
-    return SASS_MEMORY_NEW(Bubble, mm->pstate(), &mm);
+    return SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
   }
 
   bool Cssize::bubblable(Statement_Ptr s)
   {
-    return dynamic_cast<Ruleset_Ptr>(s) || s->bubbles();
+    return Cast<Ruleset>(s) || s->bubbles();
   }
 
   Block_Ptr Cssize::flatten(Block_Ptr b)
   {
     Block_Ptr result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Ptr ss = &b->at(i);
-      if (Block_Ptr bb = SASS_MEMORY_CAST_PTR(Block, ss)) {
+      Statement_Ptr ss = b->at(i);
+      if (Block_Ptr bb = Cast<Block>(ss)) {
         Block_Obj bs = flatten(bb);
         for (size_t j = 0, K = bs->length(); j < K; ++j) {
           result->append(bs->at(j));
@@ -395,7 +402,7 @@ namespace Sass {
 
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj value = b->at(i);
-      bool key = dynamic_cast<Bubble_Ptr>(&value) != NULL;
+      bool key = Cast<Bubble>(value) != NULL;
 
       if (!results.empty() && results.back().first == key)
       {
@@ -424,45 +431,50 @@ namespace Sass {
 
       if (!is_bubble) {
         if (!parent) {
-          result->append(&slice);
+          result->append(slice);
         }
         else if (previous_parent) {
-          previous_parent->block()->concat(&slice);
+          previous_parent->block()->concat(slice);
         }
         else {
-          previous_parent = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(parent));
+          previous_parent = Cast<Has_Block>(SASS_MEMORY_COPY(parent));
           previous_parent->block(slice);
           previous_parent->tabs(parent->tabs());
 
-          result->append(&previous_parent);
+          result->append(previous_parent);
         }
         continue;
       }
 
       for (size_t j = 0, K = slice->length(); j < K; ++j)
       {
-        Statement_Ptr ss = NULL;
+        Statement_Ptr ss;
         Statement_Obj stm = slice->at(j);
         // this has to go now here (too bad)
-        Bubble_Obj node = SASS_MEMORY_CAST(Bubble, stm);
+        Bubble_Obj node = Cast<Bubble>(stm);
         Media_Block_Ptr m1 = NULL;
         Media_Block_Ptr m2 = NULL;
-        if (parent) m1 = SASS_MEMORY_CAST(Media_Block, *parent);
-        if (node) m2 = SASS_MEMORY_CAST(Media_Block, node->node());
+        if (parent) m1 = Cast<Media_Block>(parent);
+        if (node) m2 = Cast<Media_Block>(node->node());
         if (!parent ||
             parent->statement_type() != Statement::MEDIA ||
             node->node()->statement_type() != Statement::MEDIA ||
-            (m1 && m2 && &m1->media_queries() == &m2->media_queries())
+            (m1 && m2 && *m1->media_queries() == *m2->media_queries())
           )
         {
-          ss = &node->node();
+          ss = node->node();
         }
         else
         {
-          List_Obj mq = merge_media_queries(static_cast<Media_Block_Ptr>(&node->node()), static_cast<Media_Block_Ptr>(parent));
+          List_Obj mq = merge_media_queries(
+            Cast<Media_Block>(node->node()),
+            Cast<Media_Block>(parent)
+          );
           if (!mq->length()) continue;
-          static_cast<Media_Block_Ptr>(&node->node())->media_queries(mq);
-          ss = &node->node();
+          if (Media_Block* b = Cast<Media_Block>(node->node())) {
+            b->media_queries(mq);
+          }
+          ss = node->node();
         }
 
         if (!ss) continue;
@@ -470,8 +482,6 @@ namespace Sass {
         ss->tabs(ss->tabs() + node->tabs());
         ss->group_end(node->group_end());
 
-        if (!ss) continue;
-
         Block_Obj bb = SASS_MEMORY_NEW(Block,
                                     children->pstate(),
                                     children->length(),
@@ -483,7 +493,7 @@ namespace Sass {
                                               children->length(),
                                               children->is_root());
 
-        Block_Ptr wrapper = flatten(&bb);
+        Block_Ptr wrapper = flatten(bb);
         wrapper_block->append(wrapper);
 
         if (wrapper->length()) {
@@ -491,12 +501,12 @@ namespace Sass {
         }
 
         if (wrapper_block) {
-          result->append(&wrapper_block);
+          result->append(wrapper_block);
         }
       }
     }
 
-    return flatten(&result);
+    return flatten(result);
   }
 
   Statement_Ptr Cssize::fallback_impl(AST_Node_Ptr n)
@@ -508,7 +518,7 @@ namespace Sass {
   {
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj ith = b->at(i)->perform(this);
-      if (Block_Ptr bb = SASS_MEMORY_CAST(Block, ith)) {
+      if (Block_Ptr bb = Cast<Block>(ith)) {
         for (size_t j = 0, K = bb->length(); j < K; ++j) {
           cur->append(bb->at(j));
         }
@@ -530,8 +540,8 @@ namespace Sass {
       for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {
         Expression_Obj l1 = m1->media_queries()->at(i);
         Expression_Obj l2 = m2->media_queries()->at(j);
-        Media_Query_Ptr mq1 = SASS_MEMORY_CAST(Media_Query, l1);
-        Media_Query_Ptr mq2 = SASS_MEMORY_CAST(Media_Query, l2);
+        Media_Query_Ptr mq1 = Cast<Media_Query>(l1);
+        Media_Query_Ptr mq2 = Cast<Media_Query>(l2);
         Media_Query_Ptr mq = merge_media_query(mq1, mq2);
         if (mq) qq->append(mq);
       }
@@ -548,9 +558,9 @@ namespace Sass {
     std::string mod;
 
     std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    std::string t1 = &mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : "";
-    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    std::string t2 = &mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
+    std::string t1 = mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : "";
+    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq2->is_negated() ? "not" : "");
+    std::string t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
 
 
     if (t1.empty()) t1 = t2;
@@ -578,10 +588,11 @@ namespace Sass {
     }
 
     Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,
-
-mq1->pstate(), 0,
-mq1->length() + mq2->length(), mod == "not", mod == "only"
-);
+                                         mq1->pstate(),
+                                         0,
+                                         mq1->length() + mq2->length(),
+                                         mod == "not",
+                                         mod == "only");
 
     if (!type.empty()) {
       mm->media_type(SASS_MEMORY_NEW(String_Quoted, mq1->pstate(), type));