sassc 1.11.1 → 1.11.2

data/ext/libsass/src/parser.hpp

@@ -26,9 +26,9 @@ namespace Sass {
     enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules };
 
     Context& ctx;
-    std::vector<Block*> block_stack;
+    std::vector<Block_Obj> block_stack;
     std::vector<Scope> stack;
-    Media_Block* last_media_block;
+    Media_Block_Ptr last_media_block;
     const char* source;
     const char* position;
     const char* end;
@@ -42,7 +42,7 @@ namespace Sass {
     bool in_at_root;
 
     Parser(Context& ctx, const ParserState& pstate)
-    : ParserState(pstate), ctx(ctx), block_stack(0), stack(0), last_media_block(0),
+    : ParserState(pstate), ctx(ctx), block_stack(), stack(0), last_media_block(),
       source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate(pstate), indentation(0)
     { in_at_root = false; stack.push_back(Scope::Root); }
 
@@ -51,7 +51,7 @@ namespace Sass {
     static Parser from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
     static Parser from_token(Token t, Context& ctx, ParserState pstate = ParserState("[TOKEN]"), const char* source = 0);
     // special static parsers to convert strings into certain selectors
-    static CommaSequence_Selector* parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
+    static Selector_List_Obj parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
 
 #ifdef __clang__
 
@@ -231,93 +231,88 @@ namespace Sass {
                    const std::string& middle = ", was: ");
     void read_bom();
 
-    Block* parse();
-    Import* parse_import();
-    Definition* parse_definition(Definition::Type which_type);
-    Parameters* parse_parameters();
-    Parameter* parse_parameter();
-    Mixin_Call* parse_include_directive();
-    Arguments* parse_arguments();
-    Argument* parse_argument();
-    Assignment* parse_assignment();
-    Ruleset* parse_ruleset(Lookahead lookahead, bool is_root = false);
-    Selector_Schema* parse_selector_schema(const char* end_of_selector);
-    CommaSequence_Selector* parse_selector_list(bool at_root = false);
-    Sequence_Selector* parse_complex_selector(bool in_root = true);
-    SimpleSequence_Selector* parse_compound_selector();
-    Simple_Selector* parse_simple_selector();
-    Wrapped_Selector* parse_negated_selector();
-    Simple_Selector* parse_pseudo_selector();
-    Attribute_Selector* parse_attribute_selector();
-    Block* parse_block(bool is_root = false);
-    Block* parse_css_block(bool is_root = false);
+    Block_Obj parse();
+    Import_Obj parse_import();
+    Definition_Obj parse_definition(Definition::Type which_type);
+    Parameters_Obj parse_parameters();
+    Parameter_Obj parse_parameter();
+    Mixin_Call_Obj parse_include_directive();
+    Arguments_Obj parse_arguments();
+    Argument_Obj parse_argument();
+    Assignment_Obj parse_assignment();
+    Ruleset_Obj parse_ruleset(Lookahead lookahead, bool is_root = false);
+    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector);
+    Selector_List_Obj parse_selector_list(bool at_root = false);
+    Complex_Selector_Obj parse_complex_selector(bool in_root = true);
+    Compound_Selector_Obj parse_compound_selector();
+    Simple_Selector_Obj parse_simple_selector();
+    Wrapped_Selector_Obj parse_negated_selector();
+    Simple_Selector_Obj parse_pseudo_selector();
+    Attribute_Selector_Obj parse_attribute_selector();
+    Block_Obj parse_block(bool is_root = false);
+    Block_Obj parse_css_block(bool is_root = false);
     bool parse_block_nodes(bool is_root = false);
     bool parse_block_node(bool is_root = false);
 
     bool parse_number_prefix();
-    Declaration* parse_declaration();
-    Expression* parse_map_value();
-    Expression* parse_map();
-    Expression* parse_list(bool delayed = false);
-    Expression* parse_comma_list(bool delayed = false);
-    Expression* parse_space_list();
-    Expression* parse_disjunction();
-    Expression* parse_conjunction();
-    Expression* parse_relation();
-    Expression* parse_expression();
-    Expression* parse_operators();
-    Expression* parse_factor();
-    Expression* parse_value2();
-    Expression* parse_value();
-    Function_Call* parse_calc_function();
-    Function_Call* parse_function_call();
-    Function_Call_Schema* parse_function_call_schema();
-    String* parse_url_function_string();
-    String* parse_url_function_argument();
-    String* parse_interpolated_chunk(Token, bool constant = false);
-    String* parse_string();
-    String_Constant* parse_static_expression();
-    // String_Constant* parse_static_property();
-    String_Constant* parse_static_value();
-    String* parse_ie_property();
-    String* parse_ie_keyword_arg();
-    String_Schema* parse_value_schema(const char* stop);
-    String* parse_identifier_schema();
-    // String_Schema* parse_url_schema();
-    If* parse_if_directive(bool else_if = false);
-    For* parse_for_directive();
-    Each* parse_each_directive();
-    While* parse_while_directive();
-    Return* parse_return_directive();
-    Content* parse_content_directive();
+    Declaration_Obj parse_declaration();
+    Expression_Obj parse_map();
+    Expression_Obj parse_list(bool delayed = false);
+    Expression_Obj parse_comma_list(bool delayed = false);
+    Expression_Obj parse_space_list();
+    Expression_Obj parse_disjunction();
+    Expression_Obj parse_conjunction();
+    Expression_Obj parse_relation();
+    Expression_Obj parse_expression();
+    Expression_Obj parse_operators();
+    Expression_Obj parse_factor();
+    Expression_Obj parse_value();
+    Function_Call_Obj parse_calc_function();
+    Function_Call_Obj parse_function_call();
+    Function_Call_Schema_Obj parse_function_call_schema();
+    String_Obj parse_url_function_string();
+    String_Obj parse_url_function_argument();
+    String_Obj parse_interpolated_chunk(Token, bool constant = false);
+    String_Obj parse_string();
+    String_Constant_Obj parse_static_value();
+    String_Obj parse_ie_property();
+    String_Obj parse_ie_keyword_arg();
+    String_Schema_Obj parse_value_schema(const char* stop);
+    String_Obj parse_identifier_schema();
+    If_Obj parse_if_directive(bool else_if = false);
+    For_Obj parse_for_directive();
+    Each_Obj parse_each_directive();
+    While_Obj parse_while_directive();
+    Return_Obj parse_return_directive();
+    Content_Obj parse_content_directive();
     void parse_charset_directive();
-    Media_Block* parse_media_block();
-    List* parse_media_queries();
-    Media_Query* parse_media_query();
-    Media_Query_Expression* parse_media_expression();
-    Supports_Block* parse_supports_directive();
-    Supports_Condition* parse_supports_condition();
-    Supports_Condition* parse_supports_negation();
-    Supports_Condition* parse_supports_operator();
-    Supports_Condition* parse_supports_interpolation();
-    Supports_Condition* parse_supports_declaration();
-    Supports_Condition* parse_supports_condition_in_parens();
-    At_Root_Block* parse_at_root_block();
-    At_Root_Query* parse_at_root_query();
-    String_Schema* parse_almost_any_value();
-    Directive* parse_special_directive();
-    Directive* parse_prefixed_directive();
-    Directive* parse_directive();
-    Warning* parse_warning();
-    Error* parse_error();
-    Debug* parse_debug();
+    Media_Block_Obj parse_media_block();
+    List_Obj parse_media_queries();
+    Media_Query_Obj parse_media_query();
+    Media_Query_Expression_Obj parse_media_expression();
+    Supports_Block_Obj parse_supports_directive();
+    Supports_Condition_Obj parse_supports_condition();
+    Supports_Condition_Obj parse_supports_negation();
+    Supports_Condition_Obj parse_supports_operator();
+    Supports_Condition_Obj parse_supports_interpolation();
+    Supports_Condition_Obj parse_supports_declaration();
+    Supports_Condition_Obj parse_supports_condition_in_parens();
+    At_Root_Block_Obj parse_at_root_block();
+    At_Root_Query_Obj parse_at_root_query();
+    String_Schema_Obj parse_almost_any_value();
+    Directive_Obj parse_special_directive();
+    Directive_Obj parse_prefixed_directive();
+    Directive_Obj parse_directive();
+    Warning_Obj parse_warning();
+    Error_Obj parse_error();
+    Debug_Obj parse_debug();
 
     // be more like ruby sass
-    Expression* lex_almost_any_value_token();
-    Expression* lex_almost_any_value_chars();
-    Expression* lex_interp_string();
-    Expression* lex_interp_uri();
-    Expression* lex_interpolation();
+    Expression_Obj lex_almost_any_value_token();
+    Expression_Obj lex_almost_any_value_chars();
+    Expression_Obj lex_interp_string();
+    Expression_Obj lex_interp_uri();
+    Expression_Obj lex_interpolation();
 
     // these will throw errors
     Token lex_variable();
@@ -329,35 +324,35 @@ namespace Sass {
     Lookahead lookahead_for_selector(const char* start = 0);
     Lookahead lookahead_for_include(const char* start = 0);
 
-    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, Operand op);
-    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, std::vector<Operand>& ops, size_t i = 0);
+    Expression_Obj fold_operands(Expression_Obj base, std::vector<Expression_Obj>& operands, Operand op);
+    Expression_Obj fold_operands(Expression_Obj base, std::vector<Expression_Obj>& operands, std::vector<Operand>& ops, size_t i = 0);
 
     void throw_syntax_error(std::string message, size_t ln = 0);
     void throw_read_error(std::string message, size_t ln = 0);
 
 
     template <Prelexer::prelexer open, Prelexer::prelexer close>
-    Expression* lex_interp()
+    Expression_Obj lex_interp()
     {
       if (lex < open >(false)) {
-        String_Schema* schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, pstate);
+        String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
         // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
-        *schema << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
         if (position[0] == '#' && position[1] == '{') {
-          Expression* itpl = lex_interpolation();
-          if (itpl) *schema << itpl;
+          Expression_Obj itpl = lex_interpolation();
+          if (&itpl) schema->append(&itpl);
           while (lex < close >(false)) {
             // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
-            *schema << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+            schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
             if (position[0] == '#' && position[1] == '{') {
-              Expression* itpl = lex_interpolation();
-              if (itpl) *schema << itpl;
+              Expression_Obj itpl = lex_interpolation();
+              if (&itpl) schema->append(&itpl);
             } else {
-              return schema;
+              return &schema;
             }
           }
         } else {
-          return SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+          return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
         }
       }
       return 0;

data/ext/libsass/src/prelexer.cpp

@@ -243,16 +243,19 @@ namespace Sass {
         exactly <'l'>,
         exactly <'('>,
         W,
-        non_greedy<
-          alternatives<
-            class_char< real_uri_chars >,
-            uri_character,
-            NONASCII,
-            ESCAPE
-          >,
-          alternatives<
-            sequence < W, exactly <')'> >,
-            exactly< hash_lbrace >
+        alternatives<
+          quoted_string,
+          non_greedy<
+            alternatives<
+              class_char< real_uri_chars >,
+              uri_character,
+              NONASCII,
+              ESCAPE
+            >,
+            alternatives<
+              sequence < W, exactly <')'> >,
+              exactly< hash_lbrace >
+            >
           >
         >
       >(src);

data/ext/libsass/src/remove_placeholders.cpp

@@ -10,19 +10,20 @@ namespace Sass {
     : ctx(ctx)
     { }
 
-    void Remove_Placeholders::operator()(Block* b) {
+    void Remove_Placeholders::operator()(Block_Ptr b) {
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            (*b)[i]->perform(this);
+            Statement_Ptr st = &b->at(i);
+            st->perform(this);
         }
     }
 
-    CommaSequence_Selector* Remove_Placeholders::remove_placeholders(CommaSequence_Selector* sl)
+    Selector_List_Ptr Remove_Placeholders::remove_placeholders(Selector_List_Ptr sl)
     {
-      CommaSequence_Selector* new_sl = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, sl->pstate());
+      Selector_List_Ptr new_sl = SASS_MEMORY_NEW(Selector_List, sl->pstate());
 
       for (size_t i = 0, L = sl->length(); i < L; ++i) {
-          if (!(*sl)[i]->contains_placeholder()) {
-              *new_sl << (*sl)[i];
+          if (!sl->at(i)->contains_placeholder()) {
+              new_sl->append(sl->at(i));
           }
       }
 
@@ -31,21 +32,21 @@ namespace Sass {
     }
 
 
-    void Remove_Placeholders::operator()(Ruleset* r) {
+    void Remove_Placeholders::operator()(Ruleset_Ptr r) {
         // Create a new selector group without placeholders
-        CommaSequence_Selector* sl = static_cast<CommaSequence_Selector*>(r->selector());
+        Selector_List_Obj sl = SASS_MEMORY_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 (Sequence_Selector* cs : *sl) {
+          for (Complex_Selector_Obj cs : sl->elements()) {
             while (cs) {
               if (cs->head()) {
-                for (Simple_Selector* ss : *cs->head()) {
-                  if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
-                    if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
-                      CommaSequence_Selector* clean = remove_placeholders(sl);
+                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);
                       // also clean superflous parent selectors
                       // probably not really the correct place
                       clean->remove_parent_selectors();
@@ -60,21 +61,24 @@ namespace Sass {
         }
 
         // Iterate into child blocks
-        Block* b = r->block();
+        Block_Obj b = r->block();
 
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            if ((*b)[i]) (*b)[i]->perform(this);
+            if (b->at(i)) {
+                Statement_Obj st = b->at(i);
+                st->perform(this);
+            }
         }
     }
 
-    void Remove_Placeholders::operator()(Media_Block* m) {
-        operator()(m->block());
+    void Remove_Placeholders::operator()(Media_Block_Ptr m) {
+        operator()(&m->block());
     }
-    void Remove_Placeholders::operator()(Supports_Block* m) {
-        operator()(m->block());
+    void Remove_Placeholders::operator()(Supports_Block_Ptr m) {
+        operator()(&m->block());
     }
 
-    void Remove_Placeholders::operator()(Directive* a) {
+    void Remove_Placeholders::operator()(Directive_Ptr a) {
         if (a->block()) a->block()->perform(this);
     }
 

data/ext/libsass/src/remove_placeholders.hpp

@@ -15,20 +15,20 @@ namespace Sass {
 
         Context&          ctx;
 
-        void fallback_impl(AST_Node* n) {}
+        void fallback_impl(AST_Node_Ptr n) {}
 
     public:
-      CommaSequence_Selector* remove_placeholders(CommaSequence_Selector*);
+      Selector_List_Ptr remove_placeholders(Selector_List_Ptr);
 
     public:
         Remove_Placeholders(Context&);
         ~Remove_Placeholders() { }
 
-        void operator()(Block*);
-        void operator()(Ruleset*);
-        void operator()(Media_Block*);
-        void operator()(Supports_Block*);
-        void operator()(Directive*);
+        void operator()(Block_Ptr);
+        void operator()(Ruleset_Ptr);
+        void operator()(Media_Block_Ptr);
+        void operator()(Supports_Block_Ptr);
+        void operator()(Directive_Ptr);
 
         template <typename U>
         void fallback(U x) { return fallback_impl(x); }

data/ext/libsass/src/sass2scss.cpp

@@ -587,7 +587,8 @@ namespace Sass
 				sass.substr(pos_left, 5) == "@warn" ||
 				sass.substr(pos_left, 6) == "@debug" ||
 				sass.substr(pos_left, 6) == "@error" ||
-				sass.substr(pos_left, 8) == "@charset"
+				sass.substr(pos_left, 8) == "@charset" ||
+				sass.substr(pos_left, 10) == "@namespace"
 			) { sass = indent + sass.substr(pos_left); }
 			// replace some specific sass shorthand directives (if not fallowed by a white space character)
 			else if (sass.substr(pos_left, 1) == "=")

data/ext/libsass/src/sass_context.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "sass.h"
+#include "ast.hpp"
 #include "file.hpp"
 #include "json.hpp"
 #include "util.hpp"
@@ -26,39 +27,10 @@ namespace Sass {
     std::string str(stream.str());
     return json_mkstring(str.c_str());
   }
-}
-
-extern "C" {
-  using namespace Sass;
-
-  static void sass_clear_options (struct Sass_Options* options);
-  static void sass_reset_options (struct Sass_Options* options);
-  static void copy_options(struct Sass_Options* to, struct Sass_Options* from) {
-    // free assigned memory
-    sass_clear_options(to);
-    // move memory
-    *to = *from;
-    // Reset pointers on source
-    sass_reset_options(from);
-  }
-
-  #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); } \
-    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_CONTEXT_GETTER(type, option) \
-    type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }
-  #define IMPLEMENT_SASS_CONTEXT_TAKER(type, option) \
-    type sass_context_take_##option (struct Sass_Context* ctx) \
-    { type foo = ctx->option; ctx->option = 0; return foo; }
 
   static int handle_error(Sass_Context* c_ctx) {
     try {
-     throw;
+      throw;
     }
     catch (Exception::Base& e) {
       std::stringstream msg_stream;
@@ -68,17 +40,19 @@ extern "C" {
       bool got_newline = false;
       msg_stream << msg_prefix << ": ";
       const char* msg = e.what();
-      while(msg && *msg) {
+      while (msg && *msg) {
         if (*msg == '\r') {
           got_newline = true;
-        } else if (*msg == '\n') {
+        }
+        else if (*msg == '\n') {
           got_newline = true;
-        } else if (got_newline) {
+        }
+        else if (got_newline) {
           msg_stream << std::string(msg_prefix.size() + 2, ' ');
           got_newline = false;
         }
         msg_stream << *msg;
-        ++ msg;
+        ++msg;
       }
       if (!got_newline) msg_stream << "\n";
       if (e.import_stack) {
@@ -87,12 +61,13 @@ extern "C" {
           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";
+          msg_stream << e.pstate.line + 1 << " of " << rel_path << "\n";
         }
-      } else {
+      }
+      else {
         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";
+        msg_stream << " on line " << e.pstate.line + 1 << " of " << rel_path << "\n";
       }
 
       // now create the code trace (ToDo: maybe have util functions?)
@@ -100,19 +75,19 @@ extern "C" {
         size_t line = e.pstate.line;
         const char* line_beg = e.pstate.src;
         while (line_beg && *line_beg && line) {
-          if (*line_beg == '\n') -- line;
-          ++ line_beg;
+          if (*line_beg == '\n') --line;
+          ++line_beg;
         }
         const char* line_end = line_beg;
         while (line_end && *line_end && *line_end != '\n') {
           if (*line_end == '\n') break;
           if (*line_end == '\r') break;
-          line_end ++;
+          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;
+          (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";
       }
@@ -120,17 +95,18 @@ extern "C" {
       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, "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, "message", json_mkstring(e.what()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       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_line = e.pstate.line + 1;
+      c_ctx->error_column = e.pstate.column + 1;
       c_ctx->error_src = e.pstate.src;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -143,7 +119,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(2));
       json_append_member(json_err, "message", json_mkstring(ba.what()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(ba.what());
       c_ctx->error_status = 2;
@@ -158,7 +135,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(3));
       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, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 3;
@@ -173,7 +151,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e.c_str()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.c_str());
       c_ctx->error_status = 4;
@@ -188,7 +167,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e);
       c_ctx->error_status = 4;
@@ -202,7 +182,8 @@ extern "C" {
       msg_stream << "Unknown error occurred" << std::endl;
       json_append_member(json_err, "status", json_mknumber(5));
       json_append_member(json_err, "message", json_mkstring("unknown"));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
+      try { c_ctx->error_json = json_stringify(json_err, "  "); }
+      catch (...) {}
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string("unknown");
       c_ctx->error_status = 5;
@@ -221,6 +202,88 @@ extern "C" {
     return c_ctx->error_status;
   }
 
+  static Block_Obj sass_parse_block(Sass_Compiler* compiler) throw()
+  {
+
+    // assert valid pointer
+    if (compiler == 0) return 0;
+    // The cpp context must be set by now
+    Context* cpp_ctx = compiler->cpp_ctx;
+    Sass_Context* c_ctx = compiler->c_ctx;
+    // We will take care to wire up the rest
+    compiler->cpp_ctx->c_compiler = compiler;
+    compiler->state = SASS_COMPILER_PARSED;
+
+    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);
+
+      // maybe skip some entries of included files
+      // we do not include stdin for data contexts
+      bool skip = c_ctx->type == SASS_CONTEXT_DATA;
+
+      // dispatch parse call
+      Block_Obj root(cpp_ctx->parse());
+      // abort on errors
+      if (!root) return 0;
+
+      // skip all prefixed files? (ToDo: check srcmap)
+      // IMO source-maps should point to headers already
+      // therefore don't skip it for now. re-enable or
+      // remove completely once this is tested
+      size_t headers = cpp_ctx->head_imports;
+
+      // copy the included files on to the context (dont forget to free later)
+      if (copy_strings(cpp_ctx->get_included_files(skip, headers), &c_ctx->included_files) == NULL)
+        throw(std::bad_alloc());
+
+      // return parsed block
+      return root;
+
+    }
+    // pass errors to generic error handler
+    catch (...) { handle_errors(c_ctx); }
+
+    // error
+    return 0;
+
+  }
+
+}
+
+extern "C" {
+  using namespace Sass;
+
+  static void sass_clear_options (struct Sass_Options* options);
+  static void sass_reset_options (struct Sass_Options* options);
+  static void copy_options(struct Sass_Options* to, struct Sass_Options* from) {
+    // do not overwrite ourself
+    if (to == from) return;
+    // free assigned memory
+    sass_clear_options(to);
+    // move memory
+    *to = *from;
+    // Reset pointers on source
+    sass_reset_options(from);
+  }
+
+  #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); } \
+    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_CONTEXT_GETTER(type, option) \
+    type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }
+  #define IMPLEMENT_SASS_CONTEXT_TAKER(type, option) \
+    type sass_context_take_##option (struct Sass_Context* ctx) \
+    { type foo = ctx->option; ctx->option = 0; return foo; }
+
+
   // generic compilation function (not exported, use file/data compile instead)
   static Sass_Compiler* sass_prepare_context (Sass_Context* c_ctx, Context* cpp_ctx) throw()
   {
@@ -284,58 +347,6 @@ extern "C" {
 
   }
 
-  static Block* sass_parse_block (Sass_Compiler* compiler) throw()
-  {
-
-    // assert valid pointer
-    if (compiler == 0) return 0;
-    // The cpp context must be set by now
-    Context* cpp_ctx = compiler->cpp_ctx;
-    Sass_Context* c_ctx = compiler->c_ctx;
-    // We will take care to wire up the rest
-    compiler->cpp_ctx->c_compiler = compiler;
-    compiler->state = SASS_COMPILER_PARSED;
-
-    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);
-
-      // parsed root block
-      Block* root = 0;
-
-      // maybe skip some entries of included files
-      // we do not include stdin for data contexts
-      bool skip = c_ctx->type == SASS_CONTEXT_DATA;
-
-      // dispatch parse call
-      root = cpp_ctx->parse();
-      // abort on errors
-      if (!root) return 0;
-
-      // skip all prefixed files? (ToDo: check srcmap)
-      // IMO source-maps should point to headers already
-      // therefore don't skip it for now. re-enable or
-      // remove completely once this is tested
-      size_t headers = cpp_ctx->head_imports;
-
-      // copy the included files on to the context (dont forget to free later)
-      if (copy_strings(cpp_ctx->get_included_files(skip, headers), &c_ctx->included_files) == NULL)
-        throw(std::bad_alloc());
-
-      // return parsed block
-      return root;
-
-    }
-    // pass errors to generic error handler
-    catch (...) { handle_errors(c_ctx); }
-
-    // error
-    return 0;
-
-  }
-
   // generic compilation function (not exported, use file/data compile instead)
   static int sass_compile_context (Sass_Context* c_ctx, Context* cpp_ctx)
   {
@@ -373,6 +384,7 @@ extern "C" {
 
   Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)
   {
+    SharedObj::setTaint(true); // needed for static colors
     struct Sass_File_Context* ctx = (struct Sass_File_Context*) calloc(1, sizeof(struct Sass_File_Context));
     if (ctx == 0) { std::cerr << "Error allocating memory for file context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_FILE;
@@ -456,7 +468,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;
   }
@@ -468,12 +480,12 @@ extern "C" {
     if (compiler->state != SASS_COMPILER_PARSED) return -1;
     if (compiler->c_ctx == NULL) return 1;
     if (compiler->cpp_ctx == NULL) return 1;
-    if (compiler->root == NULL) return 1;
+    if (compiler->root.isNull()) return 1;
     if (compiler->c_ctx->error_status)
       return compiler->c_ctx->error_status;
     compiler->state = SASS_COMPILER_EXECUTED;
     Context* cpp_ctx = compiler->cpp_ctx;
-    Block* root = compiler->root;
+    Block_Obj root = compiler->root;
     // compile the parsed root block
     try { compiler->c_ctx->output_string = cpp_ctx->render(root); }
     // pass catched errors to generic error handler
@@ -601,6 +613,10 @@ extern "C" {
     ctx->error_json = 0;
     ctx->error_file = 0;
     ctx->included_files = 0;
+    // debug leaked memory
+    #ifdef DEBUG_SHARED_PTR
+      SharedObj::dumpMemLeaks();
+    #endif
     // now clear the options
     sass_clear_options(ctx);
   }
@@ -612,7 +628,9 @@ extern "C" {
     }
     Context* cpp_ctx = compiler->cpp_ctx;
     if (cpp_ctx) delete(cpp_ctx);
-    compiler->cpp_ctx = 0;
+    compiler->cpp_ctx = NULL;
+    compiler->c_ctx = NULL;
+    compiler->root = NULL;
     free(compiler);
   }