310 lines
9.7 KiB
C++
310 lines
9.7 KiB
C++
#ifndef UTILS_HPP
|
|
#define UTILS_HPP
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "utils/common.hpp"
|
|
#include "utils/error.hpp"
|
|
#include "utils/optional.hpp"
|
|
#include "utils/result.hpp"
|
|
|
|
namespace cpptrace {
|
|
namespace detail {
|
|
bool isatty(int fd);
|
|
int fileno(std::FILE* stream);
|
|
|
|
inline std::vector<std::string> split(const std::string& str, const std::string& delims) {
|
|
std::vector<std::string> vec;
|
|
std::size_t old_pos = 0;
|
|
std::size_t pos = 0;
|
|
while((pos = str.find_first_of(delims, old_pos)) != std::string::npos) {
|
|
vec.emplace_back(str.substr(old_pos, pos - old_pos));
|
|
old_pos = pos + 1;
|
|
}
|
|
vec.emplace_back(str.substr(old_pos));
|
|
return vec;
|
|
}
|
|
|
|
template<typename C>
|
|
std::string join(const C& container, const std::string& delim) {
|
|
auto iter = std::begin(container);
|
|
auto end = std::end(container);
|
|
std::string str;
|
|
if(std::distance(iter, end) > 0) {
|
|
str += *iter;
|
|
while(++iter != end) {
|
|
str += delim;
|
|
str += *iter;
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// first value in a sorted range such that *it <= value
|
|
template<typename ForwardIt, typename T>
|
|
ForwardIt first_less_than_or_equal(ForwardIt begin, ForwardIt end, const T& value) {
|
|
auto it = std::upper_bound(begin, end, value);
|
|
// it is first > value, we want first <= value
|
|
if(it != begin) {
|
|
return --it;
|
|
}
|
|
return end;
|
|
}
|
|
|
|
// first value in a sorted range such that *it <= value
|
|
template<typename ForwardIt, typename T, typename Compare>
|
|
ForwardIt first_less_than_or_equal(ForwardIt begin, ForwardIt end, const T& value, Compare compare) {
|
|
auto it = std::upper_bound(begin, end, value, compare);
|
|
// it is first > value, we want first <= value
|
|
if(it != begin) {
|
|
return --it;
|
|
}
|
|
return end;
|
|
}
|
|
|
|
constexpr const char* const whitespace = " \t\n\r\f\v";
|
|
|
|
inline std::string trim(const std::string& str) {
|
|
if(str.empty()) {
|
|
return "";
|
|
}
|
|
const std::size_t left = str.find_first_not_of(whitespace);
|
|
const std::size_t right = str.find_last_not_of(whitespace) + 1;
|
|
return str.substr(left, right - left);
|
|
}
|
|
|
|
inline bool starts_with(const std::string& str, const std::string& prefix) {
|
|
return str.size() >= prefix.size() && str.compare(0, prefix.size(), prefix) == 0;
|
|
}
|
|
|
|
inline bool is_little_endian() {
|
|
std::uint16_t num = 0x1;
|
|
const auto* ptr = (std::uint8_t*)#
|
|
return ptr[0] == 1;
|
|
}
|
|
|
|
// Modified from
|
|
// https://stackoverflow.com/questions/105252/how-do-i-convert-between-big-endian-and-little-endian-values-in-c
|
|
template<typename T, std::size_t N>
|
|
struct byte_swapper;
|
|
|
|
template<typename T>
|
|
struct byte_swapper<T, 1> {
|
|
T operator()(T val) {
|
|
return val;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct byte_swapper<T, 2> {
|
|
T operator()(T val) {
|
|
return (((val >> 8) & 0xff) | ((val & 0xff) << 8));
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct byte_swapper<T, 4> {
|
|
T operator()(T val) {
|
|
return (((val & 0xff000000) >> 24) |
|
|
((val & 0x00ff0000) >> 8) |
|
|
((val & 0x0000ff00) << 8) |
|
|
((val & 0x000000ff) << 24));
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct byte_swapper<T, 8> {
|
|
T operator()(T val) {
|
|
return (((val & 0xff00000000000000ULL) >> 56) |
|
|
((val & 0x00ff000000000000ULL) >> 40) |
|
|
((val & 0x0000ff0000000000ULL) >> 24) |
|
|
((val & 0x000000ff00000000ULL) >> 8 ) |
|
|
((val & 0x00000000ff000000ULL) << 8 ) |
|
|
((val & 0x0000000000ff0000ULL) << 24) |
|
|
((val & 0x000000000000ff00ULL) << 40) |
|
|
((val & 0x00000000000000ffULL) << 56));
|
|
}
|
|
};
|
|
|
|
template<typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
|
|
T byteswap(T value) {
|
|
return byte_swapper<T, sizeof(T)>{}(value);
|
|
}
|
|
|
|
void enable_virtual_terminal_processing_if_needed() noexcept;
|
|
|
|
constexpr unsigned n_digits(unsigned value) noexcept {
|
|
return value < 10 ? 1 : 1 + n_digits(value / 10);
|
|
}
|
|
|
|
// TODO: Re-evaluate use of off_t
|
|
template<typename T, typename std::enable_if<std::is_trivial<T>::value, int>::type = 0>
|
|
Result<T, internal_error> load_bytes(std::FILE* object_file, off_t offset) {
|
|
T object;
|
|
if(std::fseek(object_file, offset, SEEK_SET) != 0) {
|
|
return internal_error("fseek error");
|
|
}
|
|
if(std::fread(&object, sizeof(T), 1, object_file) != 1) {
|
|
return internal_error("fread error");
|
|
}
|
|
return object;
|
|
}
|
|
|
|
// shamelessly stolen from stackoverflow
|
|
bool directory_exists(const std::string& path);
|
|
|
|
inline std::string basename(const std::string& path, bool maybe_windows = false) {
|
|
// Assumes no trailing /'s
|
|
auto pos = path.find_last_of(maybe_windows ? "/\\" : "/");
|
|
if(pos == std::string::npos) {
|
|
return path;
|
|
} else {
|
|
return path.substr(pos + 1);
|
|
}
|
|
}
|
|
|
|
// A way to cast to unsigned long long without "warning: useless cast to type"
|
|
template<typename T>
|
|
unsigned long long to_ull(T t) {
|
|
return static_cast<unsigned long long>(t);
|
|
}
|
|
template<typename T>
|
|
frame_ptr to_frame_ptr(T t) {
|
|
return static_cast<frame_ptr>(t);
|
|
}
|
|
|
|
// A way to cast to U without "warning: useless cast to type"
|
|
template<typename U, typename V>
|
|
U to(V v) {
|
|
return static_cast<U>(v);
|
|
}
|
|
|
|
template<typename T, typename U = T>
|
|
T exchange(T& obj, U&& value) {
|
|
T old = std::move(obj);
|
|
obj = std::forward<U>(value);
|
|
return old;
|
|
}
|
|
|
|
struct monostate {};
|
|
|
|
// TODO: Rework some stuff here. Not sure deleters should be optional or moved.
|
|
// Also allow file_wrapper file = std::fopen(object_path.c_str(), "rb");
|
|
template<
|
|
typename T,
|
|
typename D,
|
|
// Note: Previously checked if D was invocable and returned void but this kept causing problems for MSVC
|
|
// == 19.38-specific msvc bug https://developercommunity.visualstudio.com/t/MSVC-1938331290-preview-fails-to-comp/10505565
|
|
// <= 19.23 msvc also appears to fail (but for a different reason https://godbolt.org/z/6Y5EvdWPK)
|
|
// <= 19.39 msvc also has trouble with it for different reasons https://godbolt.org/z/aPPPT7z3z
|
|
typename std::enable_if<
|
|
std::is_standard_layout<T>::value && std::is_trivial<T>::value,
|
|
int
|
|
>::type = 0,
|
|
typename std::enable_if<
|
|
std::is_nothrow_move_constructible<T>::value,
|
|
int
|
|
>::type = 0
|
|
>
|
|
class raii_wrapper {
|
|
T obj;
|
|
optional<D> deleter;
|
|
public:
|
|
raii_wrapper(T obj, D deleter) : obj(obj), deleter(deleter) {}
|
|
raii_wrapper(raii_wrapper&& other) noexcept : obj(std::move(other.obj)), deleter(std::move(other.deleter)) {
|
|
other.deleter = nullopt;
|
|
}
|
|
raii_wrapper(const raii_wrapper&) = delete;
|
|
raii_wrapper& operator=(raii_wrapper&&) = delete;
|
|
raii_wrapper& operator=(const raii_wrapper&) = delete;
|
|
~raii_wrapper() {
|
|
if(deleter.has_value()) {
|
|
deleter.unwrap()(obj);
|
|
}
|
|
}
|
|
operator T&() {
|
|
return obj;
|
|
}
|
|
operator const T&() const {
|
|
return obj;
|
|
}
|
|
T& get() {
|
|
return obj;
|
|
}
|
|
const T& get() const {
|
|
return obj;
|
|
}
|
|
};
|
|
|
|
template<typename T, typename D>
|
|
raii_wrapper<typename std::remove_reference<T>::type, D> raii_wrap(T obj, D deleter) {
|
|
return raii_wrapper<typename std::remove_reference<T>::type, D>(obj, deleter);
|
|
}
|
|
|
|
inline void file_deleter(std::FILE* ptr) {
|
|
if(ptr) {
|
|
fclose(ptr);
|
|
}
|
|
}
|
|
|
|
using file_wrapper = raii_wrapper<std::FILE*, void(*)(std::FILE*)>;
|
|
|
|
template<class T, class... Args>
|
|
auto make_unique(Args&&... args) -> typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type {
|
|
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
|
|
}
|
|
|
|
template<typename T>
|
|
class maybe_owned {
|
|
std::unique_ptr<T> owned;
|
|
T* ptr;
|
|
public:
|
|
maybe_owned(T* ptr) : ptr(ptr) {}
|
|
maybe_owned(std::unique_ptr<T>&& owned) : owned(std::move(owned)), ptr(this->owned.get()) {}
|
|
T* operator->() {
|
|
return ptr;
|
|
}
|
|
T& operator*() {
|
|
return *ptr;
|
|
}
|
|
};
|
|
|
|
// template<typename F>
|
|
// class scope_guard {
|
|
// F f;
|
|
// bool active;
|
|
// public:
|
|
// scope_guard(F&& f) : f(std::forward<F>(f)), active(true) {}
|
|
// ~scope_guard() {
|
|
// if(active) {
|
|
// f();
|
|
// }
|
|
// }
|
|
// scope_guard(const scope_guard&) = delete;
|
|
// scope_guard(scope_guard&& other) : f(std::move(other.f)), active(exchange(other.active, false)) {}
|
|
// scope_guard& operator=(const scope_guard&) = delete;
|
|
// scope_guard& operator=(scope_guard&& other) {
|
|
// f = std::move(other.f);
|
|
// active = exchange(other.active, false);
|
|
// return *this;
|
|
// }
|
|
// };
|
|
|
|
// template<typename F>
|
|
// auto scope_exit(F&& f) {
|
|
// return scope_guard<F>(std::forward<F>(f));
|
|
// }
|
|
}
|
|
}
|
|
|
|
#endif
|