sassc 1.8.3 → 1.8.4

data/ext/libsass/src/extend.hpp

@@ -25,9 +25,7 @@ namespace Sass {
     static Node subweave(Node& one, Node& two, Context& ctx);
     static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething);
     Extend(Context&, ExtensionSubsetMap&);
-    virtual ~Extend() { }
-
-    using Operation<void>::operator();
+    ~Extend() { }
 
     void operator()(Block*);
     void operator()(Ruleset*);

data/ext/libsass/src/file.cpp

@@ -1,19 +1,15 @@
 #ifdef _WIN32
-#ifdef __MINGW32__
-#ifndef off64_t
-#define off64_t _off64_t    /* Workaround for http://sourceforge.net/p/mingw/bugs/2024/ */
-#endif
-#endif
-#include <direct.h>
-#define getcwd _getcwd
-#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
+# ifdef __MINGW32__
+#  ifndef off64_t
+#   define off64_t _off64_t    /* Workaround for http://sourceforge.net/p/mingw/bugs/2024/ */
+#  endif
+# endif
+# include <direct.h>
+# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
 #else
-#include <unistd.h>
+# include <unistd.h>
 #endif
-#ifdef _MSC_VER
-#define NOMINMAX
-#endif
-
+#include "sass.hpp"
 #include <iostream>
 #include <fstream>
 #include <cctype>
@@ -27,15 +23,24 @@
 #include "sass2scss.h"
 
 #ifdef _WIN32
-#include <windows.h>
-#endif
-
-#ifndef FS_CASE_SENSITIVE
-#ifdef _WIN32
-#define FS_CASE_SENSITIVE 0
-#else
-#define FS_CASE_SENSITIVE 1
-#endif
+# include <windows.h>
+
+# ifdef _MSC_VER
+# include <codecvt>
+inline static std::string wstring_to_string(const std::wstring& wstr)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> wchar_converter;
+    return wchar_converter.to_bytes(wstr);
+}
+# else // mingw(/gcc) does not support C++11's codecvt yet.
+inline static std::string wstring_to_string(const std::wstring &wstr)
+{
+    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
+    std::string strTo(size_needed, 0);
+    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
+    return strTo;
+}
+# endif
 #endif
 
 namespace Sass {
@@ -46,9 +51,12 @@ namespace Sass {
     std::string get_cwd()
     {
       const size_t wd_len = 1024;
-      char wd[wd_len];
-      std::string cwd = getcwd(wd, wd_len);
-      #ifdef _WIN32
+      #ifndef _WIN32
+        char wd[wd_len];
+        std::string cwd = getcwd(wd, wd_len);
+      #else
+        wchar_t wd[wd_len];
+        std::string cwd = wstring_to_string(_wgetcwd(wd, wd_len));
         //convert backslashes to forward slashes
         replace(cwd.begin(), cwd.end(), '\\', '/');
       #endif
@@ -184,8 +192,10 @@ namespace Sass {
       if (l[l.length()-1] != '/') l += '/';
 
       while ((r.length() > 3) && ((r.substr(0, 3) == "../") || (r.substr(0, 3)) == "..\\")) {
-        r = r.substr(3);
-        size_t pos = find_last_folder_separator(l, l.length() - 2);
+        size_t L = l.length(), pos = find_last_folder_separator(l, L - 2);
+        bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\');
+        bool is_self = pos + 3 == L && (l[pos+1] == '.');
+        if (!is_self && !is_slash) r = r.substr(3);
         l = l.substr(0, pos == std::string::npos ? pos : pos + 1);
       }
 

data/ext/libsass/src/functions.cpp

@@ -1,10 +1,10 @@
+#include "sass.hpp"
 #include "functions.hpp"
 #include "ast.hpp"
 #include "context.hpp"
 #include "backtrace.hpp"
 #include "parser.hpp"
 #include "constants.hpp"
-#include "to_string.hpp"
 #include "inspect.hpp"
 #include "extend.hpp"
 #include "eval.hpp"
@@ -14,6 +14,7 @@
 #include "sass/base.h"
 #include "utf8.h"
 
+#include <cstdint>
 #include <cstdlib>
 #include <cmath>
 #include <cctype>
@@ -155,7 +156,6 @@ namespace Sass {
 
     template <>
     Selector_List* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
-      To_String to_string(&ctx, false);
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
@@ -163,13 +163,15 @@ namespace Sass {
         msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
         error(msg.str(), pstate);
       }
-      std::string exp_src = exp->perform(&to_string) + "{";
+      if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
+        str->quote_mark(0);
+      }
+      std::string exp_src = exp->to_string(ctx.c_options) + "{";
       return Parser::parse_selector(exp_src.c_str(), ctx);
     }
 
     template <>
     Complex_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
-      To_String to_string(&ctx, false);
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
@@ -177,21 +179,26 @@ namespace Sass {
         msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
         error(msg.str(), pstate);
       }
-      std::string exp_src = exp->perform(&to_string) + "{";
+      if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
+        str->quote_mark(0);
+      }
+      std::string exp_src = exp->to_string(ctx.c_options) + "{";
       Selector_List* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
       return (sel_list->length() > 0) ? sel_list->first() : 0;
     }
 
     template <>
     Compound_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
-      To_String to_string(&ctx, false);
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
         msg << argname << ": null is not a string for `" << function_name(sig) << "'";
         error(msg.str(), pstate);
       }
-      std::string exp_src = exp->perform(&to_string) + "{";
+      if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
+        str->quote_mark(0);
+      }
+      std::string exp_src = exp->to_string(ctx.c_options) + "{";
       Selector_List* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
       return (sel_list->length() > 0) ? sel_list->first()->tail()->head() : 0;
     }
@@ -211,9 +218,9 @@ namespace Sass {
       return seed;
     }
     #else
-    static std::random_device rd;
     uint64_t GetSeed()
     {
+      std::random_device rd;
       return rd();
     }
     #endif
@@ -311,9 +318,9 @@ namespace Sass {
 
       return SASS_MEMORY_NEW(ctx.mem, Color,
                              pstate,
-                             Sass::round(w1*color1->r() + w2*color2->r()),
-                             Sass::round(w1*color1->g() + w2*color2->g()),
-                             Sass::round(w1*color1->b() + w2*color2->b()),
+                             Sass::round(w1*color1->r() + w2*color2->r(), ctx.c_options.precision),
+                             Sass::round(w1*color1->g() + w2*color2->g(), ctx.c_options.precision),
+                             Sass::round(w1*color1->b() + w2*color2->b(), ctx.c_options.precision),
                              color1->a()*p + color2->a()*(1-p));
     }
 
@@ -510,8 +517,7 @@ namespace Sass {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$amount"]);
       if (!amount) {
-        To_String to_string(&ctx);
-        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "saturate(" + env["$color"]->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "saturate(" + env["$color"]->to_string(ctx.c_options) + ")");
       }
 
       ARGR("$amount", Number, 0, 100);
@@ -571,8 +577,7 @@ namespace Sass {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
-        To_String to_string(&ctx);
-        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "grayscale(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "grayscale(" + amount->to_string(ctx.c_options) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
@@ -608,8 +613,7 @@ namespace Sass {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
-        To_String to_string(&ctx);
-        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "invert(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
@@ -636,8 +640,7 @@ namespace Sass {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
-        To_String to_string(&ctx);
-        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "opacity(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "opacity(" + amount->to_string(ctx.c_options) + ")");
       }
 
       return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->a());
@@ -854,10 +857,10 @@ namespace Sass {
 
       std::stringstream ss;
       ss << '#' << std::setw(2) << std::setfill('0');
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(a));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(r));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b));
+      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());
       for (size_t i = 0, L = result.length(); i < L; ++i) {
@@ -884,9 +887,11 @@ namespace Sass {
         return (Expression*) arg;
       }
       else {
-        To_String to_string(&ctx, false, true);
-        std::string val(arg->perform(&to_string));
+        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));
         val = dynamic_cast<Null*>(arg) ? "null" : val;
+        ctx.c_options.output_style = oldstyle;
 
         deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
         return (Expression*) arg;
@@ -896,9 +901,8 @@ namespace Sass {
     Signature quote_sig = "quote($string)";
     BUILT_IN(sass_quote)
     {
-      To_String to_string(&ctx);
       AST_Node* arg = env["$string"];
-      std::string str(quote(arg->perform(&to_string), String_Constant::double_quote()));
+      std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));
       String_Quoted* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
       result->is_delayed(true);
       return result;
@@ -1088,7 +1092,7 @@ namespace Sass {
       Number* n = ARG("$number", Number);
       Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
-      r->value(Sass::round(r->value()));
+      r->value(Sass::round(r->value(), ctx.c_options.precision));
       return r;
     }
 
@@ -1128,10 +1132,13 @@ namespace Sass {
       List* arglist = ARG("$numbers", List);
       Number* least = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + std::string(sig) + "` only takes numeric arguments", pstate);
+        Expression* val = arglist->value_at_index(i);
+        Number* xi = dynamic_cast<Number*>(val);
+        if (!xi) {
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate);
+        }
         if (least) {
-          if (Eval::lt(xi, least)) least = xi;
+          if (*xi < *least) least = xi;
         } else least = xi;
       }
       return least;
@@ -1143,10 +1150,13 @@ namespace Sass {
       List* arglist = ARG("$numbers", List);
       Number* greatest = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + std::string(sig) + "` only takes numeric arguments", pstate);
+        Expression* val = arglist->value_at_index(i);
+        Number* xi = dynamic_cast<Number*>(val);
+        if (!xi) {
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate);
+        }
         if (greatest) {
-          if (Eval::lt(greatest, xi)) greatest = xi;
+          if (*greatest < *xi) greatest = xi;
         } else greatest = xi;
       }
       return greatest;
@@ -1231,7 +1241,7 @@ namespace Sass {
         double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
         if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
         // return (*sl)[static_cast<int>(index)];
-        Listize listize(ctx);
+        Listize listize(ctx.mem);
         return (*sl)[static_cast<int>(index)]->perform(&listize);
       }
       List* l = dynamic_cast<List*>(env["$list"]);
@@ -1326,7 +1336,7 @@ namespace Sass {
       List* l = dynamic_cast<List*>(env["$list"]);
       Expression* v = ARG("$val", Expression);
       if (Selector_List* sl = dynamic_cast<Selector_List*>(env["$list"])) {
-        Listize listize(ctx);
+        Listize listize(ctx.mem);
         l = dynamic_cast<List*>(sl->perform(&listize));
       }
       String_Constant* sep = ARG("$separator", String_Constant);
@@ -1662,6 +1672,9 @@ namespace Sass {
     // MISCELLANEOUS FUNCTIONS
     //////////////////////////
 
+    // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)
+    // unquoted_string(value.to_sass)
+
     Signature inspect_sig = "inspect($value)";
     BUILT_IN(inspect)
     {
@@ -1673,23 +1686,23 @@ namespace Sass {
       } else if (v->concrete_type() == Expression::STRING) {
         return v;
       } else {
-        bool parentheses = v->concrete_type() == Expression::MAP ||
-                           v->concrete_type() == Expression::LIST;
+        // ToDo: fix to_sass for nested parentheses
         Sass_Output_Style old_style;
-        old_style = ctx.c_options->output_style;
-        ctx.c_options->output_style = SASS_STYLE_NESTED;
-        To_String to_string(&ctx, false);
-        std::string inspect = v->perform(&to_string);
-        if (inspect.empty() && parentheses) inspect = "()";
-        ctx.c_options->output_style = old_style;
-        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, inspect);
+        old_style = ctx.c_options.output_style;
+        ctx.c_options.output_style = TO_SASS;
+        Sass_Output_Options out(ctx.c_options);
+        Emitter emitter(ctx.c_options);
+        Inspect i(emitter);
+        i.in_declaration = false;
+        v->perform(&i);
+        ctx.c_options.output_style = old_style;
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, i.get_buffer());
       }
       // return v;
     }
     Signature selector_nest_sig = "selector-nest($selectors...)";
     BUILT_IN(selector_nest)
     {
-      To_String to_string(&ctx, false);
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
@@ -1706,7 +1719,10 @@ namespace Sass {
           msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
           error(msg.str(), pstate);
         }
-        std::string exp_src = exp->perform(&to_string) + "{";
+        if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
+          str->quote_mark(0);
+        }
+        std::string exp_src = exp->to_string(ctx.c_options) + "{";
         Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
         parsedSelectors.push_back(sel);
       }
@@ -1731,14 +1747,13 @@ namespace Sass {
         result->elements(exploded);
       }
 
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return result->perform(&listize);
     }
 
     Signature selector_append_sig = "selector-append($selectors...)";
     BUILT_IN(selector_append)
     {
-      To_String to_string;
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
@@ -1755,7 +1770,10 @@ namespace Sass {
           msg << "a list of strings, or a list of lists of strings for 'selector-append'";
           error(msg.str(), pstate);
         }
-        std::string exp_src = exp->perform(&to_string) + "{";
+        if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
+          str->quote_mark(0);
+        }
+        std::string exp_src = exp->to_string() + "{";
         Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
         parsedSelectors.push_back(sel);
       }
@@ -1790,9 +1808,9 @@ namespace Sass {
             // Must be a simple sequence
             if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
               std::string msg("Can't append  `");
-              msg += childSeq->perform(&to_string);
+              msg += childSeq->to_string();
               msg += "` to `";
-              msg += parentSeqClone->perform(&to_string);;
+              msg += parentSeqClone->to_string();
               msg += "`";
               error(msg, pstate, backtrace);
             }
@@ -1801,9 +1819,9 @@ namespace Sass {
             Type_Selector* pType = dynamic_cast<Type_Selector*>(base->head()->first());
             if(pType && pType->name() == "*") {
               std::string msg("Can't append  `");
-              msg += childSeq->perform(&to_string);
+              msg += childSeq->to_string();
               msg += "` to `";
-              msg += parentSeqClone->perform(&to_string);;
+              msg += parentSeqClone->to_string();
               msg += "`";
               error(msg, pstate, backtrace);
             }
@@ -1823,7 +1841,7 @@ namespace Sass {
         result->elements(newElements);
       }
 
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return result->perform(&listize);
     }
 
@@ -1834,7 +1852,7 @@ namespace Sass {
       Selector_List* selector2 = ARGSEL("$selector2", Selector_List, p_contextualize);
 
       Selector_List* result = selector1->unify_with(selector2, ctx);
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return result->perform(&listize);
     }
 
@@ -1843,12 +1861,11 @@ namespace Sass {
     {
       Compound_Selector* sel = ARGSEL("$selector", Compound_Selector, p_contextualize);
 
-      To_String to_string;
       List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
 
       for (size_t i = 0, L = sel->length(); i < L; ++i) {
         Simple_Selector* ss = (*sel)[i];
-        std::string ss_string = ss->perform(&to_string) ;
+        std::string ss_string = ss->to_string() ;
 
         *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, ss->pstate(), ss_string);
       }
@@ -1869,7 +1886,7 @@ namespace Sass {
       bool extendedSomething;
       Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, false, extendedSomething);
 
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return result->perform(&listize);
     }
 
@@ -1886,7 +1903,7 @@ namespace Sass {
       bool extendedSomething;
       Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, true, extendedSomething);
 
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return result->perform(&listize);
     }
 
@@ -1895,14 +1912,13 @@ namespace Sass {
     {
       Selector_List* sel = ARGSEL("$selector", Selector_List, p_contextualize);
 
-      Listize listize(ctx);
+      Listize listize(ctx.mem);
       return sel->perform(&listize);
     }
 
     Signature is_superselector_sig = "is-superselector($super, $sub)";
     BUILT_IN(is_superselector)
     {
-      To_String to_string(&ctx, false);
       Selector_List*  sel_sup = ARGSEL("$super", Selector_List, p_contextualize);
       Selector_List*  sel_sub = ARGSEL("$sub", Selector_List, p_contextualize);
       bool result = sel_sup->is_superselector_of(sel_sub);