cppcheck fixes.

alethzero/GraphParameters.h

@@ -37,8 +37,11 @@ static T graphParameters(T _min, T _max, unsigned _divisions, T* o_from = 0, T*
 	T uMax = _max / _divisor;
 	if (uMax == uMin || !_divisions)
 	{
-		*o_from = 0;
+		if (o_delta && o_from)
-		*o_delta = 1;
+		{
+			*o_from = 0;
+			*o_delta = 1;
+		}
 		return 1;
 	}
 	long double l10 = std::log10((uMax - uMin) / T(_divisions) * 5.5f);

alethzero/Grapher.h

@@ -76,24 +76,24 @@ public:
 	void labelYOrderedPoints(std::map<float, float> const& _translatedData, int _maxCount = 20, float _minFactor = .01f) const;
 
 protected:
-	QPainter* p;
+	QPainter* p = nullptr;
 	QRect active;
 	std::pair<float, float> xRange;
 	std::pair<float, float> yRange;
 
-	float xM;
+	float xM = 0;
-	float xC;
+	float xC = 0;
-	float yM;
+	float yM = 0;
-	float yC;
+	float yC = 0;
 
-	float dx;
+	float dx = 0;
-	float dy;
+	float dy = 0;
 
 	std::function<std::string(float _f)> xLabel;
 	std::function<std::string(float _f)> yLabel;
 	std::function<std::string(float _x, float _y)> pLabel;
 
-	float fontPixelSize;
+	float fontPixelSize = 0;
 
 	// Translate from raw indexed data into x/y graph units. Only relevant for indexed data.
 	float xT(float _dataIndex) const { return _dataIndex * xM + xC; }

alethzero/MiningView.cpp

@@ -48,7 +48,6 @@ string sL(float _x, float _y) { return toString(round(_x * 1000)) + "s (" + toSt
 
 MiningView::MiningView(QWidget* _p): QWidget(_p)
 {
-
 }
 
 void MiningView::appendStats(list<MineInfo> const& _i, MineProgress const& _p)
@@ -86,10 +85,10 @@ void MiningView::appendStats(list<MineInfo> const& _i, MineProgress const& _p)
 
 	for (auto& i: m_resets)
 		i -= o;
-	remove_if(m_resets.begin(), m_resets.end(), [](int i){return i < 0;});
+	m_resets.erase(remove_if(m_resets.begin(), m_resets.end(), [](int i){return i < 0;}), m_resets.end());
 	for (auto& i: m_completes)
 		i -= o;
-	remove_if(m_completes.begin(), m_completes.end(), [](int i){return i < 0;});
+	m_completes.erase(remove_if(m_completes.begin(), m_completes.end(), [](int i){return i < 0;}), m_completes.end());
 
 	m_progress = _p;
 	update();

alethzero/NatspecHandler.cpp

@@ -66,7 +66,6 @@ string NatspecHandler::getUserNotice(string const& json, dev::bytes const& _tran
 {
 	Json::Value natspec;
 	Json::Value userNotice;
-	string retStr;
 	m_reader.parse(json, natspec);
 
 	FixedHash<4> transactionFunctionHash((bytesConstRef(&_transactionData).cropped(0, 4).toBytes()));

alethzero/NatspecHandler.h

@@ -54,6 +54,6 @@ class NatspecHandler: public NatSpecFace
   private:
 	ldb::ReadOptions m_readOptions;
 	ldb::WriteOptions m_writeOptions;
-	ldb::DB* m_db;
+	ldb::DB* m_db = nullptr;
 	Json::Reader m_reader;
 };

alethzero/Transact.cpp

@@ -202,7 +202,7 @@ void Transact::rejigData()
 				for (auto& i: errors)
 					i = "(LLL " + i + ")";
 			}
-			catch (string err)
+			catch (string const& err)
 			{
 				errors.push_back("Serpent " + err);
 			}

eth/main.cpp

@@ -749,7 +749,7 @@ int main(int argc, char** argv)
 						else if (format == "standard+")
 							oof = [&](uint64_t, Instruction instr, bigint, bigint, dev::eth::VM* vvm, dev::eth::ExtVMFace const* vextVM)
 							{
-								dev::eth::VM* vm = (VM*)vvm;
+								dev::eth::VM* vm = vvm;
 								dev::eth::ExtVM const* ext = static_cast<ExtVM const*>(vextVM);
 								if (instr == Instruction::STOP || instr == Instruction::RETURN || instr == Instruction::SUICIDE)
 									for (auto const& i: ext->state().storage(ext->myAddress))

evmjit/libevmjit-cpp/Env.cpp

@@ -70,7 +70,7 @@ extern "C"
 			_env->subBalance(value);
 			auto receiveAddress = right160(*_receiveAddress);
 			auto inRef = bytesConstRef{_inBeg, _inSize};
-			auto outRef = bytesConstRef{_outBeg, _outSize};
+			auto outRef = bytesRef{_outBeg, _outSize};
 			OnOpFunc onOp {}; // TODO: Handle that thing
 			auto codeAddress = right160(*_codeAddress);
 			auto gas = llvm2eth(*io_gas);

libdevcore/Common.cpp

@@ -27,7 +27,7 @@ using namespace dev;
 namespace dev
 {
 
-char const* Version = "0.8.1";
+char const* Version = "0.8.2";
 
 }
 

libdevcore/Worker.h

@@ -64,7 +64,7 @@ protected:
 
 private:
 	std::string m_name;
-	unsigned m_idleWaitMs;
+	unsigned m_idleWaitMs = 0;
 	
 	mutable Mutex x_work;						///< Lock for the network existance.
 	std::unique_ptr<std::thread> m_work;		///< The network thread.

libdevcore/vector_ref.h

@@ -19,7 +19,7 @@ public:
 
 	vector_ref(): m_data(nullptr), m_count(0) {}
 	vector_ref(_T* _data, size_t _count): m_data(_data), m_count(_count) {}
-	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const*, std::string*>::type _data): m_data((_T*)_data->data()), m_count(_data->size() / sizeof(_T)) {}
+	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)) {}
 	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()) {}
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data((_T*)_data.data()), m_count(_data.size() / sizeof(_T)) {}
 #ifdef STORAGE_LEVELDB_INCLUDE_DB_H_
@@ -29,9 +29,10 @@ public:
 
 	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count); }
 	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>((unsigned char const*)m_data, (unsigned char const*)m_data + m_count * sizeof(_T)); }
+	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> operator vector_ref<_T2>() const { assert(m_count * sizeof(_T) / sizeof(_T2) * sizeof(_T2) / sizeof(_T) == m_count); return vector_ref<_T2>((_T2*)m_data, m_count * sizeof(_T) / sizeof(_T2)); }
+	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; }
 	size_t count() const { return m_count; }

libethereum/BlockQueue.cpp

@@ -59,7 +59,6 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc)
 	catch (Exception const& _e)
 	{
 		cwarn << "Ignoring malformed block: " << diagnostic_information(_e);
-		return false;
 		return ImportResult::Malformed;
 	}
 #endif
@@ -128,7 +127,7 @@ void BlockQueue::drain(std::vector<bytes>& o_out)
 void BlockQueue::noteReadyWithoutWriteGuard(h256 _good)
 {
 	list<h256> goodQueue(1, _good);
-	while (goodQueue.size())
+	while (!goodQueue.empty())
 	{
 		auto r = m_unknown.equal_range(goodQueue.front());
 		goodQueue.pop_front();

libethereum/Client.h

@@ -127,7 +127,7 @@ template <class T> struct ABIDeserialiser {};
 template <unsigned N> struct ABIDeserialiser<FixedHash<N>> { static FixedHash<N> deserialise(bytesConstRef& io_t) { static_assert(N <= 32, "Parameter sizes must be at most 32 bytes."); FixedHash<N> ret; io_t.cropped(32 - N, N).populate(ret.ref()); io_t = io_t.cropped(32); return ret; } };
 template <> struct ABIDeserialiser<u256> { static u256 deserialise(bytesConstRef& io_t) { u256 ret = fromBigEndian<u256>(io_t.cropped(0, 32)); io_t = io_t.cropped(32); return ret; } };
 template <> struct ABIDeserialiser<u160> { static u160 deserialise(bytesConstRef& io_t) { u160 ret = fromBigEndian<u160>(io_t.cropped(12, 20)); io_t = io_t.cropped(32); return ret; } };
-template <> struct ABIDeserialiser<string32> { static string32 deserialise(bytesConstRef& io_t) { string32 ret; io_t.cropped(0, 32).populate(vector_ref<char>(ret.data(), 32)); io_t = io_t.cropped(32); return ret; } };
+template <> struct ABIDeserialiser<string32> { static string32 deserialise(bytesConstRef& io_t) { string32 ret; io_t.cropped(0, 32).populate(bytesRef((byte*)ret.data(), 32)); io_t = io_t.cropped(32); return ret; } };
 
 template <class T> T abiOut(bytes const& _data)
 {

libethereum/State.cpp

@@ -1199,11 +1199,11 @@ std::ostream& dev::eth::operator<<(std::ostream& _out, State const& _s)
 						else if (j.second)
 							cached.insert(j.first);
 					}
-				if (delta.size())
+				if (!delta.empty())
 					lead = (lead == " .   ") ? "*.*  " : "***  ";
 
 				contout << " @:";
-				if (delta.size())
+				if (!delta.empty())
 					contout << "???";
 				else
 					contout << r[2].toHash<h256>();

libevm/VMFace.h

@@ -40,7 +40,7 @@ public:
 	explicit VMFace(u256 _gas): m_gas(_gas) {}
 	virtual ~VMFace() = default;
 	VMFace(VMFace const&) = delete;
-	void operator=(VMFace const&) = delete;
+	VMFace& operator=(VMFace const&) = delete;
 
 	virtual void reset(u256 _gas = 0) noexcept { m_gas = _gas; }
 	u256 gas() const noexcept { return m_gas; }

libevm/VMFactory.cpp

@@ -39,7 +39,7 @@ void VMFactory::setKind(VMKind _kind)
 std::unique_ptr<VMFace> VMFactory::create(u256 _gas)
 {
 #if ETH_EVMJIT
-	return std::unique_ptr<VMFace>(g_kind == VMKind::JIT ? (VMFace*)new JitVM(_gas) : new VM(_gas));
+	return std::unique_ptr<VMFace>(g_kind == VMKind::JIT ? static_cast<VMFace*>(new JitVM(_gas)) : static_cast<VMFace*>(new VM(_gas)));
 #else
 	asserts(g_kind == VMKind::Interpreter && "JIT disabled in build configuration");
 	return std::unique_ptr<VMFace>(new VM(_gas));

libevmcore/Assembly.cpp

@@ -214,7 +214,7 @@ ostream& Assembly::streamRLP(ostream& _out, string const& _prefix) const
 			BOOST_THROW_EXCEPTION(InvalidOpcode());
 		}
 
-	if (m_data.size() || m_subs.size())
+	if (!m_data.empty() || !m_subs.empty())
 	{
 		_out << _prefix << ".data:" << endl;
 		for (auto const& i: m_data)
@@ -441,7 +441,7 @@ Assembly& Assembly::optimise(bool _enable)
 			if (i.type() == PushTag)
 				tags.erase(i.data());
 
-		if (tags.size())
+		if (tags.empty())
 		{
 			auto t = *tags.begin();
 			unsigned i = t.second;
@@ -567,7 +567,7 @@ bytes Assembly::assemble() const
 		toBigEndian(tagPos[i.second], r);
 	}
 
-	if (m_data.size())
+	if (!m_data.empty())
 	{
 		ret.push_back(0);
 		for (auto const& i: m_data)

libevmcore/Assembly.h

@@ -72,6 +72,8 @@ inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _i) { r
 class Assembly
 {
 public:
+	Assembly() {}
+
 	AssemblyItem newTag() { return AssemblyItem(Tag, m_usedTags++); }
 	AssemblyItem newPushTag() { return AssemblyItem(PushTag, m_usedTags++); }
 	AssemblyItem newData(bytes const& _data) { h256 h = (u256)std::hash<std::string>()(asString(_data)); m_data[h] = _data; return AssemblyItem(PushData, h); }

libp2p/UDP.cpp

@@ -38,9 +38,9 @@ h256 RLPXDatagramFace::sign(Secret const& _k)
 	Signature sig = dev::sign(_k, sighash); // S(H(type||data))
 	
 	data.resize(h256::size + Signature::size + rlpx.size());
-	bytesConstRef rlpxHash(&data[0], h256::size);
+	bytesRef rlpxHash(&data[0], h256::size);
-	bytesConstRef rlpxSig(&data[h256::size], Signature::size);
+	bytesRef rlpxSig(&data[h256::size], Signature::size);
-	bytesConstRef rlpxPayload(&data[h256::size + Signature::size], rlpx.size());
+	bytesRef rlpxPayload(&data[h256::size + Signature::size], rlpx.size());
 	
 	sig.ref().copyTo(rlpxSig);
 	rlpx.copyTo(rlpxPayload);

libsolidity/Token.h

@@ -372,7 +372,7 @@ public:
 	static Value AssignmentToBinaryOp(Value op)
 	{
 		solAssert(isAssignmentOp(op) && op != Assign, "");
-		return Token::Value(op + (BitOr - AssignBitOr));
+		return Value(op + (BitOr - AssignBitOr));
 	}
 
 	static bool isBitOp(Value op) { return (BitOr <= op && op <= SHR) || op == BitNot; }

libsolidity/Types.h

@@ -430,12 +430,21 @@ public:
 				 Location _location = Location::Internal, bool _arbitraryParameters = false):
 		FunctionType(parseElementaryTypeVector(_parameterTypes), parseElementaryTypeVector(_returnParameterTypes),
 					 _location, _arbitraryParameters) {}
-	FunctionType(TypePointers const& _parameterTypes, TypePointers const& _returnParameterTypes,
+	FunctionType(
-				 Location _location = Location::Internal,
+		TypePointers const&	_parameterTypes,
-				 bool _arbitraryParameters = false, bool _gasSet = false, bool _valueSet = false):
+		TypePointers const&	_returnParameterTypes,
-		m_parameterTypes(_parameterTypes), m_returnParameterTypes(_returnParameterTypes),
+		Location			_location = Location::Internal,
-		m_location(_location),
+		bool				_arbitraryParameters = false,
-		m_arbitraryParameters(_arbitraryParameters), m_gasSet(_gasSet), m_valueSet(_valueSet) {}
+		bool				_gasSet = false,
+		bool				_valueSet = false
+	):
+		m_parameterTypes		(_parameterTypes),
+		m_returnParameterTypes	(_returnParameterTypes),
+		m_location				(_location),
+		m_arbitraryParameters	(_arbitraryParameters),
+		m_gasSet				(_gasSet),
+		m_valueSet				(_valueSet)
+	{}
 
 	TypePointers const& getParameterTypes() const { return m_parameterTypes; }
 	std::vector<std::string> const& getParameterNames() const { return m_parameterNames; }
@@ -490,7 +499,7 @@ private:
 	bool const m_arbitraryParameters = false;
 	bool const m_gasSet = false; ///< true iff the gas value to be used is on the stack
 	bool const m_valueSet = false; ///< true iff the value to be sent is on the stack
-	bool m_isConstant;
+	bool m_isConstant = false;
 	mutable std::unique_ptr<MemberList> m_members;
 	Declaration const* m_declaration = nullptr;
 };