sassc 1.11.4 → 1.12.0

data/ext/libsass/src/prelexer.hpp

@@ -46,7 +46,7 @@ namespace Sass {
       src = exactly<beg>(src);
       if (!src) return 0;
       const char* stop;
-      while (1) {
+      while (true) {
         if (!*src) return 0;
         stop = exactly<end>(src);
         if (stop && (!esc || *(src - 1) != '\\')) return stop;
@@ -139,7 +139,7 @@ namespace Sass {
       src = exactly<beg>(src);
       if (!src) return 0;
       const char* stop;
-      while (1) {
+      while (true) {
         if (!*src) return 0;
         stop = exactly<end>(src);
         if (stop && (!esc || *(src - 1) != '\\')) return stop;
@@ -264,7 +264,6 @@ namespace Sass {
     const char* kwd_while_directive(const char* src);
 
     const char* re_nothing(const char* src);
-    const char* re_type_selector2(const char* src);
 
     const char* re_special_fun(const char* src);
 
@@ -355,6 +354,10 @@ namespace Sass {
     const char* ie_keyword_arg_value(const char* src);
     const char* ie_keyword_arg_property(const char* src);
 
+    // characters that terminate parsing of a list
+    const char* list_terminator(const char* src);
+    const char* space_list_terminator(const char* src);
+
     // match url()
     const char* H(const char* src);
     const char* W(const char* src);
@@ -362,6 +365,7 @@ namespace Sass {
     const char* UUNICODE(const char* src);
     const char* NONASCII(const char* src);
     const char* ESCAPE(const char* src);
+    const char* real_uri(const char* src);
     const char* real_uri_suffix(const char* src);
     // const char* real_uri_prefix(const char* src);
     const char* real_uri_value(const char* src);
@@ -376,6 +380,9 @@ namespace Sass {
     const char* static_property(const char* src);
     const char* static_value(const char* src);
 
+    const char* css_variable_value(const char* src);
+    const char* css_variable_top_level_value(const char* src);
+
     // Utility functions for finding and counting characters in a string.
     template<char c>
     const char* find_first(const char* src) {

data/ext/libsass/src/remove_placeholders.cpp

@@ -6,13 +6,12 @@
 
 namespace Sass {
 
-    Remove_Placeholders::Remove_Placeholders(Context& ctx)
-    : ctx(ctx)
+    Remove_Placeholders::Remove_Placeholders()
     { }
 
     void Remove_Placeholders::operator()(Block_Ptr b) {
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            Statement_Ptr st = &b->at(i);
+            Statement_Ptr st = b->at(i);
             st->perform(this);
         }
     }
@@ -34,19 +33,19 @@ namespace Sass {
 
     void Remove_Placeholders::operator()(Ruleset_Ptr r) {
         // Create a new selector group without placeholders
-        Selector_List_Obj sl = SASS_MEMORY_CAST(Selector_List, r->selector());
+        Selector_List_Obj sl = Cast<Selector_List>(r->selector());
 
         if (sl) {
           // Set the new placeholder selector list
-          r->selector(remove_placeholders(&sl));
+          r->selector(remove_placeholders(sl));
           // Remove placeholders in wrapped selectors
           for (Complex_Selector_Obj cs : sl->elements()) {
             while (cs) {
               if (cs->head()) {
                 for (Simple_Selector_Obj& ss : cs->head()->elements()) {
-                  if (Wrapped_Selector_Ptr ws = SASS_MEMORY_CAST(Wrapped_Selector, ss)) {
-                    if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, ws->selector())) {
-                      Selector_List_Ptr clean = remove_placeholders(sl);
+                  if (Wrapped_Selector_Ptr ws = Cast<Wrapped_Selector>(ss)) {
+                    if (Selector_List_Ptr wsl = Cast<Selector_List>(ws->selector())) {
+                      Selector_List_Ptr clean = remove_placeholders(wsl);
                       // also clean superflous parent selectors
                       // probably not really the correct place
                       clean->remove_parent_selectors();
@@ -72,10 +71,10 @@ namespace Sass {
     }
 
     void Remove_Placeholders::operator()(Media_Block_Ptr m) {
-        operator()(&m->block());
+        operator()(m->block());
     }
     void Remove_Placeholders::operator()(Supports_Block_Ptr m) {
-        operator()(&m->block());
+        operator()(m->block());
     }
 
     void Remove_Placeholders::operator()(Directive_Ptr a) {

data/ext/libsass/src/remove_placeholders.hpp

@@ -9,19 +9,15 @@
 namespace Sass {
 
 
-    class Context;
-
     class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
 
-        Context&          ctx;
-
         void fallback_impl(AST_Node_Ptr n) {}
 
     public:
       Selector_List_Ptr remove_placeholders(Selector_List_Ptr);
 
     public:
-        Remove_Placeholders(Context&);
+        Remove_Placeholders();
         ~Remove_Placeholders() { }
 
         void operator()(Block_Ptr);

data/ext/libsass/src/sass.cpp

@@ -7,6 +7,23 @@
 #include "sass.h"
 #include "file.hpp"
 #include "util.hpp"
+#include "sass_context.hpp"
+#include "sass_functions.hpp"
+
+namespace Sass {
+
+  // helper to convert string list to vector
+  std::vector<std::string> list2vec(struct string_list* cur)
+  {
+    std::vector<std::string> list;
+    while (cur) {
+      list.push_back(cur->string);
+      cur = cur->next;
+    }
+    return list;
+  }
+
+}
 
 extern "C" {
   using namespace Sass;
@@ -16,8 +33,10 @@ extern "C" {
   void* ADDCALL sass_alloc_memory(size_t size)
   {
     void* ptr = malloc(size);
-    if (ptr == NULL)
-      out_of_memory();
+    if (ptr == NULL) {
+      std::cerr << "Out of memory.\n";
+      exit(EXIT_FAILURE);
+    }
     return ptr;
   }
 
@@ -49,11 +68,50 @@ extern "C" {
     return sass_copy_c_string(unquoted.c_str());
   }
 
+  char* ADDCALL sass_compiler_find_include (const char* file, struct Sass_Compiler* compiler)
+  {
+    // get the last import entry to get current base directory
+    Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    // create the vector with paths to lookup
+    std::vector<std::string> paths(1 + incs.size());
+    paths.push_back(File::dir_name(import->abs_path));
+    paths.insert( paths.end(), incs.begin(), incs.end() );
+    // now resolve the file path relative to lookup paths
+    std::string resolved(File::find_include(file, paths));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
+  char* ADDCALL sass_compiler_find_file (const char* file, struct Sass_Compiler* compiler)
+  {
+    // get the last import entry to get current base directory
+    Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    // create the vector with paths to lookup
+    std::vector<std::string> paths(1 + incs.size());
+    paths.push_back(File::dir_name(import->abs_path));
+    paths.insert( paths.end(), incs.begin(), incs.end() );
+    // now resolve the file path relative to lookup paths
+    std::string resolved(File::find_file(file, paths));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
   // Make sure to free the returned value!
   // Incs array has to be null terminated!
-  char* ADDCALL sass_resolve_file (const char* file, const char* paths[])
+  // this has the original resolve logic for sass include
+  char* ADDCALL sass_find_include (const char* file, struct Sass_Options* opt)
   {
-    std::string resolved(File::find_file(file, paths));
+    std::vector<std::string> vec(list2vec(opt->include_paths));
+    std::string resolved(File::find_include(file, vec));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
+  // Make sure to free the returned value!
+  // Incs array has to be null terminated!
+  char* ADDCALL sass_find_file (const char* file, struct Sass_Options* opt)
+  {
+    std::vector<std::string> vec(list2vec(opt->include_paths));
+    std::string resolved(File::find_file(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 

data/ext/libsass/src/sass.hpp

@@ -90,10 +90,13 @@ struct Sass_Inspect_Options {
   // Precision for fractional numbers
   int precision;
 
+  // Do not compress colors in selectors
+  bool in_selector;
+
   // initialization list (constructor with defaults)
   Sass_Inspect_Options(Sass_Output_Style style = Sass::NESTED,
-                       int precision = 5)
-  : output_style(style), precision(precision)
+                       int precision = 5, bool in_selector = false)
+  : output_style(style), precision(precision), in_selector(in_selector)
   { }
 
 };

data/ext/libsass/src/sass_context.cpp

@@ -35,7 +35,6 @@ namespace Sass {
     catch (Exception::Base& e) {
       std::stringstream msg_stream;
       std::string cwd(Sass::File::get_cwd());
-
       std::string msg_prefix(e.errtype());
       bool got_newline = false;
       msg_stream << msg_prefix << ": ";
@@ -55,41 +54,49 @@ namespace Sass {
         ++msg;
       }
       if (!got_newline) msg_stream << "\n";
-      if (e.import_stack) {
-        for (size_t i = 1; i < e.import_stack->size() - 1; ++i) {
-          std::string path((*e.import_stack)[i]->imp_path);
-          std::string rel_path(Sass::File::abs2rel(path, cwd, cwd));
-          msg_stream << std::string(msg_prefix.size() + 2, ' ');
-          msg_stream << (i == 1 ? " on line " : " from line ");
-          msg_stream << e.pstate.line + 1 << " of " << rel_path << "\n";
-        }
-      }
-      else {
+
+      if (e.traces.empty()) {
+        // we normally should have some traces, still here as a fallback
         std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
         msg_stream << std::string(msg_prefix.size() + 2, ' ');
         msg_stream << " on line " << e.pstate.line + 1 << " of " << rel_path << "\n";
       }
+      else {
+        std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
+        msg_stream << traces_to_string(e.traces, "        ");
+      }
 
       // now create the code trace (ToDo: maybe have util functions?)
       if (e.pstate.line != std::string::npos && e.pstate.column != std::string::npos) {
-        size_t line = e.pstate.line;
+        size_t lines = e.pstate.line;
         const char* line_beg = e.pstate.src;
-        while (line_beg && *line_beg && line) {
-          if (*line_beg == '\n') --line;
-          ++line_beg;
+        // scan through src until target line
+        // move line_beg pointer to line start
+        while (line_beg && *line_beg && lines != 0) {
+          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;
-          line_end++;
+          utf8::unchecked::next(line_end);
         }
-        size_t max_left = 42; size_t max_right = 78;
-        size_t move_in = e.pstate.column > max_left ? e.pstate.column - max_left : 0;
-        size_t shorten = (line_end - line_beg) - move_in > max_right ?
-          (line_end - line_beg) - move_in - max_right : 0;
-        msg_stream << ">> " << std::string(line_beg + move_in, line_end - shorten) << "\n";
-        msg_stream << "   " << std::string(e.pstate.column - move_in, '-') << "^\n";
+        if (line_end && *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;
+        // reported excerpt should not exceed `max_chars` chars
+        if (e.pstate.column > line_len) left_chars = e.pstate.column;
+        if (e.pstate.column > left_chars) move_in = e.pstate.column - left_chars;
+        if (line_len > max_chars + move_in) shorten = line_len - move_in - max_chars;
+        utf8::advance(line_beg, move_in, line_end);
+        utf8::retreat(line_end, shorten, line_beg);
+        std::string sanitized; std::string marker(e.pstate.column - move_in, '-');
+        utf8::replace_invalid(line_beg, line_end, std::back_inserter(sanitized));
+        msg_stream << ">> " << sanitized << "\n";
+        msg_stream << "   " << marker << "^\n";
       }
 
       JsonNode* json_err = json_mkobject();
@@ -199,7 +206,6 @@ namespace Sass {
   static int handle_errors(Sass_Context* c_ctx) {
     try { return handle_error(c_ctx); }
     catch (...) { return handle_error(c_ctx); }
-    return c_ctx->error_status;
   }
 
   static Block_Obj sass_parse_block(Sass_Compiler* compiler) throw()
@@ -272,10 +278,14 @@ extern "C" {
   #define IMPLEMENT_SASS_OPTION_ACCESSOR(type, option) \
     type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return options->option; } \
     void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) { options->option = option; }
-  #define IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(type, option, def) \
-    type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return safe_str(options->option, def); } \
+  #define IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \
+    type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return safe_str(options->option, def); }
+  #define IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def) \
     void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) \
     { free(options->option); options->option = option || def ? sass_copy_c_string(option ? option : def) : 0; }
+  #define IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(type, option, def) \
+    IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \
+    IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def)
 
   #define IMPLEMENT_SASS_CONTEXT_GETTER(type, option) \
     type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }
@@ -327,7 +337,9 @@ extern "C" {
       c_ctx->error_column = std::string::npos;
 
       // allocate a new compiler instance
-      Sass_Compiler* compiler = (struct Sass_Compiler*) calloc(1, sizeof(struct Sass_Compiler));
+      void* ctxmem = calloc(1, sizeof(struct Sass_Compiler));
+      if (ctxmem == 0) { std::cerr << "Error allocating memory for context" << std::endl; return 0; }
+      Sass_Compiler* compiler = (struct Sass_Compiler*) ctxmem;
       compiler->state = SASS_COMPILER_CREATED;
 
       // store in sass compiler
@@ -468,7 +480,7 @@ extern "C" {
     if (compiler->c_ctx->error_status)
       return compiler->c_ctx->error_status;
     // parse the context we have set up (file or data)
-    compiler->root = &sass_parse_block(compiler);
+    compiler->root = sass_parse_block(compiler);
     // success
     return 0;
   }
@@ -512,36 +524,17 @@ extern "C" {
     options->c_headers = 0;
     options->plugin_paths = 0;
     options->include_paths = 0;
+    options->extensions = 0;
   }
 
   // helper function, not exported, only accessible locally
   static void sass_clear_options (struct Sass_Options* options)
   {
     if (options == 0) return;
-    // Deallocate custom functions
-    if (options->c_functions) {
-      Sass_Function_List this_func_data = options->c_functions;
-      while (this_func_data && *this_func_data) {
-        free(*this_func_data);
-        ++this_func_data;
-      }
-    }
-    // Deallocate custom headers
-    if (options->c_headers) {
-      Sass_Importer_List this_head_data = options->c_headers;
-      while (this_head_data && *this_head_data) {
-        free(*this_head_data);
-        ++this_head_data;
-      }
-    }
-    // Deallocate custom importers
-    if (options->c_importers) {
-      Sass_Importer_List this_imp_data = options->c_importers;
-      while (this_imp_data && *this_imp_data) {
-        free(*this_imp_data);
-        ++this_imp_data;
-      }
-    }
+    // Deallocate custom functions, headers and importes
+    sass_delete_function_list(options->c_functions);
+    sass_delete_importer_list(options->c_importers);
+    sass_delete_importer_list(options->c_headers);
     // Deallocate inc paths
     if (options->plugin_paths) {
       struct string_list* cur;
@@ -566,6 +559,18 @@ extern "C" {
         cur = next;
       }
     }
+    // Deallocate extension
+    if (options->extensions) {
+      struct string_list* cur;
+      struct string_list* next;
+      cur = options->extensions;
+      while (cur) {
+        next = cur->next;
+        free(cur->string);
+        free(cur);
+        cur = next;
+      }
+    }
     // Free options strings
     free(options->input_path);
     free(options->output_path);
@@ -573,11 +578,6 @@ extern "C" {
     free(options->include_path);
     free(options->source_map_file);
     free(options->source_map_root);
-    // Free custom functions
-    free(options->c_functions);
-    // Free custom importers
-    free(options->c_importers);
-    free(options->c_headers);
     // Reset our pointers
     options->input_path = 0;
     options->output_path = 0;
@@ -590,6 +590,7 @@ extern "C" {
     options->c_headers = 0;
     options->plugin_paths = 0;
     options->include_paths = 0;
+    options->extensions = 0;
   }
 
   // helper function, not exported, only accessible locally
@@ -674,6 +675,10 @@ extern "C" {
   size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.size(); }
   Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.back(); }
   Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx) { return compiler->cpp_ctx->import_stack[idx]; }
+  // Getters for Sass_Compiler options (query function stack)
+  size_t ADDCALL sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->callee_stack.size(); }
+  Sass_Callee_Entry ADDCALL sass_compiler_get_last_callee(struct Sass_Compiler* compiler) { return &compiler->cpp_ctx->callee_stack.back(); }
+  Sass_Callee_Entry ADDCALL sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx) { return &compiler->cpp_ctx->callee_stack[idx]; }
 
   // Calculate the size of the stored null terminated array
   size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx)
@@ -693,10 +698,10 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_headers);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);
+  IMPLEMENT_SASS_OPTION_STRING_SETTER(const char*, plugin_path, 0);
+  IMPLEMENT_SASS_OPTION_STRING_SETTER(const char*, include_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, output_path, 0);
-  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, plugin_path, 0);
-  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, include_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_file, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_root, 0);
 
@@ -722,6 +727,22 @@ extern "C" {
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char**, included_files);
 
+  // Push function for import extenions
+  void ADDCALL sass_option_push_import_extension(struct Sass_Options* options, const char* ext)
+  {
+    struct string_list* extension = (struct string_list*) calloc(1, sizeof(struct string_list));
+    if (extension == 0) return;
+    extension->string = ext ? sass_copy_c_string(ext) : 0;
+    struct string_list* last = options->extensions;
+    if (!options->extensions) {
+      options->extensions = extension;
+    } else {
+      while (last->next)
+        last = last->next;
+      last->next = extension;
+    }
+  }
+
   // Push function for include paths (no manipulation support for now)
   void ADDCALL sass_option_push_include_path(struct Sass_Options* options, const char* path)
   {
@@ -740,6 +761,23 @@ extern "C" {
 
   }
 
+  // Push function for include paths (no manipulation support for now)
+  size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options)
+  {
+    size_t len = 0;
+    struct string_list* cur = options->include_paths;
+    while (cur) { len ++; cur = cur->next; }
+    return len;
+  }
+
+  // Push function for include paths (no manipulation support for now)
+  const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i)
+  {
+    struct string_list* cur = options->include_paths;
+    while (i) { i--; cur = cur->next; }
+    return cur->string;
+  }
+
   // Push function for plugin paths (no manipulation support for now)
   void ADDCALL sass_option_push_plugin_path(struct Sass_Options* options, const char* path)
   {