sassc 2.2.1 → 2.4.0

data/ext/libsass/src/sass2scss.cpp

@@ -467,7 +467,7 @@ namespace Sass
 		// right trim input
 		sass = rtrim(sass);
 
-		// get postion of first meaningfull character in string
+		// get position of first meaningfull character in string
 		size_t pos_left = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE);
 
 		// special case for final run
@@ -557,7 +557,7 @@ namespace Sass
 				// default to a selector
 				// change back if property found
 				converter.selector = true;
-				// get postion of first whitespace char
+				// get position of first whitespace char
 				size_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);
 				// assertion check for valid result
 				if (pos_wspace != std::string::npos)
@@ -580,7 +580,7 @@ namespace Sass
 							// assertion for valid result
 							if (pos_colon != std::string::npos)
 							{
-								// ... after the first word (skip begining colons)
+								// ... after the first word (skip beginning colons)
 								pos_colon = sass.find_first_of(":", pos_colon);
 								// it is a selector if there was no colon found
 								converter.selector = pos_colon == std::string::npos;
@@ -758,7 +758,7 @@ namespace Sass
 				scss += flush(sass, converter);
 			}
 
-			// get postion of last meaningfull char
+			// get position of last meaningfull char
 			size_t pos_right = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);
 
 			// check for invalid result

data/ext/libsass/src/sass_context.cpp

@@ -1,44 +1,49 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
-#include <cstring>
-#include <stdexcept>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "sass.h"
 #include "ast.hpp"
-#include "file.hpp"
-#include "json.hpp"
-#include "util.hpp"
-#include "context.hpp"
-#include "sass_context.hpp"
+
 #include "sass_functions.hpp"
-#include "ast_fwd_decl.hpp"
-#include "error_handling.hpp"
+#include "json.hpp"
 
 #define LFEED "\n"
 
 // C++ helper
 namespace Sass {
-  // see sass_copy_c_string(std::string str)
-  static inline JsonNode* json_mkstream(const std::stringstream& stream)
+  // see sass_copy_c_string(sass::string str)
+  static inline JsonNode* json_mkstream(const sass::ostream& stream)
   {
     // hold on to string on stack!
-    std::string str(stream.str());
+    sass::string str(stream.str());
     return json_mkstring(str.c_str());
   }
 
+  static void handle_string_error(Sass_Context* c_ctx, const sass::string& msg, int severety)
+  {
+    sass::ostream msg_stream;
+    JsonNode* json_err = json_mkobject();
+    msg_stream << "Internal Error: " << msg << std::endl;
+    json_append_member(json_err, "status", json_mknumber(severety));
+    json_append_member(json_err, "message", json_mkstring(msg.c_str()));
+    json_append_member(json_err, "formatted", json_mkstream(msg_stream));
+    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(msg.c_str());
+    c_ctx->error_status = severety;
+    c_ctx->output_string = 0;
+    c_ctx->source_map_string = 0;
+    json_delete(json_err);
+  }
+
   static int handle_error(Sass_Context* c_ctx) {
     try {
       throw;
     }
     catch (Exception::Base& e) {
-      std::stringstream msg_stream;
-      std::string cwd(Sass::File::get_cwd());
-      std::string msg_prefix(e.errtype());
+      sass::ostream msg_stream;
+      sass::string cwd(Sass::File::get_cwd());
+      sass::string msg_prefix(e.errtype());
       bool got_newline = false;
       msg_stream << msg_prefix << ": ";
       const char* msg = e.what();
@@ -50,7 +55,7 @@ namespace Sass {
           got_newline = true;
         }
         else if (got_newline) {
-          msg_stream << std::string(msg_prefix.size() + 2, ' ');
+          msg_stream << sass::string(msg_prefix.size() + 2, ' ');
           got_newline = false;
         }
         msg_stream << *msg;
@@ -60,24 +65,25 @@ namespace Sass {
 
       if (e.traces.empty()) {
         // we normally should have some traces, still here as a fallback
-        std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
-        msg_stream << std::string(msg_prefix.size() + 2, ' ');
-        msg_stream << " on line " << e.pstate.line + 1 << " of " << rel_path << "\n";
+        sass::string rel_path(Sass::File::abs2rel(e.pstate.getPath(), cwd, cwd));
+        msg_stream << sass::string(msg_prefix.size() + 2, ' ');
+        msg_stream << " on line " << e.pstate.getLine() << " of " << rel_path << "\n";
       }
       else {
-        std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
+        sass::string rel_path(Sass::File::abs2rel(e.pstate.getPath(), cwd, cwd));
         msg_stream << traces_to_string(e.traces, "        ");
       }
 
       // now create the code trace (ToDo: maybe have util functions?)
-      if (e.pstate.line != std::string::npos &&
-          e.pstate.column != std::string::npos &&
-          e.pstate.src != nullptr) {
-        size_t lines = e.pstate.line;
+      if (e.pstate.position.line != sass::string::npos &&
+          e.pstate.position.column != sass::string::npos &&
+          e.pstate.source != nullptr) {
+        Offset offset(e.pstate.position);
+        size_t lines = offset.line;
         // scan through src until target line
         // move line_beg pointer to line start
         const char* line_beg;
-        for (line_beg = e.pstate.src; *line_beg != '\0'; ++line_beg) {
+        for (line_beg = e.pstate.getRawData(); *line_beg != '\0'; ++line_beg) {
           if (lines == 0) break;
           if (*line_beg == '\n') --lines;
         }
@@ -91,12 +97,12 @@ namespace Sass {
         size_t move_in = 0; size_t shorten = 0;
         size_t left_chars = 42; size_t max_chars = 76;
         // reported excerpt should not exceed `max_chars` chars
-        if (e.pstate.column > line_len) left_chars = e.pstate.column;
-        if (e.pstate.column > left_chars) move_in = e.pstate.column - left_chars;
+        if (offset.column > line_len) left_chars = offset.column;
+        if (offset.column > left_chars) move_in = offset.column - left_chars;
         if (line_len > max_chars + move_in) shorten = line_len - move_in - max_chars;
         utf8::advance(line_beg, move_in, line_end);
         utf8::retreat(line_end, shorten, line_beg);
-        std::string sanitized; std::string marker(e.pstate.column - move_in, '-');
+        sass::string sanitized; sass::string marker(offset.column - move_in, '-');
         utf8::replace_invalid(line_beg, line_end, std::back_inserter(sanitized));
         msg_stream << ">> " << sanitized << "\n";
         msg_stream << "   " << marker << "^\n";
@@ -104,102 +110,40 @@ namespace Sass {
 
       JsonNode* json_err = json_mkobject();
       json_append_member(json_err, "status", json_mknumber(1));
-      json_append_member(json_err, "file", json_mkstring(e.pstate.path));
-      json_append_member(json_err, "line", json_mknumber((double)(e.pstate.line + 1)));
-      json_append_member(json_err, "column", json_mknumber((double)(e.pstate.column + 1)));
+      json_append_member(json_err, "file", json_mkstring(e.pstate.getPath()));
+      json_append_member(json_err, "line", json_mknumber((double)(e.pstate.getLine())));
+      json_append_member(json_err, "column", json_mknumber((double)(e.pstate.getColumn())));
       json_append_member(json_err, "message", json_mkstring(e.what()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
+      catch (...) {} // silently ignore this error?
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 1;
-      c_ctx->error_file = sass_copy_c_string(e.pstate.path);
-      c_ctx->error_line = e.pstate.line + 1;
-      c_ctx->error_column = e.pstate.column + 1;
-      c_ctx->error_src = e.pstate.src;
+      c_ctx->error_file = sass_copy_c_string(e.pstate.getPath());
+      c_ctx->error_line = e.pstate.getLine();
+      c_ctx->error_column = e.pstate.getColumn();
+      c_ctx->error_src = sass_copy_c_string(e.pstate.getRawData());
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
     catch (std::bad_alloc& ba) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      msg_stream << "Unable to allocate memory: " << ba.what() << std::endl;
-      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 (...) {}
-      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;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      sass::ostream msg_stream;
+      msg_stream << "Unable to allocate memory: " << ba.what();
+      handle_string_error(c_ctx, msg_stream.str(), 2);
     }
     catch (std::exception& e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      msg_stream << "Internal Error: " << e.what() << std::endl;
-      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 (...) {}
-      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;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, e.what(), 3);
     }
-    catch (std::string& e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      msg_stream << "Internal Error: " << e << std::endl;
-      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 (...) {}
-      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;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+    catch (sass::string& e) {
+      handle_string_error(c_ctx, e, 4);
     }
     catch (const char* e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      msg_stream << "Internal Error: " << e << std::endl;
-      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 (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string(e);
-      c_ctx->error_status = 4;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, e, 4);
     }
     catch (...) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      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 (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string("unknown");
-      c_ctx->error_status = 5;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, "unknown", 5);
     }
     return c_ctx->error_status;
   }
@@ -226,8 +170,8 @@ namespace Sass {
     try {
 
       // get input/output path from options
-      std::string input_path = safe_str(c_ctx->input_path);
-      std::string output_path = safe_str(c_ctx->output_path);
+      sass::string input_path = safe_str(c_ctx->input_path);
+      sass::string output_path = safe_str(c_ctx->output_path);
 
       // maybe skip some entries of included files
       // we do not include stdin for data contexts
@@ -334,10 +278,10 @@ extern "C" {
       c_ctx->error_message = 0;
       c_ctx->error_status = 0;
       // reset error position
-      c_ctx->error_src = 0;
       c_ctx->error_file = 0;
-      c_ctx->error_line = std::string::npos;
-      c_ctx->error_column = std::string::npos;
+      c_ctx->error_src = 0;
+      c_ctx->error_line = sass::string::npos;
+      c_ctx->error_column = sass::string::npos;
 
       // allocate a new compiler instance
       void* ctxmem = calloc(1, sizeof(struct Sass_Compiler));
@@ -399,7 +343,9 @@ extern "C" {
 
   Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)
   {
-    SharedObj::setTaint(true); // needed for static colors
+    #ifdef DEBUG_SHARED_PTR
+    SharedObj::setTaint(true);
+    #endif
     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;
@@ -416,6 +362,9 @@ extern "C" {
 
   Sass_Data_Context* ADDCALL sass_make_data_context(char* source_string)
   {
+    #ifdef DEBUG_SHARED_PTR
+    SharedObj::setTaint(true);
+    #endif
     struct Sass_Data_Context* ctx = (struct Sass_Data_Context*) calloc(1, sizeof(struct Sass_Data_Context));
     if (ctx == 0) { std::cerr << "Error allocating memory for data context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_DATA;
@@ -451,7 +400,7 @@ extern "C" {
       return data_ctx->error_status;
     try {
       if (data_ctx->source_string == 0) { throw(std::runtime_error("Data context has no source string")); }
-      // empty source string is a valid case, even if not really usefull (different than with file context)
+      // empty source string is a valid case, even if not really useful (different than with file context)
       // if (*data_ctx->source_string == 0) { throw(std::runtime_error("Data context has empty source string")); }
     }
     catch (...) { return handle_errors(data_ctx) | 1; }
@@ -533,7 +482,7 @@ extern "C" {
   static void sass_clear_options (struct Sass_Options* options)
   {
     if (options == 0) return;
-    // Deallocate custom functions, headers and importes
+    // Deallocate custom functions, headers and imports
     sass_delete_function_list(options->c_functions);
     sass_delete_importer_list(options->c_importers);
     sass_delete_importer_list(options->c_headers);
@@ -594,6 +543,7 @@ extern "C" {
     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->error_src)         free(ctx->error_src);
     free_string_array(ctx->included_files);
     // play safe and reset properties
     ctx->output_string = 0;
@@ -602,6 +552,7 @@ extern "C" {
     ctx->error_text = 0;
     ctx->error_json = 0;
     ctx->error_file = 0;
+    ctx->error_src = 0;
     ctx->included_files = 0;
     // debug leaked memory
     #ifdef DEBUG_SHARED_PTR
@@ -656,7 +607,7 @@ extern "C" {
   void ADDCALL sass_file_context_set_options (struct Sass_File_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }
   void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }
 
-  // Getters for Sass_Compiler options (get conected sass context)
+  // Getters for Sass_Compiler options (get connected sass context)
   enum Sass_Compiler_State ADDCALL sass_compiler_get_state(struct Sass_Compiler* compiler) { return compiler->state; }
   struct Sass_Context* ADDCALL sass_compiler_get_context(struct Sass_Compiler* compiler) { return compiler->c_ctx; }
   struct Sass_Options* ADDCALL sass_compiler_get_options(struct Sass_Compiler* compiler) { return compiler->c_ctx; }
@@ -700,9 +651,9 @@ extern "C" {
   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(const char*, error_src);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_line);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_column);
-  IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_src);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, output_string);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, source_map_string);
   IMPLEMENT_SASS_CONTEXT_GETTER(char**, included_files);
@@ -712,6 +663,7 @@ extern "C" {
   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*, error_src);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, output_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char**, included_files);
@@ -751,6 +703,23 @@ extern "C" {
     return cur->string;
   }
 
+  // Push function for plugin paths (no manipulation support for now)
+  size_t ADDCALL sass_option_get_plugin_path_size(struct Sass_Options* options)
+  {
+    size_t len = 0;
+    struct string_list* cur = options->plugin_paths;
+    while (cur) { len++; cur = cur->next; }
+    return len;
+  }
+
+  // Push function for plugin paths (no manipulation support for now)
+  const char* ADDCALL sass_option_get_plugin_path(struct Sass_Options* options, size_t i)
+  {
+    struct string_list* cur = options->plugin_paths;
+    while (i) { i--; cur = cur->next; }
+    return cur->string;
+  }
+
   // Push function for plugin paths (no manipulation support for now)
   void ADDCALL sass_option_push_plugin_path(struct Sass_Options* options, const char* path)
   {

data/ext/libsass/src/sass_context.hpp

@@ -90,7 +90,7 @@ struct Sass_Context : Sass_Options
   char* error_file;
   size_t error_line;
   size_t error_column;
-  const char* error_src;
+  char* error_src;
 
   // report imported files
   char** included_files;
@@ -126,4 +126,4 @@ struct Sass_Compiler {
   Sass::Block_Obj root;
 };
 
-#endif
+#endif

data/ext/libsass/src/sass_functions.cpp

@@ -101,7 +101,7 @@ extern "C" {
   }
 
   // Creator for a single import entry returned by the custom importer inside the list
-  // We take ownership of the memory for source and srcmap (freed when context is destroyd)
+  // We take ownership of the memory for source and srcmap (freed when context is destroyed)
   Sass_Import_Entry ADDCALL sass_make_import(const char* imp_path, const char* abs_path, char* source, char* srcmap)
   {
     Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));

data/ext/libsass/src/sass_values.cpp

@@ -6,7 +6,6 @@
 #include <cstring>
 #include "util.hpp"
 #include "eval.hpp"
-#include "values.hpp"
 #include "operators.hpp"
 #include "sass/values.h"
 #include "sass_values.hpp"
@@ -284,21 +283,21 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* v, bool compressed, int precision)
   {
-    Value_Obj val = sass_value_to_ast_node(v);
+    ValueObj val = sass_value_to_ast_node(v);
     Sass_Inspect_Options options(compressed ? COMPRESSED : NESTED, precision);
-    std::string str(val->to_string(options));
+    sass::string str(val->to_string(options));
     return sass_make_qstring(str.c_str());
   }
 
   union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b)
   {
 
-    Sass::Value_Obj rv;
+    Sass::ValueObj rv;
 
     try {
 
-      Value_Obj lhs = sass_value_to_ast_node(a);
-      Value_Obj rhs = sass_value_to_ast_node(b);
+      ValueObj lhs = sass_value_to_ast_node(a);
+      ValueObj rhs = sass_value_to_ast_node(b);
       struct Sass_Inspect_Options options(NESTED, 5);
 
       // see if it's a relational expression
@@ -341,12 +340,10 @@ extern "C" {
         rv = Operators::op_colors(op, *l_c, *r_c, options, l_c->pstate());
       }
       else /* convert other stuff to string and apply operation */ {
-        Value* l_v = Cast<Value>(lhs);
-        Value* r_v = Cast<Value>(rhs);
-        rv = Operators::op_strings(op, *l_v, *r_v, options, l_v->pstate());
+        rv = Operators::op_strings(op, *lhs, *rhs, options, lhs->pstate());
       }
 
-      // ToDo: maybe we should should return null value?
+      // ToDo: maybe we should return null value?
       if (!rv) return sass_make_error("invalid return value");
 
       // convert result back to ast node
@@ -357,7 +354,7 @@ extern "C" {
     catch (Exception::InvalidSass& e) { return sass_make_error(e.what()); }
     catch (std::bad_alloc&) { return sass_make_error("memory exhausted"); }
     catch (std::exception& e) { return sass_make_error(e.what()); }
-    catch (std::string& e) { return sass_make_error(e.c_str()); }
+    catch (sass::string& e) { return sass_make_error(e.c_str()); }
     catch (const char* e) { return sass_make_error(e); }
     catch (...) { return sass_make_error("unknown"); }
   }

data/ext/libsass/src/settings.hpp

@@ -0,0 +1,19 @@
+#ifndef SASS_SETTINGS_H
+#define SASS_SETTINGS_H
+
+// Global compile time settings should go here
+
+// When enabled we use our custom memory pool allocator
+// With intense workloads this can double the performance
+// Max memory usage mostly only grows by a slight amount
+// #define SASS_CUSTOM_ALLOCATOR
+
+// How many buckets should we have for the free-list
+// Determines when allocations go directly to malloc/free
+// For maximum size of managed items multiply by alignment
+#define SassAllocatorBuckets 512
+
+// The size of the memory pool arenas in bytes.
+#define SassAllocatorArenaSize (1024 * 256)
+
+#endif

data/ext/libsass/src/source.cpp

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <string.h>
+#include "source.hpp"
+#include "utf8/checked.h"
+#include "position.hpp"
+
+namespace Sass {
+
+  SourceData::SourceData()
+    : SharedObj()
+  {
+  }
+
+  SourceFile::SourceFile(
+    const char* path,
+    const char* data,
+    size_t srcid) :
+    SourceData(),
+    path(sass_copy_c_string(path)),
+    data(sass_copy_c_string(data)),
+    length(0),
+    srcid(srcid)
+  {
+    length = strlen(data);
+  }
+
+  SourceFile::~SourceFile() {
+    sass_free_memory(path);
+    sass_free_memory(data);
+  }
+
+  const char* SourceFile::end() const
+  {
+    return data + length;
+  }
+
+  const char* SourceFile::begin() const
+  {
+    return data;
+  }
+
+  const char* SourceFile::getRawData() const
+  {
+    return data;
+  }
+
+  SourceSpan SourceFile::getSourceSpan()
+  {
+    return SourceSpan(this);
+  }
+
+  ItplFile::ItplFile(const char* data, const SourceSpan& pstate) :
+    SourceFile(pstate.getPath(),
+      data, pstate.getSrcId()),
+    pstate(pstate)
+  {}
+
+  const char* ItplFile::getRawData() const
+  {
+    return pstate.getRawData();
+  }
+
+  SourceSpan ItplFile::getSourceSpan()
+  {
+    return SourceSpan(pstate);
+  }
+
+}
+

data/ext/libsass/src/source.hpp

@@ -0,0 +1,95 @@
+#ifndef SASS_SOURCE_H
+#define SASS_SOURCE_H
+
+#include "sass.hpp"
+#include "memory.hpp"
+#include "position.hpp"
+#include "source_data.hpp"
+
+namespace Sass {
+
+  class SourceFile :
+    public SourceData {
+  protected:
+    char* path;
+    char* data;
+    size_t length;
+    size_t srcid;
+  public:
+
+    SourceFile(
+      const char* path,
+      const char* data,
+      size_t srcid);
+
+    ~SourceFile();
+
+    const char* end() const override final;
+    const char* begin() const override final;
+    virtual const char* getRawData() const override;
+    virtual SourceSpan getSourceSpan() override;
+
+    size_t size() const override final {
+      return length;
+    }
+
+    virtual const char* getPath() const override {
+      return path;
+    }
+
+    virtual size_t getSrcId() const override {
+      return srcid;
+    }
+
+  };
+
+  class SynthFile :
+    public SourceData {
+  protected:
+    const char* path;
+  public:
+
+    SynthFile(
+      const char* path) :
+      path(path)
+    {}
+
+    ~SynthFile() {}
+
+    const char* end() const override final { return nullptr; }
+    const char* begin() const override final { return nullptr; };
+    virtual const char* getRawData() const override { return nullptr; };
+    virtual SourceSpan getSourceSpan() override { return SourceSpan(path); };
+
+    size_t size() const override final {
+      return 0;
+    }
+
+    virtual const char* getPath() const override {
+      return path;
+    }
+
+    virtual size_t getSrcId() const override {
+      return std::string::npos;
+    }
+
+  };
+  
+
+  class ItplFile :
+    public SourceFile {
+  private:
+    SourceSpan pstate;
+  public:
+
+    ItplFile(const char* data,
+      const SourceSpan& pstate);
+
+    // Offset getPosition() const override final;
+    const char* getRawData() const override final;
+    SourceSpan getSourceSpan() override final;
+  };
+
+}
+
+#endif