sassc 2.3.0 → 2.4.0

data/ext/libsass/src/check_nesting.hpp

@@ -12,7 +12,7 @@ namespace Sass {
 
   class CheckNesting : public Operation_CRTP<Statement*, CheckNesting> {
 
-    std::vector<Statement*>  parents;
+    sass::vector<Statement*>  parents;
     Backtraces                  traces;
     Statement*               parent;
     Definition*              current_mixin_definition;
@@ -33,7 +33,7 @@ namespace Sass {
       Statement* s = Cast<Statement>(x);
       if (s && this->should_visit(s)) {
         Block* b1 = Cast<Block>(s);
-        Has_Block* b2 = Cast<Has_Block>(s);
+        ParentStatement* b2 = Cast<ParentStatement>(s);
         if (b1 || b2) return visit_children(s);
       }
       return s;

data/ext/libsass/src/color_maps.cpp

@@ -162,7 +162,7 @@ namespace Sass {
   }
 
   namespace Colors {
-    const ParserState color_table("[COLOR TABLE]");
+    const SourceSpan color_table("[COLOR TABLE]");
     const Color_RGBA aliceblue(color_table, 240, 248, 255, 1);
     const Color_RGBA antiquewhite(color_table, 250, 235, 215, 1);
     const Color_RGBA cyan(color_table, 0, 255, 255, 1);
@@ -456,7 +456,7 @@ namespace Sass {
     { 102 * 0x10000 +  51 * 0x100 + 153, ColorNames::rebeccapurple }
   };
 
-  static const auto *const names_to_colors = new std::unordered_map<std::string, const Color_RGBA*>
+  static const auto *const names_to_colors = new std::unordered_map<sass::string, const Color_RGBA*>
   {
     { ColorNames::aliceblue, &Colors::aliceblue },
     { ColorNames::antiquewhite, &Colors::antiquewhite },
@@ -611,13 +611,13 @@ namespace Sass {
 
   const Color_RGBA* name_to_color(const char* key)
   {
-    return name_to_color(std::string(key));
+    return name_to_color(sass::string(key));
   }
 
-  const Color_RGBA* name_to_color(const std::string& key)
+  const Color_RGBA* name_to_color(const sass::string& key)
   {
     // case insensitive lookup.  See #2462
-    std::string lower = key;
+    sass::string lower = key;
     Util::ascii_str_tolower(&lower);
 
     auto p = names_to_colors->find(lower);

data/ext/libsass/src/color_maps.hpp

@@ -313,7 +313,7 @@ namespace Sass {
   }
 
   const Color_RGBA* name_to_color(const char*);
-  const Color_RGBA* name_to_color(const std::string&);
+  const Color_RGBA* name_to_color(const sass::string&);
   const char* color_to_name(const int);
   const char* color_to_name(const Color_RGBA&);
   const char* color_to_name(const double);

data/ext/libsass/src/context.cpp

@@ -17,6 +17,7 @@
 #include "expand.hpp"
 #include "parser.hpp"
 #include "cssize.hpp"
+#include "source.hpp"
 
 namespace Sass {
   using namespace Constants;
@@ -26,13 +27,13 @@ namespace Sass {
   inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)
   { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }
 
-  static std::string safe_input(const char* in_path)
+  static sass::string safe_input(const char* in_path)
   {
     if (in_path == nullptr || in_path[0] == '\0') return "stdin";
     return in_path;
   }
 
-  static std::string safe_output(const char* out_path, std::string input_path)
+  static sass::string safe_output(const char* out_path, sass::string input_path)
   {
     if (out_path == nullptr || out_path[0] == '\0') {
       if (input_path.empty()) return "stdout";
@@ -59,9 +60,9 @@ namespace Sass {
     extender(Extender::NORMAL, traces),
     c_compiler(NULL),
 
-    c_headers               (std::vector<Sass_Importer_Entry>()),
-    c_importers             (std::vector<Sass_Importer_Entry>()),
-    c_functions             (std::vector<Sass_Function_Entry>()),
+    c_headers               (sass::vector<Sass_Importer_Entry>()),
+    c_importers             (sass::vector<Sass_Importer_Entry>()),
+    c_functions             (sass::vector<Sass_Function_Entry>()),
 
     indent                  (safe_str(c_options.indent, "  ")),
     linefeed                (safe_str(c_options.linefeed, "\n")),
@@ -155,7 +156,7 @@ namespace Sass {
       const char* end = Prelexer::find_first<PATH_SEP>(beg);
 
       while (end) {
-        std::string path(beg, end - beg);
+        sass::string path(beg, end - beg);
         if (!path.empty()) {
           if (*path.rbegin() != '/') path += '/';
           include_paths.push_back(path);
@@ -164,7 +165,7 @@ namespace Sass {
         end = Prelexer::find_first<PATH_SEP>(beg);
       }
 
-      std::string path(beg);
+      sass::string path(beg);
       if (!path.empty()) {
         if (*path.rbegin() != '/') path += '/';
         include_paths.push_back(path);
@@ -188,7 +189,7 @@ namespace Sass {
       const char* end = Prelexer::find_first<PATH_SEP>(beg);
 
       while (end) {
-        std::string path(beg, end - beg);
+        sass::string path(beg, end - beg);
         if (!path.empty()) {
           if (*path.rbegin() != '/') path += '/';
           plugin_paths.push_back(path);
@@ -197,7 +198,7 @@ namespace Sass {
         end = Prelexer::find_first<PATH_SEP>(beg);
       }
 
-      std::string path(beg);
+      sass::string path(beg);
       if (!path.empty()) {
         if (*path.rbegin() != '/') path += '/';
         plugin_paths.push_back(path);
@@ -216,17 +217,17 @@ namespace Sass {
 
   // resolve the imp_path in base_path or include_paths
   // looks for alternatives and returns a list from one directory
-  std::vector<Include> Context::find_includes(const Importer& import)
+  sass::vector<Include> Context::find_includes(const Importer& import)
   {
     // make sure we resolve against an absolute path
-    std::string base_path(rel2abs(import.base_path));
+    sass::string base_path(rel2abs(import.base_path));
     // first try to resolve the load path relative to the base path
-    std::vector<Include> vec(resolve_includes(base_path, import.imp_path));
+    sass::vector<Include> vec(resolve_includes(base_path, import.imp_path));
     // then search in every include path (but only if nothing found yet)
     for (size_t i = 0, S = include_paths.size(); vec.size() == 0 && i < S; ++i)
     {
       // call resolve_includes and individual base path and append all results
-      std::vector<Include> resolved(resolve_includes(include_paths[i], import.imp_path));
+      sass::vector<Include> resolved(resolve_includes(include_paths[i], import.imp_path));
       if (resolved.size()) vec.insert(vec.end(), resolved.begin(), resolved.end());
     }
     // return vector
@@ -273,22 +274,22 @@ namespace Sass {
 
     // get pointer to the loaded content
     const char* contents = resources[idx].contents;
-    // keep a copy of the path around (for parserstates)
-    // ToDo: we clean it, but still not very elegant!?
-    strings.push_back(sass_copy_c_string(inc.abs_path.c_str()));
+    SourceFileObj source = SASS_MEMORY_NEW(SourceFile,
+      inc.abs_path.c_str(), contents, idx);
+
     // create the initial parser state from resource
-    ParserState pstate(strings.back(), contents, idx);
+    SourceSpan pstate(source);
 
     // check existing import stack for possible recursion
     for (size_t i = 0; i < import_stack.size() - 2; ++i) {
       auto parent = import_stack[i];
       if (std::strcmp(parent->abs_path, import->abs_path) == 0) {
-        std::string cwd(File::get_cwd());
+        sass::string cwd(File::get_cwd());
         // make path relative to the current directory
-        std::string stack("An @import loop has been found:");
+        sass::string stack("An @import loop has been found:");
         for (size_t n = 1; n < i + 2; ++n) {
-          stack += "\n    " + std::string(File::abs2rel(import_stack[n]->abs_path, cwd, cwd)) +
-            " imports " + std::string(File::abs2rel(import_stack[n+1]->abs_path, cwd, cwd));
+          stack += "\n    " + sass::string(File::abs2rel(import_stack[n]->abs_path, cwd, cwd)) +
+            " imports " + sass::string(File::abs2rel(import_stack[n+1]->abs_path, cwd, cwd));
         }
         // implement error throw directly until we
         // decided how to handle full stack traces
@@ -298,7 +299,7 @@ namespace Sass {
     }
 
     // create a parser instance from the given c_str buffer
-    Parser p(Parser::from_c_str(contents, *this, traces, pstate));
+    Parser p(source, *this, traces);
     // do not yet dispose these buffers
     sass_import_take_source(import);
     sass_import_take_srcmap(import);
@@ -309,7 +310,7 @@ namespace Sass {
     // remove current stack frame
     import_stack.pop_back();
     // create key/value pair for ast node
-    std::pair<const std::string, StyleSheet>
+    std::pair<const sass::string, StyleSheet>
       ast_pair(inc.abs_path, { res, root });
     // register resulting resource
     sheets.insert(ast_pair);
@@ -317,7 +318,7 @@ namespace Sass {
 
   // register include with resolved path and its content
   // memory of the resources will be freed by us on exit
-  void Context::register_resource(const Include& inc, const Resource& res, ParserState& prstate)
+  void Context::register_resource(const Include& inc, const Resource& res, SourceSpan& prstate)
   {
     traces.push_back(Backtrace(prstate));
     register_resource(inc, res);
@@ -325,16 +326,16 @@ namespace Sass {
   }
 
   // Add a new import to the context (called from `import_url`)
-  Include Context::load_import(const Importer& imp, ParserState pstate)
+  Include Context::load_import(const Importer& imp, SourceSpan pstate)
   {
 
     // search for valid imports (ie. partials) on the filesystem
     // this may return more than one valid result (ambiguous imp_path)
-    const std::vector<Include> resolved(find_includes(imp));
+    const sass::vector<Include> resolved(find_includes(imp));
 
     // error nicely on ambiguous imp_path
     if (resolved.size() > 1) {
-      std::stringstream msg_stream;
+      sass::ostream msg_stream;
       msg_stream << "It's not clear which file to import for ";
       msg_stream << "'@import \"" << imp.imp_path << "\"'." << "\n";
       msg_stream << "Candidates:" << "\n";
@@ -364,16 +365,16 @@ namespace Sass {
 
   }
 
-  void Context::import_url (Import* imp, std::string load_path, const std::string& ctx_path) {
+  void Context::import_url (Import* imp, sass::string load_path, const sass::string& ctx_path) {
 
-    ParserState pstate(imp->pstate());
-    std::string imp_path(unquote(load_path));
-    std::string protocol("file");
+    SourceSpan pstate(imp->pstate());
+    sass::string imp_path(unquote(load_path));
+    sass::string protocol("file");
 
     using namespace Prelexer;
     if (const char* proto = sequence< identifier, exactly<':'>, exactly<'/'>, exactly<'/'> >(imp_path.c_str())) {
 
-      protocol = std::string(imp_path.c_str(), proto - 3);
+      protocol = sass::string(imp_path.c_str(), proto - 3);
       // if (protocol.compare("file") && true) { }
     }
 
@@ -387,7 +388,7 @@ namespace Sass {
       Argument_Obj loc_arg = SASS_MEMORY_NEW(Argument, pstate, loc);
       Arguments_Obj loc_args = SASS_MEMORY_NEW(Arguments, pstate);
       loc_args->append(loc_arg);
-      Function_Call* new_url = SASS_MEMORY_NEW(Function_Call, pstate, std::string("url"), loc_args);
+      Function_Call* new_url = SASS_MEMORY_NEW(Function_Call, pstate, sass::string("url"), loc_args);
       imp->urls().push_back(new_url);
     }
     else {
@@ -403,7 +404,7 @@ namespace Sass {
 
 
   // call custom importers on the given (unquoted) load_path and eventually parse the resulting style_sheet
-  bool Context::call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
+  bool Context::call_loader(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp, sass::vector<Sass_Importer_Entry> importers, bool only_one)
   {
     // unique counter
     size_t count = 0;
@@ -421,9 +422,9 @@ namespace Sass {
         Sass_Import_List it_includes = includes;
         while (*it_includes) { ++count;
           // create unique path to use as key
-          std::string uniq_path = load_path;
+          sass::string uniq_path = load_path;
           if (!only_one && count) {
-            std::stringstream path_strm;
+            sass::ostream path_strm;
             path_strm << uniq_path << ":" << count;
             uniq_path = path_strm.str();
           }
@@ -440,14 +441,14 @@ namespace Sass {
           // it may (or may not) override the line and column info
           if (const char* err_message = sass_import_get_error_message(include_ent)) {
             if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap }, pstate);
-            if (line == std::string::npos && column == std::string::npos) error(err_message, pstate, traces);
-            else error(err_message, ParserState(ctx_path, source, Position(line, column)), traces);
+            if (line == sass::string::npos && column == sass::string::npos) error(err_message, pstate, traces);
+            else { error(err_message, { pstate.source, { line, column } }, traces); }
           }
           // content for import was set
           else if (source) {
             // resolved abs_path should be set by custom importer
             // use the created uniq_path as fallback (maybe enforce)
-            std::string path_key(abs_path ? abs_path : uniq_path);
+            sass::string path_key(abs_path ? abs_path : uniq_path);
             // create the importer struct
             Include include(importer, path_key);
             // attach information to AST node
@@ -484,7 +485,7 @@ namespace Sass {
 
   void register_function(Context&, Signature sig, Native_Function f, Env* env);
   void register_function(Context&, Signature sig, Native_Function f, size_t arity, Env* env);
-  void register_overload_stub(Context&, std::string name, Env* env);
+  void register_overload_stub(Context&, sass::string name, Env* env);
   void register_built_in_functions(Context&, Env* env);
   void register_c_functions(Context&, Env* env, Sass_Function_List);
   void register_c_function(Context&, Env* env, Sass_Function_Entry);
@@ -517,7 +518,7 @@ namespace Sass {
     return sass_copy_c_string(emitted.buffer.c_str());
   }
 
-  void Context::apply_custom_headers(Block_Obj root, const char* ctx_path, ParserState pstate)
+  void Context::apply_custom_headers(Block_Obj root, const char* ctx_path, SourceSpan pstate)
   {
     // create a custom import to resolve headers
     Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);
@@ -542,7 +543,7 @@ namespace Sass {
 
     // create absolute path from input filename
     // ToDo: this should be resolved via custom importers
-    std::string abs_path(rel2abs(input_path, CWD));
+    sass::string abs_path(rel2abs(input_path, CWD));
 
     // try to load the entry file
     char* contents = read_file(abs_path);
@@ -557,7 +558,9 @@ namespace Sass {
     }
 
     // abort early if no content could be loaded (various reasons)
-    if (!contents) throw std::runtime_error("File to read not found or unreadable: " + input_path);
+    if (!contents) throw std::runtime_error(
+      "File to read not found or unreadable: "
+      + std::string(input_path.c_str()));
 
     // store entry path
     entry_path = abs_path;
@@ -600,7 +603,7 @@ namespace Sass {
     entry_path = input_path.empty() ? "stdin" : input_path;
 
     // ToDo: this may be resolved via custom importers
-    std::string abs_path(rel2abs(entry_path));
+    sass::string abs_path(rel2abs(entry_path));
     char* abs_path_c_str = sass_copy_c_string(abs_path.c_str());
     strings.push_back(abs_path_c_str);
 
@@ -670,38 +673,38 @@ namespace Sass {
   }
   // EO compile
 
-  std::string Context::format_embedded_source_map()
+  sass::string Context::format_embedded_source_map()
   {
-    std::string map = emitter.render_srcmap(*this);
-    std::istringstream is( map );
-    std::ostringstream buffer;
+    sass::string map = emitter.render_srcmap(*this);
+    sass::istream is( map.c_str() );
+    sass::ostream buffer;
     base64::encoder E;
     E.encode(is, buffer);
-    std::string url = "data:application/json;base64," + buffer.str();
+    sass::string url = "data:application/json;base64," + buffer.str();
     url.erase(url.size() - 1);
     return "/*# sourceMappingURL=" + url + " */";
   }
 
-  std::string Context::format_source_mapping_url(const std::string& file)
+  sass::string Context::format_source_mapping_url(const sass::string& file)
   {
-    std::string url = abs2rel(file, output_path, CWD);
+    sass::string url = abs2rel(file, output_path, CWD);
     return "/*# sourceMappingURL=" + url + " */";
   }
 
   char* Context::render_srcmap()
   {
     if (source_map_file == "") return 0;
-    std::string map = emitter.render_srcmap(*this);
+    sass::string map = emitter.render_srcmap(*this);
     return sass_copy_c_string(map.c_str());
   }
 
 
   // for data context we want to start after "stdin"
   // we probably always want to skip the header includes?
-  std::vector<std::string> Context::get_included_files(bool skip, size_t headers)
+  sass::vector<sass::string> Context::get_included_files(bool skip, size_t headers)
   {
       // create a copy of the vector for manipulations
-      std::vector<std::string> includes = included_files;
+      sass::vector<sass::string> includes = included_files;
       if (includes.size() == 0) return includes;
       if (skip) { includes.erase( includes.begin(), includes.begin() + 1 + headers); }
       else { includes.erase( includes.begin() + 1, includes.begin() + 1 + headers); }
@@ -720,20 +723,20 @@ namespace Sass {
   void register_function(Context& ctx, Signature sig, Native_Function f, size_t arity, Env* env)
   {
     Definition* def = make_native_function(sig, f, ctx);
-    std::stringstream ss;
+    sass::ostream ss;
     ss << def->name() << "[f]" << arity;
     def->environment(env);
     (*env)[ss.str()] = def;
   }
 
-  void register_overload_stub(Context& ctx, std::string name, Env* env)
+  void register_overload_stub(Context& ctx, sass::string name, Env* env)
   {
     Definition* stub = SASS_MEMORY_NEW(Definition,
-                                       ParserState("[built-in function]"),
-                                       0,
+                                       SourceSpan{ "[built-in function]" },
+                                       nullptr,
                                        name,
-                                       {},
-                                       0,
+                                       Parameters_Obj{},
+                                       nullptr,
                                        true);
     (*env)[name + "[f]"] = stub;
   }

data/ext/libsass/src/context.hpp

@@ -19,19 +19,19 @@ namespace Sass {
 
   class Context {
   public:
-    void import_url (Import* imp, std::string load_path, const std::string& ctx_path);
-    bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
+    void import_url (Import* imp, sass::string load_path, const sass::string& ctx_path);
+    bool call_headers(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_headers, false); };
-    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
+    bool call_importers(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_importers, true); };
 
   private:
-    bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
+    bool call_loader(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp, sass::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
   public:
-    const std::string CWD;
+    const sass::string CWD;
     struct Sass_Options& c_options;
-    std::string entry_path;
+    sass::string entry_path;
     size_t head_imports;
     Plugins plugins;
     Output emitter;
@@ -41,41 +41,41 @@ namespace Sass {
     CallStack ast_gc;
     // resources add under our control
     // these are guaranteed to be freed
-    std::vector<char*> strings;
-    std::vector<Resource> resources;
-    std::map<const std::string, StyleSheet> sheets;
+    sass::vector<char*> strings;
+    sass::vector<Resource> resources;
+    std::map<const sass::string, StyleSheet> sheets;
     ImporterStack import_stack;
-    std::vector<Sass_Callee> callee_stack;
-    std::vector<Backtrace> traces;
+    sass::vector<Sass_Callee> callee_stack;
+    sass::vector<Backtrace> traces;
     Extender extender;
 
     struct Sass_Compiler* c_compiler;
 
     // absolute paths to includes
-    std::vector<std::string> included_files;
+    sass::vector<sass::string> included_files;
     // relative includes for sourcemap
-    std::vector<std::string> srcmap_links;
+    sass::vector<sass::string> srcmap_links;
     // vectors above have same size
 
-    std::vector<std::string> plugin_paths; // relative paths to load plugins
-    std::vector<std::string> include_paths; // lookup paths for includes
+    sass::vector<sass::string> plugin_paths; // relative paths to load plugins
+    sass::vector<sass::string> include_paths; // lookup paths for includes
 
-    void apply_custom_headers(Block_Obj root, const char* path, ParserState pstate);
+    void apply_custom_headers(Block_Obj root, const char* path, SourceSpan pstate);
 
-    std::vector<Sass_Importer_Entry> c_headers;
-    std::vector<Sass_Importer_Entry> c_importers;
-    std::vector<Sass_Function_Entry> c_functions;
+    sass::vector<Sass_Importer_Entry> c_headers;
+    sass::vector<Sass_Importer_Entry> c_importers;
+    sass::vector<Sass_Function_Entry> c_functions;
 
     void add_c_header(Sass_Importer_Entry header);
     void add_c_importer(Sass_Importer_Entry importer);
     void add_c_function(Sass_Function_Entry function);
 
-    const std::string indent; // String to be used for indentation
-    const std::string linefeed; // String to be used for line feeds
-    const std::string input_path; // for relative paths in src-map
-    const std::string output_path; // for relative paths to the output
-    const std::string source_map_file; // path to source map file (enables feature)
-    const std::string source_map_root; // path for sourceRoot property (pass-through)
+    const sass::string indent; // String to be used for indentation
+    const sass::string linefeed; // String to be used for line feeds
+    const sass::string input_path; // for relative paths in src-map
+    const sass::string output_path; // for relative paths to the output
+    const sass::string source_map_file; // path to source map file (enables feature)
+    const sass::string source_map_root; // path for sourceRoot property (pass-through)
 
     virtual ~Context();
     Context(struct Sass_Context&);
@@ -85,29 +85,29 @@ namespace Sass {
     virtual char* render_srcmap();
 
     void register_resource(const Include&, const Resource&);
-    void register_resource(const Include&, const Resource&, ParserState&);
-    std::vector<Include> find_includes(const Importer& import);
-    Include load_import(const Importer&, ParserState pstate);
+    void register_resource(const Include&, const Resource&, SourceSpan&);
+    sass::vector<Include> find_includes(const Importer& import);
+    Include load_import(const Importer&, SourceSpan pstate);
 
     Sass_Output_Style output_style() { return c_options.output_style; };
-    std::vector<std::string> get_included_files(bool skip = false, size_t headers = 0);
+    sass::vector<sass::string> get_included_files(bool skip = false, size_t headers = 0);
 
   private:
     void collect_plugin_paths(const char* paths_str);
     void collect_plugin_paths(string_list* paths_array);
     void collect_include_paths(const char* paths_str);
     void collect_include_paths(string_list* paths_array);
-    std::string format_embedded_source_map();
-    std::string format_source_mapping_url(const std::string& out_path);
+    sass::string format_embedded_source_map();
+    sass::string format_source_mapping_url(const sass::string& out_path);
 
 
     // void register_built_in_functions(Env* env);
     // void register_function(Signature sig, Native_Function f, Env* env);
     // void register_function(Signature sig, Native_Function f, size_t arity, Env* env);
-    // void register_overload_stub(std::string name, Env* env);
+    // void register_overload_stub(sass::string name, Env* env);
 
   public:
-    const std::string& cwd() { return CWD; };
+    const sass::string& cwd() { return CWD; };
   };
 
   class File_Context : public Context {