450 lines
13 KiB
C++
450 lines
13 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2020 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#ifndef XENIA_BASE_STRING_UTIL_H_
|
|
#define XENIA_BASE_STRING_UTIL_H_
|
|
|
|
#include <algorithm>
|
|
#include <charconv>
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <regex>
|
|
#include <string>
|
|
#include <variant>
|
|
|
|
#include "third_party/fmt/include/fmt/format.h"
|
|
#include "xenia/base/assert.h"
|
|
#include "xenia/base/memory.h"
|
|
#include "xenia/base/platform.h"
|
|
#include "xenia/base/string.h"
|
|
#include "xenia/base/vec128.h"
|
|
|
|
// TODO(gibbed): Clang and GCC don't have std::from_chars for floating point(!)
|
|
// despite it being part of the C++17 standard. Check this in the future to see
|
|
// if it's been resolved.
|
|
|
|
#if XE_COMPILER_CLANG || XE_COMPILER_GNUC
|
|
#include <cstdlib>
|
|
#endif
|
|
|
|
namespace xe {
|
|
namespace string_util {
|
|
|
|
enum class Safety {
|
|
IDontKnowWhatIAmDoing,
|
|
IKnowWhatIAmDoing,
|
|
};
|
|
|
|
inline size_t copy_truncating(char* dest, const std::string_view source,
|
|
size_t dest_buffer_count) {
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count - size_t(1));
|
|
std::memcpy(dest, source.data(), chars_copied);
|
|
dest[chars_copied] = '\0';
|
|
return chars_copied;
|
|
}
|
|
|
|
inline size_t copy_truncating(char16_t* dest, const std::u16string_view source,
|
|
size_t dest_buffer_count) {
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count - size_t(1));
|
|
std::memcpy(dest, source.data(), chars_copied * sizeof(char16_t));
|
|
dest[chars_copied] = u'\0';
|
|
return chars_copied;
|
|
}
|
|
|
|
inline size_t copy_and_swap_truncating(char16_t* dest,
|
|
const std::u16string_view source,
|
|
size_t dest_buffer_count) {
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count - size_t(1));
|
|
xe::copy_and_swap(dest, source.data(), chars_copied);
|
|
dest[chars_copied] = u'\0';
|
|
return chars_copied;
|
|
}
|
|
|
|
template <Safety safety = Safety::IDontKnowWhatIAmDoing>
|
|
inline size_t copy_maybe_truncating(char* dest, const std::string_view source,
|
|
size_t dest_buffer_count) {
|
|
static_assert(safety == Safety::IKnowWhatIAmDoing);
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count);
|
|
std::memcpy(dest, source.data(), chars_copied);
|
|
return chars_copied;
|
|
}
|
|
|
|
template <Safety safety = Safety::IDontKnowWhatIAmDoing>
|
|
inline size_t copy_maybe_truncating(char16_t* dest,
|
|
const std::u16string_view source,
|
|
size_t dest_buffer_count) {
|
|
static_assert(safety == Safety::IKnowWhatIAmDoing);
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count);
|
|
std::memcpy(dest, source.data(), chars_copied * sizeof(char16_t));
|
|
return chars_copied;
|
|
}
|
|
|
|
template <Safety safety = Safety::IDontKnowWhatIAmDoing>
|
|
inline size_t copy_and_swap_maybe_truncating(char16_t* dest,
|
|
const std::u16string_view source,
|
|
size_t dest_buffer_count) {
|
|
static_assert(safety == Safety::IKnowWhatIAmDoing);
|
|
if (!dest_buffer_count) {
|
|
return 0;
|
|
}
|
|
size_t chars_copied = std::min(source.size(), dest_buffer_count);
|
|
xe::copy_and_swap(dest, source.data(), chars_copied);
|
|
return chars_copied;
|
|
}
|
|
|
|
inline bool hex_string_to_array(std::vector<uint8_t>& output_array,
|
|
std::string_view value) {
|
|
if (value.rfind("0x", 0) == 0) {
|
|
value.remove_prefix(2);
|
|
}
|
|
|
|
output_array.reserve((value.size() + 1) / 2);
|
|
|
|
size_t remaining_length = value.size();
|
|
while (remaining_length > 0) {
|
|
uint8_t chars_to_read = remaining_length > 1 ? 2 : 1;
|
|
const char* substring_pointer =
|
|
value.data() + value.size() - remaining_length;
|
|
|
|
uint8_t string_value = 0;
|
|
std::from_chars_result result = std::from_chars(
|
|
substring_pointer, substring_pointer + chars_to_read, string_value, 16);
|
|
|
|
if (result.ec != std::errc() ||
|
|
result.ptr != substring_pointer + chars_to_read) {
|
|
output_array.clear();
|
|
return false;
|
|
}
|
|
|
|
output_array.push_back(string_value);
|
|
remaining_length -= chars_to_read;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline std::string BoolToString(bool value) { return value ? "true" : "false"; }
|
|
|
|
inline std::string ltrim(const std::string& value) {
|
|
return std::regex_replace(value, std::regex("^\\s+"), std::string(""));
|
|
}
|
|
|
|
inline std::string rtrim(const std::string& value) {
|
|
return std::regex_replace(value, std::regex("\\s+$"), std::string(""));
|
|
}
|
|
|
|
inline std::string trim(const std::string& value) {
|
|
return ltrim(rtrim(value));
|
|
}
|
|
|
|
inline std::string remove_eol(const std::string& value) {
|
|
std::string result = value;
|
|
result.erase(std::remove(result.begin(), result.end(), '\n'), result.cend());
|
|
return result;
|
|
}
|
|
|
|
inline std::string to_hex_string(uint32_t value) {
|
|
return fmt::format("{:08X}", value);
|
|
}
|
|
|
|
inline std::string to_hex_string(uint64_t value) {
|
|
return fmt::format("{:016X}", value);
|
|
}
|
|
|
|
inline std::string to_hex_string(float value) {
|
|
static_assert(sizeof(uint32_t) == sizeof(value));
|
|
uint32_t pun;
|
|
std::memcpy(&pun, &value, sizeof(value));
|
|
return to_hex_string(pun);
|
|
}
|
|
|
|
inline std::string to_hex_string(double value) {
|
|
static_assert(sizeof(uint64_t) == sizeof(value));
|
|
uint64_t pun;
|
|
std::memcpy(&pun, &value, sizeof(value));
|
|
return to_hex_string(pun);
|
|
}
|
|
|
|
inline std::string to_hex_string(const vec128_t& value) {
|
|
return fmt::format("[{:08X} {:08X} {:08X} {:08X}]", value.u32[0],
|
|
value.u32[1], value.u32[2], value.u32[3]);
|
|
}
|
|
|
|
template <typename T>
|
|
inline T from_string(const std::string_view value, bool force_hex = false) {
|
|
// Missing implementation for converting type T from string
|
|
throw;
|
|
}
|
|
|
|
namespace internal {
|
|
|
|
template <typename T, typename V = std::make_signed_t<T>>
|
|
inline T make_negative(T value) {
|
|
if constexpr (std::is_unsigned_v<T>) {
|
|
value = static_cast<T>(-static_cast<V>(value));
|
|
} else {
|
|
value = -value;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// integral_from_string
|
|
template <typename T>
|
|
inline T ifs(const std::string_view value, bool force_hex) {
|
|
int base = 10;
|
|
std::string_view range = value;
|
|
bool is_hex = force_hex;
|
|
bool is_negative = false;
|
|
if (utf8::starts_with(range, "-")) {
|
|
is_negative = true;
|
|
range = range.substr(1);
|
|
}
|
|
if (utf8::starts_with(range, "0x")) {
|
|
is_hex = true;
|
|
range = range.substr(2);
|
|
}
|
|
if (utf8::ends_with(range, "h")) {
|
|
is_hex = true;
|
|
range = range.substr(0, range.length() - 1);
|
|
}
|
|
T result;
|
|
if (is_hex) {
|
|
base = 16;
|
|
}
|
|
// TODO(gibbed): do something more with errors?
|
|
auto [p, error] =
|
|
std::from_chars(range.data(), range.data() + range.size(), result, base);
|
|
if (error != std::errc()) {
|
|
assert_always();
|
|
return T();
|
|
}
|
|
if (is_negative) {
|
|
result = make_negative(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// floating_point_from_string
|
|
template <typename T, typename PUN>
|
|
inline T fpfs(const std::string_view value, bool force_hex) {
|
|
static_assert(sizeof(T) == sizeof(PUN));
|
|
std::string_view range = value;
|
|
bool is_hex = force_hex;
|
|
bool is_negative = false;
|
|
if (utf8::starts_with(range, "-")) {
|
|
is_negative = true;
|
|
range = range.substr(1);
|
|
}
|
|
if (utf8::starts_with(range, "0x")) {
|
|
is_hex = true;
|
|
range = range.substr(2);
|
|
}
|
|
if (utf8::ends_with(range, "h")) {
|
|
is_hex = true;
|
|
range = range.substr(0, range.length() - 1);
|
|
}
|
|
T result;
|
|
if (is_hex) {
|
|
PUN pun = from_string<PUN>(range, true);
|
|
if (is_negative) {
|
|
pun = make_negative(pun);
|
|
}
|
|
std::memcpy(&result, &pun, sizeof(PUN));
|
|
} else {
|
|
auto temp = std::string(range);
|
|
result = static_cast<T>(std::strtod(temp.c_str(), nullptr));
|
|
if (is_negative) {
|
|
result = -result;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
template <>
|
|
inline bool from_string<bool>(const std::string_view value, bool force_hex) {
|
|
return value == "true" || value == "1";
|
|
}
|
|
|
|
template <>
|
|
inline int8_t from_string<int8_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<int8_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline uint8_t from_string<uint8_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<uint8_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline int16_t from_string<int16_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<int16_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline uint16_t from_string<uint16_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<uint16_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline int32_t from_string<int32_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<int32_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline uint32_t from_string<uint32_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<uint32_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline int64_t from_string<int64_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<int64_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline uint64_t from_string<uint64_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::ifs<uint64_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline float from_string<float>(const std::string_view value, bool force_hex) {
|
|
return internal::fpfs<float, uint32_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline double from_string<double>(const std::string_view value,
|
|
bool force_hex) {
|
|
return internal::fpfs<double, uint64_t>(value, force_hex);
|
|
}
|
|
|
|
template <>
|
|
inline vec128_t from_string<vec128_t>(const std::string_view value,
|
|
bool force_hex) {
|
|
if (!value.size()) {
|
|
return vec128_t();
|
|
}
|
|
vec128_t v;
|
|
#if XE_COMPILER_CLANG || XE_COMPILER_GNUC
|
|
auto temp = std::string(value);
|
|
auto p = temp.c_str();
|
|
auto end = temp.c_str() + temp.size();
|
|
#else
|
|
auto p = value.data();
|
|
auto end = value.data() + value.size();
|
|
#endif
|
|
bool is_hex = force_hex;
|
|
if (p != end && *p == '[') {
|
|
is_hex = true;
|
|
++p;
|
|
} else if (p != end && *p == '(') {
|
|
is_hex = false;
|
|
++p;
|
|
} else {
|
|
// Assume hex?
|
|
is_hex = true;
|
|
}
|
|
if (p == end) {
|
|
assert_always();
|
|
return vec128_t();
|
|
}
|
|
if (is_hex) {
|
|
for (size_t i = 0; i < 4; i++) {
|
|
while (p != end && (*p == ' ' || *p == ',')) {
|
|
++p;
|
|
}
|
|
if (p == end) {
|
|
assert_always();
|
|
return vec128_t();
|
|
}
|
|
auto result = std::from_chars(p, end, v.u32[i], 16);
|
|
if (result.ec != std::errc()) {
|
|
assert_always();
|
|
return vec128_t();
|
|
}
|
|
p = result.ptr;
|
|
}
|
|
} else {
|
|
for (size_t i = 0; i < 4; i++) {
|
|
while (p != end && (*p == ' ' || *p == ',')) {
|
|
++p;
|
|
}
|
|
if (p == end) {
|
|
assert_always();
|
|
return vec128_t();
|
|
}
|
|
#if XE_COMPILER_CLANG || XE_COMPILER_GNUC
|
|
char* next_p;
|
|
v.f32[i] = std::strtof(p, &next_p);
|
|
p = next_p;
|
|
#else
|
|
auto result =
|
|
std::from_chars(p, end, v.f32[i], std::chars_format::general);
|
|
if (result.ec != std::errc()) {
|
|
assert_always();
|
|
return vec128_t();
|
|
}
|
|
p = result.ptr;
|
|
#endif
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
|
|
inline size_t size_in_bytes(std::variant<std::string, std::u16string> string,
|
|
bool include_terminator = true) {
|
|
if (std::holds_alternative<std::string>(string)) {
|
|
return std::get<std::string>(string).size() + include_terminator;
|
|
} else if (std::holds_alternative<std::u16string>(string)) {
|
|
return (std::get<std::u16string>(string).size() + include_terminator) *
|
|
sizeof(char16_t);
|
|
} else {
|
|
assert_always();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline std::u16string read_u16string_and_swap(const char16_t* string_ptr) {
|
|
std::u16string input_str = std::u16string(string_ptr);
|
|
|
|
std::u16string output_str = {};
|
|
output_str.resize(input_str.size() + 1);
|
|
copy_and_swap_truncating(output_str.data(), input_str,
|
|
size_in_bytes(input_str, false));
|
|
output_str.pop_back(); // Remove nullptr added by copy_and_swap.
|
|
return output_str;
|
|
}
|
|
|
|
} // namespace string_util
|
|
} // namespace xe
|
|
|
|
#endif // XENIA_BASE_STRING_UTIL_H_
|