Merge branch 'develop' into develop-evmcc

Conflicts:
	libevm/VM.h
	test/vm.cpp

libdevcore/FixedHash.h

@@ -83,6 +83,7 @@ public:
 	bool operator==(FixedHash const& _c) const { return m_data == _c.m_data; }
 	bool operator!=(FixedHash const& _c) const { return m_data != _c.m_data; }
 	bool operator<(FixedHash const& _c) const { return m_data < _c.m_data; }
+	bool operator>=(FixedHash const& _c) const { return m_data >= _c.m_data; }
 
 	// The obvious binary operators.
 	FixedHash& operator^=(FixedHash const& _c) { for (unsigned i = 0; i < N; ++i) m_data[i] ^= _c.m_data[i]; return *this; }

libdevcore/Worker.cpp

@@ -41,7 +41,8 @@ void Worker::startWorking()
 		startedWorking();
 		while (!m_stop)
 		{
-			this_thread::sleep_for(chrono::milliseconds(30));
+			if (m_idleWaitMs)
+				this_thread::sleep_for(chrono::milliseconds(m_idleWaitMs));
 			doWork();
 		}
 		cdebug << "Finishing up worker thread";

libdevcore/Worker.h

@@ -31,7 +31,7 @@ namespace dev
 class Worker
 {
 protected:
-	Worker(std::string const& _name = "anon"): m_name(_name) {}
+	Worker(std::string const& _name = "anon", unsigned _idleWaitMs = 30): m_name(_name), m_idleWaitMs(_idleWaitMs) {}
 
 	/// Move-constructor.
 	Worker(Worker&& _m) { std::swap(m_name, _m.m_name); }
@@ -41,20 +41,34 @@ protected:
 
 	virtual ~Worker() { stopWorking(); }
 
+	/// Allows changing worker name if work is stopped.
 	void setName(std::string _n) { if (!isWorking()) m_name = _n; }
 
+	/// Starts worker thread; causes startedWorking() to be called.
 	void startWorking();
+	
+	/// Stop worker thread; causes call to stopWorking().
 	void stopWorking();
+	
+	/// Returns if worker thread is present.
 	bool isWorking() const { Guard l(x_work); return !!m_work; }
+	
+	/// Called after thread is started from startWorking().
 	virtual void startedWorking() {}
+	
+	/// Called continuously following sleep for m_idleWaitMs.
 	virtual void doWork() = 0;
+	
+	/// Called when is to be stopped, just prior to thread being joined.
 	virtual void doneWorking() {}
 
 private:
+	std::string m_name;
+	unsigned m_idleWaitMs;
+	
 	mutable Mutex x_work;						///< Lock for the network existance.
 	std::unique_ptr<std::thread> m_work;		///< The network thread.
 	bool m_stop = false;
-	std::string m_name;
 };
 
 }

libdevcrypto/Common.cpp

@@ -33,6 +33,15 @@ using namespace dev::crypto;
 
 static Secp256k1 s_secp256k1;
 
+bool dev::SignatureStruct::isValid()
+{
+	if (this->v > 1 ||
+			this->r >= h256("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141") ||
+			this->s >= h256("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"))
+		return false;
+	return true;
+}
+
 Public dev::toPublic(Secret const& _secret)
 {
 	Public p;

libdevcrypto/Common.h

@@ -43,7 +43,15 @@ using Public = h512;
 /// @NOTE This is not endian-specific; it's just a bunch of bytes.
 using Signature = h520;
 
-struct SignatureStruct { h256 r; h256 s; byte v; };
+struct SignatureStruct
+{
+	/// @returns true if r,s,v values are valid, otherwise false
+	bool isValid();
+
+	h256 r;
+	h256 s;
+	byte v;
+};
 
 /// An Ethereum address: 20 bytes.
 /// @NOTE This is not endian-specific; it's just a bunch of bytes.

libethcore/CommonEth.cpp

@@ -33,7 +33,7 @@ namespace dev
 namespace eth
 {
 
-const unsigned c_protocolVersion = 43;
+const unsigned c_protocolVersion = 44;
 const unsigned c_databaseVersion = 4;
 
 static const vector<pair<u256, string>> g_units =

libethcore/Exceptions.h

@@ -60,6 +60,7 @@ struct InvalidTransactionGasUsed: virtual dev::Exception {};
 struct InvalidTransactionsStateRoot: virtual dev::Exception {};
 struct InvalidReceiptsStateRoot: virtual dev::Exception {};
 struct InvalidTimestamp: virtual dev::Exception {};
+struct InvalidLogBloom: virtual dev::Exception {};
 class InvalidNonce: virtual public dev::Exception { public: InvalidNonce(u256 _required = 0, u256 _candidate = 0): required(_required), candidate(_candidate) {} u256 required; u256 candidate; virtual const char* what() const noexcept; };
 class InvalidBlockNonce: virtual public dev::Exception { public: InvalidBlockNonce(h256 _h = h256(), h256 _n = h256(), u256 _d = 0): h(_h), n(_n), d(_d) {} h256 h; h256 n; u256 d; virtual const char* what() const noexcept; };
 struct InvalidParentHash: virtual dev::Exception {};

libethereum/EthereumHost.h

@@ -51,6 +51,7 @@ class BlockQueue;
 /**
  * @brief The EthereumHost class
  * @warning None of this is thread-safe. You have been warned.
+ * @doWork Syncs to peers and sends new blocks and transactions.
  */
 class EthereumHost: public p2p::HostCapability<EthereumPeer>, Worker
 {

libethereum/State.cpp

@@ -55,6 +55,10 @@ void ecrecoverCode(bytesConstRef _in, bytesRef _out)
 
 	memcpy(&in, _in.data(), min(_in.size(), sizeof(in)));
 
+	SignatureStruct sig{in.r, in.s, (byte)((int)(u256)in.v - 27)};
+	if (!sig.isValid() || in.v > 28)
+		return;
+
 	byte pubkey[65];
 	int pubkeylen = 65;
 	secp256k1_start();
@@ -663,6 +667,12 @@ u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
 		BOOST_THROW_EXCEPTION(InvalidReceiptsStateRoot());
 	}
 
+	if (m_currentBlock.logBloom != logBloom())
+	{
+		cwarn << "Bad log bloom!";
+		BOOST_THROW_EXCEPTION(InvalidLogBloom());
+	}
+
 	// Initialise total difficulty calculation.
 	u256 tdIncrease = m_currentBlock.difficulty;
 

libethereum/Transaction.cpp

@@ -82,7 +82,9 @@ Address Transaction::sender() const
 void Transaction::sign(Secret _priv)
 {
 	auto sig = dev::sign(_priv, sha3(WithoutSignature));
-	m_vrs = *(SignatureStruct const*)&sig;
+	SignatureStruct sigStruct = *(SignatureStruct const*)&sig;
+	if (sigStruct.isValid())
+		m_vrs = sigStruct;
 }
 
 void Transaction::streamRLP(RLPStream& _s, IncludeSignature _sig) const

libethereum/Utility.h

@@ -29,6 +29,17 @@ namespace dev
 namespace eth
 {
 
+/**
+ * Takes a user-authorable string with several whitespace delimited arguments and builds a byte array
+ * from it. Arguments can be hex data/numerals, decimal numbers or ASCII strings. Literals are padded
+ * to 32 bytes if prefixed by a '@' (or not prefixed at all), and tightly packed if prefixed by a '$'.
+ * Currency multipliers can be provided.
+ *
+ * Example:
+ * @code
+ * parseData("$42 0x42 $\"Hello\"");	// == bytes(1, 0x2a) + bytes(31, 0) + bytes(1, 0x42) + asBytes("Hello");
+ * @endcode
+ */
 bytes parseData(std::string const& _args);
 
 }

libevm/VM.h

@@ -45,7 +45,7 @@ public:
 
 	virtual bytesConstRef go(ExtVMFace& _ext, OnOpFunc const& _onOp = {}, uint64_t _steps = (uint64_t)-1) override final;
 
-	void require(u256 _n) { if (m_stack.size() < _n) BOOST_THROW_EXCEPTION(StackTooSmall() << RequirementError((bigint)_n, (bigint)m_stack.size())); }
+	void require(u256 _n) { if (m_stack.size() < _n) { if (m_onFail) m_onFail(); BOOST_THROW_EXCEPTION(StackTooSmall() << RequirementError((bigint)_n, (bigint)m_stack.size())); } }
 	void requireMem(unsigned _n) { if (m_temp.size() < _n) { m_temp.resize(_n); } }
 	u256 curPC() const { return m_curPC; }
 
@@ -63,6 +63,7 @@ private:
 	bytes m_temp;
 	u256s m_stack;
 	std::set<u256> m_jumpDests;
+	std::function<void()> m_onFail;
 };
 
 }
@@ -107,6 +108,15 @@ template <class Ext> dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
 		// FEES...
 		bigint runGas = c_stepGas;
 		bigint newTempSize = m_temp.size();
+
+		auto onOperation = [&]()
+		{
+			if (_onOp)
+				_onOp(osteps - _steps - 1, inst, newTempSize > m_temp.size() ? (newTempSize - m_temp.size()) / 32 : bigint(0), runGas, this, &_ext);
+		};
+		// should work, but just seems to result in immediate errorless exit on initial execution. yeah. weird.
+		//m_onFail = std::function<void()>(onOperation);
+
 		switch (inst)
 		{
 		case Instruction::STOP:
@@ -333,8 +343,9 @@ template <class Ext> dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
 		if (newTempSize > m_temp.size())
 			runGas += c_memoryGas * (newTempSize - m_temp.size()) / 32;
 
-		if (_onOp)
-			_onOp(osteps - _steps - 1, inst, newTempSize > m_temp.size() ? (newTempSize - m_temp.size()) / 32 : bigint(0), runGas, this, &_ext);
+		onOperation();
+//		if (_onOp)
+//			_onOp(osteps - _steps - 1, inst, newTempSize > m_temp.size() ? (newTempSize - m_temp.size()) / 32 : bigint(0), runGas, this, &_ext);
 
 		if (m_gas < runGas)
 		{

libp2p/Common.cpp

@@ -53,6 +53,20 @@ bool p2p::isPrivateAddress(bi::address const& _addressToCheck)
 	return false;
 }
 
+// Helper function to determine if an address is localhost
+bool p2p::isLocalHostAddress(bi::address const& _addressToCheck)
+{
+	// @todo: ivp6 link-local adresses (macos), ex: fe80::1%lo0
+	static const set<bi::address> c_rejectAddresses = {
+		{bi::address_v4::from_string("127.0.0.1")},
+		{bi::address_v4::from_string("0.0.0.0")},
+		{bi::address_v6::from_string("::1")},
+		{bi::address_v6::from_string("::")}
+	};
+	
+	return find(c_rejectAddresses.begin(), c_rejectAddresses.end(), _addressToCheck) != c_rejectAddresses.end();
+}
+
 std::string p2p::reasonOf(DisconnectReason _r)
 {
 	switch (_r)

libp2p/Common.h

@@ -47,6 +47,7 @@ namespace p2p
 using NodeId = h512;
 
 bool isPrivateAddress(bi::address const& _addressToCheck);
+bool isLocalHostAddress(bi::address const& _addressToCheck);
 
 class UPnP;
 class Capability;

libp2p/Host.cpp

@@ -46,103 +46,196 @@ using namespace std;
 using namespace dev;
 using namespace dev::p2p;
 
-// Addresses we will skip during network interface discovery
-// Use a vector as the list is small
-// Why this and not names?
-// Under MacOSX loopback (127.0.0.1) can be named lo0 and br0 are bridges (0.0.0.0)
-static const set<bi::address> c_rejectAddresses = {
-	{bi::address_v4::from_string("127.0.0.1")},
-	{bi::address_v6::from_string("::1")},
-	{bi::address_v4::from_string("0.0.0.0")},
-	{bi::address_v6::from_string("::")}
-};
-
-Host::Host(std::string const& _clientVersion, NetworkPreferences const& _n, bool _start):
-	Worker("p2p"),
-	m_clientVersion(_clientVersion),
-	m_netPrefs(_n),
-	m_ioService(new ba::io_service),
-	m_acceptor(new bi::tcp::acceptor(*m_ioService)),
-	m_socket(new bi::tcp::socket(*m_ioService)),
-	m_key(KeyPair::create())
+std::vector<bi::address> Host::getInterfaceAddresses()
 {
-	populateAddresses();
-	clog(NetNote) << "Id:" << id().abridged();
-	if (_start)
-		start();
-}
-
-Host::~Host()
-{
-	quit();
+	std::vector<bi::address> addresses;
+	
+#ifdef _WIN32
+	WSAData wsaData;
+	if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
+		BOOST_THROW_EXCEPTION(NoNetworking());
+	
+	char ac[80];
+	if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR)
+	{
+		clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name.";
+		WSACleanup();
+		BOOST_THROW_EXCEPTION(NoNetworking());
+	}
+	
+	struct hostent* phe = gethostbyname(ac);
+	if (phe == 0)
+	{
+		clog(NetWarn) << "Bad host lookup.";
+		WSACleanup();
+		BOOST_THROW_EXCEPTION(NoNetworking());
+	}
+	
+	for (int i = 0; phe->h_addr_list[i] != 0; ++i)
+	{
+		struct in_addr addr;
+		memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
+		char *addrStr = inet_ntoa(addr);
+		bi::address address(bi::address::from_string(addrStr));
+		if (!isLocalHostAddress(address))
+			addresses.push_back(ad.to_v4());
+	}
+	
+	WSACleanup();
+#else
+	ifaddrs* ifaddr;
+	if (getifaddrs(&ifaddr) == -1)
+		BOOST_THROW_EXCEPTION(NoNetworking());
+	
+	for (auto ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
+	{
+		if (!ifa->ifa_addr || string(ifa->ifa_name) == "lo0")
+			continue;
+		
+		if (ifa->ifa_addr->sa_family == AF_INET)
+		{
+			in_addr addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
+			boost::asio::ip::address_v4 address(boost::asio::detail::socket_ops::network_to_host_long(addr.s_addr));
+			if (!isLocalHostAddress(address))
+				addresses.push_back(address);
+		}
+		else if (ifa->ifa_addr->sa_family == AF_INET6)
+		{
+			sockaddr_in6* sockaddr = ((struct sockaddr_in6 *)ifa->ifa_addr);
+			in6_addr addr = sockaddr->sin6_addr;
+			boost::asio::ip::address_v6::bytes_type bytes;
+			memcpy(&bytes[0], addr.s6_addr, 16);
+			boost::asio::ip::address_v6 address(bytes, sockaddr->sin6_scope_id);
+			if (!isLocalHostAddress(address))
+				addresses.push_back(address);
+		}
+	}
+	
+	if (ifaddr!=NULL)
+		freeifaddrs(ifaddr);
+	
+#endif
+	
+	return std::move(addresses);
 }
 
-void Host::start()
+int Host::listen4(bi::tcp::acceptor* _acceptor, unsigned short _listenPort)
 {
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
-		return;
-
-	if (isWorking())
-		stop();
-
+	int retport = -1;
 	for (unsigned i = 0; i < 2; ++i)
 	{
-		bi::tcp::endpoint endpoint(bi::tcp::v4(), i ? 0 : m_netPrefs.listenPort);
+		// try to connect w/listenPort, else attempt net-allocated port
+		bi::tcp::endpoint endpoint(bi::tcp::v4(), i ? 0 : _listenPort);
 		try
 		{
-			m_acceptor->open(endpoint.protocol());
-			m_acceptor->set_option(ba::socket_base::reuse_address(true));
-			m_acceptor->bind(endpoint);
-			m_acceptor->listen();
-			m_listenPort = i ? m_acceptor->local_endpoint().port() : m_netPrefs.listenPort;
+			_acceptor->open(endpoint.protocol());
+			_acceptor->set_option(ba::socket_base::reuse_address(true));
+			_acceptor->bind(endpoint);
+			_acceptor->listen();
+			retport = _acceptor->local_endpoint().port();
 			break;
 		}
 		catch (...)
 		{
 			if (i)
 			{
+				// both attempts failed
 				cwarn << "Couldn't start accepting connections on host. Something very wrong with network?\n" << boost::current_exception_diagnostic_information();
-				return;
 			}
-			m_acceptor->close();
+			
+			// first attempt failed
+			_acceptor->close();
 			continue;
 		}
 	}
+	return retport;
+}
 
-	for (auto const& h: m_capabilities)
-		h.second->onStarting();
+bi::tcp::endpoint Host::traverseNAT(std::vector<bi::address> const& _ifAddresses, unsigned short _listenPort, bi::address& o_upnpifaddr)
+{
+	asserts(_listenPort);
+	
+	UPnP* upnp;
+	try
+	{
+		upnp = new UPnP;
+	}
+	// let m_upnp continue as null - we handle it properly.
+	catch (NoUPnPDevice) {}
+	
+	bi::tcp::endpoint upnpep;
+	if (upnp && upnp->isValid())
+	{
+		bi::address paddr;
+		int extPort = 0;
+		for (auto const& addr: _ifAddresses)
+			if (addr.is_v4() && isPrivateAddress(addr) && (extPort = upnp->addRedirect(addr.to_string().c_str(), _listenPort)))
+			{
+				paddr = addr;
+				break;
+			}
 
-	startWorking();
+		auto eip = upnp->externalIP();
+		bi::address eipaddr(bi::address::from_string(eip));
+		if (extPort && eip != string("0.0.0.0") && !isPrivateAddress(eipaddr))
+		{
+			clog(NetNote) << "Punched through NAT and mapped local port" << _listenPort << "onto external port" << extPort << ".";
+			clog(NetNote) << "External addr:" << eip;
+			o_upnpifaddr = paddr;
+			upnpep = bi::tcp::endpoint(eipaddr, (unsigned short)extPort);
+		}
+		else
+			clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place).";
+		
+		if (upnp)
+			delete upnp;
+	}
+
+	return upnpep;
 }
 
-void Host::stop()
+Host::Host(std::string const& _clientVersion, NetworkPreferences const& _n, bool _start):
+	Worker("p2p", 0),
+	m_clientVersion(_clientVersion),
+	m_netPrefs(_n),
+	m_ifAddresses(getInterfaceAddresses()),
+	m_ioService(new ba::io_service),
+	m_acceptor(new bi::tcp::acceptor(*m_ioService)),
+	m_socket(new bi::tcp::socket(*m_ioService)),
+	m_key(KeyPair::create())
 {
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
-		return;
-
-	for (auto const& h: m_capabilities)
-		h.second->onStopping();
+	for (auto address: m_ifAddresses)
+		if (address.is_v4())
+			clog(NetNote) << "IP Address: " << address << " = " << (isPrivateAddress(address) ? "[LOCAL]" : "[PEER]");
+	
+	clog(NetNote) << "Id:" << id().abridged();
+	if (_start)
+		start();
+}
 
-	stopWorking();
+Host::~Host()
+{
+	quit();
+}
 
-	if (m_acceptor->is_open())
-	{
-		if (m_accepting)
-			m_acceptor->cancel();
-		m_acceptor->close();
-		m_accepting = false;
-	}
-	if (m_socket->is_open())
-		m_socket->close();
-	disconnectPeers();
+void Host::start()
+{
+	startWorking();
+}
 
-	if (!!m_ioService)
+void Host::stop()
+{
 	{
-		m_ioService->stop();
-		m_ioService->reset();
+		// prevent m_run from being set to false at same time as set to true by start()
+		lock_guard<mutex> l(x_runtimer);
+		// once m_run is false the scheduler will shutdown network and stopWorking()
+		m_run = false;
 	}
+	
+	// we know shutdown is complete when m_timer is reset
+	while (m_timer)
+		this_thread::sleep_for(chrono::milliseconds(50));
+	stopWorking();
 }
 
 void Host::quit()
@@ -150,7 +243,8 @@ void Host::quit()
 	// called to force io_service to kill any remaining tasks it might have -
 	// such tasks may involve socket reads from Capabilities that maintain references
 	// to resources we're about to free.
-	stop();
+	if (isWorking())
+		stop();
 	m_acceptor.reset();
 	m_socket.reset();
 	m_ioService.reset();
@@ -183,33 +277,6 @@ void Host::registerPeer(std::shared_ptr<Session> _s, CapDescs const& _caps)
 		}
 }
 
-void Host::disconnectPeers()
-{
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
-		return;
-
-	for (unsigned n = 0;; n = 0)
-	{
-		{
-			RecursiveGuard l(x_peers);
-			for (auto i: m_peers)
-				if (auto p = i.second.lock())
-				{
-					p->disconnect(ClientQuit);
-					n++;
-				}
-		}
-		if (!n)
-			break;
-		m_ioService->poll();
-		this_thread::sleep_for(chrono::milliseconds(100));
-	}
-
-	delete m_upnp;
-	m_upnp = nullptr;
-}
-
 void Host::seal(bytes& _b)
 {
 	_b[0] = 0x22;
@@ -223,165 +290,6 @@ void Host::seal(bytes& _b)
 	_b[7] = len & 0xff;
 }
 
-void Host::determinePublic(string const& _publicAddress, bool _upnp)
-{
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
-		return;
-
-	if (_upnp)
-		try
-		{
-			m_upnp = new UPnP;
-		}
-		catch (NoUPnPDevice) {}	// let m_upnp continue as null - we handle it properly.
-
-	bi::tcp::resolver r(*m_ioService);
-	if (m_upnp && m_upnp->isValid() && m_peerAddresses.size())
-	{
-		clog(NetNote) << "External addr:" << m_upnp->externalIP();
-		int p;
-		for (auto const& addr : m_peerAddresses)
-			if ((p = m_upnp->addRedirect(addr.to_string().c_str(), m_listenPort)))
-				break;
-		if (p)
-			clog(NetNote) << "Punched through NAT and mapped local port" << m_listenPort << "onto external port" << p << ".";
-		else
-		{
-			// couldn't map
-			clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place). Assuming" << m_listenPort << "is local & external port.";
-			p = m_listenPort;
-		}
-
-		auto eip = m_upnp->externalIP();
-		if (eip == string("0.0.0.0") && _publicAddress.empty())
-			m_public = bi::tcp::endpoint(bi::address(), (unsigned short)p);
-		else
-		{
-			bi::address adr = adr = bi::address::from_string(eip);
-			try
-			{
-				adr = bi::address::from_string(_publicAddress);
-			}
-			catch (...) {}
-			m_public = bi::tcp::endpoint(adr, (unsigned short)p);
-			m_addresses.push_back(m_public.address());
-		}
-	}
-	else
-	{
-		// No UPnP - fallback on given public address or, if empty, the assumed peer address.
-		bi::address adr = m_peerAddresses.size() ? m_peerAddresses[0] : bi::address();
-		try
-		{
-			adr = bi::address::from_string(_publicAddress);
-		}
-		catch (...) {}
-		m_public = bi::tcp::endpoint(adr, m_listenPort);
-		m_addresses.push_back(adr);
-	}
-}
-
-void Host::populateAddresses()
-{
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
-		return;
-
-#ifdef _WIN32
-	WSAData wsaData;
-	if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
-		BOOST_THROW_EXCEPTION(NoNetworking());
-
-	char ac[80];
-	if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR)
-	{
-		clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name.";
-		WSACleanup();
-		BOOST_THROW_EXCEPTION(NoNetworking());
-	}
-
-	struct hostent* phe = gethostbyname(ac);
-	if (phe == 0)
-	{
-		clog(NetWarn) << "Bad host lookup.";
-		WSACleanup();
-		BOOST_THROW_EXCEPTION(NoNetworking());
-	}
-
-	for (int i = 0; phe->h_addr_list[i] != 0; ++i)
-	{
-		struct in_addr addr;
-		memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
-		char *addrStr = inet_ntoa(addr);
-		bi::address ad(bi::address::from_string(addrStr));
-		m_addresses.push_back(ad.to_v4());
-		bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end();
-		if (!isLocal)
-			m_peerAddresses.push_back(ad.to_v4());
-		clog(NetNote) << "Address: " << ac << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]");
-	}
-
-	WSACleanup();
-#else
-	ifaddrs* ifaddr;
-	if (getifaddrs(&ifaddr) == -1)
-		BOOST_THROW_EXCEPTION(NoNetworking());
-
-	bi::tcp::resolver r(*m_ioService);
-
-	for (ifaddrs* ifa = ifaddr; ifa; ifa = ifa->ifa_next)
-	{
-		if (!ifa->ifa_addr)
-			continue;
-		if (ifa->ifa_addr->sa_family == AF_INET)
-		{
-			char host[NI_MAXHOST];
-			if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
-				continue;
-			try
-			{
-				auto it = r.resolve({host, "30303"});
-				bi::tcp::endpoint ep = it->endpoint();
-				bi::address ad = ep.address();
-				m_addresses.push_back(ad.to_v4());
-				bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end();
-				if (!isLocal)
-					m_peerAddresses.push_back(ad.to_v4());
-				clog(NetNote) << "Address: " << host << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]");
-			}
-			catch (...)
-			{
-				clog(NetNote) << "Couldn't resolve: " << host;
-			}
-		}
-		else if (ifa->ifa_addr->sa_family == AF_INET6)
-		{
-			char host[NI_MAXHOST];
-			if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
-				continue;
-			try
-			{
-				auto it = r.resolve({host, "30303"});
-				bi::tcp::endpoint ep = it->endpoint();
-				bi::address ad = ep.address();
-				m_addresses.push_back(ad.to_v6());
-				bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end();
-				if (!isLocal)
-					m_peerAddresses.push_back(ad);
-				clog(NetNote) << "Address: " << host << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]");
-			}
-			catch (...)
-			{
-				clog(NetNote) << "Couldn't resolve: " << host;
-			}
-		}
-	}
-
-	freeifaddrs(ifaddr);
-#endif
-}
-
 shared_ptr<Node> Host::noteNode(NodeId _id, bi::tcp::endpoint _a, Origin _o, bool _ready, NodeId _oldId)
 {
 	RecursiveGuard l(x_peers);
@@ -459,10 +367,73 @@ Nodes Host::potentialPeers(RangeMask<unsigned> const& _known)
 	return ret;
 }
 
+void Host::determinePublic(string const& _publicAddress, bool _upnp)
+{
+	m_peerAddresses.clear();
+	
+	// no point continuing if there are no interface addresses or valid listen port
+	if (!m_ifAddresses.size() || m_listenPort < 1)
+		return;
+
+	// populate interfaces we'll listen on (eth listens on all interfaces); ignores local
+	for (auto addr: m_ifAddresses)
+		if ((m_netPrefs.localNetworking || !isPrivateAddress(addr)) && !isLocalHostAddress(addr))
+			m_peerAddresses.insert(addr);
+	
+	// if user supplied address is a public address then we use it
+	// if user supplied address is private, and localnetworking is enabled, we use it
+	bi::address reqpublicaddr(bi::address(_publicAddress.empty() ? bi::address() : bi::address::from_string(_publicAddress)));
+	bi::tcp::endpoint reqpublic(reqpublicaddr, m_listenPort);
+	bool isprivate = isPrivateAddress(reqpublicaddr);
+	bool ispublic = !isprivate && !isLocalHostAddress(reqpublicaddr);
+	if (!reqpublicaddr.is_unspecified() && (ispublic || (isprivate && m_netPrefs.localNetworking)))
+	{
+		if (!m_peerAddresses.count(reqpublicaddr))
+			m_peerAddresses.insert(reqpublicaddr);
+		m_public = reqpublic;
+		return;
+	}
+	
+	// if address wasn't provided, then use first public ipv4 address found
+	for (auto addr: m_peerAddresses)
+		if (addr.is_v4() && !isPrivateAddress(addr))
+		{
+			m_public = bi::tcp::endpoint(*m_peerAddresses.begin(), m_listenPort);
+			return;
+		}
+	
+	// or find address via upnp
+	if (_upnp)
+	{
+		bi::address upnpifaddr;
+		bi::tcp::endpoint upnpep = traverseNAT(m_ifAddresses, m_listenPort, upnpifaddr);
+		if (!upnpep.address().is_unspecified() && !upnpifaddr.is_unspecified())
+		{
+			if (!m_peerAddresses.count(upnpep.address()))
+				m_peerAddresses.insert(upnpep.address());
+			m_public = upnpep;
+			return;
+		}
+	}
+
+	// or if no address provided, use private ipv4 address if local networking is enabled
+	if (reqpublicaddr.is_unspecified())
+		if (m_netPrefs.localNetworking)
+			for (auto addr: m_peerAddresses)
+				if (addr.is_v4() && isPrivateAddress(addr))
+				{
+					m_public = bi::tcp::endpoint(addr, m_listenPort);
+					return;
+				}
+	
+	// otherwise address is unspecified
+	m_public = bi::tcp::endpoint(bi::address(), m_listenPort);
+}
+
 void Host::ensureAccepting()
 {
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
-	if (!m_ioService)
+	// return if there's no io-server (quit called) or we're not listening
+	if (!m_ioService || m_listenPort < 1)
 		return;
 
 	if (!m_accepting)
@@ -654,12 +625,9 @@ void Host::growPeers()
 					return;
 			}
 		else
-		{
-			ensureAccepting();
 			for (auto const& i: m_peers)
 				if (auto p = i.second.lock())
 					p->ensureNodesRequested();
-		}
 	}
 }
 
@@ -717,46 +685,154 @@ PeerInfos Host::peers(bool _updatePing) const
 				ret.push_back(j->m_info);
 	return ret;
 }
+			
+void Host::run(boost::system::error_code const& error)
+{
+	static unsigned s_lasttick = 0;
+	s_lasttick += c_timerInterval;
+	
+	if (error || !m_ioService)
+	{
+		// timer died or io service went away, so stop here
+		m_timer.reset();
+		return;
+	}
 
+	// network running
+	if (m_run)
+	{
+		if (s_lasttick >= c_timerInterval * 50)
+		{
+			growPeers();
+			prunePeers();
+			s_lasttick = 0;
+		}
+		
+		if (m_hadNewNodes)
+		{
+			for (auto p: m_peers)
+				if (auto pp = p.second.lock())
+					pp->serviceNodesRequest();
+			
+			m_hadNewNodes = false;
+		}
+		
+		if (chrono::steady_clock::now() - m_lastPing > chrono::seconds(30))	// ping every 30s.
+		{
+			for (auto p: m_peers)
+				if (auto pp = p.second.lock())
+					if (chrono::steady_clock::now() - pp->m_lastReceived > chrono::seconds(60))
+						pp->disconnect(PingTimeout);
+			pingAll();
+		}
+		
+		auto runcb = [this](boost::system::error_code const& error) -> void { run(error); };
+		m_timer->expires_from_now(boost::posix_time::milliseconds(c_timerInterval));
+		m_timer->async_wait(runcb);
+		
+		return;
+	}
+	
+	// network stopping
+	if (!m_run)
+	{
+		// close acceptor
+		if (m_acceptor->is_open())
+		{
+			if (m_accepting)
+				m_acceptor->cancel();
+			m_acceptor->close();
+			m_accepting = false;
+		}
+		
+		// stop capabilities (eth: stops syncing or block/tx broadcast)
+		for (auto const& h: m_capabilities)
+			h.second->onStopping();
+		
+		// disconnect peers
+		for (unsigned n = 0;; n = 0)
+		{
+			{
+				RecursiveGuard l(x_peers);
+				for (auto i: m_peers)
+					if (auto p = i.second.lock())
+						if (p->isOpen())
+						{
+							p->disconnect(ClientQuit);
+							n++;
+						}
+			}
+			if (!n)
+				break;
+			this_thread::sleep_for(chrono::milliseconds(100));
+		}
+		
+		if (m_socket->is_open())
+			m_socket->close();
+		
+		// m_run is false, so we're stopping; kill timer
+		s_lasttick = 0;
+		
+		// causes parent thread's stop() to continue which calls stopWorking()
+		m_timer.reset();
+		
+		// stop ioservice (stops blocking worker thread, allowing thread to join)
+		if (!!m_ioService)
+			m_ioService->stop();
+		return;
+	}
+}
+			
 void Host::startedWorking()
 {
-	determinePublic(m_netPrefs.publicIP, m_netPrefs.upnp);
-	ensureAccepting();
-
-	if (!m_public.address().is_unspecified() && (m_nodes.empty() || m_nodes[m_nodesList[0]]->id != id()))
-		noteNode(id(), m_public, Origin::Perfect, false);
-
-	clog(NetNote) << "Id:" << id().abridged();
+	if (!m_timer)
+	{
+		// no timer means this is first run and network must be started
+		// (run once when host worker thread calls startedWorking())
+		
+		{
+			// prevent m_run from being set to true at same time as set to false by stop()
+			// don't release mutex until m_timer is set so in case stop() is called at same
+			// time, stop will wait on m_timer and graceful network shutdown.
+			lock_guard<mutex> l(x_runtimer);
+			// reset io service and create deadline timer
+			m_timer.reset(new boost::asio::deadline_timer(*m_ioService));
+			m_run = true;
+		}
+		m_ioService->reset();
+		
+		// try to open acceptor (todo: ipv6)
+		m_listenPort = listen4(m_acceptor.get(), m_netPrefs.listenPort);
+		
+		// start capability threads
+		for (auto const& h: m_capabilities)
+			h.second->onStarting();
+		
+		// determine public IP, but only if we're able to listen for connections
+		// todo: GUI when listen is unavailable in UI
+		if (m_listenPort)
+		{
+			determinePublic(m_netPrefs.publicIP, m_netPrefs.upnp);
+			ensureAccepting();
+		}
+		
+		// if m_public address is valid then add us to node list
+		// todo: abstract empty() and emplace logic
+		if (!m_public.address().is_unspecified() && (m_nodes.empty() || m_nodes[m_nodesList[0]]->id != id()))
+			noteNode(id(), m_public, Origin::Perfect, false);
+		
+		clog(NetNote) << "Id:" << id().abridged();
+	}
+	
+	run(boost::system::error_code());
 }
 
 void Host::doWork()
 {
-	// if there's no ioService, it means we've had quit() called - bomb out - we're not allowed in here.
+	// no ioService means we've had quit() called - bomb out - we're not allowed in here.
 	if (asserts(!!m_ioService))
 		return;
-
-	growPeers();
-	prunePeers();
-
-	if (m_hadNewNodes)
-	{
-		for (auto p: m_peers)
-			if (auto pp = p.second.lock())
-				pp->serviceNodesRequest();
-
-		m_hadNewNodes = false;
-	}
-
-	if (chrono::steady_clock::now() - m_lastPing > chrono::seconds(30))	// ping every 30s.
-	{
-		for (auto p: m_peers)
-			if (auto pp = p.second.lock())
-				if (chrono::steady_clock::now() - pp->m_lastReceived > chrono::seconds(60))
-					pp->disconnect(PingTimeout);
-		pingAll();
-	}
-
-	m_ioService->poll();
+	m_ioService->run();
 }
 
 void Host::pingAll()

libp2p/Host.h

@@ -121,16 +121,24 @@ class Host: public Worker
 	friend class HostCapabilityFace;
 	friend struct Node;
 
+	/// Static network interface methods
+public:
+	/// @returns public and private interface addresses
+	static std::vector<bi::address> getInterfaceAddresses();
+	
+	/// Try to bind and listen on _listenPort, else attempt net-allocated port.
+	static int listen4(bi::tcp::acceptor* _acceptor, unsigned short _listenPort);
+	
+	/// Return public endpoint of upnp interface. If successful o_upnpifaddr will be a private interface address and endpoint will contain public address and port.
+	static bi::tcp::endpoint traverseNAT(std::vector<bi::address> const& _ifAddresses, unsigned short _listenPort, bi::address& o_upnpifaddr);
+	
 public:
 	/// Start server, listening for connections on the given port.
 	Host(std::string const& _clientVersion, NetworkPreferences const& _n = NetworkPreferences(), bool _start = false);
 
 	/// Will block on network process events.
 	virtual ~Host();
-
-	/// Closes all peers.
-	void disconnectPeers();
-
+	
 	/// Basic peer network protocol version.
 	unsigned protocolVersion() const;
 
@@ -147,7 +155,7 @@ public:
 	void connect(bi::tcp::endpoint const& _ep);
 	void connect(std::shared_ptr<Node> const& _n);
 
-	/// @returns true iff we have the a peer of the given id.
+	/// @returns true iff we have a peer of the given id.
 	bool havePeer(NodeId _id) const;
 
 	/// Set ideal number of peers.
@@ -175,10 +183,16 @@ public:
 
 	void setNetworkPreferences(NetworkPreferences const& _p) { auto had = isStarted(); if (had) stop(); m_netPrefs = _p; if (had) start(); }
 
+	/// Start network. @threadsafe
 	void start();
+	
+	/// Stop network. @threadsafe
 	void stop();
-	bool isStarted() const { return isWorking(); }
+	
+	/// @returns if network is running.
+	bool isStarted() const { return m_run; }
 
+	/// Reset acceptor, socket, and IO service. Called by deallocator. Maybe called by implementation when ordered deallocation is required.
 	void quit();
 
 	NodeId id() const { return m_key.pub(); }
@@ -188,38 +202,48 @@ public:
 	std::shared_ptr<Node> node(NodeId _id) const { if (m_nodes.count(_id)) return m_nodes.at(_id); return std::shared_ptr<Node>(); }
 
 private:
-	void seal(bytes& _b);
-	void populateAddresses();
+	/// Populate m_peerAddresses with available public addresses.
 	void determinePublic(std::string const& _publicAddress, bool _upnp);
+	
 	void ensureAccepting();
+	
+	void seal(bytes& _b);
 
 	void growPeers();
 	void prunePeers();
 
+	/// Called by Worker. Not thread-safe; to be called only by worker.
 	virtual void startedWorking();
+	/// Called by startedWorking. Not thread-safe; to be called only be worker callback.
+	void run(boost::system::error_code const& error);			///< Run network. Called serially via ASIO deadline timer. Manages connection state transitions.
 
-	/// Conduct I/O, polling, syncing, whatever.
-	/// Ideally all time-consuming I/O is done in a background thread or otherwise asynchronously, but you get this call every 100ms or so anyway.
-	/// This won't touch alter the blockchain.
+	/// Run network
 	virtual void doWork();
 
 	std::shared_ptr<Node> noteNode(NodeId _id, bi::tcp::endpoint _a, Origin _o, bool _ready, NodeId _oldId = NodeId());
 	Nodes potentialPeers(RangeMask<unsigned> const& _known);
 
+	bool m_run = false;													///< Whether network is running.
+	std::mutex x_runtimer;													///< Start/stop mutex.
+	
 	std::string m_clientVersion;											///< Our version string.
 
-	NetworkPreferences m_netPrefs;											///< Network settings.
+	NetworkPreferences m_netPrefs;										///< Network settings.
+	
+	/// Interface addresses (private, public)
+	std::vector<bi::address> m_ifAddresses;									///< Interface addresses.
 
-	static const int NetworkStopped = -1;									///< The value meaning we're not actually listening.
-	int m_listenPort = NetworkStopped;										///< What port are we listening on?
+	int m_listenPort = -1;												///< What port are we listening on. -1 means binding failed or acceptor hasn't been initialized.
 
 	std::unique_ptr<ba::io_service> m_ioService;							///< IOService for network stuff.
-	std::unique_ptr<bi::tcp::acceptor> m_acceptor;											///< Listening acceptor.
-	std::unique_ptr<bi::tcp::socket> m_socket;												///< Listening socket.
+	std::unique_ptr<bi::tcp::acceptor> m_acceptor;							///< Listening acceptor.
+	std::unique_ptr<bi::tcp::socket> m_socket;								///< Listening socket.
+	
+	std::unique_ptr<boost::asio::deadline_timer> m_timer;					///< Timer which, when network is running, calls scheduler() every c_timerInterval ms.
+	static const unsigned c_timerInterval = 100;							///< Interval which m_timer is run when network is connected.
 
-	UPnP* m_upnp = nullptr;													///< UPnP helper.
-	bi::tcp::endpoint m_public;												///< Our public listening endpoint.
-	KeyPair m_key;															///< Our unique ID.
+	bi::tcp::endpoint m_public;											///< Our public listening endpoint.
+	KeyPair m_key;														///< Our unique ID.
 
 	bool m_hadNewNodes = false;
 
@@ -237,13 +261,11 @@ private:
 	std::vector<NodeId> m_nodesList;
 
 	RangeMask<unsigned> m_ready;											///< Indices into m_nodesList over to which nodes we are not currently connected, connecting or otherwise ignoring.
-	RangeMask<unsigned> m_private;											///< Indices into m_nodesList over to which nodes are private.
-
-	unsigned m_idealPeerCount = 5;											///< Ideal number of peers to be connected to.
+	RangeMask<unsigned> m_private;										///< Indices into m_nodesList over to which nodes are private.
 
-	// Our addresses.
-	std::vector<bi::address> m_addresses;									///< Addresses for us.
-	std::vector<bi::address> m_peerAddresses;								///< Addresses that peers (can) know us by.
+	unsigned m_idealPeerCount = 5;										///< Ideal number of peers to be connected to.
+	
+	std::set<bi::address> m_peerAddresses;									///< Public addresses that peers (can) know us by.
 
 	// Our capabilities.
 	std::map<CapDesc, std::shared_ptr<HostCapabilityFace>> m_capabilities;	///< Each of the capabilities we support.

libp2p/Session.cpp

@@ -344,7 +344,7 @@ bool Session::interpret(RLP const& _r)
 //				goto CONTINUE;	// Wierd port.
 
 			// Avoid our random other addresses that they might end up giving us.
-			for (auto i: m_server->m_addresses)
+			for (auto i: m_server->m_peerAddresses)
 				if (ep.address() == i && ep.port() == m_server->listenPort())
 					goto CONTINUE;
 

libsolidity/AST.cpp

@@ -51,6 +51,40 @@ void StructDefinition::accept(ASTVisitor& _visitor)
 	_visitor.endVisit(*this);
 }
 
+void StructDefinition::checkValidityOfMembers()
+{
+	checkMemberTypes();
+	checkRecursion();
+}
+
+void StructDefinition::checkMemberTypes()
+{
+	for (ASTPointer<VariableDeclaration> const& member: getMembers())
+		if (!member->getType()->canBeStored())
+			BOOST_THROW_EXCEPTION(member->createTypeError("Type cannot be used in struct."));
+}
+
+void StructDefinition::checkRecursion()
+{
+	set<StructDefinition const*> definitionsSeen;
+	vector<StructDefinition const*> queue = {this};
+	while (!queue.empty())
+	{
+		StructDefinition const* def = queue.back();
+		queue.pop_back();
+		if (definitionsSeen.count(def))
+			BOOST_THROW_EXCEPTION(ParserError() << errinfo_sourceLocation(def->getLocation())
+												<< errinfo_comment("Recursive struct definition."));
+		definitionsSeen.insert(def);
+		for (ASTPointer<VariableDeclaration> const& member: def->getMembers())
+			if (member->getType()->getCategory() == Type::Category::STRUCT)
+			{
+				UserDefinedTypeName const& typeName = dynamic_cast<UserDefinedTypeName&>(*member->getTypeName());
+				queue.push_back(&dynamic_cast<StructDefinition const&>(*typeName.getReferencedDeclaration()));
+			}
+	}
+}
+
 void ParameterList::accept(ASTVisitor& _visitor)
 {
 	if (_visitor.visit(*this))
@@ -258,7 +292,7 @@ void Literal::accept(ASTVisitor& _visitor)
 	_visitor.endVisit(*this);
 }
 
-TypeError ASTNode::createTypeError(string const& _description)
+TypeError ASTNode::createTypeError(string const& _description) const
 {
 	return TypeError() << errinfo_sourceLocation(getLocation()) << errinfo_comment(_description);
 }
@@ -338,8 +372,6 @@ void VariableDefinition::checkTypeRequirements()
 			m_variable->setType(m_value->getType());
 		}
 	}
-	if (m_variable->getType() && !m_variable->getType()->canLiveOutsideStorage())
-		BOOST_THROW_EXCEPTION(m_variable->createTypeError("Type is required to live outside storage."));
 }
 
 void Assignment::checkTypeRequirements()
@@ -432,24 +464,22 @@ void FunctionCall::checkTypeRequirements()
 	}
 	else
 	{
-		m_expression->requireLValue();
-
 		//@todo would be nice to create a struct type from the arguments
 		// and then ask if that is implicitly convertible to the struct represented by the
 		// function parameters
-		FunctionDefinition const& fun = dynamic_cast<FunctionType const&>(*expressionType).getFunction();
-		vector<ASTPointer<VariableDeclaration>> const& parameters = fun.getParameters();
-		if (parameters.size() != m_arguments.size())
+		FunctionType const& functionType = dynamic_cast<FunctionType const&>(*expressionType);
+		TypePointers const& parameterTypes = functionType.getParameterTypes();
+		if (parameterTypes.size() != m_arguments.size())
 			BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for function call."));
 		for (size_t i = 0; i < m_arguments.size(); ++i)
-			if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameters[i]->getType()))
+			if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
 				BOOST_THROW_EXCEPTION(createTypeError("Invalid type for argument in function call."));
 		// @todo actually the return type should be an anonymous struct,
 		// but we change it to the type of the first return value until we have structs
-		if (fun.getReturnParameters().empty())
+		if (functionType.getReturnParameterTypes().empty())
 			m_type = make_shared<VoidType>();
 		else
-			m_type = fun.getReturnParameters().front()->getType();
+			m_type = functionType.getReturnParameterTypes().front();
 	}
 }
 
@@ -461,29 +491,23 @@ bool FunctionCall::isTypeConversion() const
 void MemberAccess::checkTypeRequirements()
 {
 	m_expression->checkTypeRequirements();
-	m_expression->requireLValue();
-	if (m_expression->getType()->getCategory() != Type::Category::STRUCT)
-		BOOST_THROW_EXCEPTION(createTypeError("Member access to a non-struct (is " +
-													  m_expression->getType()->toString() + ")"));
-	StructType const& type = dynamic_cast<StructType const&>(*m_expression->getType());
-	unsigned memberIndex = type.memberNameToIndex(*m_memberName);
-	if (memberIndex >= type.getMemberCount())
+	Type const& type = *m_expression->getType();
+	m_type = type.getMemberType(*m_memberName);
+	if (!m_type)
 		BOOST_THROW_EXCEPTION(createTypeError("Member \"" + *m_memberName + "\" not found in " + type.toString()));
-	m_type = type.getMemberByIndex(memberIndex).getType();
-	m_isLvalue = true;
+	m_isLvalue = (type.getCategory() == Type::Category::STRUCT && m_type->getCategory() != Type::Category::MAPPING);
 }
 
 void IndexAccess::checkTypeRequirements()
 {
 	m_base->checkTypeRequirements();
-	m_base->requireLValue();
 	if (m_base->getType()->getCategory() != Type::Category::MAPPING)
 		BOOST_THROW_EXCEPTION(m_base->createTypeError("Indexed expression has to be a mapping (is " +
 													  m_base->getType()->toString() + ")"));
 	MappingType const& type = dynamic_cast<MappingType const&>(*m_base->getType());
 	m_index->expectType(*type.getKeyType());
 	m_type = type.getValueType();
-	m_isLvalue = true;
+	m_isLvalue = m_type->getCategory() != Type::Category::MAPPING;
 }
 
 void Identifier::checkTypeRequirements()
@@ -515,7 +539,6 @@ void Identifier::checkTypeRequirements()
 		// Calling a function (e.g. function(12), otherContract.function(34)) does not do a type
 		// conversion.
 		m_type = make_shared<FunctionType>(*functionDef);
-		m_isLvalue = true;
 		return;
 	}
 	ContractDefinition* contractDef = dynamic_cast<ContractDefinition*>(m_referencedDeclaration);
@@ -524,6 +547,12 @@ void Identifier::checkTypeRequirements()
 		m_type = make_shared<TypeType>(make_shared<ContractType>(*contractDef));
 		return;
 	}
+	MagicVariableDeclaration* magicVariable = dynamic_cast<MagicVariableDeclaration*>(m_referencedDeclaration);
+	if (magicVariable)
+	{
+		m_type = magicVariable->getType();
+		return;
+	}
 	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Declaration reference of unknown/forbidden type."));
 }
 

libsolidity/AST.h

@@ -66,7 +66,7 @@ public:
 
 	/// Creates a @ref TypeError exception and decorates it with the location of the node and
 	/// the given description
-	TypeError createTypeError(std::string const& _description);
+	TypeError createTypeError(std::string const& _description) const;
 
 	///@{
 	///@name equality operators
@@ -122,6 +122,7 @@ public:
 
 	/// Returns the functions that make up the calling interface in the intended order.
 	std::vector<FunctionDefinition const*> getInterfaceFunctions() const;
+
 private:
 	std::vector<ASTPointer<StructDefinition>> m_definedStructs;
 	std::vector<ASTPointer<VariableDeclaration>> m_stateVariables;
@@ -139,7 +140,14 @@ public:
 
 	std::vector<ASTPointer<VariableDeclaration>> const& getMembers() const { return m_members; }
 
+	/// Checks that the members do not include any recursive structs and have valid types
+	/// (e.g. no functions).
+	void checkValidityOfMembers();
+
 private:
+	void checkMemberTypes();
+	void checkRecursion();
+
 	std::vector<ASTPointer<VariableDeclaration>> m_members;
 };
 
@@ -188,6 +196,7 @@ public:
 
 	/// Checks that all parameters have allowed types and calls checkTypeRequirements on the body.
 	void checkTypeRequirements();
+
 private:
 	bool m_isPublic;
 	ASTPointer<ParameterList> m_parameters;
@@ -210,7 +219,6 @@ public:
 		Declaration(_location, _name), m_typeName(_type) {}
 	virtual void accept(ASTVisitor& _visitor) override;
 
-	bool isTypeGivenExplicitly() const { return bool(m_typeName); }
 	TypeName* getTypeName() const { return m_typeName.get(); }
 
 	/// Returns the declared or inferred type. Can be an empty pointer if no type was explicitly
@@ -224,6 +232,24 @@ private:
 	std::shared_ptr<Type const> m_type; ///< derived type, initially empty
 };
 
+/**
+ * Pseudo AST node that is used as declaration for "this", "msg", "tx", "block" and the global
+ * functions when such an identifier is encountered. Will never have a valid location in the source code.
+ */
+class MagicVariableDeclaration: public Declaration
+{
+public:
+	MagicVariableDeclaration(ASTString const& _name, std::shared_ptr<Type const> const& _type):
+		Declaration(Location(), std::make_shared<ASTString>(_name)), m_type(_type) {}
+	virtual void accept(ASTVisitor&) override { BOOST_THROW_EXCEPTION(InternalCompilerError()
+							<< errinfo_comment("MagicVariableDeclaration used inside real AST.")); }
+
+	std::shared_ptr<Type const> const& getType() const { return m_type; }
+
+private:
+	std::shared_ptr<Type const> m_type;
+};
+
 /// Types
 /// @{
 
@@ -238,6 +264,7 @@ public:
 
 	/// Retrieve the element of the type hierarchy this node refers to. Can return an empty shared
 	/// pointer until the types have been resolved using the @ref NameAndTypeResolver.
+	/// If it returns an empty shared pointer after that, this indicates that the type was not found.
 	virtual std::shared_ptr<Type> toType() const = 0;
 };
 
@@ -263,8 +290,7 @@ private:
 };
 
 /**
- * Name referring to a user-defined type (i.e. a struct).
- * @todo some changes are necessary if this is also used to refer to contract types later
+ * Name referring to a user-defined type (i.e. a struct, contract, etc.).
  */
 class UserDefinedTypeName: public TypeName
 {
@@ -275,13 +301,13 @@ public:
 	virtual std::shared_ptr<Type> toType() const override { return Type::fromUserDefinedTypeName(*this); }
 
 	ASTString const& getName() const { return *m_name; }
-	void setReferencedStruct(StructDefinition& _referencedStruct) { m_referencedStruct = &_referencedStruct; }
-	StructDefinition const* getReferencedStruct() const { return m_referencedStruct; }
+	void setReferencedDeclaration(Declaration& _referencedDeclaration) { m_referencedDeclaration = &_referencedDeclaration; }
+	Declaration const* getReferencedDeclaration() const { return m_referencedDeclaration; }
 
 private:
 	ASTPointer<ASTString> m_name;
 
-	StructDefinition* m_referencedStruct;
+	Declaration* m_referencedDeclaration;
 };
 
 /**

libsolidity/ASTForward.h

@@ -40,6 +40,7 @@ class StructDefinition;
 class ParameterList;
 class FunctionDefinition;
 class VariableDeclaration;
+class MagicVariableDeclaration;
 class TypeName;
 class ElementaryTypeName;
 class UserDefinedTypeName;

libsolidity/Compiler.cpp

@@ -32,17 +32,13 @@ using namespace std;
 namespace dev {
 namespace solidity {
 
-bytes Compiler::compile(ContractDefinition& _contract, bool _optimize)
-{
-	Compiler compiler;
-	compiler.compileContract(_contract);
-	return compiler.m_context.getAssembledBytecode(_optimize);
-}
-
-void Compiler::compileContract(ContractDefinition& _contract)
+void Compiler::compileContract(ContractDefinition& _contract, vector<MagicVariableDeclaration const*> const& _magicGlobals)
 {
 	m_context = CompilerContext(); // clear it just in case
 
+	for (MagicVariableDeclaration const* variable: _magicGlobals)
+		m_context.addMagicGlobal(*variable);
+
 	for (ASTPointer<FunctionDefinition> const& function: _contract.getDefinedFunctions())
 		if (function->getName() != _contract.getName()) // don't add the constructor here
 			m_context.addFunction(*function);
@@ -328,7 +324,8 @@ bool Compiler::visit(ExpressionStatement& _expressionStatement)
 {
 	Expression& expression = _expressionStatement.getExpression();
 	ExpressionCompiler::compileExpression(m_context, expression);
-	if (expression.getType()->getCategory() != Type::Category::VOID)
+	Type::Category category = expression.getType()->getCategory();
+	for (unsigned i = 0; i < expression.getType()->getSizeOnStack(); ++i)
 		m_context << eth::Instruction::POP;
 	return false;
 }

libsolidity/Compiler.h

@@ -32,13 +32,10 @@ class Compiler: private ASTVisitor
 public:
 	Compiler(): m_returnTag(m_context.newTag()) {}
 
-	void compileContract(ContractDefinition& _contract);
+	void compileContract(ContractDefinition& _contract, std::vector<MagicVariableDeclaration const*> const& _magicGlobals);
 	bytes getAssembledBytecode(bool _optimize = false) { return m_context.getAssembledBytecode(_optimize); }
 	void streamAssembly(std::ostream& _stream) const { m_context.streamAssembly(_stream); }
 
-	/// Compile the given contract and return the EVM bytecode.
-	static bytes compile(ContractDefinition& _contract, bool _optimize);
-
 private:
 	/// Creates a new compiler context / assembly, packs the current code into the data part and
 	/// adds the constructor code.

libsolidity/CompilerContext.cpp

@@ -30,6 +30,11 @@ using namespace std;
 namespace dev {
 namespace solidity {
 
+void CompilerContext::addMagicGlobal(MagicVariableDeclaration const& _declaration)
+{
+	m_magicGlobals.insert(&_declaration);
+}
+
 void CompilerContext::addStateVariable(VariableDeclaration const& _declaration)
 {
 	m_stateVariables[&_declaration] = m_stateVariablesSize;

libsolidity/CompilerContext.h

@@ -40,6 +40,7 @@ class CompilerContext
 public:
 	CompilerContext(): m_stateVariablesSize(0) {}
 
+	void addMagicGlobal(MagicVariableDeclaration const& _declaration);
 	void addStateVariable(VariableDeclaration const& _declaration);
 	void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); }
 	void initializeLocalVariables(unsigned _numVariables);
@@ -48,6 +49,7 @@ public:
 
 	void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); }
 
+	bool isMagicGlobal(Declaration const* _declaration) const { return m_magicGlobals.count(_declaration); }
 	bool isFunctionDefinition(Declaration const* _declaration) const { return m_functionEntryLabels.count(_declaration); }
 	bool isLocalVariable(Declaration const* _declaration) const;
 	bool isStateVariable(Declaration const* _declaration) const { return m_stateVariables.count(_declaration); }
@@ -90,6 +92,8 @@ public:
 private:
 	eth::Assembly m_asm;
 
+	/// Magic global variables like msg, tx or this, distinguished by type.
+	std::set<Declaration const*> m_magicGlobals;
 	/// Size of the state variables, offset of next variable to be added.
 	u256 m_stateVariablesSize;
 	/// Storage offsets of state variables

libsolidity/CompilerStack.cpp

@@ -23,6 +23,7 @@
 #include <libsolidity/AST.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Parser.h>
+#include <libsolidity/GlobalContext.h>
 #include <libsolidity/NameAndTypeResolver.h>
 #include <libsolidity/Compiler.h>
 #include <libsolidity/CompilerStack.h>
@@ -45,7 +46,9 @@ void CompilerStack::parse()
 	if (!m_scanner)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Source not available."));
 	m_contractASTNode = Parser().parse(m_scanner);
-	NameAndTypeResolver().resolveNamesAndTypes(*m_contractASTNode);
+	m_globalContext = make_shared<GlobalContext>();
+	m_globalContext->setCurrentContract(*m_contractASTNode);
+	NameAndTypeResolver(m_globalContext->getDeclarations()).resolveNamesAndTypes(*m_contractASTNode);
 	m_parseSuccessful = true;
 }
 
@@ -61,7 +64,7 @@ bytes const& CompilerStack::compile(bool _optimize)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
 	m_bytecode.clear();
 	m_compiler = make_shared<Compiler>();
-	m_compiler->compileContract(*m_contractASTNode);
+	m_compiler->compileContract(*m_contractASTNode, m_globalContext->getMagicVariables());
 	return m_bytecode = m_compiler->getAssembledBytecode(_optimize);
 }
 

libsolidity/CompilerStack.h

@@ -30,9 +30,11 @@
 namespace dev {
 namespace solidity {
 
-class Scanner; // forward
-class ContractDefinition; // forward
-class Compiler; // forward
+// forward declarations
+class Scanner;
+class ContractDefinition;
+class Compiler;
+class GlobalContext;
 
 /**
  * Easy to use and self-contained Solidity compiler with as few header dependencies as possible.
@@ -71,6 +73,7 @@ public:
 
 private:
 	std::shared_ptr<Scanner> m_scanner;
+	std::shared_ptr<GlobalContext> m_globalContext;
 	std::shared_ptr<ContractDefinition> m_contractASTNode;
 	bool m_parseSuccessful;
 	std::string m_interface;

libsolidity/ExpressionCompiler.cpp

@@ -160,67 +160,181 @@ bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation)
 
 bool ExpressionCompiler::visit(FunctionCall& _functionCall)
 {
+	using Location = FunctionType::Location;
 	if (_functionCall.isTypeConversion())
 	{
-		//@todo we only have integers and bools for now which cannot be explicitly converted
+		//@todo struct construction
 		if (asserts(_functionCall.getArguments().size() == 1))
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
 		Expression& firstArgument = *_functionCall.getArguments().front();
 		firstArgument.accept(*this);
-		appendTypeConversion(*firstArgument.getType(), *_functionCall.getType());
+		if (firstArgument.getType()->getCategory() == Type::Category::CONTRACT &&
+				_functionCall.getType()->getCategory() == Type::Category::INTEGER)
+		{
+			// explicit type conversion contract -> address, nothing to do.
+		}
+		else
+		{
+			appendTypeConversion(*firstArgument.getType(), *_functionCall.getType());
+		}
 	}
 	else
 	{
-		// Calling convention: Caller pushes return address and arguments
-		// Callee removes them and pushes return values
-		FunctionDefinition const& function = dynamic_cast<FunctionType const&>(*_functionCall.getExpression().getType()).getFunction();
-
-		eth::AssemblyItem returnLabel = m_context.pushNewTag();
+		FunctionType const& function = dynamic_cast<FunctionType const&>(*_functionCall.getExpression().getType());
 		std::vector<ASTPointer<Expression>> const& arguments = _functionCall.getArguments();
-		if (asserts(arguments.size() == function.getParameters().size()))
+		if (asserts(arguments.size() == function.getParameterTypes().size()))
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
-		for (unsigned i = 0; i < arguments.size(); ++i)
+
+		if (function.getLocation() == Location::INTERNAL)
 		{
-			arguments[i]->accept(*this);
-			appendTypeConversion(*arguments[i]->getType(), *function.getParameters()[i]->getType());
+			// Calling convention: Caller pushes return address and arguments
+			// Callee removes them and pushes return values
+
+			eth::AssemblyItem returnLabel = m_context.pushNewTag();
+			for (unsigned i = 0; i < arguments.size(); ++i)
+			{
+				arguments[i]->accept(*this);
+				appendTypeConversion(*arguments[i]->getType(), *function.getParameterTypes()[i]);
+			}
+			_functionCall.getExpression().accept(*this);
+
+			m_context.appendJump();
+			m_context << returnLabel;
+
+			// callee adds return parameters, but removes arguments and return label
+			m_context.adjustStackOffset(function.getReturnParameterTypes().size() - arguments.size() - 1);
+
+			// @todo for now, the return value of a function is its first return value, so remove
+			// all others
+			for (unsigned i = 1; i < function.getReturnParameterTypes().size(); ++i)
+				m_context << eth::Instruction::POP;
+		}
+		else if (function.getLocation() == Location::EXTERNAL)
+			BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("External function calls not implemented yet."));
+		else
+		{
+			switch (function.getLocation())
+			{
+			case Location::SEND:
+				m_context << u256(0) << u256(0) << u256(0) << u256(0);
+				arguments.front()->accept(*this);
+				//@todo might not be necessary
+				appendTypeConversion(*arguments.front()->getType(), *function.getParameterTypes().front(), true);
+				_functionCall.getExpression().accept(*this);
+				m_context << u256(25) << eth::Instruction::GAS << eth::Instruction::SUB
+						  << eth::Instruction::CALL
+						  << eth::Instruction::POP;
+				break;
+			case Location::SUICIDE:
+				arguments.front()->accept(*this);
+				//@todo might not be necessary
+				appendTypeConversion(*arguments.front()->getType(), *function.getParameterTypes().front(), true);
+				m_context << eth::Instruction::SUICIDE;
+				break;
+			case Location::SHA3:
+				arguments.front()->accept(*this);
+				appendTypeConversion(*arguments.front()->getType(), *function.getParameterTypes().front(), true);
+				// @todo move this once we actually use memory
+				m_context << u256(0) << eth::Instruction::MSTORE << u256(32) << u256(0) << eth::Instruction::SHA3;
+				break;
+			case Location::ECRECOVER:
+			case Location::SHA256:
+			case Location::RIPEMD160:
+			{
+				static const map<Location, u256> contractAddresses{{Location::ECRECOVER, 1},
+																   {Location::SHA256, 2},
+																   {Location::RIPEMD160, 3}};
+				u256 contractAddress = contractAddresses.find(function.getLocation())->second;
+				// @todo later, combine this code with external function call
+				for (unsigned i = 0; i < arguments.size(); ++i)
+				{
+					arguments[i]->accept(*this);
+					appendTypeConversion(*arguments[i]->getType(), *function.getParameterTypes()[i], true);
+					// @todo move this once we actually use memory
+					m_context << u256(i * 32) << eth::Instruction::MSTORE;
+				}
+				m_context << u256(32) << u256(0) << u256(arguments.size() * 32) << u256(0) << u256(0)
+						  << contractAddress << u256(500) //@todo determine actual gas requirement
+						  << eth::Instruction::CALL
+						  << eth::Instruction::POP
+						  << u256(0) << eth::Instruction::MLOAD;
+				break;
+			}
+			default:
+				BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Function not yet implemented."));
+			}
 		}
-		_functionCall.getExpression().accept(*this);
-		if (asserts(m_currentLValue.isInCode()))
-			BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Code reference expected."));
-		m_currentLValue.reset();
-
-		m_context.appendJump();
-		m_context << returnLabel;
-
-		// callee adds return parameters, but removes arguments and return label
-		m_context.adjustStackOffset(function.getReturnParameters().size() - arguments.size() - 1);
-
-		// @todo for now, the return value of a function is its first return value, so remove
-		// all others
-		for (unsigned i = 1; i < function.getReturnParameters().size(); ++i)
-			m_context << eth::Instruction::POP;
 	}
 	return false;
 }
 
 void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
 {
-	if (asserts(m_currentLValue.isInStorage()))
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Member access to a non-storage value."));
-	StructType const& type = dynamic_cast<StructType const&>(*_memberAccess.getExpression().getType());
-	unsigned memberIndex = type.memberNameToIndex(_memberAccess.getMemberName());
-	if (asserts(memberIndex <= type.getMemberCount()))
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Member not found in struct during compilation."));
-	m_context << type.getStorageOffsetOfMember(memberIndex) << eth::Instruction::ADD;
-	m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess);
+	ASTString const& member = _memberAccess.getMemberName();
+	switch (_memberAccess.getExpression().getType()->getCategory())
+	{
+	case Type::Category::INTEGER:
+		if (member == "balance")
+		{
+			appendTypeConversion(*_memberAccess.getExpression().getType(),
+								 IntegerType(0, IntegerType::Modifier::ADDRESS), true);
+			m_context << eth::Instruction::BALANCE;
+		}
+		else if (member == "send")
+		{
+			appendTypeConversion(*_memberAccess.getExpression().getType(),
+								 IntegerType(0, IntegerType::Modifier::ADDRESS), true);
+		}
+		else
+			BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid member access to integer."));
+		break;
+	case Type::Category::CONTRACT:
+		// call function
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Contract variables not yet implemented."));
+		break;
+	case Type::Category::MAGIC:
+		// we can ignore the kind of magic and only look at the name of the member
+		if (member == "coinbase")
+			m_context << eth::Instruction::COINBASE;
+		else if (member == "timestamp")
+			m_context << eth::Instruction::TIMESTAMP;
+		else if (member == "prevhash")
+			m_context << eth::Instruction::PREVHASH;
+		else if (member == "difficulty")
+			m_context << eth::Instruction::DIFFICULTY;
+		else if (member == "number")
+			m_context << eth::Instruction::NUMBER;
+		else if (member == "gaslimit")
+			m_context << eth::Instruction::GASLIMIT;
+		else if (member == "sender")
+			m_context << eth::Instruction::CALLER;
+		else if (member == "value")
+			m_context << eth::Instruction::CALLVALUE;
+		else if (member == "origin")
+			m_context << eth::Instruction::ORIGIN;
+		else if (member == "gas")
+			m_context << eth::Instruction::GAS;
+		else if (member == "gasprice")
+			m_context << eth::Instruction::GASPRICE;
+		else
+			BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member."));
+		break;
+	case Type::Category::STRUCT:
+	{
+		StructType const& type = dynamic_cast<StructType const&>(*_memberAccess.getExpression().getType());
+		m_context << type.getStorageOffsetOfMember(member) << eth::Instruction::ADD;
+		m_currentLValue = LValue(m_context, LValue::STORAGE);
+		m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess);
+		break;
+	}
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Member access to unknown type."));
+	}
 }
 
 bool ExpressionCompiler::visit(IndexAccess& _indexAccess)
 {
-	m_currentLValue.reset();
 	_indexAccess.getBaseExpression().accept(*this);
-	if (asserts(m_currentLValue.isInStorage()))
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Index access to a non-storage value."));
 	_indexAccess.getIndexExpression().accept(*this);
 	appendTypeConversion(*_indexAccess.getIndexExpression().getType(),
 						 *dynamic_cast<MappingType const&>(*_indexAccess.getBaseExpression().getType()).getKeyType(),
@@ -237,8 +351,25 @@ bool ExpressionCompiler::visit(IndexAccess& _indexAccess)
 
 void ExpressionCompiler::endVisit(Identifier& _identifier)
 {
-	m_currentLValue.fromDeclaration(_identifier, *_identifier.getReferencedDeclaration());
-	m_currentLValue.retrieveValueIfLValueNotRequested(_identifier);
+	Declaration* declaration = _identifier.getReferencedDeclaration();
+	if (MagicVariableDeclaration* magicVar = dynamic_cast<MagicVariableDeclaration*>(declaration))
+	{
+		if (magicVar->getType()->getCategory() == Type::Category::CONTRACT) // must be "this"
+			m_context << eth::Instruction::ADDRESS;
+		return;
+	}
+	if (FunctionDefinition* functionDef = dynamic_cast<FunctionDefinition*>(declaration))
+	{
+		m_context << m_context.getFunctionEntryLabel(*functionDef).pushTag();
+		return;
+	}
+	if (VariableDeclaration* varDef = dynamic_cast<VariableDeclaration*>(declaration))
+	{
+		m_currentLValue.fromIdentifier(_identifier, *_identifier.getReferencedDeclaration());
+		m_currentLValue.retrieveValueIfLValueNotRequested(_identifier);
+		return;
+	}
+	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Identifier type not expected in expression context."));
 }
 
 void ExpressionCompiler::endVisit(Literal& _literal)
@@ -405,9 +536,6 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 {
 	switch (m_type)
 	{
-	case CODE:
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Tried to retrieve value of a function."));
-		break;
 	case STACK:
 	{
 		unsigned stackPos = m_context->baseToCurrentStackOffset(unsigned(m_baseStackOffset));
@@ -418,11 +546,15 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 		break;
 	}
 	case STORAGE:
+		if (!_expression.getType()->isValueType())
+			break; // no distinction between value and reference for non-value types
 		if (!_remove)
 			*m_context << eth::Instruction::DUP1;
 		*m_context << eth::Instruction::SLOAD;
 		break;
 	case MEMORY:
+		if (!_expression.getType()->isValueType())
+			break; // no distinction between value and reference for non-value types
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_expression.getLocation())
 													  << errinfo_comment("Location type not yet implemented."));
 		break;
@@ -450,15 +582,15 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, bool
 		break;
 	}
 	case LValue::STORAGE:
+		if (!_expression.getType()->isValueType())
+			break; // no distinction between value and reference for non-value types
 		if (!_move)
 			*m_context << eth::Instruction::DUP2 << eth::Instruction::SWAP1;
 		*m_context << eth::Instruction::SSTORE;
 		break;
-	case LValue::CODE:
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_expression.getLocation())
-													  << errinfo_comment("Location type does not support assignment."));
-		break;
 	case LValue::MEMORY:
+		if (!_expression.getType()->isValueType())
+			break; // no distinction between value and reference for non-value types
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_expression.getLocation())
 													  << errinfo_comment("Location type not yet implemented."));
 		break;
@@ -469,7 +601,7 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, bool
 	}
 }
 
-void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(const Expression& _expression)
+void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(Expression const& _expression)
 {
 	if (!_expression.lvalueRequested())
 	{
@@ -478,7 +610,7 @@ void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(const Express
 	}
 }
 
-void ExpressionCompiler::LValue::fromDeclaration( Expression const& _expression, Declaration const& _declaration)
+void ExpressionCompiler::LValue::fromIdentifier(Identifier const& _identifier, Declaration const& _declaration)
 {
 	if (m_context->isLocalVariable(&_declaration))
 	{
@@ -490,13 +622,8 @@ void ExpressionCompiler::LValue::fromDeclaration( Expression const& _expression,
 		m_type = STORAGE;
 		*m_context << m_context->getStorageLocationOfVariable(_declaration);
 	}
-	else if (m_context->isFunctionDefinition(&_declaration))
-	{
-		m_type = CODE;
-		*m_context << m_context->getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(_declaration)).pushTag();
-	}
 	else
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_expression.getLocation())
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_identifier.getLocation())
 													  << errinfo_comment("Identifier type not supported or identifier not found."));
 }
 

libsolidity/ExpressionCompiler.h

@@ -83,31 +83,30 @@ private:
 
 	/**
 	 * Helper class to store and retrieve lvalues to and from various locations.
-	 * All types except STACK store a reference in a slot on the stack, STACK just stores the
-	 * base stack offset of the variable in @a m_baseStackOffset.
+	 * All types except STACK store a reference in a slot on the stack, STACK just
+	 * stores the base stack offset of the variable in @a m_baseStackOffset.
 	 */
 	class LValue
 	{
 	public:
-		enum LValueType { NONE, CODE, STACK, MEMORY, STORAGE };
+		enum LValueType { NONE, STACK, MEMORY, STORAGE };
 
 		explicit LValue(CompilerContext& _compilerContext): m_context(&_compilerContext) { reset(); }
 		LValue(CompilerContext& _compilerContext, LValueType _type, unsigned _baseStackOffset = 0):
 			m_context(&_compilerContext), m_type(_type), m_baseStackOffset(_baseStackOffset) {}
 
 		/// Set type according to the declaration and retrieve the reference.
-		/// @a _expression is the current expression, used for error reporting.
-		void fromDeclaration(Expression const& _expression, Declaration const& _declaration);
+		/// @a _expression is the current expression
+		void fromIdentifier(Identifier const& _identifier, Declaration const& _declaration);
 		void reset() { m_type = NONE; m_baseStackOffset = 0; }
 
 		bool isValid() const { return m_type != NONE; }
-		bool isInCode() const { return m_type == CODE; }
 		bool isInOnStack() const { return m_type == STACK; }
 		bool isInMemory() const { return m_type == MEMORY; }
 		bool isInStorage() const { return m_type == STORAGE; }
 
 		/// @returns true if this lvalue reference type occupies a slot on the stack.
-		bool storesReferenceOnStack() const { return m_type == STORAGE || m_type == MEMORY || m_type == CODE; }
+		bool storesReferenceOnStack() const { return m_type == STORAGE || m_type == MEMORY; }
 
 		/// Copies the value of the current lvalue to the top of the stack and, if @a _remove is true,
 		/// also removes the reference from the stack (note that is does not reset the type to @a NONE).
@@ -133,6 +132,10 @@ private:
 
 	CompilerContext& m_context;
 	LValue m_currentLValue;
+	/// If a "virtual" function (i.e. a bulit-in function without jump tag) is encountered, the
+	/// actual function is stored here. @todo prevent assignment or store it with assignment
+	enum class SpecialFunction { NONE, SEND, SHA3, SUICIDE, ECRECOVER, SHA256, RIPEMD160 };
+	SpecialFunction m_currentSpecialFunction;
 };
 
 

libsolidity/GlobalContext.cpp

@@ -0,0 +1,101 @@
+/*
+	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/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Container of the (implicit and explicit) global objects.
+ */
+
+#include <memory>
+#include <libsolidity/GlobalContext.h>
+#include <libsolidity/AST.h>
+#include <libsolidity/Types.h>
+
+using namespace std;
+
+namespace dev
+{
+namespace solidity
+{
+
+GlobalContext::GlobalContext():
+	m_magicVariables{make_shared<MagicVariableDeclaration>("block", make_shared<MagicType>(MagicType::Kind::BLOCK)),
+					 make_shared<MagicVariableDeclaration>("msg", make_shared<MagicType>(MagicType::Kind::MSG)),
+					 make_shared<MagicVariableDeclaration>("tx", make_shared<MagicType>(MagicType::Kind::TX)),
+					 make_shared<MagicVariableDeclaration>("suicide",
+							make_shared<FunctionType>(TypePointers({std::make_shared<IntegerType>(0,
+																	IntegerType::Modifier::ADDRESS)}),
+													  TypePointers(),
+													  FunctionType::Location::SUICIDE)),
+					 make_shared<MagicVariableDeclaration>("sha3",
+							make_shared<FunctionType>(TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  FunctionType::Location::SHA3)),
+					 make_shared<MagicVariableDeclaration>("sha256",
+							make_shared<FunctionType>(TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  FunctionType::Location::SHA256)),
+					 make_shared<MagicVariableDeclaration>("ecrecover",
+							make_shared<FunctionType>(TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH),
+																	std::make_shared<IntegerType>(8, IntegerType::Modifier::HASH),
+																	std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH),
+																	std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  TypePointers({std::make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)}),
+													  FunctionType::Location::ECRECOVER)),
+					 make_shared<MagicVariableDeclaration>("ripemd160",
+							make_shared<FunctionType>(TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  TypePointers({std::make_shared<IntegerType>(256, IntegerType::Modifier::HASH)}),
+													  FunctionType::Location::RIPEMD160))}
+{
+}
+
+void GlobalContext::setCurrentContract(ContractDefinition const& _contract)
+{
+	m_currentContract = &_contract;
+}
+
+vector<Declaration*> GlobalContext::getDeclarations() const
+{
+	vector<Declaration*> declarations;
+	declarations.reserve(m_magicVariables.size() + 1);
+	for (ASTPointer<Declaration> const& variable: m_magicVariables)
+		declarations.push_back(variable.get());
+	declarations.push_back(getCurrentThis());
+	return declarations;
+}
+
+MagicVariableDeclaration*GlobalContext::getCurrentThis() const
+{
+	if (!m_thisPointer[m_currentContract])
+		m_thisPointer[m_currentContract] = make_shared<MagicVariableDeclaration>(
+													"this", make_shared<ContractType>(*m_currentContract));
+	return m_thisPointer[m_currentContract].get();
+
+}
+
+vector<MagicVariableDeclaration const*> GlobalContext::getMagicVariables() const
+{
+	vector<MagicVariableDeclaration const*> declarations;
+	declarations.reserve(m_magicVariables.size() + 1);
+	for (ASTPointer<MagicVariableDeclaration const> const& variable: m_magicVariables)
+		declarations.push_back(variable.get());
+	declarations.push_back(getCurrentThis());
+	return declarations;
+}
+
+}
+}

libsolidity/GlobalContext.h

@@ -0,0 +1,62 @@
+/*
+	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/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Container of the (implicit and explicit) global objects.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <boost/noncopyable.hpp>
+#include <libsolidity/ASTForward.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+class Type; // forward
+
+/**
+ * Container for all global objects which look like AST nodes, but are not part of the AST
+ * that is currently being compiled.
+ * @note must not be destroyed or moved during compilation as its objects can be referenced from
+ * other objects.
+ */
+class GlobalContext: private boost::noncopyable
+{
+public:
+	GlobalContext();
+	void setCurrentContract(ContractDefinition const& _contract);
+
+	std::vector<MagicVariableDeclaration const*> getMagicVariables() const;
+	std::vector<Declaration*> getDeclarations() const;
+
+private:
+	MagicVariableDeclaration* getCurrentThis() const;
+	std::vector<std::shared_ptr<MagicVariableDeclaration>> m_magicVariables;
+	ContractDefinition const* m_currentContract;
+	std::map<ContractDefinition const*, std::shared_ptr<MagicVariableDeclaration>> mutable m_thisPointer;
+};
+
+}
+}

libsolidity/NameAndTypeResolver.cpp

@@ -32,15 +32,20 @@ namespace solidity
 {
 
 
+NameAndTypeResolver::NameAndTypeResolver(std::vector<Declaration*> const& _globals)
+{
+	for (Declaration* declaration: _globals)
+		m_scopes[nullptr].registerDeclaration(*declaration);
+}
+
 void NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract)
 {
-	reset();
 	DeclarationRegistrationHelper registrar(m_scopes, _contract);
 	m_currentScope = &m_scopes[&_contract];
 	for (ASTPointer<StructDefinition> const& structDef: _contract.getDefinedStructs())
 		ReferencesResolver resolver(*structDef, *this, nullptr);
 	for (ASTPointer<StructDefinition> const& structDef: _contract.getDefinedStructs())
-		checkForRecursion(*structDef);
+		structDef->checkValidityOfMembers();
 	for (ASTPointer<VariableDeclaration> const& variable: _contract.getStateVariables())
 		ReferencesResolver resolver(*variable, *this, nullptr);
 	for (ASTPointer<FunctionDefinition> const& function: _contract.getDefinedFunctions())
@@ -73,30 +78,6 @@ Declaration* NameAndTypeResolver::getNameFromCurrentScope(ASTString const& _name
 	return m_currentScope->resolveName(_name, _recursive);
 }
 
-void NameAndTypeResolver::checkForRecursion(StructDefinition const& _struct)
-{
-	set<StructDefinition const*> definitionsSeen;
-	vector<StructDefinition const*> queue = {&_struct};
-	while (!queue.empty())
-	{
-		StructDefinition const* def = queue.back();
-		queue.pop_back();
-		if (definitionsSeen.count(def))
-			BOOST_THROW_EXCEPTION(ParserError() << errinfo_sourceLocation(def->getLocation())
-												<< errinfo_comment("Recursive struct definition."));
-		definitionsSeen.insert(def);
-		for (ASTPointer<VariableDeclaration> const& member: def->getMembers())
-			if (member->getType()->getCategory() == Type::Category::STRUCT)
-				queue.push_back(dynamic_cast<UserDefinedTypeName&>(*member->getTypeName()).getReferencedStruct());
-	}
-}
-
-void NameAndTypeResolver::reset()
-{
-	m_scopes.clear();
-	m_currentScope = nullptr;
-}
-
 DeclarationRegistrationHelper::DeclarationRegistrationHelper(map<ASTNode const*, Scope>& _scopes,
 															 ASTNode& _astRoot):
 	m_scopes(_scopes), m_currentScope(&m_scopes[nullptr])
@@ -195,7 +176,11 @@ void ReferencesResolver::endVisit(VariableDeclaration& _variable)
 	// endVisit because the internal type needs resolving if it is a user defined type
 	// or mapping
 	if (_variable.getTypeName())
+	{
 		_variable.setType(_variable.getTypeName()->toType());
+		if (!_variable.getType())
+			BOOST_THROW_EXCEPTION(_variable.getTypeName()->createTypeError("Invalid type name"));
+	}
 	else if (!m_allowLazyTypes)
 		BOOST_THROW_EXCEPTION(_variable.createTypeError("Explicit type needed."));
 	// otherwise we have a "var"-declaration whose type is resolved by the first assignment
@@ -221,11 +206,7 @@ bool ReferencesResolver::visit(UserDefinedTypeName& _typeName)
 	if (!declaration)
 		BOOST_THROW_EXCEPTION(DeclarationError() << errinfo_sourceLocation(_typeName.getLocation())
 												 << errinfo_comment("Undeclared identifier."));
-	StructDefinition* referencedStruct = dynamic_cast<StructDefinition*>(declaration);
-	//@todo later, contracts are also valid types
-	if (!referencedStruct)
-		BOOST_THROW_EXCEPTION(_typeName.createTypeError("Identifier does not name a type name."));
-	_typeName.setReferencedStruct(*referencedStruct);
+	_typeName.setReferencedDeclaration(*declaration);
 	return false;
 }
 

libsolidity/NameAndTypeResolver.h

@@ -41,8 +41,7 @@ namespace solidity
 class NameAndTypeResolver: private boost::noncopyable
 {
 public:
-	NameAndTypeResolver() {}
-
+	explicit NameAndTypeResolver(std::vector<Declaration*> const& _globals);
 	void resolveNamesAndTypes(ContractDefinition& _contract);
 
 	/// Resolves the given @a _name inside the scope @a _scope. If @a _scope is omitted,

libsolidity/Scanner.cpp

@@ -63,34 +63,34 @@ namespace solidity
 
 namespace
 {
-bool IsDecimalDigit(char c)
+bool isDecimalDigit(char c)
 {
 	return '0' <= c && c <= '9';
 }
-bool IsHexDigit(char c)
+bool isHexDigit(char c)
 {
-	return IsDecimalDigit(c)
+	return isDecimalDigit(c)
 		   || ('a' <= c && c <= 'f')
 		   || ('A' <= c && c <= 'F');
 }
-bool IsLineTerminator(char c)
+bool isLineTerminator(char c)
 {
 	return c == '\n';
 }
-bool IsWhiteSpace(char c)
+bool isWhiteSpace(char c)
 {
 	return c == ' ' || c == '\n' || c == '\t';
 }
-bool IsIdentifierStart(char c)
+bool isIdentifierStart(char c)
 {
 	return c == '_' || c == '$' || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
 }
-bool IsIdentifierPart(char c)
+bool isIdentifierPart(char c)
 {
-	return IsIdentifierStart(c) || IsDecimalDigit(c);
+	return isIdentifierStart(c) || isDecimalDigit(c);
 }
 
-int HexValue(char c)
+int hexValue(char c)
 {
 	if (c >= '0' && c <= '9')
 		return c - '0';
@@ -104,11 +104,16 @@ int HexValue(char c)
 
 void Scanner::reset(CharStream const& _source)
 {
+	bool foundDocComment;
 	m_source = _source;
 	m_char = m_source.get();
 	skipWhitespace();
-	scanToken();
-	next();
+	foundDocComment = scanToken();
+
+	// special version of Scanner:next() taking the previous scanToken() result into account
+	m_currentToken = m_nextToken;
+	if (scanToken() || foundDocComment)
+		m_skippedComment = m_nextSkippedComment;
 }
 
 
@@ -117,7 +122,7 @@ bool Scanner::scanHexByte(char& o_scannedByte)
 	char x = 0;
 	for (int i = 0; i < 2; i++)
 	{
-		int d = HexValue(m_char);
+		int d = hexValue(m_char);
 		if (d < 0)
 		{
 			rollback(i);
@@ -136,9 +141,10 @@ BOOST_STATIC_ASSERT(Token::NUM_TOKENS <= 0x100);
 
 Token::Value Scanner::next()
 {
-	m_current_token = m_next_token;
-	scanToken();
-	return m_current_token.token;
+	m_currentToken = m_nextToken;
+	if (scanToken())
+		m_skippedComment = m_nextSkippedComment;
+	return m_currentToken.token;
 }
 
 Token::Value Scanner::selectToken(char _next, Token::Value _then, Token::Value _else)
@@ -153,11 +159,11 @@ Token::Value Scanner::selectToken(char _next, Token::Value _then, Token::Value _
 
 bool Scanner::skipWhitespace()
 {
-	int const start_position = getSourcePos();
-	while (IsWhiteSpace(m_char))
+	int const startPosition = getSourcePos();
+	while (isWhiteSpace(m_char))
 		advance();
 	// Return whether or not we skipped any characters.
-	return getSourcePos() != start_position;
+	return getSourcePos() != startPosition;
 }
 
 
@@ -167,10 +173,24 @@ Token::Value Scanner::skipSingleLineComment()
 	// to be part of the single-line comment; it is recognized
 	// separately by the lexical grammar and becomes part of the
 	// stream of input elements for the syntactic grammar
-	while (advance() && !IsLineTerminator(m_char)) { };
+	while (advance() && !isLineTerminator(m_char)) { };
 	return Token::WHITESPACE;
 }
 
+/// For the moment this function simply consumes a single line triple slash doc comment
+Token::Value Scanner::scanDocumentationComment()
+{
+	LiteralScope literal(this);
+	advance(); //consume the last '/'
+	while (!isSourcePastEndOfInput() && !isLineTerminator(m_char))
+	{
+		addCommentLiteralChar(m_char);
+		advance();
+	}
+	literal.complete();
+	return Token::COMMENT_LITERAL;
+}
+
 Token::Value Scanner::skipMultiLineComment()
 {
 	if (asserts(m_char == '*'))
@@ -194,14 +214,15 @@ Token::Value Scanner::skipMultiLineComment()
 	return Token::ILLEGAL;
 }
 
-void Scanner::scanToken()
+bool Scanner::scanToken()
 {
-	m_next_token.literal.clear();
+	bool foundDocComment = false;
+	m_nextToken.literal.clear();
 	Token::Value token;
 	do
 	{
 		// Remember the position of the next token
-		m_next_token.location.start = getSourcePos();
+		m_nextToken.location.start = getSourcePos();
 		switch (m_char)
 		{
 		case '\n': // fall-through
@@ -280,7 +301,7 @@ void Scanner::scanToken()
 			}
 			else if (m_char == '=')
 				token = selectToken(Token::ASSIGN_SUB);
-			else if (m_char == '.' || IsDecimalDigit(m_char))
+			else if (m_char == '.' || isDecimalDigit(m_char))
 				token = scanNumber('-');
 			else
 				token = Token::SUB;
@@ -297,7 +318,22 @@ void Scanner::scanToken()
 			// /  // /* /=
 			advance();
 			if (m_char == '/')
-				token = skipSingleLineComment();
+			{
+				if (!advance()) /* double slash comment directly before EOS */
+					token = Token::WHITESPACE;
+				else if (m_char == '/')
+				{
+					Token::Value comment;
+					m_nextSkippedComment.location.start = getSourcePos();
+					comment = scanDocumentationComment();
+					m_nextSkippedComment.location.end = getSourcePos();
+					m_nextSkippedComment.token = comment;
+					token = Token::WHITESPACE;
+					foundDocComment = true;
+				}
+				else
+					token = skipSingleLineComment();
+			}
 			else if (m_char == '*')
 				token = skipMultiLineComment();
 			else if (m_char == '=')
@@ -332,7 +368,7 @@ void Scanner::scanToken()
 		case '.':
 			// . Number
 			advance();
-			if (IsDecimalDigit(m_char))
+			if (isDecimalDigit(m_char))
 				token = scanNumber('.');
 			else
 				token = Token::PERIOD;
@@ -371,9 +407,9 @@ void Scanner::scanToken()
 			token = selectToken(Token::BIT_NOT);
 			break;
 		default:
-			if (IsIdentifierStart(m_char))
+			if (isIdentifierStart(m_char))
 				token = scanIdentifierOrKeyword();
-			else if (IsDecimalDigit(m_char))
+			else if (isDecimalDigit(m_char))
 				token = scanNumber();
 			else if (skipWhitespace())
 				token = Token::WHITESPACE;
@@ -387,8 +423,10 @@ void Scanner::scanToken()
 		// whitespace.
 	}
 	while (token == Token::WHITESPACE);
-	m_next_token.location.end = getSourcePos();
-	m_next_token.token = token;
+	m_nextToken.location.end = getSourcePos();
+	m_nextToken.token = token;
+
+	return foundDocComment;
 }
 
 bool Scanner::scanEscape()
@@ -396,7 +434,7 @@ bool Scanner::scanEscape()
 	char c = m_char;
 	advance();
 	// Skip escaped newlines.
-	if (IsLineTerminator(c))
+	if (isLineTerminator(c))
 		return true;
 	switch (c)
 	{
@@ -437,7 +475,7 @@ Token::Value Scanner::scanString()
 	char const quote = m_char;
 	advance();  // consume quote
 	LiteralScope literal(this);
-	while (m_char != quote && !isSourcePastEndOfInput() && !IsLineTerminator(m_char))
+	while (m_char != quote && !isSourcePastEndOfInput() && !isLineTerminator(m_char))
 	{
 		char c = m_char;
 		advance();
@@ -449,8 +487,9 @@ Token::Value Scanner::scanString()
 		else
 			addLiteralChar(c);
 	}
-	if (m_char != quote) return Token::ILLEGAL;
-	literal.Complete();
+	if (m_char != quote)
+		return Token::ILLEGAL;
+	literal.complete();
 	advance();  // consume quote
 	return Token::STRING_LITERAL;
 }
@@ -458,7 +497,7 @@ Token::Value Scanner::scanString()
 
 void Scanner::scanDecimalDigits()
 {
-	while (IsDecimalDigit(m_char))
+	while (isDecimalDigit(m_char))
 		addLiteralCharAndAdvance();
 }
 
@@ -487,9 +526,9 @@ Token::Value Scanner::scanNumber(char _charSeen)
 				// hex number
 				kind = HEX;
 				addLiteralCharAndAdvance();
-				if (!IsHexDigit(m_char))
+				if (!isHexDigit(m_char))
 					return Token::ILLEGAL; // we must have at least one hex digit after 'x'/'X'
-				while (IsHexDigit(m_char))
+				while (isHexDigit(m_char))
 					addLiteralCharAndAdvance();
 			}
 		}
@@ -509,12 +548,13 @@ Token::Value Scanner::scanNumber(char _charSeen)
 	{
 		if (asserts(kind != HEX)) // 'e'/'E' must be scanned as part of the hex number
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
-		if (kind != DECIMAL) return Token::ILLEGAL;
+		if (kind != DECIMAL)
+			return Token::ILLEGAL;
 		// scan exponent
 		addLiteralCharAndAdvance();
 		if (m_char == '+' || m_char == '-')
 			addLiteralCharAndAdvance();
-		if (!IsDecimalDigit(m_char))
+		if (!isDecimalDigit(m_char))
 			return Token::ILLEGAL; // we must have at least one decimal digit after 'e'/'E'
 		scanDecimalDigits();
 	}
@@ -522,9 +562,9 @@ Token::Value Scanner::scanNumber(char _charSeen)
 	// not be an identifier start or a decimal digit; see ECMA-262
 	// section 7.8.3, page 17 (note that we read only one decimal digit
 	// if the value is 0).
-	if (IsDecimalDigit(m_char) || IsIdentifierStart(m_char))
+	if (isDecimalDigit(m_char) || isIdentifierStart(m_char))
 		return Token::ILLEGAL;
-	literal.Complete();
+	literal.complete();
 	return Token::NUMBER;
 }
 
@@ -532,9 +572,9 @@ Token::Value Scanner::scanNumber(char _charSeen)
 // ----------------------------------------------------------------------------
 // Keyword Matcher
 
-#define KEYWORDS(KEYWORD_GROUP, KEYWORD)                                     \
+#define KEYWORDS(KEYWORD_GROUP, KEYWORD)                                       \
 	KEYWORD_GROUP('a')                                                         \
-	KEYWORD("address", Token::ADDRESS)                                           \
+	KEYWORD("address", Token::ADDRESS)                                         \
 	KEYWORD_GROUP('b')                                                         \
 	KEYWORD("break", Token::BREAK)                                             \
 	KEYWORD("bool", Token::BOOL)                                               \
@@ -643,7 +683,6 @@ Token::Value Scanner::scanNumber(char _charSeen)
 	KEYWORD("switch", Token::SWITCH)                                           \
 	KEYWORD_GROUP('t')                                                         \
 	KEYWORD("text", Token::TEXT)                                               \
-	KEYWORD("this", Token::THIS)                                               \
 	KEYWORD("true", Token::TRUE_LITERAL)                                       \
 	KEYWORD_GROUP('u')                                                         \
 	KEYWORD("uint", Token::UINT)                                               \
@@ -686,29 +725,29 @@ Token::Value Scanner::scanNumber(char _charSeen)
 	KEYWORD("while", Token::WHILE)                                             \
 
 
-static Token::Value KeywordOrIdentifierToken(string const& input)
+static Token::Value KeywordOrIdentifierToken(string const& _input)
 {
-	if (asserts(!input.empty()))
+	if (asserts(!_input.empty()))
 		BOOST_THROW_EXCEPTION(InternalCompilerError());
 	int const kMinLength = 2;
 	int const kMaxLength = 10;
-	if (input.size() < kMinLength || input.size() > kMaxLength)
+	if (_input.size() < kMinLength || _input.size() > kMaxLength)
 		return Token::IDENTIFIER;
-	switch (input[0])
+	switch (_input[0])
 	{
 	default:
-#define KEYWORD_GROUP_CASE(ch)                                \
-	break;                                                  \
-case ch:
-#define KEYWORD(keyword, token)                               \
-	{                                                         \
-		/* 'keyword' is a char array, so sizeof(keyword) is */  \
-		/* strlen(keyword) plus 1 for the NUL char. */          \
-		int const keyword_length = sizeof(keyword) - 1;         \
-		BOOST_STATIC_ASSERT(keyword_length >= kMinLength);      \
-		BOOST_STATIC_ASSERT(keyword_length <= kMaxLength);      \
-		if (input == keyword)                                   \
-			return token;                                       \
+#define KEYWORD_GROUP_CASE(ch)					\
+		break;									\
+	case ch:
+#define KEYWORD(keyword, token)                                         \
+		{                                                               \
+			/* 'keyword' is a char array, so sizeof(keyword) is */      \
+			/* strlen(keyword) plus 1 for the NUL char. */              \
+			int const keywordLength = sizeof(keyword) - 1;              \
+			BOOST_STATIC_ASSERT(keywordLength >= kMinLength);           \
+			BOOST_STATIC_ASSERT(keywordLength <= kMaxLength);           \
+			if (_input == keyword)                                     \
+				return token;                                           \
 	}
 		KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD)
 	}
@@ -717,15 +756,15 @@ case ch:
 
 Token::Value Scanner::scanIdentifierOrKeyword()
 {
-	if (asserts(IsIdentifierStart(m_char)))
+	if (asserts(isIdentifierStart(m_char)))
 		BOOST_THROW_EXCEPTION(InternalCompilerError());
 	LiteralScope literal(this);
 	addLiteralCharAndAdvance();
 	// Scan the rest of the identifier characters.
-	while (IsIdentifierPart(m_char))
+	while (isIdentifierPart(m_char))
 		addLiteralCharAndAdvance();
-	literal.Complete();
-	return KeywordOrIdentifierToken(m_next_token.literal);
+	literal.complete();
+	return KeywordOrIdentifierToken(m_nextToken.literal);
 }
 
 char CharStream::advanceAndGet()

libsolidity/Scanner.h

@@ -96,18 +96,18 @@ private:
 class Scanner
 {
 public:
-	// Scoped helper for literal recording. Automatically drops the literal
-	// if aborting the scanning before it's complete.
+	/// Scoped helper for literal recording. Automatically drops the literal
+	/// if aborting the scanning before it's complete.
 	class LiteralScope
 	{
 	public:
-		explicit LiteralScope(Scanner* self): scanner_(self), complete_(false) { scanner_->startNewLiteral(); }
-		~LiteralScope() { if (!complete_) scanner_->dropLiteral(); }
-		void Complete() { complete_ = true; }
+		explicit LiteralScope(Scanner* self): m_scanner(self), m_complete(false) { m_scanner->startNewLiteral(); }
+		~LiteralScope() { if (!m_complete) m_scanner->dropLiteral(); }
+		void complete() { m_complete = true; }
 
 	private:
-		Scanner* scanner_;
-		bool complete_;
+		Scanner* m_scanner;
+		bool m_complete;
 	};
 
 	Scanner() { reset(CharStream()); }
@@ -116,25 +116,34 @@ public:
 	/// Resets the scanner as if newly constructed with _input as input.
 	void reset(CharStream const& _source);
 
-	/// Returns the next token and advances input.
+	/// Returns the next token and advances input
 	Token::Value next();
 
 	///@{
 	///@name Information about the current token
 
 	/// Returns the current token
-	Token::Value getCurrentToken() { return m_current_token.token; }
-	Location getCurrentLocation() const { return m_current_token.location; }
-	std::string const& getCurrentLiteral() const { return m_current_token.literal; }
+	Token::Value getCurrentToken()
+	{
+		return m_currentToken.token;
+	}
+	Location getCurrentLocation() const { return m_currentToken.location; }
+	std::string const& getCurrentLiteral() const { return m_currentToken.literal; }
+	///@}
+
+	///@{
+	///@name Information about the current comment token
+	Location getCurrentCommentLocation() const { return m_skippedComment.location; }
+	std::string const& getCurrentCommentLiteral() const { return m_skippedComment.literal; }
 	///@}
 
 	///@{
 	///@name Information about the next token
 
 	/// Returns the next token without advancing input.
-	Token::Value peekNextToken() const { return m_next_token.token; }
-	Location peekLocation() const { return m_next_token.location; }
-	std::string const& peekLiteral() const { return m_next_token.literal; }
+	Token::Value peekNextToken() const { return m_nextToken.token; }
+	Location peekLocation() const { return m_nextToken.location; }
+	std::string const& peekLiteral() const { return m_nextToken.literal; }
 	///@}
 
 	///@{
@@ -146,7 +155,7 @@ public:
 	///@}
 
 private:
-	// Used for the current and look-ahead token.
+	/// Used for the current and look-ahead token and comments
 	struct TokenDesc
 	{
 		Token::Value token;
@@ -156,9 +165,10 @@ private:
 
 	///@{
 	///@name Literal buffer support
-	inline void startNewLiteral() { m_next_token.literal.clear(); }
-	inline void addLiteralChar(char c) { m_next_token.literal.push_back(c); }
-	inline void dropLiteral() { m_next_token.literal.clear(); }
+	inline void startNewLiteral() { m_nextToken.literal.clear(); }
+	inline void addLiteralChar(char c) { m_nextToken.literal.push_back(c); }
+	inline void addCommentLiteralChar(char c) { m_nextSkippedComment.literal.push_back(c); }
+	inline void dropLiteral() { m_nextToken.literal.clear(); }
 	inline void addLiteralCharAndAdvance() { addLiteralChar(m_char); advance(); }
 	///@}
 
@@ -171,8 +181,9 @@ private:
 
 	bool scanHexByte(char& o_scannedByte);
 
-	/// Scans a single JavaScript token.
-	void scanToken();
+	/// Scans a single Solidity token. Returns true if the scanned token was
+	/// a skipped documentation comment. False in all other cases.
+	bool scanToken();
 
 	/// Skips all whitespace and @returns true if something was skipped.
 	bool skipWhitespace();
@@ -184,6 +195,7 @@ private:
 	Token::Value scanIdentifierOrKeyword();
 
 	Token::Value scanString();
+	Token::Value scanDocumentationComment();
 
 	/// Scans an escape-sequence which is part of a string and adds the
 	/// decoded character to the current literal. Returns true if a pattern
@@ -194,8 +206,11 @@ private:
 	int getSourcePos() { return m_source.getPos(); }
 	bool isSourcePastEndOfInput() { return m_source.isPastEndOfInput(); }
 
-	TokenDesc m_current_token;  // desc for current token (as returned by Next())
-	TokenDesc m_next_token;     // desc for next token (one token look-ahead)
+	TokenDesc m_skippedComment;  // desc for current skipped comment
+	TokenDesc m_nextSkippedComment; // desc for next skiped comment
+
+	TokenDesc m_currentToken;  // desc for current token (as returned by Next())
+	TokenDesc m_nextToken;     // desc for next token (one token look-ahead)
 
 	CharStream m_source;
 

libsolidity/Token.h

@@ -160,7 +160,6 @@ namespace solidity
 	K(RETURNS, "returns", 0)                                           \
 	K(STRUCT, "struct", 0)                                             \
 	K(SWITCH, "switch", 0)                                             \
-	K(THIS, "this", 0)                                                 \
 	K(VAR, "var", 0)                                                   \
 	K(WHILE, "while", 0)                                               \
 	\
@@ -281,6 +280,7 @@ namespace solidity
 	K(FALSE_LITERAL, "false", 0)                                       \
 	T(NUMBER, NULL, 0)                                                 \
 	T(STRING_LITERAL, NULL, 0)                                         \
+	T(COMMENT_LITERAL, NULL, 0)                                        \
 	\
 	/* Identifiers (not keywords or future reserved words). */         \
 	T(IDENTIFIER, NULL, 0)                                             \

libsolidity/Types.cpp

@@ -60,13 +60,24 @@ shared_ptr<Type> Type::fromElementaryTypeName(Token::Value _typeToken)
 
 shared_ptr<Type> Type::fromUserDefinedTypeName(UserDefinedTypeName const& _typeName)
 {
-	return make_shared<StructType>(*_typeName.getReferencedStruct());
+	Declaration const* declaration = _typeName.getReferencedDeclaration();
+	if (StructDefinition const* structDef = dynamic_cast<StructDefinition const*>(declaration))
+		return make_shared<StructType>(*structDef);
+	else if (FunctionDefinition const* function = dynamic_cast<FunctionDefinition const*>(declaration))
+		return make_shared<FunctionType>(*function);
+	else if (ContractDefinition const* contract = dynamic_cast<ContractDefinition const*>(declaration))
+		return make_shared<ContractType>(*contract);
+	return shared_ptr<Type>();
 }
 
 shared_ptr<Type> Type::fromMapping(Mapping const& _typeName)
 {
 	shared_ptr<Type const> keyType = _typeName.getKeyType().toType();
+	if (!keyType)
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Error resolving type name."));
 	shared_ptr<Type const> valueType = _typeName.getValueType().toType();
+	if (!valueType)
+		BOOST_THROW_EXCEPTION(_typeName.getValueType().createTypeError("Invalid type name"));
 	return make_shared<MappingType>(keyType, valueType);
 }
 
@@ -86,6 +97,8 @@ shared_ptr<Type> Type::forLiteral(Literal const& _literal)
 	}
 }
 
+const MemberList Type::EmptyMemberList = MemberList();
+
 shared_ptr<IntegerType> IntegerType::smallestTypeForLiteral(string const& _literal)
 {
 	bigint value(_literal);
@@ -176,6 +189,11 @@ u256 IntegerType::literalValue(Literal const& _literal) const
 	return u256(value);
 }
 
+const MemberList IntegerType::AddressMemberList =
+		MemberList({{"balance", make_shared<IntegerType const>(256)},
+					{"send", make_shared<FunctionType const>(TypePointers({make_shared<IntegerType const>(256)}),
+															 TypePointers(), FunctionType::Location::SEND)}});
+
 bool BoolType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
 	// conversion to integer is fine, but not to address
@@ -199,6 +217,15 @@ u256 BoolType::literalValue(Literal const& _literal) const
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Bool type constructed from non-boolean literal."));
 }
 
+bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
+{
+	if (isImplicitlyConvertibleTo(_convertTo))
+		return true;
+	if (_convertTo.getCategory() == Category::INTEGER)
+		return dynamic_cast<IntegerType const&>(_convertTo).isAddress();
+	return false;
+}
+
 bool ContractType::operator==(Type const& _other) const
 {
 	if (_other.getCategory() != getCategory())
@@ -215,6 +242,11 @@ u256 ContractType::getStorageSize() const
 	return max<u256>(1, size);
 }
 
+string ContractType::toString() const
+{
+	return "contract " + m_contract.getName();
+}
+
 bool StructType::operator==(Type const& _other) const
 {
 	if (_other.getCategory() != getCategory())
@@ -226,15 +258,15 @@ bool StructType::operator==(Type const& _other) const
 u256 StructType::getStorageSize() const
 {
 	u256 size = 0;
-	for (ASTPointer<VariableDeclaration> const& variable: m_struct.getMembers())
-		size += variable->getType()->getStorageSize();
+	for (pair<string, shared_ptr<Type const>> const& member: getMembers())
+		size += member.second->getStorageSize();
 	return max<u256>(1, size);
 }
 
 bool StructType::canLiveOutsideStorage() const
 {
-	for (unsigned i = 0; i < getMemberCount(); ++i)
-		if (!getMemberByIndex(i).getType()->canLiveOutsideStorage())
+	for (pair<string, shared_ptr<Type const>> const& member: getMembers())
+		if (!member.second->canLiveOutsideStorage())
 			return false;
 	return true;
 }
@@ -244,33 +276,45 @@ string StructType::toString() const
 	return string("struct ") + m_struct.getName();
 }
 
-unsigned StructType::getMemberCount() const
-{
-	return m_struct.getMembers().size();
-}
-
-unsigned StructType::memberNameToIndex(string const& _name) const
+MemberList const& StructType::getMembers() const
 {
-	vector<ASTPointer<VariableDeclaration>> const& members = m_struct.getMembers();
-	for (unsigned index = 0; index < members.size(); ++index)
-		if (members[index]->getName() == _name)
-			return index;
-	return unsigned(-1);
+	// We need to lazy-initialize it because of recursive references.
+	if (!m_members)
+	{
+		map<string, shared_ptr<Type const>> members;
+		for (ASTPointer<VariableDeclaration> const& variable: m_struct.getMembers())
+			members[variable->getName()] = variable->getType();
+		m_members.reset(new MemberList(members));
+	}
+	return *m_members;
 }
 
-VariableDeclaration const& StructType::getMemberByIndex(unsigned _index) const
+u256 StructType::getStorageOffsetOfMember(string const& _name) const
 {
-	return *m_struct.getMembers()[_index];
+	//@todo cache member offset?
+	u256 offset;
+	for (ASTPointer<VariableDeclaration> variable: m_struct.getMembers())
+	{
+		offset += variable->getType()->getStorageSize();
+		if (variable->getName() == _name)
+			return offset;
+	}
+	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage offset of non-existing member requested."));
 }
 
-u256 StructType::getStorageOffsetOfMember(unsigned _index) const
+FunctionType::FunctionType(FunctionDefinition const& _function)
 {
-	//@todo cache member offset?
-	u256 offset;
-//	vector<ASTPointer<VariableDeclaration>> const& members = m_struct.getMembers();
-	for (unsigned index = 0; index < _index; ++index)
-		offset += getMemberByIndex(index).getType()->getStorageSize();
-	return offset;
+	TypePointers params;
+	TypePointers retParams;
+	params.reserve(_function.getParameters().size());
+	for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
+		params.push_back(var->getType());
+	retParams.reserve(_function.getReturnParameters().size());
+	for (ASTPointer<VariableDeclaration> const& var: _function.getReturnParameters())
+		retParams.push_back(var->getType());
+	swap(params, m_parameterTypes);
+	swap(retParams, m_returnParameterTypes);
+	m_location = Location::INTERNAL;
 }
 
 bool FunctionType::operator==(Type const& _other) const
@@ -278,13 +322,43 @@ bool FunctionType::operator==(Type const& _other) const
 	if (_other.getCategory() != getCategory())
 		return false;
 	FunctionType const& other = dynamic_cast<FunctionType const&>(_other);
-	return other.m_function == m_function;
+
+	if (m_parameterTypes.size() != other.m_parameterTypes.size() ||
+			m_returnParameterTypes.size() != other.m_returnParameterTypes.size())
+		return false;
+	auto typeCompare = [](TypePointer const& _a, TypePointer const& _b) -> bool { return *_a == *_b; };
+
+	if (!equal(m_parameterTypes.cbegin(), m_parameterTypes.cend(),
+			   other.m_parameterTypes.cbegin(), typeCompare))
+		return false;
+	if (!equal(m_returnParameterTypes.cbegin(), m_returnParameterTypes.cend(),
+			   other.m_returnParameterTypes.cbegin(), typeCompare))
+		return false;
+	return true;
 }
 
 string FunctionType::toString() const
 {
-	//@todo nice string for function types
-	return "function(...)returns(...)";
+	string name = "function (";
+	for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
+		name += (*it)->toString() + (it + 1 == m_parameterTypes.end() ? "" : ",");
+	name += ") returns (";
+	for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
+		name += (*it)->toString() + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
+	return name + ")";
+}
+
+unsigned FunctionType::getSizeOnStack() const
+{
+	switch (m_location)
+	{
+	case Location::INTERNAL:
+		return 1;
+	case Location::EXTERNAL:
+		return 2;
+	default:
+		return 0;
+	}
 }
 
 bool MappingType::operator==(Type const& _other) const
@@ -308,5 +382,55 @@ bool TypeType::operator==(Type const& _other) const
 	return *getActualType() == *other.getActualType();
 }
 
+MagicType::MagicType(MagicType::Kind _kind):
+	m_kind(_kind)
+{
+	switch (m_kind)
+	{
+	case Kind::BLOCK:
+		m_members = MemberList({{"coinbase", make_shared<IntegerType const>(0, IntegerType::Modifier::ADDRESS)},
+								{"timestamp", make_shared<IntegerType const>(256)},
+								{"prevhash", make_shared<IntegerType const>(256, IntegerType::Modifier::HASH)},
+								{"difficulty", make_shared<IntegerType const>(256)},
+								{"number", make_shared<IntegerType const>(256)},
+								{"gaslimit", make_shared<IntegerType const>(256)}});
+		break;
+	case Kind::MSG:
+		m_members = MemberList({{"sender", make_shared<IntegerType const>(0, IntegerType::Modifier::ADDRESS)},
+								{"value", make_shared<IntegerType const>(256)}});
+		break;
+	case Kind::TX:
+		m_members = MemberList({{"origin", make_shared<IntegerType const>(0, IntegerType::Modifier::ADDRESS)},
+								{"gas", make_shared<IntegerType const>(256)},
+								{"gasprice", make_shared<IntegerType const>(256)}});
+		break;
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
+	}
+}
+
+bool MagicType::operator==(Type const& _other) const
+{
+	if (_other.getCategory() != getCategory())
+		return false;
+	MagicType const& other = dynamic_cast<MagicType const&>(_other);
+	return other.m_kind == m_kind;
+}
+
+string MagicType::toString() const
+{
+	switch (m_kind)
+	{
+	case Kind::BLOCK:
+		return "block";
+	case Kind::MSG:
+		return "msg";
+	case Kind::TX:
+		return "tx";
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
+	}
+}
+
 }
 }

libsolidity/Types.h

@@ -24,6 +24,7 @@
 
 #include <memory>
 #include <string>
+#include <map>
 #include <boost/noncopyable.hpp>
 #include <libdevcore/Common.h>
 #include <libsolidity/Exceptions.h>
@@ -37,6 +38,34 @@ namespace solidity
 
 // @todo realMxN, string<N>
 
+class Type; // forward
+using TypePointer = std::shared_ptr<Type const>;
+using TypePointers = std::vector<TypePointer>;
+
+/**
+ * List of members of a type.
+ */
+class MemberList
+{
+public:
+	using MemberMap = std::map<std::string, TypePointer>;
+
+	MemberList() {}
+	explicit MemberList(MemberMap const& _members): m_memberTypes(_members) {}
+	TypePointer getMemberType(std::string const& _name) const
+	{
+		auto it = m_memberTypes.find(_name);
+		return it != m_memberTypes.end() ? it->second : TypePointer();
+	}
+
+	MemberMap::const_iterator begin() const { return m_memberTypes.begin(); }
+	MemberMap::const_iterator end() const { return m_memberTypes.end(); }
+
+private:
+	MemberMap m_memberTypes;
+};
+
+
 /**
  * Abstract base class that forms the root of the type hierarchy.
  */
@@ -45,7 +74,7 @@ class Type: private boost::noncopyable
 public:
 	enum class Category
 	{
-		INTEGER, BOOL, REAL, STRING, CONTRACT, STRUCT, FUNCTION, MAPPING, VOID, TYPE
+		INTEGER, BOOL, REAL, STRING, CONTRACT, STRUCT, FUNCTION, MAPPING, VOID, TYPE, MAGIC
 	};
 
 	///@{
@@ -54,6 +83,7 @@ public:
 	static std::shared_ptr<Type> fromElementaryTypeName(Token::Value _typeToken);
 	static std::shared_ptr<Type> fromUserDefinedTypeName(UserDefinedTypeName const& _typeName);
 	static std::shared_ptr<Type> fromMapping(Mapping const& _typeName);
+	static std::shared_ptr<Type> fromFunction(FunctionDefinition const& _function);
 	/// @}
 
 	/// Auto-detect the proper type for a literal. @returns an empty pointer if the literal does
@@ -78,8 +108,19 @@ public:
 	/// @returns number of bytes required to hold this value in storage.
 	/// For dynamically "allocated" types, it returns the size of the statically allocated head,
 	virtual u256 getStorageSize() const { return 1; }
+	/// Returns true if the type can be stored in storage.
+	virtual bool canBeStored() const { return true; }
 	/// Returns false if the type cannot live outside the storage, i.e. if it includes some mapping.
 	virtual bool canLiveOutsideStorage() const { return true; }
+	/// Returns true if the type can be stored as a value (as opposed to a reference) on the stack,
+	/// i.e. it behaves differently in lvalue context and in value context.
+	virtual bool isValueType() const { return false; }
+	virtual unsigned getSizeOnStack() const { return 1; }
+
+	/// Returns the list of all members of this type. Default implementation: no members.
+	virtual MemberList const& getMembers() const { return EmptyMemberList; }
+	/// Convenience method, returns the type of the given named member or an empty pointer if no such member exists.
+	TypePointer getMemberType(std::string const& _name) const { return getMembers().getMemberType(_name); }
 
 	virtual std::string toString() const = 0;
 	virtual u256 literalValue(Literal const&) const
@@ -87,6 +128,10 @@ public:
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Literal value requested "
 																		  "for type without literals."));
 	}
+
+protected:
+	/// Convenience object used when returning an empty member list.
+	static const MemberList EmptyMemberList;
 };
 
 /**
@@ -114,7 +159,10 @@ public:
 
 	virtual bool operator==(Type const& _other) const override;
 
-	virtual unsigned getCalldataEncodedSize() const { return m_bits / 8; }
+	virtual unsigned getCalldataEncodedSize() const override { return m_bits / 8; }
+	virtual bool isValueType() const override { return true; }
+
+	virtual MemberList const& getMembers() const { return isAddress() ? AddressMemberList : EmptyMemberList; }
 
 	virtual std::string toString() const override;
 	virtual u256 literalValue(Literal const& _literal) const override;
@@ -127,6 +175,7 @@ public:
 private:
 	int m_bits;
 	Modifier m_modifier;
+	static const MemberList AddressMemberList;
 };
 
 /**
@@ -147,6 +196,7 @@ public:
 	}
 
 	virtual unsigned getCalldataEncodedSize() const { return 1; }
+	virtual bool isValueType() const override { return true; }
 
 	virtual std::string toString() const override { return "bool"; }
 	virtual u256 literalValue(Literal const& _literal) const override;
@@ -160,10 +210,11 @@ class ContractType: public Type
 public:
 	virtual Category getCategory() const override { return Category::CONTRACT; }
 	ContractType(ContractDefinition const& _contract): m_contract(_contract) {}
-
+	/// Contracts can be converted to themselves and to addresses.
+	virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual bool operator==(Type const& _other) const override;
-	virtual u256 getStorageSize() const;
-	virtual std::string toString() const override { return "contract{...}"; }
+	virtual u256 getStorageSize() const override;
+	virtual std::string toString() const override;
 
 private:
 	ContractDefinition const& m_contract;
@@ -183,38 +234,57 @@ public:
 	}
 
 	virtual bool operator==(Type const& _other) const override;
-	virtual u256 getStorageSize() const;
-	virtual bool canLiveOutsideStorage() const;
+	virtual u256 getStorageSize() const override;
+	virtual bool canLiveOutsideStorage() const override;
+	virtual unsigned getSizeOnStack() const override { return 1; /*@todo*/ }
 	virtual std::string toString() const override;
 
-	unsigned getMemberCount() const;
-	/// Returns the index of the member with name @a _name or unsigned(-1) if it does not exist.
-	unsigned memberNameToIndex(std::string const& _name) const;
-	VariableDeclaration const& getMemberByIndex(unsigned _index) const;
-	u256 getStorageOffsetOfMember(unsigned _index) const;
+	virtual MemberList const& getMembers() const override;
+
+	u256 getStorageOffsetOfMember(std::string const& _name) const;
 
 private:
 	StructDefinition const& m_struct;
+	/// List of member types, will be lazy-initialized because of recursive references.
+	mutable std::unique_ptr<MemberList> m_members;
 };
 
 /**
- * The type of a function, there is one distinct type per function definition.
+ * The type of a function, identified by its (return) parameter types.
+ * @todo the return parameters should also have names, i.e. return parameters should be a struct
+ * type.
  */
 class FunctionType: public Type
 {
 public:
+	/// The meaning of the value(s) on the stack referencing the function:
+	/// INTERNAL: jump tag, EXTERNAL: contract address + function index,
+	/// OTHERS: special virtual function, nothing on the stack
+	enum class Location { INTERNAL, EXTERNAL, SEND, SHA3, SUICIDE, ECRECOVER, SHA256, RIPEMD160 };
+
 	virtual Category getCategory() const override { return Category::FUNCTION; }
-	FunctionType(FunctionDefinition const& _function): m_function(_function) {}
+	explicit FunctionType(FunctionDefinition const& _function);
+	FunctionType(TypePointers const& _parameterTypes, TypePointers const& _returnParameterTypes,
+				 Location _location = Location::INTERNAL):
+		m_parameterTypes(_parameterTypes), m_returnParameterTypes(_returnParameterTypes),
+		m_location(_location) {}
 
-	FunctionDefinition const& getFunction() const { return m_function; }
+	TypePointers const& getParameterTypes() const { return m_parameterTypes; }
+	TypePointers const& getReturnParameterTypes() const { return m_returnParameterTypes; }
 
 	virtual bool operator==(Type const& _other) const override;
 	virtual std::string toString() const override;
-	virtual u256 getStorageSize() const { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable function type requested.")); }
-	virtual bool canLiveOutsideStorage() const { return false; }
+	virtual bool canBeStored() const override { return false; }
+	virtual u256 getStorageSize() const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable function type requested.")); }
+	virtual bool canLiveOutsideStorage() const override { return false; }
+	virtual unsigned getSizeOnStack() const override;
+
+	Location getLocation() const { return m_location; }
 
 private:
-	FunctionDefinition const& m_function;
+	TypePointers m_parameterTypes;
+	TypePointers m_returnParameterTypes;
+	Location m_location;
 };
 
 /**
@@ -224,19 +294,19 @@ class MappingType: public Type
 {
 public:
 	virtual Category getCategory() const override { return Category::MAPPING; }
-	MappingType(std::shared_ptr<Type const> _keyType, std::shared_ptr<Type const> _valueType):
+	MappingType(TypePointer const& _keyType, TypePointer const& _valueType):
 		m_keyType(_keyType), m_valueType(_valueType) {}
 
 	virtual bool operator==(Type const& _other) const override;
 	virtual std::string toString() const override;
-	virtual bool canLiveOutsideStorage() const { return false; }
+	virtual bool canLiveOutsideStorage() const override { return false; }
 
-	std::shared_ptr<Type const> getKeyType() const { return m_keyType; }
-	std::shared_ptr<Type const> getValueType() const { return m_valueType; }
+	TypePointer getKeyType() const { return m_keyType; }
+	TypePointer getValueType() const { return m_valueType; }
 
 private:
-	std::shared_ptr<Type const> m_keyType;
-	std::shared_ptr<Type const> m_valueType;
+	TypePointer m_keyType;
+	TypePointer m_valueType;
 };
 
 /**
@@ -250,8 +320,10 @@ public:
 	VoidType() {}
 
 	virtual std::string toString() const override { return "void"; }
-	virtual u256 getStorageSize() const { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable void type requested.")); }
-	virtual bool canLiveOutsideStorage() const { return false; }
+	virtual bool canBeStored() const override { return false; }
+	virtual u256 getStorageSize() const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable void type requested.")); }
+	virtual bool canLiveOutsideStorage() const override { return false; }
+	virtual unsigned getSizeOnStack() const override { return 0; }
 };
 
 /**
@@ -262,19 +334,45 @@ class TypeType: public Type
 {
 public:
 	virtual Category getCategory() const override { return Category::TYPE; }
-	TypeType(std::shared_ptr<Type const> const& _actualType): m_actualType(_actualType) {}
+	TypeType(TypePointer const& _actualType): m_actualType(_actualType) {}
 
-	std::shared_ptr<Type const> const& getActualType() const { return m_actualType; }
+	TypePointer const& getActualType() const { return m_actualType; }
 
 	virtual bool operator==(Type const& _other) const override;
-	virtual u256 getStorageSize() const { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable type type requested.")); }
-	virtual bool canLiveOutsideStorage() const { return false; }
+	virtual bool canBeStored() const override { return false; }
+	virtual u256 getStorageSize() const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable type type requested.")); }
+	virtual bool canLiveOutsideStorage() const override { return false; }
 	virtual std::string toString() const override { return "type(" + m_actualType->toString() + ")"; }
 
 private:
-	std::shared_ptr<Type const> m_actualType;
+	TypePointer m_actualType;
 };
 
 
+/**
+ * Special type for magic variables (block, msg, tx), similar to a struct but without any reference
+ * (it always references a global singleton by name).
+ */
+class MagicType: public Type
+{
+public:
+	enum class Kind { BLOCK, MSG, TX };
+	virtual Category getCategory() const override { return Category::MAGIC; }
+
+	MagicType(Kind _kind);
+	virtual bool operator==(Type const& _other) const;
+	virtual bool canBeStored() const override { return false; }
+	virtual bool canLiveOutsideStorage() const override { return true; }
+	virtual unsigned getSizeOnStack() const override { return 0; }
+	virtual MemberList const& getMembers() const override { return m_members; }
+
+	virtual std::string toString() const override;
+
+private:
+	Kind m_kind;
+
+	MemberList m_members;
+};
+
 }
 }

test/TestHelper.cpp

@@ -293,6 +293,18 @@ void checkStorage(map<u256, u256> _expectedStore, map<u256, u256> _resultStore,
     }
 }
 
+void checkLog(LogEntries _resultLogs, LogEntries _expectedLogs)
+{
+	BOOST_REQUIRE_EQUAL(_resultLogs.size(), _expectedLogs.size());
+
+	for (size_t i = 0; i < _resultLogs.size(); ++i)
+	{
+		BOOST_CHECK_EQUAL(_resultLogs[i].address, _expectedLogs[i].address);
+		BOOST_CHECK_EQUAL(_resultLogs[i].topics, _expectedLogs[i].topics);
+		BOOST_CHECK(_resultLogs[i].data == _expectedLogs[i].data);
+	}
+}
+
 std::string getTestPath()
 {
 	string testPath;
@@ -316,12 +328,13 @@ void userDefinedTest(string testTypeFlag, std::function<void(json_spirit::mValue
 		string arg = boost::unit_test::framework::master_test_suite().argv[i];
 		if (arg == testTypeFlag)
 		{
-			if (i + 1 >= boost::unit_test::framework::master_test_suite().argc)
+			if (boost::unit_test::framework::master_test_suite().argc <= i + 2)
 			{
-				cnote << "Missing filename\nUsage: testeth " << testTypeFlag << " <filename>\n";
+				cnote << "Missing filename\nUsage: testeth " << testTypeFlag << " <filename> <testname>\n";
 				return;
 			}
 			string filename = boost::unit_test::framework::master_test_suite().argv[i + 1];
+			string testname = boost::unit_test::framework::master_test_suite().argv[i + 2];
 			int currentVerbosity = g_logVerbosity;
 			g_logVerbosity = 12;
 			try
@@ -331,7 +344,19 @@ void userDefinedTest(string testTypeFlag, std::function<void(json_spirit::mValue
 				string s = asString(contents(filename));
 				BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + filename + " is empty. ");
 				json_spirit::read_string(s, v);
-				doTests(v, false);
+				json_spirit::mObject oSingleTest;
+
+				json_spirit::mObject::const_iterator pos = v.get_obj().find(testname);
+				if (pos == v.get_obj().end())
+				{
+					cnote << "Could not find test: " << testname << " in " << filename << "\n";
+					return;
+				}
+				else
+					oSingleTest[pos->first] = pos->second;
+
+				json_spirit::mValue v_singleTest(oSingleTest);
+				doTests(v_singleTest, false);
 			}
 			catch (Exception const& _e)
 			{

test/TestHelper.h

@@ -25,6 +25,7 @@
 #include <boost/test/unit_test.hpp>
 #include "JsonSpiritHeaders.h"
 #include <libethereum/State.h>
+#include <libevm/ExtVMFace.h>
 
 namespace dev
 {
@@ -69,6 +70,7 @@ bytes importCode(json_spirit::mObject& _o);
 bytes importData(json_spirit::mObject& _o);
 void checkOutput(bytes const& _output, json_spirit::mObject& _o);
 void checkStorage(std::map<u256, u256> _expectedStore, std::map<u256, u256> _resultStore, Address _expectedAddr);
+void checkLog(eth::LogEntries _resultLogs, eth::LogEntries _expectedLogs);
 void executeTests(const std::string& _name, const std::string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests);
 std::string getTestPath();
 void userDefinedTest(std::string testTypeFlag, std::function<void(json_spirit::mValue&, bool)> doTests);

test/solidityCompiler.cpp

@@ -48,11 +48,11 @@ bytes compileContract(const string& _sourceCode)
 	Parser parser;
 	ASTPointer<ContractDefinition> contract;
 	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
-	NameAndTypeResolver resolver;
+	NameAndTypeResolver resolver({});
 	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
 
 	Compiler compiler;
-	compiler.compileContract(*contract);
+	compiler.compileContract(*contract, {});
 	// debug
 	//compiler.streamAssembly(cout);
 	return compiler.getAssembledBytecode();

test/solidityEndToEndTest.cpp

@@ -27,12 +27,14 @@
 #include <libethereum/State.h>
 #include <libethereum/Executive.h>
 #include <libsolidity/CompilerStack.h>
+#include <libdevcrypto/SHA3.h>
 
 using namespace std;
 
 namespace dev
 {
-/// Provider another overload for toBigEndian to encode arguments and return values.
+/// Provides additional overloads for toBigEndian to encode arguments and return values.
+inline bytes toBigEndian(byte _value) { return bytes({_value}); }
 inline bytes toBigEndian(bool _value) { return bytes({byte(_value)}); }
 
 namespace solidity
@@ -45,17 +47,17 @@ class ExecutionFramework
 public:
 	ExecutionFramework() { g_logVerbosity = 0; }
 
-	bytes const& compileAndRun(string const& _sourceCode)
+	bytes const& compileAndRun(string const& _sourceCode, u256 const& _value = 0)
 	{
 		bytes code = dev::solidity::CompilerStack::staticCompile(_sourceCode);
-		sendMessage(code, true);
+		sendMessage(code, true, _value);
 		BOOST_REQUIRE(!m_output.empty());
 		return m_output;
 	}
 
-	bytes const& callContractFunction(byte _index, bytes const& _data = bytes())
+	bytes const& callContractFunction(byte _index, bytes const& _data = bytes(), u256 const& _value = 0)
 	{
-		sendMessage(bytes(1, _index) + _data, false);
+		sendMessage(bytes(1, _index) + _data, false, _value);
 		return m_output;
 	}
 
@@ -111,11 +113,11 @@ private:
 		return toBigEndian(_cppFunction(_arguments...));
 	}
 
-	void sendMessage(bytes const& _data, bool _isCreation)
+	void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
 	{
 		eth::Executive executive(m_state);
-		eth::Transaction t = _isCreation ? eth::Transaction(0, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec())
-										 : eth::Transaction(0, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
+		eth::Transaction t = _isCreation ? eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec())
+										 : eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
 		bytes transactionRLP = t.rlp();
 		try
 		{
@@ -125,7 +127,7 @@ private:
 		catch (...) {}
 		if (_isCreation)
 		{
-			BOOST_REQUIRE(!executive.create(Address(), 0, m_gasPrice, m_gas, &_data, Address()));
+			BOOST_REQUIRE(!executive.create(Address(), _value, m_gasPrice, m_gas, &_data, Address()));
 			m_contractAddress = executive.newAddress();
 			BOOST_REQUIRE(m_contractAddress);
 			BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
@@ -133,7 +135,7 @@ private:
 		else
 		{
 			BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
-			BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), 0, m_gasPrice, &_data, m_gas, Address()));
+			BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), _value, m_gasPrice, &_data, m_gas, Address()));
 		}
 		BOOST_REQUIRE(executive.go());
 		executive.finalize();
@@ -700,6 +702,34 @@ BOOST_AUTO_TEST_CASE(structs)
 	BOOST_CHECK(callContractFunction(0) == bytes({0x01}));
 }
 
+BOOST_AUTO_TEST_CASE(struct_reference)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  struct s2 {\n"
+							 "    uint32 z;\n"
+							 "    mapping(uint8 => s2) recursive;\n"
+							 "  }\n"
+							 "  s2 data;\n"
+							 "  function check() returns (bool ok) {\n"
+							 "    return data.z == 2 && \n"
+							 "        data.recursive[0].z == 3 && \n"
+							 "        data.recursive[0].recursive[1].z == 0 && \n"
+							 "        data.recursive[0].recursive[0].z == 1;\n"
+							 "  }\n"
+							 "  function set() {\n"
+							 "    data.z = 2;\n"
+							 "    var map = data.recursive;\n"
+							 "    s2 inner = map[0];\n"
+							 "    inner.z = 3;\n"
+							 "    inner.recursive[0].z = inner.recursive[1].z + 1;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction(0) == bytes({0x00}));
+	BOOST_CHECK(callContractFunction(1) == bytes());
+	BOOST_CHECK(callContractFunction(0) == bytes({0x01}));
+}
+
 BOOST_AUTO_TEST_CASE(constructor)
 {
 	char const* sourceCode = "contract test {\n"
@@ -722,6 +752,152 @@ BOOST_AUTO_TEST_CASE(constructor)
 	testSolidityAgainstCpp(0, get, u256(7));
 }
 
+BOOST_AUTO_TEST_CASE(balance)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function getBalance() returns (uint256 balance) {\n"
+							 "    return address(this).balance;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode, 23);
+	BOOST_CHECK(callContractFunction(0) == toBigEndian(u256(23)));
+}
+
+BOOST_AUTO_TEST_CASE(blockchain)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function someInfo() returns (uint256 value, address coinbase, uint256 blockNumber) {\n"
+							 "    value = msg.value;\n"
+							 "    coinbase = block.coinbase;\n"
+							 "    blockNumber = block.number;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode, 27);
+	BOOST_CHECK(callContractFunction(0, bytes{0}, u256(28)) == toBigEndian(u256(28)) + bytes(20, 0) + toBigEndian(u256(1)));
+}
+
+BOOST_AUTO_TEST_CASE(function_types)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(bool selector) returns (uint b) {\n"
+							 "    var f = fun1;\n"
+							 "    if (selector) f = fun2;\n"
+							 "    return f(9);\n"
+							 "  }\n"
+							 "  function fun1(uint x) returns (uint b) {\n"
+							 "    return 11;\n"
+							 "  }\n"
+							 "  function fun2(uint x) returns (uint b) {\n"
+							 "    return 12;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction(0, bytes{0}) == toBigEndian(u256(11)));
+	BOOST_CHECK(callContractFunction(0, bytes{1}) == toBigEndian(u256(12)));
+}
+
+BOOST_AUTO_TEST_CASE(send_ether)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(address addr, uint amount) returns (uint ret) {\n"
+							 "    addr.send(amount);\n"
+							 "    return address(this).balance;\n"
+							 "  }\n"
+							 "}\n";
+	u256 amount(130);
+	compileAndRun(sourceCode, amount + 1);
+	u160 address(23);
+	BOOST_CHECK(callContractFunction(0, address, amount) == toBigEndian(u256(1)));
+	BOOST_CHECK_EQUAL(m_state.balance(address), amount);
+}
+
+BOOST_AUTO_TEST_CASE(suicide)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(address receiver) returns (uint ret) {\n"
+							 "    suicide(receiver);\n"
+							 "    return 10;\n"
+							 "  }\n"
+							 "}\n";
+	u256 amount(130);
+	compileAndRun(sourceCode, amount);
+	u160 address(23);
+	BOOST_CHECK(callContractFunction(0, address) == bytes());
+	BOOST_CHECK(!m_state.addressHasCode(m_contractAddress));
+	BOOST_CHECK_EQUAL(m_state.balance(address), amount);
+}
+
+BOOST_AUTO_TEST_CASE(sha3)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(hash input) returns (hash sha3hash) {\n"
+							 "    return sha3(input);\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	auto f = [&](u256 const& _x) -> u256
+	{
+		return dev::sha3(toBigEndian(_x));
+	};
+	testSolidityAgainstCpp(0, f, u256(4));
+	testSolidityAgainstCpp(0, f, u256(5));
+	testSolidityAgainstCpp(0, f, u256(-1));
+}
+
+BOOST_AUTO_TEST_CASE(sha256)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(hash input) returns (hash sha256hash) {\n"
+							 "    return sha256(input);\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	auto f = [&](u256 const& _input) -> u256
+	{
+		h256 ret;
+		dev::sha256(dev::ref(toBigEndian(_input)), bytesRef(&ret[0], 32));
+		return ret;
+	};
+	testSolidityAgainstCpp(0, f, u256(4));
+	testSolidityAgainstCpp(0, f, u256(5));
+	testSolidityAgainstCpp(0, f, u256(-1));
+}
+
+BOOST_AUTO_TEST_CASE(ripemd)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(hash input) returns (hash sha256hash) {\n"
+							 "    return ripemd160(input);\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	auto f = [&](u256 const& _input) -> u256
+	{
+		h256 ret;
+		dev::ripemd160(dev::ref(toBigEndian(_input)), bytesRef(&ret[0], 32));
+		return u256(ret) >> (256 - 160);
+	};
+	testSolidityAgainstCpp(0, f, u256(4));
+	testSolidityAgainstCpp(0, f, u256(5));
+	testSolidityAgainstCpp(0, f, u256(-1));
+}
+
+BOOST_AUTO_TEST_CASE(ecrecover)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function a(hash h, uint8 v, hash r, hash s) returns (address addr) {\n"
+							 "    return ecrecover(h, v, r, s);\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	u256 h("0x18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c");
+	byte v = 28;
+	u256 r("0x73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9aa6a5a75f");
+	u256 s("0xeeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549");
+	u160 addr("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b");
+	BOOST_CHECK(callContractFunction(0, h, v, r, s) == toBigEndian(addr));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/solidityExpressionCompiler.cpp

@@ -88,7 +88,7 @@ bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _
 	Parser parser;
 	ASTPointer<ContractDefinition> contract;
 	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
-	NameAndTypeResolver resolver;
+	NameAndTypeResolver resolver({});
 	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
 	FirstExpressionExtractor extractor(*contract);
 	BOOST_REQUIRE(extractor.getExpression() != nullptr);

test/solidityNameAndTypeResolution.cpp

@@ -43,7 +43,7 @@ void parseTextAndResolveNames(std::string const& _source)
 	Parser parser;
 	ASTPointer<ContractDefinition> contract = parser.parse(
 										   std::make_shared<Scanner>(CharStream(_source)));
-	NameAndTypeResolver resolver;
+	NameAndTypeResolver resolver({});
 	resolver.resolveNamesAndTypes(*contract);
 }
 }
@@ -224,6 +224,26 @@ BOOST_AUTO_TEST_CASE(type_inference_explicit_conversion)
 	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
 }
 
+BOOST_AUTO_TEST_CASE(balance)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint256 x = address(0).balance;\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
+}
+
+BOOST_AUTO_TEST_CASE(balance_invalid)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    address(0).balance = 7;\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/solidityScanner.cpp

@@ -153,6 +153,46 @@ BOOST_AUTO_TEST_CASE(ambiguities)
 	BOOST_CHECK_EQUAL(scanner.next(), Token::SHL);
 }
 
+BOOST_AUTO_TEST_CASE(documentation_comments_parsed_begin)
+{
+	Scanner scanner(CharStream("/// Send $(value / 1000) chocolates to the user"));
+	BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), " Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(documentation_comments_parsed)
+{
+	Scanner scanner(CharStream("some other tokens /// Send $(value / 1000) chocolates to the user"));
+	BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::IDENTIFIER);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::IDENTIFIER);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::IDENTIFIER);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), " Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(comment_before_eos)
+{
+	Scanner scanner(CharStream("//"));
+	BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(documentation_comment_before_eos)
+{
+	Scanner scanner(CharStream("///"));
+	BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(comments_mixed_in_sequence)
+{
+	Scanner scanner(CharStream("hello_world ///documentation comment \n"
+							   "//simple comment \n"
+							   "<<"));
+	BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::IDENTIFIER);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SHL);
+	BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), "documentation comment ");
+}
 
 BOOST_AUTO_TEST_SUITE_END()
 

test/stPreCompiledContractsFiller.json

@@ -33,6 +33,40 @@
         }
      },
 
+    "CallEcrecover0_completeReturnValue": {
+         "env" : {
+             "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+             "currentNumber" : "0",
+             "currentGasLimit" : "10000000",
+             "currentDifficulty" : "256",
+             "currentTimestamp" : 1,
+             "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+         },
+         "pre" : {
+             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
+                 "balance" : "20000000",
+                 "nonce" : 0,
+                 "code": "{ (MSTORE 0 0x18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c) (MSTORE 32 28) (MSTORE 64 0x73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9aa6a5a75f) (MSTORE 96 0xeeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549) [[ 2 ]] (CALL 1000 1 0 0 128 128 32) [[ 0 ]] (MLOAD 128) }",
+                 "storage": {}
+             },
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "",
+                "storage": {}
+            }
+        },
+        "transaction" : {
+            "nonce" : "0",
+            "gasPrice" : "1",
+            "gasLimit" : "365224",
+            "to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
+            "value" : "100000",
+            "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+            "data" : ""
+        }
+     },
+
     "CallEcrecover0_gas500": {
          "env" : {
              "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
@@ -305,6 +339,40 @@
         }
      },
 
+    "CallSha256_1_nonzeroValue": {
+         "env" : {
+             "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+             "currentNumber" : "0",
+             "currentGasLimit" : "10000000",
+             "currentDifficulty" : "256",
+             "currentTimestamp" : 1,
+             "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+         },
+         "pre" : {
+             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
+                 "balance" : "20000000",
+                 "nonce" : 0,
+                 "code" : "{ [[ 2 ]] (CALL 500 2 0x13 0 0 0 32) [[ 0 ]] (MLOAD 0)}",
+                 "storage": {}
+             },
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "",
+                "storage": {}
+            }
+        },
+        "transaction" : {
+            "nonce" : "0",
+            "gasPrice" : "1",
+            "gasLimit" : "365224",
+            "to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
+            "value" : "100000",
+            "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+            "data" : ""
+        }
+     },
+
     "CallSha256_2": {
          "env" : {
              "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",

test/stSpecialTestFiller.json

@@ -0,0 +1,41 @@
+{
+   "makeMoney" : {
+        "env" : {
+            "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+            "currentNumber" : "0",
+            "currentGasLimit" : "1000000",
+            "currentDifficulty" : "256",
+            "currentTimestamp" : 1,
+            "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+            "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "{ (MSTORE 0 0x601080600c6000396000f20060003554156009570060203560003555) (CALL 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec 0xaaaaaaaaace5edbc8e2a8697c15331677e6ebf0b 23 0 0 0 0) }",
+                "storage": {}
+            },
+            "aaaaaaaaace5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "0x600160015532600255",
+                "storage": {}
+            },
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "1000",
+                "nonce" : 0,
+                "code" : "",
+                "storage": {}
+            }
+        },
+        "transaction" : {
+            "nonce" : "0",
+            "gasPrice" : "1",
+            "gasLimit" : "850",
+            "to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
+            "value" : "10",
+            "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+            "data" : ""
+        }
+    }
+}

test/state.cpp

@@ -122,6 +122,11 @@ BOOST_AUTO_TEST_CASE(stPreCompiledContracts)
 	dev::test::executeTests("stPreCompiledContracts", "/StateTests", dev::test::doStateTests);
 }
 
+BOOST_AUTO_TEST_CASE(stSpecialTest)
+{
+	dev::test::executeTests("stSpecialTest", "/StateTests", dev::test::doStateTests);
+}
+
 BOOST_AUTO_TEST_CASE(stCreateTest)
 {
 	for (int i = 1; i < boost::unit_test::framework::master_test_suite().argc; ++i)

test/vm.cpp

@@ -120,6 +120,41 @@ void FakeExtVM::importEnv(mObject& _o)
 	currentBlock.coinbaseAddress = Address(_o["currentCoinbase"].get_str());
 }
 
+mObject FakeExtVM::exportLog()
+{
+	mObject ret;
+	for (LogEntry const& l: sub.logs)
+	{
+		mObject o;
+		o["address"] = toString(l.address);
+		mArray topics;
+		for (auto const& t: l.topics)
+			topics.push_back(toString(t));
+		o["topics"] = topics;
+		o["data"] = "0x" + toHex(l.data);
+		ret[toString(l.bloom())] = o;
+	}
+	return ret;
+}
+
+void FakeExtVM::importLog(mObject& _o)
+{
+	for (auto const& l: _o)
+	{
+		mObject o = l.second.get_obj();
+		// cant use BOOST_REQUIRE, because this function is used outside boost test (createRandomTest)
+		assert(o.count("address") > 0);
+		assert(o.count("topics") > 0);
+		assert(o.count("data") > 0);
+		LogEntry log;
+		log.address = Address(o["address"].get_str());
+		for (auto const& t: o["topics"].get_array())
+			log.topics.insert(h256(t.get_str()));
+		log.data = importData(o);
+		sub.logs.push_back(log);
+	}
+}
+
 mObject FakeExtVM::exportState()
 {
 	mObject ret;
@@ -312,7 +347,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
 		bool vmExceptionOccured = false;
 		try
 		{
-			output = vm->go(fev, fev.simpleTrace()).toVector();
+			output = vm->go(fev, fev.simpleTrace()).toBytes();
 			gas = vm->gas();
 		}
 		catch (VMException const& _e)
@@ -371,6 +406,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
 				o["callcreates"] = fev.exportCallCreates();
 				o["out"] = "0x" + toHex(output);
 				fev.push(o, "gas", gas);
+				o["logs"] = mValue(fev.exportLog());
 			}
 		}
 		else
@@ -379,14 +415,16 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
 			{
 				BOOST_CHECK(!vmExceptionOccured);
 
-			BOOST_REQUIRE(o.count("post") > 0);
-			BOOST_REQUIRE(o.count("callcreates") > 0);
-			BOOST_REQUIRE(o.count("out") > 0);
-			BOOST_REQUIRE(o.count("gas") > 0);
+				BOOST_REQUIRE(o.count("post") > 0);
+				BOOST_REQUIRE(o.count("callcreates") > 0);
+				BOOST_REQUIRE(o.count("out") > 0);
+				BOOST_REQUIRE(o.count("gas") > 0);
+				BOOST_REQUIRE(o.count("logs") > 0);
 
-			dev::test::FakeExtVM test;
-			test.importState(o["post"].get_obj());
-			test.importCallCreates(o["callcreates"].get_array());
+				dev::test::FakeExtVM test;
+				test.importState(o["post"].get_obj());
+				test.importCallCreates(o["callcreates"].get_array());
+				test.importLog(o["logs"].get_obj());
 
 			checkOutput(output, o);
 
@@ -412,9 +450,11 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
 				}
 			}
 
-			checkAddresses<std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes> > >(test.addresses, fev.addresses);
-			BOOST_CHECK(test.callcreates == fev.callcreates);
-		}
+				checkAddresses<std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes> > >(test.addresses, fev.addresses);
+				BOOST_CHECK(test.callcreates == fev.callcreates);
+
+				checkLog(fev.sub.logs, test.sub.logs);
+			}
 			else	// Exception expected
 				BOOST_CHECK(vmExceptionOccured);
 		}
@@ -465,6 +505,11 @@ BOOST_AUTO_TEST_CASE(vmPushDupSwapTest)
 	dev::test::executeTests("vmPushDupSwapTest", "/VMTests", dev::test::doVMTests);
 }
 
+BOOST_AUTO_TEST_CASE(vmLogTest)
+{
+	dev::test::executeTests("vmLogTest", "/VMTests", dev::test::doVMTests);
+}
+
 BOOST_AUTO_TEST_CASE(vmRandom)
 {
 	string testPath = getTestPath();

test/vm.h

@@ -66,6 +66,8 @@ public:
 	u256 doPosts();
 	json_spirit::mObject exportEnv();
 	void importEnv(json_spirit::mObject& _o);
+	json_spirit::mObject exportLog();
+	void importLog(json_spirit::mObject& _o);
 	json_spirit::mObject exportState();
 	void importState(json_spirit::mObject& _object);
 	json_spirit::mObject exportExec();

test/vmIOandFlowOperationsTestFiller.json

@@ -55,7 +55,7 @@
         }
     },
 
-    "dupAt51doesNotExistAnymore": {
+    "dupAt51becameMload": {
         "env" : {
         "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
         "currentNumber" : "0",
@@ -83,7 +83,7 @@
         }
     },
 
-    "swapAt52doesNotExistAnymore": {
+    "swapAt52becameMstore": {
         "env" : {
         "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
         "currentNumber" : "0",

test/vmPushDupSwapTestFiller.json

@@ -924,7 +924,7 @@
         }
     },
 
-    "push32error": {
+    "push32AndSuicide": {
         "env" : {
             "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
             "currentNumber" : "0",
@@ -952,6 +952,35 @@
         }
     },
 
+
+    "push32FillUpInputWithZerosAtTheEnd": {
+        "env" : {
+            "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+            "currentNumber" : "0",
+            "currentGasLimit" : "1000000",
+            "currentDifficulty" : "256",
+            "currentTimestamp" : 1,
+            "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+            "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "0x7fff10112233445566778899aabbccddeeff00112233445566778899aabbccdd",
+                "storage": {}
+            }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "10000"
+        }
+    },
+
     "dup1": {
         "env" : {
             "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",