mirror of
https://github.com/RPCSX/rpcsx.git
synced 2026-04-04 22:19:02 +00:00
fixes to get llvm to compile (excepti for utils.cpp, that'll get fixed
later) Eradicate the Array almost everywhere, some usages like Stack still remains
This commit is contained in:
Bigpet
Peter Tissen
parent
d65968b41d
commit
25c3aa8e19
92 changed files with 931 additions and 1305 deletions
|
|
@ -1,228 +1,5 @@
|
|||
#pragma once
|
||||
|
||||
template<typename T> class Array
|
||||
{
|
||||
protected:
|
||||
u32 m_count;
|
||||
T* m_array;
|
||||
|
||||
public:
|
||||
Array()
|
||||
: m_count(0)
|
||||
, m_array(NULL)
|
||||
{
|
||||
}
|
||||
|
||||
~Array()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
inline bool RemoveAt(const u32 from, const u32 count = 1)
|
||||
{
|
||||
if(!GetCount()) return false;
|
||||
const u32 to = from + count;
|
||||
if(to > GetCount()) return false;
|
||||
|
||||
for(u32 i=0; i<count; ++i) m_array[from + i].~T();
|
||||
memmove(m_array + from, m_array + to, (m_count-to) * sizeof(T));
|
||||
m_count -= count;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void InsertRoomEnd(const u32 size)
|
||||
{
|
||||
_InsertRoomEnd(size);
|
||||
}
|
||||
|
||||
bool InsertRoom(const u32 pos, const u32 size)
|
||||
{
|
||||
if(pos >= m_count) return false;
|
||||
|
||||
_InsertRoomEnd(size);
|
||||
memmove(m_array + pos + size, m_array + pos, sizeof(T) * (m_count - size - pos));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool Move(const u32 pos, T* data)
|
||||
{
|
||||
if(!InsertRoom(pos, 1)) return false;
|
||||
|
||||
memcpy(m_array + pos, data, sizeof(T));
|
||||
free(data);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline u32 Move(T* data)
|
||||
{
|
||||
_InsertRoomEnd(1);
|
||||
|
||||
memcpy(m_array + GetCount() - 1, data, sizeof(T));
|
||||
free(data);
|
||||
|
||||
return m_count - 1;
|
||||
}
|
||||
|
||||
inline bool Add(const u32 pos, T*& data)
|
||||
{
|
||||
if(!InsertRoom(pos, 1)) return false;
|
||||
|
||||
memcpy(m_array + pos, data, sizeof(T));
|
||||
free(data);
|
||||
data = m_array + pos;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline u32 Add(T*& data)
|
||||
{
|
||||
_InsertRoomEnd(1);
|
||||
|
||||
memcpy(m_array + GetCount() - 1, data, sizeof(T));
|
||||
free(data);
|
||||
data = m_array + GetCount() - 1;
|
||||
|
||||
return m_count - 1;
|
||||
}
|
||||
|
||||
inline bool AddCpy(const u32 pos, const T* data, u32 count = 1)
|
||||
{
|
||||
if(!InsertRoom(pos, count)) return false;
|
||||
|
||||
for(u32 i=0; i<count; ++i)
|
||||
{
|
||||
new (m_array + pos + i) T(data[i]);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool AddCpy(const u32 pos, const T& data)
|
||||
{
|
||||
return AddCpy(pos, &data);
|
||||
}
|
||||
|
||||
inline u32 AddCpy(const T* data, u32 count = 1)
|
||||
{
|
||||
_InsertRoomEnd(count);
|
||||
|
||||
for(u32 i=0; i<count; ++i)
|
||||
{
|
||||
new (m_array + m_count - count + i) T(data[i]);
|
||||
}
|
||||
|
||||
return m_count - count;
|
||||
}
|
||||
|
||||
inline u32 AddCpy(const T& data)
|
||||
{
|
||||
return AddCpy(&data);
|
||||
}
|
||||
|
||||
inline void Clear()
|
||||
{
|
||||
u32 count = m_count;
|
||||
m_count = 0;
|
||||
for(u32 i=0; i<count; ++i) m_array[i].~T();
|
||||
safe_free(m_array);
|
||||
}
|
||||
|
||||
inline void ClearF()
|
||||
{
|
||||
m_count = 0;
|
||||
safe_free(m_array);
|
||||
}
|
||||
|
||||
inline T& Get(u32 num)
|
||||
{
|
||||
//if(num >= GetCount()) return *new T();
|
||||
return m_array[num];
|
||||
}
|
||||
|
||||
u32 GetCount() const { return m_count; }
|
||||
|
||||
void SetCount(const u32 count, bool memzero = true)
|
||||
{
|
||||
if(m_count >= count) return;
|
||||
|
||||
_InsertRoomEnd(count - m_count);
|
||||
|
||||
if(memzero) memset(m_array + m_count - count, 0, sizeof(T) * (m_count - count));
|
||||
}
|
||||
|
||||
void Reserve(const u32 count)
|
||||
{
|
||||
SetCount(GetCount() + count);
|
||||
}
|
||||
|
||||
void AppendFrom(const Array<T>& src)
|
||||
{
|
||||
if(!src.GetCount()) return;
|
||||
|
||||
Reserve(src.GetCount());
|
||||
|
||||
memcpy(m_array, &src[0], GetCount() * sizeof(T));
|
||||
}
|
||||
|
||||
void CopyFrom(const Array<T>& src)
|
||||
{
|
||||
Clear();
|
||||
|
||||
AppendFrom(src);
|
||||
}
|
||||
|
||||
inline T* GetPtr() { return m_array; }
|
||||
inline const T* GetPtr() const { return m_array; }
|
||||
|
||||
T& operator[](u32 num) const { return m_array[num]; }
|
||||
|
||||
T* operator + (u32 right) const
|
||||
{
|
||||
return m_array + right;
|
||||
}
|
||||
|
||||
T* operator ->()
|
||||
{
|
||||
return m_array;
|
||||
}
|
||||
|
||||
protected:
|
||||
void _InsertRoomEnd(const u32 size)
|
||||
{
|
||||
if(!size) return;
|
||||
|
||||
m_array = m_count ? (T*)realloc(m_array, sizeof(T) * (m_count + size)) : (T*)malloc(sizeof(T) * size);
|
||||
m_count += size;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T> struct Stack : public Array<T>
|
||||
{
|
||||
Stack() : Array<T>()
|
||||
{
|
||||
}
|
||||
|
||||
~Stack()
|
||||
{
|
||||
Array<T>::Clear();
|
||||
}
|
||||
|
||||
void Push(const T data) { Array<T>::AddCpy(data); }
|
||||
|
||||
T Pop()
|
||||
{
|
||||
const u32 pos = Array<T>::GetCount() - 1;
|
||||
|
||||
const T ret = Array<T>::Get(pos);
|
||||
Array<T>::RemoveAt(pos);
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T, size_t size> class SizedStack
|
||||
{
|
||||
T m_ptr[size];
|
||||
|
|
@ -278,106 +55,6 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
template<typename T> class ArrayF
|
||||
{
|
||||
u32 m_count;
|
||||
T** m_array;
|
||||
|
||||
public:
|
||||
ArrayF()
|
||||
: m_count(0)
|
||||
, m_array(NULL)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~ArrayF()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
inline bool RemoveFAt(const u32 from, const u32 count = 1)
|
||||
{
|
||||
if(from + count > m_count) return false;
|
||||
|
||||
memmove(&m_array[from], &m_array[from+count], (m_count-(from+count)) * sizeof(T**));
|
||||
|
||||
m_count -= count;
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool RemoveAt(const u32 from, const u32 count = 1)
|
||||
{
|
||||
if(from + count > m_count) return false;
|
||||
|
||||
for(uint i = from; i < from + count; ++i)
|
||||
{
|
||||
free(m_array[i]);
|
||||
}
|
||||
|
||||
return RemoveFAt(from, count);
|
||||
}
|
||||
|
||||
inline u32 Add(T& data)
|
||||
{
|
||||
return Add(&data);
|
||||
}
|
||||
|
||||
inline u32 Add(T* data)
|
||||
{
|
||||
if(!m_array)
|
||||
{
|
||||
m_array = (T**)malloc(sizeof(T*));
|
||||
}
|
||||
else
|
||||
{
|
||||
m_array = (T**)realloc(m_array, sizeof(T*) * (m_count + 1));
|
||||
}
|
||||
|
||||
m_array[m_count] = data;
|
||||
return m_count++;
|
||||
}
|
||||
|
||||
inline void ClearF()
|
||||
{
|
||||
if(m_count == 0) return;
|
||||
|
||||
m_count = 0;
|
||||
m_array = NULL;
|
||||
}
|
||||
|
||||
inline void Clear()
|
||||
{
|
||||
if(m_count == 0) return;
|
||||
|
||||
m_count = 0;
|
||||
safe_free(m_array);
|
||||
}
|
||||
|
||||
inline T& Get(const u64 num)
|
||||
{
|
||||
//if(m_count <= num) *m_array[0]; //TODO
|
||||
return *m_array[num];
|
||||
}
|
||||
|
||||
T** operator + (u32 right) const
|
||||
{
|
||||
return m_array + right;
|
||||
}
|
||||
|
||||
T* operator ->()
|
||||
{
|
||||
return *m_array;
|
||||
}
|
||||
|
||||
inline T** GetPtr()
|
||||
{
|
||||
return m_array;
|
||||
}
|
||||
|
||||
inline u32 GetCount() const { return m_count; }
|
||||
T& operator[](u32 num) const { return *m_array[num]; }
|
||||
};
|
||||
|
||||
template<typename T> struct ScopedPtr
|
||||
{
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -57,17 +57,18 @@ public:
|
|||
be_t() noexcept = default;
|
||||
#endif
|
||||
|
||||
be_t(const be_t<T,size>& value) = default;
|
||||
be_t(const T& value)
|
||||
{
|
||||
FromLE(value);
|
||||
}
|
||||
|
||||
template<typename T1>
|
||||
be_t(const be_t<T1>& value)
|
||||
explicit be_t(const be_t<T1>& value)
|
||||
{
|
||||
FromBE(value.ToBE());
|
||||
}
|
||||
|
||||
|
||||
const T& ToBE() const
|
||||
{
|
||||
return m_data;
|
||||
|
|
@ -126,11 +127,7 @@ public:
|
|||
return *this;
|
||||
}
|
||||
|
||||
be_t& operator = (const be_t& right)
|
||||
{
|
||||
m_data = right.m_data;
|
||||
return *this;
|
||||
}
|
||||
be_t<T,size>& operator = (const be_t<T,size>& right) = default;
|
||||
|
||||
template<typename T1> be_t& operator += (T1 right) { return *this = T(*this) + right; }
|
||||
template<typename T1> be_t& operator -= (T1 right) { return *this = T(*this) - right; }
|
||||
|
|
|
|||
|
|
@ -2,6 +2,9 @@
|
|||
|
||||
#if defined(__GNUG__)
|
||||
#include <cmath>
|
||||
#include <stdlib.h>
|
||||
#include <malloc.h>
|
||||
|
||||
#define _fpclass(x) std::fpclassify(x)
|
||||
#define __forceinline __attribute__((always_inline))
|
||||
#define _byteswap_ushort(x) __builtin_bswap16(x)
|
||||
|
|
@ -13,7 +16,8 @@
|
|||
#define _CRT_ALIGN(x) __attribute__((aligned(x)))
|
||||
#define InterlockedCompareExchange(ptr,new_val,old_val) __sync_val_compare_and_swap(ptr,old_val,new_val)
|
||||
#define InterlockedCompareExchange64(ptr,new_val,old_val) __sync_val_compare_and_swap(ptr,old_val,new_val)
|
||||
#define _aligned_malloc(size,alignment) aligned_alloc(alignment,size)
|
||||
#define _aligned_free(pointer) free(pointer)
|
||||
#define _aligned_malloc(size,alignment) memalign(alignment,size)
|
||||
#define _aligned_free free
|
||||
#define DWORD int32_t
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
#include "Array.h"
|
||||
#include <functional>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
#include <mutex>
|
||||
#include <atomic>
|
||||
#include <condition_variable>
|
||||
|
|
@ -73,7 +74,7 @@ template<typename T> class MTPacketBuffer
|
|||
protected:
|
||||
volatile bool m_busy;
|
||||
volatile u32 m_put, m_get;
|
||||
Array<u8> m_buffer;
|
||||
std::vector<u8> m_buffer;
|
||||
u32 m_max_buffer_size;
|
||||
mutable std::recursive_mutex m_cs_main;
|
||||
|
||||
|
|
@ -98,7 +99,7 @@ public:
|
|||
{
|
||||
std::lock_guard<std::recursive_mutex> lock(m_cs_main);
|
||||
m_put = m_get = 0;
|
||||
m_buffer.Clear();
|
||||
m_buffer.clear();
|
||||
m_busy = false;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue