sassc 0.0.1

data/ext/libsass/sass_context.h

@@ -0,0 +1,120 @@
+#ifndef SASS_C_CONTEXT
+#define SASS_C_CONTEXT
+
+#include <stddef.h>
+#include <stdbool.h>
+#include "sass.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Forward declaration
+struct Sass_Compiler;
+
+// Forward declaration
+struct Sass_Options;
+struct Sass_Context; // : Sass_Options
+struct Sass_File_Context; // : Sass_Context
+struct Sass_Data_Context; // : Sass_Context
+
+// Create and initialize an option struct
+ADDAPI struct Sass_Options* ADDCALL sass_make_options (void);
+// Create and initialize a specific context
+ADDAPI struct Sass_File_Context* ADDCALL sass_make_file_context (const char* input_path);
+ADDAPI struct Sass_Data_Context* ADDCALL sass_make_data_context (char* source_string);
+
+// Call the compilation step for the specific context
+ADDAPI int ADDCALL sass_compile_file_context (struct Sass_File_Context* ctx);
+ADDAPI int ADDCALL sass_compile_data_context (struct Sass_Data_Context* ctx);
+
+// Create a sass compiler instance for more control
+ADDAPI struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* file_ctx);
+ADDAPI struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx);
+
+// Execute the different compilation steps individually
+// Usefull if you only want to query the included files
+ADDAPI int ADDCALL sass_compiler_parse(struct Sass_Compiler* compiler);
+ADDAPI int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler);
+
+// Release all memory allocated with the compiler
+// This does _not_ include any contexts or options
+ADDAPI void ADDCALL sass_delete_compiler(struct Sass_Compiler* compiler);
+
+// Release all memory allocated and also ourself
+ADDAPI void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx);
+ADDAPI void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx);
+
+// Getters for context from specific implementation
+ADDAPI struct Sass_Context* ADDCALL sass_file_context_get_context (struct Sass_File_Context* file_ctx);
+ADDAPI struct Sass_Context* ADDCALL sass_data_context_get_context (struct Sass_Data_Context* data_ctx);
+
+// Getters for context options from Sass_Context
+ADDAPI struct Sass_Options* ADDCALL sass_context_get_options (struct Sass_Context* ctx);
+ADDAPI struct Sass_Options* ADDCALL sass_file_context_get_options (struct Sass_File_Context* file_ctx);
+ADDAPI struct Sass_Options* ADDCALL sass_data_context_get_options (struct Sass_Data_Context* data_ctx);
+ADDAPI void ADDCALL sass_file_context_set_options (struct Sass_File_Context* file_ctx, struct Sass_Options* opt);
+ADDAPI void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* data_ctx, struct Sass_Options* opt);
+
+
+// Getters for options
+ADDAPI int ADDCALL sass_option_get_precision (struct Sass_Options* options);
+ADDAPI enum Sass_Output_Style ADDCALL sass_option_get_output_style (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_source_comments (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_source_map_embed (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_source_map_contents (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_omit_source_map_url (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_is_indented_syntax_src (struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_input_path (struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_output_path (struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_image_path (struct Sass_Options* options);
+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 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);
+
+// Setters for options
+ADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);
+ADDAPI void ADDCALL sass_option_set_output_style (struct Sass_Options* options, enum Sass_Output_Style output_style);
+ADDAPI void ADDCALL sass_option_set_source_comments (struct Sass_Options* options, bool source_comments);
+ADDAPI void ADDCALL sass_option_set_source_map_embed (struct Sass_Options* options, bool source_map_embed);
+ADDAPI void ADDCALL sass_option_set_source_map_contents (struct Sass_Options* options, bool source_map_contents);
+ADDAPI void ADDCALL sass_option_set_omit_source_map_url (struct Sass_Options* options, bool omit_source_map_url);
+ADDAPI void ADDCALL sass_option_set_is_indented_syntax_src (struct Sass_Options* options, bool is_indented_syntax_src);
+ADDAPI void ADDCALL sass_option_set_input_path (struct Sass_Options* options, const char* input_path);
+ADDAPI void ADDCALL sass_option_set_output_path (struct Sass_Options* options, const char* output_path);
+ADDAPI void ADDCALL sass_option_set_image_path (struct Sass_Options* options, const char* image_path);
+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_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);
+
+
+// Getter for context
+ADDAPI const char* ADDCALL sass_context_get_output_string (struct Sass_Context* ctx);
+ADDAPI int ADDCALL sass_context_get_error_status (struct Sass_Context* ctx);
+ADDAPI const char* ADDCALL sass_context_get_error_json (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 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);
+
+// 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_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);
+
+// Push function for include paths (no manipulation support for now)
+ADDAPI void ADDCALL sass_option_push_include_path (struct Sass_Options* options, const char* path);
+
+
+#ifdef __cplusplus
+} // __cplusplus defined.
+#endif
+
+#endif

data/ext/libsass/sass_functions.cpp

@@ -0,0 +1,137 @@
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "context.hpp"
+#include "sass_functions.h"
+
+extern "C" {
+  using namespace std;
+
+  // Struct to hold custom function callback
+  struct Sass_C_Function_Descriptor {
+    const char*     signature;
+    Sass_C_Function function;
+    void*           cookie;
+  };
+
+  Sass_C_Function_List ADDCALL sass_make_function_list(size_t length)
+  {
+    return (Sass_C_Function_List) calloc(length + 1, sizeof(Sass_C_Function_Callback));
+  }
+
+  Sass_C_Function_Callback ADDCALL sass_make_function(const char* signature, Sass_C_Function function, void* cookie)
+  {
+    Sass_C_Function_Callback cb = (Sass_C_Function_Callback) calloc(1, sizeof(Sass_C_Function_Descriptor));
+    if (cb == 0) return 0;
+    cb->signature = signature;
+    cb->function = function;
+    cb->cookie = cookie;
+    return cb;
+  }
+
+  // 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; }
+
+  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; }
+
+  // External import entry
+  struct Sass_Import {
+    char* path;
+    char* base;
+    char* source;
+    char* srcmap;
+  };
+
+  // Struct to hold importer callback
+  struct Sass_C_Import_Descriptor {
+    Sass_C_Import_Fn function;
+    void*            cookie;
+  };
+
+  Sass_C_Import_Callback ADDCALL sass_make_importer(Sass_C_Import_Fn function, void* cookie)
+  {
+    Sass_C_Import_Callback cb = (Sass_C_Import_Callback) calloc(1, sizeof(Sass_C_Import_Descriptor));
+    if (cb == 0) return 0;
+    cb->function = function;
+    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; }
+
+  // Just in case we have some stray import structs
+  void ADDCALL sass_delete_importer (Sass_C_Import_Callback fn)
+  {
+    free(fn);
+  }
+
+  // Creator for sass custom importer return argument list
+  struct Sass_Import** 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* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));
+    if (v == 0) return 0;
+    v->path = path ? strdup(path) : 0;
+    v->base = base ? strdup(base) : 0;
+    v->source = source;
+    v->srcmap = srcmap;
+    return v;
+  }
+
+  // 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)
+  {
+    return sass_make_import(path, path, source, srcmap);
+  }
+
+  // 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]; }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_import_list(struct Sass_Import** list)
+  {
+    struct Sass_Import** it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_import(*list);
+      ++list;
+    }
+    free(it);
+  }
+
+  // Just in case we have some stray import structs
+  void ADDCALL sass_delete_import(struct Sass_Import* import)
+  {
+    free(import->path);
+    free(import->base);
+    free(import->source);
+    free(import->srcmap);
+    free(import);
+  }
+
+  // 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; }
+
+  // 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; }
+
+}

data/ext/libsass/sass_functions.h

@@ -0,0 +1,90 @@
+#ifndef SASS_C_FUNCTIONS
+#define SASS_C_FUNCTIONS
+
+#include <stddef.h>
+#include <stdbool.h>
+#include "sass.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Forward declaration
+struct Sass_Import;
+
+// 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);
+
+// 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);
+
+// 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);
+
+// Deallocator for associated memory
+ADDAPI void ADDCALL sass_delete_importer (Sass_C_Import_Callback fn);
+
+// Creator for sass custom importer return argument list
+ADDAPI struct Sass_Import** 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);
+
+// 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);
+
+// 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*);
+// 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*);
+
+// Deallocator for associated memory (incl. entries)
+ADDAPI void ADDCALL sass_delete_import_list (struct Sass_Import**);
+// 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;
+
+// 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);
+
+// 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);
+
+// 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);
+
+
+#ifdef __cplusplus
+} // __cplusplus defined.
+#endif
+
+#endif

data/ext/libsass/sass_interface.cpp

@@ -0,0 +1,277 @@
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "sass_interface.h"
+#include "context.hpp"
+#include "inspect.hpp"
+
+#ifndef SASS_ERROR_HANDLING
+#include "error_handling.hpp"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <cstring>
+
+extern "C" {
+  using namespace std;
+
+  sass_context* sass_new_context()
+  { return (sass_context*) calloc(1, sizeof(sass_context)); }
+
+  // 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 skip = 0) {
+    int num = static_cast<int>(strings.size());
+    char** arr = (char**) malloc(sizeof(char*) * (num + 1));
+
+    for(int i = skip; i < num; i++) {
+      arr[i-skip] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
+      std::copy(strings[i].begin(), strings[i].end(), arr[i-skip]);
+      arr[i-skip][strings[i].size()] = '\0';
+    }
+
+    arr[num-skip] = 0;
+    *array = arr;
+  }
+
+  static void free_string_array(char ** arr) {
+    if(!arr)
+        return;
+
+    char **it = arr;
+    while (it && (*it)) {
+      free(*it);
+      ++it;
+    }
+
+    free(arr);
+  }
+
+  void sass_free_context(sass_context* ctx)
+  {
+    if (ctx->output_string)     free(ctx->output_string);
+    if (ctx->source_map_string) free(ctx->source_map_string);
+    if (ctx->error_message)     free(ctx->error_message);
+    if (ctx->c_functions)       free(ctx->c_functions);
+
+    free_string_array(ctx->included_files);
+
+    free(ctx);
+  }
+
+  sass_file_context* sass_new_file_context()
+  { return (sass_file_context*) calloc(1, sizeof(sass_file_context)); }
+
+  void sass_free_file_context(sass_file_context* ctx)
+  {
+    if (ctx->output_string)     free(ctx->output_string);
+    if (ctx->source_map_string) free(ctx->source_map_string);
+    if (ctx->error_message)     free(ctx->error_message);
+    if (ctx->c_functions)       free(ctx->c_functions);
+
+    free_string_array(ctx->included_files);
+
+    free(ctx);
+  }
+
+  sass_folder_context* sass_new_folder_context()
+  { return (sass_folder_context*) calloc(1, sizeof(sass_folder_context)); }
+
+  void sass_free_folder_context(sass_folder_context* ctx)
+  {
+    free_string_array(ctx->included_files);
+    free(ctx);
+  }
+
+  int sass_compile(sass_context* c_ctx)
+  {
+    using namespace Sass;
+    try {
+      string input_path = safe_str(c_ctx->input_path);
+      int lastindex = static_cast<int>(input_path.find_last_of("."));
+      string output_path;
+      if (!c_ctx->output_path) {
+        if (input_path != "") {
+          output_path = (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
+        }
+      }
+      else {
+          output_path = c_ctx->output_path;
+      }
+      Context cpp_ctx(
+        Context::Data().source_c_str(c_ctx->source_string)
+                       .output_path(output_path)
+                       .output_style((Output_Style) c_ctx->options.output_style)
+                       .is_indented_syntax_src(c_ctx->options.is_indented_syntax_src)
+                       .source_comments(c_ctx->options.source_comments)
+                       .source_map_file(safe_str(c_ctx->options.source_map_file))
+                       .source_map_embed(c_ctx->options.source_map_embed)
+                       .source_map_contents(c_ctx->options.source_map_contents)
+                       .omit_source_map_url(c_ctx->options.omit_source_map_url)
+                       .image_path(safe_str(c_ctx->options.image_path))
+                       .include_paths_c_str(c_ctx->options.include_paths)
+                       .include_paths_array(0)
+                       .include_paths(vector<string>())
+                       .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
+                       .importer(0)
+      );
+      if (c_ctx->c_functions) {
+        struct Sass_C_Function_Descriptor** 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;
+        }
+      }
+      c_ctx->output_string = cpp_ctx.compile_string();
+      c_ctx->source_map_string = cpp_ctx.generate_source_map();
+      c_ctx->error_message = 0;
+      c_ctx->error_status = 0;
+
+      copy_strings(cpp_ctx.get_included_files(1), &c_ctx->included_files, 1);
+    }
+    catch (Sass_Error& e) {
+      stringstream msg_stream;
+      msg_stream << e.path << ":" << e.position.line << ": " << e.message << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch(bad_alloc& ba) {
+      stringstream msg_stream;
+      msg_stream << "Unable to allocate memory: " << ba.what() << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (std::exception& e) {
+      stringstream msg_stream;
+      msg_stream << "Error: " << e.what() << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (string& e) {
+      stringstream msg_stream;
+      msg_stream << "Error: " << e << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (...) {
+      // couldn't find the specified file in the include paths; report an error
+      stringstream msg_stream;
+      msg_stream << "Unknown error occurred" << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    return 0;
+  }
+
+  int sass_compile_file(sass_file_context* c_ctx)
+  {
+    using namespace Sass;
+    try {
+      string input_path = safe_str(c_ctx->input_path);
+      int lastindex = static_cast<int>(input_path.find_last_of("."));
+      string output_path;
+      if (!c_ctx->output_path) {
+          output_path = (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
+      }
+      else {
+          output_path = c_ctx->output_path;
+      }
+      Context cpp_ctx(
+        Context::Data().entry_point(input_path)
+                       .output_path(output_path)
+                       .output_style((Output_Style) c_ctx->options.output_style)
+                       .is_indented_syntax_src(c_ctx->options.is_indented_syntax_src)
+                       .source_comments(c_ctx->options.source_comments)
+                       .source_map_file(safe_str(c_ctx->options.source_map_file))
+                       .source_map_embed(c_ctx->options.source_map_embed)
+                       .source_map_contents(c_ctx->options.source_map_contents)
+                       .omit_source_map_url(c_ctx->options.omit_source_map_url)
+                       .image_path(safe_str(c_ctx->options.image_path))
+                       .include_paths_c_str(c_ctx->options.include_paths)
+                       .include_paths_array(0)
+                       .include_paths(vector<string>())
+                       .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
+      );
+      if (c_ctx->c_functions) {
+        struct Sass_C_Function_Descriptor** 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;
+        }
+      }
+      c_ctx->output_string = cpp_ctx.compile_file();
+      c_ctx->source_map_string = cpp_ctx.generate_source_map();
+      c_ctx->error_message = 0;
+      c_ctx->error_status = 0;
+
+      copy_strings(cpp_ctx.get_included_files(), &c_ctx->included_files);
+    }
+    catch (Sass_Error& e) {
+      stringstream msg_stream;
+      msg_stream << e.path << ":" << e.position.line << ": " << e.message << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch(bad_alloc& ba) {
+      stringstream msg_stream;
+      msg_stream << "Unable to allocate memory: " << ba.what() << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (std::exception& e) {
+      stringstream msg_stream;
+      msg_stream << "Error: " << e.what() << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (string& e) {
+      stringstream msg_stream;
+      msg_stream << "Error: " << e << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    catch (...) {
+      // couldn't find the specified file in the include paths; report an error
+      stringstream msg_stream;
+      msg_stream << "Unknown error occurred" << endl;
+      c_ctx->error_message = strdup(msg_stream.str().c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->source_map_string = 0;
+    }
+    return 0;
+  }
+
+  int sass_compile_folder(sass_folder_context* c_ctx)
+  {
+    return 1;
+  }
+
+}