sassc 2.0.0 → 2.4.0

data/ext/libsass/src/file.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #ifdef _WIN32
 # ifdef __MINGW32__
 #  ifndef off64_t
@@ -10,9 +13,7 @@
 #else
 # include <unistd.h>
 #endif
-#include <iostream>
-#include <fstream>
-#include <cctype>
+#include <cstdio>
 #include <vector>
 #include <algorithm>
 #include <sys/stat.h>
@@ -21,6 +22,9 @@
 #include "prelexer.hpp"
 #include "utf8_string.hpp"
 #include "sass_functions.hpp"
+#include "error_handling.hpp"
+#include "util.hpp"
+#include "util_string.hpp"
 #include "sass2scss.h"
 
 #ifdef _WIN32
@@ -28,16 +32,16 @@
 
 # ifdef _MSC_VER
 # include <codecvt>
-inline static std::string wstring_to_string(const std::wstring& wstr)
+inline static Sass::sass::string wstring_to_string(const std::wstring& wstr)
 {
     std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> wchar_converter;
     return wchar_converter.to_bytes(wstr);
 }
 # else // mingw(/gcc) does not support C++11's codecvt yet.
-inline static std::string wstring_to_string(const std::wstring &wstr)
+inline static Sass::sass::string wstring_to_string(const std::wstring &wstr)
 {
     int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
-    std::string strTo(size_needed, 0);
+    Sass::sass::string strTo(size_needed, 0);
     WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
     return strTo;
 }
@@ -50,7 +54,7 @@ namespace Sass {
     // return the current directory
     // always with forward slashes
     // always with trailing slash
-    std::string get_cwd()
+    sass::string get_cwd()
     {
       const size_t wd_len = 4096;
       #ifndef _WIN32
@@ -59,12 +63,12 @@ namespace Sass {
         // we should check error for more detailed info (e.g. ENOENT)
         // http://man7.org/linux/man-pages/man2/getcwd.2.html#ERRORS
         if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
-        std::string cwd = pwd;
+        sass::string cwd = pwd;
       #else
         wchar_t wd[wd_len];
         wchar_t* pwd = _wgetcwd(wd, wd_len);
         if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
-        std::string cwd = wstring_to_string(pwd);
+        sass::string cwd = wstring_to_string(pwd);
         //convert backslashes to forward slashes
         replace(cwd.begin(), cwd.end(), '\\', '/');
       #endif
@@ -73,13 +77,16 @@ namespace Sass {
     }
 
     // test if path exists and is a file
-    bool file_exists(const std::string& path)
+    bool file_exists(const sass::string& path)
     {
       #ifdef _WIN32
         wchar_t resolved[32768];
         // windows unicode filepaths are encoded in utf16
-        std::string abspath(join_paths(get_cwd(), path));
-        std::wstring wpath(UTF_8::convert_to_utf16("\\\\?\\" + abspath));
+        sass::string abspath(join_paths(get_cwd(), path));
+        if (!(abspath[0] == '/' && abspath[1] == '/')) {
+          abspath = "//?/" + abspath;
+        }
+        std::wstring wpath(UTF_8::convert_to_utf16(abspath));
         std::replace(wpath.begin(), wpath.end(), '/', '\\');
         DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);
         if (rv > 32767) throw Exception::OperationError("Path is too long");
@@ -96,35 +103,35 @@ namespace Sass {
 
     // return if given path is absolute
     // works with *nix and windows paths
-    bool is_absolute_path(const std::string& path)
+    bool is_absolute_path(const sass::string& path)
     {
       #ifdef _WIN32
-        if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;
+        if (path.length() >= 2 && Util::ascii_isalpha(path[0]) && path[1] == ':') return true;
       #endif
       size_t i = 0;
       // check if we have a protocol
-      if (path[i] && Prelexer::is_alpha(path[i])) {
+      if (path[i] && Util::ascii_isalpha(static_cast<unsigned char>(path[i]))) {
         // skip over all alphanumeric characters
-        while (path[i] && Prelexer::is_alnum(path[i])) ++i;
+        while (path[i] && Util::ascii_isalnum(static_cast<unsigned char>(path[i]))) ++i;
         i = i && path[i] == ':' ? i + 1 : 0;
       }
       return path[i] == '/';
     }
 
-    // helper function to find the last directory seperator
-    inline size_t find_last_folder_separator(const std::string& path, size_t limit = std::string::npos)
+    // helper function to find the last directory separator
+    inline size_t find_last_folder_separator(const sass::string& path, size_t limit = sass::string::npos)
     {
       size_t pos;
       size_t pos_p = path.find_last_of('/', limit);
       #ifdef _WIN32
         size_t pos_w = path.find_last_of('\\', limit);
       #else
-        size_t pos_w = std::string::npos;
+        size_t pos_w = sass::string::npos;
       #endif
-      if (pos_p != std::string::npos && pos_w != std::string::npos) {
+      if (pos_p != sass::string::npos && pos_w != sass::string::npos) {
         pos = std::max(pos_p, pos_w);
       }
-      else if (pos_p != std::string::npos) {
+      else if (pos_p != sass::string::npos) {
         pos = pos_p;
       }
       else {
@@ -134,24 +141,24 @@ namespace Sass {
     }
 
     // return only the directory part of path
-    std::string dir_name(const std::string& path)
+    sass::string dir_name(const sass::string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == std::string::npos) return "";
+      if (pos == sass::string::npos) return "";
       else return path.substr(0, pos+1);
     }
 
     // return only the filename part of path
-    std::string base_name(const std::string& path)
+    sass::string base_name(const sass::string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == std::string::npos) return path;
+      if (pos == sass::string::npos) return path;
       else return path.substr(pos+1);
     }
 
     // do a logical clean up of the path
     // no physical check on the filesystem
-    std::string make_canonical_path (std::string path)
+    sass::string make_canonical_path (sass::string path)
     {
 
       // declarations
@@ -163,18 +170,18 @@ namespace Sass {
       #endif
 
       pos = 0; // remove all self references inside the path string
-      while((pos = path.find("/./", pos)) != std::string::npos) path.erase(pos, 2);
+      while((pos = path.find("/./", pos)) != sass::string::npos) path.erase(pos, 2);
 
       // 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);
+      while(path.size() >= 2 && path[0] == '.' && path[1] == '/') path.erase(0, 2);
+      while((pos = path.length()) > 1 && path[pos - 2] == '/' && path[pos - 1] == '.') path.erase(pos - 2);
 
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -183,7 +190,7 @@ namespace Sass {
       while (path[proto++] == '/') {}
 
       pos = proto; // collapse multiple delimiters into a single one
-      while((pos = path.find("//", pos)) != std::string::npos) path.erase(pos, 1);
+      while((pos = path.find("//", pos)) != sass::string::npos) path.erase(pos, 1);
 
       return path;
 
@@ -191,7 +198,7 @@ namespace Sass {
 
     // join two path segments cleanly together
     // but only if right side is not absolute yet
-    std::string join_paths(std::string l, std::string r)
+    sass::string join_paths(sass::string l, sass::string r)
     {
 
       #ifdef _WIN32
@@ -218,16 +225,16 @@ namespace Sass {
         bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\');
         bool is_self = pos + 3 == L && (l[pos+1] == '.');
         if (!is_self && !is_slash) r = r.substr(3);
-        else if (pos == std::string::npos) break;
-        l = l.substr(0, pos == std::string::npos ? pos : pos + 1);
+        else if (pos == sass::string::npos) break;
+        l = l.substr(0, pos == sass::string::npos ? pos : pos + 1);
       }
 
       return l + r;
     }
 
-    std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path)
+    sass::string path_for_console(const sass::string& rel_path, const sass::string& abs_path, const sass::string& orig_path)
     {
-      // magic algorith goes here!!
+      // magic algorithm goes here!!
 
       // if the file is outside this directory show the absolute path
       if (rel_path.substr(0, 3) == "../") {
@@ -238,24 +245,32 @@ namespace Sass {
     }
 
     // create an absolute path by resolving relative paths with cwd
-    std::string rel2abs(const std::string& path, const std::string& base, const std::string& cwd)
+    sass::string rel2abs(const sass::string& path, const sass::string& base, const sass::string& cwd)
     {
-      return make_canonical_path(join_paths(join_paths(cwd + "/", base + "/"), path));
+      sass::string rv = make_canonical_path(join_paths(join_paths(cwd + "/", base + "/"), path));
+      #ifdef _WIN32
+      // On windows we may get an absolute path without directory
+      // In that case we should prepend the directory from the root
+      if (rv[0] == '/' && rv[1] != '/') {
+        rv.insert(0, cwd, 0, 2);
+      }
+      #endif
+      return rv;
     }
 
     // create a path that is relative to the given base directory
     // path and base will first be resolved against cwd to make them absolute
-    std::string abs2rel(const std::string& path, const std::string& base, const std::string& cwd)
+    sass::string abs2rel(const sass::string& path, const sass::string& base, const sass::string& cwd)
     {
 
-      std::string abs_path = rel2abs(path, cwd);
-      std::string abs_base = rel2abs(base, cwd);
+      sass::string abs_path = rel2abs(path, cwd);
+      sass::string abs_base = rel2abs(base, cwd);
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -270,8 +285,8 @@ namespace Sass {
         if (abs_base[0] != abs_path[0]) return abs_path;
       #endif
 
-      std::string stripped_uri = "";
-      std::string stripped_base = "";
+      sass::string stripped_uri = "";
+      sass::string stripped_base = "";
 
       size_t index = 0;
       size_t minSize = std::min(abs_path.size(), abs_base.size());
@@ -281,7 +296,8 @@ namespace Sass {
         #else
           // compare the charactes in a case insensitive manner
           // windows fs is only case insensitive in ascii ranges
-          if (tolower(abs_path[i]) != tolower(abs_base[i])) break;
+          if (Util::ascii_tolower(static_cast<unsigned char>(abs_path[i])) !=
+              Util::ascii_tolower(static_cast<unsigned char>(abs_base[i]))) break;
         #endif
         if (abs_path[i] == '/') index = i + 1;
       }
@@ -309,7 +325,7 @@ namespace Sass {
         }
       }
 
-      std::string result = "";
+      sass::string result = "";
       for (size_t i = 0; i < directories; ++i) {
         result += "../";
       }
@@ -323,16 +339,18 @@ namespace Sass {
     // (2) underscore + given
     // (3) underscore + given + extension
     // (4) given + extension
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file, const std::vector<std::string>& exts)
+    // (5) given + _index.scss
+    // (6) given + _index.sass
+    sass::vector<Include> resolve_includes(const sass::string& root, const sass::string& file, const sass::vector<sass::string>& exts)
     {
-      std::string filename = join_paths(root, file);
+      sass::string filename = join_paths(root, file);
       // split the filename
-      std::string base(dir_name(file));
-      std::string name(base_name(file));
-      std::vector<Include> includes;
+      sass::string base(dir_name(file));
+      sass::string name(base_name(file));
+      sass::vector<Include> includes;
       // create full path (maybe relative)
-      std::string rel_path(join_paths(base, name));
-      std::string abs_path(join_paths(root, rel_path));
+      sass::string rel_path(join_paths(base, name));
+      sass::string abs_path(join_paths(root, rel_path));
       if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       // next test variation with underscore
       rel_path = join_paths(base, "_" + name);
@@ -350,28 +368,47 @@ namespace Sass {
         abs_path = join_paths(root, rel_path);
         if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       }
+      // index files
+      if (includes.size() == 0) {
+        // ignore directories that look like @import'able filename
+        for(auto ext : exts) {
+          if (ends_with(name, ext)) return includes;
+        }
+        // next test underscore index exts
+        for(auto ext : exts) {
+          rel_path = join_paths(base, join_paths(name, "_index" + ext));
+          abs_path = join_paths(root, rel_path);
+          if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
+        }
+        // next test plain index exts
+        for(auto ext : exts) {
+          rel_path = join_paths(base, join_paths(name, "index" + ext));
+          abs_path = join_paths(root, rel_path);
+          if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
+        }
+      }
       // nothing found
       return includes;
     }
 
-    std::vector<std::string> find_files(const std::string& file, const std::vector<std::string> paths)
+    sass::vector<sass::string> find_files(const sass::string& file, const sass::vector<sass::string> paths)
     {
-      std::vector<std::string> includes;
-      for (std::string path : paths) {
-        std::string abs_path(join_paths(path, file));
+      sass::vector<sass::string> includes;
+      for (sass::string path : paths) {
+        sass::string abs_path(join_paths(path, file));
         if (file_exists(abs_path)) includes.push_back(abs_path);
       }
       return includes;
     }
 
-    std::vector<std::string> find_files(const std::string& file, struct Sass_Compiler* compiler)
+    sass::vector<sass::string> find_files(const sass::string& file, struct Sass_Compiler* compiler)
     {
       // get the last import entry to get current base directory
       // struct Sass_Options* options = sass_compiler_get_options(compiler);
       Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
-      const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+      const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
       // create the vector with paths to lookup
-      std::vector<std::string> paths(1 + incs.size());
+      sass::vector<sass::string> paths(1 + incs.size());
       paths.push_back(dir_name(import->abs_path));
       paths.insert(paths.end(), incs.begin(), incs.end());
       // dispatch to find files in paths
@@ -380,7 +417,7 @@ namespace Sass {
 
     // helper function to search one file in all include paths
     // this is normally not used internally by libsass (C-API sugar)
-    std::string find_file(const std::string& file, const std::vector<std::string> paths)
+    sass::string find_file(const sass::string& file, const sass::vector<sass::string> paths)
     {
       if (file.empty()) return file;
       auto res = find_files(file, paths);
@@ -388,30 +425,33 @@ namespace Sass {
     }
 
     // helper function to resolve a filename
-    std::string find_include(const std::string& file, const std::vector<std::string> paths)
+    sass::string find_include(const sass::string& file, const sass::vector<sass::string> paths)
     {
       // search in every include path for a match
       for (size_t i = 0, S = paths.size(); i < S; ++i)
       {
-        std::vector<Include> resolved(resolve_includes(paths[i], file));
+        sass::vector<Include> resolved(resolve_includes(paths[i], file));
         if (resolved.size()) return resolved[0].abs_path;
       }
       // nothing found
-      return std::string("");
+      return sass::string("");
     }
 
     // try to load the given filename
     // returned memory must be freed
     // will auto convert .sass files
-    char* read_file(const std::string& path)
+    char* read_file(const sass::string& path)
     {
       #ifdef _WIN32
         BYTE* pBuffer;
         DWORD dwBytes;
         wchar_t resolved[32768];
         // windows unicode filepaths are encoded in utf16
-        std::string abspath(join_paths(get_cwd(), path));
-        std::wstring wpath(UTF_8::convert_to_utf16("\\\\?\\" + abspath));
+        sass::string abspath(join_paths(get_cwd(), path));
+        if (!(abspath[0] == '/' && abspath[1] == '/')) {
+          abspath = "//?/" + abspath;
+        }
+        std::wstring wpath(UTF_8::convert_to_utf16(abspath));
         std::replace(wpath.begin(), wpath.end(), '/', '\\');
         DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);
         if (rv > 32767) throw Exception::OperationError("Path is too long");
@@ -430,28 +470,34 @@ namespace Sass {
         // just convert from unsigned char*
         char* contents = (char*) pBuffer;
       #else
+        // Read the file using `<cstdio>` instead of `<fstream>` for better portability.
+        // The `<fstream>` header initializes `<locale>` and this buggy in GCC4/5 with static linking.
+        // See:
+        // https://www.spinics.net/lists/gcchelp/msg46851.html
+        // https://github.com/sass/sassc-ruby/issues/128
         struct stat st;
         if (stat(path.c_str(), &st) == -1 || S_ISDIR(st.st_mode)) return 0;
-        std::ifstream file(path.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
-        char* contents = 0;
-        if (file.is_open()) {
-          size_t size = file.tellg();
-          // allocate an extra byte for the null char
-          // and another one for edge-cases in lexer
-          contents = (char*) malloc((size+2)*sizeof(char));
-          file.seekg(0, std::ios::beg);
-          file.read(contents, size);
-          contents[size+0] = '\0';
-          contents[size+1] = '\0';
-          file.close();
+        FILE* fd = std::fopen(path.c_str(), "rb");
+        if (fd == nullptr) return nullptr;
+        const std::size_t size = st.st_size;
+        char* contents = static_cast<char*>(malloc(st.st_size + 2 * sizeof(char)));
+        if (std::fread(static_cast<void*>(contents), 1, size, fd) != size) {
+          free(contents);
+          std::fclose(fd);
+          return nullptr;
+        }
+        if (std::fclose(fd) != 0) {
+          free(contents);
+          return nullptr;
         }
+        contents[size] = '\0';
+        contents[size + 1] = '\0';
       #endif
-      std::string extension;
+      sass::string extension;
       if (path.length() > 5) {
         extension = path.substr(path.length() - 5, 5);
       }
-      for(size_t i=0; i<extension.size();++i)
-        extension[i] = tolower(extension[i]);
+      Util::ascii_str_tolower(&extension);
       if (extension == ".sass" && contents != 0) {
         char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
         free(contents); // free the indented contents
@@ -462,21 +508,21 @@ namespace Sass {
     }
 
     // split a path string delimited by semicolons or colons (OS dependent)
-    std::vector<std::string> split_path_list(const char* str)
+    sass::vector<sass::string> split_path_list(const char* str)
     {
-      std::vector<std::string> paths;
+      sass::vector<sass::string> paths;
       if (str == NULL) return paths;
       // find delimiter via prelexer (return zero at end)
       const char* end = Prelexer::find_first<PATH_SEP>(str);
       // search until null delimiter
       while (end) {
         // add path from current position to delimiter
-        paths.push_back(std::string(str, end - str));
+        paths.push_back(sass::string(str, end - str));
         str = end + 1; // skip delimiter
         end = Prelexer::find_first<PATH_SEP>(str);
       }
       // add path from current position to end
-      paths.push_back(std::string(str));
+      paths.push_back(sass::string(str));
       // return back
       return paths;
     }