Make the Solidity repository standalone.

This commit is the culmination of several months of work to decouple Solidity from the webthree-umbrella so that it can be developed in parallel with cpp-ethereum (the Ethereum C++ runtime) and so that even for the Solidity unit-tests there is no hard-dependency onto the C++ runtime.

The Tests-over-IPC refactoring was a major step in the same process which was already committed.

This commit contains the following changes:

- A subset of the CMake functionality in webthree-helpers was extracted and tailored for Solidity into ./cmake.   Further cleanup is certainly possible.
- A subset of the libdevcore functionality in libweb3core was extracted and tailored for Solidity into ./libdevcore.   Further cleanup is certainly possible
- The gas price constants in EVMSchedule were orphaned into libevmasm.
- Some other refactorings and cleanups were made to sever unnecessary EVM dependencies in the Solidity unit-tests.
- TravisCI and Appveyor support was added, covering builds and running of the unit-tests (Linux and macOS only for now)
- A bug-fix was made to get the Tests-over-IPC running on macOS.
- There are still reliability issues in the unit-tests, which need immediate attention.    The Travis build has been flipped to run the unit-tests 5 times, to try to flush these out.
- The Emscripten automation which was previously in webthree-umbrella was merged into the TravisCI automation here.
- The development ZIP deployment step has been commented out, but we will want to read that ONLY for release branch.

Further iteration on these changes will definitely be needed, but I feel these have got to sufficient maturity than holding them back further isn't winning us anything.    It is go time :-)

1 files changed, 120 insertions, 0 deletions

diff --git a/libdevcore/vector_ref.h b/libdevcore/vector_ref.h
new file mode 100644
index 00000000..46d06946
--- /dev/null
+++ b/libdevcore/vector_ref.h
@@ -0,0 +1,120 @@
+#pragma once
+
+#include <cstring>
+#include <cassert>
+#include <type_traits>
+#include <vector>
+#include <string>
+
+#ifdef __INTEL_COMPILER
+#pragma warning(disable:597) //will not be called for implicit or explicit conversions
+#endif
+
+namespace dev
+{
+
+/**
+ * A modifiable reference to an existing object or vector in memory.
+ */
+template <class _T>
+class vector_ref
+{
+public:
+	using value_type = _T;
+	using element_type = _T;
+	using mutable_value_type = typename std::conditional<std::is_const<_T>::value, typename std::remove_const<_T>::type, _T>::type;
+
+	static_assert(std::is_pod<value_type>::value, "vector_ref can only be used with PODs due to its low-level treatment of data.");
+
+	vector_ref(): m_data(nullptr), m_count(0) {}
+	/// Creates a new vector_ref to point to @a _count elements starting at @a _data.
+	vector_ref(_T* _data, size_t _count): m_data(_data), m_count(_count) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as pointer).
+	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const*, std::string*>::type _data): m_data(reinterpret_cast<_T*>(_data->data())), m_count(_data->size() / sizeof(_T)) {}
+	/// Creates a new vector_ref pointing to the data part of a vector (given as pointer).
+	vector_ref(typename std::conditional<std::is_const<_T>::value, std::vector<typename std::remove_const<_T>::type> const*, std::vector<_T>*>::type _data): m_data(_data->data()), m_count(_data->size()) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as reference).
+	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data(reinterpret_cast<_T*>(_data.data())), m_count(_data.size() / sizeof(_T)) {}
+#if DEV_LDB
+	vector_ref(ldb::Slice const& _s): m_data(reinterpret_cast<_T*>(_s.data())), m_count(_s.size() / sizeof(_T)) {}
+#endif
+	explicit operator bool() const { return m_data && m_count; }
+
+	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { if (!m_data || m_count == 0) return _c.empty(); else return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count * sizeof(_T)); }
+	std::vector<mutable_value_type> toVector() const { return std::vector<mutable_value_type>(m_data, m_data + m_count); }
+	std::vector<unsigned char> toBytes() const { return std::vector<unsigned char>(reinterpret_cast<unsigned char const*>(m_data), reinterpret_cast<unsigned char const*>(m_data) + m_count * sizeof(_T)); }
+	std::string toString() const { return std::string((char const*)m_data, ((char const*)m_data) + m_count * sizeof(_T)); }
+
+	template <class _T2> explicit operator vector_ref<_T2>() const { assert(m_count * sizeof(_T) / sizeof(_T2) * sizeof(_T2) / sizeof(_T) == m_count); return vector_ref<_T2>(reinterpret_cast<_T2*>(m_data), m_count * sizeof(_T) / sizeof(_T2)); }
+	operator vector_ref<_T const>() const { return vector_ref<_T const>(m_data, m_count); }
+
+	_T* data() const { return m_data; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
+	size_t count() const { return m_count; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
+	size_t size() const { return m_count; }
+	bool empty() const { return !m_count; }
+	/// @returns a new vector_ref pointing at the next chunk of @a size() elements.
+	vector_ref<_T> next() const { if (!m_data) return *this; else return vector_ref<_T>(m_data + m_count, m_count); }
+	/// @returns a new vector_ref which is a shifted and shortened view of the original data.
+	/// If this goes out of bounds in any way, returns an empty vector_ref.
+	/// If @a _count is ~size_t(0), extends the view to the end of the data.
+	vector_ref<_T> cropped(size_t _begin, size_t _count) const { if (m_data && _begin <= m_count && _count <= m_count && _begin + _count <= m_count) return vector_ref<_T>(m_data + _begin, _count == ~size_t(0) ? m_count - _begin : _count); else return vector_ref<_T>(); }
+	/// @returns a new vector_ref which is a shifted view of the original data (not going beyond it).
+	vector_ref<_T> cropped(size_t _begin) const { if (m_data && _begin <= m_count) return vector_ref<_T>(m_data + _begin, m_count - _begin); else return vector_ref<_T>(); }
+	void retarget(_T* _d, size_t _s) { m_data = _d; m_count = _s; }
+	void retarget(std::vector<_T> const& _t) { m_data = _t.data(); m_count = _t.size(); }
+	template <class T> bool overlapsWith(vector_ref<T> _t) const { void const* f1 = data(); void const* t1 = data() + size(); void const* f2 = _t.data(); void const* t2 = _t.data() + _t.size(); return f1 < t2 && t1 > f2; }
+	/// Copies the contents of this vector_ref to the contents of @a _t, up to the max size of @a _t.
+	void copyTo(vector_ref<typename std::remove_const<_T>::type> _t) const { if (overlapsWith(_t)) memmove(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); else memcpy(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); }
+	/// Copies the contents of this vector_ref to the contents of @a _t, and zeros further trailing elements in @a _t.
+	void populate(vector_ref<typename std::remove_const<_T>::type> _t) const { copyTo(_t); memset(_t.data() + m_count, 0, std::max(_t.size(), m_count) - m_count); }
+	/// Securely overwrite the memory.
+	/// @note adapted from OpenSSL's implementation.
+	void cleanse()
+	{
+		static unsigned char s_cleanseCounter = 0;
+		uint8_t* p = (uint8_t*)begin();
+		size_t const len = (uint8_t*)end() - p;
+		size_t loop = len;
+		size_t count = s_cleanseCounter;
+		while (loop--)
+		{
+			*(p++) = (uint8_t)count;
+			count += (17 + ((size_t)p & 0xf));
+		}
+		p = (uint8_t*)memchr((uint8_t*)begin(), (uint8_t)count, len);
+		if (p)
+			count += (63 + (size_t)p);
+		s_cleanseCounter = (uint8_t)count;
+		memset((uint8_t*)begin(), 0, len);
+	}
+
+	_T* begin() { return m_data; }
+	_T* end() { return m_data + m_count; }
+	_T const* begin() const { return m_data; }
+	_T const* end() const { return m_data + m_count; }
+
+	_T& operator[](size_t _i) { assert(m_data); assert(_i < m_count); return m_data[_i]; }
+	_T const& operator[](size_t _i) const { assert(m_data); assert(_i < m_count); return m_data[_i]; }
+
+	bool operator==(vector_ref<_T> const& _cmp) const { return m_data == _cmp.m_data && m_count == _cmp.m_count; }
+	bool operator!=(vector_ref<_T> const& _cmp) const { return !operator==(_cmp); }
+
+#if DEV_LDB
+	operator ldb::Slice() const { return ldb::Slice((char const*)m_data, m_count * sizeof(_T)); }
+#endif
+
+	void reset() { m_data = nullptr; m_count = 0; }
+
+private:
+	_T* m_data;
+	size_t m_count;
+};
+
+template<class _T> vector_ref<_T const> ref(_T const& _t) { return vector_ref<_T const>(&_t, 1); }
+template<class _T> vector_ref<_T> ref(_T& _t) { return vector_ref<_T>(&_t, 1); }
+template<class _T> vector_ref<_T const> ref(std::vector<_T> const& _t) { return vector_ref<_T const>(&_t); }
+template<class _T> vector_ref<_T> ref(std::vector<_T>& _t) { return vector_ref<_T>(&_t); }
+
+}