2022-04-28 18:24:11 +02:00
|
|
|
// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
|
|
|
|
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-25 02:03:43 +02:00
|
|
|
#include <algorithm>
|
2015-06-20 23:33:54 +02:00
|
|
|
#include <cctype>
|
2018-09-22 07:03:47 +02:00
|
|
|
#include <codecvt>
|
2018-11-13 20:09:05 +01:00
|
|
|
#include <locale>
|
|
|
|
#include <sstream>
|
2020-10-30 20:02:02 +01:00
|
|
|
|
2016-09-21 08:52:38 +02:00
|
|
|
#include "common/string_util.h"
|
2016-08-01 23:13:35 +02:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2016-12-03 21:08:02 +01:00
|
|
|
#include <windows.h>
|
2013-09-05 02:17:46 +02:00
|
|
|
#endif
|
|
|
|
|
2014-09-07 20:50:43 +02:00
|
|
|
namespace Common {
|
|
|
|
|
2014-04-15 03:25:46 +02:00
|
|
|
/// Make a string lowercase
|
2014-09-07 20:50:43 +02:00
|
|
|
std::string ToLower(std::string str) {
|
2018-07-25 02:03:43 +02:00
|
|
|
std::transform(str.begin(), str.end(), str.begin(),
|
2020-10-30 20:02:02 +01:00
|
|
|
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
|
2014-09-07 09:49:52 +02:00
|
|
|
return str;
|
2014-04-15 03:25:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Make a string uppercase
|
2014-09-07 20:50:43 +02:00
|
|
|
std::string ToUpper(std::string str) {
|
2018-07-25 02:03:43 +02:00
|
|
|
std::transform(str.begin(), str.end(), str.begin(),
|
2020-10-30 20:02:02 +01:00
|
|
|
[](unsigned char c) { return static_cast<char>(std::toupper(c)); });
|
2014-09-07 09:49:52 +02:00
|
|
|
return str;
|
2014-04-15 03:25:46 +02:00
|
|
|
}
|
|
|
|
|
2018-06-06 15:38:54 +02:00
|
|
|
std::string StringFromBuffer(const std::vector<u8>& data) {
|
|
|
|
return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
|
|
|
|
}
|
|
|
|
|
2013-09-05 02:17:46 +02:00
|
|
|
// Turns " hej " into "hej". Also handles tabs.
|
2016-09-18 02:38:01 +02:00
|
|
|
std::string StripSpaces(const std::string& str) {
|
2018-09-15 15:21:06 +02:00
|
|
|
const std::size_t s = str.find_first_not_of(" \t\r\n");
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
if (str.npos != s)
|
|
|
|
return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
|
|
|
|
else
|
|
|
|
return "";
|
2013-09-05 02:17:46 +02: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 02:38:01 +02:00
|
|
|
std::string StripQuotes(const std::string& s) {
|
2014-04-02 00:20:08 +02:00
|
|
|
if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
|
|
|
|
return s.substr(1, s.size() - 2);
|
|
|
|
else
|
|
|
|
return s;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::string StringFromBool(bool value) {
|
2014-04-02 00:20:08 +02:00
|
|
|
return value ? "True" : "False";
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
|
|
|
|
std::string* _pExtension) {
|
2014-04-02 00:20:08 +02:00
|
|
|
if (full_path.empty())
|
|
|
|
return false;
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t dir_end = full_path.find_last_of("/"
|
2016-09-18 02:38:01 +02:00
|
|
|
// windows needs the : included for something like just "C:" to be considered a directory
|
2013-09-05 02:17:46 +02:00
|
|
|
#ifdef _WIN32
|
2018-09-15 15:21:06 +02:00
|
|
|
"\\:"
|
2013-09-05 02:17:46 +02:00
|
|
|
#endif
|
2018-01-20 08:48:02 +01:00
|
|
|
);
|
2014-04-02 00:20:08 +02:00
|
|
|
if (std::string::npos == dir_end)
|
|
|
|
dir_end = 0;
|
|
|
|
else
|
|
|
|
dir_end += 1;
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t fname_end = full_path.rfind('.');
|
2014-04-02 00:20:08 +02:00
|
|
|
if (fname_end < dir_end || std::string::npos == fname_end)
|
|
|
|
fname_end = full_path.size();
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
if (_pPath)
|
|
|
|
*_pPath = full_path.substr(0, dir_end);
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
if (_pFilename)
|
|
|
|
*_pFilename = full_path.substr(dir_end, fname_end - dir_end);
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
if (_pExtension)
|
|
|
|
*_pExtension = full_path.substr(fname_end);
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
return true;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
|
2014-04-02 00:20:08 +02:00
|
|
|
std::istringstream iss(str);
|
|
|
|
output.resize(1);
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:36:30 +02:00
|
|
|
while (std::getline(iss, *output.rbegin(), delim)) {
|
|
|
|
output.emplace_back();
|
|
|
|
}
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
output.pop_back();
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2018-07-22 21:33:07 +02:00
|
|
|
std::string TabsToSpaces(int tab_size, std::string in) {
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t i = 0;
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:33:07 +02:00
|
|
|
while ((i = in.find('\t')) != std::string::npos) {
|
|
|
|
in.replace(i, 1, tab_size, ' ');
|
|
|
|
}
|
|
|
|
|
|
|
|
return in;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t pos = 0;
|
2014-09-08 20:48:59 +02:00
|
|
|
|
|
|
|
if (src == dest)
|
|
|
|
return result;
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
while ((pos = result.find(src, pos)) != std::string::npos) {
|
2014-04-02 00:20:08 +02:00
|
|
|
result.replace(pos, src.size(), dest);
|
2014-09-08 20:48:59 +02:00
|
|
|
pos += dest.length();
|
2014-04-02 00:20:08 +02:00
|
|
|
}
|
2014-09-08 20:48:59 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
return result;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::string UTF16ToUTF8(const std::u16string& input) {
|
2014-11-10 23:36:32 +01:00
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
|
|
|
|
return convert.to_bytes(input);
|
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::u16string UTF8ToUTF16(const std::string& input) {
|
2014-11-10 23:36:32 +01:00
|
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
|
|
|
|
return convert.from_bytes(input);
|
|
|
|
}
|
|
|
|
|
2018-09-22 07:03:47 +02:00
|
|
|
#ifdef _WIN32
|
2016-09-18 02:38:01 +02:00
|
|
|
static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
|
2018-07-22 21:47:37 +02:00
|
|
|
const auto size =
|
2016-09-18 02:38:01 +02:00
|
|
|
MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:47:37 +02:00
|
|
|
if (size == 0) {
|
|
|
|
return L"";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::wstring output(size, L'\0');
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:47:37 +02:00
|
|
|
if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
|
|
|
|
&output[0], static_cast<int>(output.size()))) {
|
2014-04-02 00:20:08 +02:00
|
|
|
output.clear();
|
2018-07-22 21:47:37 +02:00
|
|
|
}
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
return output;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::string UTF16ToUTF8(const std::wstring& input) {
|
2018-07-22 21:47:37 +02:00
|
|
|
const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
|
2016-09-18 02:38:01 +02:00
|
|
|
nullptr, 0, nullptr, nullptr);
|
2018-07-22 21:47:37 +02:00
|
|
|
if (size == 0) {
|
|
|
|
return "";
|
|
|
|
}
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:47:37 +02:00
|
|
|
std::string output(size, '\0');
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2018-07-22 21:47:37 +02: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 00:20:08 +02:00
|
|
|
output.clear();
|
2018-07-22 21:47:37 +02:00
|
|
|
}
|
2013-09-05 02:17:46 +02:00
|
|
|
|
2014-04-02 00:20:08 +02:00
|
|
|
return output;
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
std::wstring UTF8ToUTF16W(const std::string& input) {
|
2014-04-02 00:20:08 +02:00
|
|
|
return CPToUTF16(CP_UTF8, input);
|
2013-09-05 02:17:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2014-09-07 20:50:43 +02:00
|
|
|
|
2022-05-16 00:06:33 +02:00
|
|
|
std::u16string U16StringFromBuffer(const u16* input, std::size_t length) {
|
|
|
|
return std::u16string(reinterpret_cast<const char16_t*>(input), length);
|
|
|
|
}
|
|
|
|
|
2021-10-14 19:11:08 +02:00
|
|
|
std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer, std::size_t max_len) {
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t len = 0;
|
2021-10-14 19:11:08 +02:00
|
|
|
while (len < buffer.length() && len < max_len && buffer[len] != '\0') {
|
2015-05-07 02:32:52 +02:00
|
|
|
++len;
|
2021-10-14 19:11:08 +02:00
|
|
|
}
|
|
|
|
return std::string(buffer.begin(), buffer.begin() + len);
|
2015-05-07 02:32:52 +02:00
|
|
|
}
|
2018-03-22 11:21:29 +01:00
|
|
|
|
2018-11-11 22:39:25 +01:00
|
|
|
std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
|
2018-11-09 23:03:54 +01:00
|
|
|
std::size_t max_len) {
|
|
|
|
std::size_t len = 0;
|
2021-10-13 18:49:22 +02:00
|
|
|
while (len < buffer.length() && len < max_len && buffer[len] != '\0') {
|
2018-11-09 23:03:54 +01:00
|
|
|
++len;
|
2021-10-13 18:49:22 +02:00
|
|
|
}
|
2018-11-11 22:39:25 +01:00
|
|
|
return std::u16string(buffer.begin(), buffer.begin() + len);
|
2018-11-09 23:03:54 +01:00
|
|
|
}
|
|
|
|
|
2018-01-20 08:48:02 +01:00
|
|
|
} // namespace Common
|