sassc 2.3.0 → 2.4.0

data/ext/libsass/src/plugins.hpp

@@ -36,19 +36,19 @@ namespace Sass {
 
     public: // methods
       // load one specific plugin
-      bool load_plugin(const std::string& path);
+      bool load_plugin(const sass::string& path);
       // load all plugins from a directory
-      size_t load_plugins(const std::string& path);
+      size_t load_plugins(const sass::string& path);
 
     public: // public accessors
-      const std::vector<Sass_Importer_Entry> get_headers(void) { return headers; }
-      const std::vector<Sass_Importer_Entry> get_importers(void) { return importers; }
-      const std::vector<Sass_Function_Entry> get_functions(void) { return functions; }
+      const sass::vector<Sass_Importer_Entry> get_headers(void) { return headers; }
+      const sass::vector<Sass_Importer_Entry> get_importers(void) { return importers; }
+      const sass::vector<Sass_Function_Entry> get_functions(void) { return functions; }
 
     private: // private vars
-      std::vector<Sass_Importer_Entry> headers;
-      std::vector<Sass_Importer_Entry> importers;
-      std::vector<Sass_Function_Entry> functions;
+      sass::vector<Sass_Importer_Entry> headers;
+      sass::vector<Sass_Importer_Entry> importers;
+      sass::vector<Sass_Function_Entry> functions;
 
   };
 

data/ext/libsass/src/position.cpp

@@ -3,6 +3,7 @@
 #include "sass.hpp"
 
 #include "position.hpp"
+#include "source.hpp"
 
 namespace Sass {
 
@@ -18,7 +19,7 @@ namespace Sass {
     *this = inc(string, string + strlen(string));
   }
 
-  Offset::Offset(const std::string& text)
+  Offset::Offset(const sass::string& text)
   : line(0), column(0)
   {
     *this = inc(text.c_str(), text.c_str() + text.size());
@@ -56,7 +57,7 @@ namespace Sass {
         // skip over 10xxxxxx
         // is 1st bit not set
         if ((chr & 128) == 0) {
-          // regular ascii char
+          // regular ASCII char
           column += 1;
         }
         // is 2nd bit not set
@@ -117,14 +118,11 @@ namespace Sass {
   : Offset(line, column), file(file) { }
 
 
-  ParserState::ParserState(const char* path, const char* src, const size_t file)
-  : Position(file, 0, 0), path(path), src(src), offset(0, 0), token() { }
+  SourceSpan::SourceSpan(const char* path)
+  : source(SASS_MEMORY_NEW(SynthFile, path)), position(0, 0), offset(0, 0) { }
 
-  ParserState::ParserState(const char* path, const char* src, const Position& position, Offset offset)
-  : Position(position), path(path), src(src), offset(offset), token() { }
-
-  ParserState::ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset)
-  : Position(position), path(path), src(src), offset(offset), token(token) { }
+  SourceSpan::SourceSpan(SourceDataObj source, const Offset& position, const Offset& offset)
+    : source(source), position(position), offset(offset) { }
 
   Position Position::add(const char* begin, const char* end)
   {
@@ -164,21 +162,4 @@ namespace Sass {
     return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
-  /* not used anymore - remove?
-  std::ostream& operator<<(std::ostream& strm, const Offset& off)
-  {
-    if (off.line == string::npos) strm << "-1:"; else strm << off.line << ":";
-    if (off.column == string::npos) strm << "-1"; else strm << off.column;
-    return strm;
-  } */
-
-  /* not used anymore - remove?
-  std::ostream& operator<<(std::ostream& strm, const Position& pos)
-  {
-    if (pos.file != string::npos) strm << pos.file << ":";
-    if (pos.line == string::npos) strm << "-1:"; else strm << pos.line << ":";
-    if (pos.column == string::npos) strm << "-1"; else strm << pos.column;
-    return strm;
-  } */
-
 }

data/ext/libsass/src/position.hpp

@@ -3,7 +3,8 @@
 
 #include <string>
 #include <cstring>
-// #include <iostream>
+#include "source_data.hpp"
+#include "ast_fwd_decl.hpp"
 
 namespace Sass {
 
@@ -13,7 +14,7 @@ namespace Sass {
     public: // c-tor
       Offset(const char chr);
       Offset(const char* string);
-      Offset(const std::string& text);
+      Offset(const sass::string& text);
       Offset(const size_t line, const size_t column);
 
       // return new position, incremented by the given string
@@ -85,37 +86,59 @@ namespace Sass {
     : prefix(p), begin(b), end(e) { }
 
     size_t length()    const { return end - begin; }
-    std::string ws_before() const { return std::string(prefix, begin); }
-    std::string to_string() const { return std::string(begin, end); }
-    std::string time_wspace() const {
-      std::string str(to_string());
-      std::string whitespaces(" \t\f\v\n\r");
+    sass::string ws_before() const { return sass::string(prefix, begin); }
+    sass::string to_string() const { return sass::string(begin, end); }
+    sass::string time_wspace() const {
+      sass::string str(to_string());
+      sass::string whitespaces(" \t\f\v\n\r");
       return str.erase(str.find_last_not_of(whitespaces)+1);
     }
 
     operator bool()        { return begin && end && begin >= end; }
-    operator std::string() { return to_string(); }
+    operator sass::string() { return to_string(); }
 
     bool operator==(Token t)  { return to_string() == t.to_string(); }
   };
 
-  class ParserState : public Position {
+  class SourceSpan {
 
-    public: // c-tor
-      ParserState(const char* path, const char* src = 0, const size_t file = std::string::npos);
-      ParserState(const char* path, const char* src, const Position& position, Offset offset = Offset(0, 0));
-      ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset = Offset(0, 0));
+    public:
 
-    public: // down casts
-      Offset off() { return *this; }
-      Position pos() { return *this; }
-      ParserState pstate() { return *this; }
+      SourceSpan(const char* path);
 
-    public:
-      const char* path;
-      const char* src;
+      SourceSpan(SourceDataObj source,
+        const Offset& position = Offset(0, 0),
+        const Offset& offset = Offset(0, 0));
+
+      const char* getPath() const {
+        return source->getPath();
+      }
+
+      const char* getRawData() const {
+        return source->getRawData();
+      }
+
+      Offset getPosition() const {
+        return position;
+      }
+
+      size_t getLine() const {
+        return position.line + 1;
+      }
+
+      size_t getColumn() const {
+        return position.column + 1;
+      }
+
+      size_t getSrcId() const {
+        return source == nullptr
+          ? std::string::npos
+          : source->getSrcId();
+      }
+
+      SourceDataObj source;
+      Offset position;
       Offset offset;
-      Token token;
 
   };
 

data/ext/libsass/src/remove_placeholders.cpp

@@ -18,7 +18,7 @@ namespace Sass {
 
     void Remove_Placeholders::remove_placeholders(SimpleSelector* simple)
     {
-      if (Pseudo_Selector * pseudo = simple->getPseudoSelector()) {
+      if (PseudoSelector * pseudo = simple->getPseudoSelector()) {
         if (pseudo->selector()) remove_placeholders(pseudo->selector());
       }
     }
@@ -60,7 +60,7 @@ namespace Sass {
       if (rule->block()) operator()(rule->block());
     }
 
-    void Remove_Placeholders::operator()(Ruleset* r)
+    void Remove_Placeholders::operator()(StyleRule* r)
     {
       if (SelectorListObj sl = r->selector()) {
         // Set the new placeholder selector list
@@ -73,12 +73,12 @@ namespace Sass {
       }
     }
 
-    void Remove_Placeholders::operator()(Supports_Block* m)
+    void Remove_Placeholders::operator()(SupportsRule* m)
     {
       if (m->block()) operator()(m->block());
     }
 
-    void Remove_Placeholders::operator()(Directive* a)
+    void Remove_Placeholders::operator()(AtRule* a)
     {
       if (a->block()) a->block()->perform(this);
     }

data/ext/libsass/src/remove_placeholders.hpp

@@ -21,10 +21,10 @@ namespace Sass {
     ~Remove_Placeholders() { }
 
     void operator()(Block*);
-    void operator()(Ruleset*);
+    void operator()(StyleRule*);
     void operator()(CssMediaRule*);
-    void operator()(Supports_Block*);
-    void operator()(Directive*);
+    void operator()(SupportsRule*);
+    void operator()(AtRule*);
 
     // ignore missed types
     template <typename U>

data/ext/libsass/src/sass.cpp

@@ -17,9 +17,9 @@
 namespace Sass {
 
   // helper to convert string list to vector
-  std::vector<std::string> list2vec(struct string_list* cur)
+  sass::vector<sass::string> list2vec(struct string_list* cur)
   {
-    std::vector<std::string> list;
+    sass::vector<sass::string> list;
     while (cur) {
       list.push_back(cur->string);
       cur = cur->next;
@@ -46,6 +46,7 @@ extern "C" {
 
   char* ADDCALL sass_copy_c_string(const char* str)
   {
+    if (str == nullptr) return nullptr;
     size_t len = strlen(str) + 1;
     char* cpy = (char*) sass_alloc_memory(len);
     std::memcpy(cpy, str, len);
@@ -61,14 +62,14 @@ extern "C" {
   // caller must free the returned memory
   char* ADDCALL sass_string_quote (const char *str, const char quote_mark)
   {
-    std::string quoted = quote(str, quote_mark);
+    sass::string quoted = quote(str, quote_mark);
     return sass_copy_c_string(quoted.c_str());
   }
 
   // caller must free the returned memory
   char* ADDCALL sass_string_unquote (const char *str)
   {
-    std::string unquoted = unquote(str);
+    sass::string unquoted = unquote(str);
     return sass_copy_c_string(unquoted.c_str());
   }
 
@@ -76,13 +77,13 @@ extern "C" {
   {
     // 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;
+    const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
     // create the vector with paths to lookup
-    std::vector<std::string> paths(1 + incs.size());
+    sass::vector<sass::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));
+    sass::string resolved(File::find_include(file, paths));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -90,13 +91,13 @@ extern "C" {
   {
     // 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;
+    const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
     // create the vector with paths to lookup
-    std::vector<std::string> paths(1 + incs.size());
+    sass::vector<sass::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));
+    sass::string resolved(File::find_file(file, paths));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -105,8 +106,8 @@ extern "C" {
   // this has the original resolve logic for sass include
   char* ADDCALL sass_find_include (const char* file, struct Sass_Options* opt)
   {
-    std::vector<std::string> vec(list2vec(opt->include_paths));
-    std::string resolved(File::find_include(file, vec));
+    sass::vector<sass::string> vec(list2vec(opt->include_paths));
+    sass::string resolved(File::find_include(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -114,8 +115,8 @@ extern "C" {
   // 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));
+    sass::vector<sass::string> vec(list2vec(opt->include_paths));
+    sass::string resolved(File::find_file(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -136,7 +137,7 @@ extern "C" {
 namespace Sass {
 
   // helper to aid dreaded MSVC debug mode
-  char* sass_copy_string(std::string str)
+  char* sass_copy_string(sass::string str)
   {
     // In MSVC the following can lead to segfault:
     // sass_copy_c_string(stream.str().c_str());

data/ext/libsass/src/sass.hpp

@@ -11,7 +11,7 @@
 #pragma warning(disable : 4005)
 #endif
 
-// aplies to MSVC and MinGW
+// applies to MSVC and MinGW
 #ifdef _WIN32
 // we do not want the ERROR macro
 # ifndef NOGDI
@@ -48,13 +48,17 @@
 #endif
 
 
-// include C-API header
+// Include C-API header
 #include "sass/base.h"
 
+// Include allocator
+#include "memory.hpp"
+
 // For C++ helper
 #include <string>
+#include <vector>
 
-// output behaviours
+// output behavior
 namespace Sass {
 
   // create some C++ aliases for the most used options
@@ -69,11 +73,11 @@ namespace Sass {
 
   // helper to aid dreaded MSVC debug mode
   // see implementation for more details
-  char* sass_copy_string(std::string str);
+  char* sass_copy_string(sass::string str);
 
 }
 
-// input behaviours
+// input behaviors
 enum Sass_Input_Style {
   SASS_CONTEXT_NULL,
   SASS_CONTEXT_FILE,

data/ext/libsass/src/sass_context.cpp

@@ -10,17 +10,17 @@
 
 // C++ helper
 namespace Sass {
-  // see sass_copy_c_string(std::string str)
-  static inline JsonNode* json_mkstream(const std::stringstream& stream)
+  // see sass_copy_c_string(sass::string str)
+  static inline JsonNode* json_mkstream(const sass::ostream& stream)
   {
     // hold on to string on stack!
-    std::string str(stream.str());
+    sass::string str(stream.str());
     return json_mkstring(str.c_str());
   }
 
-  static void handle_string_error(Sass_Context* c_ctx, const std::string& msg, int severety)
+  static void handle_string_error(Sass_Context* c_ctx, const sass::string& msg, int severety)
   {
-    std::stringstream msg_stream;
+    sass::ostream msg_stream;
     JsonNode* json_err = json_mkobject();
     msg_stream << "Internal Error: " << msg << std::endl;
     json_append_member(json_err, "status", json_mknumber(severety));
@@ -41,9 +41,9 @@ namespace Sass {
       throw;
     }
     catch (Exception::Base& e) {
-      std::stringstream msg_stream;
-      std::string cwd(Sass::File::get_cwd());
-      std::string msg_prefix(e.errtype());
+      sass::ostream msg_stream;
+      sass::string cwd(Sass::File::get_cwd());
+      sass::string msg_prefix(e.errtype());
       bool got_newline = false;
       msg_stream << msg_prefix << ": ";
       const char* msg = e.what();
@@ -55,7 +55,7 @@ namespace Sass {
           got_newline = true;
         }
         else if (got_newline) {
-          msg_stream << std::string(msg_prefix.size() + 2, ' ');
+          msg_stream << sass::string(msg_prefix.size() + 2, ' ');
           got_newline = false;
         }
         msg_stream << *msg;
@@ -65,24 +65,25 @@ namespace Sass {
 
       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";
+        sass::string rel_path(Sass::File::abs2rel(e.pstate.getPath(), cwd, cwd));
+        msg_stream << sass::string(msg_prefix.size() + 2, ' ');
+        msg_stream << " on line " << e.pstate.getLine() << " of " << rel_path << "\n";
       }
       else {
-        std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
+        sass::string rel_path(Sass::File::abs2rel(e.pstate.getPath(), 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 &&
-          e.pstate.src != nullptr) {
-        size_t lines = e.pstate.line;
+      if (e.pstate.position.line != sass::string::npos &&
+          e.pstate.position.column != sass::string::npos &&
+          e.pstate.source != nullptr) {
+        Offset offset(e.pstate.position);
+        size_t lines = offset.line;
         // scan through src until target line
         // move line_beg pointer to line start
         const char* line_beg;
-        for (line_beg = e.pstate.src; *line_beg != '\0'; ++line_beg) {
+        for (line_beg = e.pstate.getRawData(); *line_beg != '\0'; ++line_beg) {
           if (lines == 0) break;
           if (*line_beg == '\n') --lines;
         }
@@ -96,12 +97,12 @@ namespace Sass {
         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 (offset.column > line_len) left_chars = offset.column;
+        if (offset.column > left_chars) move_in = offset.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, '-');
+        sass::string sanitized; sass::string marker(offset.column - move_in, '-');
         utf8::replace_invalid(line_beg, line_end, std::back_inserter(sanitized));
         msg_stream << ">> " << sanitized << "\n";
         msg_stream << "   " << marker << "^\n";
@@ -109,9 +110,9 @@ namespace Sass {
 
       JsonNode* json_err = json_mkobject();
       json_append_member(json_err, "status", json_mknumber(1));
-      json_append_member(json_err, "file", json_mkstring(e.pstate.path));
-      json_append_member(json_err, "line", json_mknumber((double)(e.pstate.line + 1)));
-      json_append_member(json_err, "column", json_mknumber((double)(e.pstate.column + 1)));
+      json_append_member(json_err, "file", json_mkstring(e.pstate.getPath()));
+      json_append_member(json_err, "line", json_mknumber((double)(e.pstate.getLine())));
+      json_append_member(json_err, "column", json_mknumber((double)(e.pstate.getColumn())));
       json_append_member(json_err, "message", json_mkstring(e.what()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); }
@@ -119,23 +120,23 @@ namespace Sass {
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 1;
-      c_ctx->error_file = sass_copy_c_string(e.pstate.path);
-      c_ctx->error_line = e.pstate.line + 1;
-      c_ctx->error_column = e.pstate.column + 1;
-      c_ctx->error_src = sass_copy_c_string(e.pstate.src);
+      c_ctx->error_file = sass_copy_c_string(e.pstate.getPath());
+      c_ctx->error_line = e.pstate.getLine();
+      c_ctx->error_column = e.pstate.getColumn();
+      c_ctx->error_src = sass_copy_c_string(e.pstate.getRawData());
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
     catch (std::bad_alloc& ba) {
-      std::stringstream msg_stream;
+      sass::ostream msg_stream;
       msg_stream << "Unable to allocate memory: " << ba.what();
       handle_string_error(c_ctx, msg_stream.str(), 2);
     }
     catch (std::exception& e) {
       handle_string_error(c_ctx, e.what(), 3);
     }
-    catch (std::string& e) {
+    catch (sass::string& e) {
       handle_string_error(c_ctx, e, 4);
     }
     catch (const char* e) {
@@ -169,8 +170,8 @@ namespace Sass {
     try {
 
       // get input/output path from options
-      std::string input_path = safe_str(c_ctx->input_path);
-      std::string output_path = safe_str(c_ctx->output_path);
+      sass::string input_path = safe_str(c_ctx->input_path);
+      sass::string output_path = safe_str(c_ctx->output_path);
 
       // maybe skip some entries of included files
       // we do not include stdin for data contexts
@@ -279,8 +280,8 @@ extern "C" {
       // reset error position
       c_ctx->error_file = 0;
       c_ctx->error_src = 0;
-      c_ctx->error_line = std::string::npos;
-      c_ctx->error_column = std::string::npos;
+      c_ctx->error_line = sass::string::npos;
+      c_ctx->error_column = sass::string::npos;
 
       // allocate a new compiler instance
       void* ctxmem = calloc(1, sizeof(struct Sass_Compiler));
@@ -702,6 +703,23 @@ extern "C" {
     return cur->string;
   }
 
+  // Push function for plugin paths (no manipulation support for now)
+  size_t ADDCALL sass_option_get_plugin_path_size(struct Sass_Options* options)
+  {
+    size_t len = 0;
+    struct string_list* cur = options->plugin_paths;
+    while (cur) { len++; cur = cur->next; }
+    return len;
+  }
+
+  // Push function for plugin paths (no manipulation support for now)
+  const char* ADDCALL sass_option_get_plugin_path(struct Sass_Options* options, size_t i)
+  {
+    struct string_list* cur = options->plugin_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)
   {