sassc 1.11.4 → 1.12.0

data/ext/libsass/src/sass_context.hpp

@@ -1,9 +1,8 @@
 #ifndef SASS_SASS_CONTEXT_H
 #define SASS_SASS_CONTEXT_H
 
-#include "sass.h"
-#include "sass.hpp"
-#include "context.hpp"
+#include "sass/base.h"
+#include "sass/context.h"
 #include "ast_fwd_decl.hpp"
 
 // sass config options structure
@@ -33,7 +32,7 @@ struct Sass_Options : Sass_Output_Options {
   char* input_path;
 
   // The output path is used for source map
-  // generation. Libsass will not write to
+  // generation. LibSass will not write to
   // this file, it is just used to create
   // information in source-maps etc.
   char* output_path;
@@ -41,9 +40,12 @@ struct Sass_Options : Sass_Output_Options {
   // Colon-separated list of paths
   // Semicolon-separated on Windows
   // Maybe use array interface instead?
+  char* extension;
   char* include_path;
   char* plugin_path;
 
+  // Extensions (linked string list)
+  struct string_list* extensions;
   // Include paths (linked string list)
   struct string_list* include_paths;
   // Plugin paths (linked string list)
@@ -127,4 +129,4 @@ struct Sass_Compiler {
   Sass::Block_Obj root;
 };
 
-#endif
+#endif

data/ext/libsass/src/sass_functions.cpp

@@ -2,6 +2,7 @@
 #include <cstring>
 #include "util.hpp"
 #include "context.hpp"
+#include "values.hpp"
 #include "sass/functions.h"
 #include "sass_functions.hpp"
 
@@ -17,12 +18,30 @@ extern "C" {
   {
     Sass_Function_Entry cb = (Sass_Function_Entry) calloc(1, sizeof(Sass_Function));
     if (cb == 0) return 0;
-    cb->signature = signature;
+    cb->signature = sass_copy_c_string(signature);
     cb->function = function;
     cb->cookie = cookie;
     return cb;
   }
 
+  void ADDCALL sass_delete_function(Sass_Function_Entry entry)
+  {
+    free(entry->signature);
+    free(entry);
+  }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_function_list(Sass_Function_List list)
+  {
+    Sass_Function_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_function(*list);
+      ++list;
+    }
+    free(it);
+  }
+
   // Setters and getters for callbacks on function lists
   Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos) { return list[pos]; }
   void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb) { list[pos] = cb; }
@@ -57,6 +76,18 @@ extern "C" {
     return (Sass_Importer_List) calloc(length + 1, sizeof(Sass_Importer_Entry));
   }
 
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_importer_list(Sass_Importer_List list)
+  {
+    Sass_Importer_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_importer(*list);
+      ++list;
+    }
+    free(it);
+  }
+
   Sass_Importer_Entry ADDCALL sass_importer_get_list_entry(Sass_Importer_List list, size_t idx) { return list[idx]; }
   void ADDCALL sass_importer_set_list_entry(Sass_Importer_List list, size_t idx, Sass_Importer_Entry cb) { list[idx] = cb; }
 
@@ -126,6 +157,37 @@ extern "C" {
     free(import);
   }
 
+  // Getter for callee entry
+  const char* ADDCALL sass_callee_get_name(Sass_Callee_Entry entry) { return entry->name; }
+  const char* ADDCALL sass_callee_get_path(Sass_Callee_Entry entry) { return entry->path; }
+  size_t ADDCALL sass_callee_get_line(Sass_Callee_Entry entry) { return entry->line; }
+  size_t ADDCALL sass_callee_get_column(Sass_Callee_Entry entry) { return entry->column; }
+  enum Sass_Callee_Type ADDCALL sass_callee_get_type(Sass_Callee_Entry entry) { return entry->type; }
+  Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry entry) { return &entry->env; }
+
+  // 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]);
+    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));
+    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));
+    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) {
+    env->frame->set_global(name, sass_value_to_ast_node(val));
+  }
+
   // Getter for import entry
   const char* ADDCALL sass_import_get_imp_path(Sass_Import_Entry entry) { return entry->imp_path; }
   const char* ADDCALL sass_import_get_abs_path(Sass_Import_Entry entry) { return entry->abs_path; }

data/ext/libsass/src/sass_functions.hpp

@@ -2,10 +2,12 @@
 #define SASS_SASS_FUNCTIONS_H
 
 #include "sass.h"
+#include "environment.hpp"
+#include "functions.hpp"
 
 // Struct to hold custom function callback
 struct Sass_Function {
-  const char*      signature;
+  char*            signature;
   Sass_Function_Fn function;
   void*            cookie;
 };
@@ -22,6 +24,22 @@ struct Sass_Import {
   size_t column;
 };
 
+// External environments
+struct Sass_Env {
+  // links to parent frames
+  Sass::Env* frame;
+};
+
+// External call entry
+struct Sass_Callee {
+  const char* name;
+  const char* path;
+  size_t line;
+  size_t column;
+  enum Sass_Callee_Type type;
+  struct Sass_Env env;
+};
+
 // Struct to hold importer callback
 struct Sass_Importer {
   Sass_Importer_Fn importer;

data/ext/libsass/src/sass_util.cpp

@@ -37,7 +37,7 @@ namespace Sass {
       end
     end
   */
-  Node paths(const Node& arrs, Context& ctx) {
+  Node paths(const Node& arrs) {
 
     Node loopStart = Node::createCollection();
     loopStart.collection()->push_back(Node::createCollection());
@@ -108,7 +108,7 @@ namespace Sass {
     return flattened
   end
   */
-  Node flatten(Node& arr, Context& ctx, int n) {
+  Node flatten(Node& arr, int n) {
     if (n != -1 && n == 0) {
       return arr;
     }
@@ -124,7 +124,7 @@ namespace Sass {
       if (e.isCollection()) {
 
       	// e.collection().got_line_feed = e.got_line_feed;
-      	Node recurseFlattened = flatten(e, ctx, n - 1);
+      	Node recurseFlattened = flatten(e, n - 1);
 
       	if(e.got_line_feed) {
       		 flattened.got_line_feed = e.got_line_feed;

data/ext/libsass/src/sass_util.hpp

@@ -28,7 +28,7 @@ namespace Sass {
     #     #  [1, 4, 5],
     #     #  [2, 4, 5]]
   */
-  Node paths(const Node& arrs, Context& ctx);
+  Node paths(const Node& arrs);
 
 
   /*
@@ -40,7 +40,7 @@ namespace Sass {
     bool operator()(const Node& one, const Node& two, Node& out) const {
       // TODO: Is this the correct C++ interpretation?
       // block ||= proc {|a, b| a == b && a}
-      if (nodesEqual(one, two, true)) {
+      if (one == two) {
         out = one;
         return true;
       }
@@ -139,7 +139,7 @@ namespace Sass {
   http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
   */
   template<typename ComparatorType>
-  Node lcs(Node& x, Node& y, const ComparatorType& comparator, Context& ctx) {
+  Node lcs(Node& x, Node& y, const ComparatorType& comparator) {
     DEBUG_PRINTLN(LCS, "LCS: X=" << x << " Y=" << y)
 
     Node newX = Node::createCollection();
@@ -169,7 +169,7 @@ namespace Sass {
   # @param n [int] The number of levels to flatten
   # @return [NodeCollection] The flattened array
   */
-  Node flatten(Node& arr, Context& ctx, int n = -1);
+  Node flatten(Node& arr, int n = -1);
 
 
   /*

data/ext/libsass/src/sass_values.cpp

@@ -4,6 +4,7 @@
 #include "util.hpp"
 #include "eval.hpp"
 #include "values.hpp"
+#include "operators.hpp"
 #include "sass/values.h"
 #include "sass_values.hpp"
 
@@ -54,6 +55,8 @@ extern "C" {
   size_t ADDCALL sass_list_get_length(const union Sass_Value* v) { return v->list.length; }
   enum Sass_Separator ADDCALL sass_list_get_separator(const union Sass_Value* v) { return v->list.separator; }
   void ADDCALL sass_list_set_separator(union Sass_Value* v, enum Sass_Separator separator) { v->list.separator = separator; }
+  bool ADDCALL sass_list_get_is_bracketed(const union Sass_Value* v) { return v->list.is_bracketed; }
+  void ADDCALL sass_list_set_is_bracketed(union Sass_Value* v, bool is_bracketed) { v->list.is_bracketed = is_bracketed; }
   // Getters and setters for Sass_List values
   union Sass_Value* ADDCALL sass_list_get_value(const union Sass_Value* v, size_t i) { return v->list.values[i]; }
   void ADDCALL sass_list_set_value(union Sass_Value* v, size_t i, union Sass_Value* value) { v->list.values[i] = value; }
@@ -130,13 +133,14 @@ extern "C" {
     return v;
   }
 
-  union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep)
+  union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep, bool is_bracketed)
   {
     union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->list.tag = SASS_LIST;
     v->list.length = len;
     v->list.separator = sep;
+    v->list.is_bracketed = is_bracketed;
     v->list.values = (union Sass_Value**) calloc(len, sizeof(union Sass_Value*));
     if (v->list.values == 0) { free(v); return 0; }
     return v;
@@ -218,6 +222,7 @@ extern "C" {
         case SASS_WARNING: {
                 free(val->error.message);
         }   break;
+        default: break;
     }
 
     free(val);
@@ -233,26 +238,26 @@ extern "C" {
     switch(val->unknown.tag) {
         case SASS_NULL: {
                 return sass_make_null();
-        }   break;
+        }
         case SASS_BOOLEAN: {
                 return sass_make_boolean(val->boolean.value);
-        }   break;
+        }
         case SASS_NUMBER: {
                 return sass_make_number(val->number.value, val->number.unit);
-        }   break;
+        }
         case SASS_COLOR: {
                 return sass_make_color(val->color.r, val->color.g, val->color.b, val->color.a);
-        }   break;
+        }
         case SASS_STRING: {
                 return sass_string_is_quoted(val) ? sass_make_qstring(val->string.value) : sass_make_string(val->string.value);
-        }   break;
+        }
         case SASS_LIST: {
-                union Sass_Value* list = sass_make_list(val->list.length, val->list.separator);
+                union Sass_Value* list = sass_make_list(val->list.length, val->list.separator, val->list.is_bracketed);
                 for (i = 0; i < list->list.length; i++) {
                     list->list.values[i] = sass_clone_value(val->list.values[i]);
                 }
                 return list;
-        }   break;
+        }
         case SASS_MAP: {
                 union Sass_Value* map = sass_make_map(val->map.length);
                 for (i = 0; i < val->map.length; i++) {
@@ -260,13 +265,14 @@ extern "C" {
                     map->map.pairs[i].value = sass_clone_value(val->map.pairs[i].value);
                 }
                 return map;
-        }   break;
+        }
         case SASS_ERROR: {
                 return sass_make_error(val->error.message);
-        }   break;
+        }
         case SASS_WARNING: {
                 return sass_make_warning(val->warning.message);
-        }   break;
+        }
+        default: break;
     }
 
     return 0;
@@ -284,7 +290,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 = 0;
+    Sass::Value_Ptr rv;
 
     try {
 
@@ -294,41 +300,41 @@ extern "C" {
 
       // see if it's a relational expression
       switch(op) {
-        case Sass_OP::EQ:  return sass_make_boolean(Eval::eq(&lhs, &rhs));
-        case Sass_OP::NEQ: return sass_make_boolean(!Eval::eq(&lhs, &rhs));
-        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(&lhs, &rhs, "gt") && !Eval::eq(&lhs, &rhs));
-        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(&lhs, &rhs, "gte"));
-        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(&lhs, &rhs, "lt"));
-        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(&lhs, &rhs, "lte") || Eval::eq(&lhs, &rhs));
-        case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? &lhs : &rhs);
-        case Sass_OP::OR:  return ast_node_to_sass_value(lhs->is_false() ? &rhs : &lhs);
-        default:           break;
+        case Sass_OP::EQ:  return sass_make_boolean(Operators::eq(lhs, rhs));
+        case Sass_OP::NEQ: return sass_make_boolean(Operators::neq(lhs, rhs));
+        case Sass_OP::GT:  return sass_make_boolean(Operators::gt(lhs, rhs));
+        case Sass_OP::GTE: return sass_make_boolean(Operators::gte(lhs, rhs));
+        case Sass_OP::LT:  return sass_make_boolean(Operators::lt(lhs, rhs));
+        case Sass_OP::LTE: return sass_make_boolean(Operators::lte(lhs, rhs));
+        case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? lhs : rhs);
+        case Sass_OP::OR:  return ast_node_to_sass_value(lhs->is_false() ? rhs : lhs);
+        default: break;
       }
 
       if (sass_value_is_number(a) && sass_value_is_number(b)) {
-        Number_Ptr_Const l_n = SASS_MEMORY_CAST(Number, lhs);
-        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
-        rv = Eval::op_numbers(op, *l_n, *r_n, options);
+        Number_Ptr_Const l_n = Cast<Number>(lhs);
+        Number_Ptr_Const 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 = SASS_MEMORY_CAST(Number, lhs);
-        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
-        rv = Eval::op_number_color(op, *l_n, *r_c, options);
+        Number_Ptr_Const l_n = Cast<Number>(lhs);
+        Color_Ptr_Const r_c = Cast<Color>(rhs);
+        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 = SASS_MEMORY_CAST(Color, lhs);
-        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
-        rv = Eval::op_color_number(op, *l_c, *r_n, options);
+        Color_Ptr_Const l_c = Cast<Color>(lhs);
+        Number_Ptr_Const 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 = SASS_MEMORY_CAST(Color, lhs);
-        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
-        rv = Eval::op_colors(op, *l_c, *r_c, options);
+        Color_Ptr_Const l_c = Cast<Color>(lhs);
+        Color_Ptr_Const r_c = Cast<Color>(rhs);
+        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 = SASS_MEMORY_CAST(Value, lhs);
-        Value_Ptr r_v = SASS_MEMORY_CAST(Value, rhs);
-        rv = Eval::op_strings(op, *l_v, *r_v, options);
+        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());
       }
 
       // ToDo: maybe we should should return null value?
@@ -346,9 +352,6 @@ extern "C" {
     catch (std::string& e) { return sass_make_error(e.c_str()); }
     catch (const char* e) { return sass_make_error(e); }
     catch (...) { return sass_make_error("unknown"); }
-
-    return 0;
-
   }
 
 }

data/ext/libsass/src/sass_values.hpp

@@ -35,6 +35,7 @@ struct Sass_String {
 struct Sass_List {
   enum Sass_Tag       tag;
   enum Sass_Separator separator;
+  bool                is_bracketed;
   size_t              length;
   // null terminated "array"
   union Sass_Value**  values;
@@ -78,4 +79,4 @@ struct Sass_MapPair {
   union Sass_Value* value;
 };
 
-#endif
+#endif

data/ext/libsass/src/source_map.cpp

@@ -2,7 +2,6 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include <cstddef>
 #include <iomanip>
 
 #include "ast.hpp"
@@ -25,9 +24,9 @@ namespace Sass {
 
     json_append_member(json_srcmap, "version", json_mknumber(3));
 
-    const char *include = file.c_str();
-    JsonNode *json_include = json_mkstring(include);
-    json_append_member(json_srcmap, "file", json_include);
+    const char *file_name = file.c_str();
+    JsonNode *json_file_name = json_mkstring(file_name);
+    json_append_member(json_srcmap, "file", json_file_name);
 
     // pass-through sourceRoot option
     if (!ctx.source_map_root.empty()) {
@@ -35,35 +34,34 @@ namespace Sass {
       json_append_member(json_srcmap, "sourceRoot", root);
     }
 
-    JsonNode *json_includes = json_mkarray();
+    JsonNode *json_sources = json_mkarray();
     for (size_t i = 0; i < source_index.size(); ++i) {
-      std::string include(links[source_index[i]]);
+      std::string source(links[source_index[i]]);
       if (ctx.c_options.source_map_file_urls) {
-        include = File::rel2abs(include);
+        source = File::rel2abs(source);
         // check for windows abs path
-        if (include[0] == '/') {
+        if (source[0] == '/') {
           // ends up with three slashes
-          include = "file://" + include;
+          source = "file://" + source;
         } else {
           // needs an additional slash
-          include = "file:///" + include;
+          source = "file:///" + source;
         }
       }
-      const char* inc = include.c_str();
-      JsonNode *json_include = json_mkstring(inc);
-      json_append_element(json_includes, json_include);
+      const char* source_name = source.c_str();
+      JsonNode *json_source_name = json_mkstring(source_name);
+      json_append_element(json_sources, json_source_name);
     }
-    json_append_member(json_srcmap, "sources", json_includes);
+    json_append_member(json_srcmap, "sources", json_sources);
 
-    if (include_sources) {
+    if (include_sources && source_index.size()) {
       JsonNode *json_contents = json_mkarray();
       for (size_t i = 0; i < source_index.size(); ++i) {
         const Resource& resource(sources[source_index[i]]);
         JsonNode *json_content = json_mkstring(resource.contents);
         json_append_element(json_contents, json_content);
       }
-      if (json_contents->children.head)
-        json_append_member(json_srcmap, "sourcesContent", json_contents);
+      json_append_member(json_srcmap, "sourcesContent", json_contents);
     }
 
     JsonNode *json_names = json_mkarray();
@@ -138,7 +136,7 @@ namespace Sass {
         }
       }
     }
-    // will adjust the offset
+    // adjust the buffer offset
     prepend(Offset(out.buffer));
     // now add the new mappings
     VECTOR_UNSHIFT(mappings, out.smap.mappings);