sassc 0.0.10 → 0.0.11

data/ext/libsass/sass.cpp

@@ -4,29 +4,39 @@
 #include <sstream>
 
 #include "sass.h"
+#include "file.hpp"
 #include "util.hpp"
 
 extern "C" {
   using namespace std;
+  using namespace Sass;
+  using namespace File;
 
   // caller must free the returned memory
-  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;
+  char* ADDCALL sass_string_quote (const char *str, const char quote_mark)
+  {
+    string quoted = quote(str, quote_mark);
+    return sass_strdup(quoted.c_str());
   }
 
   // caller must free the returned memory
-  char* ADDCALL sass_string_unquote (const char *str) {
-    string unquoted = Sass::unquote(str);
-    char *cstr = (char*) malloc(unquoted.length() + 1);
-    std::strcpy(cstr, unquoted.c_str());
-    return cstr;
+  char* ADDCALL sass_string_unquote (const char *str)
+  {
+    string unquoted = unquote(str);
+    return sass_strdup(unquoted.c_str());
+  }
+
+  // Make sure to free the returned value!
+  // Incs array has to be null terminated!
+  char* ADDCALL sass_resolve_file (const char* file, const char* paths[])
+  {
+    string resolved(find_file(file, paths));
+    return sass_strdup(resolved.c_str());
   }
 
   // Get compiled libsass version
-  const char* ADDCALL libsass_version(void) {
+  const char* ADDCALL libsass_version(void)
+  {
     return LIBSASS_VERSION;
   }
 

data/ext/libsass/sass.h

@@ -32,11 +32,8 @@
 
 #endif
 
-#ifndef LIBSASS_VERSION
-#define LIBSASS_VERSION "[NA]"
-#endif
-
 // include API headers
+#include "sass_version.h"
 #include "sass_values.h"
 #include "sass_functions.h"
 
@@ -55,8 +52,11 @@ enum Sass_Output_Style {
 };
 
 // Some convenient string helper function
-ADDAPI char* ADDCALL sass_string_quote (const char *str, const char quote_mark);
-ADDAPI char* ADDCALL sass_string_unquote (const char *str);
+ADDAPI char* ADDCALL sass_string_quote (const char* str, const char quote_mark);
+ADDAPI char* ADDCALL sass_string_unquote (const char* str);
+
+// Resolve a file via the given include paths in the include char* array
+ADDAPI char* ADDCALL sass_resolve_file (const char* path, const char* incs[]);
 
 // Get compiled libsass version
 ADDAPI const char* ADDCALL libsass_version(void);

data/ext/libsass/sass_context.cpp

@@ -14,6 +14,7 @@
 #include "context.hpp"
 #include "sass_values.h"
 #include "sass_context.h"
+#include "ast_fwd_decl.hpp"
 #include "error_handling.hpp"
 
 extern "C" {
@@ -99,10 +100,13 @@ extern "C" {
     char* source_map_root;
 
     // Custom functions that can be called from sccs code
-    Sass_C_Function_List c_functions;
+    Sass_Function_List c_functions;
 
-    // Callback to overload imports
-    Sass_C_Import_Callback importer;
+    // List of custom importers
+    Sass_Importer_List c_importers;
+
+    // List of custom headers
+    Sass_Importer_List c_headers;
 
   };
 
@@ -128,6 +132,7 @@ extern "C" {
     char* error_file;
     size_t error_line;
     size_t error_column;
+    const char* error_src;
 
     // report imported files
     char** included_files;
@@ -150,13 +155,6 @@ extern "C" {
 
   };
 
-  // Compiler states
-  enum Sass_Compiler_State {
-    SASS_COMPILER_CREATED,
-    SASS_COMPILER_PARSED,
-    SASS_COMPILER_EXECUTED
-  };
-
   // link c and cpp context
   struct Sass_Compiler {
     // progress status
@@ -164,9 +162,9 @@ extern "C" {
     // original c context
     Sass_Context* c_ctx;
     // Sass::Context
-    void* cpp_ctx;
+    Context* cpp_ctx;
     // Sass::Block
-    void* root;
+    Block* root;
   };
 
   static void copy_options(struct Sass_Options* to, struct Sass_Options* from) { *to = *from; }
@@ -190,19 +188,19 @@ extern "C" {
     return str == NULL ? "" : str;
   }
 
-  static void copy_strings(const std::vector<std::string>& strings, char*** array, int skip = 0) throw() {
+  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 = skip; i < num; i++) {
-      arr[i-skip] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
-      if (arr[i-skip] == 0) throw(bad_alloc());
-      std::copy(strings[i].begin(), strings[i].end(), arr[i-skip]);
-      arr[i-skip][strings[i].size()] = '\0';
+    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-skip] = 0;
+    arr[num] = 0;
     *array = arr;
   }
 
@@ -249,6 +247,29 @@ extern "C" {
       if (!got_newline) msg_stream << "\n";
       msg_stream << 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) {
+        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;
+        }
+        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 ++;
+        }
+        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;
+        msg_stream << ">> " << string(line_beg + move_in, line_end - shorten) << "\n";
+        msg_stream << "   " << string(e.pstate.column - move_in, '-') << "^\n";
+      }
+
       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());
@@ -256,6 +277,7 @@ extern "C" {
       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->error_src = e.pstate.src;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
@@ -320,7 +342,7 @@ extern "C" {
   }
 
   // generic compilation function (not exported, use file/data compile instead)
-  static Context* sass_prepare_context (Sass_Context* c_ctx, Context::Data cpp_opt)
+  static Sass_Compiler* sass_prepare_context (Sass_Context* c_ctx, Context::Data cpp_opt) throw()
   {
     try {
 
@@ -364,7 +386,9 @@ extern "C" {
       }
 
       // transfer the options to c++
-      cpp_opt.input_path(input_path)
+      cpp_opt.c_compiler(0)
+             .c_options(c_ctx)
+             .input_path(input_path)
              .output_path(output_path)
              .output_style((Output_Style) c_ctx->output_style)
              .is_indented_syntax_src(c_ctx->is_indented_syntax_src)
@@ -376,14 +400,13 @@ extern "C" {
              .omit_source_map_url(c_ctx->omit_source_map_url)
              .include_paths_c_str(c_ctx->include_path)
              .plugin_paths_c_str(c_ctx->plugin_path)
-             .include_paths_array(include_paths)
-             .plugin_paths_array(plugin_paths)
+             // .include_paths_array(include_paths)
+             // .plugin_paths_array(plugin_paths)
              .include_paths(vector<string>())
              .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 : "  ");
+             .precision(c_ctx->precision)
+             .linefeed(c_ctx->linefeed)
+             .indent(c_ctx->indent);
 
       // create new c++ Context
       Context* cpp_ctx = new Context(cpp_opt);
@@ -393,25 +416,53 @@ extern "C" {
 
       // register our custom functions
       if (c_ctx->c_functions) {
-        Sass_C_Function_List this_func_data = c_ctx->c_functions;
-        while ((this_func_data) && (*this_func_data)) {
-          cpp_ctx->c_functions.push_back((*this_func_data));
+        auto this_func_data = c_ctx->c_functions;
+        while (this_func_data && *this_func_data) {
+          cpp_ctx->add_c_function(*this_func_data);
           ++this_func_data;
         }
       }
 
+      // register our custom headers
+      if (c_ctx->c_headers) {
+        auto this_head_data = c_ctx->c_headers;
+        while (this_head_data && *this_head_data) {
+          cpp_ctx->add_c_header(*this_head_data);
+          ++this_head_data;
+        }
+      }
+
+      // register our custom importers
+      if (c_ctx->c_importers) {
+        auto this_imp_data = c_ctx->c_importers;
+        while (this_imp_data && *this_imp_data) {
+          cpp_ctx->add_c_importer(*this_imp_data);
+          ++this_imp_data;
+        }
+      }
+
       // 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
+      c_ctx->error_src = 0;
       c_ctx->error_file = 0;
-      c_ctx->error_line = -1;
-      c_ctx->error_column = -1;
+      c_ctx->error_line = string::npos;
+      c_ctx->error_column = string::npos;
+
+      // allocate a new compiler instance
+      Sass_Compiler* compiler = (struct Sass_Compiler*) calloc(1, sizeof(struct Sass_Compiler));
+      compiler->state = SASS_COMPILER_CREATED;
+
+      // store in sass compiler
+      compiler->c_ctx = c_ctx;
+      compiler->cpp_ctx = cpp_ctx;
+      cpp_ctx->c_compiler = compiler;
 
       // use to parse block
-      return cpp_ctx;
+      return compiler;
 
     }
     // pass errors to generic error handler
@@ -422,8 +473,18 @@ extern "C" {
 
   }
 
-  static Block* sass_parse_block (Sass_Context* c_ctx, Context* cpp_ctx)
+  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
@@ -445,8 +506,11 @@ extern "C" {
         skip = 1; // skip first entry of includes
       }
 
+      // skip all prefixed files?
+      skip += 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, skip);
+      if (root) copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files);
 
       // return parsed block
       return root;
@@ -464,36 +528,35 @@ extern "C" {
   static int sass_compile_context (Sass_Context* c_ctx, Context::Data cpp_opt)
   {
 
-    // first prepare the c++ context
-    Context* cpp_ctx = sass_prepare_context(c_ctx, cpp_opt);
-
-    // parse given context and return root block
-    Block* root = cpp_ctx ? sass_parse_block(c_ctx, cpp_ctx) : 0;
-
-    if (cpp_ctx && root) {
-
-      try {
-
-        // now compile the parsed root block
-        c_ctx->output_string = cpp_ctx->compile_block(root);
-
-        // generate source map json and store on context
-        c_ctx->source_map_string = cpp_ctx->generate_source_map();
-
-      }
-      // pass errors to generic error handler
-      catch (...) { handle_errors(c_ctx); }
+    // prepare sass compiler with context and options
+    Sass_Compiler* compiler = sass_prepare_context(c_ctx, cpp_opt);
 
+    try {
+      // call each compiler step
+      sass_compiler_parse(compiler);
+      sass_compiler_execute(compiler);
     }
+    // pass errors to generic error handler
+    catch (...) { handle_errors(c_ctx); }
 
-    delete cpp_ctx;
+    sass_delete_compiler(compiler);
 
     return c_ctx->error_status;
   }
 
+  inline void init_options (struct Sass_Options* options)
+  {
+    options->precision = 5;
+    options->indent = "  ";
+    options->linefeed = LFEED;
+  }
+
   Sass_Options* ADDCALL sass_make_options (void)
   {
-    return (struct Sass_Options*) calloc(1, sizeof(struct Sass_Options));
+    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; }
+    init_options(options);
+    return options;
   }
 
   Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)
@@ -501,6 +564,7 @@ extern "C" {
     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; }
     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")); }
@@ -516,6 +580,7 @@ extern "C" {
     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; }
     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")); }
@@ -529,27 +594,17 @@ extern "C" {
   struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* c_ctx)
   {
     if (c_ctx == 0) return 0;
-    struct Sass_Compiler* compiler = (struct Sass_Compiler*) calloc(1, sizeof(struct Sass_Compiler));
-    if (compiler == 0) { cerr << "Error allocating memory for file compiler" << endl; return 0; }
-    compiler->state = SASS_COMPILER_CREATED;
-    compiler->c_ctx = c_ctx;
     Context::Data cpp_opt = Context::Data();
     cpp_opt.entry_point(c_ctx->input_path);
-    compiler->cpp_ctx = sass_prepare_context(c_ctx, cpp_opt);
-    return compiler;
+    return sass_prepare_context(c_ctx, cpp_opt);
   }
 
   struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* c_ctx)
   {
     if (c_ctx == 0) return 0;
-    struct Sass_Compiler* compiler = (struct Sass_Compiler*) calloc(1, sizeof(struct Sass_Compiler));
-    if (compiler == 0) { cerr << "Error allocating memory for data compiler" << endl; return 0; }
-    compiler->state = SASS_COMPILER_CREATED;
-    compiler->c_ctx = c_ctx;
     Context::Data cpp_opt = Context::Data();
     cpp_opt.source_c_str(c_ctx->source_string);
-    compiler->cpp_ctx = sass_prepare_context(c_ctx, cpp_opt);
-    return compiler;
+    return sass_prepare_context(c_ctx, cpp_opt);
   }
 
   int ADDCALL sass_compile_data_context(Sass_Data_Context* data_ctx)
@@ -593,10 +648,8 @@ extern "C" {
     if (compiler->cpp_ctx == NULL) return 1;
     if (compiler->c_ctx->error_status)
       return compiler->c_ctx->error_status;
-    compiler->state = SASS_COMPILER_PARSED;
-    Context* cpp_ctx = (Context*) compiler->cpp_ctx;
     // parse the context we have set up (file or data)
-    compiler->root = sass_parse_block(compiler->c_ctx, cpp_ctx);
+    compiler->root = sass_parse_block(compiler);
     // success
     return 0;
   }
@@ -630,12 +683,28 @@ extern "C" {
     if (options == 0) return;
     // Deallocate custom functions
     if (options->c_functions) {
-      struct Sass_C_Function_Descriptor** this_func_data = options->c_functions;
-      while ((this_func_data) && (*this_func_data)) {
-        free((*this_func_data));
+      Sass_Function_List this_func_data = options->c_functions;
+      while (this_func_data && *this_func_data) {
+        free(*this_func_data);
         ++this_func_data;
       }
     }
+    // Deallocate custom headers
+    if (options->c_headers) {
+      Sass_Importer_List this_head_data = options->c_headers;
+      while (this_head_data && *this_head_data) {
+        free(*this_head_data);
+        ++this_head_data;
+      }
+    }
+    // Deallocate custom importers
+    if (options->c_importers) {
+      Sass_Importer_List this_imp_data = options->c_importers;
+      while (this_imp_data && *this_imp_data) {
+        free(*this_imp_data);
+        ++this_imp_data;
+      }
+    }
     // Deallocate inc paths
     if (options->plugin_paths) {
       struct string_list* cur;
@@ -660,13 +729,15 @@ extern "C" {
         cur = next;
       }
     }
-    // Free custom importer
-    free(options->importer);
-    // Free the list container
+    // Free custom functions
     free(options->c_functions);
-    // Make it null terminated
-    options->importer = 0;
+    // Free custom importers
+    free(options->c_importers);
+    free(options->c_headers);
+    // Reset our pointers
     options->c_functions = 0;
+    options->c_importers = 0;
+    options->c_headers = 0;
     options->plugin_paths = 0;
     options->include_paths = 0;
   }
@@ -730,6 +801,18 @@ 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)
+  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; }
+  // Getters for Sass_Compiler options (query import stack)
+  size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.size(); }
+  Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.back(); }
+  Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx) { return compiler->cpp_ctx->import_stack[idx]; }
+
+  // Calculate the size of the stored null terminated array
+  size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx)
+  { size_t l = 0; auto i = ctx->included_files; while (i && *i) { ++i; ++l; } return l; }
+
   // Create getter and setters for options
   IMPLEMENT_SASS_OPTION_ACCESSOR(int, precision);
   IMPLEMENT_SASS_OPTION_ACCESSOR(enum Sass_Output_Style, output_style);
@@ -738,8 +821,9 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_contents);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, omit_source_map_url);
   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(Sass_Function_List, c_functions);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_importers);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_headers);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path);
@@ -757,6 +841,7 @@ extern "C" {
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_file);
   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);
@@ -768,6 +853,7 @@ extern "C" {
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_file);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, output_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);
+  IMPLEMENT_SASS_CONTEXT_TAKER(char**, included_files);
 
   // Push function for include paths (no manipulation support for now)
   void ADDCALL sass_option_push_include_path(struct Sass_Options* options, const char* path)