mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
54
gpu/compat/boost/container/flat_set.hpp
Normal file
54
gpu/compat/boost/container/flat_set.hpp
Normal file
@@ -0,0 +1,54 @@
|
||||
// boost::container::flat_set for suyu's shader_recompiler: a sorted vector.
|
||||
#pragma once
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
namespace boost::container {
|
||||
template <typename T, typename Compare = std::less<T>, typename Container = std::vector<T>>
|
||||
class flat_set {
|
||||
Container v;
|
||||
Compare cmp;
|
||||
|
||||
public:
|
||||
using value_type = T;
|
||||
using iterator = typename Container::iterator;
|
||||
using const_iterator = typename Container::const_iterator;
|
||||
std::pair<iterator, bool> insert(const T& x) {
|
||||
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
|
||||
if (it != v.end() && !cmp(x, *it)) return {it, false};
|
||||
return {v.insert(it, x), true};
|
||||
}
|
||||
template <typename... A>
|
||||
std::pair<iterator, bool> emplace(A&&... a) { return insert(T(std::forward<A>(a)...)); }
|
||||
iterator find(const T& x) {
|
||||
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
|
||||
return it != v.end() && !cmp(x, *it) ? it : v.end();
|
||||
}
|
||||
const_iterator find(const T& x) const {
|
||||
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
|
||||
return it != v.end() && !cmp(x, *it) ? it : v.end();
|
||||
}
|
||||
bool contains(const T& x) const { return find(x) != v.end(); }
|
||||
std::size_t index_of(const_iterator it) const { return static_cast<std::size_t>(it - v.begin()); }
|
||||
std::size_t index_of(iterator it) { return static_cast<std::size_t>(it - v.begin()); }
|
||||
const T& operator[](std::size_t i) const { return v[i]; }
|
||||
T& operator[](std::size_t i) { return v[i]; }
|
||||
std::size_t count(const T& x) const { return contains(x) ? 1 : 0; }
|
||||
iterator erase(const_iterator it) { return v.erase(it); }
|
||||
std::size_t erase(const T& x) {
|
||||
auto it = find(x);
|
||||
if (it == v.end()) return 0;
|
||||
v.erase(it);
|
||||
return 1;
|
||||
}
|
||||
iterator begin() { return v.begin(); }
|
||||
iterator end() { return v.end(); }
|
||||
const_iterator begin() const { return v.begin(); }
|
||||
const_iterator end() const { return v.end(); }
|
||||
std::size_t size() const { return v.size(); }
|
||||
bool empty() const { return v.empty(); }
|
||||
void clear() { v.clear(); }
|
||||
void reserve(std::size_t n) { v.reserve(n); }
|
||||
};
|
||||
} // namespace boost::container
|
||||
14
gpu/compat/boost/container/small_vector.hpp
Normal file
14
gpu/compat/boost/container/small_vector.hpp
Normal file
@@ -0,0 +1,14 @@
|
||||
// boost::container::small_vector for suyu's shader_recompiler: a std::vector with the inline capacity reserved.
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <initializer_list>
|
||||
#include <vector>
|
||||
namespace boost::container {
|
||||
template <typename T, std::size_t N, typename Alloc = void>
|
||||
class small_vector : public std::vector<T> {
|
||||
public:
|
||||
using std::vector<T>::vector;
|
||||
small_vector() { this->reserve(N); }
|
||||
small_vector(std::initializer_list<T> list) : std::vector<T>(list) {}
|
||||
};
|
||||
} // namespace boost::container
|
||||
21
gpu/compat/boost/container/static_vector.hpp
Normal file
21
gpu/compat/boost/container/static_vector.hpp
Normal file
@@ -0,0 +1,21 @@
|
||||
// boost::container::static_vector for suyu's code: a std::vector (capacity and options are not enforced).
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <vector>
|
||||
namespace boost::container {
|
||||
template <std::size_t A>
|
||||
struct inplace_alignment {};
|
||||
template <bool B>
|
||||
struct throw_on_overflow {};
|
||||
template <typename... Options>
|
||||
struct static_vector_options {
|
||||
using type = static_vector_options;
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N, typename Options = void>
|
||||
class static_vector : public std::vector<T> {
|
||||
public:
|
||||
using std::vector<T>::vector;
|
||||
static_vector() { this->reserve(N); }
|
||||
};
|
||||
} // namespace boost::container
|
||||
209
gpu/compat/boost/intrusive/list.hpp
Normal file
209
gpu/compat/boost/intrusive/list.hpp
Normal file
@@ -0,0 +1,209 @@
|
||||
// boost::intrusive::list (the subset suyu's shader_recompiler uses): a circular doubly linked list threaded through
|
||||
// a hook the element type derives from. Elements are never owned or copied by the list.
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace boost::intrusive {
|
||||
struct normal_link {};
|
||||
struct safe_link {};
|
||||
template <typename Mode>
|
||||
struct link_mode {};
|
||||
template <typename Hook>
|
||||
struct base_hook {};
|
||||
template <bool B>
|
||||
struct constant_time_size {};
|
||||
|
||||
namespace detail {
|
||||
struct list_node {
|
||||
list_node* prev_ = nullptr;
|
||||
list_node* next_ = nullptr;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
template <typename... Options>
|
||||
struct list_base_hook : detail::list_node {};
|
||||
|
||||
template <typename T, typename... Options>
|
||||
class list {
|
||||
using node = detail::list_node;
|
||||
node root;
|
||||
std::size_t count = 0;
|
||||
|
||||
static T& value_of(node* n) { return static_cast<T&>(*n); }
|
||||
static node* node_of(T& v) { return static_cast<node*>(&v); }
|
||||
static node* node_of(const T& v) { return const_cast<node*>(static_cast<const node*>(&v)); }
|
||||
void reset() {
|
||||
root.prev_ = root.next_ = &root;
|
||||
count = 0;
|
||||
}
|
||||
static void link_before(node* pos, node* n) {
|
||||
n->prev_ = pos->prev_;
|
||||
n->next_ = pos;
|
||||
pos->prev_->next_ = n;
|
||||
pos->prev_ = n;
|
||||
}
|
||||
static void unlink(node* n) {
|
||||
n->prev_->next_ = n->next_;
|
||||
n->next_->prev_ = n->prev_;
|
||||
n->prev_ = n->next_ = nullptr;
|
||||
}
|
||||
|
||||
public:
|
||||
template <bool Const>
|
||||
class iter {
|
||||
friend class list;
|
||||
node* n = nullptr;
|
||||
|
||||
public:
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
using value_type = T;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using pointer = std::conditional_t<Const, const T*, T*>;
|
||||
using reference = std::conditional_t<Const, const T&, T&>;
|
||||
iter() = default;
|
||||
explicit iter(node* n_) : n(n_) {}
|
||||
// boost's iterators convert from an element pointer (structured_control_flow assigns `node = stmt->up`)
|
||||
iter(std::conditional_t<Const, const T*, T*> p) : n(p ? node_of(*p) : nullptr) {}
|
||||
template <bool C2, typename = std::enable_if_t<Const && !C2>>
|
||||
iter(const iter<C2>& o) : n(o.raw()) {}
|
||||
reference operator*() const { return value_of(n); }
|
||||
pointer operator->() const { return &value_of(n); }
|
||||
iter& operator++() {
|
||||
n = n->next_;
|
||||
return *this;
|
||||
}
|
||||
iter operator++(int) {
|
||||
iter t = *this;
|
||||
n = n->next_;
|
||||
return t;
|
||||
}
|
||||
iter& operator--() {
|
||||
n = n->prev_;
|
||||
return *this;
|
||||
}
|
||||
iter operator--(int) {
|
||||
iter t = *this;
|
||||
n = n->prev_;
|
||||
return t;
|
||||
}
|
||||
friend bool operator==(const iter& a, const iter& b) { return a.n == b.n; }
|
||||
node* raw() const { return n; }
|
||||
};
|
||||
using value_type = T;
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using iterator = iter<false>;
|
||||
using const_iterator = iter<true>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
list() { reset(); }
|
||||
list(const list&) = delete;
|
||||
list& operator=(const list&) = delete;
|
||||
list(list&& o) noexcept {
|
||||
reset();
|
||||
take(o);
|
||||
}
|
||||
list& operator=(list&& o) noexcept {
|
||||
if (this != &o) {
|
||||
clear();
|
||||
take(o);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
// Elements are not touched: they may already be gone (suyu frees them through ObjectPool), as boost allows.
|
||||
~list() = default;
|
||||
|
||||
iterator begin() { return iterator(root.next_); }
|
||||
iterator end() { return iterator(&root); }
|
||||
const_iterator begin() const { return const_iterator(root.next_); }
|
||||
const_iterator end() const { return const_iterator(const_cast<node*>(&root)); }
|
||||
const_iterator cbegin() const { return begin(); }
|
||||
const_iterator cend() const { return end(); }
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
|
||||
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
|
||||
const_reverse_iterator crbegin() const { return rbegin(); }
|
||||
const_reverse_iterator crend() const { return rend(); }
|
||||
|
||||
bool empty() const { return root.next_ == &root; }
|
||||
size_type size() const { return count; }
|
||||
T& front() { return value_of(root.next_); }
|
||||
T& back() { return value_of(root.prev_); }
|
||||
const T& front() const { return value_of(root.next_); }
|
||||
const T& back() const { return value_of(root.prev_); }
|
||||
|
||||
void push_back(T& v) {
|
||||
link_before(&root, node_of(v));
|
||||
++count;
|
||||
}
|
||||
void push_front(T& v) {
|
||||
link_before(root.next_, node_of(v));
|
||||
++count;
|
||||
}
|
||||
void pop_front() {
|
||||
unlink(root.next_);
|
||||
--count;
|
||||
}
|
||||
void pop_back() {
|
||||
unlink(root.prev_);
|
||||
--count;
|
||||
}
|
||||
iterator insert(const_iterator pos, T& v) {
|
||||
link_before(pos.raw(), node_of(v));
|
||||
++count;
|
||||
return iterator(node_of(v));
|
||||
}
|
||||
iterator erase(const_iterator pos) {
|
||||
node* next = pos.raw()->next_;
|
||||
unlink(pos.raw());
|
||||
--count;
|
||||
return iterator(next);
|
||||
}
|
||||
iterator erase(const_iterator first, const_iterator last) {
|
||||
while (first != last) first = erase(first);
|
||||
return iterator(last.raw());
|
||||
}
|
||||
void clear() { reset(); } // elements keep stale links, as boost's normal_link mode leaves them
|
||||
// Moves [first, last) of x in front of pos.
|
||||
void splice(const_iterator pos, list& x, const_iterator first, const_iterator last) {
|
||||
if (first == last) return;
|
||||
std::size_t moved = 0;
|
||||
for (const_iterator i = first; i != last; ++i) ++moved;
|
||||
node* f = first.raw();
|
||||
node* l = last.raw()->prev_;
|
||||
f->prev_->next_ = last.raw();
|
||||
last.raw()->prev_ = f->prev_;
|
||||
node* p = pos.raw();
|
||||
f->prev_ = p->prev_;
|
||||
l->next_ = p;
|
||||
p->prev_->next_ = f;
|
||||
p->prev_ = l;
|
||||
x.count -= moved;
|
||||
count += moved;
|
||||
}
|
||||
void splice(const_iterator pos, list& x) { splice(pos, x, x.begin(), x.end()); }
|
||||
|
||||
static iterator s_iterator_to(T& v) { return iterator(node_of(v)); }
|
||||
static const_iterator s_iterator_to(const T& v) { return const_iterator(node_of(v)); }
|
||||
iterator iterator_to(T& v) { return iterator(node_of(v)); }
|
||||
const_iterator iterator_to(const T& v) const { return const_iterator(node_of(v)); }
|
||||
|
||||
private:
|
||||
void take(list& o) {
|
||||
if (o.empty()) return;
|
||||
root.next_ = o.root.next_;
|
||||
root.prev_ = o.root.prev_;
|
||||
root.next_->prev_ = &root;
|
||||
root.prev_->next_ = &root;
|
||||
count = o.count;
|
||||
o.reset();
|
||||
}
|
||||
};
|
||||
} // namespace boost::intrusive
|
||||
100
gpu/compat/boost/intrusive/set.hpp
Normal file
100
gpu/compat/boost/intrusive/set.hpp
Normal file
@@ -0,0 +1,100 @@
|
||||
// boost::intrusive::set (the subset suyu's shader_recompiler uses): an ordered set of element references, ordered by
|
||||
// the element's operator<. Built on std::multiset of pointers, whose iterators survive inserts as boost's do.
|
||||
// Lookups with a separate key and comparator are linear: a shader's control-flow graph has few blocks.
|
||||
#pragma once
|
||||
#include <boost/intrusive/list.hpp>
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <set>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace boost::intrusive {
|
||||
template <typename... Options>
|
||||
struct set_base_hook {};
|
||||
|
||||
template <typename T, typename... Options>
|
||||
class set {
|
||||
struct less {
|
||||
bool operator()(const T* a, const T* b) const { return *a < *b; }
|
||||
};
|
||||
using base = std::multiset<T*, less>;
|
||||
base s;
|
||||
|
||||
public:
|
||||
template <typename It, typename Ref>
|
||||
class iter {
|
||||
friend class set;
|
||||
It it{};
|
||||
|
||||
public:
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
using value_type = T;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using pointer = std::remove_reference_t<Ref>*;
|
||||
using reference = Ref;
|
||||
iter() = default;
|
||||
explicit iter(It i) : it(i) {}
|
||||
reference operator*() const { return **it; }
|
||||
pointer operator->() const { return *it; }
|
||||
iter& operator++() {
|
||||
++it;
|
||||
return *this;
|
||||
}
|
||||
iter operator++(int) {
|
||||
iter t = *this;
|
||||
++it;
|
||||
return t;
|
||||
}
|
||||
iter& operator--() {
|
||||
--it;
|
||||
return *this;
|
||||
}
|
||||
iter operator--(int) {
|
||||
iter t = *this;
|
||||
--it;
|
||||
return t;
|
||||
}
|
||||
friend bool operator==(const iter& a, const iter& b) { return a.it == b.it; }
|
||||
};
|
||||
using iterator = iter<typename base::iterator, T&>;
|
||||
using const_iterator = iter<typename base::const_iterator, const T&>;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
using size_type = std::size_t;
|
||||
using value_type = T;
|
||||
|
||||
std::pair<iterator, bool> insert(T& v) { return {iterator(s.insert(&v)), true}; }
|
||||
iterator insert(iterator hint, T& v) { return iterator(s.insert(hint.it, &v)); }
|
||||
iterator erase(iterator it) { return iterator(s.erase(it.it)); }
|
||||
template <typename Key, typename Compare>
|
||||
iterator find(const Key& key, Compare comp) {
|
||||
for (auto i = s.begin(); i != s.end(); ++i)
|
||||
if (!comp(**i, key) && !comp(key, **i)) return iterator(i);
|
||||
return end();
|
||||
}
|
||||
template <typename Key, typename Compare>
|
||||
iterator upper_bound(const Key& key, Compare comp) {
|
||||
for (auto i = s.begin(); i != s.end(); ++i)
|
||||
if (comp(key, **i)) return iterator(i);
|
||||
return end();
|
||||
}
|
||||
template <typename Key, typename Compare>
|
||||
iterator lower_bound(const Key& key, Compare comp) {
|
||||
for (auto i = s.begin(); i != s.end(); ++i)
|
||||
if (!comp(**i, key)) return iterator(i);
|
||||
return end();
|
||||
}
|
||||
iterator begin() { return iterator(s.begin()); }
|
||||
iterator end() { return iterator(s.end()); }
|
||||
const_iterator begin() const { return const_iterator(s.begin()); }
|
||||
const_iterator end() const { return const_iterator(s.end()); }
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
|
||||
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
|
||||
bool empty() const { return s.empty(); }
|
||||
size_type size() const { return s.size(); }
|
||||
void clear() { s.clear(); }
|
||||
};
|
||||
} // namespace boost::intrusive
|
||||
Reference in New Issue
Block a user