Fix signed instructions.

CMakeLists.txt

@@ -275,6 +275,9 @@ add_subdirectory(libethereum)
 add_subdirectory(test)
 add_subdirectory(lllc)
 add_subdirectory(eth)
+if ("x${CMAKE_BUILD_TYPE}" STREQUAL "xDebug")
+	add_subdirectory(exp)
+endif ()
 if (NOT ("${TARGET_PLATFORM}" STREQUAL "w64"))
 	add_subdirectory(neth)
 endif ()

exp/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_policy(SET CMP0015 NEW)
+
+aux_source_directory(. SRC_LIST)
+
+include_directories(..)
+
+set(EXECUTABLE exp)
+
+add_executable(${EXECUTABLE} ${SRC_LIST})
+
+if (JSONRPC_LS)
+	add_definitions(-DETH_JSONRPC)
+	include_directories(${JSONRPC_ID})
+	target_link_libraries(${EXECUTABLE} ${JSONRPC_LS})
+endif ()
+
+if (READLINE_LS)
+	add_definitions(-DETH_READLINE)
+	include_directories(${READLINE_ID})
+	target_link_libraries(${EXECUTABLE} ${READLINE_LS})
+endif ()
+
+if (${TARGET_PLATFORM} STREQUAL "w64")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
+	target_link_libraries(${EXECUTABLE} gcc)
+	target_link_libraries(${EXECUTABLE} gdi32)
+	target_link_libraries(${EXECUTABLE} ws2_32)
+	target_link_libraries(${EXECUTABLE} mswsock)
+	target_link_libraries(${EXECUTABLE} shlwapi)
+	target_link_libraries(${EXECUTABLE} iphlpapi)
+	target_link_libraries(${EXECUTABLE} cryptopp)
+	target_link_libraries(${EXECUTABLE} boost_system-mt-s)
+	target_link_libraries(${EXECUTABLE} boost_filesystem-mt-s)
+	target_link_libraries(${EXECUTABLE} boost_thread_win32-mt-s)
+	set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+elseif (UNIX)
+else ()
+	target_link_libraries(${EXECUTABLE} ${CRYPTOPP_LIBRARIES})
+	target_link_libraries(${EXECUTABLE} boost_system)
+	target_link_libraries(${EXECUTABLE} boost_filesystem)
+	find_package(Threads REQUIRED)
+	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+endif ()
+
+target_link_libraries(${EXECUTABLE} ethereum)
+target_link_libraries(${EXECUTABLE} ${MINIUPNPC_LS})
+target_link_libraries(${EXECUTABLE} ${LEVELDB_LS})
+target_link_libraries(${EXECUTABLE} gmp)
+
+install( TARGETS ${EXECUTABLE} DESTINATION bin )
+

exp/main.cpp

@@ -0,0 +1,44 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	cpp-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file main.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ * Ethereum client.
+ */
+
+#include <libethsupport/Log.h>
+#include <libethsupport/Common.h>
+#include <libethsupport/CommonData.h>
+#include "BuildInfo.h"
+using namespace std;
+using namespace eth;
+
+int main(int, char**)
+{
+    u256 z = 0;
+    u256 s = 7;
+    u256 ms = z - s;
+    s256 ams = -7;
+    s256 sms = u2s(ms);
+    cnote << sms;
+    cnote << ams;
+    cnote << ms;
+    u256 t = 3;
+    s256 st = u2s(t);
+    cnote << ms << t << (sms % t) << sms << st << (s2u(sms % st) + 70);
+	return 0;
+}

libethereum/State.h

@@ -106,7 +106,6 @@ struct StateDiff
  */
 class State
 {
-	template <unsigned T> friend class UnitTest;
 	friend class ExtVM;
 	friend class Executive;
 

libethsupport/Common.h

@@ -80,7 +80,23 @@ static const u256 Invalid256 = ~(u256)0;
 static const bytes NullBytes;
 static const std::map<u256, u256> EmptyMapU256U256;
 
-/// Trivial UnitTest type that everyone can agree on, mainly to allow befriending for test classes & their code.
-template <unsigned T> class UnitTest {};
+inline s256 u2s(u256 _u)
+{
+    static const bigint c_end = (bigint)1 << 256;
+    static const u256 c_send = (u256)1 << 255;
+    if (_u < c_send)
+        return (s256)_u;
+    else
+        return (s256)-(c_end - _u);
+}
+
+inline u256 s2u(s256 _u)
+{
+    static const bigint c_end = (bigint)1 << 256;
+    if (_u >= 0)
+        return (u256)_u;
+    else
+        return (u256)(c_end + _u);
+}
 
 }

libevm/VM.h

@@ -59,8 +59,6 @@ inline u256 fromAddress(Address _a)
  */
 class VM
 {
-	template <unsigned T> friend class UnitTest;
-
 public:
 	/// Construct VM object.
 	explicit VM(u256 _gas = 0) { reset(_gas); }
@@ -221,7 +219,7 @@ template <class Ext> eth::bytesConstRef eth::VM::go(Ext& _ext, uint64_t _steps)
 			break;
 		case Instruction::SDIV:
 			require(2);
-			(s256&)m_stack[m_stack.size() - 2] = m_stack[m_stack.size() - 2] ? (s256&)m_stack.back() / (s256&)m_stack[m_stack.size() - 2] : 0;
+            m_stack[m_stack.size() - 2] = m_stack[m_stack.size() - 2] ? s2u(u2s(m_stack.back()) / u2s(m_stack[m_stack.size() - 2])) : 0;
 			m_stack.pop_back();
 			break;
 		case Instruction::MOD:
@@ -231,7 +229,7 @@ template <class Ext> eth::bytesConstRef eth::VM::go(Ext& _ext, uint64_t _steps)
 			break;
 		case Instruction::SMOD:
 			require(2);
-			(s256&)m_stack[m_stack.size() - 2] = m_stack[m_stack.size() - 2] ? (s256&)m_stack.back() % (s256&)m_stack[m_stack.size() - 2] : 0;
+            m_stack[m_stack.size() - 2] = m_stack[m_stack.size() - 2] ? s2u(u2s(m_stack.back()) % u2s(m_stack[m_stack.size() - 2])) : 0;
 			m_stack.pop_back();
 			break;
 		case Instruction::EXP:
@@ -259,12 +257,12 @@ template <class Ext> eth::bytesConstRef eth::VM::go(Ext& _ext, uint64_t _steps)
 			break;
 		case Instruction::SLT:
 			require(2);
-			m_stack[m_stack.size() - 2] = (s256&)m_stack.back() < (s256&)m_stack[m_stack.size() - 2] ? 1 : 0;
+            m_stack[m_stack.size() - 2] = u2s(m_stack.back()) < u2s(m_stack[m_stack.size() - 2]) ? 1 : 0;
 			m_stack.pop_back();
 			break;
 		case Instruction::SGT:
 			require(2);
-			m_stack[m_stack.size() - 2] = (s256&)m_stack.back() > (s256&)m_stack[m_stack.size() - 2] ? 1 : 0;
+            m_stack[m_stack.size() - 2] = u2s(m_stack.back()) > u2s(m_stack[m_stack.size() - 2]) ? 1 : 0;
 			m_stack.pop_back();
 			break;
 		case Instruction::EQ:

liblll/Assembly.cpp

@@ -195,14 +195,14 @@ void Assembly::optimise()
 	{
 		{ Instruction::SUB, [](u256 a, u256 b)->u256{return a - b;} },
 		{ Instruction::DIV, [](u256 a, u256 b)->u256{return a / b;} },
-		{ Instruction::SDIV, [](u256 a, u256 b)->u256{u256 r; (s256&)r = (s256&)a / (s256&)b; return r;} },
+        { Instruction::SDIV, [](u256 a, u256 b)->u256{return s2u(u2s(a) / u2s(b));} },
 		{ Instruction::MOD, [](u256 a, u256 b)->u256{return a % b;} },
-		{ Instruction::SMOD, [](u256 a, u256 b)->u256{u256 r; (s256&)r = (s256&)a % (s256&)b; return r;} },
+        { Instruction::SMOD, [](u256 a, u256 b)->u256{return s2u(u2s(a) % u2s(b));} },
 		{ Instruction::EXP, [](u256 a, u256 b)->u256{return boost::multiprecision::pow(a, (unsigned)b);} },
 		{ Instruction::LT, [](u256 a, u256 b)->u256{return a < b ? 1 : 0;} },
 		{ Instruction::GT, [](u256 a, u256 b)->u256{return a > b ? 1 : 0;} },
-		{ Instruction::SLT, [](u256 a, u256 b)->u256{return *(s256*)&a < *(s256*)&b ? 1 : 0;} },
-		{ Instruction::SGT, [](u256 a, u256 b)->u256{return *(s256*)&a > *(s256*)&b ? 1 : 0;} },
+        { Instruction::SLT, [](u256 a, u256 b)->u256{return u2s(a) < u2s(b) ? 1 : 0;} },
+        { Instruction::SGT, [](u256 a, u256 b)->u256{return u2s(a) > u2s(b) ? 1 : 0;} },
 		{ Instruction::EQ, [](u256 a, u256 b)->u256{return a == b ? 1 : 0;} },
 	};
 	map<Instruction, function<u256(u256, u256)>> c_associative =