Initial checkin

IDEHelper/Beef/BfCommon.h

@@ -0,0 +1,278 @@
+#pragma once
+
+#include "BeefySysLib/Common.h"
+#include "BeefySysLib/util/SizedArray.h"
+#include "BeefySysLib/util/TLSingleton.h"
+#include "BeefySysLib/util/String.h"
+#include "BeefySysLib/util/BumpAllocator.h"
+
+#pragma warning(push)
+#pragma warning(disable:4141)
+#pragma warning(disable:4146)
+#pragma warning(disable:4291)
+#pragma warning(disable:4244)
+#pragma warning(disable:4267)
+#pragma warning(disable:4624)
+#pragma warning(disable:4800)
+#pragma warning(disable:4996)
+#include "llvm/ADT/SmallVector.h"
+#pragma warning(pop)
+
+NS_BF_BEGIN
+
+template <typename T, unsigned int N>
+using BfSizedVector = llvm::SmallVector<T, N>;
+
+template <typename T>
+using BfSizedVectorRef = llvm::SmallVectorImpl<T>;
+
+template <typename T>
+class BfSizedArray
+{
+public:
+	T* mVals;
+	int mSize;
+
+public:
+	struct Iterator
+	{
+	public:
+		T* mPtr;
+
+	public:
+		Iterator(T* ptr)
+		{
+			mPtr = ptr;
+		}
+
+		Iterator& operator++()
+		{
+			mPtr++;
+			return *this;
+		}
+
+		bool operator!=(const Iterator& itr) const
+		{
+			return itr.mPtr != mPtr;
+		}
+
+		bool operator==(const Iterator& itr) const
+		{
+			return itr.mPtr == mPtr;
+		}
+
+		T& operator*()
+		{
+			return *mPtr;
+		}
+	};
+
+	BfSizedArray()
+	{
+		mSize = 0;
+	}
+
+	BfSizedArray(const llvm::SmallVectorImpl<T>& refVec)
+	{
+		mSize = (int)refVec.size();
+		if (mSize > 0)
+			mVals = (T*)&refVec[0];
+		else
+			mVals = NULL;
+	}
+
+	BfSizedArray(const Array<T>& refVec)
+	{
+		mSize = (int)refVec.size();
+		if (mSize > 0)
+			mVals = (T*)&refVec[0];
+		else
+			mVals = NULL;
+	}
+
+	BfSizedArray(const SizedArrayImpl<T>& refVec)
+	{
+		mSize = (int)refVec.size();
+		if (mSize > 0)
+			mVals = (T*)&refVec[0];
+		else
+			mVals = NULL;
+	}
+
+	void CopyFrom(T* vals, int size, BumpAllocator& bumpAlloc)
+	{
+		mVals = (T*)bumpAlloc.AllocBytes(sizeof(T) * size, alignof(T));
+		mSize = size;
+		memcpy(mVals, vals, sizeof(T) * size);
+	}
+
+	T& operator[](int idx) const
+	{
+		return mVals[idx];
+	}
+
+	Iterator begin() const
+	{
+		return mVals;
+	}
+
+	Iterator end() const
+	{
+		return mVals + mSize;
+	}
+
+	T back() const
+	{
+		return mVals[mSize - 1];
+	}
+
+	int size() const
+	{
+		return mSize;
+	}
+
+	bool empty() const
+	{
+		return mSize == 0;
+	}
+
+	bool IsEmpty() const
+	{
+		return mSize == 0;
+	}
+
+	T Get(int idx)
+	{
+		if ((idx < 0) || (idx >= mSize))
+			return (T)0;
+		return mVals[idx];
+	}
+
+	template <typename T2>
+	T2 GetAs(int idx)
+	{
+		if ((idx < 0) || (idx >= mSize))
+			return (T2)0;
+		return (T2)mVals[idx];
+	}
+
+	T GetLast()
+	{
+		if (mSize == 0)
+			return (T)0;
+		return mVals[mSize - 1];
+	}
+
+	T GetFirst()
+	{
+		if (mSize == 0)
+			return (T)0;
+		return mVals[0];
+	}
+
+	/*void Init(const llvm::SmallVectorImpl<T>& vec, BfAstAllocator* alloc)
+	{
+		mSize = (int)vec.size();
+		if (mSize > 0)
+		{
+			mVals = (T*)alloc->AllocBytes(mSize * sizeof(T), sizeof(T));
+			memcpy(mVals, &vec[0], mSize * sizeof(T));
+		}
+	}
+
+	template <typename T2>
+	void InitIndirect(const llvm::SmallVectorImpl<T2>& vec, BfAstAllocator* alloc)
+	{
+		mSize = (int)vec.size();
+		if (mSize > 0)
+		{
+			mVals = (T*)alloc->AllocBytes(mSize * sizeof(T), sizeof(T));
+			for (int i = 0; i < mSize; i++)
+				mVals[i] = vec[i];
+		}
+	}*/
+
+	void SetSize(int size)
+	{
+		BF_ASSERT(size <= mSize);
+		mSize = size;
+	}
+};
+
+class ChunkedDataBuffer;
+
+class BfIRCodeGenBase
+{
+public:
+	ChunkedDataBuffer* mStream;
+	int mPtrSize;
+	bool mIsOptimized;
+	bool mFailed;
+	String mErrorMsg;
+
+public:
+	BfIRCodeGenBase()
+	{
+		mStream = NULL;
+		mPtrSize = -1;
+		mIsOptimized = false;
+		mFailed = false;
+	}
+
+	virtual void Fail(const StringImpl& error)
+	{
+		if (mErrorMsg.IsEmpty())
+			mErrorMsg = error;
+		mFailed = true;
+	}
+
+	virtual ~BfIRCodeGenBase() {}
+
+	virtual void ProcessBfIRData(const BfSizedArray<uint8>& buffer) = 0;
+	virtual void HandleNextCmd() = 0;
+	virtual void SetConfigConst(int idx, int value) = 0;
+};
+
+extern TLSingleton<String> gTLStrReturn;
+extern TLSingleton<String> gTLStrReturn2;
+
+template <typename T>
+struct OwnedWrapper
+{
+public:
+	T* mValue;
+
+	OwnedWrapper()
+	{
+		mValue = NULL;
+	}
+
+	OwnedWrapper(const T* value)
+	{
+		mValue = (T*)value;
+	}
+
+	OwnedWrapper(const T& value)
+	{
+		mValue = (T*)&value;
+	}
+
+	bool operator==(const OwnedWrapper& rhs)
+	{
+		return *mValue == *rhs.mValue;
+	}
+};
+
+NS_BF_END
+
+namespace std
+{
+	template <typename T>
+	struct hash<Beefy::OwnedWrapper<T> >
+	{
+		size_t operator()(const Beefy::OwnedWrapper<T>& val) const
+		{
+			return std::hash<T>()(*val.mValue);
+		}
+	};
+}