sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/fn_numbers.cpp

@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <cstdlib>
 #include <cmath>
-#include <cctype>
 #include <random>
 #include <sstream>
 #include <iomanip>
@@ -61,7 +60,7 @@ namespace Sass {
     BUILT_IN(percentage)
     {
       Number_Obj n = ARGN("$number");
-      if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate, traces);
+      if (!n->is_unitless()) error("argument $number of `" + sass::string(sig) + "` must be unitless", pstate, traces);
       return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, "%");
     }
 
@@ -106,8 +105,12 @@ namespace Sass {
     {
       List* arglist = ARG("$numbers", List);
       Number_Obj least;
-      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj val = arglist->value_at_index(i);
+      size_t L = arglist->length();
+      if (L == 0) {
+        error("At least one argument must be passed.", pstate, traces);
+      }
+      for (size_t i = 0; i < L; ++i) {
+        ExpressionObj val = arglist->value_at_index(i);
         Number_Obj xi = Cast<Number>(val);
         if (!xi) {
           error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate, traces);
@@ -124,8 +127,12 @@ namespace Sass {
     {
       List* arglist = ARG("$numbers", List);
       Number_Obj greatest;
-      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj val = arglist->value_at_index(i);
+      size_t L = arglist->length();
+      if (L == 0) {
+        error("At least one argument must be passed.", pstate, traces);
+      }
+      for (size_t i = 0; i < L; ++i) {
+        ExpressionObj val = arglist->value_at_index(i);
         Number_Obj xi = Cast<Number>(val);
         if (!xi) {
           error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate, traces);
@@ -147,13 +154,13 @@ namespace Sass {
       if (l) {
         double lv = l->value();
         if (lv < 1) {
-          std::stringstream err;
+          sass::ostream err;
           err << "$limit " << lv << " must be greater than or equal to 1 for `random'";
           error(err.str(), pstate, traces);
         }
         bool eq_int = std::fabs(trunc(lv) - lv) < NUMBER_EPSILON;
         if (!eq_int) {
-          std::stringstream err;
+          sass::ostream err;
           err << "Expected $limit to be an integer but got " << lv << " for `random'";
           error(err.str(), pstate, traces);
         }
@@ -177,7 +184,7 @@ namespace Sass {
     Signature unique_id_sig = "unique-id()";
     BUILT_IN(unique_id)
     {
-      std::stringstream ss;
+      sass::ostream ss;
       std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
       uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
       ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
@@ -188,7 +195,7 @@ namespace Sass {
     BUILT_IN(unit)
     {
       Number_Obj arg = ARGN("$number");
-      std::string str(quote(arg->unit(), '"'));
+      sass::string str(quote(arg->unit(), '"'));
       return SASS_MEMORY_NEW(String_Quoted, pstate, str);
     }
 
@@ -200,11 +207,11 @@ namespace Sass {
       return SASS_MEMORY_NEW(Boolean, pstate, unitless);
     }
 
-    Signature comparable_sig = "comparable($number-1, $number-2)";
+    Signature comparable_sig = "comparable($number1, $number2)";
     BUILT_IN(comparable)
     {
-      Number_Obj n1 = ARGN("$number-1");
-      Number_Obj n2 = ARGN("$number-2");
+      Number_Obj n1 = ARGN("$number1");
+      Number_Obj n2 = ARGN("$number2");
       if (n1->is_unitless() || n2->is_unitless()) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
       }

data/ext/libsass/src/fn_selectors.cpp

@@ -1,5 +1,8 @@
+#include <numeric>
+
 #include "parser.hpp"
-#include "extend.hpp"
+#include "extender.hpp"
+#include "listize.hpp"
 #include "fn_utils.hpp"
 #include "fn_selectors.hpp"
 
@@ -13,24 +16,28 @@ namespace Sass {
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
-      if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-nest'", pstate, traces);
+      if (arglist->length() == 0) {
+        error(
+          "$selectors: At least one selector must be passed for `selector-nest'",
+          pstate, traces);
+      }
 
       // Parse args into vector of selectors
       SelectorStack parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
+        ExpressionObj exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
-          std::stringstream msg;
-          msg << "$selectors: null is not a valid selector: it must be a string,\n";
-          msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
-          error(msg.str(), pstate, traces);
+          error(
+            "$selectors: null is not a valid selector: it must be a string,\n"
+            "a list of strings, or a list of lists of strings for 'selector-nest'",
+            pstate, traces);
         }
         if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string(ctx.c_options);
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+        sass::string exp_src = exp->to_string(ctx.c_options);
+        ItplFile* source = SASS_MEMORY_NEW(ItplFile, exp_src.c_str(), exp->pstate());
+        SelectorListObj sel = Parser::parse_selector(source, ctx, traces);
         parsedSelectors.push_back(sel);
       }
 
@@ -39,25 +46,21 @@ namespace Sass {
         return SASS_MEMORY_NEW(Null, pstate);
       }
 
-      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
+      // Set the first element as the `result`, keep
+      // appending to as we go down the parsedSelector vector.
       SelectorStack::iterator itr = parsedSelectors.begin();
-      Selector_List_Obj result = *itr;
+      SelectorListObj& result = *itr;
       ++itr;
 
       for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List_Obj child = *itr;
-        std::vector<Complex_Selector_Obj> exploded;
-        selector_stack.push_back(result);
-        Selector_List_Obj rv = child->resolve_parent_refs(selector_stack, traces);
-        selector_stack.pop_back();
-        for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
-          exploded.push_back((*rv)[m]);
-        }
-        result->elements(exploded);
+        SelectorListObj& child = *itr;
+        original_stack.push_back(result);
+        SelectorListObj rv = child->resolve_parent_refs(original_stack, traces);
+        result->elements(rv->elements());
+        original_stack.pop_back();
       }
 
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_append_sig = "selector-append($selectors...)";
@@ -66,113 +69,95 @@ namespace Sass {
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
-      if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-append'", pstate, traces);
+      if (arglist->empty()) {
+        error(
+          "$selectors: At least one selector must be "
+          "passed for `selector-append'",
+          pstate, traces);
+      }
 
       // Parse args into vector of selectors
       SelectorStack parsedSelectors;
+      parsedSelectors.push_back({});
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
+        Expression* exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
-          std::stringstream msg;
-          msg << "$selectors: null is not a valid selector: it must be a string,\n";
-          msg << "a list of strings, or a list of lists of strings for 'selector-append'";
-          error(msg.str(), pstate, traces);
+          error(
+            "$selectors: null is not a valid selector: it must be a string,\n"
+             "a list of strings, or a list of lists of strings for 'selector-append'",
+            pstate, traces);
         }
         if (String_Constant* str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string();
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces,
-                                                       exp->pstate(), pstate.src,
-                                                       /*allow_parent=*/false);
-
-        parsedSelectors.push_back(sel);
-      }
+        sass::string exp_src = exp->to_string();
+        ItplFile* source = SASS_MEMORY_NEW(ItplFile, exp_src.c_str(), exp->pstate());
+        SelectorListObj sel = Parser::parse_selector(source, ctx, traces, true);
 
-      // Nothing to do
-      if( parsedSelectors.empty() ) {
-        return SASS_MEMORY_NEW(Null, pstate);
-      }
-
-      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
-      SelectorStack::iterator itr = parsedSelectors.begin();
-      Selector_List_Obj result = *itr;
-      ++itr;
-
-      for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List_Obj child = *itr;
-        std::vector<Complex_Selector_Obj> newElements;
-
-        // For every COMPLEX_SELECTOR in `result`
-        // For every COMPLEX_SELECTOR in `child`
-          // let parentSeqClone equal a copy of result->elements[i]
-          // let childSeq equal child->elements[j]
-          // Append all of childSeq head elements into parentSeqClone
-          // Set the innermost tail of parentSeqClone, to childSeq's tail
-        // Replace result->elements with newElements
-        for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {
-          for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {
-            Complex_Selector_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);
-            Complex_Selector_Obj childSeq = (*child)[j];
-            Complex_Selector_Obj base = childSeq->tail();
-
-            // Must be a simple sequence
-            if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
-              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
-                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
-            }
-
-            // Cannot be a Universal selector
-            Type_Selector_Obj pType = Cast<Type_Selector>(childSeq->head()->first());
-            if(pType && pType->name() == "*") {
-              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
-                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
-            }
+        for (auto& complex : sel->elements()) {
+          if (complex->empty()) {
+            complex->append(SASS_MEMORY_NEW(CompoundSelector, "[phony]"));
+          }
+          if (CompoundSelector* comp = Cast<CompoundSelector>(complex->first())) {
+            comp->hasRealParent(true);
+            complex->chroots(true);
+          }
+        }
 
-            // TODO: Add check for namespace stuff
+        if (parsedSelectors.size() > 1) {
 
-            Complex_Selector* lastComponent = parentSeqClone->mutable_last();
-            if (lastComponent->head() == nullptr) {
-              std::string msg = "Parent \"" + parentSeqClone->to_string() + "\" is incompatible with \"" + base->to_string() + "\"";
-              error(msg, pstate, traces);
+          if (!sel->has_real_parent_ref()) {
+            auto parent = parsedSelectors.back();
+            for (auto& complex : parent->elements()) {
+              if (CompoundSelector* comp = Cast<CompoundSelector>(complex->first())) {
+                comp->hasRealParent(false);
+              }
             }
-            lastComponent->head()->concat(base->head());
-            lastComponent->tail(base->tail());
-
-            newElements.push_back(parentSeqClone);
+            error("Can't append \"" + sel->to_string() + "\" to \"" +
+              parent->to_string() + "\" for `selector-append'",
+              pstate, traces);
           }
+
+          // Build the resolved stack from the left. It's cheaper to directly
+          // calculate and update each resolved selcted from the left, than to
+          // recursively calculate them from the right side, as we would need
+          // to go through the whole stack depth to build the final results.
+          // E.g. 'a', 'b', 'x, y' => 'a' => 'a b' => 'a b x, a b y'
+          // vs 'a', 'b', 'x, y' => 'x' => 'b x' => 'a b x', 'y' ...
+          parsedSelectors.push_back(sel->resolve_parent_refs(parsedSelectors, traces, true));
         }
+        else {
+          parsedSelectors.push_back(sel);
+        }
+      }
 
-        result->elements(newElements);
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(Null, pstate);
       }
 
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      return Cast<Value>(Listize::perform(parsedSelectors.back()));
     }
 
     Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
     BUILT_IN(selector_unify)
     {
-      Selector_List_Obj selector1 = ARGSELS("$selector1");
-      Selector_List_Obj selector2 = ARGSELS("$selector2");
-
-      Selector_List_Obj result = selector1->unify_with(selector2);
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector1 = ARGSELS("$selector1");
+      SelectorListObj selector2 = ARGSELS("$selector2");
+      SelectorListObj result = selector1->unifyWith(selector2);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature simple_selectors_sig = "simple-selectors($selector)";
     BUILT_IN(simple_selectors)
     {
-      Compound_Selector_Obj sel = ARGSEL("$selector");
+      CompoundSelectorObj sel = ARGSEL("$selector");
 
       List* l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
 
       for (size_t i = 0, L = sel->length(); i < L; ++i) {
-        Simple_Selector_Obj ss = (*sel)[i];
-        std::string ss_string = ss->to_string() ;
-
+        const SimpleSelectorObj& ss = sel->get(i);
+        sass::string ss_string = ss->to_string() ;
         l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
       }
 
@@ -182,51 +167,36 @@ namespace Sass {
     Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
     BUILT_IN(selector_extend)
     {
-      Selector_List_Obj  selector = ARGSELS("$selector");
-      Selector_List_Obj  extendee = ARGSELS("$extendee");
-      Selector_List_Obj  extender = ARGSELS("$extender");
-
-      Subset_Map subset_map;
-      extender->populate_extends(extendee, subset_map);
-      Extend extend(subset_map);
-
-      Selector_List_Obj result = extend.extendSelectorList(selector, false);
-
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      SelectorListObj target = ARGSELS("$extendee");
+      SelectorListObj source = ARGSELS("$extender");
+      SelectorListObj result = Extender::extend(selector, source, target, traces);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
     BUILT_IN(selector_replace)
     {
-      Selector_List_Obj selector = ARGSELS("$selector");
-      Selector_List_Obj original = ARGSELS("$original");
-      Selector_List_Obj replacement = ARGSELS("$replacement");
-      Subset_Map subset_map;
-      replacement->populate_extends(original, subset_map);
-      Extend extend(subset_map);
-
-      Selector_List_Obj result = extend.extendSelectorList(selector, true);
-
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      SelectorListObj target = ARGSELS("$original");
+      SelectorListObj source = ARGSELS("$replacement");
+      SelectorListObj result = Extender::replace(selector, source, target, traces);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_parse_sig = "selector-parse($selector)";
     BUILT_IN(selector_parse)
     {
-      Selector_List_Obj sel = ARGSELS("$selector");
-
-      Listize listize;
-      return Cast<Value>(sel->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      return Cast<Value>(Listize::perform(selector));
     }
 
     Signature is_superselector_sig = "is-superselector($super, $sub)";
     BUILT_IN(is_superselector)
     {
-      Selector_List_Obj  sel_sup = ARGSELS("$super");
-      Selector_List_Obj  sel_sub = ARGSELS("$sub");
-      bool result = sel_sup->is_superselector_of(sel_sub);
+      SelectorListObj sel_sup = ARGSELS("$super");
+      SelectorListObj sel_sub = ARGSELS("$sub");
+      bool result = sel_sup->isSuperselectorOf(sel_sub);
       return SASS_MEMORY_NEW(Boolean, pstate, result);
     }
 

data/ext/libsass/src/fn_strings.cpp

@@ -2,31 +2,31 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <cctype>
 #include "utf8.h"
 #include "ast.hpp"
 #include "fn_utils.hpp"
 #include "fn_strings.hpp"
+#include "util_string.hpp"
 
 namespace Sass {
 
   namespace Functions {
 
-    void handle_utf8_error (const ParserState& pstate, Backtraces traces)
+    void handle_utf8_error (const SourceSpan& pstate, Backtraces traces)
     {
       try {
        throw;
       }
       catch (utf8::invalid_code_point&) {
-        std::string msg("utf8::invalid_code_point");
+        sass::string msg("utf8::invalid_code_point");
         error(msg, pstate, traces);
       }
       catch (utf8::not_enough_room&) {
-        std::string msg("utf8::not_enough_room");
+        sass::string msg("utf8::not_enough_room");
         error(msg, pstate, traces);
       }
       catch (utf8::invalid_utf8&) {
-        std::string msg("utf8::invalid_utf8");
+        sass::string msg("utf8::invalid_utf8");
         error(msg, pstate, traces);
       }
       catch (...) { throw; }
@@ -52,7 +52,7 @@ namespace Sass {
       else if (Value* ex = Cast<Value>(arg)) {
         Sass_Output_Style oldstyle = ctx.c_options.output_style;
         ctx.c_options.output_style = SASS_STYLE_NESTED;
-        std::string val(arg->to_string(ctx.c_options));
+        sass::string val(arg->to_string(ctx.c_options));
         val = Cast<Null>(arg) ? "null" : val;
         ctx.c_options.output_style = oldstyle;
 
@@ -76,7 +76,7 @@ namespace Sass {
     Signature str_length_sig = "str-length($string)";
     BUILT_IN(str_length)
     {
-      size_t len = std::string::npos;
+      size_t len = sass::string::npos;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         len = UTF_8::code_point_count(s->value(), 0, s->value().size());
@@ -92,13 +92,20 @@ namespace Sass {
     Signature str_insert_sig = "str-insert($string, $insert, $index)";
     BUILT_IN(str_insert)
     {
-      std::string str;
+      sass::string str;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         str = s->value();
         String_Constant* i = ARG("$insert", String_Constant);
-        std::string ins = i->value();
+        sass::string ins = i->value();
         double index = ARGVAL("$index");
+        if (index != (int)index) {
+          sass::ostream strm;
+          strm << "$index: ";
+          strm << std::to_string(index);
+          strm << " is not an int";
+          error(strm.str(), pstate, traces);
+        }
         size_t len = UTF_8::code_point_count(str, 0, str.size());
 
         if (index > 0 && index <= len) {
@@ -135,15 +142,15 @@ namespace Sass {
     Signature str_index_sig = "str-index($string, $substring)";
     BUILT_IN(str_index)
     {
-      size_t index = std::string::npos;
+      size_t index = sass::string::npos;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         String_Constant* t = ARG("$substring", String_Constant);
-        std::string str = s->value();
-        std::string substr = t->value();
+        sass::string str = s->value();
+        sass::string substr = t->value();
 
         size_t c_index = str.find(substr);
-        if(c_index == std::string::npos) {
+        if(c_index == sass::string::npos) {
           return SASS_MEMORY_NEW(Null, pstate);
         }
         index = UTF_8::code_point_count(str, 0, c_index) + 1;
@@ -158,14 +165,23 @@ namespace Sass {
     Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
     BUILT_IN(str_slice)
     {
-      std::string newstr;
+      sass::string newstr;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         double start_at = ARGVAL("$start-at");
         double end_at = ARGVAL("$end-at");
+
+        if (start_at != (int)start_at) {
+          sass::ostream strm;
+          strm << "$start-at: ";
+          strm << std::to_string(start_at);
+          strm << " is not an int";
+          error(strm.str(), pstate, traces);
+        }
+
         String_Quoted* ss = Cast<String_Quoted>(s);
 
-        std::string str(s->value());
+        sass::string str(s->value());
 
         size_t size = utf8::distance(str.begin(), str.end());
 
@@ -173,6 +189,14 @@ namespace Sass {
           end_at = -1;
         }
 
+        if (end_at != (int)end_at) {
+          sass::ostream strm;
+          strm << "$end-at: ";
+          strm << std::to_string(end_at);
+          strm << " is not an int";
+          error(strm.str(), pstate, traces);
+        }
+
         if (end_at == 0 || (end_at + size) < 0) {
           if (ss && ss->quote_mark()) newstr = quote("");
           return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
@@ -185,17 +209,17 @@ namespace Sass {
         if (end_at > size) { end_at = (double)size; }
         if (start_at < 0) {
           start_at += size + 1;
-          if (start_at < 0)  start_at = 0;
+          if (start_at <= 0) start_at = 1;
         }
         else if (start_at == 0) { ++ start_at; }
 
         if (start_at <= end_at)
         {
-          std::string::iterator start = str.begin();
+          sass::string::iterator start = str.begin();
           utf8::advance(start, start_at - 1, str.end());
-          std::string::iterator end = start;
+          sass::string::iterator end = start;
           utf8::advance(end, end_at - start_at + 1, str.end());
-          newstr = std::string(start, end);
+          newstr = sass::string(start, end);
         }
         if (ss) {
           if(ss->quote_mark()) newstr = quote(newstr);
@@ -211,13 +235,8 @@ namespace Sass {
     BUILT_IN(to_upper_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      std::string str = s->value();
-
-      for (size_t i = 0, L = str.length(); i < L; ++i) {
-        if (Sass::Util::isAscii(str[i])) {
-          str[i] = std::toupper(str[i]);
-        }
-      }
+      sass::string str = s->value();
+      Util::ascii_str_toupper(&str);
 
       if (String_Quoted* ss = Cast<String_Quoted>(s)) {
         String_Quoted* cpy = SASS_MEMORY_COPY(ss);
@@ -232,13 +251,8 @@ namespace Sass {
     BUILT_IN(to_lower_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      std::string str = s->value();
-
-      for (size_t i = 0, L = str.length(); i < L; ++i) {
-        if (Sass::Util::isAscii(str[i])) {
-          str[i] = std::tolower(str[i]);
-        }
-      }
+      sass::string str = s->value();
+      Util::ascii_str_tolower(&str);
 
       if (String_Quoted* ss = Cast<String_Quoted>(s)) {
         String_Quoted* cpy = SASS_MEMORY_COPY(ss);