sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/{sass_context.cpp → src/sass_context.cpp}

@@ -1,24 +1,20 @@
-#ifdef _WIN32
-#include <io.h>
-#define LFEED "\n"
-#else
-#include <unistd.h>
-#define LFEED "\n"
-#endif
-
 #include <cstring>
 #include <stdexcept>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "sass.h"
 #include "file.hpp"
 #include "json.hpp"
 #include "util.hpp"
 #include "context.hpp"
-#include "sass_values.h"
-#include "sass_context.h"
 #include "ast_fwd_decl.hpp"
 #include "error_handling.hpp"
 
+#define LFEED "\n"
+
 extern "C" {
-  using namespace std;
   using namespace Sass;
 
   // Input behaviours
@@ -183,73 +179,35 @@ extern "C" {
     type sass_context_take_##option (struct Sass_Context* ctx) \
     { type foo = ctx->option; ctx->option = 0; return foo; }
 
-  // helper for safe access to c_ctx
-  static const char* safe_str (const char* str) {
-    return str == NULL ? "" : str;
-  }
-
-  static void copy_strings(const std::vector<std::string>& strings, char*** array) {
-    int num = static_cast<int>(strings.size());
-    char** arr = (char**) malloc(sizeof(char*) * (num + 1));
-    if (arr == 0) throw(bad_alloc());
-
-    for(int i = 0; i < num; i++) {
-      arr[i] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
-      if (arr[i] == 0) throw(bad_alloc());
-      std::copy(strings[i].begin(), strings[i].end(), arr[i]);
-      arr[i][strings[i].size()] = '\0';
-    }
-
-    arr[num] = 0;
-    *array = arr;
-  }
-
-  static void free_string_array(char ** arr) {
-    if(!arr)
-        return;
-
-    char **it = arr;
-    while (it && (*it)) {
-      free(*it);
-      ++it;
-    }
-
-    free(arr);
-  }
-
   static int handle_errors(Sass_Context* c_ctx) {
     try {
      throw;
     }
-    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.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()));
-      string rel_path(Sass::File::resolve_relative_path(e.pstate.path, cwd, cwd));
+    catch (Error_Invalid& e) {
+      std::stringstream msg_stream;
+      std::string cwd(Sass::File::get_cwd());
+      std::string rel_path(Sass::File::resolve_relative_path(e.pstate.path, cwd, cwd));
 
-      string msg_prefix("Error: ");
+      std::string msg_prefix("Error: ");
       bool got_newline = false;
       msg_stream << msg_prefix;
       for (char chr : e.message) {
-        if (chr == '\n') {
+        if (chr == '\r') {
+          got_newline = true;
+        } else if (chr == '\n') {
           got_newline = true;
         } else if (got_newline) {
-          msg_stream << string(msg_prefix.size(), ' ');
+          msg_stream << std::string(msg_prefix.size(), ' ');
           got_newline = false;
         }
         msg_stream << chr;
       }
       if (!got_newline) msg_stream << "\n";
-      msg_stream << string(msg_prefix.size(), ' ');
+      msg_stream << std::string(msg_prefix.size(), ' ');
       msg_stream << " on line " << e.pstate.line+1 << " of " << rel_path << "\n";
 
       // now create the code trace (ToDo: maybe have util functions?)
-      if (e.pstate.line != string::npos && e.pstate.column != string::npos) {
+      if (e.pstate.line != std::string::npos && e.pstate.column != std::string::npos) {
         size_t line = e.pstate.line;
         const char* line_beg = e.pstate.src;
         while (line_beg && *line_beg && line) {
@@ -266,15 +224,23 @@ extern "C" {
         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;
-        msg_stream << ">> " << string(line_beg + move_in, line_end - shorten) << "\n";
-        msg_stream << "   " << string(e.pstate.column - move_in, '-') << "^\n";
+        msg_stream << ">> " << std::string(line_beg + move_in, line_end - shorten) << "\n";
+        msg_stream << "   " << std::string(e.pstate.column - move_in, '-') << "^\n";
       }
 
+      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, "message", json_mkstring(e.message.c_str()));
+      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
+
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
-      c_ctx->error_text = strdup(e.message.c_str());
+      c_ctx->error_text = sass_strdup(e.message.c_str());
       c_ctx->error_status = 1;
-      c_ctx->error_file = sass_strdup(e.pstate.path.c_str());
+      c_ctx->error_file = sass_strdup(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;
@@ -282,57 +248,71 @@ extern "C" {
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
-    catch(bad_alloc& ba) {
-      stringstream msg_stream;
+    catch (std::bad_alloc& ba) {
+      std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Unable to allocate memory: " << ba.what() << endl;
+      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()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
-      c_ctx->error_text = strdup(ba.what());
+      c_ctx->error_text = sass_strdup(ba.what());
       c_ctx->error_status = 2;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
     catch (std::exception& e) {
-      stringstream msg_stream;
+      std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Error: " << e.what() << endl;
+      msg_stream << "Error: " << e.what() << std::endl;
       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 = sass_strdup(msg_stream.str().c_str());
-      c_ctx->error_text = strdup(e.what());
+      c_ctx->error_text = sass_strdup(e.what());
       c_ctx->error_status = 3;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
-    catch (string& e) {
-      stringstream msg_stream;
+    catch (std::string& e) {
+      std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Error: " << e << endl;
+      msg_stream << "Error: " << e << std::endl;
       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 = sass_strdup(msg_stream.str().c_str());
-      c_ctx->error_text = strdup(e.c_str());
+      c_ctx->error_text = sass_strdup(e.c_str());
+      c_ctx->error_status = 4;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+      json_delete(json_err);
+    }
+    catch (const char* e) {
+      std::stringstream msg_stream;
+      JsonNode* json_err = json_mkobject();
+      msg_stream << "Error: " << e << std::endl;
+      json_append_member(json_err, "status", json_mknumber(4));
+      json_append_member(json_err, "message", json_mkstring(e));
+      c_ctx->error_json = json_stringify(json_err, "  ");;
+      c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
+      c_ctx->error_text = sass_strdup(e);
       c_ctx->error_status = 4;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
     catch (...) {
-      stringstream msg_stream;
+      std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Unknown error occurred" << endl;
+      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"));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
-      c_ctx->error_text = strdup("unknown");
+      c_ctx->error_text = sass_strdup("unknown");
       c_ctx->error_status = 5;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
@@ -347,8 +327,8 @@ extern "C" {
     try {
 
       // get input/output path from options
-      string input_path = safe_str(c_ctx->input_path);
-      string output_path = safe_str(c_ctx->output_path);
+      std::string input_path = safe_str(c_ctx->input_path);
+      std::string output_path = safe_str(c_ctx->output_path);
       // maybe we can extract an output path from input path
       if (output_path == "" && input_path != "") {
         int lastindex = static_cast<int>(input_path.find_last_of("."));
@@ -361,7 +341,7 @@ extern "C" {
       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(inc_size + 1, sizeof(char*));
-      if (include_paths == 0) throw(bad_alloc());
+      if (include_paths == 0) throw(std::bad_alloc());
       // reset iterator
       inc = c_ctx->include_paths;
       // copy over the paths
@@ -376,7 +356,7 @@ extern "C" {
       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());
+      if (plugin_paths == 0) throw(std::bad_alloc());
       // reset iterator
       imp = c_ctx->plugin_paths;
       // copy over the paths
@@ -402,8 +382,8 @@ extern "C" {
              .plugin_paths_c_str(c_ctx->plugin_path)
              // .include_paths_array(include_paths)
              // .plugin_paths_array(plugin_paths)
-             .include_paths(vector<string>())
-             .plugin_paths(vector<string>())
+             .include_paths(std::vector<std::string>())
+             .plugin_paths(std::vector<std::string>())
              .precision(c_ctx->precision)
              .linefeed(c_ctx->linefeed)
              .indent(c_ctx->indent);
@@ -449,8 +429,8 @@ extern "C" {
       // reset error position
       c_ctx->error_src = 0;
       c_ctx->error_file = 0;
-      c_ctx->error_line = string::npos;
-      c_ctx->error_column = string::npos;
+      c_ctx->error_line = std::string::npos;
+      c_ctx->error_column = std::string::npos;
 
       // allocate a new compiler instance
       Sass_Compiler* compiler = (struct Sass_Compiler*) calloc(1, sizeof(struct Sass_Compiler));
@@ -488,29 +468,34 @@ extern "C" {
     try {
 
       // get input/output path from options
-      string input_path = safe_str(c_ctx->input_path);
-      string output_path = safe_str(c_ctx->output_path);
+      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
-      size_t skip = 0;
+      bool skip = false;
 
       // dispatch to the correct render function
       if (c_ctx->type == SASS_CONTEXT_FILE) {
         root = cpp_ctx->parse_file();
       } else if (c_ctx->type == SASS_CONTEXT_DATA) {
         root = cpp_ctx->parse_string();
-        skip = 1; // skip first entry of includes
+        skip = true; // skip first entry of includes
       }
 
-      // skip all prefixed files?
-      skip += cpp_ctx->head_imports;
+      // 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)
-      if (root) copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files);
+      if (root)
+        if (copy_strings(cpp_ctx->get_included_files(skip, headers), &c_ctx->included_files) == NULL)
+          throw(std::bad_alloc());
 
       // return parsed block
       return root;
@@ -554,7 +539,7 @@ extern "C" {
   Sass_Options* ADDCALL sass_make_options (void)
   {
     struct Sass_Options* options = (struct Sass_Options*) calloc(1, sizeof(struct Sass_Options));
-    if (options == 0) { cerr << "Error allocating memory for options" << endl; return 0; }
+    if (options == 0) { std::cerr << "Error allocating memory for options" << std::endl; return 0; }
     init_options(options);
     return options;
   }
@@ -562,12 +547,12 @@ extern "C" {
   Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)
   {
     struct Sass_File_Context* ctx = (struct Sass_File_Context*) calloc(1, sizeof(struct Sass_File_Context));
-    if (ctx == 0) { cerr << "Error allocating memory for file context" << endl; return 0; }
+    if (ctx == 0) { std::cerr << "Error allocating memory for file context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_FILE;
     init_options(ctx);
     try {
-      if (input_path == 0) { throw(runtime_error("File context created without an input path")); }
-      if (*input_path == 0) { throw(runtime_error("File context created with empty input path")); }
+      if (input_path == 0) { throw(std::runtime_error("File context created without an input path")); }
+      if (*input_path == 0) { throw(std::runtime_error("File context created with empty input path")); }
       sass_option_set_input_path(ctx, input_path);
     } catch (...) {
       handle_errors(ctx);
@@ -578,12 +563,12 @@ extern "C" {
   Sass_Data_Context* ADDCALL sass_make_data_context(char* source_string)
   {
     struct Sass_Data_Context* ctx = (struct Sass_Data_Context*) calloc(1, sizeof(struct Sass_Data_Context));
-    if (ctx == 0) { cerr << "Error allocating memory for data context" << endl; return 0; }
+    if (ctx == 0) { std::cerr << "Error allocating memory for data context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_DATA;
     init_options(ctx);
     try {
-      if (source_string == 0) { throw(runtime_error("Data context created without a source string")); }
-      if (*source_string == 0) { throw(runtime_error("Data context created with empty source string")); }
+      if (source_string == 0) { throw(std::runtime_error("Data context created without a source string")); }
+      if (*source_string == 0) { throw(std::runtime_error("Data context created with empty source string")); }
       ctx->source_string = source_string;
     } catch (...) {
       handle_errors(ctx);
@@ -604,6 +589,7 @@ extern "C" {
     if (c_ctx == 0) return 0;
     Context::Data cpp_opt = Context::Data();
     cpp_opt.source_c_str(c_ctx->source_string);
+    c_ctx->source_string = 0; // passed away
     return sass_prepare_context(c_ctx, cpp_opt);
   }
 
@@ -615,9 +601,10 @@ extern "C" {
       return c_ctx->error_status;
     Context::Data cpp_opt = Context::Data();
     try {
-      if (data_ctx->source_string == 0) { throw(runtime_error("Data context has no source string")); }
-      if (*data_ctx->source_string == 0) { throw(runtime_error("Data context has empty source string")); }
+      if (data_ctx->source_string == 0) { throw(std::runtime_error("Data context has no source string")); }
+      if (*data_ctx->source_string == 0) { throw(std::runtime_error("Data context has empty source string")); }
       cpp_opt.source_c_str(data_ctx->source_string);
+      data_ctx->source_string = 0; // passed away
     }
     catch (...) { return handle_errors(c_ctx) | 1; }
     return sass_compile_context(c_ctx, cpp_opt);
@@ -631,8 +618,8 @@ extern "C" {
       return c_ctx->error_status;
     Context::Data cpp_opt = Context::Data();
     try {
-      if (file_ctx->input_path == 0) { throw(runtime_error("File context has no input path")); }
-      if (*file_ctx->input_path == 0) { throw(runtime_error("File context has empty input path")); }
+      if (file_ctx->input_path == 0) { throw(std::runtime_error("File context has no input path")); }
+      if (*file_ctx->input_path == 0) { throw(std::runtime_error("File context has empty input path")); }
       cpp_opt.entry_point(file_ctx->input_path);
     }
     catch (...) { return handle_errors(c_ctx) | 1; }
@@ -665,8 +652,8 @@ extern "C" {
     if (compiler->c_ctx->error_status)
       return compiler->c_ctx->error_status;
     compiler->state = SASS_COMPILER_EXECUTED;
-    Context* cpp_ctx = (Context*) compiler->cpp_ctx;
-    Block* root = (Block*) compiler->root;
+    Context* cpp_ctx = compiler->cpp_ctx;
+    Block* root = compiler->root;
     // compile the parsed root block
     try { compiler->c_ctx->output_string = cpp_ctx->compile_block(root); }
     // pass catched errors to generic error handler
@@ -756,6 +743,7 @@ extern "C" {
     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->plugin_path)       free(ctx->plugin_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);
@@ -779,16 +767,30 @@ extern "C" {
 
   void ADDCALL sass_delete_compiler (struct Sass_Compiler* compiler)
   {
-    if (compiler == 0) return;
-    Context* cpp_ctx = (Context*) compiler->cpp_ctx;
+    if (compiler == 0) {
+      return;
+    }
+    Context* cpp_ctx = compiler->cpp_ctx;
+    if (cpp_ctx) delete(cpp_ctx);
     compiler->cpp_ctx = 0;
-    delete cpp_ctx;
     free(compiler);
   }
 
-  // Deallocate all associated memory with contexts
-  void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx) { sass_clear_context(ctx); free(ctx); }
-  void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx) { sass_clear_context(ctx); free(ctx); }
+  // Deallocate all associated memory with file context
+  void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx)
+  {
+    // clear the context and free it
+    sass_clear_context(ctx); free(ctx);
+  }
+  // Deallocate all associated memory with data context
+  void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx)
+  {
+    // clean the source string if it was not passed
+    // we reset this member once we start parsing
+    if (ctx->source_string) free(ctx->source_string);
+    // clear the context and free it
+    sass_clear_context(ctx); free(ctx);
+  }
 
   // Getters for sass context from specific implementations
   struct Sass_Context* ADDCALL sass_file_context_get_context(struct Sass_File_Context* ctx) { return ctx; }

data/ext/libsass/{sass_functions.cpp → src/sass_functions.cpp}

@@ -1,16 +1,9 @@
-#ifdef _WIN32
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-
 #include <cstring>
 #include "util.hpp"
 #include "context.hpp"
-#include "sass_functions.h"
+#include "sass/functions.h"
 
 extern "C" {
-  using namespace std;
   using namespace Sass;
 
   // Struct to hold custom function callback
@@ -45,8 +38,8 @@ extern "C" {
 
   // External import entry
   struct Sass_Import {
-    char* path;
-    char* base;
+    char* imp_path; // path as found in the import statement
+    char *abs_path; // path after importer has resolved it
     char* source;
     char* srcmap;
     // error handling
@@ -99,12 +92,12 @@ 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)
-  Sass_Import_Entry ADDCALL sass_make_import(const char* path, const char* base, char* source, char* srcmap)
+  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));
     if (v == 0) return 0;
-    v->path = path ? sass_strdup(path) : 0;
-    v->base = base ? sass_strdup(base) : 0;
+    v->imp_path = imp_path ? sass_strdup(imp_path) : 0;
+    v->abs_path = abs_path ? sass_strdup(abs_path) : 0;
     v->source = source;
     v->srcmap = srcmap;
     v->error = 0;
@@ -124,7 +117,7 @@ extern "C" {
   {
     if (import == 0) return 0;
     if (import->error) free(import->error);
-    import->error = error ? strdup(error) : 0;
+    import->error = error ? sass_strdup(error) : 0;
     import->line = line ? line : -1;
     import->column = col ? col : -1;
     return import;
@@ -149,8 +142,8 @@ extern "C" {
   // Just in case we have some stray import structs
   void ADDCALL sass_delete_import(Sass_Import_Entry import)
   {
-    free(import->path);
-    free(import->base);
+    free(import->imp_path);
+    free(import->abs_path);
     free(import->source);
     free(import->srcmap);
     free(import->error);
@@ -158,8 +151,8 @@ extern "C" {
   }
 
   // Getter for import entry
-  const char* ADDCALL sass_import_get_path(Sass_Import_Entry entry) { return entry->path; }
-  const char* ADDCALL sass_import_get_base(Sass_Import_Entry entry) { return entry->base; }
+  const char* ADDCALL sass_import_get_imp_path(Sass_Import_Entry entry) { return entry->imp_path; }
+  const char* ADDCALL sass_import_get_abs_path(Sass_Import_Entry entry) { return entry->abs_path; }
   const char* ADDCALL sass_import_get_source(Sass_Import_Entry entry) { return entry->source; }
   const char* ADDCALL sass_import_get_srcmap(Sass_Import_Entry entry) { return entry->srcmap; }