sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/sass_context.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cstring>
 #include <stdexcept>
 #include <sstream>
@@ -67,23 +70,23 @@ namespace Sass {
       }
 
       // now create the code trace (ToDo: maybe have util functions?)
-      if (e.pstate.line != std::string::npos && e.pstate.column != std::string::npos) {
+      if (e.pstate.line != std::string::npos &&
+          e.pstate.column != std::string::npos &&
+          e.pstate.src != nullptr) {
         size_t lines = e.pstate.line;
-        const char* line_beg = e.pstate.src;
         // scan through src until target line
         // move line_beg pointer to line start
-        while (line_beg && *line_beg && lines != 0) {
+        const char* line_beg;
+        for (line_beg = e.pstate.src; *line_beg != '\0'; ++line_beg) {
+          if (lines == 0) break;
           if (*line_beg == '\n') --lines;
-          utf8::unchecked::next(line_beg); 
         }
-        const char* line_end = line_beg;
         // move line_end before next newline character
-        while (line_end && *line_end && *line_end != '\n') {
-          if (*line_end == '\n') break;
-          if (*line_end == '\r') break;
-          utf8::unchecked::next(line_end); 
+        const char* line_end;
+        for (line_end = line_beg; *line_end != '\0'; ++line_end) {
+          if (*line_end == '\n' || *line_end == '\r') break;
         }
-        if (line_end && *line_end != 0) ++ line_end;
+        if (*line_end != '\0') ++line_end;
         size_t line_len = line_end - line_beg;
         size_t move_in = 0; size_t shorten = 0;
         size_t left_chars = 42; size_t max_chars = 76;
@@ -212,7 +215,7 @@ namespace Sass {
   {
 
     // assert valid pointer
-    if (compiler == 0) return 0;
+    if (compiler == 0) return {};
     // The cpp context must be set by now
     Context* cpp_ctx = compiler->cpp_ctx;
     Sass_Context* c_ctx = compiler->c_ctx;
@@ -233,7 +236,7 @@ namespace Sass {
       // dispatch parse call
       Block_Obj root(cpp_ctx->parse());
       // abort on errors
-      if (!root) return 0;
+      if (!root) return {};
 
       // skip all prefixed files? (ToDo: check srcmap)
       // IMO source-maps should point to headers already
@@ -253,7 +256,7 @@ namespace Sass {
     catch (...) { handle_errors(c_ctx); }
 
     // error
-    return 0;
+    return {};
 
   }
 
@@ -381,7 +384,7 @@ extern "C" {
 
   inline void init_options (struct Sass_Options* options)
   {
-    options->precision = 5;
+    options->precision = 10;
     options->indent = "  ";
     options->linefeed = LFEED;
   }
@@ -617,7 +620,7 @@ extern "C" {
     if (cpp_ctx) delete(cpp_ctx);
     compiler->cpp_ctx = NULL;
     compiler->c_ctx = NULL;
-    compiler->root = NULL;
+    compiler->root = {};
     free(compiler);
   }
 

data/ext/libsass/src/sass_functions.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cstring>
 #include "util.hpp"
 #include "context.hpp"
@@ -167,21 +170,21 @@ extern "C" {
 
   // Getters and Setters for environments (lexical, local and global)
   union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame env, const char* name) {
-    Expression_Ptr ex = Cast<Expression>((*env->frame)[name]);
+    Expression* ex = Cast<Expression>((*env->frame)[name]);
     return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
   }
   void ADDCALL sass_env_set_lexical (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
     (*env->frame)[name] = sass_value_to_ast_node(val);
   }
   union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame env, const char* name) {
-    Expression_Ptr ex = Cast<Expression>(env->frame->get_local(name));
+    Expression* ex = Cast<Expression>(env->frame->get_local(name));
     return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
   }
   void ADDCALL sass_env_set_local (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
     env->frame->set_local(name, sass_value_to_ast_node(val));
   }
   union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame env, const char* name) {
-    Expression_Ptr ex = Cast<Expression>(env->frame->get_global(name));
+    Expression* ex = Cast<Expression>(env->frame->get_global(name));
     return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
   }
   void ADDCALL sass_env_set_global (Sass_Env_Frame env, const char* name, union Sass_Value* val) {

data/ext/libsass/src/sass_functions.hpp

@@ -3,7 +3,7 @@
 
 #include "sass.h"
 #include "environment.hpp"
-#include "functions.hpp"
+#include "fn_utils.hpp"
 
 // Struct to hold custom function callback
 struct Sass_Function {

data/ext/libsass/src/sass_util.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "node.hpp"
 
 namespace Sass {

data/ext/libsass/src/sass_values.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cstdlib>
 #include <cstring>
 #include "util.hpp"
@@ -290,7 +293,7 @@ extern "C" {
   union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b)
   {
 
-    Sass::Value_Ptr rv;
+    Sass::Value_Obj rv;
 
     try {
 
@@ -312,28 +315,34 @@ extern "C" {
       }
 
       if (sass_value_is_number(a) && sass_value_is_number(b)) {
-        Number_Ptr_Const l_n = Cast<Number>(lhs);
-        Number_Ptr_Const r_n = Cast<Number>(rhs);
+        const Number* l_n = Cast<Number>(lhs);
+        const Number* r_n = Cast<Number>(rhs);
         rv = Operators::op_numbers(op, *l_n, *r_n, options, l_n->pstate());
       }
       else if (sass_value_is_number(a) && sass_value_is_color(a)) {
-        Number_Ptr_Const l_n = Cast<Number>(lhs);
-        Color_Ptr_Const r_c = Cast<Color>(rhs);
+        const Number* l_n = Cast<Number>(lhs);
+        // Direct HSLA operations are not supported
+        // All color maths will be deprecated anyway
+        Color_RGBA_Obj r_c = Cast<Color>(rhs)->toRGBA();
         rv = Operators::op_number_color(op, *l_n, *r_c, options, l_n->pstate());
       }
       else if (sass_value_is_color(a) && sass_value_is_number(b)) {
-        Color_Ptr_Const l_c = Cast<Color>(lhs);
-        Number_Ptr_Const r_n = Cast<Number>(rhs);
+        // Direct HSLA operations are not supported
+        // All color maths will be deprecated anyway
+        Color_RGBA_Obj l_c = Cast<Color>(lhs)->toRGBA();
+        const Number* r_n = Cast<Number>(rhs);
         rv = Operators::op_color_number(op, *l_c, *r_n, options, l_c->pstate());
       }
       else if (sass_value_is_color(a) && sass_value_is_color(b)) {
-        Color_Ptr_Const l_c = Cast<Color>(lhs);
-        Color_Ptr_Const r_c = Cast<Color>(rhs);
+        // Direct HSLA operations are not supported
+        // All color maths will be deprecated anyway
+        Color_RGBA_Obj l_c = Cast<Color>(lhs)->toRGBA();
+        Color_RGBA_Obj r_c = Cast<Color>(rhs)->toRGBA();
         rv = Operators::op_colors(op, *l_c, *r_c, options, l_c->pstate());
       }
       else /* convert other stuff to string and apply operation */ {
-        Value_Ptr l_v = Cast<Value>(lhs);
-        Value_Ptr r_v = Cast<Value>(rhs);
+        Value* l_v = Cast<Value>(lhs);
+        Value* r_v = Cast<Value>(rhs);
         rv = Operators::op_strings(op, *l_v, *r_v, options, l_v->pstate());
       }
 
@@ -341,8 +350,7 @@ extern "C" {
       if (!rv) return sass_make_error("invalid return value");
 
       // convert result back to ast node
-      return ast_node_to_sass_value(rv);
-
+      return ast_node_to_sass_value(rv.ptr());
     }
 
     // simply pass the error message back to the caller for now

data/ext/libsass/src/source_map.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <string>
 #include <sstream>
 #include <iostream>
@@ -170,12 +173,12 @@ namespace Sass {
     current_position += offset;
   }
 
-  void SourceMap::add_open_mapping(const AST_Node_Ptr node)
+  void SourceMap::add_open_mapping(const AST_Node* node)
   {
     mappings.push_back(Mapping(node->pstate(), current_position));
   }
 
-  void SourceMap::add_close_mapping(const AST_Node_Ptr node)
+  void SourceMap::add_close_mapping(const AST_Node* node)
   {
     mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));
   }

data/ext/libsass/src/source_map.hpp

@@ -28,8 +28,8 @@ namespace Sass {
     void prepend(const Offset& offset);
     void append(const OutputBuffer& out);
     void prepend(const OutputBuffer& out);
-    void add_open_mapping(const AST_Node_Ptr node);
-    void add_close_mapping(const AST_Node_Ptr node);
+    void add_open_mapping(const AST_Node* node);
+    void add_close_mapping(const AST_Node* node);
 
     std::string render_srcmap(Context &ctx);
     ParserState remap(const ParserState& pstate);

data/ext/libsass/src/subset_map.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "subset_map.hpp"
 
@@ -52,4 +55,4 @@ namespace Sass {
     return get_kv(sel);
   }
 
-}
+}

data/ext/libsass/src/to_value.cpp

@@ -1,60 +1,62 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "to_value.hpp"
 
 namespace Sass {
 
-  Value_Ptr To_Value::fallback_impl(AST_Node_Ptr n)
-  {
-    // throw a runtime error if this happens
-    // we want a well defined set of possible nodes
-    throw std::runtime_error("invalid node for to_value");
-  }
-
   // Custom_Error is a valid value
-  Value_Ptr To_Value::operator()(Custom_Error_Ptr e)
+  Value* To_Value::operator()(Custom_Error* e)
   {
     return e;
   }
 
   // Custom_Warning is a valid value
-  Value_Ptr To_Value::operator()(Custom_Warning_Ptr w)
+  Value* To_Value::operator()(Custom_Warning* w)
   {
     return w;
   }
 
   // Boolean is a valid value
-  Value_Ptr To_Value::operator()(Boolean_Ptr b)
+  Value* To_Value::operator()(Boolean* b)
   {
     return b;
   }
 
   // Number is a valid value
-  Value_Ptr To_Value::operator()(Number_Ptr n)
+  Value* To_Value::operator()(Number* n)
   {
     return n;
   }
 
   // Color is a valid value
-  Value_Ptr To_Value::operator()(Color_Ptr c)
+  Value* To_Value::operator()(Color_RGBA* c)
+  {
+    return c;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color_HSLA* c)
   {
     return c;
   }
 
   // String_Constant is a valid value
-  Value_Ptr To_Value::operator()(String_Constant_Ptr s)
+  Value* To_Value::operator()(String_Constant* s)
   {
     return s;
   }
 
   // String_Quoted is a valid value
-  Value_Ptr To_Value::operator()(String_Quoted_Ptr s)
+  Value* To_Value::operator()(String_Quoted* s)
   {
     return s;
   }
 
   // List is a valid value
-  Value_Ptr To_Value::operator()(List_Ptr l)
+  Value* To_Value::operator()(List* l)
   {
     List_Obj ll = SASS_MEMORY_NEW(List,
                                l->pstate(),
@@ -69,32 +71,32 @@ namespace Sass {
   }
 
   // Map is a valid value
-  Value_Ptr To_Value::operator()(Map_Ptr m)
+  Value* To_Value::operator()(Map* m)
   {
     return m;
   }
 
   // Null is a valid value
-  Value_Ptr To_Value::operator()(Null_Ptr n)
+  Value* To_Value::operator()(Null* n)
   {
     return n;
   }
 
   // Function is a valid value
-  Value_Ptr To_Value::operator()(Function_Ptr n)
+  Value* To_Value::operator()(Function* n)
   {
     return n;
   }
 
   // Argument returns its value
-  Value_Ptr To_Value::operator()(Argument_Ptr arg)
+  Value* To_Value::operator()(Argument* arg)
   {
     if (!arg->name().empty()) return 0;
     return arg->value()->perform(this);
   }
 
   // Selector_List is converted to a string
-  Value_Ptr To_Value::operator()(Selector_List_Ptr s)
+  Value* To_Value::operator()(Selector_List* s)
   {
     return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),
@@ -102,7 +104,7 @@ namespace Sass {
   }
 
   // Binary_Expression is converted to a string
-  Value_Ptr To_Value::operator()(Binary_Expression_Ptr s)
+  Value* To_Value::operator()(Binary_Expression* s)
   {
     return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),

data/ext/libsass/src/to_value.hpp

@@ -7,9 +7,7 @@
 
 namespace Sass {
 
-  class To_Value : public Operation_CRTP<Value_Ptr, To_Value> {
-
-    Value_Ptr fallback_impl(AST_Node_Ptr n);
+  class To_Value : public Operation_CRTP<Value*, To_Value> {
 
   private:
 
@@ -21,28 +19,26 @@ namespace Sass {
     : ctx(ctx)
     { }
     ~To_Value() { }
-    using Operation<Value_Ptr>::operator();
-
-    Value_Ptr operator()(Argument_Ptr);
-    Value_Ptr operator()(Boolean_Ptr);
-    Value_Ptr operator()(Number_Ptr);
-    Value_Ptr operator()(Color_Ptr);
-    Value_Ptr operator()(String_Constant_Ptr);
-    Value_Ptr operator()(String_Quoted_Ptr);
-    Value_Ptr operator()(Custom_Warning_Ptr);
-    Value_Ptr operator()(Custom_Error_Ptr);
-    Value_Ptr operator()(List_Ptr);
-    Value_Ptr operator()(Map_Ptr);
-    Value_Ptr operator()(Null_Ptr);
-    Value_Ptr operator()(Function_Ptr);
+    using Operation<Value*>::operator();
+
+    Value* operator()(Argument*);
+    Value* operator()(Boolean*);
+    Value* operator()(Number*);
+    Value* operator()(Color_RGBA*);
+    Value* operator()(Color_HSLA*);
+    Value* operator()(String_Constant*);
+    Value* operator()(String_Quoted*);
+    Value* operator()(Custom_Warning*);
+    Value* operator()(Custom_Error*);
+    Value* operator()(List*);
+    Value* operator()(Map*);
+    Value* operator()(Null*);
+    Value* operator()(Function*);
 
     // convert to string via `To_String`
-    Value_Ptr operator()(Selector_List_Ptr);
-    Value_Ptr operator()(Binary_Expression_Ptr);
+    Value* operator()(Selector_List*);
+    Value* operator()(Binary_Expression*);
 
-    // fallback throws error
-    template <typename U>
-    Value_Ptr fallback(U x) { return fallback_impl(x); }
   };
 
 }

data/ext/libsass/src/units.cpp

@@ -266,6 +266,10 @@ namespace Sass {
     return (numerators == rhs.numerators) &&
            (denominators == rhs.denominators);
   }
+  bool Units::operator!= (const Units& rhs) const
+  {
+    return ! (*this == rhs);
+  }
 
   double Units::normalize()
   {