sassc 0.0.10 → 0.0.11

data/ext/libsass/sass_context.h

@@ -14,11 +14,18 @@ extern "C" {
 struct Sass_Compiler;
 
 // Forward declaration
-struct Sass_Options;
+struct Sass_Options; // base struct
 struct Sass_Context; // : Sass_Options
 struct Sass_File_Context; // : Sass_Context
 struct Sass_Data_Context; // : Sass_Context
 
+// Compiler states
+enum Sass_Compiler_State {
+  SASS_COMPILER_CREATED,
+  SASS_COMPILER_PARSED,
+  SASS_COMPILER_EXECUTED
+};
+
 // Create and initialize an option struct
 ADDAPI struct Sass_Options* ADDCALL sass_make_options (void);
 // Create and initialize a specific context
@@ -74,8 +81,9 @@ ADDAPI const char* ADDCALL sass_option_get_plugin_path (struct Sass_Options* opt
 ADDAPI const char* ADDCALL sass_option_get_include_path (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_source_map_file (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_source_map_root (struct Sass_Options* options);
-ADDAPI Sass_C_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
-ADDAPI Sass_C_Import_Callback ADDCALL sass_option_get_importer (struct Sass_Options* options);
+ADDAPI Sass_Importer_List ADDCALL sass_option_get_c_headers (struct Sass_Options* options);
+ADDAPI Sass_Importer_List ADDCALL sass_option_get_c_importers (struct Sass_Options* options);
+ADDAPI Sass_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
 
 // Setters for Context_Option values
 ADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);
@@ -93,8 +101,9 @@ ADDAPI void ADDCALL sass_option_set_plugin_path (struct Sass_Options* options, c
 ADDAPI void ADDCALL sass_option_set_include_path (struct Sass_Options* options, const char* include_path);
 ADDAPI void ADDCALL sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);
 ADDAPI void ADDCALL sass_option_set_source_map_root (struct Sass_Options* options, const char* source_map_root);
-ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_C_Function_List c_functions);
-ADDAPI void ADDCALL sass_option_set_importer (struct Sass_Options* options, Sass_C_Import_Callback importer);
+ADDAPI void ADDCALL sass_option_set_c_headers (struct Sass_Options* options, Sass_Importer_List c_headers);
+ADDAPI void ADDCALL sass_option_set_c_importers (struct Sass_Options* options, Sass_Importer_List c_importers);
+ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_Function_List c_functions);
 
 
 // Getters for Sass_Context values
@@ -104,11 +113,15 @@ ADDAPI const char* ADDCALL sass_context_get_error_json (struct Sass_Context* ctx
 ADDAPI const char* ADDCALL sass_context_get_error_text (struct Sass_Context* ctx);
 ADDAPI const char* ADDCALL sass_context_get_error_message (struct Sass_Context* ctx);
 ADDAPI const char* ADDCALL sass_context_get_error_file (struct Sass_Context* ctx);
+ADDAPI const char* ADDCALL sass_context_get_error_src (struct Sass_Context* ctx);
 ADDAPI size_t ADDCALL sass_context_get_error_line (struct Sass_Context* ctx);
 ADDAPI size_t ADDCALL sass_context_get_error_column (struct Sass_Context* ctx);
 ADDAPI const char* ADDCALL sass_context_get_source_map_string (struct Sass_Context* ctx);
 ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx);
 
+// Calculate the size of the stored null terminated array
+ADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);
+
 // Take ownership of memory (value on context is set to 0)
 ADDAPI char* ADDCALL sass_context_take_error_json (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_error_text (struct Sass_Context* ctx);
@@ -116,12 +129,19 @@ ADDAPI char* ADDCALL sass_context_take_error_message (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_error_file (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_output_string (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_source_map_string (struct Sass_Context* ctx);
+ADDAPI char** ADDCALL sass_context_take_included_files (struct Sass_Context* ctx);
+
+// Getters for Sass_Compiler options
+ADDAPI enum Sass_Compiler_State ADDCALL sass_compiler_get_state(struct Sass_Compiler* compiler);
+ADDAPI struct Sass_Context* ADDCALL sass_compiler_get_context(struct Sass_Compiler* compiler);
+ADDAPI size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler);
+ADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler);
+ADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx);
 
 // Push function for paths (no manipulation support for now)
 ADDAPI void ADDCALL sass_option_push_plugin_path (struct Sass_Options* options, const char* path);
 ADDAPI void ADDCALL sass_option_push_include_path (struct Sass_Options* options, const char* path);
 
-
 #ifdef __cplusplus
 } // __cplusplus defined.
 #endif

data/ext/libsass/sass_functions.cpp

@@ -14,20 +14,20 @@ extern "C" {
   using namespace Sass;
 
   // Struct to hold custom function callback
-  struct Sass_C_Function_Descriptor {
-    const char*     signature;
-    Sass_C_Function function;
-    void*           cookie;
+  struct Sass_Function {
+    const char*      signature;
+    Sass_Function_Fn function;
+    void*            cookie;
   };
 
-  Sass_C_Function_List ADDCALL sass_make_function_list(size_t length)
+  Sass_Function_List ADDCALL sass_make_function_list(size_t length)
   {
-    return (Sass_C_Function_List) calloc(length + 1, sizeof(Sass_C_Function_Callback));
+    return (Sass_Function_List) calloc(length + 1, sizeof(Sass_Function_Entry));
   }
 
-  Sass_C_Function_Callback ADDCALL sass_make_function(const char* signature, Sass_C_Function function, void* cookie)
+  Sass_Function_Entry ADDCALL sass_make_function(const char* signature, Sass_Function_Fn function, void* cookie)
   {
-    Sass_C_Function_Callback cb = (Sass_C_Function_Callback) calloc(1, sizeof(Sass_C_Function_Descriptor));
+    Sass_Function_Entry cb = (Sass_Function_Entry) calloc(1, sizeof(Sass_Function));
     if (cb == 0) return 0;
     cb->signature = signature;
     cb->function = function;
@@ -36,12 +36,12 @@ extern "C" {
   }
 
   // Setters and getters for callbacks on function lists
-  Sass_C_Function_Callback ADDCALL sass_function_get_list_entry(Sass_C_Function_List list, size_t pos) { return list[pos]; }
-  void sass_function_set_list_entry(Sass_C_Function_List list, size_t pos, Sass_C_Function_Callback cb) { list[pos] = cb; }
+  Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos) { return list[pos]; }
+  void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb) { list[pos] = cb; }
 
-  const char* ADDCALL sass_function_get_signature(Sass_C_Function_Callback fn) { return fn->signature; }
-  Sass_C_Function ADDCALL sass_function_get_function(Sass_C_Function_Callback fn) { return fn->function; }
-  void* ADDCALL sass_function_get_cookie(Sass_C_Function_Callback fn) { return fn->cookie; }
+  const char* ADDCALL sass_function_get_signature(Sass_Function_Entry cb) { return cb->signature; }
+  Sass_Function_Fn ADDCALL sass_function_get_function(Sass_Function_Entry cb) { return cb->function; }
+  void* ADDCALL sass_function_get_cookie(Sass_Function_Entry cb) { return cb->cookie; }
 
   // External import entry
   struct Sass_Import {
@@ -56,38 +56,47 @@ extern "C" {
   };
 
   // Struct to hold importer callback
-  struct Sass_C_Import_Descriptor {
-    Sass_C_Import_Fn function;
+  struct Sass_Importer {
+    Sass_Importer_Fn importer;
+    double           priority;
     void*            cookie;
   };
 
-  Sass_C_Import_Callback ADDCALL sass_make_importer(Sass_C_Import_Fn function, void* cookie)
+  Sass_Importer_Entry ADDCALL sass_make_importer(Sass_Importer_Fn importer, double priority, void* cookie)
   {
-    Sass_C_Import_Callback cb = (Sass_C_Import_Callback) calloc(1, sizeof(Sass_C_Import_Descriptor));
+    Sass_Importer_Entry cb = (Sass_Importer_Entry) calloc(1, sizeof(Sass_Importer));
     if (cb == 0) return 0;
-    cb->function = function;
+    cb->importer = importer;
+    cb->priority = priority;
     cb->cookie = cookie;
     return cb;
   }
 
-  Sass_C_Import_Fn ADDCALL sass_import_get_function(Sass_C_Import_Callback fn) { return fn->function; }
-  void* ADDCALL sass_import_get_cookie(Sass_C_Import_Callback fn) { return fn->cookie; }
+  Sass_Importer_Fn ADDCALL sass_importer_get_function(Sass_Importer_Entry cb) { return cb->importer; }
+  double ADDCALL sass_importer_get_priority (Sass_Importer_Entry cb) { return cb->priority; }
+  void* ADDCALL sass_importer_get_cookie(Sass_Importer_Entry cb) { return cb->cookie; }
 
   // Just in case we have some stray import structs
-  void ADDCALL sass_delete_importer (Sass_C_Import_Callback fn)
+  void ADDCALL sass_delete_importer (Sass_Importer_Entry cb)
+  {
+    free(cb);
+  }
+
+  // Creator for sass custom importer function list
+  Sass_Importer_List ADDCALL sass_make_importer_list(size_t length)
   {
-    free(fn);
+    return (Sass_Importer_List) calloc(length + 1, sizeof(Sass_Importer_Entry));
   }
 
   // Creator for sass custom importer return argument list
-  struct Sass_Import** ADDCALL sass_make_import_list(size_t length)
+  Sass_Import_List ADDCALL sass_make_import_list(size_t length)
   {
     return (Sass_Import**) calloc(length + 1, sizeof(Sass_Import*));
   }
 
   // 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)
-  struct Sass_Import* ADDCALL sass_make_import(const char* path, const char* base, char* source, char* srcmap)
+  Sass_Import_Entry ADDCALL sass_make_import(const char* path, const char* base, char* source, char* srcmap)
   {
     Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));
     if (v == 0) return 0;
@@ -102,13 +111,13 @@ extern "C" {
   }
 
   // Older style, but somehow still valid - keep around or deprecate?
-  struct Sass_Import* ADDCALL sass_make_import_entry(const char* path, char* source, char* srcmap)
+  Sass_Import_Entry ADDCALL sass_make_import_entry(const char* path, char* source, char* srcmap)
   {
     return sass_make_import(path, path, source, srcmap);
   }
 
   // Upgrade a normal import entry to throw an error (original path can be re-used by error reporting)
-  struct Sass_Import* ADDCALL sass_import_set_error(struct Sass_Import* import, const char* error, size_t line, size_t col)
+  Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import, const char* error, size_t line, size_t col)
   {
     if (import == 0) return 0;
     if (import->error) free(import->error);
@@ -119,13 +128,13 @@ extern "C" {
   }
 
   // Setters and getters for entries on the import list
-  void ADDCALL sass_import_set_list_entry(struct Sass_Import** list, size_t idx, struct Sass_Import* entry) { list[idx] = entry; }
-  struct Sass_Import* ADDCALL sass_import_get_list_entry(struct Sass_Import** list, size_t idx) { return list[idx]; }
+  void ADDCALL sass_import_set_list_entry(Sass_Import_List list, size_t idx, Sass_Import_Entry entry) { list[idx] = entry; }
+  Sass_Import_Entry ADDCALL sass_import_get_list_entry(Sass_Import_List list, size_t idx) { return list[idx]; }
 
   // Deallocator for the allocated memory
-  void ADDCALL sass_delete_import_list(struct Sass_Import** list)
+  void ADDCALL sass_delete_import_list(Sass_Import_List list)
   {
-    struct Sass_Import** it = list;
+    Sass_Import_List it = list;
     if (list == 0) return;
     while(*list) {
       sass_delete_import(*list);
@@ -135,7 +144,7 @@ extern "C" {
   }
 
   // Just in case we have some stray import structs
-  void ADDCALL sass_delete_import(struct Sass_Import* import)
+  void ADDCALL sass_delete_import(Sass_Import_Entry import)
   {
     free(import->path);
     free(import->base);
@@ -146,19 +155,19 @@ extern "C" {
   }
 
   // Getter for import entry
-  const char* ADDCALL sass_import_get_path(struct Sass_Import* entry) { return entry->path; }
-  const char* ADDCALL sass_import_get_base(struct Sass_Import* entry) { return entry->base; }
-  const char* ADDCALL sass_import_get_source(struct Sass_Import* entry) { return entry->source; }
-  const char* ADDCALL sass_import_get_srcmap(struct Sass_Import* entry) { return entry->srcmap; }
+  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_source(Sass_Import_Entry entry) { return entry->source; }
+  const char* ADDCALL sass_import_get_srcmap(Sass_Import_Entry entry) { return entry->srcmap; }
 
   // Getter for import error entry
-  size_t ADDCALL sass_import_get_error_line(struct Sass_Import* entry) { return entry->line; }
-  size_t ADDCALL sass_import_get_error_column(struct Sass_Import* entry) { return entry->column; }
-  const char* ADDCALL sass_import_get_error_message(struct Sass_Import* entry) { return entry->error; }
+  size_t ADDCALL sass_import_get_error_line(Sass_Import_Entry entry) { return entry->line; }
+  size_t ADDCALL sass_import_get_error_column(Sass_Import_Entry entry) { return entry->column; }
+  const char* ADDCALL sass_import_get_error_message(Sass_Import_Entry entry) { return entry->error; }
 
   // Explicit functions to take ownership of the memory
   // Resets our own property since we do not know if it is still alive
-  char* ADDCALL sass_import_take_source(struct Sass_Import* entry) { char* ptr = entry->source; entry->source = 0; return ptr; }
-  char* ADDCALL sass_import_take_srcmap(struct Sass_Import* entry) { char* ptr = entry->srcmap; entry->srcmap = 0; return ptr; }
+  char* ADDCALL sass_import_take_source(Sass_Import_Entry entry) { char* ptr = entry->source; entry->source = 0; return ptr; }
+  char* ADDCALL sass_import_take_srcmap(Sass_Import_Entry entry) { char* ptr = entry->srcmap; entry->srcmap = 0; return ptr; }
 
 }

data/ext/libsass/sass_functions.h

@@ -12,81 +12,93 @@ extern "C" {
 
 // Forward declaration
 struct Sass_Import;
+struct Sass_Options;
+struct Sass_Compiler;
+struct Sass_Importer;
+struct Sass_Function;
+
+// Typedef helpers for import lists
+typedef struct Sass_Import (*Sass_Import_Entry);
+typedef struct Sass_Import* (*Sass_Import_List);
+// Typedef helpers for custom importer lists
+typedef struct Sass_Importer (*Sass_Importer_Entry);
+typedef struct Sass_Importer* (*Sass_Importer_List);
+// Typedef defining importer signature and return type
+typedef Sass_Import_List (*Sass_Importer_Fn)
+  (const char* url, Sass_Importer_Entry cb, struct Sass_Compiler* compiler);
+
+// Typedef helpers for custom functions lists
+typedef struct Sass_Function (*Sass_Function_Entry);
+typedef struct Sass_Function* (*Sass_Function_List);
+// Typedef defining function signature and return type
+typedef union Sass_Value* (*Sass_Function_Fn)
+  (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Options* options);
 
-// Forward declaration
-struct Sass_C_Import_Descriptor;
 
-// Typedef defining the custom importer callback
-typedef struct Sass_C_Import_Descriptor (*Sass_C_Import_Callback);
-// Typedef defining the importer c function prototype
-typedef struct Sass_Import** (*Sass_C_Import_Fn) (const char* url, const char* prev, void* cookie);
+// Creator for sass custom importer return argument list
+ADDAPI Sass_Importer_List ADDCALL sass_make_importer_list (size_t length);
+ADDAPI Sass_Importer_Entry ADDCALL sass_importer_get_list_entry (Sass_Importer_List list, size_t idx);
+ADDAPI void ADDCALL sass_importer_set_list_entry (Sass_Importer_List list, size_t idx, Sass_Importer_Entry entry);
+
 
 // Creators for custom importer callback (with some additional pointer)
 // The pointer is mostly used to store the callback into the actual binding
-ADDAPI Sass_C_Import_Callback ADDCALL sass_make_importer (Sass_C_Import_Fn, void* cookie);
+ADDAPI Sass_Importer_Entry ADDCALL sass_make_importer (Sass_Importer_Fn importer, double priority, void* cookie);
 
 // Getters for import function descriptors
-ADDAPI Sass_C_Import_Fn ADDCALL sass_import_get_function (Sass_C_Import_Callback fn);
-ADDAPI void* ADDCALL sass_import_get_cookie (Sass_C_Import_Callback fn);
+ADDAPI Sass_Importer_Fn ADDCALL sass_importer_get_function (Sass_Importer_Entry cb);
+ADDAPI double ADDCALL sass_importer_get_priority (Sass_Importer_Entry cb);
+ADDAPI void* ADDCALL sass_importer_get_cookie (Sass_Importer_Entry cb);
 
 // Deallocator for associated memory
-ADDAPI void ADDCALL sass_delete_importer (Sass_C_Import_Callback fn);
+ADDAPI void ADDCALL sass_delete_importer (Sass_Importer_Entry cb);
 
 // Creator for sass custom importer return argument list
-ADDAPI struct Sass_Import** ADDCALL sass_make_import_list (size_t length);
+ADDAPI Sass_Import_List ADDCALL sass_make_import_list (size_t length);
 // Creator for a single import entry returned by the custom importer inside the list
-ADDAPI struct Sass_Import* ADDCALL sass_make_import_entry (const char* path, char* source, char* srcmap);
-ADDAPI struct Sass_Import* ADDCALL sass_make_import (const char* path, const char* base, char* source, char* srcmap);
+ADDAPI Sass_Import_Entry ADDCALL sass_make_import_entry (const char* path, char* source, char* srcmap);
+ADDAPI Sass_Import_Entry ADDCALL sass_make_import (const char* path, const char* base, char* source, char* srcmap);
 // set error message to abort import and to print out a message (path from existing object is used in output)
-ADDAPI struct Sass_Import* ADDCALL sass_import_set_error(struct Sass_Import* import, const char* message, size_t line, size_t col);
+ADDAPI Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import, const char* message, size_t line, size_t col);
 
 // Setters to insert an entry into the import list (you may also use [] access directly)
 // Since we are dealing with pointers they should have a guaranteed and fixed size
-ADDAPI void ADDCALL sass_import_set_list_entry (struct Sass_Import** list, size_t idx, struct Sass_Import* entry);
-ADDAPI struct Sass_Import* ADDCALL sass_import_get_list_entry (struct Sass_Import** list, size_t idx);
+ADDAPI void ADDCALL sass_import_set_list_entry (Sass_Import_List list, size_t idx, Sass_Import_Entry entry);
+ADDAPI Sass_Import_Entry ADDCALL sass_import_get_list_entry (Sass_Import_List list, size_t idx);
 
 // Getters for import entry
-ADDAPI const char* ADDCALL sass_import_get_path (struct Sass_Import*);
-ADDAPI const char* ADDCALL sass_import_get_base (struct Sass_Import*);
-ADDAPI const char* ADDCALL sass_import_get_source (struct Sass_Import*);
-ADDAPI const char* ADDCALL sass_import_get_srcmap (struct Sass_Import*);
+ADDAPI const char* ADDCALL sass_import_get_path (Sass_Import_Entry);
+ADDAPI const char* ADDCALL sass_import_get_base (Sass_Import_Entry);
+ADDAPI const char* ADDCALL sass_import_get_source (Sass_Import_Entry);
+ADDAPI const char* ADDCALL sass_import_get_srcmap (Sass_Import_Entry);
 // Explicit functions to take ownership of these items
 // The property on our struct will be reset to NULL
-ADDAPI char* ADDCALL sass_import_take_source (struct Sass_Import*);
-ADDAPI char* ADDCALL sass_import_take_srcmap (struct Sass_Import*);
+ADDAPI char* ADDCALL sass_import_take_source (Sass_Import_Entry);
+ADDAPI char* ADDCALL sass_import_take_srcmap (Sass_Import_Entry);
 // Getters from import error entry
-ADDAPI size_t ADDCALL sass_import_get_error_line (struct Sass_Import*);
-ADDAPI size_t ADDCALL sass_import_get_error_column (struct Sass_Import*);
-ADDAPI const char* ADDCALL sass_import_get_error_message (struct Sass_Import*);
+ADDAPI size_t ADDCALL sass_import_get_error_line (Sass_Import_Entry);
+ADDAPI size_t ADDCALL sass_import_get_error_column (Sass_Import_Entry);
+ADDAPI const char* ADDCALL sass_import_get_error_message (Sass_Import_Entry);
 
 // Deallocator for associated memory (incl. entries)
-ADDAPI void ADDCALL sass_delete_import_list (struct Sass_Import**);
+ADDAPI void ADDCALL sass_delete_import_list (Sass_Import_List);
 // Just in case we have some stray import structs
-ADDAPI void ADDCALL sass_delete_import (struct Sass_Import*);
-
-
-// Forward declaration
-struct Sass_C_Function_Descriptor;
+ADDAPI void ADDCALL sass_delete_import (Sass_Import_Entry);
 
-// Typedef defining null terminated list of custom callbacks
-typedef struct Sass_C_Function_Descriptor* (*Sass_C_Function_List);
-typedef struct Sass_C_Function_Descriptor (*Sass_C_Function_Callback);
-// Typedef defining custom function prototype and its return value type
-typedef union Sass_Value*(*Sass_C_Function) (const union Sass_Value*, void* cookie);
 
 
 // Creators for sass function list and function descriptors
-ADDAPI Sass_C_Function_List ADDCALL sass_make_function_list (size_t length);
-ADDAPI Sass_C_Function_Callback ADDCALL sass_make_function (const char* signature, Sass_C_Function fn, void* cookie);
+ADDAPI Sass_Function_List ADDCALL sass_make_function_list (size_t length);
+ADDAPI Sass_Function_Entry ADDCALL sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);
 
 // Setters and getters for callbacks on function lists
-ADDAPI Sass_C_Function_Callback ADDCALL sass_function_get_list_entry(Sass_C_Function_List list, size_t pos);
-ADDAPI void ADDCALL sass_function_set_list_entry(Sass_C_Function_List list, size_t pos, Sass_C_Function_Callback cb);
+ADDAPI Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos);
+ADDAPI void ADDCALL sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb);
 
 // Getters for custom function descriptors
-ADDAPI const char* ADDCALL sass_function_get_signature (Sass_C_Function_Callback fn);
-ADDAPI Sass_C_Function ADDCALL sass_function_get_function (Sass_C_Function_Callback fn);
-ADDAPI void* ADDCALL sass_function_get_cookie (Sass_C_Function_Callback fn);
+ADDAPI const char* ADDCALL sass_function_get_signature (Sass_Function_Entry cb);
+ADDAPI Sass_Function_Fn ADDCALL sass_function_get_function (Sass_Function_Entry cb);
+ADDAPI void* ADDCALL sass_function_get_cookie (Sass_Function_Entry cb);
 
 
 #ifdef __cplusplus

data/ext/libsass/sass_interface.cpp

@@ -121,17 +121,16 @@ extern "C" {
                        .omit_source_map_url(c_ctx->options.omit_source_map_url)
                        .include_paths_c_str(c_ctx->options.include_paths)
                        .plugin_paths_c_str(c_ctx->options.plugin_paths)
-                       .include_paths_array(0)
-                       .plugin_paths_array(0)
+                       // .include_paths_array(0)
+                       // .plugin_paths_array(0)
                        .include_paths(vector<string>())
                        .plugin_paths(vector<string>())
                        .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
                        .indent(c_ctx->options.indent ? c_ctx->options.indent : "  ")
                        .linefeed(c_ctx->options.linefeed ? c_ctx->options.linefeed : LFEED)
-                       .importer(0)
       );
       if (c_ctx->c_functions) {
-        struct Sass_C_Function_Descriptor** this_func_data = c_ctx->c_functions;
+        Sass_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);
           ++this_func_data;
@@ -214,14 +213,16 @@ extern "C" {
                        .omit_source_map_url(c_ctx->options.omit_source_map_url)
                        .include_paths_c_str(c_ctx->options.include_paths)
                        .plugin_paths_c_str(c_ctx->options.plugin_paths)
-                       .include_paths_array(0)
-                       .plugin_paths_array(0)
+                       // .include_paths_array(0)
+                       // .plugin_paths_array(0)
                        .include_paths(vector<string>())
                        .plugin_paths(vector<string>())
                        .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
+                       .indent(c_ctx->options.indent ? c_ctx->options.indent : "  ")
+                       .linefeed(c_ctx->options.linefeed ? c_ctx->options.linefeed : LFEED)
       );
       if (c_ctx->c_functions) {
-        struct Sass_C_Function_Descriptor** this_func_data = c_ctx->c_functions;
+        Sass_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);
           ++this_func_data;
@@ -236,7 +237,7 @@ extern "C" {
     }
     catch (Sass_Error& e) {
       stringstream msg_stream;
-      msg_stream << e.path << ":" << e.pstate.line << ": " << e.message << endl;
+      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;

data/ext/libsass/sass_interface.h

@@ -53,7 +53,7 @@ struct sass_context {
   struct sass_options options;
   int error_status;
   char* error_message;
-  Sass_C_Function_List c_functions;
+  Sass_Function_List c_functions;
   char** included_files;
   int num_included_files;
 };
@@ -66,7 +66,7 @@ struct sass_file_context {
   struct sass_options options;
   int error_status;
   char* error_message;
-  Sass_C_Function_List c_functions;
+  Sass_Function_List c_functions;
   char** included_files;
   int num_included_files;
 };
@@ -77,7 +77,7 @@ struct sass_folder_context {
   struct sass_options options;
   int error_status;
   char* error_message;
-  Sass_C_Function_List c_functions;
+  Sass_Function_List c_functions;
   char** included_files;
   int num_included_files;
 };