20 #define GETTEXT_DOMAIN "wesnoth-lib"
34 #include <boost/algorithm/string/predicate.hpp>
35 #include <boost/algorithm/string/replace.hpp>
36 #include <boost/filesystem.hpp>
37 #include <boost/filesystem/fstream.hpp>
38 #include <boost/format.hpp>
39 #include <boost/iostreams/device/file_descriptor.hpp>
40 #include <boost/iostreams/stream.hpp>
42 #if !defined(_WIN32) && !defined(__APPLE__)
44 #if BOOST_VERSION >= 108600
45 #include <boost/process/v2/environment.hpp>
47 #include <boost/process/search_path.hpp>
53 #include <boost/locale.hpp>
60 #ifndef VOLUME_NAME_NONE
61 #define VOLUME_NAME_NONE 0x4
67 #include <mach-o/dyld.h>
77 #if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
79 #define WESNOTH_BOOST_OS_IOS (__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000)
80 #include <SDL2/SDL_filesystem.h>
86 #define DBG_FS LOG_STREAM(debug, log_filesystem)
87 #define LOG_FS LOG_STREAM(info, log_filesystem)
88 #define WRN_FS LOG_STREAM(warn, log_filesystem)
89 #define ERR_FS LOG_STREAM(err, log_filesystem)
91 namespace bfs = boost::filesystem;
92 using boost::system::error_code;
100 std::string
path = WESNOTH_PATH;
105 #ifdef DEFAULT_PREFS_PATH
120 const std::string maincfg_filename =
"_main.cfg";
121 const std::string finalcfg_filename =
"_final.cfg";
122 const std::string initialcfg_filename =
"_initial.cfg";
125 class customcodecvt :
public std::codecvt<wchar_t , char , std::mbstate_t>
129 template<
typename char_t_to>
130 struct customcodecvt_do_conversion_writer
132 customcodecvt_do_conversion_writer(char_t_to*& _to_next, char_t_to* _to_end)
141 bool can_push(std::size_t count)
const
143 return static_cast<std::size_t
>(to_end - to_next) > count;
146 void push(char_t_to val)
148 assert(to_next != to_end);
153 template<
typename char_t_from,
typename char_t_to>
154 static void customcodecvt_do_conversion(std::mbstate_t& ,
155 const char_t_from* from,
156 const char_t_from* from_end,
157 const char_t_from*& from_next,
167 customcodecvt_do_conversion_writer<char_t_to> writer(to_next, to_end);
169 while(from_next != from_end) {
176 int do_encoding()
const noexcept
182 bool do_always_noconv()
const noexcept
187 int do_length(std::mbstate_t& ,
const char* ,
const char* , std::size_t )
const
190 throw "Not supported";
193 std::codecvt_base::result unshift(
194 std::mbstate_t& ,
char* ,
char* ,
char*& )
const
197 throw "Not supported";
201 std::codecvt_base::result do_in(std::mbstate_t& state,
203 const char* from_end,
204 const char*& from_next,
207 wchar_t*& to_next)
const
210 customcodecvt_do_conversion<char, wchar_t>(state, from, from_end, from_next, to, to_end, to_next);
213 return std::codecvt_base::error;
216 return std::codecvt_base::ok;
219 std::codecvt_base::result do_out(std::mbstate_t& state,
221 const wchar_t* from_end,
222 const wchar_t*& from_next,
225 char*& to_next)
const
228 customcodecvt_do_conversion<wchar_t, char>(state, from, from_end, from_next, to, to_end, to_next);
231 return std::codecvt_base::error;
234 return std::codecvt_base::ok;
248 utf8_loc = std::locale(utf8_loc,
new customcodecvt());
250 boost::filesystem::path::imbue(utf8_loc);
254 static static_runner static_bfs_path_imbuer;
256 bool is_filename_case_correct(
const std::string& fname,
const boost::iostreams::file_descriptor_source& fd)
258 wchar_t real_path[MAX_PATH];
259 GetFinalPathNameByHandleW(fd.handle(), real_path, MAX_PATH - 1, VOLUME_NAME_NONE);
266 bool is_filename_case_correct(
const std::string& ,
const boost::iostreams::file_descriptor_source& )
314 vec->push_back(file.generic_string());
316 vec->push_back(file.filename().generic_string());
323 return ec && ec != boost::system::errc::no_such_file_or_directory;
331 LOG_FS <<
"Failed to check if " << fpath.string() <<
" is a directory: " << ec.message();
342 ERR_FS <<
"Failed to check existence of file " << fpath.string() <<
": " << ec.message();
353 bfs::create_directory(dirpath, ec);
356 ERR_FS <<
"Failed to create directory " << dirpath.string() <<
": " << ec.message();
364 ERR_FS <<
"Could not open or create directory " << dirpath.string();
365 return std::string();
374 bfs::file_status
fs = bfs::status(dirpath, ec);
377 ERR_FS <<
"Failed to retrieve file status for " << dirpath.string() <<
": " << ec.message();
380 DBG_FS <<
"directory " << dirpath.string() <<
" exists, not creating";
383 ERR_FS <<
"cannot create directory " << dirpath.string() <<
"; file exists";
387 bool created = bfs::create_directory(dirpath, ec);
389 ERR_FS <<
"Failed to create directory " << dirpath.string() <<
": " << ec.message();
397 DBG_FS <<
"creating recursive directory: " << dirpath.string();
399 if(dirpath.empty()) {
404 bfs::file_status
fs = bfs::status(dirpath);
407 ERR_FS <<
"Failed to retrieve file status for " << dirpath.string() <<
": " << ec.message();
418 ERR_FS <<
"Could not create parents to " << dirpath.string();
426 while(fi != fe && pi != pe && *fi == *pi) {
460 std::vector<std::string>* files,
461 std::vector<std::string>* dirs,
480 LOG_FS <<
"searching for _main.cfg in directory " << dir;
481 const bfs::path maincfg = dirpath / maincfg_filename;
484 LOG_FS <<
"_main.cfg found : " << maincfg;
491 bfs::directory_iterator di(dirpath, ec);
492 bfs::directory_iterator end;
499 for(; di != end; ++di) {
501 bfs::file_status st = di->status(ec);
503 LOG_FS <<
"Failed to get file status of " << di->path().string() <<
": " << ec.message();
507 if(st.type() == bfs::regular_file) {
509 std::string basename = di->path().filename().string();
512 if(!basename.empty() && basename[0] ==
'.')
518 if(checksum !=
nullptr) {
525 LOG_FS <<
"Failed to read filesize of " << di->path().string() <<
": " << ec.message();
532 }
else if(st.type() == bfs::directory_file) {
533 std::string basename = di->path().filename().string();
535 if(!basename.empty() && basename[0] ==
'.') {
543 const bfs::path inner_main(di->path() / maincfg_filename);
544 bfs::file_status main_st = bfs::status(inner_main, ec);
547 LOG_FS <<
"Failed to get file status of " << inner_main.string() <<
": " << ec.message();
549 LOG_FS <<
"_main.cfg found : "
558 if(files !=
nullptr) {
559 std::sort(files->begin(), files->end());
562 if(dirs !=
nullptr) {
563 std::sort(dirs->begin(), dirs->end());
568 for(
unsigned int i = 0;
i < files->size();
i++) {
569 if(boost::algorithm::ends_with((*files)[
i],
"/" + finalcfg_filename)) {
570 files->push_back((*files)[
i]);
571 files->erase(files->begin() +
i);
578 for(
unsigned int i = 0;
i < files->size();
i++)
579 if(boost::algorithm::ends_with((*files)[
i],
"/" + initialcfg_filename)) {
584 std::string initialcfg = (*files)[foundit];
585 for(
unsigned int i = foundit;
i > 0;
i--)
586 (*files)[
i] = (*files)[
i - 1];
587 (*files)[0] = initialcfg;
599 std::string next_filename;
608 filename.setf(std::ios_base::right);
613 }
while(
file_exists(next_filename) && counter < 1000);
615 return next_filename;
627 std::ostringstream
s;
634 static std::string suffix;
646 #if defined(__APPLE__) && !defined(__IPHONEOS__)
652 static void migrate_apple_config_directory_for_unsandboxed_builds()
654 const char* home_str = getenv(
"HOME");
655 bfs::path home = home_str ? home_str :
".";
660 boost::filesystem::path new_saves_dir = home /
"Library/Containers/org.wesnoth.Wesnoth/Data/Library/Application Support/Wesnoth_";
665 LOG_FS <<
"Apple developer's userdata migration: symlinking " << old_saves_dir.string() <<
" to " << new_saves_dir.string();
666 bfs::create_symlink(new_saves_dir, old_saves_dir);
667 }
else if(!bfs::is_symlink(old_saves_dir)) {
668 ERR_FS <<
"Apple developer's userdata migration: Problem! Old (non-containerized) directory " << old_saves_dir.string() <<
" is not a symlink. Your savegames are scattered around 2 locations.";
678 #if defined(__APPLE__) && !defined(__IPHONEOS__)
679 migrate_apple_config_directory_for_unsandboxed_builds();
713 static utils::optional<std::string> get_games_path()
715 PWSTR docs_path =
nullptr;
716 HRESULT res = SHGetKnownFolderPath(FOLDERID_Documents, KF_FLAG_CREATE,
nullptr, &docs_path);
717 utils::optional<std::string>
path = utils::nullopt;
721 path = games_path.string();
723 ERR_FS <<
"Could not determine path to user's Documents folder! (" << std::hex <<
"0x" << res << std::dec <<
") "
724 <<
"Please report this as a bug.";
727 CoTaskMemFree(docs_path);
734 #ifdef PREFERENCES_DIR
735 if(newprefdir.empty()) {
736 newprefdir = PREFERENCES_DIR;
737 DBG_FS <<
"Using PREFERENCES_DIR '" << PREFERENCES_DIR <<
"'";
743 if(newprefdir.empty()) {
746 #elif defined(__APPLE__)
748 #elif defined(WESNOTH_BOOST_OS_IOS)
749 char* sdl_pref_path = SDL_GetPrefPath(
"wesnoth.org",
"iWesnoth");
751 newprefdir = std::string(sdl_pref_path);
752 SDL_free(sdl_pref_path);
757 const char*
h = std::getenv(
"HOME");
758 std::string home =
h ?
h :
"";
759 h = std::getenv(
"XDG_DATA_HOME");
760 std::string xdg_data_home =
h ?
h :
"";
761 if (!xdg_data_home.empty()) {
763 }
else if (!home.empty()) {
772 if(newprefdir[0] ==
'~') {
774 utils::optional<std::string> games_path = get_games_path();
780 WRN_FS <<
"Using current directory instead: " << dir.string();
783 const char*
h = std::getenv(
"HOME");
784 std::string home =
h ?
h :
"";
789 ERR_FS <<
"Unable to determine path to user's HOME.";
790 WRN_FS <<
"Using current directory instead: " << dir.string();
793 dir /= newprefdir.substr(1);
808 bool rename_dir(
const std::string& old_dir,
const std::string& new_dir)
811 bfs::rename(old_dir, new_dir, ec);
814 ERR_FS <<
"Failed to rename directory '" << old_dir <<
"' to '" << new_dir <<
"'";
824 ERR_FS <<
"could not open or create cache directory at " <<
cache_dir.string() <<
'\n';
835 assert(!
user_data_dir.empty() &&
"Attempted to access userdata location before userdata initialization!");
841 utils::optional<std::string> manual_path_opt;
843 boost::format manual_template(manual_dir +
"manual.%s.html");
844 bfs::path manual_path((manual_template % locale_code).str());
847 return "file://" + bfs::canonical(manual_path).string();
853 const auto& split_locale_code =
utils::split(locale_code,
'_');
854 const std::string& language_code = split_locale_code.empty() ?
"en" : split_locale_code[0];
855 manual_path = (manual_template % language_code).str();
859 return "file://" + bfs::canonical(manual_path).string();
878 #if defined(_X11) && !defined(PREFERENCES_DIR)
879 char const* xdg_cache = getenv(
"XDG_CACHE_HOME");
881 if(!xdg_cache || xdg_cache[0] ==
'\0') {
882 xdg_cache = getenv(
"HOME");
906 #if !defined(_WIN32) && !defined(_X11) && !defined(__APPLE__)
913 if(w_ver.major_version() != 1 || ms_ver.major_version() != 1) {
918 std::vector<other_version_dir> result;
921 for(
auto minor = w_ver.minor_version() + 4; minor >= ms_ver.minor_version(); --minor) {
922 if(minor == w_ver.minor_version())
927 version.set_minor_version(minor);
944 #elif defined(__APPLE__)
949 result.emplace_back(suffix,
path.string());
963 ERR_FS <<
"Failed to get current directory: " << ec.message();
967 return cwd.generic_string();
976 ERR_FS <<
"Failed to set current directory: " << ec.message();
979 LOG_FS <<
"Process working directory set to " << dir;
988 wchar_t process_path[MAX_PATH];
989 SetLastError(ERROR_SUCCESS);
991 GetModuleFileNameW(
nullptr, process_path, MAX_PATH);
993 if(GetLastError() != ERROR_SUCCESS) {
999 #elif defined(__APPLE__)
1000 std::vector<char> buffer(PATH_MAX, 0);
1001 uint32_t
size = PATH_MAX;
1002 if(_NSGetExecutablePath(&buffer[0], &
size) == 0) {
1003 buffer.resize(
size+1);
1004 return std::string(buffer.begin(), buffer.end());
1006 ERR_FS <<
"Path to wesnoth executable is too long";
1007 return get_cwd() +
"/The Battle for Wesnoth";
1014 bfs::path exe = bfs::read_symlink(self_exe, ec);
1016 return exe.string();
1024 #if BOOST_VERSION >= 108600
1025 bfs::path search = boost::process::v2::environment::find_executable(exe);
1027 bfs::path search = boost::process::search_path(exe);
1029 if(!search.empty()) {
1030 return search.string();
1035 #if BOOST_VERSION >= 108600
1036 search = boost::process::v2::environment::find_executable(exe);
1038 search = boost::process::search_path(exe);
1040 if(!search.empty()) {
1041 return search.string();
1045 return get_cwd() +
"/wesnoth";
1052 return path.parent_path().string();
1061 std::string
wesnothd = exe_dir +
"/wesnothd" + exe_name.substr(7);
1071 bool created = bfs::create_directory(
bfs::path(dirname), ec);
1073 ERR_FS <<
"Failed to create directory " << dirname <<
": " << ec.message();
1082 std::vector<std::string> files;
1083 std::vector<std::string> dirs;
1088 if(!files.empty()) {
1089 for(
const std::string&
f : files) {
1092 LOG_FS <<
"remove(" <<
f <<
"): " << ec.message();
1099 for(
const std::string&
d : dirs) {
1110 LOG_FS <<
"remove(" << dirname <<
"): " << ec.message();
1123 ERR_FS <<
"Could not delete file " <<
filename <<
": " << ec.message();
1131 std::ifstream file(fname, std::ios::binary);
1132 std::vector<uint8_t> file_contents;
1134 file_contents.reserve(
file_size(fname));
1135 file_contents.assign(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
1137 return file_contents;
1144 std::string
img =
"";
1146 if(name.find(
".") != std::string::npos) {
1148 img =
"data:image/" + name.substr(name.find(
".") + 1) +
";base64," +
base64::encode(file_contents);
1157 std::stringstream ss;
1164 LOG_FS <<
"Streaming " << fname <<
" for reading.";
1167 ERR_FS <<
"Trying to open file with empty name.";
1169 s->clear(std::ios_base::failbit);
1176 boost::iostreams::file_descriptor_source fd(
bfs::path(fname), std::ios_base::binary);
1179 if(!fd.is_open() && treat_failure_as_error) {
1180 ERR_FS <<
"Could not open '" << fname <<
"' for reading.";
1181 }
else if(!is_filename_case_correct(fname, fd)) {
1182 ERR_FS <<
"Not opening '" << fname <<
"' due to case mismatch.";
1184 s->clear(std::ios_base::failbit);
1188 return std::make_unique<boost::iostreams::stream<boost::iostreams::file_descriptor_source>>(fd, 4096, 0);
1189 }
catch(
const std::exception&) {
1190 if(treat_failure_as_error) {
1191 ERR_FS <<
"Could not open '" << fname <<
"' for reading.";
1195 s->clear(std::ios_base::failbit);
1202 LOG_FS <<
"streaming " << fname <<
" for writing.";
1204 boost::iostreams::file_descriptor_sink fd(
bfs::path(fname), mode);
1205 return std::make_unique<boost::iostreams::stream<boost::iostreams::file_descriptor_sink>>(fd, 4096, 0);
1206 }
catch(
const BOOST_IOSTREAMS_FAILURE&
e) {
1209 error_code ec_unused;
1210 if(create_directory && bfs::create_directories(
bfs::path(fname).parent_path(), ec_unused)) {
1219 void write_file(
const std::string& fname,
const std::string&
data, std::ios_base::openmode mode)
1222 os->exceptions(std::ios_base::goodbit);
1224 const std::size_t block_size = 4096;
1225 char buf[block_size];
1227 for(std::size_t
i = 0;
i <
data.size();
i += block_size) {
1228 const std::size_t bytes = std::min<std::size_t>(block_size,
data.size() -
i);
1229 std::copy(
data.begin() +
i,
data.begin() +
i + bytes, buf);
1231 os->write(buf, bytes);
1233 throw io_exception(
"Error writing to file: '" + fname +
"'");
1267 std::time_t mtime = bfs::last_write_time(
path, ec);
1269 LOG_FS <<
"Failed to read modification time of " <<
path.string() <<
": " << ec.message();
1310 LOG_FS <<
"Failed to read filesize of " << fname <<
": " << ec.message();
1312 }
else if(
size > std::numeric_limits<int>::max()) {
1313 return std::numeric_limits<int>::max();
1322 uintmax_t size_sum = 0;
1324 for(bfs::recursive_directory_iterator
i(
p), end;
i != end && !ec; ++
i) {
1325 if(bfs::is_regular_file(
i->path())) {
1331 LOG_FS <<
"Failed to read directorysize of " << pname <<
": " << ec.message();
1333 }
else if(size_sum > std::numeric_limits<int>::max()) {
1334 return std::numeric_limits<int>::max();
1340 std::string
base_name(
const std::string& file,
const bool remove_extension)
1342 if(!remove_extension) {
1343 return bfs::path(file).filename().string();
1351 return bfs::path(file).parent_path().string();
1364 p =
p.parent_path();
1369 }
while(ec && !
is_root(
p.string()));
1371 return ec ?
"" :
p.string();
1377 const std::string
s = std::string(1,
c);
1383 return bfs::path::preferred_separator;
1391 return ec ? false : !
p.has_parent_path();
1414 const std::wstring& wpath =
bfs::path{
path}.make_preferred().wstring();
1415 return PathIsRootW(wpath.c_str()) == TRUE;
1429 std::string
normalize_path(
const std::string& fpath,
bool normalize_separators,
bool resolve_dot_entries)
1436 bfs::path p = resolve_dot_entries ? bfs::canonical(fpath, ec) : bfs::absolute(fpath);
1442 if(normalize_separators) {
1443 return p.make_preferred().string();
1449 utils::optional<std::string>
to_asset_path(
const std::string&
path,
const std::string& addon_id,
const std::string& asset_type)
1453 bfs::path core_asset_dir = datadir /
"data" /
"core" / asset_type;
1454 bfs::path data_asset_dir = datadir / asset_type;
1462 outpath = bfs::relative(
path, core_asset_dir);
1467 outpath = bfs::relative(
path, data_asset_dir);
1469 }
else if(!addon_id.empty()) {
1471 addon_asset_dir /= asset_type;
1477 outpath = bfs::relative(
path, addon_asset_dir);
1482 return found ? utils::optional<std::string>{ outpath.string() } : utils::nullopt;
1499 std::set<std::string> binary_paths;
1501 typedef std::map<std::string, std::vector<std::string>> paths_map;
1502 paths_map binary_paths_cache;
1508 if(binary_paths.empty()) {
1509 binary_paths.insert(
"");
1535 std::string
path = bp[
"path"].str();
1536 if(
path.find(
"..") != std::string::npos) {
1537 ERR_FS <<
"Invalid binary path '" <<
path <<
"'";
1541 if(!
path.empty() &&
path.back() !=
'/')
1543 if(binary_paths.count(
path) == 0) {
1544 binary_paths.insert(
path);
1552 binary_paths_cache.clear();
1554 for(
const std::string&
p :
paths_) {
1555 binary_paths.erase(
p);
1561 binary_paths_cache.clear();
1566 DBG_FS <<
"Looking for '" << filename_str <<
"'.";
1568 if(filename_str.empty()) {
1569 LOG_FS <<
" invalid filename";
1573 if(filename_str.find(
"..") != std::string::npos) {
1574 ERR_FS <<
"Illegal path '" << filename_str <<
"' (\"..\" not allowed).";
1578 if(filename_str.find(
'\\') != std::string::npos) {
1579 ERR_FS <<
"Illegal path '" << filename_str
1580 << R
"end(' ("\" not allowed, for compatibility with GNU/Linux and macOS).)end";
1587 ERR_FS <<
"Illegal path '" << filename_str <<
"' (blacklisted filename).";
1591 if(std::any_of(filepath.begin(), filepath.end(),
1592 [](
const bfs::path& dirname) { return default_blacklist.match_dir(dirname.string()); })) {
1593 ERR_FS <<
"Illegal path '" << filename_str <<
"' (blacklisted directory name).";
1606 const paths_map::const_iterator itor = binary_paths_cache.find(
type);
1607 if(itor != binary_paths_cache.end()) {
1608 return itor->second;
1611 if(
type.find(
"..") != std::string::npos) {
1613 ERR_FS <<
"Invalid WML type '" <<
type <<
"' for binary paths";
1614 static std::vector<std::string>
dummy;
1618 std::vector<std::string>& res = binary_paths_cache[
type];
1622 for(
const std::string&
path : binary_paths) {
1649 std::string::size_type pos =
filename.rfind(
"../");
1650 if(pos != std::string::npos) {
1656 return utils::nullopt;
1663 const std::set<std::string> bpaths(temp.begin(), temp.end());
1664 for(
const std::string& bp : bpaths) {
1668 DBG_FS <<
" checking '" << bp <<
"'";
1671 DBG_FS <<
" found at '" << bpath.string() <<
"'";
1672 if(result.empty()) {
1673 result = bpath.string();
1675 WRN_FS <<
"Conflicting files in binary_path: '" << result
1676 <<
"' and '" << bpath.string() <<
"'";
1681 if(result.empty()) {
1683 return utils::nullopt;
1692 return utils::nullopt;
1698 DBG_FS <<
" checking '" << bp <<
"'";
1700 DBG_FS <<
" found at '" << bpath.string() <<
"'";
1701 return bpath.string();
1706 return utils::nullopt;
1709 utils::optional<std::string>
get_wml_location(
const std::string&
path,
const utils::optional<std::string>& current_dir)
1712 return utils::nullopt;
1718 if(
path[0] ==
'~') {
1720 DBG_FS <<
" trying '" << result.string() <<
"'";
1721 }
else if(*fpath.begin() ==
".") {
1723 WRN_FS <<
"Cannot resolve " <<
path <<
" since the current directory is unknown!";
1724 return utils::nullopt;
1730 WRN_FS <<
"Resolved path " <<
c <<
" is outside game and user data directories!";
1734 WRN_FS <<
"Cannot resolve " <<
path <<
" since the game data directory is unknown!";
1735 return utils::nullopt;
1742 return utils::nullopt;
1744 DBG_FS <<
" found: '" << result.string() <<
"'";
1745 return result.string();
1755 return "~" +
partial.generic_string();
1760 return partial.generic_string();
1770 return utils::nullopt;
1776 return partial.generic_string();
1781 return partial.generic_string();
1784 return full_path.generic_string();
1790 return program_name +
".exe";
1792 return program_name;
1799 const char* user_name = getenv(
"USERNAME");
1801 const char* user_name = getenv(
"USER");
1805 if(user_name !=
nullptr) {
1806 boost::replace_all(canonicalized, user_name,
"USER");
1809 return canonicalized;
1819 const std::size_t pos_ext = base.rfind(
".");
1821 std::string loc_base;
1822 if(pos_ext != std::string::npos) {
1823 loc_base = base.substr(0, pos_ext) + suff + base.substr(pos_ext);
1825 loc_base = base + suff;
1838 std::vector<std::string> langs =
utils::split(
_(
"language code for localized resources^en_US"));
1843 langs.push_back(
"en_US");
1844 for(
const std::string& lang : langs) {
1845 std::string loc_file = dir +
"/" +
"l10n" +
"/" + lang +
"/" + loc_base;
1851 return utils::nullopt;
1859 if(full_path.find(addons_path) == 0) {
1861 if(
path.size() > 0) {
1862 return path.begin()->string();
1866 return utils::nullopt;
A config object defines a single node in a WML file, with access to child nodes.
bool match_file(const std::string &name) const
A class grating read only view to a vector of config objects, viewed as one config with all children ...
config_array_view child_range(config_key_type key) const
Represents version numbers.
void set_major_version(unsigned int)
Sets the major version number.
unsigned int minor_version() const
Retrieves the minor version number (x2 in "x1.x2.x3").
unsigned int major_version() const
Retrieves the major version number (x1 in "x1.x2.x3").
Definitions for the interface to Wesnoth Markup Language (WML).
static lg::log_domain log_filesystem("filesystem")
Declarations for File-IO.
static std::string _(const char *str)
Standard logging facilities (interface).
std::string encode(utils::byte_view bytes)
auto parse_timestamp(long long val)
std::string get_legacy_editor_dir()
std::string get_cache_dir()
bool is_bzip2_file(const std::string &filename)
Returns true if the file ends with '.bz2'.
int dir_size(const std::string &pname)
Returns the sum of the sizes of the files contained in a directory.
static bfs::path subtract_path(const bfs::path &full, const bfs::path &prefix_path)
bool is_relative(const std::string &path)
Returns whether the path seems to be relative.
static const bfs::path & get_user_data_path()
filesystem::scoped_istream istream_file(const std::string &fname, bool treat_failure_as_error)
bool is_root(const std::string &path)
Returns whether the path is the root of the file hierarchy.
void get_files_in_dir(const std::string &dir, std::vector< std::string > *files, std::vector< std::string > *dirs, name_mode mode, filter_mode filter, reorder_mode reorder, file_tree_checksum *checksum)
Get a list of all files and/or directories in a given directory.
const std::string wml_extension
std::chrono::system_clock::time_point file_modified_time(const bfs::path &path)
bool is_cfg(const std::string &filename)
Returns true if the file ends with the wmlfile extension.
static bfs::path get_dir(const bfs::path &dirpath)
std::string get_user_data_dir()
std::string base_name(const std::string &file, const bool remove_extension)
Returns the base filename of a file, with directory name stripped.
std::string get_wml_persist_dir()
bool rename_dir(const std::string &old_dir, const std::string &new_dir)
static bool is_legal_file(const std::string &filename_str)
std::string get_exe_path()
void copy_file(const std::string &src, const std::string &dest)
Read a file and then writes it back out.
bool delete_file(const std::string &filename)
bool is_gzip_file(const std::string &filename)
Returns true if the file ends with '.gz'.
static bool file_exists(const bfs::path &fpath)
std::string get_exe_dir()
bool is_directory(const std::string &fname)
Returns true if the given file is a directory.
static bool is_directory_internal(const bfs::path &fpath)
bool delete_directory(const std::string &dirname, const bool keep_pbl)
std::string get_synced_prefs_file()
location of preferences file containing preferences that are synced between computers note that wesno...
utils::optional< std::string > get_wml_location(const std::string &path, const utils::optional< std::string > ¤t_dir)
Returns a translated path to the actual file or directory, if it exists.
std::string get_saves_dir()
std::string get_program_invocation(const std::string &program_name)
Returns the appropriate invocation for a Wesnoth-related binary, assuming that it is located in the s...
static bool is_prefix(const bfs::path &full, const bfs::path &prefix_path)
std::string read_file(const std::string &fname)
Basic disk I/O - read file.
std::string get_unsynced_prefs_file()
location of preferences file containing preferences that aren't synced between computers
const std::string map_extension
utils::optional< std::string > get_binary_file_location(const std::string &type, const std::string &filename)
Returns a complete path to the actual file of a given type, if it exists.
filesystem::scoped_ostream ostream_file(const std::string &fname, std::ios_base::openmode mode, bool create_directory)
static bool create_directory_if_missing_recursive(const bfs::path &dirpath)
int file_size(const std::string &fname)
Returns the size of a file, or -1 if the file doesn't exist.
bool is_mask(const std::string &filename)
Returns true if the file ends with the maskfile extension.
utils::optional< std::string > get_addon_id_from_path(const std::string &location)
Returns the add-on ID from a path.
std::string read_file_as_data_uri(const std::string &fname)
void set_cache_dir(const std::string &newcachedir)
const std::string mask_extension
std::unique_ptr< std::istream > scoped_istream
void clear_binary_paths_cache()
static bfs::path user_data_dir
void write_file(const std::string &fname, const std::string &data, std::ios_base::openmode mode)
Throws io_exception if an error occurs.
std::string get_short_wml_path(const std::string &filename)
Returns a short path to filename, skipping the (user) data directory.
std::string root_name(const std::string &path)
Returns the name of the root device if included in the given path.
std::string directory_name(const std::string &file)
Returns the directory name of a file, with filename stripped.
std::string get_logs_dir()
std::unique_ptr< std::ostream > scoped_ostream
static bool create_directory_if_missing(const bfs::path &dirpath)
utils::optional< std::string > get_binary_dir_location(const std::string &type, const std::string &filename)
Returns a complete path to the actual directory of a given type, if it exists.
bool is_userdata_initialized()
utils::optional< std::string > get_game_manual_file(const std::string &locale_code)
location of the game manual file correponding to the given locale (default: en)
std::string nearest_extant_parent(const std::string &file)
Finds the nearest parent in existence for a file or directory.
char path_separator()
Returns the standard path separator for the current platform.
std::string get_sync_dir()
parent directory for everything that should be synced between systems.
bool looks_like_pbl(const std::string &file)
std::string get_addons_data_dir()
static void push_if_exists(std::vector< std::string > *vec, const bfs::path &file, bool full)
bool is_map(const std::string &filename)
Returns true if the file ends with the mapfile extension.
bool make_directory(const std::string &dirname)
utils::optional< std::string > get_independent_binary_file_path(const std::string &type, const std::string &filename)
Returns an asset path to filename for binary path-independent use in saved games.
std::string get_wesnothd_name()
static void setup_user_data_dir()
const blacklist_pattern_list default_blacklist
std::string get_addons_dir()
bool set_cwd(const std::string &dir)
utils::optional< std::string > get_localized_path(const std::string &file, const std::string &suff)
Returns the localized version of the given filename, if it exists.
std::vector< other_version_dir > find_other_version_saves_dirs()
Searches for directories containing saves created by other versions of Wesnoth.
static bool check_prefix(bfs::path::iterator &fi, const bfs::path::iterator &fe, const bfs::path &prefix)
std::string get_next_filename(const std::string &name, const std::string &extension)
Get the next free filename using "name + number (3 digits) + extension" maximum 1000 files then start...
static void set_cache_path(bfs::path newcache)
std::vector< uint8_t > read_file_binary(const std::string &fname)
std::string sanitize_path(const std::string &path)
Sanitizes a path to remove references to the user's name.
std::string get_current_editor_dir(const std::string &addon_id)
const std::string get_version_path_suffix(const version_info &version)
static bool error_except_not_found(const error_code &ec)
bool is_path_sep(char c)
Returns whether c is a path separator.
static bfs::path cache_dir
utils::optional< std::string > to_asset_path(const std::string &path, const std::string &addon_id, const std::string &asset_type)
Helper function to convert absolute path to wesnoth relative path.
std::string normalize_path(const std::string &fpath, bool normalize_separators, bool resolve_dot_entries)
Returns the absolute path of a file.
void set_user_data_dir(std::string newprefdir)
const std::vector< std::string > & get_binary_paths(const std::string &type)
Returns a vector with all possible paths to a given type of binary, e.g.
static void init_binary_paths()
Game configuration data as global variables.
const version_info min_savegame_version(MIN_SAVEGAME_VERSION)
std::string default_preferences_path
const version_info wesnoth_version(VERSION)
const std::string observer_team_name
observer team name used for observer team chat
int cache_compression_level
void remove()
Removes a tip.
bool exists(const image::locator &i_locator)
Returns true if the given image actually exists, without loading it.
config read(std::istream &in, abstract_validator *validator)
void write(std::ostream &out, const configr_of &cfg, unsigned int level)
void move_log_file()
Move the log file to another directory.
std::string img(const std::string &src, const std::string &align, bool floating)
Generates a Help markup tag corresponding to an image.
rng * generator
This generator is automatically synced during synced context.
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
std::string get_unknown_exception_type()
Utility function for finding the type of thing caught with catch(...).
std::vector< std::string > split(const config_attribute_value &val)
std::string::const_iterator iterator
@ partial
There are still moves and/or attacks possible, but the unit doesn't fit in the "unmoved" status.
rect src
Non-transparent portion of the surface to compose.
std::string filename
Filename.
std::vector< std::string > paths_
void set_paths(const game_config_view &cfg)
std::chrono::system_clock::time_point modified
An exception object used when an IO error occurs.
static map_location::direction s