sassc 1.8.1 → 1.8.2

data/ext/libsass/src/bind.hpp

@@ -12,7 +12,7 @@ namespace Sass {
   class   Eval;
   typedef Environment<AST_Node*> Env;
 
-  void bind(std::string caller, Parameters*, Arguments*, Context&, Env*, Eval*);
+  void bind(std::string type, std::string name, Parameters*, Arguments*, Context*, Env*, Eval*);
 }
 
 #endif

data/ext/libsass/src/context.cpp

@@ -38,88 +38,80 @@ namespace Sass {
   using namespace File;
   using namespace Sass;
 
-  Sass_Queued::Sass_Queued(const std::string& load_path, const std::string& abs_path, const char* source)
+  inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)
+  { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }
+
+  static std::string safe_input(const char* in_path)
   {
-    this->load_path = load_path;
-    this->abs_path = abs_path;
-    this->source = source;
+    // enforce some safe defaults
+    // used to create relative file links
+    std::string safe_path(in_path ? in_path : "");
+    return safe_path == "" ? "stdin" : safe_path;
   }
 
-  inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)
-  { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }
+  static std::string safe_output(const char* out_path, const std::string& input_path = "")
+  {
+    std::string safe_path(out_path ? out_path : "");
+    // maybe we can extract an output path from input path
+    if (safe_path == "" && input_path != "") {
+      int lastindex = static_cast<int>(input_path.find_last_of("."));
+      return (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
+    }
+    // enforce some safe defaults
+    // used to create relative file links
+    return safe_path == "" ? "stdout" : safe_path;
+  }
 
-  Context::Context(Context::Data initializers)
-  : // Output(this),
+  Context::Context(struct Sass_Context* c_ctx)
+  : CWD(File::get_cwd()),
+    entry_path(""),
     head_imports(0),
     mem(Memory_Manager()),
-    c_options               (initializers.c_options()),
-    c_compiler              (initializers.c_compiler()),
-    source_c_str            (initializers.source_c_str()),
-    sources                 (std::vector<char*>()),
-    strings                 (std::vector<char*>()),
-    plugin_paths            (initializers.plugin_paths()),
-    include_paths           (initializers.include_paths()),
-    queue                   (std::vector<Sass_Queued>()),
-    style_sheets            (std::map<std::string, Block*>()),
-    emitter (this),
+    plugins(),
+    emitter(this),
+
+    strings(),
+    resources(),
+    sheets(),
+    subset_map(),
+    import_stack(),
+
+    c_options               (c_ctx),
+
     c_headers               (std::vector<Sass_Importer_Entry>()),
     c_importers             (std::vector<Sass_Importer_Entry>()),
     c_functions             (std::vector<Sass_Function_Entry>()),
-    indent                  (initializers.indent()),
-    linefeed                (initializers.linefeed()),
-    input_path              (make_canonical_path(initializers.input_path())),
-    output_path             (make_canonical_path(initializers.output_path())),
-    source_comments         (initializers.source_comments()),
-    output_style            (initializers.output_style()),
-    source_map_file         (make_canonical_path(initializers.source_map_file())),
-    source_map_root         (initializers.source_map_root()), // pass-through
-    source_map_embed        (initializers.source_map_embed()),
-    source_map_contents     (initializers.source_map_contents()),
-    omit_source_map_url     (initializers.omit_source_map_url()),
-    is_indented_syntax_src  (initializers.is_indented_syntax_src()),
-    precision               (initializers.precision()),
-    plugins(),
-    subset_map              (Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> >())
-  {
 
-    cwd = get_cwd();
+    indent                  (safe_str(c_options->indent, "  ")),
+    linefeed                (safe_str(c_options->linefeed, "\n")),
 
-    // enforce some safe defaults
-    // used to create relative file links
-    if (input_path == "") input_path = "stdin";
-    if (output_path == "") output_path = "stdout";
+    input_path              (make_canonical_path(safe_input(c_options->input_path))),
+    output_path             (make_canonical_path(safe_output(c_options->output_path, input_path))),
+    source_map_file         (make_canonical_path(safe_str(c_options->source_map_file, ""))),
+    source_map_root         (make_canonical_path(safe_str(c_options->source_map_root, "")))
+
+  {
 
-    include_paths.push_back(cwd);
-    collect_include_paths(initializers.include_paths_c_str());
+    // add cwd to include paths
+    include_paths.push_back(CWD);
+
+    // collect more paths from different options
+    collect_include_paths(sass_option_get_include_path(c_options));
     // collect_include_paths(initializers.include_paths_array());
-    collect_plugin_paths(initializers.plugin_paths_c_str());
+    collect_plugin_paths(sass_option_get_plugin_path(c_options));
     // collect_plugin_paths(initializers.plugin_paths_array());
 
-    for (size_t i = 0, S = plugin_paths.size(); i < S; ++i) {
-      plugins.load_plugins(plugin_paths[i]);
-    }
-
-    for(auto fn : plugins.get_functions()) {
-      c_functions.push_back(fn);
-    }
-    for(auto fn : plugins.get_headers()) {
-      c_headers.push_back(fn);
-    }
-    for(auto fn : plugins.get_importers()) {
-      c_importers.push_back(fn);
-    }
+    // load plugins and register custom behaviors
+    for(auto plug : plugin_paths) plugins.load_plugins(plug);
+    for(auto fn : plugins.get_headers()) c_headers.push_back(fn);
+    for(auto fn : plugins.get_importers()) c_importers.push_back(fn);
+    for(auto fn : plugins.get_functions()) c_functions.push_back(fn);
 
+    // sort the items by priority (lowest first)
     sort (c_headers.begin(), c_headers.end(), sort_importers);
     sort (c_importers.begin(), c_importers.end(), sort_importers);
-    std::string entry_point = initializers.entry_point();
-    if (!entry_point.empty()) {
-      std::string result(add_file(entry_point, true));
-      if (result.empty()) {
-        throw "File to read not found or unreadable: " + entry_point;
-      }
-    }
 
-    emitter.set_filename(resolve_relative_path(output_path, source_map_file, cwd));
+    emitter.set_filename(abs2rel(output_path, source_map_file, CWD));
 
   }
 
@@ -142,16 +134,35 @@ namespace Sass {
 
   Context::~Context()
   {
-    // make sure we free the source even if not processed!
-    if (sources.size() == 0 && source_c_str) free(source_c_str);
-    // sources are allocated by strdup or malloc (overtaken from C code)
-    for (size_t i = 0; i < sources.size(); ++i) free(sources[i]);
+    // resources were allocated by strdup or malloc
+    for (size_t i = 0; i < resources.size(); ++i) {
+      free(resources[i].contents);
+      free(resources[i].srcmap);
+    }
     // free all strings we kept alive during compiler execution
     for (size_t n = 0; n < strings.size(); ++n) free(strings[n]);
     // everything that gets put into sources will be freed by us
-    for (size_t m = 0; m < import_stack.size(); ++m) sass_delete_import(import_stack[m]);
+    // this shouldn't have anything in it anyway!?
+    for (size_t m = 0; m < import_stack.size(); ++m) {
+      sass_import_take_source(import_stack[m]);
+      sass_import_take_srcmap(import_stack[m]);
+      sass_delete_import(import_stack[m]);
+    }
     // clear inner structures (vectors) and input source
-    sources.clear(); import_stack.clear(); source_c_str = 0;
+    resources.clear(); import_stack.clear();
+  }
+
+  Data_Context::~Data_Context()
+  {
+    // --> this will be freed by resources
+    // make sure we free the source even if not processed!
+    // if (resources.size() == 0 && source_c_str) free(source_c_str);
+    // if (resources.size() == 0 && srcmap_c_str) free(srcmap_c_str);
+    // source_c_str = 0; srcmap_c_str = 0;
+  }
+
+  File_Context::~File_Context()
+  {
   }
 
   void Context::collect_include_paths(const char* paths_str)
@@ -181,10 +192,9 @@ namespace Sass {
 
   void Context::collect_include_paths(const char** paths_array)
   {
-    if (paths_array) {
-      for (size_t i = 0; paths_array[i]; i++) {
-        collect_include_paths(paths_array[i]);
-      }
+    if (!paths_array) return;
+    for (size_t i = 0; paths_array[i]; i++) {
+      collect_include_paths(paths_array[i]);
     }
   }
 
@@ -215,70 +225,255 @@ namespace Sass {
 
   void Context::collect_plugin_paths(const char** paths_array)
   {
-    if (paths_array) {
-      for (size_t i = 0; paths_array[i]; i++) {
-        collect_plugin_paths(paths_array[i]);
-      }
+    if (!paths_array) return;
+    for (size_t i = 0; paths_array[i]; i++) {
+      collect_plugin_paths(paths_array[i]);
     }
   }
-  void Context::add_source(std::string load_path, std::string abs_path, char* contents)
+
+
+  // resolve the imp_path in base_path or include_paths
+  // looks for alternatives and returns a list from one directory
+  std::vector<Include> Context::find_includes(const Importer& import)
   {
-    sources.push_back(contents);
-    included_files.push_back(abs_path);
-    queue.push_back(Sass_Queued(load_path, abs_path, contents));
-    emitter.add_source_index(sources.size() - 1);
-    include_links.push_back(resolve_relative_path(abs_path, source_map_file, cwd));
+    // make sure we resolve against an absolute path
+    std::string base_path(rel2abs(import.base_path));
+    // first try to resolve the load path relative to the base path
+    std::vector<Include> vec(resolve_includes(base_path, import.imp_path));
+    // then search in every include path (but only if nothing found yet)
+    for (size_t i = 0, S = include_paths.size(); vec.size() == 0 && i < S; ++i)
+    {
+      // call resolve_includes and individual base path and append all results
+      std::vector<Include> resolved(resolve_includes(include_paths[i], import.imp_path));
+      if (resolved.size()) vec.insert(vec.end(), resolved.begin(), resolved.end());
+    }
+    // return vector
+    return vec;
   }
 
-  // Add a new import file to the context
-  std::string Context::add_file(const std::string& file, bool delay)
+
+  // register include with resolved path and its content
+  // memory of the resources will be freed by us on exit
+  void Context::register_resource(const Include& inc, const Resource& res)
   {
-    using namespace File;
-    std::string path(make_canonical_path(file));
-    std::string resolved(find_file(path, include_paths));
-    if (resolved == "") return resolved;
-    if (char* contents = read_file(resolved)) {
-      add_source(path, resolved, contents);
-      style_sheets[path] = 0;
-      if (delay == false) {
-        size_t i = queue.size() - 1;
-        process_queue_entry(queue[i], i);
-      }
-      return path;
-    }
-    return std::string("");
+
+    // do not parse same resource twice
+    // maybe raise an error in this case
+    // if (sheets.count(inc.abs_path)) {
+    //   free(res.contents); free(res.srcmap);
+    //   throw std::runtime_error("duplicate resource registered");
+    //   return;
+    // }
+
+    // get index for this resource
+    size_t idx = resources.size();
+
+    // tell emitter about new resource
+    emitter.add_source_index(idx);
+
+    // put resources under our control
+    // the memory will be freed later
+    resources.push_back(res);
+
+    // add a relative link to the working directory
+    included_files.push_back(inc.abs_path);
+    // add a relative link  to the source map output file
+    srcmap_links.push_back(abs2rel(inc.abs_path, source_map_file, CWD));
+
+    // get pointer to the loaded content
+    Sass_Import_Entry import = sass_make_import(
+      inc.imp_path.c_str(),
+      inc.abs_path.c_str(),
+      res.contents,
+      res.srcmap
+    );
+    // add the entry to the stack
+    import_stack.push_back(import);
+
+    // get pointer to the loaded content
+    const char* contents = resources[idx].contents;
+    // keep a copy of the path around (for parserstates)
+    // ToDo: we clean it, but still not very elegant!?
+    strings.push_back(sass_strdup(inc.abs_path.c_str()));
+    // create the initial parser state from resource
+    ParserState pstate(strings.back(), contents, idx);
+    // create a parser instance from the given c_str buffer
+    Parser p(Parser::from_c_str(contents, *this, pstate));
+    // do not yet dispose these buffers
+    sass_import_take_source(import);
+    sass_import_take_srcmap(import);
+    // then parse the root block
+    Block* root = p.parse();
+    // delete memory of current stack frame
+    sass_delete_import(import_stack.back());
+    // remove current stack frame
+    import_stack.pop_back();
+    // create key/value pair for ast node
+    std::pair<const std::string, const StyleSheet>
+      ast_pair(inc.abs_path, { res, root });
+    // register resulting resource
+    sheets.insert(ast_pair);
+
   }
 
-  // Add a new import file to the context
-  // This has some previous directory context
-  std::string Context::add_file(const std::string& base, const std::string& file, ParserState pstate)
+  // Add a new import to the context (called from `import_url`)
+  Include Context::load_import(const Importer& imp, ParserState pstate)
   {
-    using namespace File;
-    std::string path(make_canonical_path(file));
-    std::string base_file(join_paths(base, path));
-    if (style_sheets.count(base_file)) return base_file;
-    std::vector<Sass_Queued> resolved(resolve_file(base, path));
+
+    // search for valid imports (ie. partials) on the filesystem
+    // this may return more than one valid result (ambiguous imp_path)
+    const std::vector<Include> resolved(find_includes(imp));
+
+    // error nicely on ambiguous imp_path
     if (resolved.size() > 1) {
       std::stringstream msg_stream;
       msg_stream << "It's not clear which file to import for ";
-      msg_stream << "'@import \"" << file << "\"'." << "\n";
+      msg_stream << "'@import \"" << imp.imp_path << "\"'." << "\n";
       msg_stream << "Candidates:" << "\n";
       for (size_t i = 0, L = resolved.size(); i < L; ++i)
-      { msg_stream << "  " << resolved[i].load_path << "\n"; }
+      { msg_stream << "  " << resolved[i].imp_path << "\n"; }
       msg_stream << "Please delete or rename all but one of these files." << "\n";
       error(msg_stream.str(), pstate);
     }
-    if (resolved.size()) {
+
+    // process the resolved entry
+    else if (resolved.size() == 1) {
+      // use cache for the resource loading
+      if (sheets.count(resolved[0].abs_path)) return resolved[0];
+      // try to read the content of the resolved file entry
+      // the memory buffer returned must be freed by us!
       if (char* contents = read_file(resolved[0].abs_path)) {
-        add_source(base_file, resolved[0].abs_path, contents);
-        style_sheets[base_file] = 0;
-        size_t i = queue.size() - 1;
-        process_queue_entry(queue[i], i);
-        return base_file;
+        // register the newly resolved file resource
+        register_resource(resolved[0], { contents, 0 });
+        // return resolved entry
+        return resolved[0];
+      }
+    }
+
+    // nothing found
+    return { imp, "" };
+
+  }
+
+  void Context::import_url (Import* imp, std::string load_path, const std::string& ctx_path) {
+
+    ParserState pstate(imp->pstate());
+    std::string imp_path(unquote(load_path));
+    std::string protocol("file");
+
+    using namespace Prelexer;
+    if (const char* proto = sequence< identifier, exactly<':'>, exactly<'/'>, exactly<'/'> >(imp_path.c_str())) {
+
+      protocol = std::string(imp_path.c_str(), proto - 3);
+      // std::cerr << "==================== " << protocol << "\n";
+      if (protocol.compare("file") && true) {
+
+      }
+    }
+
+    // add urls (protocol other than file) and urls without procotol to `urls` member
+    // ToDo: if ctx_path is already a file resource, we should not add it here?
+    if (imp->media_queries() || protocol != "file" || imp_path.substr(0, 2) == "//") {
+      imp->urls().push_back(SASS_MEMORY_NEW(mem, String_Quoted, imp->pstate(), load_path));
+    }
+    else if (imp_path.length() > 4 && imp_path.substr(imp_path.length() - 4, 4) == ".css") {
+      String_Constant* loc = SASS_MEMORY_NEW(mem, String_Constant, pstate, unquote(load_path));
+      Argument* loc_arg = SASS_MEMORY_NEW(mem, Argument, pstate, loc);
+      Arguments* loc_args = SASS_MEMORY_NEW(mem, Arguments, pstate);
+      (*loc_args) << loc_arg;
+      Function_Call* new_url = SASS_MEMORY_NEW(mem, Function_Call, pstate, "url", loc_args);
+      imp->urls().push_back(new_url);
+    }
+    else {
+      const Importer importer(imp_path, ctx_path);
+      Include include(load_import(importer, pstate));
+      if (include.abs_path.empty()) {
+        error("File to import not found or unreadable: " + imp_path + "\nParent style sheet: " + ctx_path, pstate);
+      }
+      imp->incs().push_back(include);
+    }
+
+  }
+
+
+  // call custom importers on the given (unquoted) load_path and eventually parse the resulting style_sheet
+  bool Context::call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
+  {
+    // unique counter
+    size_t count = 0;
+    // need one correct import
+    bool has_import = false;
+    // process all custom importers (or custom headers)
+    for (Sass_Importer_Entry& importer : importers) {
+      // int priority = sass_importer_get_priority(importer);
+      Sass_Importer_Fn fn = sass_importer_get_function(importer);
+      // skip importer if it returns NULL
+      if (Sass_Import_List includes =
+          fn(load_path.c_str(), importer, c_compiler)
+      ) {
+        // get c pointer copy to iterate over
+        Sass_Import_List it_includes = includes;
+        while (*it_includes) { ++count;
+          // create unique path to use as key
+          std::string uniq_path = load_path;
+          if (!only_one && count) {
+            std::stringstream path_strm;
+            path_strm << uniq_path << ":" << count;
+            uniq_path = path_strm.str();
+          }
+          // create the importer struct
+          Importer importer(uniq_path, ctx_path);
+          // query data from the current include
+          Sass_Import_Entry include = *it_includes;
+          char* source = sass_import_take_source(include);
+          char* srcmap = sass_import_take_source(include);
+          size_t line = sass_import_get_error_line(include);
+          size_t column = sass_import_get_error_column(include);
+          const char *abs_path = sass_import_get_abs_path(include);
+          // handle error message passed back from custom importer
+          // it may (or may not) override the line and column info
+          if (const char* err_message = sass_import_get_error_message(include)) {
+            if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap });
+            if (line == std::string::npos && column == std::string::npos) error(err_message, pstate);
+            else error(err_message, ParserState(ctx_path, source, Position(line, column)));
+          }
+          // content for import was set
+          else if (source) {
+            // resolved abs_path should be set by custom importer
+            // use the created uniq_path as fallback (maybe enforce)
+            std::string path_key(abs_path ? abs_path : uniq_path);
+            // create the importer struct
+            Include include(importer, path_key);
+            // attach information to AST node
+            imp->incs().push_back(include);
+            // register the resource buffers
+            register_resource(include, { source, srcmap });
+          }
+          // only a path was retuned
+          // try to load it like normal
+          else if(abs_path) {
+            // checks some urls to preserve
+            // `http://`, `https://` and `//`
+            // or dispatchs to `import_file`
+            // which will check for a `.css` extension
+            // or resolves the file on the filesystem
+            // added and resolved via `add_file`
+            // finally stores everything on `imp`
+            import_url(imp, abs_path, ctx_path);
+          }
+          // move to next
+          ++it_includes;
+        }
+        // deallocate the returned memory
+        sass_delete_import_list(includes);
+        // set success flag
+        has_import = true;
+        // break out of loop
+        if (only_one) break;
       }
     }
-    // now go the regular code path
-    return add_file(path);
+    // return result
+    return has_import;
   }
 
   void register_function(Context&, Signature sig, Native_Function f, Env* env);
@@ -288,53 +483,148 @@ namespace Sass {
   void register_c_functions(Context&, Env* env, Sass_Function_List);
   void register_c_function(Context&, Env* env, Sass_Function_Entry);
 
-  char* Context::compile_block(Block* root)
+  char* Context::render(Block* root)
   {
+    // check for valid block
     if (!root) return 0;
+    // start the render process
     root->perform(&emitter);
+    // finish emitter stream
     emitter.finalize();
+    // get the resulting buffer from stream
     OutputBuffer emitted = emitter.get_buffer();
-    std::string output = emitted.buffer;
-    if (!omit_source_map_url) {
-      if (source_map_embed) {
-       output += linefeed + format_embedded_source_map();
+    // should we append a source map url?
+    if (!c_options->omit_source_map_url) {
+      // generate an embeded source map
+      if (c_options->source_map_embed) {
+        emitted.buffer += linefeed;
+        emitted.buffer += format_embedded_source_map();
       }
+      // or just link the generated one
       else if (source_map_file != "") {
-        output += linefeed + format_source_mapping_url(source_map_file);
+        emitted.buffer += linefeed;
+        emitted.buffer += format_source_mapping_url(source_map_file);
       }
     }
-    return sass_strdup(output.c_str());
+    // create a copy of the resulting buffer string
+    // this must be freed or taken over by implementor
+    return sass_strdup(emitted.buffer.c_str());
   }
 
-  void Context::process_queue_entry(Sass_Queued& entry, size_t i)
+  void Context::apply_custom_headers(Block* root, const char* ctx_path, ParserState pstate)
   {
-    if (style_sheets[queue[i].load_path]) return;
+    // create a custom import to resolve headers
+    Import* imp = SASS_MEMORY_NEW(mem, Import, pstate);
+    // dispatch headers which will add custom functions
+    // custom headers are added to the import instance
+    call_headers(entry_path, ctx_path, pstate, imp);
+    // increase head count to skip later
+    head_imports += resources.size() - 1;
+    // add the statement if we have urls
+    if (!imp->urls().empty()) (*root) << imp;
+    // process all other resources (add Import_Stub nodes)
+    for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {
+      (*root) << SASS_MEMORY_NEW(mem, Import_Stub, pstate, imp->incs()[i]);
+    }
+  }
+
+  Block* File_Context::parse()
+  {
+
+    // check if entry file is given
+    if (input_path.empty()) return 0;
+
+    // create absolute path from input filename
+    // ToDo: this should be resolved via custom importers
+    std::string abs_path(rel2abs(input_path, CWD));
+
+    // try to load the entry file
+    char* contents = read_file(abs_path);
+
+    // alternatively also look inside each include path folder
+    // I think this differs from ruby sass (IMO too late to remove)
+    for (size_t i = 0, S = include_paths.size(); contents == 0 && i < S; ++i) {
+      // build absolute path for this include path entry
+      abs_path = rel2abs(input_path, include_paths[i]);
+      // try to load the resulting path
+      contents = read_file(abs_path);
+    }
+
+    // abort early if no content could be loaded (various reasons)
+    if (!contents) throw "File to read not found or unreadable: " + input_path;
+
+    // store entry path
+    entry_path = abs_path;
+
+    // create entry only for import stack
     Sass_Import_Entry import = sass_make_import(
-      queue[i].load_path.c_str(),
-      queue[i].abs_path.c_str(),
-      0, 0
+      input_path.c_str(),
+      entry_path.c_str(),
+      contents,
+      0
     );
+    // add the entry to the stack
     import_stack.push_back(import);
-    // keep a copy of the path around (for parser states)
-    strings.push_back(sass_strdup(queue[i].abs_path.c_str()));
-    ParserState pstate(strings.back(), queue[i].source, i);
-    Parser p(Parser::from_c_str(queue[i].source, *this, pstate));
-    Block* ast = p.parse();
-    sass_delete_import(import_stack.back());
-    import_stack.pop_back();
-    // ToDo: we store by load_path, which can lead
-    // to duplicates if importer reports the same path
-    // Maybe we should add an error for duplicates!?
-    style_sheets[queue[i].load_path] = ast;
+
+    // create the source entry for file entry
+    register_resource({{ input_path, "." }, abs_path }, { contents, 0 });
+
+    // create root ast tree node
+    return compile();
+
   }
 
-  Block* Context::parse_file()
+  Block* Data_Context::parse()
   {
-    Block* root = 0;
-    for (size_t i = 0; i < queue.size(); ++i) {
-      process_queue_entry(queue[i], i);
-      if (i == 0) root = style_sheets[queue[i].load_path];
+
+    // check if source string is given
+    if (!source_c_str) return 0;
+
+    // convert indented sass syntax
+    if(c_options->is_indented_syntax_src) {
+      // call sass2scss to convert the string
+      char * converted = sass2scss(source_c_str,
+        // preserve the structure as much as possible
+        SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
+      // replace old source_c_str with converted
+      free(source_c_str); source_c_str = converted;
     }
+
+    // remember entry path (defaults to stdin for string)
+    entry_path = input_path.empty() ? "stdin" : input_path;
+
+    // ToDo: this may be resolved via custom importers
+    std::string abs_path(rel2abs(entry_path));
+    char* abs_path_c_str = sass_strdup(abs_path.c_str());
+    strings.push_back(abs_path_c_str);
+
+    // create entry only for the import stack
+    Sass_Import_Entry import = sass_make_import(
+      entry_path.c_str(),
+      abs_path_c_str,
+      source_c_str,
+      srcmap_c_str
+    );
+    // add the entry to the stack
+    import_stack.push_back(import);
+
+    // register a synthetic resource (path does not really exist, skip in includes)
+    register_resource({{ input_path, "." }, input_path }, { source_c_str, srcmap_c_str });
+
+    // create root ast tree node
+    return compile();
+  }
+
+
+
+  // parse root block from includes
+  Block* Context::compile()
+  {
+    // abort if there is no data
+    if (resources.size() == 0) return 0;
+    // get root block from the first style sheet
+    Block* root = sheets.at(entry_path).root;
+    // abort on invalid root
     if (root == 0) return 0;
 
     Env global; // create root environment
@@ -367,39 +657,11 @@ namespace Sass {
     // return processed tree
     return root;
   }
-  // EO parse_file
-
-  Block* Context::parse_string()
-  {
-    if (!source_c_str) return 0;
-    queue.clear();
-    if(is_indented_syntax_src) {
-      char * contents = sass2scss(source_c_str, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
-      add_source(input_path, input_path, contents);
-      free(source_c_str);
-      return parse_file();
-    }
-    add_source(input_path, input_path, source_c_str);
-    size_t idx = queue.size() - 1;
-    process_queue_entry(queue[idx], idx);
-    return parse_file();
-  }
-
-  char* Context::compile_file()
-  {
-    // returns NULL if something fails
-    return compile_block(parse_file());
-  }
-
-  char* Context::compile_string()
-  {
-    // returns NULL if something fails
-    return compile_block(parse_string());
-  }
+  // EO compile
 
   std::string Context::format_embedded_source_map()
   {
-    std::string map = emitter.generate_source_map(*this);
+    std::string map = emitter.render_srcmap(*this);
     std::istringstream is( map );
     std::ostringstream buffer;
     base64::encoder E;
@@ -411,15 +673,15 @@ namespace Sass {
 
   std::string Context::format_source_mapping_url(const std::string& file)
   {
-    std::string url = resolve_relative_path(file, output_path, cwd);
+    std::string url = abs2rel(file, output_path, CWD);
     return "/*# sourceMappingURL=" + url + " */";
   }
 
-  char* Context::generate_source_map()
+  char* Context::render_srcmap()
   {
     if (source_map_file == "") return 0;
     char* result = 0;
-    std::string map = emitter.generate_source_map(*this);
+    std::string map = emitter.render_srcmap(*this);
     result = sass_strdup(map.c_str());
     return result;
   }
@@ -429,7 +691,7 @@ namespace Sass {
   // we probably always want to skip the header includes?
   std::vector<std::string> Context::get_included_files(bool skip, size_t headers)
   {
-      // create a copy of the vector for manupulations
+      // create a copy of the vector for manipulations
       std::vector<std::string> includes = included_files;
       if (includes.size() == 0) return includes;
       if (skip) { includes.erase( includes.begin(), includes.begin() + 1 + headers); }
@@ -439,11 +701,6 @@ namespace Sass {
       return includes;
   }
 
-  std::string Context::get_cwd()
-  {
-    return Sass::File::get_cwd();
-  }
-
   void register_function(Context& ctx, Signature sig, Native_Function f, Env* env)
   {
     Definition* def = make_native_function(sig, f, ctx);