blender/intern/cycles/util/util_path.cpp
Sergey Sharybin 75cb4850f0 Cycles: Use 1-based line number for #line directives
AMD CPU platform was complaining about #line 0 directives in the code.
2017-03-08 12:45:18 +01:00

859 lines
18 KiB
C++

/*
* Copyright 2011-2013 Blender Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "util_debug.h"
#include "util_md5.h"
#include "util_path.h"
#include "util_string.h"
#include <OpenImageIO/filesystem.h>
#include <OpenImageIO/strutil.h>
#include <OpenImageIO/sysutil.h>
OIIO_NAMESPACE_USING
#include <stdio.h>
#include <sys/stat.h>
#if defined(_WIN32)
# define DIR_SEP '\\'
# define DIR_SEP_ALT '/'
# include <direct.h>
#else
# define DIR_SEP '/'
# include <dirent.h>
# include <pwd.h>
# include <unistd.h>
# include <sys/types.h>
#endif
#ifdef HAVE_SHLWAPI_H
# include <shlwapi.h>
#endif
#include "util_windows.h"
CCL_NAMESPACE_BEGIN
#ifdef _WIN32
# if defined(_MSC_VER) || defined(__MINGW64__)
typedef struct _stat64 path_stat_t;
# elif defined(__MINGW32__)
typedef struct _stati64 path_stat_t;
# else
typedef struct _stat path_stat_t;
# endif
# ifndef S_ISDIR
# define S_ISDIR(x) (((x) & _S_IFDIR) == _S_IFDIR)
# endif
#else
typedef struct stat path_stat_t;
#endif
static string cached_path = "";
static string cached_user_path = "";
static string cached_xdg_cache_path = "";
namespace {
#ifdef _WIN32
class directory_iterator {
public:
class path_info {
public:
path_info(const string& path,
const WIN32_FIND_DATAW& find_data)
: path_(path),
find_data_(find_data)
{
}
string path() {
return path_join(path_, string_from_wstring(find_data_.cFileName));
}
protected:
const string& path_;
const WIN32_FIND_DATAW& find_data_;
};
directory_iterator()
: path_info_("", find_data_),
h_find_(INVALID_HANDLE_VALUE)
{
}
explicit directory_iterator(const string& path)
: path_(path),
path_info_(path, find_data_)
{
string wildcard = path;
if(wildcard[wildcard.size() - 1] != DIR_SEP) {
wildcard += DIR_SEP;
}
wildcard += "*";
h_find_ = FindFirstFileW(string_to_wstring(wildcard).c_str(),
&find_data_);
if(h_find_ != INVALID_HANDLE_VALUE) {
skip_dots();
}
}
~directory_iterator()
{
if(h_find_ != INVALID_HANDLE_VALUE) {
FindClose(h_find_);
}
}
directory_iterator& operator++()
{
step();
return *this;
}
path_info* operator-> ()
{
return &path_info_;
}
bool operator!=(const directory_iterator& other)
{
return h_find_ != other.h_find_;
}
protected:
bool step()
{
if(do_step()) {
return skip_dots();
}
return false;
}
bool do_step()
{
if(h_find_ != INVALID_HANDLE_VALUE) {
bool result = FindNextFileW(h_find_, &find_data_) == TRUE;
if(!result) {
FindClose(h_find_);
h_find_ = INVALID_HANDLE_VALUE;
}
return result;
}
return false;
}
bool skip_dots()
{
while(wcscmp(find_data_.cFileName, L".") == 0 ||
wcscmp(find_data_.cFileName, L"..") == 0)
{
if(!do_step()) {
return false;
}
}
return true;
}
string path_;
path_info path_info_;
WIN32_FIND_DATAW find_data_;
HANDLE h_find_;
};
#else /* _WIN32 */
class directory_iterator {
public:
class path_info {
public:
explicit path_info(const string& path)
: path_(path),
entry_(NULL)
{
}
string path() {
return path_join(path_, entry_->d_name);
}
void current_entry_set(const struct dirent *entry)
{
entry_ = entry;
}
protected:
const string& path_;
const struct dirent *entry_;
};
directory_iterator()
: path_info_(""),
name_list_(NULL),
num_entries_(-1),
cur_entry_(-1)
{
}
explicit directory_iterator(const string& path)
: path_(path),
path_info_(path_),
cur_entry_(0)
{
num_entries_ = scandir(path.c_str(),
&name_list_,
NULL,
alphasort);
if(num_entries_ < 0) {
perror("scandir");
}
else {
skip_dots();
}
}
~directory_iterator()
{
destroy_name_list();
}
directory_iterator& operator++()
{
step();
return *this;
}
path_info* operator-> ()
{
path_info_.current_entry_set(name_list_[cur_entry_]);
return &path_info_;
}
bool operator!=(const directory_iterator& other)
{
return name_list_ != other.name_list_;
}
protected:
bool step()
{
if(do_step()) {
return skip_dots();
}
return false;
}
bool do_step()
{
++cur_entry_;
if(cur_entry_ >= num_entries_) {
destroy_name_list();
return false;
}
return true;
}
/* Skip . and .. folders. */
bool skip_dots()
{
while(strcmp(name_list_[cur_entry_]->d_name, ".") == 0 ||
strcmp(name_list_[cur_entry_]->d_name, "..") == 0)
{
if(!step()) {
return false;
}
}
return true;
}
void destroy_name_list()
{
if(name_list_ == NULL) {
return;
}
for(int i = 0; i < num_entries_; ++i) {
free(name_list_[i]);
}
free(name_list_);
name_list_ = NULL;
}
string path_;
path_info path_info_;
struct dirent **name_list_;
int num_entries_, cur_entry_;
};
#endif /* _WIN32 */
size_t find_last_slash(const string& path)
{
for(size_t i = 0; i < path.size(); ++i) {
size_t index = path.size() - 1 - i;
#ifdef _WIN32
if(path[index] == DIR_SEP || path[index] == DIR_SEP_ALT)
#else
if(path[index] == DIR_SEP)
#endif
{
return index;
}
}
return string::npos;
}
} /* namespace */
static char *path_specials(const string& sub)
{
static bool env_init = false;
static char *env_shader_path;
static char *env_kernel_path;
if(!env_init) {
env_shader_path = getenv("CYCLES_SHADER_PATH");
env_kernel_path = getenv("CYCLES_KERNEL_PATH");
env_init = true;
}
if(env_shader_path != NULL && sub == "shader") {
return env_shader_path;
}
else if(env_shader_path != NULL && sub == "kernel") {
return env_kernel_path;
}
return NULL;
}
#if defined(__linux__) || defined(__APPLE__)
static string path_xdg_cache_get()
{
const char *home = getenv("XDG_CACHE_HOME");
if(home) {
return string(home);
}
else {
home = getenv("HOME");
if(home == NULL) {
home = getpwuid(getuid())->pw_dir;
}
return path_join(string(home), ".cache");
}
}
#endif
void path_init(const string& path, const string& user_path)
{
cached_path = path;
cached_user_path = user_path;
#ifdef _MSC_VER
// workaround for https://svn.boost.org/trac/boost/ticket/6320
// indirectly init boost codec here since it's not thread safe, and can
// cause crashes when it happens in multithreaded image load
OIIO::Filesystem::exists(path);
#endif
}
string path_get(const string& sub)
{
char *special = path_specials(sub);
if(special != NULL)
return special;
if(cached_path == "")
cached_path = path_dirname(Sysutil::this_program_path());
return path_join(cached_path, sub);
}
string path_user_get(const string& sub)
{
if(cached_user_path == "")
cached_user_path = path_dirname(Sysutil::this_program_path());
return path_join(cached_user_path, sub);
}
string path_cache_get(const string& sub)
{
#if defined(__linux__) || defined(__APPLE__)
if(cached_xdg_cache_path == "") {
cached_xdg_cache_path = path_xdg_cache_get();
}
string result = path_join(cached_xdg_cache_path, "cycles");
return path_join(result, sub);
#else
/* TODO(sergey): What that should be on Windows? */
return path_user_get(path_join("cache", sub));
#endif
}
#if defined(__linux__) || defined(__APPLE__)
string path_xdg_home_get(const string& sub = "");
#endif
string path_filename(const string& path)
{
size_t index = find_last_slash(path);
if(index != string::npos) {
/* Corner cases to match boost behavior. */
#ifndef _WIN32
if(index == 0 && path.size() == 1) {
return path;
}
#endif
if(index == path.size() - 1) {
#ifdef _WIN32
if(index == 2) {
return string(1, DIR_SEP);
}
#endif
return ".";
}
return path.substr(index + 1, path.size() - index - 1);
}
return path;
}
string path_dirname(const string& path)
{
size_t index = find_last_slash(path);
if(index != string::npos) {
#ifndef _WIN32
if(index == 0 && path.size() > 1) {
return string(1, DIR_SEP);
}
#endif
return path.substr(0, index);
}
return "";
}
string path_join(const string& dir, const string& file)
{
if(dir.size() == 0) {
return file;
}
if(file.size() == 0) {
return dir;
}
string result = dir;
#ifndef _WIN32
if(result[result.size() - 1] != DIR_SEP &&
file[0] != DIR_SEP)
#else
if(result[result.size() - 1] != DIR_SEP &&
result[result.size() - 1] != DIR_SEP_ALT &&
file[0] != DIR_SEP &&
file[0] != DIR_SEP_ALT)
#endif
{
result += DIR_SEP;
}
result += file;
return result;
}
string path_escape(const string& path)
{
string result = path;
string_replace(result, " ", "\\ ");
return result;
}
bool path_is_relative(const string& path)
{
#ifdef _WIN32
# ifdef HAVE_SHLWAPI_H
return PathIsRelative(path.c_str());
# else /* HAVE_SHLWAPI_H */
if(path.size() >= 3) {
return !(((path[0] >= 'a' && path[0] <= 'z') ||
(path[0] >= 'A' && path[0] <= 'Z')) &&
path[1] == ':' && path[2] == DIR_SEP);
}
return true;
# endif /* HAVE_SHLWAPI_H */
#else /* _WIN32 */
if(path.size() == 0) {
return 1;
}
return path[0] != DIR_SEP;
#endif /* _WIN32 */
}
#ifdef _WIN32
/* Add a slash if the UNC path points to a share. */
static string path_unc_add_slash_to_share(const string& path)
{
size_t slash_after_server = path.find(DIR_SEP, 2);
if(slash_after_server != string::npos) {
size_t slash_after_share = path.find(DIR_SEP,
slash_after_server + 1);
if(slash_after_share == string::npos) {
return path + DIR_SEP;
}
}
return path;
}
/* Convert:
* \\?\UNC\server\share\folder\... to \\server\share\folder\...
* \\?\C:\ to C:\ and \\?\C:\folder\... to C:\folder\...
*/
static string path_unc_to_short(const string& path)
{
size_t len = path.size();
if((len > 3) &&
(path[0] == DIR_SEP) &&
(path[1] == DIR_SEP) &&
(path[2] == '?') &&
((path[3] == DIR_SEP) || (path[3] == DIR_SEP_ALT)))
{
if((len > 5) && (path[5] == ':')) {
return path.substr(4, len - 4);
}
else if((len > 7) &&
(path.substr(4, 3) == "UNC") &&
((path[7] == DIR_SEP) || (path[7] == DIR_SEP_ALT)))
{
return "\\\\" + path.substr(8, len - 8);
}
}
return path;
}
static string path_cleanup_unc(const string& path)
{
string result = path_unc_to_short(path);
if(path.size() > 2) {
/* It's possible path is now a non-UNC. */
if(result[0] == DIR_SEP && result[1] == DIR_SEP) {
return path_unc_add_slash_to_share(result);
}
}
return result;
}
/* Make path compatible for stat() functions. */
static string path_make_compatible(const string& path)
{
string result = path;
/* In Windows stat() doesn't recognize dir ending on a slash. */
if(result.size() > 3 && result[result.size() - 1] == DIR_SEP) {
result.resize(result.size() - 1);
}
/* Clean up UNC path. */
if((path.size() >= 3) && (path[0] == DIR_SEP) && (path[1] == DIR_SEP)) {
result = path_cleanup_unc(result);
}
/* Make sure volume-only path ends up wit ha directory separator. */
if(result.size() == 2 && result[1] == ':') {
result += DIR_SEP;
}
return result;
}
static int path_wstat(const wstring& path_wc, path_stat_t *st)
{
#if defined(_MSC_VER) || defined(__MINGW64__)
return _wstat64(path_wc.c_str(), st);
#elif defined(__MINGW32__)
return _wstati64(path_wc.c_str(), st);
#else
return _wstat(path_wc.c_str(), st);
#endif
}
static int path_stat(const string& path, path_stat_t *st)
{
wstring path_wc = string_to_wstring(path);
return path_wstat(path_wc, st);
}
#else /* _WIN32 */
static int path_stat(const string& path, path_stat_t *st)
{
return stat(path.c_str(), st);
}
#endif /* _WIN32 */
size_t path_file_size(const string& path)
{
path_stat_t st;
if(path_stat(path, &st) != 0) {
return -1;
}
return st.st_size;
}
bool path_exists(const string& path)
{
#ifdef _WIN32
string fixed_path = path_make_compatible(path);
wstring path_wc = string_to_wstring(fixed_path);
path_stat_t st;
if(path_wstat(path_wc, &st) != 0) {
return false;
}
return st.st_mode != 0;
#else /* _WIN32 */
struct stat st;
if(stat(path.c_str(), &st) != 0) {
return 0;
}
return st.st_mode != 0;
#endif /* _WIN32 */
}
bool path_is_directory(const string& path)
{
path_stat_t st;
if(path_stat(path, &st) != 0) {
return false;
}
return S_ISDIR(st.st_mode);
}
static void path_files_md5_hash_recursive(MD5Hash& hash, const string& dir)
{
if(path_exists(dir)) {
directory_iterator it(dir), it_end;
for(; it != it_end; ++it) {
if(path_is_directory(it->path())) {
path_files_md5_hash_recursive(hash, it->path());
}
else {
string filepath = it->path();
hash.append((const uint8_t*)filepath.c_str(), filepath.size());
hash.append_file(filepath);
}
}
}
}
string path_files_md5_hash(const string& dir)
{
/* computes md5 hash of all files in the directory */
MD5Hash hash;
path_files_md5_hash_recursive(hash, dir);
return hash.get_hex();
}
static bool create_directories_recursivey(const string& path)
{
if(path_is_directory(path)) {
/* Directory already exists, nothing to do. */
return true;
}
if(path_exists(path)) {
/* File exists and it's not a directory. */
return false;
}
string parent = path_dirname(path);
if(parent.size() > 0 && parent != path) {
if(!create_directories_recursivey(parent)) {
return false;
}
}
#ifdef _WIN32
wstring path_wc = string_to_wstring(path);
return _wmkdir(path_wc.c_str()) == 0;
#else
return mkdir(path.c_str(), 0777) == 0;
#endif
}
void path_create_directories(const string& filepath)
{
string path = path_dirname(filepath);
create_directories_recursivey(path);
}
bool path_write_binary(const string& path, const vector<uint8_t>& binary)
{
path_create_directories(path);
/* write binary file from memory */
FILE *f = path_fopen(path, "wb");
if(!f)
return false;
if(binary.size() > 0)
fwrite(&binary[0], sizeof(uint8_t), binary.size(), f);
fclose(f);
return true;
}
bool path_write_text(const string& path, string& text)
{
vector<uint8_t> binary(text.length(), 0);
std::copy(text.begin(), text.end(), binary.begin());
return path_write_binary(path, binary);
}
bool path_read_binary(const string& path, vector<uint8_t>& binary)
{
/* read binary file into memory */
FILE *f = path_fopen(path, "rb");
if(!f) {
binary.resize(0);
return false;
}
binary.resize(path_file_size(path));
if(binary.size() == 0) {
fclose(f);
return false;
}
if(fread(&binary[0], sizeof(uint8_t), binary.size(), f) != binary.size()) {
fclose(f);
return false;
}
fclose(f);
return true;
}
bool path_read_text(const string& path, string& text)
{
vector<uint8_t> binary;
if(!path_exists(path) || !path_read_binary(path, binary))
return false;
const char *str = (const char*)&binary[0];
size_t size = binary.size();
text = string(str, size);
return true;
}
uint64_t path_modified_time(const string& path)
{
path_stat_t st;
if(path_stat(path, &st) != 0) {
return 0;
}
return st.st_mtime;
}
bool path_remove(const string& path)
{
return remove(path.c_str()) == 0;
}
static string line_directive(const string& path, int line)
{
string escaped_path = path;
string_replace(escaped_path, "\"", "\\\"");
string_replace(escaped_path, "\'", "\\\'");
string_replace(escaped_path, "\?", "\\\?");
string_replace(escaped_path, "\\", "\\\\");
return string_printf("#line %d \"%s\"", line, escaped_path.c_str());
}
string path_source_replace_includes(const string& source,
const string& path,
const string& source_filename)
{
/* Our own little c preprocessor that replaces #includes with the file
* contents, to work around issue of opencl drivers not supporting
* include paths with spaces in them.
*/
string result = "";
vector<string> lines;
string_split(lines, source, "\n", false);
for(size_t i = 0; i < lines.size(); ++i) {
string line = lines[i];
if(line[0] == '#') {
string token = string_strip(line.substr(1, line.size() - 1));
if(string_startswith(token, "include")) {
token = string_strip(token.substr(7, token.size() - 7));
if(token[0] == '"') {
size_t n_start = 1;
size_t n_end = token.find("\"", n_start);
string filename = token.substr(n_start, n_end - n_start);
string text, filepath = path_join(path, filename);
if(path_read_text(filepath, text)) {
/* Replace include directories with both current path
* and path extracted from the include file.
* Not totally robust, but works fine for Cycles kernel
* and avoids having list of include directories.x
*/
text = path_source_replace_includes(
text, path_dirname(filepath), filename);
text = path_source_replace_includes(text, path, filename);
/* Use line directives for better error messages. */
line = line_directive(filepath, 1)
+ token.replace(0, n_end + 1, "\n" + text + "\n")
+ line_directive(path_join(path, source_filename), i + 1);
}
}
}
}
result += line + "\n";
}
return result;
}
FILE *path_fopen(const string& path, const string& mode)
{
#ifdef _WIN32
wstring path_wc = string_to_wstring(path);
wstring mode_wc = string_to_wstring(mode);
return _wfopen(path_wc.c_str(), mode_wc.c_str());
#else
return fopen(path.c_str(), mode.c_str());
#endif
}
void path_cache_clear_except(const string& name, const set<string>& except)
{
string dir = path_user_get("cache");
if(path_exists(dir)) {
directory_iterator it(dir), it_end;
for(; it != it_end; ++it) {
string filename = path_filename(it->path());
if(string_startswith(filename, name.c_str()))
if(except.find(filename) == except.end())
path_remove(it->path());
}
}
}
CCL_NAMESPACE_END