sassc 2.3.0 → 2.4.0

data/ext/libsass/src/fn_colors.cpp

@@ -16,16 +16,16 @@ namespace Sass {
     bool string_argument(AST_Node_Obj obj) {
       String_Constant* s = Cast<String_Constant>(obj);
       if (s == nullptr) return false;
-      const std::string& str = s->value();
+      const sass::string& str = s->value();
       return starts_with(str, "calc(") ||
              starts_with(str, "var(");
     }
 
-    void hsla_alpha_percent_deprecation(const ParserState& pstate, const std::string val)
+    void hsla_alpha_percent_deprecation(const SourceSpan& pstate, const sass::string val)
     {
 
-      std::string msg("Passing a percentage as the alpha value to hsla() will be interpreted");
-      std::string tail("differently in future versions of Sass. For now, use " + val + " instead.");
+      sass::string msg("Passing a percentage as the alpha value to hsla() will be interpreted");
+      sass::string tail("differently in future versions of Sass. For now, use " + val + " instead.");
 
       deprecated(msg, tail, false, pstate);
 
@@ -104,7 +104,7 @@ namespace Sass {
       if (
         string_argument(env["$alpha"])
       ) {
-        std::stringstream strm;
+        sass::ostream strm;
         strm << "rgba("
                  << (int)c_arg->r() << ", "
                  << (int)c_arg->g() << ", "
@@ -145,7 +145,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(Number, pstate, color->b());
     }
 
-    Color_RGBA* colormix(Context& ctx, ParserState& pstate, Color* color1, Color* color2, double weight) {
+    Color_RGBA* colormix(Context& ctx, SourceSpan& pstate, Color* color1, Color* color2, double weight) {
       Color_RGBA_Obj c1 = color1->toRGBA();
       Color_RGBA_Obj c2 = color2->toRGBA();
       double p = weight/100;
@@ -230,7 +230,7 @@ namespace Sass {
         Number_Obj val = SASS_MEMORY_COPY(alpha);
         val->numerators.clear(); // convert
         val->value(val->value() / 100.0);
-        std::string nr(val->to_string(ctx.c_options));
+        sass::string nr(val->to_string(ctx.c_options));
         hsla_alpha_percent_deprecation(pstate, nr);
       }
 
@@ -579,14 +579,14 @@ namespace Sass {
       double b = clip(c->b(), 0.0, 255.0);
       double a = clip(c->a(), 0.0, 1.0) * 255.0;
 
-      std::stringstream ss;
+      sass::ostream ss;
       ss << '#' << std::setw(2) << std::setfill('0');
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(a, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(r, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b, ctx.c_options.precision));
 
-      std::string result = ss.str();
+      sass::string result = ss.str();
       Util::ascii_str_toupper(&result);
       return SASS_MEMORY_NEW(String_Quoted, pstate, result);
     }

data/ext/libsass/src/fn_lists.cpp

@@ -21,9 +21,9 @@ namespace Sass {
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List)); // copy
       Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);
       for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
-        Expression_Obj obj = arglist->at(i);
+        ExpressionObj obj = arglist->at(i);
         Argument_Obj arg = (Argument*) obj.ptr(); // XXX
-        std::string name = std::string(arg->name());
+        sass::string name = sass::string(arg->name());
         name = name.erase(0, 1); // sanitize name (remove dollar sign)
         *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,
                  pstate, name),
@@ -67,13 +67,13 @@ namespace Sass {
       if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
         size_t len = m ? m->length() : sl->length();
         bool empty = m ? m->empty() : sl->empty();
-        if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+        if (empty) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
         double index = std::floor(nr < 0 ? len + nr : nr - 1);
-        if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+        if (index < 0 || index > len - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
         return Cast<Value>(Listize::perform(sl->get(static_cast<int>(index))));
       }
       List_Obj l = Cast<List>(env["$list"]);
-      if (nr == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate, traces);
+      if (nr == 0) error("argument `$n` of `" + sass::string(sig) + "` must be non-zero", pstate, traces);
       // if the argument isn't a list, then wrap it in a singleton list
       if (!m && !l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
@@ -81,9 +81,9 @@ namespace Sass {
       }
       size_t len = m ? m->length() : l->length();
       bool empty = m ? m->empty() : l->empty();
-      if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+      if (empty) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
       double index = std::floor(nr < 0 ? len + nr : nr - 1);
-      if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+      if (index < 0 || index > len - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
 
       if (m) {
         l = SASS_MEMORY_NEW(List, pstate, 2);
@@ -92,7 +92,7 @@ namespace Sass {
         return l.detach();
       }
       else {
-        Value_Obj rv = l->value_at_index(static_cast<int>(index));
+        ValueObj rv = l->value_at_index(static_cast<int>(index));
         rv->set_delayed(false);
         return rv.detach();
       }
@@ -104,7 +104,7 @@ namespace Sass {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
       Number_Obj n = ARG("$n", Number);
-      Expression_Obj v = ARG("$value", Expression);
+      ExpressionObj v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
@@ -112,9 +112,9 @@ namespace Sass {
       if (m) {
         l = m->to_list(pstate);
       }
-      if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+      if (l->empty()) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
-      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
       List* result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->is_bracketed());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         result->append(((i == index) ? v : (*l)[i]));
@@ -127,7 +127,7 @@ namespace Sass {
     {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
-      Expression_Obj v = ARG("$value", Expression);
+      ExpressionObj v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
@@ -170,10 +170,10 @@ namespace Sass {
         l2 = m2->to_list(pstate);
       }
       size_t len = l1->length() + l2->length();
-      std::string sep_str = unquote(sep->value());
+      sass::string sep_str = unquote(sep->value());
       if (sep_str == "space") sep_val = SASS_SPACE;
       else if (sep_str == "comma") sep_val = SASS_COMMA;
-      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
+      else if (sep_str != "auto") error("argument `$separator` of `" + sass::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
       String_Constant_Obj bracketed_as_str = Cast<String_Constant>(bracketed);
       bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == "auto";
       if (!bracketed_is_auto) {
@@ -190,7 +190,7 @@ namespace Sass {
     {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
-      Expression_Obj v = ARG("$val", Expression);
+      ExpressionObj v = ARG("$val", Expression);
       if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
         l = Cast<List>(Listize::perform(sl));
       }
@@ -203,11 +203,11 @@ namespace Sass {
         l = m->to_list(pstate);
       }
       List* result = SASS_MEMORY_COPY(l);
-      std::string sep_str(unquote(sep->value()));
+      sass::string sep_str(unquote(sep->value()));
       if (sep_str != "auto") { // check default first
         if (sep_str == "space") result->separator(SASS_SPACE);
         else if (sep_str == "comma") result->separator(SASS_COMMA);
-        else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
+        else error("argument `$separator` of `" + sass::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
       }
       if (l->is_arglist()) {
         result->append(SASS_MEMORY_NEW(Argument,
@@ -275,7 +275,7 @@ namespace Sass {
     Signature is_bracketed_sig = "is-bracketed($list)";
     BUILT_IN(is_bracketed)
     {
-      Value_Obj value = ARG("$list", Value);
+      ValueObj value = ARG("$list", Value);
       List_Obj list = Cast<List>(value);
       return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());
     }

data/ext/libsass/src/fn_maps.cpp

@@ -16,9 +16,9 @@ namespace Sass {
       // leaks for "map-get((), foo)" if not Obj
       // investigate why this is (unexpected)
       Map_Obj m = ARGM("$map", Map);
-      Expression_Obj v = ARG("$key", Expression);
+      ExpressionObj v = ARG("$key", Expression);
       try {
-        Value_Obj val = m->at(v);
+        ValueObj val = m->at(v);
         if (!val) return SASS_MEMORY_NEW(Null, pstate);
         val->set_delayed(false);
         return val.detach();
@@ -32,7 +32,7 @@ namespace Sass {
     BUILT_IN(map_has_key)
     {
       Map_Obj m = ARGM("$map", Map);
-      Expression_Obj v = ARG("$key", Expression);
+      ExpressionObj v = ARG("$key", Expression);
       return SASS_MEMORY_NEW(Boolean, pstate, m->has(v));
     }
 

data/ext/libsass/src/fn_miscs.cpp

@@ -22,7 +22,7 @@ namespace Sass {
     Signature variable_exists_sig = "variable-exists($name)";
     BUILT_IN(variable_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has("$"+s)) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -35,7 +35,7 @@ namespace Sass {
     Signature global_variable_exists_sig = "global-variable-exists($name)";
     BUILT_IN(global_variable_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has_global("$"+s)) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -53,7 +53,7 @@ namespace Sass {
         error("$name: " + (env["$name"]->to_string()) + " is not a string for `function-exists'", pstate, traces);
       }
 
-      std::string name = Util::normalize_underscores(unquote(ss->value()));
+      sass::string name = Util::normalize_underscores(unquote(ss->value()));
 
       if(d_env.has(name+"[f]")) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -66,7 +66,7 @@ namespace Sass {
     Signature mixin_exists_sig = "mixin-exists($name)";
     BUILT_IN(mixin_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has(s+"[m]")) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -79,9 +79,9 @@ namespace Sass {
     Signature feature_exists_sig = "feature-exists($feature)";
     BUILT_IN(feature_exists)
     {
-      std::string s = unquote(ARG("$feature", String_Constant)->value());
+      sass::string s = unquote(ARG("$feature", String_Constant)->value());
 
-      static const auto *const features = new std::unordered_set<std::string> {
+      static const auto *const features = new std::unordered_set<sass::string> {
         "global-variable-shadowing",
         "extend-selector-pseudoclass",
         "at-error",
@@ -94,7 +94,7 @@ namespace Sass {
     Signature call_sig = "call($function, $args...)";
     BUILT_IN(call)
     {
-      std::string function;
+      sass::string function;
       Function* ff = Cast<Function>(env["$function"]);
       String_Constant* ss = Cast<String_Constant>(env["$function"]);
 
@@ -111,19 +111,19 @@ namespace Sass {
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
 
       Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
-      // std::string full_name(name + "[f]");
+      // sass::string full_name(name + "[f]");
       // Definition* def = d_env.has(full_name) ? Cast<Definition>((d_env)[full_name]) : 0;
       // Parameters* params = def ? def->parameters() : 0;
       // size_t param_size = params ? params->length() : 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj expr = arglist->value_at_index(i);
+        ExpressionObj expr = arglist->value_at_index(i);
         // if (params && params->has_rest_parameter()) {
         //   Parameter_Obj p = param_size > i ? (*params)[i] : 0;
         //   List* list = Cast<List>(expr);
         //   if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
         // }
         if (arglist->is_arglist()) {
-          Expression_Obj obj = arglist->at(i);
+          ExpressionObj obj = arglist->at(i);
           Argument_Obj arg = (Argument*) obj.ptr(); // XXX
           args->append(SASS_MEMORY_NEW(Argument,
                                        pstate,
@@ -157,10 +157,10 @@ namespace Sass {
     BUILT_IN(sass_if)
     {
       Expand expand(ctx, &d_env, &selector_stack, &original_stack);
-      Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
+      ExpressionObj cond = ARG("$condition", Expression)->perform(&expand.eval);
       bool is_true = !cond->is_false();
-      Expression_Obj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
-      Value_Obj qwe = Cast<Value>(res->perform(&expand.eval));
+      ExpressionObj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
+      ValueObj qwe = Cast<Value>(res->perform(&expand.eval));
       // res = res->perform(&expand.eval.val_eval);
       qwe->set_delayed(false); // clone?
       return qwe.detach();
@@ -216,8 +216,8 @@ namespace Sass {
         error("$name: " + (env["$name"]->to_string()) + " is not a string for `get-function'", pstate, traces);
       }
 
-      std::string name = Util::normalize_underscores(unquote(ss->value()));
-      std::string full_name = name + "[f]";
+      sass::string name = Util::normalize_underscores(unquote(ss->value()));
+      sass::string full_name = name + "[f]";
 
       Boolean_Obj css = ARG("$css", Boolean);
       if (!css->is_false()) {

data/ext/libsass/src/fn_numbers.cpp

@@ -60,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, "%");
     }
 
@@ -110,7 +110,7 @@ namespace Sass {
         error("At least one argument must be passed.", pstate, traces);
       }
       for (size_t i = 0; i < L; ++i) {
-        Expression_Obj val = arglist->value_at_index(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);
@@ -132,7 +132,7 @@ namespace Sass {
         error("At least one argument must be passed.", pstate, traces);
       }
       for (size_t i = 0; i < L; ++i) {
-        Expression_Obj val = arglist->value_at_index(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);
@@ -154,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);
         }
@@ -184,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;
@@ -195,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);
     }
 

data/ext/libsass/src/fn_selectors.cpp

@@ -25,7 +25,7 @@ namespace Sass {
       // 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) {
           error(
             "$selectors: null is not a valid selector: it must be a string,\n"
@@ -35,8 +35,9 @@ namespace Sass {
         if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string(ctx.c_options);
-        SelectorListObj 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);
       }
 
@@ -89,10 +90,9 @@ namespace Sass {
         if (String_Constant* str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string();
-        SelectorListObj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces,
-                                                     exp->pstate(), pstate.src,
-                                                     /*allow_parent=*/true);
+        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);
 
         for (auto& complex : sel->elements()) {
           if (complex->empty()) {
@@ -157,7 +157,7 @@ namespace Sass {
 
       for (size_t i = 0, L = sel->length(); i < L; ++i) {
         const SimpleSelectorObj& ss = sel->get(i);
-        std::string ss_string = ss->to_string() ;
+        sass::string ss_string = ss->to_string() ;
         l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
       }
 

data/ext/libsass/src/fn_strings.cpp

@@ -12,21 +12,21 @@ 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,15 +92,19 @@ 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) {
-          error("$index: " + std::to_string(index) + " is not an int", pstate, traces);
+          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());
 
@@ -138,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;
@@ -161,19 +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) {
-          error("$start-at: " + std::to_string(start_at) + " is not an int", pstate, traces);
+          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());
 
@@ -182,7 +190,11 @@ namespace Sass {
         }
 
         if (end_at != (int)end_at) {
-          error("$end-at: " + std::to_string(end_at) + " is not an int", pstate, traces);
+          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) {
@@ -203,11 +215,11 @@ namespace Sass {
 
         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);
@@ -223,7 +235,7 @@ namespace Sass {
     BUILT_IN(to_upper_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      std::string str = s->value();
+      sass::string str = s->value();
       Util::ascii_str_toupper(&str);
 
       if (String_Quoted* ss = Cast<String_Quoted>(s)) {
@@ -239,7 +251,7 @@ namespace Sass {
     BUILT_IN(to_lower_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      std::string str = s->value();
+      sass::string str = s->value();
       Util::ascii_str_tolower(&str);
 
       if (String_Quoted* ss = Cast<String_Quoted>(s)) {