sassc 2.0.0 → 2.4.0

data/ext/libsass/src/color_maps.hpp

@@ -7,14 +7,6 @@
 
 namespace Sass {
 
-  struct map_cmp_str
-  {
-    bool operator()(char const *a, char const *b) const
-    {
-      return std::strcmp(a, b) < 0;
-    }
-  };
-
   namespace ColorNames
   {
     extern const char aliceblue[];
@@ -169,161 +161,161 @@ namespace Sass {
   }
 
   namespace Colors {
-    extern const Color aliceblue;
-    extern const Color antiquewhite;
-    extern const Color cyan;
-    extern const Color aqua;
-    extern const Color aquamarine;
-    extern const Color azure;
-    extern const Color beige;
-    extern const Color bisque;
-    extern const Color black;
-    extern const Color blanchedalmond;
-    extern const Color blue;
-    extern const Color blueviolet;
-    extern const Color brown;
-    extern const Color burlywood;
-    extern const Color cadetblue;
-    extern const Color chartreuse;
-    extern const Color chocolate;
-    extern const Color coral;
-    extern const Color cornflowerblue;
-    extern const Color cornsilk;
-    extern const Color crimson;
-    extern const Color darkblue;
-    extern const Color darkcyan;
-    extern const Color darkgoldenrod;
-    extern const Color darkgray;
-    extern const Color darkgrey;
-    extern const Color darkgreen;
-    extern const Color darkkhaki;
-    extern const Color darkmagenta;
-    extern const Color darkolivegreen;
-    extern const Color darkorange;
-    extern const Color darkorchid;
-    extern const Color darkred;
-    extern const Color darksalmon;
-    extern const Color darkseagreen;
-    extern const Color darkslateblue;
-    extern const Color darkslategray;
-    extern const Color darkslategrey;
-    extern const Color darkturquoise;
-    extern const Color darkviolet;
-    extern const Color deeppink;
-    extern const Color deepskyblue;
-    extern const Color dimgray;
-    extern const Color dimgrey;
-    extern const Color dodgerblue;
-    extern const Color firebrick;
-    extern const Color floralwhite;
-    extern const Color forestgreen;
-    extern const Color magenta;
-    extern const Color fuchsia;
-    extern const Color gainsboro;
-    extern const Color ghostwhite;
-    extern const Color gold;
-    extern const Color goldenrod;
-    extern const Color gray;
-    extern const Color grey;
-    extern const Color green;
-    extern const Color greenyellow;
-    extern const Color honeydew;
-    extern const Color hotpink;
-    extern const Color indianred;
-    extern const Color indigo;
-    extern const Color ivory;
-    extern const Color khaki;
-    extern const Color lavender;
-    extern const Color lavenderblush;
-    extern const Color lawngreen;
-    extern const Color lemonchiffon;
-    extern const Color lightblue;
-    extern const Color lightcoral;
-    extern const Color lightcyan;
-    extern const Color lightgoldenrodyellow;
-    extern const Color lightgray;
-    extern const Color lightgrey;
-    extern const Color lightgreen;
-    extern const Color lightpink;
-    extern const Color lightsalmon;
-    extern const Color lightseagreen;
-    extern const Color lightskyblue;
-    extern const Color lightslategray;
-    extern const Color lightslategrey;
-    extern const Color lightsteelblue;
-    extern const Color lightyellow;
-    extern const Color lime;
-    extern const Color limegreen;
-    extern const Color linen;
-    extern const Color maroon;
-    extern const Color mediumaquamarine;
-    extern const Color mediumblue;
-    extern const Color mediumorchid;
-    extern const Color mediumpurple;
-    extern const Color mediumseagreen;
-    extern const Color mediumslateblue;
-    extern const Color mediumspringgreen;
-    extern const Color mediumturquoise;
-    extern const Color mediumvioletred;
-    extern const Color midnightblue;
-    extern const Color mintcream;
-    extern const Color mistyrose;
-    extern const Color moccasin;
-    extern const Color navajowhite;
-    extern const Color navy;
-    extern const Color oldlace;
-    extern const Color olive;
-    extern const Color olivedrab;
-    extern const Color orange;
-    extern const Color orangered;
-    extern const Color orchid;
-    extern const Color palegoldenrod;
-    extern const Color palegreen;
-    extern const Color paleturquoise;
-    extern const Color palevioletred;
-    extern const Color papayawhip;
-    extern const Color peachpuff;
-    extern const Color peru;
-    extern const Color pink;
-    extern const Color plum;
-    extern const Color powderblue;
-    extern const Color purple;
-    extern const Color red;
-    extern const Color rosybrown;
-    extern const Color royalblue;
-    extern const Color saddlebrown;
-    extern const Color salmon;
-    extern const Color sandybrown;
-    extern const Color seagreen;
-    extern const Color seashell;
-    extern const Color sienna;
-    extern const Color silver;
-    extern const Color skyblue;
-    extern const Color slateblue;
-    extern const Color slategray;
-    extern const Color slategrey;
-    extern const Color snow;
-    extern const Color springgreen;
-    extern const Color steelblue;
-    extern const Color tan;
-    extern const Color teal;
-    extern const Color thistle;
-    extern const Color tomato;
-    extern const Color turquoise;
-    extern const Color violet;
-    extern const Color wheat;
-    extern const Color white;
-    extern const Color whitesmoke;
-    extern const Color yellow;
-    extern const Color yellowgreen;
-    extern const Color rebeccapurple;
-    extern const Color transparent;
+    extern const Color_RGBA aliceblue;
+    extern const Color_RGBA antiquewhite;
+    extern const Color_RGBA cyan;
+    extern const Color_RGBA aqua;
+    extern const Color_RGBA aquamarine;
+    extern const Color_RGBA azure;
+    extern const Color_RGBA beige;
+    extern const Color_RGBA bisque;
+    extern const Color_RGBA black;
+    extern const Color_RGBA blanchedalmond;
+    extern const Color_RGBA blue;
+    extern const Color_RGBA blueviolet;
+    extern const Color_RGBA brown;
+    extern const Color_RGBA burlywood;
+    extern const Color_RGBA cadetblue;
+    extern const Color_RGBA chartreuse;
+    extern const Color_RGBA chocolate;
+    extern const Color_RGBA coral;
+    extern const Color_RGBA cornflowerblue;
+    extern const Color_RGBA cornsilk;
+    extern const Color_RGBA crimson;
+    extern const Color_RGBA darkblue;
+    extern const Color_RGBA darkcyan;
+    extern const Color_RGBA darkgoldenrod;
+    extern const Color_RGBA darkgray;
+    extern const Color_RGBA darkgrey;
+    extern const Color_RGBA darkgreen;
+    extern const Color_RGBA darkkhaki;
+    extern const Color_RGBA darkmagenta;
+    extern const Color_RGBA darkolivegreen;
+    extern const Color_RGBA darkorange;
+    extern const Color_RGBA darkorchid;
+    extern const Color_RGBA darkred;
+    extern const Color_RGBA darksalmon;
+    extern const Color_RGBA darkseagreen;
+    extern const Color_RGBA darkslateblue;
+    extern const Color_RGBA darkslategray;
+    extern const Color_RGBA darkslategrey;
+    extern const Color_RGBA darkturquoise;
+    extern const Color_RGBA darkviolet;
+    extern const Color_RGBA deeppink;
+    extern const Color_RGBA deepskyblue;
+    extern const Color_RGBA dimgray;
+    extern const Color_RGBA dimgrey;
+    extern const Color_RGBA dodgerblue;
+    extern const Color_RGBA firebrick;
+    extern const Color_RGBA floralwhite;
+    extern const Color_RGBA forestgreen;
+    extern const Color_RGBA magenta;
+    extern const Color_RGBA fuchsia;
+    extern const Color_RGBA gainsboro;
+    extern const Color_RGBA ghostwhite;
+    extern const Color_RGBA gold;
+    extern const Color_RGBA goldenrod;
+    extern const Color_RGBA gray;
+    extern const Color_RGBA grey;
+    extern const Color_RGBA green;
+    extern const Color_RGBA greenyellow;
+    extern const Color_RGBA honeydew;
+    extern const Color_RGBA hotpink;
+    extern const Color_RGBA indianred;
+    extern const Color_RGBA indigo;
+    extern const Color_RGBA ivory;
+    extern const Color_RGBA khaki;
+    extern const Color_RGBA lavender;
+    extern const Color_RGBA lavenderblush;
+    extern const Color_RGBA lawngreen;
+    extern const Color_RGBA lemonchiffon;
+    extern const Color_RGBA lightblue;
+    extern const Color_RGBA lightcoral;
+    extern const Color_RGBA lightcyan;
+    extern const Color_RGBA lightgoldenrodyellow;
+    extern const Color_RGBA lightgray;
+    extern const Color_RGBA lightgrey;
+    extern const Color_RGBA lightgreen;
+    extern const Color_RGBA lightpink;
+    extern const Color_RGBA lightsalmon;
+    extern const Color_RGBA lightseagreen;
+    extern const Color_RGBA lightskyblue;
+    extern const Color_RGBA lightslategray;
+    extern const Color_RGBA lightslategrey;
+    extern const Color_RGBA lightsteelblue;
+    extern const Color_RGBA lightyellow;
+    extern const Color_RGBA lime;
+    extern const Color_RGBA limegreen;
+    extern const Color_RGBA linen;
+    extern const Color_RGBA maroon;
+    extern const Color_RGBA mediumaquamarine;
+    extern const Color_RGBA mediumblue;
+    extern const Color_RGBA mediumorchid;
+    extern const Color_RGBA mediumpurple;
+    extern const Color_RGBA mediumseagreen;
+    extern const Color_RGBA mediumslateblue;
+    extern const Color_RGBA mediumspringgreen;
+    extern const Color_RGBA mediumturquoise;
+    extern const Color_RGBA mediumvioletred;
+    extern const Color_RGBA midnightblue;
+    extern const Color_RGBA mintcream;
+    extern const Color_RGBA mistyrose;
+    extern const Color_RGBA moccasin;
+    extern const Color_RGBA navajowhite;
+    extern const Color_RGBA navy;
+    extern const Color_RGBA oldlace;
+    extern const Color_RGBA olive;
+    extern const Color_RGBA olivedrab;
+    extern const Color_RGBA orange;
+    extern const Color_RGBA orangered;
+    extern const Color_RGBA orchid;
+    extern const Color_RGBA palegoldenrod;
+    extern const Color_RGBA palegreen;
+    extern const Color_RGBA paleturquoise;
+    extern const Color_RGBA palevioletred;
+    extern const Color_RGBA papayawhip;
+    extern const Color_RGBA peachpuff;
+    extern const Color_RGBA peru;
+    extern const Color_RGBA pink;
+    extern const Color_RGBA plum;
+    extern const Color_RGBA powderblue;
+    extern const Color_RGBA purple;
+    extern const Color_RGBA red;
+    extern const Color_RGBA rosybrown;
+    extern const Color_RGBA royalblue;
+    extern const Color_RGBA saddlebrown;
+    extern const Color_RGBA salmon;
+    extern const Color_RGBA sandybrown;
+    extern const Color_RGBA seagreen;
+    extern const Color_RGBA seashell;
+    extern const Color_RGBA sienna;
+    extern const Color_RGBA silver;
+    extern const Color_RGBA skyblue;
+    extern const Color_RGBA slateblue;
+    extern const Color_RGBA slategray;
+    extern const Color_RGBA slategrey;
+    extern const Color_RGBA snow;
+    extern const Color_RGBA springgreen;
+    extern const Color_RGBA steelblue;
+    extern const Color_RGBA tan;
+    extern const Color_RGBA teal;
+    extern const Color_RGBA thistle;
+    extern const Color_RGBA tomato;
+    extern const Color_RGBA turquoise;
+    extern const Color_RGBA violet;
+    extern const Color_RGBA wheat;
+    extern const Color_RGBA white;
+    extern const Color_RGBA whitesmoke;
+    extern const Color_RGBA yellow;
+    extern const Color_RGBA yellowgreen;
+    extern const Color_RGBA rebeccapurple;
+    extern const Color_RGBA transparent;
   }
 
-  Color_Ptr_Const name_to_color(const char*);
-  Color_Ptr_Const name_to_color(const std::string&);
+  const Color_RGBA* name_to_color(const char*);
+  const Color_RGBA* name_to_color(const sass::string&);
   const char* color_to_name(const int);
-  const char* color_to_name(const Color&);
+  const char* color_to_name(const Color_RGBA&);
   const char* color_to_name(const double);
 
 }

data/ext/libsass/src/constants.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "constants.hpp"
 
 namespace Sass {
@@ -18,6 +21,15 @@ namespace Sass {
     extern const unsigned long Specificity_Pseudo = 1000;
     extern const unsigned long Specificity_ID = 1000000;
 
+    extern const int UnificationOrder_Element = 1;
+    extern const int UnificationOrder_Id = 2;
+    extern const int UnificationOrder_Class = 2;
+    extern const int UnificationOrder_Attribute = 3;
+    extern const int UnificationOrder_PseudoClass = 4;
+    extern const int UnificationOrder_Wrapped = 5;
+    extern const int UnificationOrder_PseudoElement = 6;
+    extern const int UnificationOrder_Placeholder = 7;
+
     // sass keywords
     extern const char at_root_kwd[]       = "@at-root";
     extern const char import_kwd[]        = "@import";
@@ -33,6 +45,7 @@ namespace Sass {
     extern const char for_kwd[]           = "@for";
     extern const char from_kwd[]          = "from";
     extern const char to_kwd[]            = "to";
+    extern const char of_kwd[]            = "of";
     extern const char through_kwd[]       = "through";
     extern const char each_kwd[]          = "@each";
     extern const char in_kwd[]            = "in";
@@ -116,6 +129,9 @@ namespace Sass {
     extern const char true_kwd[]  = "true";
     extern const char false_kwd[] = "false";
 
+    // definition keywords
+    extern const char using_kwd[]   = "using";
+
     // miscellaneous punctuation and delimiters
     extern const char percent_str[]     = "%";
     extern const char empty_str[]       = "";
@@ -146,6 +162,10 @@ namespace Sass {
     extern const char uri_chars[]  = ":;/?!%&#@|[]{}'`^\"*+-.,_=~";
     extern const char real_uri_chars[]  = "#%&";
 
+    extern const char selector_combinator_child[] = ">";
+    extern const char selector_combinator_general[] = "~";
+    extern const char selector_combinator_adjacent[] = "+";
+
     // some specific constant character classes
     // they must be static to be useable by lexer
     extern const char static_ops[]      = "*/%";

data/ext/libsass/src/constants.hpp

@@ -18,6 +18,16 @@ namespace Sass {
     extern const unsigned long Specificity_Pseudo;
     extern const unsigned long Specificity_ID;
 
+    // Selector unification order;
+    extern const int UnificationOrder_Element;
+    extern const int UnificationOrder_Id;
+    extern const int UnificationOrder_Class;
+    extern const int UnificationOrder_Attribute;
+    extern const int UnificationOrder_PseudoClass;
+    extern const int UnificationOrder_Wrapped;
+    extern const int UnificationOrder_PseudoElement;
+    extern const int UnificationOrder_Placeholder;
+
     // sass keywords
     extern const char at_root_kwd[];
     extern const char import_kwd[];
@@ -33,6 +43,7 @@ namespace Sass {
     extern const char for_kwd[];
     extern const char from_kwd[];
     extern const char to_kwd[];
+    extern const char of_kwd[];
     extern const char through_kwd[];
     extern const char each_kwd[];
     extern const char in_kwd[];
@@ -117,6 +128,9 @@ namespace Sass {
     extern const char true_kwd[];
     extern const char false_kwd[];
 
+    // definition keywords
+    extern const char using_kwd[];
+
     // miscellaneous punctuation and delimiters
     extern const char percent_str[];
     extern const char empty_str[];
@@ -148,6 +162,11 @@ namespace Sass {
     extern const char uri_chars[];
     extern const char real_uri_chars[];
 
+    // constants for selector combinators
+    extern const char selector_combinator_child[];
+    extern const char selector_combinator_general[];
+    extern const char selector_combinator_adjacent[];
+
     // some specific constant character classes
     // they must be static to be useable by lexer
     extern const char static_ops[];

data/ext/libsass/src/context.cpp

@@ -1,34 +1,23 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include <string>
-#include <cstdlib>
-#include <cstring>
-#include <iomanip>
-#include <sstream>
-#include <iostream>
-
 #include "ast.hpp"
-#include "util.hpp"
-#include "sass.h"
+
+#include "remove_placeholders.hpp"
+#include "sass_functions.hpp"
+#include "check_nesting.hpp"
+#include "fn_selectors.hpp"
+#include "fn_strings.hpp"
+#include "fn_numbers.hpp"
+#include "fn_colors.hpp"
+#include "fn_miscs.hpp"
+#include "fn_lists.hpp"
+#include "fn_maps.hpp"
 #include "context.hpp"
-#include "plugins.hpp"
-#include "constants.hpp"
-#include "parser.hpp"
-#include "file.hpp"
-#include "inspect.hpp"
-#include "output.hpp"
 #include "expand.hpp"
-#include "eval.hpp"
-#include "check_nesting.hpp"
+#include "parser.hpp"
 #include "cssize.hpp"
-#include "listize.hpp"
-#include "extend.hpp"
-#include "remove_placeholders.hpp"
-#include "functions.hpp"
-#include "sass_functions.hpp"
-#include "backtrace.hpp"
-#include "sass2scss.h"
-#include "prelexer.hpp"
-#include "emitter.hpp"
+#include "source.hpp"
 
 namespace Sass {
   using namespace Constants;
@@ -38,25 +27,19 @@ 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)
   {
-    // enforce some safe defaults
-    // used to create relative file links
-    std::string safe_path(in_path ? in_path : "");
-    return safe_path == "" ? "stdin" : safe_path;
+    if (in_path == nullptr || in_path[0] == '\0') return "stdin";
+    return in_path;
   }
 
-  static std::string safe_output(const char* out_path, const std::string& input_path = "")
+  static sass::string safe_output(const char* out_path, sass::string input_path)
   {
-    std::string safe_path(out_path ? out_path : "");
-    // maybe we can extract an output path from input path
-    if (safe_path == "" && input_path != "") {
-      int lastindex = static_cast<int>(input_path.find_last_of("."));
-      return (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
+    if (out_path == nullptr || out_path[0] == '\0') {
+      if (input_path.empty()) return "stdout";
+      return input_path.substr(0, input_path.find_last_of(".")) + ".css";
     }
-    // enforce some safe defaults
-    // used to create relative file links
-    return safe_path == "" ? "stdout" : safe_path;
+    return out_path;
   }
 
   Context::Context(struct Sass_Context& c_ctx)
@@ -71,15 +54,15 @@ namespace Sass {
     strings(),
     resources(),
     sheets(),
-    subset_map(),
     import_stack(),
     callee_stack(),
     traces(),
+    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")),
@@ -150,7 +133,7 @@ namespace Sass {
     }
     // clear inner structures (vectors) and input source
     resources.clear(); import_stack.clear();
-    subset_map.clear(), sheets.clear();
+    sheets.clear();
   }
 
   Data_Context::~Data_Context()
@@ -173,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);
@@ -182,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);
@@ -206,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);
@@ -215,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);
@@ -234,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
@@ -291,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
@@ -316,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);
@@ -327,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);
@@ -335,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);
@@ -343,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";
@@ -382,30 +365,30 @@ namespace Sass {
 
   }
 
-  void Context::import_url (Import_Ptr 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) { }
     }
 
-    // add urls (protocol other than file) and urls without procotol to `urls` member
+    // add urls (protocol other than file) and urls without protocol to `urls` member
     // ToDo: if ctx_path is already a file resource, we should not add it here?
     if (imp->import_queries() || protocol != "file" || imp_path.substr(0, 2) == "//") {
       imp->urls().push_back(SASS_MEMORY_NEW(String_Quoted, imp->pstate(), load_path));
     }
     else if (imp_path.length() > 4 && imp_path.substr(imp_path.length() - 4, 4) == ".css") {
-      String_Constant_Ptr loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
+      String_Constant* loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
       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_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "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 {
@@ -421,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_Ptr 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;
@@ -439,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();
           }
@@ -458,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
@@ -502,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);
@@ -519,7 +502,7 @@ namespace Sass {
     OutputBuffer emitted = emitter.get_buffer();
     // should we append a source map url?
     if (!c_options.omit_source_map_url) {
-      // generate an embeded source map
+      // generate an embedded source map
       if (c_options.source_map_embed) {
         emitted.buffer += linefeed;
         emitted.buffer += format_embedded_source_map();
@@ -535,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);
@@ -556,11 +539,11 @@ namespace Sass {
   {
 
     // check if entry file is given
-    if (input_path.empty()) return 0;
+    if (input_path.empty()) return {};
 
     // 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);
@@ -575,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;
@@ -602,7 +587,7 @@ namespace Sass {
   {
 
     // check if source string is given
-    if (!source_c_str) return 0;
+    if (!source_c_str) return {};
 
     // convert indented sass syntax
     if(c_options.is_indented_syntax_src) {
@@ -618,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);
 
@@ -639,17 +624,15 @@ namespace Sass {
     return compile();
   }
 
-
-
   // parse root block from includes
   Block_Obj Context::compile()
   {
     // abort if there is no data
-    if (resources.size() == 0) return 0;
+    if (resources.size() == 0) return {};
     // get root block from the first style sheet
     Block_Obj root = sheets.at(entry_path).root;
     // abort on invalid root
-    if (root.isNull()) return 0;
+    if (root.isNull()) return {};
     Env global; // create root environment
     // register built-in functions on env
     register_built_in_functions(*this, &global);
@@ -668,60 +651,60 @@ namespace Sass {
     }
     // expand and eval the tree
     root = expand(root);
+
+    Extension unsatisfied;
+    // check that all extends were used
+    if (extender.checkForUnsatisfiedExtends(unsatisfied)) {
+      throw Exception::UnsatisfiedExtend(traces, unsatisfied);
+    }
+
     // check nesting
     check_nesting(root);
     // merge and bubble certain rules
     root = cssize(root);
-    // should we extend something?
-    if (!subset_map.empty()) {
-      // create crtp visitor object
-      Extend extend(subset_map);
-      extend.setEval(expand.eval);
-      // extend tree nodes
-      extend(root);
-    }
 
     // clean up by removing empty placeholders
     // ToDo: maybe we can do this somewhere else?
     Remove_Placeholders remove_placeholders;
     root->perform(&remove_placeholders);
+
     // return processed tree
     return root;
   }
   // 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); }
@@ -732,28 +715,28 @@ namespace Sass {
 
   void register_function(Context& ctx, Signature sig, Native_Function f, Env* env)
   {
-    Definition_Ptr def = make_native_function(sig, f, ctx);
+    Definition* def = make_native_function(sig, f, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }
 
   void register_function(Context& ctx, Signature sig, Native_Function f, size_t arity, Env* env)
   {
-    Definition_Ptr def = make_native_function(sig, f, ctx);
-    std::stringstream ss;
+    Definition* def = make_native_function(sig, f, ctx);
+    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_Ptr stub = SASS_MEMORY_NEW(Definition,
-                                       ParserState("[built-in function]"),
-                                       0,
+    Definition* stub = SASS_MEMORY_NEW(Definition,
+                                       SourceSpan{ "[built-in function]" },
+                                       nullptr,
                                        name,
-                                       0,
-                                       0,
+                                       Parameters_Obj{},
+                                       nullptr,
                                        true);
     (*env)[name + "[f]"] = stub;
   }
@@ -872,7 +855,7 @@ namespace Sass {
   }
   void register_c_function(Context& ctx, Env* env, Sass_Function_Entry descr)
   {
-    Definition_Ptr def = make_c_function(descr, ctx);
+    Definition* def = make_c_function(descr, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }