sassc 0.0.10 → 0.0.11

data/ext/libsass/eval.hpp

@@ -7,6 +7,8 @@
 #include "position.hpp"
 #include "operation.hpp"
 #include "environment.hpp"
+#include "contextualize.hpp"
+#include "listize.hpp"
 #include "sass_values.h"
 
 namespace Sass {
@@ -14,6 +16,8 @@ namespace Sass {
 
   typedef Environment<AST_Node*> Env;
   struct Backtrace;
+  class Contextualize;
+  class Listize;
 
   class Eval : public Operation_CRTP<Expression*, Eval> {
 
@@ -22,11 +26,14 @@ namespace Sass {
     Expression* fallback_impl(AST_Node* n);
 
   public:
+    Contextualize* contextualize;
+    Listize*   listize;
     Env*       env;
     Backtrace* backtrace;
-    Eval(Context&, Env*, Backtrace*);
+    Eval(Context&, Contextualize*, Listize*, Env*, Backtrace*);
     virtual ~Eval();
     Eval* with(Env* e, Backtrace* bt); // for setting the env before eval'ing an expression
+    Eval* with(Selector* c, Env* e, Backtrace* bt, Selector* placeholder = 0, Selector* extender = 0); // for setting the env before eval'ing an expression
     using Operation<Expression*>::operator();
 
     // for evaluating function bodies
@@ -62,6 +69,7 @@ namespace Sass {
     Expression* operator()(Argument*);
     Expression* operator()(Arguments*);
     Expression* operator()(Comment*);
+    Expression* operator()(Parent_Selector* p);
 
     template <typename U>
     Expression* fallback(U x) { return fallback_impl(x); }

data/ext/libsass/expand.cpp

@@ -4,7 +4,7 @@
 #include "expand.hpp"
 #include "bind.hpp"
 #include "eval.hpp"
-#include "contextualize.hpp"
+#include "contextualize_eval.hpp"
 #include "to_string.hpp"
 #include "backtrace.hpp"
 #include "context.hpp"
@@ -12,10 +12,10 @@
 
 namespace Sass {
 
-  Expand::Expand(Context& ctx, Eval* eval, Contextualize* contextualize, Env* env, Backtrace* bt)
+  Expand::Expand(Context& ctx, Eval* eval, Contextualize_Eval* contextualize_eval, Env* env, Backtrace* bt)
   : ctx(ctx),
     eval(eval),
-    contextualize(contextualize),
+    contextualize_eval(contextualize_eval),
     env(env),
     block_stack(vector<Block*>()),
     property_stack(vector<String*>()),
@@ -47,19 +47,15 @@ namespace Sass {
     if (in_keyframes) {
       To_String to_string;
       Keyframe_Rule* k = new (ctx.mem) Keyframe_Rule(r->pstate(), r->block()->perform(this)->block());
-      if (r->selector()) {
-        string s(r->selector()->perform(eval->with(env, backtrace))->perform(&to_string));
-        String_Constant* ss = new (ctx.mem) String_Constant(r->selector()->pstate(), s);
-        k->rules(ss);
-      }
+      if (r->selector()) k->selector(r->selector()->perform(contextualize_eval->with(0, env, backtrace)));
       in_at_root = old_in_at_root;
       old_in_at_root = false;
       return k;
     }
 
-    Contextualize* contextual = contextualize->with(selector_stack.back(), env, backtrace);
+    Contextualize_Eval* contextual = contextualize_eval->with(selector_stack.back(), env, backtrace);
     if (old_in_at_root && !r->selector()->has_reference())
-      contextual = contextualize->with(at_root_selector_stack.back(), env, backtrace);
+      contextual = contextualize_eval->with(at_root_selector_stack.back(), env, backtrace);
 
     Selector* sel_ctx = r->selector()->perform(contextual);
     if (sel_ctx == 0) throw "Cannot expand null selector";
@@ -188,7 +184,7 @@ namespace Sass {
     Block* ab = a->block();
     Selector* as = a->selector();
     Expression* av = a->value();
-    if (as) as = as->perform(contextualize->with(0, env, backtrace));
+    if (as) as = as->perform(contextualize_eval->with(0, env, backtrace));
     else if (av) av = av->perform(eval->with(env, backtrace));
     Block* bb = ab ? ab->perform(this)->block() : 0;
     At_Rule* aa = new (ctx.mem) At_Rule(a->pstate(),
@@ -204,10 +200,9 @@ namespace Sass {
   {
     String* old_p = d->property();
     String* new_p = static_cast<String*>(old_p->perform(eval->with(env, backtrace)));
-    Expression* value = d->value()->perform(eval->with(env, backtrace));
-
+    Selector* p = selector_stack.size() <= 1 ? 0 : selector_stack.back();
+    Expression* value = d->value()->perform(eval->with(p, env, backtrace));
     if (value->is_invisible() && !d->is_important()) return 0;
-
     Declaration* decl = new (ctx.mem) Declaration(d->pstate(),
                                                   new_p,
                                                   value,
@@ -219,12 +214,60 @@ namespace Sass {
   Statement* Expand::operator()(Assignment* a)
   {
     string var(a->variable());
-    if (env->has(var)) {
-      Expression* v = static_cast<Expression*>((*env)[var]);
-      if (!a->is_guarded() || v->concrete_type() == Expression::NULL_VAL) (*env)[var] = a->value()->perform(eval->with(env, backtrace));
+    Selector* p = selector_stack.size() <= 1 ? 0 : selector_stack.back();
+    if (a->is_global()) {
+      if (a->is_default()) {
+        if (env->has_global(var)) {
+          Expression* e = dynamic_cast<Expression*>(env->get_global(var));
+          if (!e || e->concrete_type() == Expression::NULL_VAL) {
+            env->set_global(var, a->value()->perform(eval->with(p, env, backtrace)));
+          }
+        }
+        else {
+          env->set_global(var, a->value()->perform(eval->with(p, env, backtrace)));
+        }
+      }
+      else {
+        env->set_global(var, a->value()->perform(eval->with(p, env, backtrace)));
+      }
+    }
+    else if (a->is_default()) {
+      if (env->has_lexical(var)) {
+        auto cur = env;
+        while (cur && cur->is_lexical()) {
+          if (cur->has_local(var)) {
+            if (AST_Node* node = cur->get_local(var)) {
+              Expression* e = dynamic_cast<Expression*>(node);
+              if (!e || e->concrete_type() == Expression::NULL_VAL) {
+                cur->set_local(var, a->value()->perform(eval->with(p, env, backtrace)));
+              }
+            }
+            else {
+              throw runtime_error("Env not in sync");
+            }
+            return 0;
+          }
+          cur = cur->parent();
+        }
+        throw runtime_error("Env not in sync");
+      }
+      else if (env->has_global(var)) {
+        if (AST_Node* node = env->get_global(var)) {
+          Expression* e = dynamic_cast<Expression*>(node);
+          if (!e || e->concrete_type() == Expression::NULL_VAL) {
+            env->set_global(var, a->value()->perform(eval->with(p, env, backtrace)));
+          }
+        }
+      }
+      else if (env->is_lexical()) {
+        env->set_local(var, a->value()->perform(eval->with(p, env, backtrace)));
+      }
+      else {
+        env->set_local(var, a->value()->perform(eval->with(p, env, backtrace)));
+      }
     }
     else {
-      env->current_frame()[var] = a->value()->perform(eval->with(env, backtrace));
+      env->set_lexical(var, a->value()->perform(eval->with(p, env, backtrace)));
     }
     return 0;
   }
@@ -283,6 +326,8 @@ namespace Sass {
     return 0;
   }
 
+  // For does not create a new env scope
+  // But iteration vars are reset afterwards
   Statement* Expand::operator()(For* f)
   {
     string variable(f->variable());
@@ -294,32 +339,49 @@ namespace Sass {
     if (high->concrete_type() != Expression::NUMBER) {
       error("upper bound of `@for` directive must be numeric", high->pstate(), backtrace);
     }
-    double start = static_cast<Number*>(low)->value();
-    double end = static_cast<Number*>(high)->value();
-    Env new_env;
-    new_env[variable] = new (ctx.mem) Number(low->pstate(), start);
-    new_env.link(env);
-    env = &new_env;
+    Number* sass_start = static_cast<Number*>(low);
+    Number* sass_end = static_cast<Number*>(high);
+    // check if units are valid for sequence
+    if (sass_start->unit() != sass_end->unit()) {
+      stringstream msg; msg << "Incompatible units: '"
+        << sass_start->unit() << "' and '"
+        << sass_end->unit() << "'.";
+      error(msg.str(), low->pstate(), backtrace);
+    }
+    double start = sass_start->value();
+    double end = sass_end->value();
+    // only create iterator once in this environment
+    Number* it = new (env->mem) Number(low->pstate(), start, sass_end->unit());
+    AST_Node* old_var = env->has_local(variable) ? env->get_local(variable) : 0;
+    env->set_local(variable, it);
     Block* body = f->block();
     if (start < end) {
       if (f->is_inclusive()) ++end;
       for (double i = start;
            i < end;
-           (*env)[variable] = new (ctx.mem) Number(low->pstate(), ++i)) {
+           ++i) {
+        it->value(i);
+        env->set_local(variable, it);
         append_block(body);
       }
     } else {
       if (f->is_inclusive()) --end;
       for (double i = start;
            i > end;
-           (*env)[variable] = new (ctx.mem) Number(low->pstate(), --i)) {
+           --i) {
+        it->value(i);
+        env->set_local(variable, it);
         append_block(body);
       }
     }
-    env = new_env.parent();
+    // restore original environment
+    if (!old_var) env->del_local(variable);
+    else env->set_local(variable, old_var);
     return 0;
   }
 
+  // Eval does not create a new env scope
+  // But iteration vars are reset afterwards
   Statement* Expand::operator()(Each* e)
   {
     vector<string> variables(e->variables());
@@ -336,10 +398,12 @@ namespace Sass {
     else {
       list = static_cast<List*>(expr);
     }
-    Env new_env;
-    for (size_t i = 0, L = variables.size(); i < L; ++i) new_env[variables[i]] = 0;
-    new_env.link(env);
-    env = &new_env;
+    // remember variables and then reset them
+    vector<AST_Node*> old_vars(variables.size());
+    for (size_t i = 0, L = variables.size(); i < L; ++i) {
+      old_vars[i] = env->has_local(variables[i]) ? env->get_local(variables[i]) : 0;
+      env->set_local(variables[i], 0);
+    }
     Block* body = e->block();
 
     if (map) {
@@ -351,10 +415,10 @@ namespace Sass {
           List* variable = new (ctx.mem) List(map->pstate(), 2, List::SPACE);
           *variable << k;
           *variable << v;
-          (*env)[variables[0]] = variable;
+          env->set_local(variables[0], variable);
         } else {
-          (*env)[variables[0]] = k;
-          (*env)[variables[1]] = v;
+          env->set_local(variables[0], k);
+          env->set_local(variables[1], v);
         }
         append_block(body);
       }
@@ -371,16 +435,20 @@ namespace Sass {
         }
         for (size_t j = 0, K = variables.size(); j < K; ++j) {
           if (j < variable->length()) {
-            (*env)[variables[j]] = (*variable)[j]->perform(eval->with(env, backtrace));
+            env->set_local(variables[j], (*variable)[j]->perform(eval->with(env, backtrace)));
           }
           else {
-            (*env)[variables[j]] = new (ctx.mem) Null(expr->pstate());
+            env->set_local(variables[j], new (ctx.mem) Null(expr->pstate()));
           }
         }
         append_block(body);
       }
     }
-    env = new_env.parent();
+    // restore original environment
+    for (size_t j = 0, K = variables.size(); j < K; ++j) {
+      if(!old_vars[j]) env->del_local(variables[j]);
+      else env->set_local(variables[j], old_vars[j]);
+    }
     return 0;
   }
 
@@ -405,26 +473,29 @@ namespace Sass {
     To_String to_string(&ctx);
     Selector_List* extender = static_cast<Selector_List*>(selector_stack.back());
     if (!extender) return 0;
-    Selector_List* org_extendee = static_cast<Selector_List*>(e->selector());
-    Selector_List* extendee = static_cast<Selector_List*>(org_extendee->perform(contextualize->with(0, env, backtrace)));
-    if (extendee->length() != 1) {
-      error("selector groups may not be extended", extendee->pstate(), backtrace);
-    }
-    Complex_Selector* c = (*extendee)[0];
-    if (!c->head() || c->tail()) {
-      error("nested selectors may not be extended", c->pstate(), backtrace);
-    }
-    Compound_Selector* s = c->head();
-    s->is_optional(org_extendee->is_optional());
-    // // need to convert the compound selector into a by-value data structure
-    // vector<string> target_vec;
-    // for (size_t i = 0, L = s->length(); i < L; ++i)
-    // { target_vec.push_back((*s)[i]->perform(&to_string)); }
-
-    for (size_t i = 0, L = extender->length(); i < L; ++i) {
-      // let's test this out
-      // cerr << "REGISTERING EXTENSION REQUEST: " << (*extender)[i]->perform(&to_string) << " <- " << s->perform(&to_string) << endl;
-      ctx.subset_map.put(s->to_str_vec(), make_pair((*extender)[i], s));
+    Contextualize_Eval* eval = contextualize_eval->with(0, env, backtrace);
+    Selector_List* selector_list = static_cast<Selector_List*>(e->selector());
+    Selector_List* contextualized = static_cast<Selector_List*>(selector_list->perform(eval));
+    // ToDo: remove once feature proves stable!
+    // if (contextualized->length() != 1) {
+    //   error("selector groups may not be extended", extendee->pstate(), backtrace);
+    // }
+    for (auto complex_sel : contextualized->elements()) {
+      Complex_Selector* c = complex_sel;
+      if (!c->head() || c->tail()) {
+        error("nested selectors may not be extended", c->pstate(), backtrace);
+      }
+      Compound_Selector* compound_sel = c->head();
+      compound_sel->is_optional(selector_list->is_optional());
+      // // need to convert the compound selector into a by-value data structure
+      // vector<string> target_vec;
+      // for (size_t i = 0, L = compound_sel->length(); i < L; ++i)
+      // { target_vec.push_back((*compound_sel)[i]->perform(&to_string)); }
+      for (size_t i = 0, L = extender->length(); i < L; ++i) {
+        // let's test this out
+        // cerr << "REGISTERING EXTENSION REQUEST: " << (*extender)[i]->perform(&to_string) << " <- " << compound_sel->perform(&to_string) << endl;
+        ctx.subset_map.put(compound_sel->to_str_vec(), make_pair((*extender)[i], compound_sel));
+      }
     }
     return 0;
   }
@@ -432,7 +503,7 @@ namespace Sass {
   Statement* Expand::operator()(Definition* d)
   {
     Definition* dd = new (ctx.mem) Definition(*d);
-    env->current_frame()[d->name() +
+    env->local_frame()[d->name() +
                         (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd;
     // set the static link so we can have lexical scoping
     dd->environment(env);
@@ -448,8 +519,10 @@ namespace Sass {
     Definition* def = static_cast<Definition*>((*env)[full_name]);
     Block* body = def->block();
     Parameters* params = def->parameters();
+    Selector* p = selector_stack.size() <= 1 ? 0 : selector_stack.back();
+
     Arguments* args = static_cast<Arguments*>(c->arguments()
-                                               ->perform(eval->with(env, backtrace)));
+                                               ->perform(eval->with(p, env, backtrace)));
     Backtrace here(backtrace, c->pstate(), ", in mixin `" + c->name() + "`");
     backtrace = &here;
     Env new_env;
@@ -460,9 +533,10 @@ namespace Sass {
                                                    "@content",
                                                    new (ctx.mem) Parameters(c->pstate()),
                                                    c->block(),
+                                                   &ctx,
                                                    Definition::MIXIN);
       thunk->environment(env);
-      new_env.current_frame()["@content[m]"] = thunk;
+      new_env.local_frame()["@content[m]"] = thunk;
     }
     bind("mixin " + c->name(), params, args, ctx, &new_env, eval);
     Env* old_env = env;

data/ext/libsass/expand.hpp

@@ -14,6 +14,9 @@
 namespace Sass {
   using namespace std;
 
+  class Context;
+  class Eval;
+  class Contextualize_Eval;
   typedef Environment<AST_Node*> Env;
   struct Backtrace;
 
@@ -21,7 +24,7 @@ namespace Sass {
 
     Context&          ctx;
     Eval*             eval;
-    Contextualize*    contextualize;
+    Contextualize_Eval*    contextualize_eval;
     Env*              env;
     vector<Block*>    block_stack;
     vector<String*>   property_stack;
@@ -34,7 +37,7 @@ namespace Sass {
     Statement* fallback_impl(AST_Node* n);
 
   public:
-    Expand(Context&, Eval*, Contextualize*, Env*, Backtrace*);
+    Expand(Context&, Eval*, Contextualize_Eval*, Env*, Backtrace*);
     virtual ~Expand() { }
 
     using Operation<Statement*>::operator();

data/ext/libsass/extend.cpp

@@ -517,14 +517,14 @@ namespace Sass {
         // had an extra source that the ruby version did not have. Without a failing test case, this is going to be extra hard to find. My
         // best guess at this point is that we're cloning an object somewhere and maintaining the sources when we shouldn't be. This is purely
         // a guess though.
-        int maxSpecificity = 0;
+        unsigned long maxSpecificity = 0;
         SourcesSet sources = pSeq1->sources();
 
         DEBUG_PRINTLN(TRIM, "TRIMASDF SEQ1: " << seq1)
         DEBUG_EXEC(TRIM, printSourcesSet(sources, ctx, "TRIMASDF SOURCES: "))
 
         for (SourcesSet::iterator sourcesSetIterator = sources.begin(), sourcesSetIteratorEnd = sources.end(); sourcesSetIterator != sourcesSetIteratorEnd; ++sourcesSetIterator) {
-           const Complex_Selector* const pCurrentSelector = *sourcesSetIterator;
+          const Complex_Selector* const pCurrentSelector = *sourcesSetIterator;
           maxSpecificity = max(maxSpecificity, pCurrentSelector->specificity());
         }
 
@@ -1679,9 +1679,11 @@ namespace Sass {
           // check if both selectors have the same media block parent
           if (ext.first->media_block() == pComplexSelector->media_block()) continue;
           To_String to_string(&ctx);
-          if (ext.second->media_block() && ext.second->media_block()->media_queries() &&
-              pComplexSelector->media_block() && pComplexSelector->media_block()->media_queries())
-          {
+          if (ext.second->media_block() == 0) continue;
+          if (pComplexSelector->media_block() &&
+              ext.second->media_block()->media_queries() &&
+              pComplexSelector->media_block()->media_queries()
+          ) {
             string query_left(ext.second->media_block()->media_queries()->perform(&to_string));
             string query_right(pComplexSelector->media_block()->media_queries()->perform(&to_string));
             if (query_left == query_right) continue;

data/ext/libsass/file.cpp

@@ -33,54 +33,55 @@ namespace Sass {
   namespace File {
     using namespace std;
 
+    // return the current directory
+    // always with forward slashes
     string get_cwd()
     {
       const size_t wd_len = 1024;
       char wd[wd_len];
       string cwd = getcwd(wd, wd_len);
-#ifdef _WIN32
-      //convert backslashes to forward slashes
-      replace(cwd.begin(), cwd.end(), '\\', '/');
-#endif
+      #ifdef _WIN32
+        //convert backslashes to forward slashes
+        replace(cwd.begin(), cwd.end(), '\\', '/');
+      #endif
       if (cwd[cwd.length() - 1] != '/') cwd += '/';
       return cwd;
     }
 
-    // no physical check on filesystem
-    // only a logical cleanup of a path
-    string make_canonical_path (string path)
+    // test if path exists and is a file
+    bool file_exists(const string& path)
     {
-
-      // declarations
-      size_t pos;
-
       #ifdef _WIN32
-        //convert backslashes to forward slashes
-        replace(path.begin(), path.end(), '\\', '/');
+        wstring wpath = UTF_8::convert_to_utf16(path);
+        DWORD dwAttrib = GetFileAttributesW(wpath.c_str());
+        return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
+               (!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)));
+      #else
+        struct stat st_buf;
+        return (stat (path.c_str(), &st_buf) == 0) &&
+               (!S_ISDIR (st_buf.st_mode));
       #endif
+    }
 
-      pos = 0; // remove all self references inside the path string
-      while((pos = path.find("/./", pos)) != string::npos) path.erase(pos, 2);
-
-      pos = 0; // remove all leading and trailing self references
-      while(path.length() > 1 && path.substr(0, 2) == "./") path.erase(0, 2);
-      while((pos = path.length()) > 1 && path.substr(pos - 2) == "/.") path.erase(pos - 2);
-
-      pos = 0; // collapse multiple delimiters into a single one
-      while((pos = path.find("//", pos)) != string::npos) path.erase(pos, 1);
-
-      return path;
-
+    // return if given path is absolute
+    // works with *nix and windows paths
+    bool is_absolute_path(const string& path)
+    {
+      #ifdef _WIN32
+        if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;
+      #endif
+      return path[0] == '/';
     }
 
-    size_t find_last_folder_separator(const string& path, size_t limit = string::npos)
+    // helper function to find the last directory seperator
+    inline size_t find_last_folder_separator(const string& path, size_t limit = string::npos)
     {
       size_t pos = string::npos;
       size_t pos_p = path.find_last_of('/', limit);
       #ifdef _WIN32
-      size_t pos_w = path.find_last_of('\\', limit);
+        size_t pos_w = path.find_last_of('\\', limit);
       #else
-      size_t pos_w = string::npos;
+        size_t pos_w = string::npos;
       #endif
       if (pos_p != string::npos && pos_w != string::npos) {
         pos = max(pos_p, pos_w);
@@ -94,26 +95,64 @@ namespace Sass {
       return pos;
     }
 
-    string base_name(string path)
+    // return only the directory part of path
+    string dir_name(const string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == string::npos) return path;
-      else                     return path.substr(pos+1);
+      if (pos == string::npos) return "";
+      else return path.substr(0, pos+1);
     }
 
-    string dir_name(string path)
+    // return only the filename part of path
+    string base_name(const string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == string::npos) return "";
-      else                     return path.substr(0, pos+1);
+      if (pos == string::npos) return path;
+      else return path.substr(pos+1);
+    }
+
+    // do a locigal clean up of the path
+    // no physical check on the filesystem
+    string make_canonical_path (string path)
+    {
+
+      // declarations
+      size_t pos;
+
+      #ifdef _WIN32
+        //convert backslashes to forward slashes
+        replace(path.begin(), path.end(), '\\', '/');
+      #endif
+
+      pos = 0; // remove all self references inside the path string
+      while((pos = path.find("/./", pos)) != string::npos) path.erase(pos, 2);
+
+      pos = 0; // remove all leading and trailing self references
+      while(path.length() > 1 && path.substr(0, 2) == "./") path.erase(0, 2);
+      while((pos = path.length()) > 1 && path.substr(pos - 2) == "/.") path.erase(pos - 2);
+
+      pos = 0; // collapse multiple delimiters into a single one
+      while((pos = path.find("//", pos)) != string::npos) path.erase(pos, 1);
+
+      return path;
+
     }
 
+    // join two path segments cleanly together
+    // but only if right side is not absolute yet
     string join_paths(string l, string r)
     {
+
+      #ifdef _WIN32
+        // convert Windows backslashes to URL forward slashes
+        replace(l.begin(), l.end(), '\\', '/');
+        replace(r.begin(), r.end(), '\\', '/');
+      #endif
+
       if (l.empty()) return r;
       if (r.empty()) return l;
-      if (is_absolute_path(r)) return r;
 
+      if (is_absolute_path(r)) return r;
       if (l[l.length()-1] != '/') l += '/';
 
       while ((r.length() > 3) && ((r.substr(0, 3) == "../") || (r.substr(0, 3)) == "..\\")) {
@@ -125,27 +164,26 @@ namespace Sass {
       return l + r;
     }
 
-    bool is_absolute_path(const string& path)
-    {
-      if (path[0] == '/') return true;
-      // TODO: UN-HACKIFY THIS
-      #ifdef _WIN32
-      if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;
-      #endif
-      return false;
-    }
-
+    // create an absolute path by resolving relative paths with cwd
     string make_absolute_path(const string& path, const string& cwd)
     {
       return make_canonical_path((is_absolute_path(path) ? path : join_paths(cwd, path)));
     }
 
+    // create a path that is relative to the given base directory
+    // path and base will first be resolved against cwd to make them absolute
     string resolve_relative_path(const string& uri, const string& base, const string& cwd)
     {
 
       string absolute_uri = make_absolute_path(uri, cwd);
       string absolute_base = make_absolute_path(base, cwd);
 
+      #ifdef _WIN32
+        // absolute link must have a drive letter, and we know that we
+        // can only create relative links if both are on the same drive
+        if (absolute_base[0] != absolute_uri[0]) return absolute_uri;
+      #endif
+
       string stripped_uri = "";
       string stripped_base = "";
 
@@ -194,89 +232,104 @@ namespace Sass {
       return result;
     }
 
-    char* resolve_and_load(string path, string& real_path)
+    // Resolution order for ambiguous imports:
+    // (1) filename as given
+    // (2) underscore + given
+    // (3) underscore + given + extension
+    // (4) given + extension
+    string resolve_file(const string& filename)
     {
-      // Resolution order for ambiguous imports:
-      // (1) filename as given
-      // (2) underscore + given
-      // (3) underscore + given + extension
-      // (4) given + extension
-      char* contents = 0;
-      real_path = path;
-      vector<string> exts(3);
-      exts[0] = ".scss";
-      exts[1] = ".sass";
-      exts[2] = ".css";
-
-      // if the file isn't found with the given filename (1)
-      if (!(contents = read_file(real_path))) {
-        string dir(dir_name(path));
-        string base(base_name(path));
-        real_path = dir + base;
-        // (2) underscore + given
-        string test_path(dir + "_" + base);
-        if ((contents = read_file(test_path))) {
-          real_path = test_path;
-        }
-        // (3) underscore + given + extension
-        if (!contents) {
-          for(auto ext : exts) {
-            test_path = dir + "_" + base + ext;
-            if ((contents = read_file(test_path))) {
-              real_path = test_path;
-              break;
-            }
-          }
-        }
-        // (4) given + extension
-        if (!contents) {
-          for(auto ext : exts) {
-            test_path = dir + base + ext;
-            if ((contents = read_file(test_path))) {
-              real_path = test_path;
-              break;
-            }
-          }
-        }
+      // supported extensions
+      const vector<string> exts = {
+        ".scss", ".sass", ".css"
+      };
+      // split the filename
+      string base(dir_name(filename));
+      string name(base_name(filename));
+      // create full path (maybe relative)
+      string path(join_paths(base, name));
+      if (file_exists(path)) return path;
+      // next test variation with underscore
+      path = join_paths(base, "_" + name);
+      if (file_exists(path)) return path;
+      // next test exts plus underscore
+      for(auto ext : exts) {
+        path = join_paths(base, "_" + name + ext);
+        if (file_exists(path)) return path;
       }
-#ifdef _WIN32
-      // convert Windows backslashes to URL forward slashes
-      replace(real_path.begin(), real_path.end(), '\\', '/');
-#endif
-      return contents;
+      // next test plain name with exts
+      for(auto ext : exts) {
+        path = join_paths(base, name + ext);
+        if (file_exists(path)) return path;
+      }
+      // nothing found
+      return string("");
     }
 
-    char* read_file(string path)
+    // helper function to resolve a filename
+    string find_file(const string& file, const vector<string> paths)
     {
-#ifdef _WIN32
-      BYTE* pBuffer;
-      DWORD dwBytes;
-      // windows unicode filepaths are encoded in utf16
-      wstring wpath = UTF_8::convert_to_utf16(path);
-      HANDLE hFile = CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
-      if (hFile == INVALID_HANDLE_VALUE) return 0;
-      DWORD dwFileLength = GetFileSize(hFile, NULL);
-      if (dwFileLength == INVALID_FILE_SIZE) return 0;
-      pBuffer = new BYTE[dwFileLength + 1];
-      ReadFile(hFile, pBuffer, dwFileLength, &dwBytes, NULL);
-      pBuffer[dwFileLength] = '\0';
-      CloseHandle(hFile);
-      // just convert from unsigned char*
-      char* contents = (char*) pBuffer;
-#else
-      struct stat st;
-      if (stat(path.c_str(), &st) == -1 || S_ISDIR(st.st_mode)) return 0;
-      ifstream file(path.c_str(), ios::in | ios::binary | ios::ate);
-      char* contents = 0;
-      if (file.is_open()) {
-        size_t size = file.tellg();
-        contents = new char[size + 1]; // extra byte for the null char
-        file.seekg(0, ios::beg);
-        file.read(contents, size);
-        contents[size] = '\0';
-        file.close();
+      // search in every include path for a match
+      for (size_t i = 0, S = paths.size(); i < S; ++i)
+      {
+        string path(join_paths(paths[i], file));
+        string resolved(resolve_file(path));
+        if (resolved != "") return resolved;
       }
-#endif
+      // nothing found
+      return string("");
+    }
+
+    // inc paths can be directly passed from C code
+    string find_file(const string& file, const char* paths[])
+    {
+      if (paths == 0) return string("");
+      vector<string> includes(0);
+      // includes.push_back(".");
+      const char** it = paths;
+      while (it && *it) {
+        includes.push_back(*it);
+        ++it;
+      }
+      return find_file(file, includes);
+    }
+
+    // try to load the given filename
+    // returned memory must be freed
+    // will auto convert .sass files
+    char* read_file(const string& path)
+    {
+      #ifdef _WIN32
+        BYTE* pBuffer;
+        DWORD dwBytes;
+        // windows unicode filepaths are encoded in utf16
+        wstring wpath = UTF_8::convert_to_utf16(path);
+        HANDLE hFile = CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+        if (hFile == INVALID_HANDLE_VALUE) return 0;
+        DWORD dwFileLength = GetFileSize(hFile, NULL);
+        if (dwFileLength == INVALID_FILE_SIZE) return 0;
+        // allocate an extra byte for the null char
+        pBuffer = (BYTE*)malloc((dwFileLength+1)*sizeof(BYTE));
+        ReadFile(hFile, pBuffer, dwFileLength, &dwBytes, NULL);
+        pBuffer[dwFileLength] = '\0';
+        CloseHandle(hFile);
+        // just convert from unsigned char*
+        char* contents = (char*) pBuffer;
+      #else
+        struct stat st;
+        if (stat(path.c_str(), &st) == -1 || S_ISDIR(st.st_mode)) return 0;
+        ifstream file(path.c_str(), ios::in | ios::binary | ios::ate);
+        char* contents = 0;
+        if (file.is_open()) {
+          size_t size = file.tellg();
+          // allocate an extra byte for the null char
+          contents = (char*) malloc((size+1)*sizeof(char));
+          file.seekg(0, ios::beg);
+          file.read(contents, size);
+          contents[size] = '\0';
+          file.close();
+        }
+      #endif
       string extension;
       if (path.length() > 5) {
         extension = path.substr(path.length() - 5, 5);
@@ -285,7 +338,7 @@ namespace Sass {
         extension[i] = tolower(extension[i]);
       if (extension == ".sass" && contents != 0) {
         char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
-        delete[] contents; // free the indented contents
+        free(contents); // free the indented contents
         return converted; // should be freed by caller
       } else {
         return contents;