2011-09-02 18:51:20 +02:00
|
|
|
#include "file.hh"
|
2011-09-09 20:40:59 +02:00
|
|
|
|
2013-04-09 20:05:40 +02:00
|
|
|
#include "assert.hh"
|
2011-09-02 18:51:20 +02:00
|
|
|
#include "buffer.hh"
|
2011-09-09 20:40:59 +02:00
|
|
|
#include "buffer_manager.hh"
|
2013-03-13 19:01:59 +01:00
|
|
|
#include "completion.hh"
|
2013-04-09 20:05:40 +02:00
|
|
|
#include "debug.hh"
|
|
|
|
#include "unicode.hh"
|
2012-10-11 00:41:48 +02:00
|
|
|
|
2013-06-19 20:28:23 +02:00
|
|
|
#include <errno.h>
|
2011-09-02 18:51:20 +02:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2012-11-23 18:43:10 +01:00
|
|
|
#include <sys/mman.h>
|
2011-09-02 18:51:20 +02:00
|
|
|
#include <fcntl.h>
|
2012-05-30 14:19:53 +02:00
|
|
|
#include <unistd.h>
|
2013-03-13 19:01:59 +01:00
|
|
|
#include <dirent.h>
|
2011-09-02 18:51:20 +02:00
|
|
|
|
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
String parse_filename(StringView filename)
|
2012-01-29 23:24:43 +01:00
|
|
|
{
|
2013-04-26 20:18:16 +02:00
|
|
|
if (filename.length() >= 1 and filename[0] == '~' and
|
|
|
|
(filename.length() == 1 or filename[1] == '/'))
|
2014-04-18 15:03:08 +02:00
|
|
|
return parse_filename("$HOME"_str + filename.substr(1_byte));
|
2012-01-29 23:24:43 +01:00
|
|
|
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount pos = 0;
|
2012-04-14 03:17:09 +02:00
|
|
|
String result;
|
2012-10-11 00:41:48 +02:00
|
|
|
for (ByteCount i = 0; i < filename.length(); ++i)
|
2012-01-29 23:24:43 +01:00
|
|
|
{
|
|
|
|
if (filename[i] == '$' and (i == 0 or filename[i-1] != '\\'))
|
|
|
|
{
|
|
|
|
result += filename.substr(pos, i - pos);
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount end = i+1;
|
|
|
|
while (end != filename.length() and is_word(filename[end]))
|
2012-01-29 23:24:43 +01:00
|
|
|
++end;
|
2014-04-18 15:03:08 +02:00
|
|
|
StringView var_name = filename.substr(i+1, end - i - 1);
|
2014-04-20 13:18:40 +02:00
|
|
|
const char* var_value = getenv(var_name.zstr());
|
2012-01-29 23:24:43 +01:00
|
|
|
if (var_value)
|
|
|
|
result += var_value;
|
|
|
|
|
|
|
|
pos = end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pos != filename.length())
|
|
|
|
result += filename.substr(pos);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
String real_path(StringView filename)
|
2013-03-22 14:27:30 +01:00
|
|
|
{
|
2014-04-18 15:03:08 +02:00
|
|
|
StringView dirname = ".";
|
|
|
|
StringView basename = filename;
|
2013-03-25 19:11:26 +01:00
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
auto it = find(filename.rbegin(), filename.rend(), '/');
|
2013-03-25 19:11:26 +01:00
|
|
|
if (it != filename.rend())
|
|
|
|
{
|
2014-04-18 15:03:08 +02:00
|
|
|
dirname = StringView{filename.begin(), it.base()};
|
|
|
|
basename = StringView{it.base(), filename.end()};
|
2013-03-25 19:11:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char buffer[PATH_MAX+1];
|
2014-04-20 13:18:40 +02:00
|
|
|
char* res = realpath(dirname.zstr(), buffer);
|
2013-03-25 19:11:26 +01:00
|
|
|
if (not res)
|
|
|
|
throw file_not_found{dirname};
|
|
|
|
return res + "/"_str + basename;
|
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
String compact_path(StringView filename)
|
2013-03-25 19:11:26 +01:00
|
|
|
{
|
|
|
|
String real_filename = real_path(filename);
|
|
|
|
|
|
|
|
char cwd[1024];
|
|
|
|
getcwd(cwd, 1024);
|
2013-04-29 13:49:47 +02:00
|
|
|
String real_cwd = real_path(cwd) + '/';
|
2013-09-23 21:16:25 +02:00
|
|
|
if (prefix_match(real_filename, real_cwd))
|
2013-04-29 13:49:47 +02:00
|
|
|
return real_filename.substr(real_cwd.length());
|
2013-03-25 19:11:26 +01:00
|
|
|
|
|
|
|
const char* home = getenv("HOME");
|
|
|
|
if (home)
|
|
|
|
{
|
|
|
|
ByteCount home_len = (int)strlen(home);
|
|
|
|
if (real_filename.substr(0, home_len) == home)
|
|
|
|
return "~" + real_filename.substr(home_len);
|
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
return filename.str();
|
2013-03-22 14:27:30 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
String read_file(StringView filename)
|
2011-12-22 14:33:29 +01:00
|
|
|
{
|
2012-09-12 19:42:12 +02:00
|
|
|
int fd = open(parse_filename(filename).c_str(), O_RDONLY);
|
2011-09-02 18:51:20 +02:00
|
|
|
if (fd == -1)
|
2011-09-02 20:01:20 +02:00
|
|
|
{
|
|
|
|
if (errno == ENOENT)
|
2011-09-09 20:40:59 +02:00
|
|
|
throw file_not_found(filename);
|
2011-09-02 20:01:20 +02:00
|
|
|
|
2011-09-09 20:40:59 +02:00
|
|
|
throw file_access_error(filename, strerror(errno));
|
2011-09-02 20:01:20 +02:00
|
|
|
}
|
2012-11-20 18:52:36 +01:00
|
|
|
auto close_fd = on_scope_end([fd]{ close(fd); });
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-04-14 03:17:09 +02:00
|
|
|
String content;
|
2011-09-02 18:51:20 +02:00
|
|
|
char buf[256];
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
ssize_t size = read(fd, buf, 256);
|
|
|
|
if (size == -1 or size == 0)
|
|
|
|
break;
|
|
|
|
|
2012-04-14 03:17:09 +02:00
|
|
|
content += String(buf, buf + size);
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|
2011-11-27 13:56:38 +01:00
|
|
|
return content;
|
|
|
|
}
|
|
|
|
|
2013-03-22 14:27:30 +01:00
|
|
|
Buffer* create_buffer_from_file(String filename)
|
2011-11-27 13:56:38 +01:00
|
|
|
{
|
2013-03-25 19:11:26 +01:00
|
|
|
filename = real_path(parse_filename(filename));
|
2013-03-22 14:27:30 +01:00
|
|
|
|
|
|
|
int fd = open(filename.c_str(), O_RDONLY);
|
2012-08-10 14:24:13 +02:00
|
|
|
if (fd == -1)
|
|
|
|
{
|
|
|
|
if (errno == ENOENT)
|
2012-10-16 14:59:39 +02:00
|
|
|
return nullptr;
|
2012-08-10 14:24:13 +02:00
|
|
|
|
|
|
|
throw file_access_error(filename, strerror(errno));
|
|
|
|
}
|
2012-11-23 18:43:10 +01:00
|
|
|
struct stat st;
|
|
|
|
fstat(fd, &st);
|
2012-12-05 13:59:08 +01:00
|
|
|
if (S_ISDIR(st.st_mode))
|
|
|
|
{
|
|
|
|
close(fd);
|
|
|
|
throw file_access_error(filename, "is a directory");
|
|
|
|
}
|
2012-11-23 18:43:10 +01:00
|
|
|
const char* data = (const char*)mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
|
|
|
|
auto cleanup = on_scope_end([&]{ munmap((void*)data, st.st_size); close(fd); });
|
2012-08-10 14:24:13 +02:00
|
|
|
|
2012-11-23 18:43:10 +01:00
|
|
|
const char* pos = data;
|
2012-08-10 14:24:13 +02:00
|
|
|
bool crlf = false;
|
2012-08-10 18:48:21 +02:00
|
|
|
bool bom = false;
|
2012-11-23 18:43:10 +01:00
|
|
|
if (st.st_size >= 3 and
|
|
|
|
data[0] == '\xEF' and data[1] == '\xBB' and data[2] == '\xBF')
|
2012-08-10 14:24:13 +02:00
|
|
|
{
|
2012-11-23 18:43:10 +01:00
|
|
|
bom = true;
|
|
|
|
pos = data + 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<String> lines;
|
|
|
|
const char* end = data + st.st_size;
|
|
|
|
while (pos < end)
|
|
|
|
{
|
|
|
|
const char* line_end = pos;
|
|
|
|
while (line_end < end and *line_end != '\r' and *line_end != '\n')
|
|
|
|
++line_end;
|
2012-08-10 14:24:13 +02:00
|
|
|
|
2012-11-23 18:43:10 +01:00
|
|
|
// this should happen only when opening a file which has no
|
|
|
|
// end of line as last character.
|
|
|
|
if (line_end == end)
|
2012-08-10 18:48:21 +02:00
|
|
|
{
|
2012-11-23 18:43:10 +01:00
|
|
|
lines.emplace_back(pos, line_end);
|
|
|
|
lines.back() += '\n';
|
|
|
|
break;
|
2012-08-10 18:48:21 +02:00
|
|
|
}
|
|
|
|
|
2012-11-23 18:43:10 +01:00
|
|
|
lines.emplace_back(pos, line_end + 1);
|
|
|
|
lines.back().back() = '\n';
|
|
|
|
|
2012-11-26 13:36:43 +01:00
|
|
|
if (line_end+1 != end and *line_end == '\r' and *(line_end+1) == '\n')
|
2012-08-10 14:24:13 +02:00
|
|
|
{
|
2012-11-23 18:43:10 +01:00
|
|
|
crlf = true;
|
|
|
|
pos = line_end + 2;
|
2012-08-10 14:24:13 +02:00
|
|
|
}
|
2012-11-23 18:43:10 +01:00
|
|
|
else
|
|
|
|
pos = line_end + 1;
|
2012-08-10 14:24:13 +02:00
|
|
|
}
|
2013-10-21 19:57:19 +02:00
|
|
|
Buffer* buffer = BufferManager::instance().get_buffer_ifp(filename);
|
|
|
|
if (buffer)
|
|
|
|
buffer->reload(std::move(lines), st.st_mtime);
|
|
|
|
else
|
|
|
|
buffer = new Buffer{filename, Buffer::Flags::File,
|
|
|
|
std::move(lines), st.st_mtime};
|
2012-08-10 14:24:13 +02:00
|
|
|
|
2012-11-22 13:50:29 +01:00
|
|
|
OptionManager& options = buffer->options();
|
2013-03-03 17:25:40 +01:00
|
|
|
options.get_local_option("eolformat").set<String>(crlf ? "crlf" : "lf");
|
|
|
|
options.get_local_option("BOM").set<String>(bom ? "utf-8" : "no");
|
2012-08-10 14:24:13 +02:00
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
static void write(int fd, StringView data, StringView filename)
|
2012-08-10 14:24:13 +02:00
|
|
|
{
|
2014-04-18 15:03:08 +02:00
|
|
|
const char* ptr = data.data();
|
|
|
|
ssize_t count = (int)data.length();
|
2012-08-10 14:24:13 +02:00
|
|
|
|
|
|
|
while (count)
|
|
|
|
{
|
|
|
|
ssize_t written = ::write(fd, ptr, count);
|
|
|
|
ptr += written;
|
|
|
|
count -= written;
|
|
|
|
|
|
|
|
if (written == -1)
|
|
|
|
throw file_access_error(filename, strerror(errno));
|
|
|
|
}
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
void write_buffer_to_file(Buffer& buffer, StringView filename)
|
2011-09-02 18:51:20 +02:00
|
|
|
{
|
2013-12-11 14:58:38 +01:00
|
|
|
buffer.run_hook_in_own_context("BufWritePre", buffer.name());
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
const String& eolformat = buffer.options()["eolformat"].get<String>();
|
|
|
|
StringView eoldata;
|
2012-08-10 14:24:13 +02:00
|
|
|
if (eolformat == "crlf")
|
2014-04-18 15:03:08 +02:00
|
|
|
eoldata = "\r\n";
|
2012-08-10 14:24:13 +02:00
|
|
|
else
|
2014-04-18 15:03:08 +02:00
|
|
|
eoldata = "\n";
|
2012-08-10 14:24:13 +02:00
|
|
|
|
2014-03-26 20:11:04 +01:00
|
|
|
{
|
|
|
|
int fd = open(parse_filename(filename).c_str(),
|
|
|
|
O_CREAT | O_WRONLY | O_TRUNC, 0644);
|
|
|
|
if (fd == -1)
|
|
|
|
throw file_access_error(filename, strerror(errno));
|
|
|
|
auto close_fd = on_scope_end([fd]{ close(fd); });
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2014-03-26 20:11:04 +01:00
|
|
|
if (buffer.options()["BOM"].get<String>() == "utf-8")
|
|
|
|
::write(fd, "\xEF\xBB\xBF", 3);
|
2012-08-10 18:48:21 +02:00
|
|
|
|
2014-03-26 20:11:04 +01:00
|
|
|
for (LineCount i = 0; i < buffer.line_count(); ++i)
|
|
|
|
{
|
|
|
|
// end of lines are written according to eolformat but always
|
|
|
|
// stored as \n
|
2014-04-18 15:03:08 +02:00
|
|
|
StringView linedata = buffer[i];
|
|
|
|
write(fd, linedata.substr(0, linedata.length()-1), filename);
|
2014-03-26 20:11:04 +01:00
|
|
|
write(fd, eoldata, filename);
|
|
|
|
}
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|
2013-10-15 19:51:31 +02:00
|
|
|
if ((buffer.flags() & Buffer::Flags::File) and filename == buffer.name())
|
2013-10-17 19:47:09 +02:00
|
|
|
buffer.notify_saved();
|
2013-12-11 14:58:38 +01:00
|
|
|
|
|
|
|
buffer.run_hook_in_own_context("BufWritePost", buffer.name());
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
String find_file(StringView filename, memoryview<String> paths)
|
2013-02-27 19:58:38 +01:00
|
|
|
{
|
2014-01-03 20:32:42 +01:00
|
|
|
struct stat buf;
|
2014-04-18 15:03:08 +02:00
|
|
|
if (filename.length() > 1 and filename[0] == '/')
|
2014-01-03 20:32:42 +01:00
|
|
|
{
|
2014-04-20 13:18:40 +02:00
|
|
|
if (stat(filename.zstr(), &buf) == 0 and S_ISREG(buf.st_mode))
|
2014-04-18 15:03:08 +02:00
|
|
|
return filename.str();
|
2014-01-03 20:32:42 +01:00
|
|
|
return "";
|
|
|
|
}
|
2014-04-18 15:03:08 +02:00
|
|
|
if (filename.length() > 2 and
|
2014-01-03 20:32:42 +01:00
|
|
|
filename[0] == '~' and filename[1] == '/')
|
|
|
|
{
|
2014-04-18 15:03:08 +02:00
|
|
|
String candidate = getenv("HOME") + filename.substr(1_byte).str();
|
2014-01-03 20:32:42 +01:00
|
|
|
if (stat(candidate.c_str(), &buf) == 0 and S_ISREG(buf.st_mode))
|
|
|
|
return candidate;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2013-03-13 18:52:08 +01:00
|
|
|
for (auto candidate : paths)
|
2013-02-27 19:58:38 +01:00
|
|
|
{
|
2013-03-13 18:52:08 +01:00
|
|
|
if (not candidate.empty() and candidate.back() != '/')
|
|
|
|
candidate += '/';
|
|
|
|
candidate += filename;
|
2013-02-27 19:58:38 +01:00
|
|
|
if (stat(candidate.c_str(), &buf) == 0 and S_ISREG(buf.st_mode))
|
|
|
|
return candidate;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2013-12-23 21:43:55 +01:00
|
|
|
template<typename Filter>
|
2014-04-18 15:03:08 +02:00
|
|
|
std::vector<String> list_files(StringView prefix, StringView dirname,
|
2013-12-23 21:43:55 +01:00
|
|
|
Filter filter)
|
|
|
|
{
|
|
|
|
kak_assert(dirname.empty() or dirname.back() == '/');
|
2014-04-20 13:18:40 +02:00
|
|
|
DIR* dir = opendir(dirname.empty() ? "./" : dirname.zstr());
|
2013-12-23 21:43:55 +01:00
|
|
|
if (not dir)
|
2014-04-06 11:59:51 +02:00
|
|
|
return {};
|
2013-12-23 21:43:55 +01:00
|
|
|
|
2014-04-06 11:59:51 +02:00
|
|
|
auto closeDir = on_scope_end([=]{ closedir(dir); });
|
|
|
|
|
|
|
|
std::vector<String> result;
|
2013-12-23 21:43:55 +01:00
|
|
|
std::vector<String> subseq_result;
|
|
|
|
while (dirent* entry = readdir(dir))
|
|
|
|
{
|
|
|
|
if (not filter(*entry))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
String filename = entry->d_name;
|
|
|
|
if (filename.empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
const bool match_prefix = prefix_match(filename, prefix);
|
|
|
|
const bool match_subseq = subsequence_match(filename, prefix);
|
2014-04-11 19:42:06 +02:00
|
|
|
struct stat st;
|
|
|
|
if ((match_prefix or match_subseq) and
|
|
|
|
stat((dirname + filename).c_str(), &st) == 0)
|
2013-12-23 21:43:55 +01:00
|
|
|
{
|
2014-04-11 19:42:06 +02:00
|
|
|
if (S_ISDIR(st.st_mode))
|
2013-12-23 21:43:55 +01:00
|
|
|
filename += '/';
|
|
|
|
if (prefix.length() != 0 or filename[0] != '.')
|
|
|
|
{
|
|
|
|
if (match_prefix)
|
|
|
|
result.push_back(filename);
|
|
|
|
if (match_subseq)
|
|
|
|
subseq_result.push_back(filename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-04-06 11:59:51 +02:00
|
|
|
return result.empty() ? subseq_result : result;
|
2013-12-23 21:43:55 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 15:02:14 +02:00
|
|
|
std::vector<String> complete_filename(StringView prefix,
|
2013-03-14 13:42:07 +01:00
|
|
|
const Regex& ignored_regex,
|
2013-03-13 19:01:59 +01:00
|
|
|
ByteCount cursor_pos)
|
|
|
|
{
|
|
|
|
String real_prefix = parse_filename(prefix.substr(0, cursor_pos));
|
2013-12-23 21:43:55 +01:00
|
|
|
String dirname;
|
2013-03-13 19:01:59 +01:00
|
|
|
String fileprefix = real_prefix;
|
|
|
|
|
|
|
|
ByteCount dir_end = -1;
|
|
|
|
for (ByteCount i = 0; i < real_prefix.length(); ++i)
|
|
|
|
{
|
|
|
|
if (real_prefix[i] == '/')
|
|
|
|
dir_end = i;
|
|
|
|
}
|
|
|
|
if (dir_end != -1)
|
|
|
|
{
|
|
|
|
dirname = real_prefix.substr(0, dir_end + 1);
|
|
|
|
fileprefix = real_prefix.substr(dir_end + 1);
|
|
|
|
}
|
|
|
|
|
2013-03-14 13:42:07 +01:00
|
|
|
const bool check_ignored_regex = not ignored_regex.empty() and
|
|
|
|
not boost::regex_match(fileprefix.c_str(), ignored_regex);
|
2013-03-13 19:01:59 +01:00
|
|
|
|
2013-12-23 21:43:55 +01:00
|
|
|
auto filter = [&](const dirent& entry)
|
2013-03-13 19:01:59 +01:00
|
|
|
{
|
2013-12-23 21:43:55 +01:00
|
|
|
return not check_ignored_regex or
|
|
|
|
not boost::regex_match(entry.d_name, ignored_regex);
|
|
|
|
};
|
|
|
|
std::vector<String> res = list_files(fileprefix, dirname, filter);
|
|
|
|
for (auto& file : res)
|
|
|
|
file = escape(dirname + file);
|
|
|
|
std::sort(res.begin(), res.end());
|
|
|
|
return res;
|
|
|
|
}
|
2013-03-13 19:01:59 +01:00
|
|
|
|
2014-04-18 15:02:14 +02:00
|
|
|
std::vector<String> complete_command(StringView prefix, ByteCount cursor_pos)
|
2013-12-23 21:43:55 +01:00
|
|
|
{
|
|
|
|
String real_prefix = parse_filename(prefix.substr(0, cursor_pos));
|
|
|
|
String dirname;
|
|
|
|
String fileprefix = real_prefix;
|
2013-03-13 19:01:59 +01:00
|
|
|
|
2013-12-23 21:43:55 +01:00
|
|
|
ByteCount dir_end = -1;
|
|
|
|
for (ByteCount i = 0; i < real_prefix.length(); ++i)
|
|
|
|
{
|
|
|
|
if (real_prefix[i] == '/')
|
|
|
|
dir_end = i;
|
2013-03-13 19:01:59 +01:00
|
|
|
}
|
2013-12-23 21:43:55 +01:00
|
|
|
|
2014-04-24 20:08:05 +02:00
|
|
|
struct CommandCache
|
|
|
|
{
|
|
|
|
timespec mtime = {};
|
|
|
|
std::vector<String> commands;
|
|
|
|
};
|
|
|
|
static std::unordered_map<String, CommandCache> command_cache;
|
|
|
|
|
2013-12-23 21:43:55 +01:00
|
|
|
std::vector<String> path;
|
|
|
|
if (dir_end != -1)
|
|
|
|
{
|
|
|
|
path.emplace_back(real_prefix.substr(0, dir_end + 1));
|
|
|
|
fileprefix = real_prefix.substr(dir_end + 1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
path = split(getenv("PATH"), ':');
|
|
|
|
|
|
|
|
std::vector<String> res;
|
|
|
|
for (auto dirname : path)
|
|
|
|
{
|
|
|
|
if (not dirname.empty() and dirname.back() != '/')
|
|
|
|
dirname += '/';
|
|
|
|
|
2014-04-24 20:08:05 +02:00
|
|
|
struct stat st;
|
|
|
|
if (stat(dirname.substr(0_byte, dirname.length() - 1).c_str(), &st))
|
|
|
|
continue;
|
|
|
|
|
2013-12-23 21:43:55 +01:00
|
|
|
auto filter = [&](const dirent& entry) {
|
|
|
|
struct stat st;
|
|
|
|
if (stat((dirname + entry.d_name).c_str(), &st))
|
|
|
|
return false;
|
|
|
|
bool executable = (st.st_mode & S_IXUSR)
|
|
|
|
| (st.st_mode & S_IXGRP)
|
|
|
|
| (st.st_mode & S_IXOTH);
|
|
|
|
return S_ISREG(st.st_mode) and executable;
|
|
|
|
};
|
2014-04-24 20:08:05 +02:00
|
|
|
|
|
|
|
auto& cache = command_cache[dirname];
|
|
|
|
if (memcmp(&cache.mtime, &st.st_mtim, sizeof(struct timespec)) != 0)
|
|
|
|
{
|
|
|
|
cache.mtime = st.st_mtim;
|
|
|
|
cache.commands = list_files("", dirname, filter);
|
|
|
|
}
|
|
|
|
for (auto& cmd : cache.commands)
|
|
|
|
{
|
|
|
|
if (prefix_match(cmd, fileprefix))
|
|
|
|
res.push_back(cmd);
|
|
|
|
}
|
2013-12-23 21:43:55 +01:00
|
|
|
}
|
|
|
|
std::sort(res.begin(), res.end());
|
|
|
|
auto it = std::unique(res.begin(), res.end());
|
|
|
|
res.erase(it, res.end());
|
|
|
|
return res;
|
2013-03-13 19:01:59 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 15:03:08 +02:00
|
|
|
time_t get_fs_timestamp(StringView filename)
|
2013-10-15 19:51:31 +02:00
|
|
|
{
|
|
|
|
struct stat st;
|
2014-04-20 13:18:40 +02:00
|
|
|
if (stat(filename.zstr(), &st) != 0)
|
2013-10-17 19:47:09 +02:00
|
|
|
return InvalidTime;
|
2013-10-15 19:51:31 +02:00
|
|
|
return st.st_mtime;
|
|
|
|
}
|
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|