open source
This commit is contained in:
lvfulong
@@ -0,0 +1,812 @@
|
||||
/**
|
||||
@file JCFileSystem.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_11
|
||||
*/
|
||||
|
||||
#include "JCFileSystem.h"
|
||||
#include <stdio.h>
|
||||
#include "../util/JCCommonMethod.h"
|
||||
#define ERROR_FILE_C_R_W (-6)
|
||||
#pragma warning(disable:4996)
|
||||
|
||||
|
||||
#ifdef WIN32
|
||||
#else
|
||||
#include <cstring>
|
||||
#include <sys/stat.h>
|
||||
#include <cstdlib>
|
||||
#include <cerrno>
|
||||
#include <dirent.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
namespace laya
|
||||
{
|
||||
GLOBAL_ONCREATEFILEERROR global_onCreateFileError = NULL;
|
||||
bool readFileSync( const char* p_pszFile , JCBuffer& p_buf, int p_nEncode )
|
||||
{
|
||||
if(!p_pszFile)
|
||||
return false;
|
||||
FILE* pf = NULL;
|
||||
pf=fopen(p_pszFile,"rb");
|
||||
if( pf==NULL )
|
||||
return false;
|
||||
fseek(pf,0,SEEK_END);
|
||||
int len = ftell(pf);
|
||||
bool bAsText = p_nEncode!=JCBuffer::raw ;
|
||||
fseek(pf,0,SEEK_SET);
|
||||
p_buf.create(len+(bAsText?1:0));
|
||||
int readlen = fread(p_buf.m_pPtr, 1, len, pf);
|
||||
if( readlen!=len){
|
||||
fclose(pf);
|
||||
p_buf.free();
|
||||
return false;
|
||||
}
|
||||
fclose(pf);
|
||||
if( bAsText )
|
||||
p_buf.m_pPtr[len]=0;
|
||||
return true;
|
||||
}
|
||||
std::string readFileSync1(const char* p_pszFile, const char* p_pszEncode)
|
||||
{
|
||||
JCBuffer buf;
|
||||
if (readFileSync(p_pszFile, buf, JCBuffer::utf8))
|
||||
{
|
||||
return buf.m_pPtr;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
bool writeFileSync1( const char* p_pszFile, char* p_pBuff, int p_nLen, int p_nEncode)
|
||||
{
|
||||
if (!p_pszFile || strlen(p_pszFile) <= 1)
|
||||
return false;
|
||||
FILE* pFile = NULL;
|
||||
try{
|
||||
pFile = fopen( p_pszFile, "wb");
|
||||
if( pFile==NULL){
|
||||
throw ERROR_FILE_C_R_W;
|
||||
return false;
|
||||
}
|
||||
int ret = fwrite( p_pBuff, 1, p_nLen, pFile );
|
||||
if(ret<p_nLen){
|
||||
fclose(pFile);
|
||||
throw ERROR_FILE_C_R_W;
|
||||
}
|
||||
fflush(pFile);
|
||||
fclose(pFile);
|
||||
}
|
||||
catch(int e)
|
||||
{
|
||||
if( e==ERROR_FILE_C_R_W && global_onCreateFileError){
|
||||
global_onCreateFileError();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool writeFileSync( const char* p_pszFile, JCBuffer& p_buf, int p_nEncode )
|
||||
{
|
||||
return writeFileSync1(p_pszFile, p_buf.m_pPtr, p_buf.m_nLen, p_nEncode);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
namespace fs
|
||||
{
|
||||
# define FILESYSTEM_REMOVE_DIRECTORY(P)(::rmdir(P)== 0)
|
||||
# define FILESYSTEM_DELETE_FILE(P)(::unlink(P)== 0)
|
||||
# define FILESYSTEM_ERRNO errno
|
||||
# define FILESYSTEM_SET_CURRENT_DIRECTORY(P)(::chdir(P)== 0)
|
||||
# define FILESYSTEM_CREATE_DIRECTORY(P)(::mkdir(P, S_IRWXU|S_IRWXG|S_IRWXO)== 0)
|
||||
typedef int err_t;
|
||||
typedef path::value_type value_type;
|
||||
typedef path::string_type string_type;
|
||||
typedef string_type::size_type size_type;
|
||||
directory_iterator end_dir_itr;
|
||||
const std::error_code ok;
|
||||
const char* const separators = "/";
|
||||
const char* separator_string = "/";
|
||||
const char* preferred_separator_string = "/";
|
||||
const char dot = '.';
|
||||
const std::error_code not_found_error_code (ENOENT, std::system_category());
|
||||
|
||||
path& path::remove_filename()
|
||||
{
|
||||
m_pathname.erase(m_parent_path_end());
|
||||
return *this;
|
||||
}
|
||||
size_type root_directory_start(const string_type & path, size_type size)
|
||||
// return npos if no root_directory found
|
||||
{
|
||||
|
||||
|
||||
// case "//"
|
||||
if (size == 2
|
||||
&& is_directory_separator(path[0])
|
||||
&& is_directory_separator(path[1])) return string_type::npos;
|
||||
|
||||
|
||||
// case "//net {/}"
|
||||
if (size > 3
|
||||
&& is_directory_separator(path[0])
|
||||
&& is_directory_separator(path[1])
|
||||
&& !is_directory_separator(path[2]))
|
||||
{
|
||||
string_type::size_type pos(path.find_first_of(separators, 2));
|
||||
return pos < size ? pos : string_type::npos;
|
||||
}
|
||||
|
||||
// case "/"
|
||||
if (size > 0 && is_directory_separator(path[0])) return 0;
|
||||
|
||||
return string_type::npos;
|
||||
}
|
||||
size_type filename_pos(const string_type & str,size_type end_pos) // end_pos is past-the-end position
|
||||
// return 0 if str itself is filename (or empty)
|
||||
{
|
||||
// case: "//"
|
||||
if (end_pos == 2
|
||||
&& is_directory_separator(str[0])
|
||||
&& is_directory_separator(str[1])) return 0;
|
||||
|
||||
// case: ends in "/"
|
||||
if (end_pos && is_directory_separator(str[end_pos-1]))
|
||||
return end_pos-1;
|
||||
|
||||
// set pos to start of last element
|
||||
size_type pos(str.find_last_of(separators, end_pos-1));
|
||||
|
||||
|
||||
return (pos == string_type::npos // path itself must be a filename (or empty)
|
||||
|| (pos == 1 && is_directory_separator(str[0]))) // or net
|
||||
? 0 // so filename is entire string
|
||||
: pos + 1; // or starts after delimiter
|
||||
}
|
||||
const path& dot_path()
|
||||
{
|
||||
static const path dot_pth(".");
|
||||
return dot_pth;
|
||||
}
|
||||
|
||||
const path& dot_dot_path()
|
||||
{
|
||||
static const path dot_dot("..");
|
||||
return dot_dot;
|
||||
}
|
||||
bool is_root_separator(const string_type & str, size_type pos)
|
||||
// pos is position of the separator
|
||||
{
|
||||
assert(!str.empty() && is_directory_separator(str[pos]) && "precondition violation");
|
||||
|
||||
// subsequent logic expects pos to be for leftmost slash of a set
|
||||
while (pos > 0 && is_directory_separator(str[pos-1]))
|
||||
--pos;
|
||||
|
||||
// "/" [...]
|
||||
if (pos == 0)
|
||||
return true;
|
||||
|
||||
|
||||
// "//" name "/"
|
||||
if (pos < 3 || !is_directory_separator(str[0])
|
||||
|| !is_directory_separator(str[1]))
|
||||
return false;
|
||||
|
||||
return str.find_first_of(separators, 2) == pos;
|
||||
}
|
||||
|
||||
string_type::size_type path::m_parent_path_end() const
|
||||
{
|
||||
size_type end_pos(filename_pos(m_pathname, m_pathname.size()));
|
||||
|
||||
bool filename_was_separator(m_pathname.size()
|
||||
&& is_directory_separator(m_pathname[end_pos]));
|
||||
|
||||
// skip separators unless root directory
|
||||
size_type root_dir_pos(root_directory_start(m_pathname, end_pos));
|
||||
for (;
|
||||
end_pos > 0
|
||||
&& (end_pos-1) != root_dir_pos
|
||||
&& is_directory_separator(m_pathname[end_pos-1])
|
||||
;
|
||||
--end_pos) {}
|
||||
|
||||
return (end_pos == 1 && root_dir_pos == 0 && filename_was_separator)
|
||||
? string_type::npos
|
||||
: end_pos;
|
||||
}
|
||||
path path::filename() const
|
||||
{
|
||||
size_type pos(filename_pos(m_pathname, m_pathname.size()));
|
||||
return (m_pathname.size()
|
||||
&& pos
|
||||
&& is_directory_separator(m_pathname[pos])
|
||||
&& !is_root_separator(m_pathname, pos))
|
||||
? dot_path()
|
||||
: path(m_pathname.c_str() + pos);
|
||||
}
|
||||
path& path::operator/=(const path& p)
|
||||
{
|
||||
if (p.empty())
|
||||
return *this;
|
||||
if (this == &p) // self-append
|
||||
{
|
||||
path rhs(p);
|
||||
if (!is_directory_separator(rhs.m_pathname[0]))
|
||||
m_append_separator_if_needed();
|
||||
m_pathname += rhs.m_pathname;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!is_directory_separator(*p.m_pathname.begin()))
|
||||
m_append_separator_if_needed();
|
||||
m_pathname += p.m_pathname;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
path& path::operator/=(const value_type* ptr)
|
||||
{
|
||||
if (!*ptr)
|
||||
return *this;
|
||||
if (ptr >= m_pathname.data()
|
||||
&& ptr < m_pathname.data() + m_pathname.size()) // overlapping source
|
||||
{
|
||||
path rhs(ptr);
|
||||
if (!is_directory_separator(rhs.m_pathname[0]))
|
||||
m_append_separator_if_needed();
|
||||
m_pathname += rhs.m_pathname;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!is_directory_separator(*ptr))
|
||||
m_append_separator_if_needed();
|
||||
m_pathname += ptr;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
path::string_type::size_type path::m_append_separator_if_needed()
|
||||
{
|
||||
if (!m_pathname.empty() &&
|
||||
!is_directory_separator(*(m_pathname.end()-1)))
|
||||
{
|
||||
string_type::size_type tmp(m_pathname.size());
|
||||
m_pathname += preferred_separator;
|
||||
return tmp;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
path path::parent_path() const
|
||||
{
|
||||
size_type end_pos(m_parent_path_end());
|
||||
return end_pos == string_type::npos
|
||||
? path()
|
||||
//: path(m_pathname.c_str(), m_pathname.c_str() + end_pos);
|
||||
:path(m_pathname.substr(0,end_pos));
|
||||
}
|
||||
bool not_found_error(int errval)
|
||||
{
|
||||
return errno == ENOENT || errno == ENOTDIR;
|
||||
}
|
||||
file_status status(const path& p, std::error_code* ec)
|
||||
{
|
||||
struct stat path_stat;
|
||||
if (::stat(p.c_str(), &path_stat)!= 0)
|
||||
{
|
||||
if (ec != 0) // always report errno, even though some
|
||||
ec->assign(errno, std::system_category()); // errno values are not status_errors
|
||||
|
||||
if (not_found_error(errno))
|
||||
{
|
||||
return file_status(file_not_found, no_perms);
|
||||
}
|
||||
//if (ec == 0)
|
||||
// BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::status",
|
||||
// p, error_code(errno, system_category())));
|
||||
if (ec == 0)
|
||||
throw filesystem_error("boost::filesystem::status");
|
||||
return file_status(status_error);
|
||||
}
|
||||
if (ec != 0) ec->clear();;
|
||||
if (S_ISDIR(path_stat.st_mode))
|
||||
return file_status(directory_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISREG(path_stat.st_mode))
|
||||
return file_status(regular_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISBLK(path_stat.st_mode))
|
||||
return file_status(block_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISCHR(path_stat.st_mode))
|
||||
return file_status(character_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISFIFO(path_stat.st_mode))
|
||||
return file_status(fifo_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISSOCK(path_stat.st_mode))
|
||||
return file_status(socket_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
return file_status(type_unknown);
|
||||
|
||||
}
|
||||
bool create_directory(const path& p, std::error_code* ec)
|
||||
{
|
||||
if (FILESYSTEM_CREATE_DIRECTORY(p.c_str()))
|
||||
{
|
||||
if (ec != 0)
|
||||
ec->clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
// attempt to create directory failed
|
||||
int errval(FILESYSTEM_ERRNO); // save reason for failure
|
||||
//error_code dummy;
|
||||
|
||||
if (is_directory(p/*, dummy*/))
|
||||
{
|
||||
if (ec != 0)
|
||||
ec->clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
// attempt to create directory failed && it doesn't already exist
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::create_directory",
|
||||
// p, error_code(errval, system_category())));
|
||||
throw filesystem_error("boost::filesystem::create_directory");
|
||||
else
|
||||
ec->assign(errval, std::system_category());
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool create_directories(const path& p, std::error_code* ec)
|
||||
{
|
||||
if (p.empty())
|
||||
{
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(filesystem_error(
|
||||
// "boost::filesystem::create_directories", p,
|
||||
// system::errc::make_error_code(system::errc::invalid_argument)));
|
||||
throw filesystem_error("boost::filesystem::create_directories");
|
||||
else
|
||||
ec->assign((int)std::errc::invalid_argument, std::generic_category());
|
||||
return false;
|
||||
}
|
||||
|
||||
if (p.filename_is_dot() || p.filename_is_dot_dot())
|
||||
return create_directories(p.parent_path(), ec);
|
||||
|
||||
std::error_code local_ec;
|
||||
file_status p_status = status(p, &local_ec);
|
||||
|
||||
if (p_status.type() == directory_file)
|
||||
{
|
||||
if (ec != 0)
|
||||
ec->clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
path parent = p.parent_path();
|
||||
//////////assert(parent != p &&"internal error: p == p.parent_path()");
|
||||
if (!parent.empty())
|
||||
{
|
||||
// determine if the parent exists
|
||||
file_status parent_status = status(parent, &local_ec);
|
||||
|
||||
// if the parent does not exist, create the parent
|
||||
if (parent_status.type() == file_not_found)
|
||||
{
|
||||
create_directories(parent, &local_ec);
|
||||
if (local_ec)
|
||||
{
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(filesystem_error(
|
||||
// "boost::filesystem::create_directories", parent, local_ec));
|
||||
throw filesystem_error("boost::filesystem::create_directories");
|
||||
else
|
||||
*ec = local_ec;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// create the directory
|
||||
return create_directory(p, ec);
|
||||
}
|
||||
bool error(err_t error_num, const path& p, std::error_code* ec, const char* message)
|
||||
{
|
||||
if (!error_num)
|
||||
{
|
||||
if (ec != 0) ec->clear();
|
||||
}
|
||||
else
|
||||
{ // error
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(filesystem_error(message,
|
||||
// p, error_code(error_num, system_category())));
|
||||
throw filesystem_error(message);
|
||||
else
|
||||
ec->assign(error_num, std::system_category());
|
||||
}
|
||||
return error_num != 0;
|
||||
}
|
||||
std::time_t last_write_time(const path& p, std::error_code* ec)
|
||||
{
|
||||
struct stat path_stat;
|
||||
if (error(::stat(p.c_str(), &path_stat)!= 0 ? FILESYSTEM_ERRNO : 0,
|
||||
p, ec, "boost::filesystem::last_write_time"))
|
||||
return std::time_t(-1);
|
||||
return path_stat.st_mtime;
|
||||
}
|
||||
|
||||
std::uintmax_t file_size(const path& p, std::error_code* ec)
|
||||
{
|
||||
struct stat path_stat;
|
||||
if (error(::stat(p.c_str(), &path_stat)!= 0 ? FILESYSTEM_ERRNO : 0,
|
||||
p, ec, "boost::filesystem::file_size"))
|
||||
return static_cast<std::uintmax_t>(-1);
|
||||
if (error(!S_ISREG(path_stat.st_mode) ? EPERM : 0,
|
||||
p, ec, "boost::filesystem::file_size"))
|
||||
return static_cast<std::uintmax_t>(-1);
|
||||
|
||||
return static_cast<std::uintmax_t>(path_stat.st_size);
|
||||
}
|
||||
// only called if directory exists
|
||||
bool remove_directory(const path& p) // true if succeeds or not found
|
||||
{
|
||||
return FILESYSTEM_REMOVE_DIRECTORY(p.c_str())
|
||||
|| not_found_error(FILESYSTEM_ERRNO); // mitigate possible file system race. See #11166
|
||||
}
|
||||
|
||||
// only called if file exists
|
||||
bool remove_file(const path& p) // true if succeeds or not found
|
||||
{
|
||||
return FILESYSTEM_DELETE_FILE(p.c_str())
|
||||
|| not_found_error(FILESYSTEM_ERRNO); // mitigate possible file system race. See #11166
|
||||
}
|
||||
|
||||
// called by remove and remove_all_aux
|
||||
bool remove_file_or_directory(const path& p, file_type type, std::error_code* ec)
|
||||
// return true if file removed, false if not removed
|
||||
{
|
||||
if (type == file_not_found)
|
||||
{
|
||||
if (ec != 0) ec->clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
if (type == directory_file)
|
||||
{
|
||||
if (error(!remove_directory(p) ? FILESYSTEM_ERRNO : 0, p, ec,
|
||||
"boost::filesystem::remove"))
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (error(!remove_file(p) ? FILESYSTEM_ERRNO : 0, p, ec,
|
||||
"boost::filesystem::remove"))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
file_status symlink_status(const path& p, std::error_code* ec)
|
||||
{
|
||||
|
||||
struct stat path_stat;
|
||||
if (::lstat(p.c_str(), &path_stat)!= 0)
|
||||
{
|
||||
if (ec != 0) // always report errno, even though some
|
||||
ec->assign(errno, std::system_category()); // errno values are not status_errors
|
||||
|
||||
if (errno == ENOENT || errno == ENOTDIR) // these are not errors
|
||||
{
|
||||
return file_status(file_not_found, no_perms);
|
||||
}
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::status",
|
||||
// p, error_code(errno, system_category())));
|
||||
throw filesystem_error("boost::filesystem::status");
|
||||
return file_status(status_error);
|
||||
}
|
||||
if (ec != 0) ec->clear();
|
||||
if (S_ISREG(path_stat.st_mode))
|
||||
return file_status(regular_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISDIR(path_stat.st_mode))
|
||||
return file_status(directory_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISLNK(path_stat.st_mode))
|
||||
return file_status(symlink_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISBLK(path_stat.st_mode))
|
||||
return file_status(block_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISCHR(path_stat.st_mode))
|
||||
return file_status(character_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISFIFO(path_stat.st_mode))
|
||||
return file_status(fifo_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
if (S_ISSOCK(path_stat.st_mode))
|
||||
return file_status(socket_file,
|
||||
static_cast<perms>(path_stat.st_mode) & perms_mask);
|
||||
return file_status(type_unknown);
|
||||
|
||||
}
|
||||
}
|
||||
inline file_type query_file_type(const path& p, std::error_code* ec)
|
||||
{
|
||||
return detail::symlink_status(p, ec).type();
|
||||
}
|
||||
bool remove(const path& p, std::error_code* ec)
|
||||
{
|
||||
std::error_code tmp_ec;
|
||||
file_type type = query_file_type(p, &tmp_ec);
|
||||
if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
|
||||
"boost::filesystem::remove"))
|
||||
return false;
|
||||
|
||||
// Since POSIX remove() is specified to work with either files or directories, in a
|
||||
// perfect world it could just be called. But some important real-world operating
|
||||
// systems (Windows, Mac OS X, for example) don't implement the POSIX spec. So
|
||||
// remove_file_or_directory() is always called to keep it simple.
|
||||
return remove_file_or_directory(p, type, ec);
|
||||
}
|
||||
std::uintmax_t remove_all_aux(const path& p, file_type type,std::error_code* ec)
|
||||
{
|
||||
std::uintmax_t count = 1;
|
||||
if (type == directory_file) // but not a directory symlink
|
||||
{
|
||||
directory_iterator itr;
|
||||
if (ec != 0)
|
||||
{
|
||||
itr = directory_iterator(p, *ec);
|
||||
if (*ec)
|
||||
return count;
|
||||
}
|
||||
else
|
||||
itr = directory_iterator(p);
|
||||
for (; itr != end_dir_itr; ++itr)
|
||||
{
|
||||
file_type tmp_type = query_file_type(itr->path(), ec);
|
||||
if (ec != 0 && *ec)
|
||||
return count;
|
||||
count += remove_all_aux(itr->path(), tmp_type, ec);
|
||||
if (ec != 0 && *ec)
|
||||
return count;
|
||||
}
|
||||
}
|
||||
remove_file_or_directory(p, type, ec);
|
||||
return count;
|
||||
}
|
||||
std::uintmax_t remove_all(const path& p, std::error_code* ec)
|
||||
{
|
||||
std::error_code tmp_ec;
|
||||
file_type type = query_file_type(p, &tmp_ec);
|
||||
if (error(type == status_error ? tmp_ec.value() : 0, p, ec,
|
||||
"boost::filesystem::remove_all"))
|
||||
return 0;
|
||||
|
||||
return (type != status_error && type != file_not_found) // exists
|
||||
? remove_all_aux(p, type, ec)
|
||||
: 0;
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
std::error_code path_max(std::size_t & result)
|
||||
// this code is based on Stevens and Rago, Advanced Programming in the
|
||||
// UNIX envirnment, 2nd Ed., ISBN 0-201-43307-9, page 49
|
||||
{
|
||||
# ifdef PATH_MAX
|
||||
static std::size_t max = PATH_MAX;
|
||||
# else
|
||||
static std::size_t max = 0;
|
||||
# endif
|
||||
if (max == 0)
|
||||
{
|
||||
errno = 0;
|
||||
long tmp = ::pathconf("/", _PC_NAME_MAX);
|
||||
if (tmp < 0)
|
||||
{
|
||||
if (errno == 0)// indeterminate
|
||||
max = 4096; // guess
|
||||
else return std::error_code(errno, std::system_category());
|
||||
}
|
||||
else max = static_cast<std::size_t>(tmp + 1); // relative root
|
||||
}
|
||||
result = max;
|
||||
return ok;
|
||||
}
|
||||
|
||||
#if defined(__PGI) && defined(__USE_FILE_OFFSET64)
|
||||
#define dirent dirent64
|
||||
#endif
|
||||
|
||||
std::error_code dir_itr_first(void *& handle, void *& buffer,const char* dir, std::string& target,file_status &, file_status &)
|
||||
{
|
||||
if ((handle = ::opendir(dir))== 0)
|
||||
return std::error_code(errno, std::system_category());
|
||||
target = std::string("."); // string was static but caused trouble
|
||||
// when iteration called from dtor, after
|
||||
// static had already been destroyed
|
||||
std::size_t path_size (0); // initialization quiets gcc warning (ticket #3509)
|
||||
std::error_code ec = path_max(path_size);
|
||||
if (ec)return ec;
|
||||
dirent de;
|
||||
buffer = std::malloc((sizeof(dirent) - sizeof(de.d_name))
|
||||
+ path_size + 1); // + 1 for "/0"
|
||||
return ok;
|
||||
}
|
||||
|
||||
// warning: the only dirent member updated is d_name
|
||||
inline int readdir_r_simulator(DIR * dirp, struct dirent * entry,struct dirent ** result)// *result set to 0 on end of directory
|
||||
{
|
||||
errno = 0;
|
||||
|
||||
# if !defined(__CYGWIN__)\
|
||||
&& defined(_POSIX_THREAD_SAFE_FUNCTIONS)\
|
||||
&& defined(_SC_THREAD_SAFE_FUNCTIONS)\
|
||||
&& (_POSIX_THREAD_SAFE_FUNCTIONS+0 >= 0)\
|
||||
&& (!defined(__hpux) || defined(_REENTRANT)) \
|
||||
&& (!defined(_AIX) || defined(__THREAD_SAFE))
|
||||
if (::sysconf(_SC_THREAD_SAFE_FUNCTIONS)>= 0)
|
||||
{ return ::readdir_r(dirp, entry, result); }
|
||||
# endif
|
||||
|
||||
struct dirent * p;
|
||||
*result = 0;
|
||||
if ((p = ::readdir(dirp))== 0)
|
||||
return errno;
|
||||
std::strcpy(entry->d_name, p->d_name);
|
||||
*result = entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::error_code dir_itr_increment(void *& handle, void *& buffer,std::string& target, file_status & sf, file_status & symlink_sf)
|
||||
{
|
||||
assert(buffer != 0);
|
||||
dirent * entry(static_cast<dirent *>(buffer));
|
||||
dirent * result;
|
||||
int return_code;
|
||||
if ((return_code = readdir_r_simulator(static_cast<DIR*>(handle), entry, &result))!= 0)
|
||||
return std::error_code(errno, std::system_category());
|
||||
if (result == 0)
|
||||
return detail::dir_itr_close(handle, buffer);
|
||||
target = entry->d_name;
|
||||
# ifdef _DIRENT_HAVE_D_TYPE //BOOST_FILESYSTEM_STATUS_CACHE
|
||||
if (entry->d_type == DT_UNKNOWN) // filesystem does not supply d_type value
|
||||
{
|
||||
sf = symlink_sf = file_status(status_error);
|
||||
}
|
||||
else // filesystem supplies d_type value
|
||||
{
|
||||
if (entry->d_type == DT_DIR)
|
||||
sf = symlink_sf = file_status(directory_file);
|
||||
else if (entry->d_type == DT_REG)
|
||||
sf = symlink_sf = file_status(regular_file);
|
||||
else if (entry->d_type == DT_LNK)
|
||||
{
|
||||
sf = file_status(status_error);
|
||||
symlink_sf = file_status(symlink_file);
|
||||
}
|
||||
else sf = symlink_sf = file_status(status_error);
|
||||
}
|
||||
# else
|
||||
sf = symlink_sf = file_status(status_error);
|
||||
# endif
|
||||
return ok;
|
||||
}
|
||||
|
||||
// dir_itr_close is called both from the ~dir_itr_imp()destructor
|
||||
// and dir_itr_increment()
|
||||
std::error_code dir_itr_close( void *& handle, void *& buffer)
|
||||
{
|
||||
|
||||
std::free(buffer);
|
||||
buffer = 0;
|
||||
if (handle == 0)return ok;
|
||||
DIR * h(static_cast<DIR*>(handle));
|
||||
handle = 0;
|
||||
return std::error_code(::closedir(h)== 0 ? 0 : errno, std::system_category());
|
||||
|
||||
}
|
||||
|
||||
void directory_iterator_construct(directory_iterator& it,const path& p, std::error_code* ec)
|
||||
{
|
||||
if (error(p.empty() ? not_found_error_code.value() : 0, p, ec,
|
||||
"boost::filesystem::directory_iterator::construct"))
|
||||
return;
|
||||
|
||||
path::string_type filename;
|
||||
file_status file_stat, symlink_file_stat;
|
||||
std::error_code result = dir_itr_first(it.m_imp->handle,
|
||||
|
||||
it.m_imp->buffer,
|
||||
|
||||
p.c_str(), filename, file_stat, symlink_file_stat);
|
||||
|
||||
if (result)
|
||||
{
|
||||
it.m_imp.reset();
|
||||
error(result.value(), p,
|
||||
ec, "boost::filesystem::directory_iterator::construct");
|
||||
return;
|
||||
}
|
||||
|
||||
if (it.m_imp->handle == 0)
|
||||
it.m_imp.reset(); // eof, so make end iterator
|
||||
else // not eof
|
||||
{
|
||||
it.m_imp->dir_entry.assign(p / filename, file_stat, symlink_file_stat);
|
||||
if (filename[0] == dot // dot or dot-dot
|
||||
&& (filename.size()== 1
|
||||
|| (filename[1] == dot
|
||||
&& filename.size()== 2)))
|
||||
{ it.increment(*ec); }
|
||||
}
|
||||
}
|
||||
|
||||
void directory_iterator_increment(directory_iterator& it,std::error_code* ec)
|
||||
{
|
||||
assert(it.m_imp.get()&&"attempt to increment end iterator");
|
||||
assert(it.m_imp->handle != 0 && "internal program error");
|
||||
|
||||
path::string_type filename;
|
||||
file_status file_stat, symlink_file_stat;
|
||||
std::error_code temp_ec;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
temp_ec = dir_itr_increment(it.m_imp->handle,
|
||||
|
||||
it.m_imp->buffer,
|
||||
filename, file_stat, symlink_file_stat);
|
||||
|
||||
if (temp_ec) // happens if filesystem is corrupt, such as on a damaged optical disc
|
||||
{
|
||||
path error_path(it.m_imp->dir_entry.path().parent_path()); // fix ticket #5900
|
||||
it.m_imp.reset();
|
||||
if (ec == 0)
|
||||
//BOOST_FILESYSTEM_THROW(
|
||||
// filesystem_error("boost::filesystem::directory_iterator::operator++",
|
||||
// error_path,
|
||||
// error_code(FILESYSTEM_ERRNO, std::system_category())));
|
||||
throw filesystem_error("boost::filesystem::operator++");
|
||||
ec->assign(FILESYSTEM_ERRNO, std::system_category());
|
||||
return;
|
||||
}
|
||||
else if (ec != 0) ec->clear();
|
||||
|
||||
if (it.m_imp->handle == 0) // eof, make end
|
||||
{
|
||||
it.m_imp.reset();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(filename[0] == dot // !(dot or dot-dot)
|
||||
&& (filename.size()== 1
|
||||
|| (filename[1] == dot
|
||||
&& filename.size()== 2))))
|
||||
{
|
||||
it.m_imp->dir_entry.replace_filename(
|
||||
filename, file_stat, symlink_file_stat);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace detail
|
||||
}
|
||||
#endif
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
Reference in New Issue
Block a user