sassc 0.0.9 → 0.0.10

data/ext/libsass/prelexer.hpp

@@ -1,4 +1,7 @@
-#define SASS_PRELEXER
+#ifndef SASS_PRELEXER_H
+#define SASS_PRELEXER_H
+
+#include <cstring>
 
 namespace Sass {
   namespace Prelexer {
@@ -16,7 +19,12 @@ namespace Sass {
     template <const char* prefix>
     const char* exactly(const char* src) {
       const char* pre = prefix;
-      while (*pre && *src == *pre) ++src, ++pre;
+      if (*src == 0) return 0;
+      // there is a small chance that the search prefix
+      // is longer than the rest of the string to look at
+      while (*pre && *src == *pre) {
+      	++src, ++pre;
+      }
       return *pre ? 0 : src;
     }
 
@@ -50,6 +58,14 @@ namespace Sass {
       return p == src ? 0 : p;
     }
 
+    // Match a sequence of characters up to the next newline.
+    template <char end>
+    const char* until(const char* src) {
+      if (*src == '\n' && exactly<end>(src)) return 0;
+      while (*src && *src != '\n' && !exactly<end>(src)) ++src;
+      return ++src;
+    }
+
     // Match a sequence of characters up to the next newline.
     template <const char* prefix>
     const char* to_endl(const char* src) {
@@ -72,6 +88,69 @@ namespace Sass {
       }
     }
 
+    // skip to delimiter (mx) inside given range
+    // this will savely skip over all quoted strings
+    // recursive skip stuff delimited by start/stop
+    // first start/opener must be consumed already!
+    template<prelexer start, prelexer stop>
+    const char* skip_over_scopes(const char* src, const char* end = 0) {
+
+      size_t level = 0;
+      bool in_squote = false;
+      bool in_dquote = false;
+      // bool in_braces = false;
+
+      while (*src) {
+
+        // check for abort condition
+        if (end && src >= end) break;
+
+        // has escaped sequence?
+        if (*src == '\\') {
+          ++ src; // skip this (and next)
+        }
+        else if (*src == '"') {
+          in_dquote = ! in_dquote;
+        }
+        else if (*src == '\'') {
+          in_squote = ! in_squote;
+        }
+        else if (in_dquote || in_squote) {
+          // take everything literally
+        }
+
+        // find another opener inside?
+        else if (start(src)) {
+          ++ level; // increase counter
+        }
+
+        // look for the closer (maybe final, maybe not)
+        else if (const char* final = stop(src)) {
+          // only close one level?
+          if (level > 0) -- level;
+          // return position at end of stop
+          // delimiter may be multiple chars
+          else return final;
+        }
+
+        // next
+        ++ src;
+      }
+
+      return 0;
+    }
+
+    // Match a sequence of characters delimited by the supplied chars.
+    template <prelexer start, prelexer stop>
+    const char* recursive_scopes(const char* src) {
+      // parse opener
+      src = start(src);
+      // abort if not found
+      if (!src) return 0;
+      // parse the rest until final closer
+      return skip_over_scopes<start, stop>(src);
+    }
+
     // Match a sequence of characters delimited by the supplied strings.
     template <const char* beg, const char* end, bool esc>
     const char* delimited_by(const char* src) {
@@ -93,12 +172,14 @@ namespace Sass {
     const char* any_char_except(const char* src) {
       return (*src && *src != c) ? src+1 : 0;
     }
+    // Match word boundary (look ahead)
+    const char* word_boundary(const char* src);
 
     // Matches zero characters (always succeeds without consuming input).
-    const char* epsilon(const char*);
+    // const char* epsilon(const char*);
 
     // Matches the empty string.
-    const char* empty(const char*);
+    // const char* empty(const char*);
 
     // Succeeds of the supplied matcher fails, and vice versa.
     template <prelexer mx>
@@ -295,6 +376,10 @@ namespace Sass {
     const char* xdigits(const char* src);
     const char* alnums(const char* src);
     const char* puncts(const char* src);
+    // Match certain white-space charactes.
+    const char* wspaces(const char* src);
+    // const char* newline(const char* src);
+    // const char* whitespace(const char* src);
 
     // Match a line comment.
     const char* line_comment(const char* src);
@@ -308,13 +393,16 @@ namespace Sass {
     // Match double- and single-quoted strings.
     const char* double_quoted_string(const char* src);
     const char* single_quoted_string(const char* src);
-    const char* string_constant(const char* src);
+    const char* quoted_string(const char* src);
     // Match interpolants.
     const char* interpolant(const char* src);
+    // Match number prefix ([\+\-]+)
+    const char* number_prefix(const char* src);
 
     // Whitespace handling.
     const char* optional_spaces(const char* src);
-    const char* optional_comment(const char* src);
+    // const char* optional_comment(const char* src);
+    const char* optional_spaces_and_comments(const char* src);
     const char* spaces_and_comments(const char* src);
     const char* no_spaces(const char* src);
 
@@ -326,22 +414,25 @@ namespace Sass {
     const char* identifier(const char* src);
     const char* identifier_fragment(const char* src);
     // Match selector names.
-    const char* sel_ident(const char* src);
+    // const char* sel_ident(const char* src);
     // Match interpolant schemas
     const char* identifier_schema(const char* src);
     const char* value_schema(const char* src);
     const char* filename(const char* src);
-    const char* filename_schema(const char* src);
-    const char* url_schema(const char* src);
-    const char* url_value(const char* src);
+    // const char* filename_schema(const char* src);
+    // const char* url_schema(const char* src);
+    // const char* url_value(const char* src);
     const char* vendor_prefix(const char* src);
     // Match CSS '@' keywords.
     const char* at_keyword(const char* src);
     const char* import(const char* src);
+    const char* at_root(const char* src);
+    const char* with_directive(const char* src);
+    const char* without_directive(const char* src);
     const char* media(const char* src);
     const char* supports(const char* src);
-    const char* keyframes(const char* src);
-    const char* keyf(const char* src);
+    // const char* keyframes(const char* src);
+    // const char* keyf(const char* src);
     const char* mixin(const char* src);
     const char* function(const char* src);
     const char* return_directive(const char* src);
@@ -367,7 +458,7 @@ namespace Sass {
     const char* err(const char* src);
     const char* dbg(const char* src);
 
-    const char* directive(const char* src);
+    // const char* directive(const char* src);
     const char* at_keyword(const char* src);
 
     const char* null(const char* src);
@@ -396,10 +487,11 @@ namespace Sass {
     const char* dimension(const char* src);
     const char* hex(const char* src);
     const char* hexa(const char* src);
-    const char* rgb_prefix(const char* src);
+    const char* hex0(const char* src);
+    // const char* rgb_prefix(const char* src);
     // Match CSS uri specifiers.
     const char* uri_prefix(const char* src);
-    const char* uri(const char* src);
+    // const char* uri(const char* src);
     const char* url(const char* src);
     // Match CSS "!important" keyword.
     const char* important(const char* src);
@@ -425,10 +517,10 @@ namespace Sass {
     const char* suffix_match(const char* src);
     const char* substring_match(const char* src);
     // Match CSS combinators.
-    const char* adjacent_to(const char* src);
-    const char* precedes(const char* src);
-    const char* parent_of(const char* src);
-    const char* ancestor_of(const char* src);
+    // const char* adjacent_to(const char* src);
+    // const char* precedes(const char* src);
+    // const char* parent_of(const char* src);
+    // const char* ancestor_of(const char* src);
 
     // Match SCSS variable names.
     const char* variable(const char* src);
@@ -456,8 +548,8 @@ namespace Sass {
     const char* url(const char* src);
 
     // Path matching functions.
-    const char* folder(const char* src);
-    const char* folders(const char* src);
+    // const char* folder(const char* src);
+    // const char* folders(const char* src);
 
 
     const char* static_string(const char* src);
@@ -477,8 +569,11 @@ namespace Sass {
     }
     template<prelexer mx>
     const char* find_first_in_interval(const char* beg, const char* end) {
+      bool esc = false;
       while ((beg < end) && *beg) {
-        if (mx(beg)) return beg;
+        if (esc) esc = false;
+        else if (*beg == '\\') esc = true;
+        else if (mx(beg)) return beg;
         ++beg;
       }
       return 0;
@@ -486,8 +581,11 @@ namespace Sass {
     template <char c>
     unsigned int count_interval(const char* beg, const char* end) {
       unsigned int counter = 0;
+      bool esc = false;
       while (beg < end && *beg) {
-        if (*beg == c) ++counter;
+        if (esc) esc = false;
+        else if (*beg == '\\') esc = true;
+        else if (*beg == c) ++counter;
         ++beg;
       }
       return counter;
@@ -495,9 +593,16 @@ namespace Sass {
     template <prelexer mx>
     unsigned int count_interval(const char* beg, const char* end) {
       unsigned int counter = 0;
+      bool esc = false;
       while (beg < end && *beg) {
         const char* p;
-        if ((p = mx(beg))) {
+        if (esc) {
+          esc = false;
+          ++beg;
+        } else if (*beg == '\\') {
+          esc = true;
+          ++beg;
+        } else if ((p = mx(beg))) {
           ++counter;
           beg = p;
         }
@@ -511,3 +616,5 @@ namespace Sass {
     const char* chunk(const char* src);
   }
 }
+
+#endif

data/ext/libsass/remove_placeholders.cpp

@@ -17,7 +17,7 @@ namespace Sass {
         Selector_List* sl = static_cast<Selector_List*>(r->selector());
 
         if (sl) {
-            Selector_List* new_sl = new (ctx.mem) Selector_List(sl->path(), sl->position());
+            Selector_List* new_sl = new (ctx.mem) Selector_List(sl->pstate());
 
             for (size_t i = 0, L = sl->length(); i < L; ++i) {
                 if (!(*sl)[i]->has_placeholder()) {

data/ext/libsass/remove_placeholders.hpp

@@ -1,20 +1,18 @@
+#ifndef SASS_REMOVE_PLACEHOLDERS_H
+#define SASS_REMOVE_PLACEHOLDERS_H
+
 #pragma once
 
 #include <iostream>
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
-#ifndef SASS_OPERATION
 #include "operation.hpp"
-#endif
 
 namespace Sass {
 
     using namespace std;
 
-    struct Context;
+    class Context;
 
     class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
 
@@ -41,3 +39,5 @@ namespace Sass {
     };
 
 }
+
+#endif

data/ext/libsass/sass.cpp

@@ -4,14 +4,14 @@
 #include <sstream>
 
 #include "sass.h"
-#include "inspect.hpp"
+#include "util.hpp"
 
 extern "C" {
   using namespace std;
 
   // caller must free the returned memory
-  char* ADDCALL sass_string_quote (const char *str, const char quotemark) {
-    string quoted = Sass::quote(str, quotemark);
+  char* ADDCALL sass_string_quote (const char *str, const char quote_mark) {
+    string quoted = Sass::quote(str, quote_mark);
     char *cstr = (char*) malloc(quoted.length() + 1);
     std::strcpy(cstr, quoted.c_str());
     return cstr;

data/ext/libsass/sass.h

@@ -1,9 +1,18 @@
-#ifndef SASS
-#define SASS
+#ifndef SASS_H
+#define SASS_H
 
 #include <stddef.h>
 #include <stdbool.h>
 
+#ifdef __GNUC__
+  #define DEPRECATED(func) func __attribute__ ((deprecated))
+#elif defined(_MSC_VER)
+  #define DEPRECATED(func) __declspec(deprecated) func
+#else
+  #pragma message("WARNING: You need to implement DEPRECATED for this compiler")
+  #define DEPRECATED(func) func
+#endif
+
 #ifdef _WIN32
 
   /* You should define ADD_EXPORTS *only* when building the DLL. */
@@ -46,13 +55,12 @@ enum Sass_Output_Style {
 };
 
 // Some convenient string helper function
-ADDAPI char* ADDCALL sass_string_quote (const char *str, const char quotemark);
+ADDAPI char* ADDCALL sass_string_quote (const char *str, const char quote_mark);
 ADDAPI char* ADDCALL sass_string_unquote (const char *str);
 
 // Get compiled libsass version
 ADDAPI const char* ADDCALL libsass_version(void);
 
-
 #ifdef __cplusplus
 } // __cplusplus defined.
 #endif

data/ext/libsass/sass2scss.cpp

@@ -561,11 +561,12 @@ namespace Sass
 
 			}
 
-			// terminate warn and debug statements immediately
+			// terminate some statements immediately
 			else if (
 				sass.substr(pos_left, 5) == "@warn" ||
 				sass.substr(pos_left, 6) == "@debug" ||
-				sass.substr(pos_left, 6) == "@error"
+				sass.substr(pos_left, 6) == "@error" ||
+				sass.substr(pos_left, 8) == "@charset"
 			) { 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) == "=" && sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left) != pos_left + 1)

data/ext/libsass/sass2scss.h

@@ -1,3 +1,6 @@
+#ifndef SASS2SCSS_H
+#define SASS2SCSS_H
+
 #ifdef _WIN32
 
   /* You should define ADD_EXPORTS *only* when building the DLL. */
@@ -108,3 +111,5 @@ extern "C" {
 #ifdef __cplusplus
 } // __cplusplus defined.
 #endif
+
+#endif

data/ext/libsass/sass_context.cpp

@@ -1,14 +1,20 @@
 #ifdef _WIN32
 #include <io.h>
+#define LFEED "\n"
 #else
 #include <unistd.h>
+#define LFEED "\n"
 #endif
 
+#include <cstring>
 #include <stdexcept>
+#include "file.hpp"
 #include "json.hpp"
+#include "util.hpp"
 #include "context.hpp"
 #include "sass_values.h"
 #include "sass_context.h"
+#include "error_handling.hpp"
 
 extern "C" {
   using namespace std;
@@ -68,22 +74,30 @@ extern "C" {
     // information in source-maps etc.
     char* output_path;
 
-    // For the image-url Sass function
-    char* image_path;
+    // String to be used for indentation
+    const char* indent;
+    // String to be used to for line feeds
+    const char* linefeed;
 
     // Colon-separated list of paths
     // Semicolon-separated on Windows
     // Maybe use array interface instead?
     char* include_path;
+    char* plugin_path;
 
-    // Include path (linked string list)
+    // Include paths (linked string list)
     struct string_list* include_paths;
+    // Plugin paths (linked string list)
+    struct string_list* plugin_paths;
 
     // Path to source map file
     // Enables source map generation
     // Used to create sourceMappingUrl
     char* source_map_file;
 
+    // Directly inserted in source maps
+    char* source_map_root;
+
     // Custom functions that can be called from sccs code
     Sass_C_Function_List c_functions;
 
@@ -108,6 +122,7 @@ extern "C" {
     // error status
     int error_status;
     char* error_json;
+    char* error_text;
     char* error_message;
     // error position
     char* error_file;
@@ -162,7 +177,7 @@ extern "C" {
   #define IMPLEMENT_SASS_OPTION_STRING_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) \
-    { free(options->option); options->option = option ? strdup(option) : 0; }
+    { free(options->option); options->option = option ? sass_strdup(option) : 0; }
 
   #define IMPLEMENT_SASS_CONTEXT_GETTER(type, option) \
     type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }
@@ -175,7 +190,7 @@ extern "C" {
     return str == NULL ? "" : str;
   }
 
-  static void copy_strings(const std::vector<std::string>& strings, char*** array, int skip = 0) {
+  static void copy_strings(const std::vector<std::string>& strings, char*** array, int skip = 0) throw() {
     int num = static_cast<int>(strings.size());
     char** arr = (char**) malloc(sizeof(char*) * (num + 1));
     if (arr == 0) throw(bad_alloc());
@@ -210,19 +225,37 @@ extern "C" {
     }
     catch (Sass_Error& e) {
       stringstream msg_stream;
+      string cwd(Sass::File::get_cwd());
       JsonNode* json_err = json_mkobject();
       json_append_member(json_err, "status", json_mknumber(1));
-      json_append_member(json_err, "file", json_mkstring(e.path.c_str()));
-      json_append_member(json_err, "line", json_mknumber(e.position.line));
-      json_append_member(json_err, "column", json_mknumber(e.position.column));
+      json_append_member(json_err, "file", json_mkstring(e.pstate.path.c_str()));
+      json_append_member(json_err, "line", json_mknumber(e.pstate.line+1));
+      json_append_member(json_err, "column", json_mknumber(e.pstate.column+1));
       json_append_member(json_err, "message", json_mkstring(e.message.c_str()));
-      msg_stream << e.path << ":" << e.position.line << ": " << e.message << endl;
+      string rel_path(Sass::File::resolve_relative_path(e.pstate.path, cwd, cwd));
+
+      string msg_prefix("Error: ");
+      bool got_newline = false;
+      msg_stream << msg_prefix;
+      for (char chr : e.message) {
+        if (chr == '\n') {
+          got_newline = true;
+        } else if (got_newline) {
+          msg_stream << string(msg_prefix.size(), ' ');
+          got_newline = false;
+        }
+        msg_stream << chr;
+      }
+      if (!got_newline) msg_stream << "\n";
+      msg_stream << string(msg_prefix.size(), ' ');
+      msg_stream << " on line " << e.pstate.line+1 << " of " << rel_path << "\n";
       c_ctx->error_json = json_stringify(json_err, "  ");;
-      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = strdup(e.message.c_str());
       c_ctx->error_status = 1;
-      c_ctx->error_file = strdup(e.path.c_str());
-      c_ctx->error_line = e.position.line;
-      c_ctx->error_column = e.position.column;
+      c_ctx->error_file = sass_strdup(e.pstate.path.c_str());
+      c_ctx->error_line = e.pstate.line+1;
+      c_ctx->error_column = e.pstate.column+1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
@@ -234,7 +267,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(2));
       json_append_member(json_err, "message", json_mkstring(ba.what()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
-      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = strdup(ba.what());
       c_ctx->error_status = 2;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -247,7 +281,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(3));
       json_append_member(json_err, "message", json_mkstring(e.what()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
-      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = strdup(e.what());
       c_ctx->error_status = 3;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -260,7 +295,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e.c_str()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
-      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = strdup(e.c_str());
       c_ctx->error_status = 4;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -273,7 +309,8 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(5));
       json_append_member(json_err, "message", json_mkstring("unknown"));
       c_ctx->error_json = json_stringify(json_err, "  ");;
-      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = strdup("unknown");
       c_ctx->error_status = 5;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -297,19 +334,35 @@ extern "C" {
       }
 
       // convert include path linked list to static array
-      struct string_list* cur = c_ctx->include_paths;
+      struct string_list* inc = c_ctx->include_paths;
       // very poor loop to get the length of the linked list
-      size_t length = 0; while (cur) { length ++; cur = cur->next; }
+      size_t inc_size = 0; while (inc) { inc_size ++; inc = inc->next; }
       // create char* array to hold all paths plus null terminator
-      const char** include_paths = (const char**) calloc(length + 1, sizeof(char*));
+      const char** include_paths = (const char**) calloc(inc_size + 1, sizeof(char*));
       if (include_paths == 0) throw(bad_alloc());
       // reset iterator
-      cur = c_ctx->include_paths;
+      inc = c_ctx->include_paths;
+      // copy over the paths
+      for (size_t i = 0; inc; i++) {
+        include_paths[i] = inc->string;
+        inc = inc->next;
+      }
+
+      // convert plugin path linked list to static array
+      struct string_list* imp = c_ctx->plugin_paths;
+      // very poor loop to get the length of the linked list
+      size_t imp_size = 0; while (imp) { imp_size ++; imp = imp->next; }
+      // create char* array to hold all paths plus null terminator
+      const char** plugin_paths = (const char**) calloc(imp_size + 1, sizeof(char*));
+      if (plugin_paths == 0) throw(bad_alloc());
+      // reset iterator
+      imp = c_ctx->plugin_paths;
       // copy over the paths
-      for (size_t i = 0; cur; i++) {
-        include_paths[i] = cur->string;
-        cur = cur->next;
+      for (size_t i = 0; imp; i++) {
+        plugin_paths[i] = imp->string;
+        imp = imp->next;
       }
+
       // transfer the options to c++
       cpp_opt.input_path(input_path)
              .output_path(output_path)
@@ -317,20 +370,26 @@ extern "C" {
              .is_indented_syntax_src(c_ctx->is_indented_syntax_src)
              .source_comments(c_ctx->source_comments)
              .source_map_file(safe_str(c_ctx->source_map_file))
+             .source_map_root(safe_str(c_ctx->source_map_root))
              .source_map_embed(c_ctx->source_map_embed)
              .source_map_contents(c_ctx->source_map_contents)
              .omit_source_map_url(c_ctx->omit_source_map_url)
-             .image_path(safe_str(c_ctx->image_path))
              .include_paths_c_str(c_ctx->include_path)
-             .importer(c_ctx->importer)
+             .plugin_paths_c_str(c_ctx->plugin_path)
              .include_paths_array(include_paths)
+             .plugin_paths_array(plugin_paths)
              .include_paths(vector<string>())
-             .precision(c_ctx->precision ? c_ctx->precision : 5);
+             .plugin_paths(vector<string>())
+             .importer(c_ctx->importer)
+             .precision(c_ctx->precision ? c_ctx->precision : 5)
+             .linefeed(c_ctx->linefeed ? c_ctx->linefeed : LFEED)
+             .indent(c_ctx->indent ? c_ctx->indent : "  ");
 
       // create new c++ Context
       Context* cpp_ctx = new Context(cpp_opt);
       // free intermediate data
       free(include_paths);
+      free(plugin_paths);
 
       // register our custom functions
       if (c_ctx->c_functions) {
@@ -343,6 +402,7 @@ extern "C" {
 
       // reset error status
       c_ctx->error_json = 0;
+      c_ctx->error_text = 0;
       c_ctx->error_message = 0;
       c_ctx->error_status = 0;
       // reset error position
@@ -386,7 +446,7 @@ extern "C" {
       }
 
       // copy the included files on to the context (dont forget to free)
-      copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files, skip);
+      if (root) copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files, skip);
 
       // return parsed block
       return root;
@@ -504,7 +564,7 @@ extern "C" {
       if (*data_ctx->source_string == 0) { throw(runtime_error("Data context has empty source string")); }
       cpp_opt.source_c_str(data_ctx->source_string);
     }
-    catch (...) { return handle_errors(c_ctx) || 1; }
+    catch (...) { return handle_errors(c_ctx) | 1; }
     return sass_compile_context(c_ctx, cpp_opt);
   }
 
@@ -520,7 +580,7 @@ extern "C" {
       if (*file_ctx->input_path == 0) { throw(runtime_error("File context has empty input path")); }
       cpp_opt.entry_point(file_ctx->input_path);
     }
-    catch (...) { return handle_errors(c_ctx) || 1; }
+    catch (...) { return handle_errors(c_ctx) | 1; }
     return sass_compile_context(c_ctx, cpp_opt);
   }
 
@@ -557,7 +617,7 @@ extern "C" {
     // compile the parsed root block
     try { compiler->c_ctx->output_string = cpp_ctx->compile_block(root); }
     // pass catched errors to generic error handler
-    catch (...) { return handle_errors(compiler->c_ctx) || 1; }
+    catch (...) { return handle_errors(compiler->c_ctx) | 1; }
     // generate source map json and store on context
     compiler->c_ctx->source_map_string = cpp_ctx->generate_source_map();
     // success
@@ -576,7 +636,19 @@ extern "C" {
         ++this_func_data;
       }
     }
-    // Free custom importer
+    // Deallocate inc paths
+    if (options->plugin_paths) {
+      struct string_list* cur;
+      struct string_list* next;
+      cur = options->plugin_paths;
+      while (cur) {
+        next = cur->next;
+        free(cur->string);
+        free(cur);
+        cur = next;
+      }
+    }
+    // Deallocate inc paths
     if (options->include_paths) {
       struct string_list* cur;
       struct string_list* next;
@@ -595,6 +667,7 @@ extern "C" {
     // Make it null terminated
     options->importer = 0;
     options->c_functions = 0;
+    options->plugin_paths = 0;
     options->include_paths = 0;
   }
 
@@ -603,29 +676,31 @@ extern "C" {
   static void sass_clear_context (struct Sass_Context* ctx)
   {
     if (ctx == 0) return;
-    // release the allocated memory (mostly via strdup)
+    // release the allocated memory (mostly via sass_strdup)
     if (ctx->output_string)     free(ctx->output_string);
     if (ctx->source_map_string) free(ctx->source_map_string);
     if (ctx->error_message)     free(ctx->error_message);
+    if (ctx->error_text)        free(ctx->error_text);
     if (ctx->error_json)        free(ctx->error_json);
     if (ctx->error_file)        free(ctx->error_file);
     if (ctx->input_path)        free(ctx->input_path);
     if (ctx->output_path)       free(ctx->output_path);
-    if (ctx->image_path)        free(ctx->image_path);
     if (ctx->include_path)      free(ctx->include_path);
     if (ctx->source_map_file)   free(ctx->source_map_file);
+    if (ctx->source_map_root)   free(ctx->source_map_root);
     free_string_array(ctx->included_files);
     // play safe and reset properties
     ctx->output_string = 0;
     ctx->source_map_string = 0;
     ctx->error_message = 0;
+    ctx->error_text = 0;
     ctx->error_json = 0;
     ctx->error_file = 0;
     ctx->input_path = 0;
     ctx->output_path = 0;
-    ctx->image_path = 0;
     ctx->include_path = 0;
     ctx->source_map_file = 0;
+    ctx->source_map_root = 0;
     ctx->included_files = 0;
     // now clear the options
     sass_clear_options(ctx);
@@ -665,16 +740,20 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, is_indented_syntax_src);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_C_Function_List, c_functions);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_C_Import_Callback, importer);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, output_path);
-  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, image_path);
+  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, plugin_path);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, include_path);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_file);
+  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_root);
 
   // Create getter and setters for context
   IMPLEMENT_SASS_CONTEXT_GETTER(int, error_status);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_json);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_message);
+  IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_text);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_file);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_line);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_column);
@@ -685,6 +764,7 @@ extern "C" {
   // Take ownership of memory (value on context is set to 0)
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_json);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_message);
+  IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_text);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_file);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, output_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);
@@ -695,7 +775,7 @@ extern "C" {
 
     struct string_list* include_path = (struct string_list*) calloc(1, sizeof(struct string_list));
     if (include_path == 0) return;
-    include_path->string = strdup(path);
+    include_path->string = path ? sass_strdup(path) : 0;
     struct string_list* last = options->include_paths;
     if (!options->include_paths) {
       options->include_paths = include_path;
@@ -706,4 +786,23 @@ extern "C" {
     }
 
   }
+
+  // Push function for plugin paths (no manipulation support for now)
+  void ADDCALL sass_option_push_plugin_path(struct Sass_Options* options, const char* path)
+  {
+
+    struct string_list* plugin_path = (struct string_list*) calloc(1, sizeof(struct string_list));
+    if (plugin_path == 0) return;
+    plugin_path->string = path ? sass_strdup(path) : 0;
+    struct string_list* last = options->plugin_paths;
+    if (!options->plugin_paths) {
+      options->plugin_paths = plugin_path;
+    } else {
+      while (last->next)
+        last = last->next;
+      last->next = plugin_path;
+    }
+
+  }
+
 }