2014-12-17 08:38:14 +03:00
|
|
|
// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
2013-09-05 04:17:46 +04:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-07-25 03:03:43 +03:00
|
|
|
#include <algorithm>
|
2015-06-21 00:33:54 +03:00
|
|
|
#include <cctype>
|
|
|
|
#include <cerrno>
|
|
|
|
#include <cstdio>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <cstring>
|
2015-05-06 10:06:12 +03:00
|
|
|
#include "common/common_paths.h"
|
|
|
|
#include "common/logging/log.h"
|
2016-09-21 09:52:38 +03:00
|
|
|
#include "common/string_util.h"
|
2016-08-02 00:13:35 +03:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2016-09-18 03:38:01 +03:00
|
|
|
#include <codecvt>
|
2016-12-03 23:08:02 +03:00
|
|
|
#include <windows.h>
|
2016-09-18 03:38:01 +03:00
|
|
|
#include "common/common_funcs.h"
|
2013-09-05 04:17:46 +04:00
|
|
|
#else
|
2016-09-18 03:38:01 +03:00
|
|
|
#include <iconv.h>
|
2013-09-05 04:17:46 +04:00
|
|
|
#endif
|
|
|
|
|
2014-09-07 22:50:43 +04:00
|
|
|
namespace Common {
|
|
|
|
|
2014-04-15 05:25:46 +04:00
|
|
|
/// Make a string lowercase
|
2014-09-07 22:50:43 +04:00
|
|
|
std::string ToLower(std::string str) {
|
2018-07-25 03:03:43 +03:00
|
|
|
std::transform(str.begin(), str.end(), str.begin(),
|
|
|
|
[](unsigned char c) { return std::tolower(c); });
|
2014-09-07 11:49:52 +04:00
|
|
|
return str;
|
2014-04-15 05:25:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Make a string uppercase
|
2014-09-07 22:50:43 +04:00
|
|
|
std::string ToUpper(std::string str) {
|
2018-07-25 03:03:43 +03:00
|
|
|
std::transform(str.begin(), str.end(), str.begin(),
|
|
|
|
[](unsigned char c) { return std::toupper(c); });
|
2014-09-07 11:49:52 +04:00
|
|
|
return str;
|
2014-04-15 05:25:46 +04:00
|
|
|
}
|
|
|
|
|
2013-09-05 04:17:46 +04:00
|
|
|
// For Debugging. Read out an u8 array.
|
2017-09-27 02:26:09 +03:00
|
|
|
std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
|
2014-04-02 02:20:08 +04:00
|
|
|
std::ostringstream oss;
|
|
|
|
oss << std::setfill('0') << std::hex;
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
for (int line = 0; size; ++data, --size) {
|
2014-04-02 02:20:08 +04:00
|
|
|
oss << std::setw(2) << (int)*data;
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
if (line_len == ++line) {
|
2014-04-02 02:20:08 +04:00
|
|
|
oss << '\n';
|
|
|
|
line = 0;
|
2016-09-18 03:38:01 +03:00
|
|
|
} else if (spaces)
|
2014-04-02 02:20:08 +04:00
|
|
|
oss << ' ';
|
|
|
|
}
|
|
|
|
|
|
|
|
return oss.str();
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2018-06-06 16:38:54 +03:00
|
|
|
std::string StringFromBuffer(const std::vector<u8>& data) {
|
|
|
|
return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
|
|
|
|
}
|
|
|
|
|
2013-09-05 04:17:46 +04:00
|
|
|
// Turns " hej " into "hej". Also handles tabs.
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string StripSpaces(const std::string& str) {
|
2014-04-02 02:20:08 +04:00
|
|
|
const size_t s = str.find_first_not_of(" \t\r\n");
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (str.npos != s)
|
|
|
|
return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
|
|
|
|
else
|
|
|
|
return "";
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// "\"hello\"" is turned to "hello"
|
|
|
|
// This one assumes that the string has already been space stripped in both
|
|
|
|
// ends, as done by StripSpaces above, for example.
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string StripQuotes(const std::string& s) {
|
2014-04-02 02:20:08 +04:00
|
|
|
if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
|
|
|
|
return s.substr(1, s.size() - 2);
|
|
|
|
else
|
|
|
|
return s;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
bool TryParse(const std::string& str, u32* const output) {
|
|
|
|
char* endptr = nullptr;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
// Reset errno to a value other than ERANGE
|
|
|
|
errno = 0;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
unsigned long value = strtoul(str.c_str(), &endptr, 0);
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (!endptr || *endptr)
|
|
|
|
return false;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (errno == ERANGE)
|
|
|
|
return false;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
|
|
|
#if ULONG_MAX > UINT_MAX
|
2016-09-18 03:38:01 +03:00
|
|
|
if (value >= 0x100000000ull && value <= 0xFFFFFFFF00000000ull)
|
2014-04-02 02:20:08 +04:00
|
|
|
return false;
|
2013-09-05 04:17:46 +04:00
|
|
|
#endif
|
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
*output = static_cast<u32>(value);
|
|
|
|
return true;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
bool TryParse(const std::string& str, bool* const output) {
|
2014-10-24 08:17:01 +04:00
|
|
|
if ("1" == str || "true" == ToLower(str))
|
2014-04-02 02:20:08 +04:00
|
|
|
*output = true;
|
2014-10-24 08:17:01 +04:00
|
|
|
else if ("0" == str || "false" == ToLower(str))
|
2014-04-02 02:20:08 +04:00
|
|
|
*output = false;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string StringFromBool(bool value) {
|
2014-04-02 02:20:08 +04:00
|
|
|
return value ? "True" : "False";
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
|
|
|
|
std::string* _pExtension) {
|
2014-04-02 02:20:08 +04:00
|
|
|
if (full_path.empty())
|
|
|
|
return false;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
size_t dir_end = full_path.find_last_of("/"
|
2016-09-18 03:38:01 +03:00
|
|
|
// windows needs the : included for something like just "C:" to be considered a directory
|
2013-09-05 04:17:46 +04:00
|
|
|
#ifdef _WIN32
|
2018-07-13 06:22:59 +03:00
|
|
|
"\\:"
|
2013-09-05 04:17:46 +04:00
|
|
|
#endif
|
2018-01-20 10:48:02 +03:00
|
|
|
);
|
2014-04-02 02:20:08 +04:00
|
|
|
if (std::string::npos == dir_end)
|
|
|
|
dir_end = 0;
|
|
|
|
else
|
|
|
|
dir_end += 1;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
size_t fname_end = full_path.rfind('.');
|
|
|
|
if (fname_end < dir_end || std::string::npos == fname_end)
|
|
|
|
fname_end = full_path.size();
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (_pPath)
|
|
|
|
*_pPath = full_path.substr(0, dir_end);
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (_pFilename)
|
|
|
|
*_pFilename = full_path.substr(dir_end, fname_end - dir_end);
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
if (_pExtension)
|
|
|
|
*_pExtension = full_path.substr(fname_end);
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
return true;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path,
|
|
|
|
const std::string& _Filename) {
|
2014-04-02 02:20:08 +04:00
|
|
|
_CompleteFilename = _Path;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
// check for seperator
|
|
|
|
if (DIR_SEP_CHR != *_CompleteFilename.rbegin())
|
|
|
|
_CompleteFilename += DIR_SEP_CHR;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
// add the filename
|
|
|
|
_CompleteFilename += _Filename;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
|
2014-04-02 02:20:08 +04:00
|
|
|
std::istringstream iss(str);
|
|
|
|
output.resize(1);
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:36:30 +03:00
|
|
|
while (std::getline(iss, *output.rbegin(), delim)) {
|
|
|
|
output.emplace_back();
|
|
|
|
}
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
output.pop_back();
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2018-07-22 22:33:07 +03:00
|
|
|
std::string TabsToSpaces(int tab_size, std::string in) {
|
2014-04-02 02:20:08 +04:00
|
|
|
size_t i = 0;
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:33:07 +03:00
|
|
|
while ((i = in.find('\t')) != std::string::npos) {
|
|
|
|
in.replace(i, 1, tab_size, ' ');
|
|
|
|
}
|
|
|
|
|
|
|
|
return in;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
|
2014-09-08 22:48:59 +04:00
|
|
|
size_t pos = 0;
|
|
|
|
|
|
|
|
if (src == dest)
|
|
|
|
return result;
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
while ((pos = result.find(src, pos)) != std::string::npos) {
|
2014-04-02 02:20:08 +04:00
|
|
|
result.replace(pos, src.size(), dest);
|
2014-09-08 22:48:59 +04:00
|
|
|
pos += dest.length();
|
2014-04-02 02:20:08 +04:00
|
|
|
}
|
2014-09-08 22:48:59 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
return result;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-08-02 00:13:35 +03:00
|
|
|
#ifdef _WIN32
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string UTF16ToUTF8(const std::u16string& input) {
|
2015-08-03 00:43:33 +03:00
|
|
|
#if _MSC_VER >= 1900
|
|
|
|
// Workaround for missing char16_t/char32_t instantiations in MSVC2015
|
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
|
|
|
|
std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
|
|
|
|
return convert.to_bytes(tmp_buffer);
|
|
|
|
#else
|
2014-11-11 01:36:32 +03:00
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
|
|
|
|
return convert.to_bytes(input);
|
2015-08-03 00:43:33 +03:00
|
|
|
#endif
|
2014-11-11 01:36:32 +03:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::u16string UTF8ToUTF16(const std::string& input) {
|
2015-08-03 00:43:33 +03:00
|
|
|
#if _MSC_VER >= 1900
|
|
|
|
// Workaround for missing char16_t/char32_t instantiations in MSVC2015
|
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
|
|
|
|
auto tmp_buffer = convert.from_bytes(input);
|
|
|
|
return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
|
|
|
|
#else
|
2014-11-11 01:36:32 +03:00
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
|
|
|
|
return convert.from_bytes(input);
|
2015-08-03 00:43:33 +03:00
|
|
|
#endif
|
2014-11-11 01:36:32 +03:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
|
2018-07-22 22:47:37 +03:00
|
|
|
const auto size =
|
2016-09-18 03:38:01 +03:00
|
|
|
MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
if (size == 0) {
|
|
|
|
return L"";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::wstring output(size, L'\0');
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
|
|
|
|
&output[0], static_cast<int>(output.size()))) {
|
2014-04-02 02:20:08 +04:00
|
|
|
output.clear();
|
2018-07-22 22:47:37 +03:00
|
|
|
}
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
return output;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string UTF16ToUTF8(const std::wstring& input) {
|
2018-07-22 22:47:37 +03:00
|
|
|
const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
|
2016-09-18 03:38:01 +03:00
|
|
|
nullptr, 0, nullptr, nullptr);
|
2018-07-22 22:47:37 +03:00
|
|
|
if (size == 0) {
|
|
|
|
return "";
|
|
|
|
}
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
std::string output(size, '\0');
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
|
|
|
|
&output[0], static_cast<int>(output.size()), nullptr,
|
|
|
|
nullptr)) {
|
2014-04-02 02:20:08 +04:00
|
|
|
output.clear();
|
2018-07-22 22:47:37 +03:00
|
|
|
}
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
return output;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::wstring UTF8ToUTF16W(const std::string& input) {
|
2014-04-02 02:20:08 +04:00
|
|
|
return CPToUTF16(CP_UTF8, input);
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string SHIFTJISToUTF8(const std::string& input) {
|
2014-04-02 02:20:08 +04:00
|
|
|
return UTF16ToUTF8(CPToUTF16(932, input));
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string CP1252ToUTF8(const std::string& input) {
|
2014-04-02 02:20:08 +04:00
|
|
|
return UTF16ToUTF8(CPToUTF16(1252, input));
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
template <typename T>
|
2016-09-18 03:38:01 +03:00
|
|
|
static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
|
2014-04-02 02:20:08 +04:00
|
|
|
iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
|
2016-09-18 03:38:01 +03:00
|
|
|
if ((iconv_t)(-1) == conv_desc) {
|
2018-07-02 19:13:26 +03:00
|
|
|
LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
|
2014-11-11 01:36:32 +03:00
|
|
|
iconv_close(conv_desc);
|
|
|
|
return {};
|
2014-04-02 02:20:08 +04:00
|
|
|
}
|
|
|
|
|
2014-11-11 01:36:32 +03:00
|
|
|
const size_t in_bytes = sizeof(T) * input.size();
|
|
|
|
// Multiply by 4, which is the max number of bytes to encode a codepoint
|
|
|
|
const size_t out_buffer_size = 4 * in_bytes;
|
2014-04-02 02:20:08 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
std::string out_buffer(out_buffer_size, '\0');
|
2014-04-02 02:20:08 +04:00
|
|
|
|
2014-11-11 01:36:32 +03:00
|
|
|
auto src_buffer = &input[0];
|
|
|
|
size_t src_bytes = in_bytes;
|
|
|
|
auto dst_buffer = &out_buffer[0];
|
|
|
|
size_t dst_bytes = out_buffer.size();
|
2014-04-02 02:20:08 +04:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
while (0 != src_bytes) {
|
|
|
|
size_t const iconv_result =
|
|
|
|
iconv(conv_desc, (char**)(&src_buffer), &src_bytes, &dst_buffer, &dst_bytes);
|
2014-11-11 01:36:32 +03:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
if (static_cast<size_t>(-1) == iconv_result) {
|
|
|
|
if (EILSEQ == errno || EINVAL == errno) {
|
2014-11-11 01:36:32 +03:00
|
|
|
// Try to skip the bad character
|
2016-09-18 03:38:01 +03:00
|
|
|
if (0 != src_bytes) {
|
2014-11-11 01:36:32 +03:00
|
|
|
--src_bytes;
|
|
|
|
++src_buffer;
|
2014-04-02 02:20:08 +04:00
|
|
|
}
|
2016-09-18 03:38:01 +03:00
|
|
|
} else {
|
2018-07-02 19:13:26 +03:00
|
|
|
LOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
|
2014-11-11 01:36:32 +03:00
|
|
|
break;
|
|
|
|
}
|
2014-04-02 02:20:08 +04:00
|
|
|
}
|
2014-11-11 01:36:32 +03:00
|
|
|
}
|
2014-04-02 02:20:08 +04:00
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
std::string result;
|
2014-11-11 01:36:32 +03:00
|
|
|
out_buffer.resize(out_buffer_size - dst_bytes);
|
|
|
|
out_buffer.swap(result);
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2014-11-11 01:36:32 +03:00
|
|
|
iconv_close(conv_desc);
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2014-11-11 01:36:32 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::u16string UTF8ToUTF16(const std::string& input) {
|
2014-12-10 09:06:53 +03:00
|
|
|
iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
|
2016-09-18 03:38:01 +03:00
|
|
|
if ((iconv_t)(-1) == conv_desc) {
|
2018-07-02 19:13:26 +03:00
|
|
|
LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
|
2014-04-02 02:20:08 +04:00
|
|
|
iconv_close(conv_desc);
|
2014-11-11 01:36:32 +03:00
|
|
|
return {};
|
2014-04-02 02:20:08 +04:00
|
|
|
}
|
2014-11-11 01:36:32 +03:00
|
|
|
|
|
|
|
const size_t in_bytes = sizeof(char) * input.size();
|
|
|
|
// Multiply by 4, which is the max number of bytes to encode a codepoint
|
|
|
|
const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
|
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
std::u16string out_buffer(out_buffer_size, char16_t{});
|
2014-11-11 01:36:32 +03:00
|
|
|
|
|
|
|
char* src_buffer = const_cast<char*>(&input[0]);
|
|
|
|
size_t src_bytes = in_bytes;
|
|
|
|
char* dst_buffer = (char*)(&out_buffer[0]);
|
|
|
|
size_t dst_bytes = out_buffer.size();
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
while (0 != src_bytes) {
|
|
|
|
size_t const iconv_result =
|
|
|
|
iconv(conv_desc, &src_buffer, &src_bytes, &dst_buffer, &dst_bytes);
|
2014-11-11 01:36:32 +03:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
if (static_cast<size_t>(-1) == iconv_result) {
|
|
|
|
if (EILSEQ == errno || EINVAL == errno) {
|
2014-11-11 01:36:32 +03:00
|
|
|
// Try to skip the bad character
|
2016-09-18 03:38:01 +03:00
|
|
|
if (0 != src_bytes) {
|
2014-11-11 01:36:32 +03:00
|
|
|
--src_bytes;
|
|
|
|
++src_buffer;
|
|
|
|
}
|
2016-09-18 03:38:01 +03:00
|
|
|
} else {
|
2018-07-02 19:13:26 +03:00
|
|
|
LOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
|
2014-11-11 01:36:32 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-22 22:47:37 +03:00
|
|
|
std::u16string result;
|
2014-11-11 01:36:32 +03:00
|
|
|
out_buffer.resize(out_buffer_size - dst_bytes);
|
|
|
|
out_buffer.swap(result);
|
|
|
|
|
|
|
|
iconv_close(conv_desc);
|
2014-11-19 11:49:13 +03:00
|
|
|
|
2014-04-02 02:20:08 +04:00
|
|
|
return result;
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string UTF16ToUTF8(const std::u16string& input) {
|
2014-12-10 09:06:53 +03:00
|
|
|
return CodeToUTF8("UTF-16LE", input);
|
2014-11-11 01:36:32 +03:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string CP1252ToUTF8(const std::string& input) {
|
|
|
|
// return CodeToUTF8("CP1252//TRANSLIT", input);
|
|
|
|
// return CodeToUTF8("CP1252//IGNORE", input);
|
2014-04-02 02:20:08 +04:00
|
|
|
return CodeToUTF8("CP1252", input);
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string SHIFTJISToUTF8(const std::string& input) {
|
|
|
|
// return CodeToUTF8("CP932", input);
|
2014-04-02 02:20:08 +04:00
|
|
|
return CodeToUTF8("SJIS", input);
|
2013-09-05 04:17:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2014-09-07 22:50:43 +04:00
|
|
|
|
2016-09-18 03:38:01 +03:00
|
|
|
std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len) {
|
2015-05-07 03:32:52 +03:00
|
|
|
size_t len = 0;
|
|
|
|
while (len < max_len && buffer[len] != '\0')
|
|
|
|
++len;
|
|
|
|
|
|
|
|
return std::string(buffer, len);
|
|
|
|
}
|
2018-03-22 13:21:29 +03:00
|
|
|
|
|
|
|
const char* TrimSourcePath(const char* path, const char* root) {
|
|
|
|
const char* p = path;
|
|
|
|
|
|
|
|
while (*p != '\0') {
|
|
|
|
const char* next_slash = p;
|
|
|
|
while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
|
|
|
|
++next_slash;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool is_src = Common::ComparePartialString(p, next_slash, root);
|
|
|
|
p = next_slash;
|
|
|
|
|
|
|
|
if (*p != '\0') {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if (is_src) {
|
|
|
|
path = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2018-01-20 10:48:02 +03:00
|
|
|
} // namespace Common
|