sassc 2.0.0 → 2.4.0

data/ext/libsass/src/sass_context.hpp

@@ -90,7 +90,7 @@ struct Sass_Context : Sass_Options
   char* error_file;
   size_t error_line;
   size_t error_column;
-  const char* error_src;
+  char* error_src;
 
   // report imported files
   char** included_files;
@@ -126,4 +126,4 @@ struct Sass_Compiler {
   Sass::Block_Obj root;
 };
 
-#endif
+#endif

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"
@@ -98,7 +101,7 @@ extern "C" {
   }
 
   // Creator for a single import entry returned by the custom importer inside the list
-  // We take ownership of the memory for source and srcmap (freed when context is destroyd)
+  // We take ownership of the memory for source and srcmap (freed when context is destroyed)
   Sass_Import_Entry ADDCALL sass_make_import(const char* imp_path, const char* abs_path, char* source, char* srcmap)
   {
     Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));
@@ -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_values.cpp

@@ -1,9 +1,11 @@
+// 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"
 #include "eval.hpp"
-#include "values.hpp"
 #include "operators.hpp"
 #include "sass/values.h"
 #include "sass_values.hpp"
@@ -281,21 +283,21 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* v, bool compressed, int precision)
   {
-    Value_Obj val = sass_value_to_ast_node(v);
+    ValueObj val = sass_value_to_ast_node(v);
     Sass_Inspect_Options options(compressed ? COMPRESSED : NESTED, precision);
-    std::string str(val->to_string(options));
+    sass::string str(val->to_string(options));
     return sass_make_qstring(str.c_str());
   }
 
   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::ValueObj rv;
 
     try {
 
-      Value_Obj lhs = sass_value_to_ast_node(a);
-      Value_Obj rhs = sass_value_to_ast_node(b);
+      ValueObj lhs = sass_value_to_ast_node(a);
+      ValueObj rhs = sass_value_to_ast_node(b);
       struct Sass_Inspect_Options options(NESTED, 5);
 
       // see if it's a relational expression
@@ -312,44 +314,47 @@ 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);
-        rv = Operators::op_strings(op, *l_v, *r_v, options, l_v->pstate());
+        rv = Operators::op_strings(op, *lhs, *rhs, options, lhs->pstate());
       }
 
-      // ToDo: maybe we should should return null value?
+      // ToDo: maybe we should return null value?
       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
     catch (Exception::InvalidSass& e) { return sass_make_error(e.what()); }
     catch (std::bad_alloc&) { return sass_make_error("memory exhausted"); }
     catch (std::exception& e) { return sass_make_error(e.what()); }
-    catch (std::string& e) { return sass_make_error(e.c_str()); }
+    catch (sass::string& e) { return sass_make_error(e.c_str()); }
     catch (const char* e) { return sass_make_error(e); }
     catch (...) { return sass_make_error("unknown"); }
   }

data/ext/libsass/src/settings.hpp

@@ -0,0 +1,19 @@
+#ifndef SASS_SETTINGS_H
+#define SASS_SETTINGS_H
+
+// Global compile time settings should go here
+
+// When enabled we use our custom memory pool allocator
+// With intense workloads this can double the performance
+// Max memory usage mostly only grows by a slight amount
+// #define SASS_CUSTOM_ALLOCATOR
+
+// How many buckets should we have for the free-list
+// Determines when allocations go directly to malloc/free
+// For maximum size of managed items multiply by alignment
+#define SassAllocatorBuckets 512
+
+// The size of the memory pool arenas in bytes.
+#define SassAllocatorArenaSize (1024 * 256)
+
+#endif

data/ext/libsass/src/source.cpp

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <string.h>
+#include "source.hpp"
+#include "utf8/checked.h"
+#include "position.hpp"
+
+namespace Sass {
+
+  SourceData::SourceData()
+    : SharedObj()
+  {
+  }
+
+  SourceFile::SourceFile(
+    const char* path,
+    const char* data,
+    size_t srcid) :
+    SourceData(),
+    path(sass_copy_c_string(path)),
+    data(sass_copy_c_string(data)),
+    length(0),
+    srcid(srcid)
+  {
+    length = strlen(data);
+  }
+
+  SourceFile::~SourceFile() {
+    sass_free_memory(path);
+    sass_free_memory(data);
+  }
+
+  const char* SourceFile::end() const
+  {
+    return data + length;
+  }
+
+  const char* SourceFile::begin() const
+  {
+    return data;
+  }
+
+  const char* SourceFile::getRawData() const
+  {
+    return data;
+  }
+
+  SourceSpan SourceFile::getSourceSpan()
+  {
+    return SourceSpan(this);
+  }
+
+  ItplFile::ItplFile(const char* data, const SourceSpan& pstate) :
+    SourceFile(pstate.getPath(),
+      data, pstate.getSrcId()),
+    pstate(pstate)
+  {}
+
+  const char* ItplFile::getRawData() const
+  {
+    return pstate.getRawData();
+  }
+
+  SourceSpan ItplFile::getSourceSpan()
+  {
+    return SourceSpan(pstate);
+  }
+
+}
+

data/ext/libsass/src/source.hpp

@@ -0,0 +1,95 @@
+#ifndef SASS_SOURCE_H
+#define SASS_SOURCE_H
+
+#include "sass.hpp"
+#include "memory.hpp"
+#include "position.hpp"
+#include "source_data.hpp"
+
+namespace Sass {
+
+  class SourceFile :
+    public SourceData {
+  protected:
+    char* path;
+    char* data;
+    size_t length;
+    size_t srcid;
+  public:
+
+    SourceFile(
+      const char* path,
+      const char* data,
+      size_t srcid);
+
+    ~SourceFile();
+
+    const char* end() const override final;
+    const char* begin() const override final;
+    virtual const char* getRawData() const override;
+    virtual SourceSpan getSourceSpan() override;
+
+    size_t size() const override final {
+      return length;
+    }
+
+    virtual const char* getPath() const override {
+      return path;
+    }
+
+    virtual size_t getSrcId() const override {
+      return srcid;
+    }
+
+  };
+
+  class SynthFile :
+    public SourceData {
+  protected:
+    const char* path;
+  public:
+
+    SynthFile(
+      const char* path) :
+      path(path)
+    {}
+
+    ~SynthFile() {}
+
+    const char* end() const override final { return nullptr; }
+    const char* begin() const override final { return nullptr; };
+    virtual const char* getRawData() const override { return nullptr; };
+    virtual SourceSpan getSourceSpan() override { return SourceSpan(path); };
+
+    size_t size() const override final {
+      return 0;
+    }
+
+    virtual const char* getPath() const override {
+      return path;
+    }
+
+    virtual size_t getSrcId() const override {
+      return std::string::npos;
+    }
+
+  };
+  
+
+  class ItplFile :
+    public SourceFile {
+  private:
+    SourceSpan pstate;
+  public:
+
+    ItplFile(const char* data,
+      const SourceSpan& pstate);
+
+    // Offset getPosition() const override final;
+    const char* getRawData() const override final;
+    SourceSpan getSourceSpan() override final;
+  };
+
+}
+
+#endif

data/ext/libsass/src/source_data.hpp

@@ -0,0 +1,32 @@
+#ifndef SASS_SOURCE_DATA_H
+#define SASS_SOURCE_DATA_H
+
+#include "sass.hpp"
+#include "memory.hpp"
+
+namespace Sass {
+
+  class SourceSpan;
+
+  class SourceData :
+    public SharedObj {
+  public:
+    SourceData();
+    virtual size_t size() const = 0;
+    virtual size_t getSrcId() const = 0;
+    virtual const char* end() const = 0;
+    virtual const char* begin() const = 0;
+    virtual const char* getPath() const = 0;
+    // virtual Offset getPosition() const = 0;
+    virtual const char* getRawData() const = 0;
+    virtual SourceSpan getSourceSpan() = 0;
+
+    sass::string to_string() const override {
+      return sass::string{ begin(), end() };
+    }
+    ~SourceData() {}
+  };
+
+}
+
+#endif

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>
@@ -12,13 +15,13 @@
 
 namespace Sass {
   SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }
-  SourceMap::SourceMap(const std::string& file) : current_position(0, 0, 0), file(file) { }
+  SourceMap::SourceMap(const sass::string& file) : current_position(0, 0, 0), file(file) { }
 
-  std::string SourceMap::render_srcmap(Context &ctx) {
+  sass::string SourceMap::render_srcmap(Context &ctx) {
 
     const bool include_sources = ctx.c_options.source_map_contents;
-    const std::vector<std::string> links = ctx.srcmap_links;
-    const std::vector<Resource>& sources(ctx.resources);
+    const sass::vector<sass::string> links = ctx.srcmap_links;
+    const sass::vector<Resource>& sources(ctx.resources);
 
     JsonNode* json_srcmap = json_mkobject();
 
@@ -36,7 +39,7 @@ namespace Sass {
 
     JsonNode *json_sources = json_mkarray();
     for (size_t i = 0; i < source_index.size(); ++i) {
-      std::string source(links[source_index[i]]);
+      sass::string source(links[source_index[i]]);
       if (ctx.c_options.source_map_file_urls) {
         source = File::rel2abs(source);
         // check for windows abs path
@@ -69,19 +72,19 @@ namespace Sass {
     // no problem as we do not alter any identifiers
     json_append_member(json_srcmap, "names", json_names);
 
-    std::string mappings = serialize_mappings();
+    sass::string mappings = serialize_mappings();
     JsonNode *json_mappings = json_mkstring(mappings.c_str());
     json_append_member(json_srcmap, "mappings", json_mappings);
 
     char *str = json_stringify(json_srcmap, "\t");
-    std::string result = std::string(str);
+    sass::string result = sass::string(str);
     free(str);
     json_delete(json_srcmap);
     return result;
   }
 
-  std::string SourceMap::serialize_mappings() {
-    std::string result = "";
+  sass::string SourceMap::serialize_mappings() {
+    sass::string result = "";
 
     size_t previous_generated_line = 0;
     size_t previous_generated_column = 0;
@@ -98,7 +101,7 @@ namespace Sass {
       if (generated_line != previous_generated_line) {
         previous_generated_column = 0;
         if (generated_line > previous_generated_line) {
-          result += std::string(generated_line - previous_generated_line, ';');
+          result += sass::string(generated_line - previous_generated_line, ';');
           previous_generated_line = generated_line;
         }
       }
@@ -170,25 +173,29 @@ 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));
+    const SourceSpan& span(node->pstate());
+    Position from(span.getSrcId(), span.position);
+    mappings.push_back(Mapping(from, 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));
+    const SourceSpan& span(node->pstate());
+    Position to(span.getSrcId(), span.position + span.offset);
+    mappings.push_back(Mapping(to, current_position));
   }
 
-  ParserState SourceMap::remap(const ParserState& pstate) {
+  SourceSpan SourceMap::remap(const SourceSpan& pstate) {
     for (size_t i = 0; i < mappings.size(); ++i) {
       if (
-        mappings[i].generated_position.file == pstate.file &&
-        mappings[i].generated_position.line == pstate.line &&
-        mappings[i].generated_position.column == pstate.column
-      ) return ParserState(pstate.path, pstate.src, mappings[i].original_position, pstate.offset);
+        mappings[i].generated_position.file == pstate.getSrcId() &&
+        mappings[i].generated_position.line == pstate.position.line &&
+        mappings[i].generated_position.column == pstate.position.column
+      ) return SourceSpan(pstate.source, mappings[i].original_position, pstate.offset);
     }
-    return ParserState(pstate.path, pstate.src, Position(-1, -1, -1), Offset(0, 0));
+    return SourceSpan(pstate.source, Position(-1, -1, -1), Offset(0, 0));
 
   }