Merge remote-tracking branch 'upstream/develop' into vm

alethzero/MainWin.cpp

@@ -1626,7 +1626,7 @@ void Main::on_data_textChanged()
 			catch (dev::Exception const& exception)
 			{
 				ostringstream error;
-				solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", compiler.getScanner());
+				solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", compiler);
 				solidity = "<h4>Solidity</h4><pre>" + QString::fromStdString(error.str()).toHtmlEscaped() + "</pre>";
 			}
 			catch (...)

libdevcrypto/CryptoPP.cpp

@@ -52,6 +52,12 @@ void Secp256k1::decrypt(Secret const& _k, bytes& io_text)
 {
 	CryptoPP::ECIES<CryptoPP::ECP>::Decryptor d;
 	initializeDLScheme(_k, d);
+
+	if (!io_text.size())
+	{
+		io_text.resize(1);
+		io_text[0] = 0;
+	}
 	
 	size_t clen = io_text.size();
 	bytes plain;

libp2p/Host.cpp

@@ -447,26 +447,31 @@ void Host::connect(std::shared_ptr<Node> const& _n)
 	_n->failedAttempts++;
 	m_ready -= _n->index;
 	bi::tcp::socket* s = new bi::tcp::socket(m_ioService);
-	s->async_connect(_n->address, [=](boost::system::error_code const& ec)
+
-	{
+	auto n = node(_n->id);
-		if (ec)
+	if (n)
-		{
+		s->async_connect(_n->address, [=](boost::system::error_code const& ec)
-			clog(NetConnect) << "Connection refused to node" << _n->id.abridged() << "@" << _n->address << "(" << ec.message() << ")";
-			_n->lastDisconnect = TCPError;
-			_n->lastAttempted = std::chrono::system_clock::now();
-			m_ready += _n->index;
-		}
-		else
 		{
-			clog(NetConnect) << "Connected to" << _n->id.abridged() << "@" << _n->address;
+			if (ec)
-			_n->lastConnected = std::chrono::system_clock::now();
+			{
-			auto p = make_shared<Session>(this, std::move(*s), node(_n->id), true);		// true because we don't care about ids matched for now. Once we have permenant IDs this will matter a lot more and we can institute a safer mechanism.
+				clog(NetConnect) << "Connection refused to node" << _n->id.abridged() << "@" << _n->address << "(" << ec.message() << ")";
-			p->start();
+				_n->lastDisconnect = TCPError;
-		}
+				_n->lastAttempted = std::chrono::system_clock::now();
-		delete s;
+				m_ready += _n->index;
-		Guard l(x_pendingNodeConns);
+			}
-		m_pendingNodeConns.erase(nptr);
+			else
-	});
+			{
+				clog(NetConnect) << "Connected to" << _n->id.abridged() << "@" << _n->address;
+				_n->lastConnected = std::chrono::system_clock::now();
+				auto p = make_shared<Session>(this, std::move(*s), n, true);		// true because we don't care about ids matched for now. Once we have permenant IDs this will matter a lot more and we can institute a safer mechanism.
+				p->start();
+			}
+			delete s;
+			Guard l(x_pendingNodeConns);
+			m_pendingNodeConns.erase(nptr);
+		});
+	else
+		clog(NetWarn) << "Trying to connect to node not in node table.";
 }
 
 bool Host::havePeer(NodeId _id) const

libsolidity/AST.cpp

@@ -25,6 +25,7 @@
 #include <libsolidity/AST.h>
 #include <libsolidity/ASTVisitor.h>
 #include <libsolidity/Exceptions.h>
+#include <libsolidity/AST_accept.h>
 
 using namespace std;
 
@@ -33,38 +34,34 @@ namespace dev
 namespace solidity
 {
 
-void ContractDefinition::accept(ASTVisitor& _visitor)
+TypeError ASTNode::createTypeError(string const& _description) const
 {
-	if (_visitor.visit(*this))
+	return TypeError() << errinfo_sourceLocation(getLocation()) << errinfo_comment(_description);
-	{
-		listAccept(m_definedStructs, _visitor);
-		listAccept(m_stateVariables, _visitor);
-		listAccept(m_definedFunctions, _visitor);
-	}
-	_visitor.endVisit(*this);
 }
 
-void StructDefinition::accept(ASTVisitor& _visitor)
+vector<FunctionDefinition const*> ContractDefinition::getInterfaceFunctions() const
 {
-	if (_visitor.visit(*this))
+	vector<FunctionDefinition const*> exportedFunctions;
-		listAccept(m_members, _visitor);
+	for (ASTPointer<FunctionDefinition> const& f: m_definedFunctions)
-	_visitor.endVisit(*this);
+		if (f->isPublic() && f->getName() != getName())
-}
+			exportedFunctions.push_back(f.get());
+	auto compareNames = [](FunctionDefinition const* _a, FunctionDefinition const* _b)
+	{
+		return _a->getName().compare(_b->getName()) < 0;
+	};
 
-void StructDefinition::checkValidityOfMembers()
+	sort(exportedFunctions.begin(), exportedFunctions.end(), compareNames);
-{
+	return exportedFunctions;
-	checkMemberTypes();
-	checkRecursion();
 }
 
-void StructDefinition::checkMemberTypes()
+void StructDefinition::checkMemberTypes() const
 {
 	for (ASTPointer<VariableDeclaration> const& member: getMembers())
 		if (!member->getType()->canBeStored())
 			BOOST_THROW_EXCEPTION(member->createTypeError("Type cannot be used in struct."));
 }
 
-void StructDefinition::checkRecursion()
+void StructDefinition::checkRecursion() const
 {
 	set<StructDefinition const*> definitionsSeen;
 	vector<StructDefinition const*> queue = {this};
@@ -79,239 +76,12 @@ void StructDefinition::checkRecursion()
 		for (ASTPointer<VariableDeclaration> const& member: def->getMembers())
 			if (member->getType()->getCategory() == Type::Category::STRUCT)
 			{
-				UserDefinedTypeName const& typeName = dynamic_cast<UserDefinedTypeName&>(*member->getTypeName());
+				UserDefinedTypeName const& typeName = dynamic_cast<UserDefinedTypeName const&>(*member->getTypeName());
 				queue.push_back(&dynamic_cast<StructDefinition const&>(*typeName.getReferencedDeclaration()));
 			}
 	}
 }
 
-void ParameterList::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		listAccept(m_parameters, _visitor);
-	_visitor.endVisit(*this);
-}
-
-void FunctionDefinition::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_parameters->accept(_visitor);
-		if (m_returnParameters)
-			m_returnParameters->accept(_visitor);
-		m_body->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void VariableDeclaration::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		if (m_typeName)
-			m_typeName->accept(_visitor);
-	_visitor.endVisit(*this);
-}
-
-void TypeName::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void ElementaryTypeName::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void UserDefinedTypeName::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void Mapping::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_keyType->accept(_visitor);
-		m_valueType->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void Statement::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void Block::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		listAccept(m_statements, _visitor);
-	_visitor.endVisit(*this);
-}
-
-void IfStatement::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_condition->accept(_visitor);
-		m_trueBody->accept(_visitor);
-		if (m_falseBody)
-			m_falseBody->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void BreakableStatement::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void WhileStatement::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_condition->accept(_visitor);
-		m_body->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void Continue::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void Break::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void Return::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		if (m_expression)
-			m_expression->accept(_visitor);
-	_visitor.endVisit(*this);
-}
-
-void ExpressionStatement::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		if (m_expression)
-			m_expression->accept(_visitor);
-	_visitor.endVisit(*this);
-}
-
-void VariableDefinition::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_variable->accept(_visitor);
-		if (m_value)
-			m_value->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void Assignment::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_leftHandSide->accept(_visitor);
-		m_rightHandSide->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void UnaryOperation::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		m_subExpression->accept(_visitor);
-	_visitor.endVisit(*this);
-}
-
-void BinaryOperation::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_left->accept(_visitor);
-		m_right->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void FunctionCall::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_expression->accept(_visitor);
-		listAccept(m_arguments, _visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void MemberAccess::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-		m_expression->accept(_visitor);
-	_visitor.endVisit(*this);
-}
-
-void IndexAccess::accept(ASTVisitor& _visitor)
-{
-	if (_visitor.visit(*this))
-	{
-		m_base->accept(_visitor);
-		m_index->accept(_visitor);
-	}
-	_visitor.endVisit(*this);
-}
-
-void Identifier::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void ElementaryTypeNameExpression::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void Literal::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-TypeError ASTNode::createTypeError(string const& _description) const
-{
-	return TypeError() << errinfo_sourceLocation(getLocation()) << errinfo_comment(_description);
-}
-
-vector<FunctionDefinition const*> ContractDefinition::getInterfaceFunctions() const
-{
-	vector<FunctionDefinition const*> exportedFunctions;
-	for (ASTPointer<FunctionDefinition> const& f: m_definedFunctions)
-		if (f->isPublic() && f->getName() != getName())
-			exportedFunctions.push_back(f.get());
-	auto compareNames = [](FunctionDefinition const* _a, FunctionDefinition const* _b)
-	{
-		return _a->getName().compare(_b->getName()) < 0;
-	};
-
-	sort(exportedFunctions.begin(), exportedFunctions.end(), compareNames);
-	return exportedFunctions;
-}
-
 void FunctionDefinition::checkTypeRequirements()
 {
 	for (ASTPointer<VariableDeclaration> const& var: getParameters() + getReturnParameters())
@@ -519,7 +289,7 @@ void Identifier::checkTypeRequirements()
 	if (asserts(m_referencedDeclaration))
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Identifier not resolved."));
 
-	VariableDeclaration* variable = dynamic_cast<VariableDeclaration*>(m_referencedDeclaration);
+	VariableDeclaration const* variable = dynamic_cast<VariableDeclaration const*>(m_referencedDeclaration);
 	if (variable)
 	{
 		if (!variable->getType())
@@ -529,29 +299,29 @@ void Identifier::checkTypeRequirements()
 		return;
 	}
 	//@todo can we unify these with TypeName::toType()?
-	StructDefinition* structDef = dynamic_cast<StructDefinition*>(m_referencedDeclaration);
+	StructDefinition const* structDef = dynamic_cast<StructDefinition const*>(m_referencedDeclaration);
 	if (structDef)
 	{
 		// note that we do not have a struct type here
-		m_type = make_shared<TypeType>(make_shared<StructType>(*structDef));
+		m_type = make_shared<TypeType const>(make_shared<StructType const>(*structDef));
 		return;
 	}
-	FunctionDefinition* functionDef = dynamic_cast<FunctionDefinition*>(m_referencedDeclaration);
+	FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(m_referencedDeclaration);
 	if (functionDef)
 	{
 		// a function reference is not a TypeType, because calling a TypeType converts to the type.
 		// Calling a function (e.g. function(12), otherContract.function(34)) does not do a type
 		// conversion.
-		m_type = make_shared<FunctionType>(*functionDef);
+		m_type = make_shared<FunctionType const>(*functionDef);
 		return;
 	}
-	ContractDefinition* contractDef = dynamic_cast<ContractDefinition*>(m_referencedDeclaration);
+	ContractDefinition const* contractDef = dynamic_cast<ContractDefinition const*>(m_referencedDeclaration);
 	if (contractDef)
 	{
-		m_type = make_shared<TypeType>(make_shared<ContractType>(*contractDef));
+		m_type = make_shared<TypeType const>(make_shared<ContractType>(*contractDef));
 		return;
 	}
-	MagicVariableDeclaration* magicVariable = dynamic_cast<MagicVariableDeclaration*>(m_referencedDeclaration);
+	MagicVariableDeclaration const* magicVariable = dynamic_cast<MagicVariableDeclaration const*>(m_referencedDeclaration);
 	if (magicVariable)
 	{
 		m_type = magicVariable->getType();
@@ -562,7 +332,7 @@ void Identifier::checkTypeRequirements()
 
 void ElementaryTypeNameExpression::checkTypeRequirements()
 {
-	m_type = make_shared<TypeType>(Type::fromElementaryTypeName(m_typeToken));
+	m_type = make_shared<TypeType const>(Type::fromElementaryTypeName(m_typeToken));
 }
 
 void Literal::checkTypeRequirements()

libsolidity/AST.h

@@ -39,6 +39,7 @@ namespace solidity
 {
 
 class ASTVisitor;
+class ASTConstVisitor;
 
 
 /**
@@ -54,12 +55,19 @@ public:
 	virtual ~ASTNode() {}
 
 	virtual void accept(ASTVisitor& _visitor) = 0;
+	virtual void accept(ASTConstVisitor& _visitor) const = 0;
 	template <class T>
 	static void listAccept(std::vector<ASTPointer<T>>& _list, ASTVisitor& _visitor)
 	{
 		for (ASTPointer<T>& element: _list)
 			element->accept(_visitor);
 	}
+	template <class T>
+	static void listAccept(std::vector<ASTPointer<T>> const& _list, ASTConstVisitor& _visitor)
+	{
+		for (ASTPointer<T> const& element: _list)
+			element->accept(_visitor);
+	}
 
 	/// Returns the source code location of this node.
 	Location const& getLocation() const { return m_location; }
@@ -79,6 +87,44 @@ private:
 	Location m_location;
 };
 
+/**
+ * Source unit containing import directives and contract definitions.
+ */
+class SourceUnit: public ASTNode
+{
+public:
+	SourceUnit(Location const& _location, std::vector<ASTPointer<ASTNode>> const& _nodes):
+		ASTNode(_location), m_nodes(_nodes) {}
+
+	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+
+	std::vector<ASTPointer<ASTNode>> getNodes() const { return m_nodes; }
+
+private:
+	std::vector<ASTPointer<ASTNode>> m_nodes;
+};
+
+/**
+ * Import directive for referencing other files / source objects.
+ * Example: import "abc.sol"
+ * Source objects are identified by a string which can be a file name but does not have to be.
+ */
+class ImportDirective: public ASTNode
+{
+public:
+	ImportDirective(Location const& _location, ASTPointer<ASTString> const& _identifier):
+		ASTNode(_location), m_identifier(_identifier) {}
+
+	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+
+	ASTString const& getIdentifier() const { return *m_identifier; }
+
+private:
+	ASTPointer<ASTString> m_identifier;
+};
+
 /**
  * Abstract AST class for a declaration (contract, function, struct, variable).
  */
@@ -86,18 +132,18 @@ class Declaration: public ASTNode
 {
 public:
 	Declaration(Location const& _location, ASTPointer<ASTString> const& _name):
-		ASTNode(_location), m_name(_name) {}
+		ASTNode(_location), m_name(_name), m_scope(nullptr) {}
 
 	/// @returns the declared name.
 	ASTString const& getName() const { return *m_name; }
 	/// @returns the scope this declaration resides in. Can be nullptr if it is the global scope.
 	/// Available only after name and type resolution step.
-	Declaration* getScope() const { return m_scope; }
+	Declaration const* getScope() const { return m_scope; }
-	void setScope(Declaration* const& _scope) { m_scope = _scope; }
+	void setScope(Declaration const* _scope) { m_scope = _scope; }
 
 private:
 	ASTPointer<ASTString> m_name;
-	Declaration* m_scope;
+	Declaration const* m_scope;
 };
 
 /**
@@ -120,6 +166,7 @@ public:
 	{}
 
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	std::vector<ASTPointer<StructDefinition>> const& getDefinedStructs() const { return m_definedStructs; }
 	std::vector<ASTPointer<VariableDeclaration>> const& getStateVariables() const { return m_stateVariables; }
@@ -142,16 +189,17 @@ public:
 					 std::vector<ASTPointer<VariableDeclaration>> const& _members):
 		Declaration(_location, _name), m_members(_members) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	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();
+	void checkValidityOfMembers() const;
 
 private:
-	void checkMemberTypes();
+	void checkMemberTypes() const;
-	void checkRecursion();
+	void checkRecursion() const;
 
 	std::vector<ASTPointer<VariableDeclaration>> m_members;
 };
@@ -168,6 +216,7 @@ public:
 				  std::vector<ASTPointer<VariableDeclaration>> const& _parameters):
 		ASTNode(_location), m_parameters(_parameters) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	std::vector<ASTPointer<VariableDeclaration>> const& getParameters() const { return m_parameters; }
 
@@ -194,14 +243,15 @@ public:
 	{}
 
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	bool isPublic() const { return m_isPublic; }
 	bool isDeclaredConst() const { return m_isDeclaredConst; }
 	std::vector<ASTPointer<VariableDeclaration>> const& getParameters() const { return m_parameters->getParameters(); }
-	ParameterList& getParameterList() { return *m_parameters; }
+	ParameterList const& getParameterList() const { return *m_parameters; }
 	std::vector<ASTPointer<VariableDeclaration>> const& getReturnParameters() const { return m_returnParameters->getParameters(); }
 	ASTPointer<ParameterList> const& getReturnParameterList() const { return m_returnParameters; }
-	Block& getBody() { return *m_body; }
+	Block const& getBody() const { return *m_body; }
 	/// @return A shared pointer of an ASTString.
 	/// Can contain a nullptr in which case indicates absence of documentation
 	ASTPointer<ASTString> const& getDocumentation() const { return m_documentation; }
@@ -234,15 +284,16 @@ public:
 						ASTPointer<ASTString> const& _name):
 		Declaration(_location, _name), m_typeName(_type) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
-	TypeName* getTypeName() const { return m_typeName.get(); }
+	TypeName const* getTypeName() const { return m_typeName.get(); }
 
 	/// Returns the declared or inferred type. Can be an empty pointer if no type was explicitly
 	/// declared and there is no assignment to the variable that fixes the type.
 	std::shared_ptr<Type const> const& getType() const { return m_type; }
 	void setType(std::shared_ptr<Type const> const& _type) { m_type = _type; }
 
-	bool isLocalVariable() const { return !!dynamic_cast<FunctionDefinition*>(getScope()); }
+	bool isLocalVariable() const { return !!dynamic_cast<FunctionDefinition const*>(getScope()); }
 
 private:
 	ASTPointer<TypeName> m_typeName; ///< can be empty ("var")
@@ -261,6 +312,8 @@ public:
 		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.")); }
+	virtual void accept(ASTConstVisitor&) const override { BOOST_THROW_EXCEPTION(InternalCompilerError()
+							<< errinfo_comment("MagicVariableDeclaration used inside real AST.")); }
 
 	std::shared_ptr<Type const> const& getType() const { return m_type; }
 
@@ -279,11 +332,12 @@ class TypeName: public ASTNode
 public:
 	explicit TypeName(Location const& _location): ASTNode(_location) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	/// 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;
+	virtual std::shared_ptr<Type const> toType() const = 0;
 };
 
 /**
@@ -299,7 +353,8 @@ public:
 		if (asserts(Token::isElementaryTypeName(_type))) BOOST_THROW_EXCEPTION(InternalCompilerError());
 	}
 	virtual void accept(ASTVisitor& _visitor) override;
-	virtual std::shared_ptr<Type> toType() const override { return Type::fromElementaryTypeName(m_type); }
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+	virtual std::shared_ptr<Type const> toType() const override { return Type::fromElementaryTypeName(m_type); }
 
 	Token::Value getTypeName() const { return m_type; }
 
@@ -314,18 +369,19 @@ class UserDefinedTypeName: public TypeName
 {
 public:
 	UserDefinedTypeName(Location const& _location, ASTPointer<ASTString> const& _name):
-		TypeName(_location), m_name(_name) {}
+		TypeName(_location), m_name(_name), m_referencedDeclaration(nullptr) {}
 	virtual void accept(ASTVisitor& _visitor) override;
-	virtual std::shared_ptr<Type> toType() const override { return Type::fromUserDefinedTypeName(*this); }
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+	virtual std::shared_ptr<Type const> toType() const override { return Type::fromUserDefinedTypeName(*this); }
 
 	ASTString const& getName() const { return *m_name; }
-	void setReferencedDeclaration(Declaration& _referencedDeclaration) { m_referencedDeclaration = &_referencedDeclaration; }
+	void setReferencedDeclaration(Declaration const& _referencedDeclaration) { m_referencedDeclaration = &_referencedDeclaration; }
 	Declaration const* getReferencedDeclaration() const { return m_referencedDeclaration; }
 
 private:
 	ASTPointer<ASTString> m_name;
 
-	Declaration* m_referencedDeclaration;
+	Declaration const* m_referencedDeclaration;
 };
 
 /**
@@ -338,7 +394,8 @@ public:
 			ASTPointer<TypeName> const& _valueType):
 		TypeName(_location), m_keyType(_keyType), m_valueType(_valueType) {}
 	virtual void accept(ASTVisitor& _visitor) override;
-	virtual std::shared_ptr<Type> toType() const override { return Type::fromMapping(*this); }
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+	virtual std::shared_ptr<Type const> toType() const override { return Type::fromMapping(*this); }
 
 	ElementaryTypeName const& getKeyType() const { return *m_keyType; }
 	TypeName const& getValueType() const { return *m_valueType; }
@@ -361,7 +418,6 @@ class Statement: public ASTNode
 {
 public:
 	explicit Statement(Location const& _location): ASTNode(_location) {}
-	virtual void accept(ASTVisitor& _visitor) override;
 
 	/// Check all type requirements, throws exception if some requirement is not met.
 	/// This includes checking that operators are applicable to their arguments but also that
@@ -378,6 +434,7 @@ public:
 	Block(Location const& _location, std::vector<ASTPointer<Statement>> const& _statements):
 		Statement(_location), m_statements(_statements) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	virtual void checkTypeRequirements() override;
 
@@ -397,12 +454,13 @@ public:
 		Statement(_location),
 		m_condition(_condition), m_trueBody(_trueBody), m_falseBody(_falseBody) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getCondition() const { return *m_condition; }
+	Expression const& getCondition() const { return *m_condition; }
-	Statement& getTrueStatement() const { return *m_trueBody; }
+	Statement const& getTrueStatement() const { return *m_trueBody; }
 	/// @returns the "else" part of the if statement or nullptr if there is no "else" part. 
-	Statement* getFalseStatement() const { return m_falseBody.get(); }
+	Statement const* getFalseStatement() const { return m_falseBody.get(); }
 
 private:
 	ASTPointer<Expression> m_condition;
@@ -411,13 +469,12 @@ private:
 };
 
 /**
- * Statement in which a break statement is legal.
+ * Statement in which a break statement is legal (abstract class).
  */
 class BreakableStatement: public Statement
 {
 public:
 	BreakableStatement(Location const& _location): Statement(_location) {}
-	virtual void accept(ASTVisitor& _visitor) override;
 };
 
 class WhileStatement: public BreakableStatement
@@ -427,10 +484,11 @@ public:
 				   ASTPointer<Statement> const& _body):
 		BreakableStatement(_location), m_condition(_condition), m_body(_body) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getCondition() const { return *m_condition; }
+	Expression const& getCondition() const { return *m_condition; }
-	Statement& getBody() const { return *m_body; }
+	Statement const& getBody() const { return *m_body; }
 
 private:
 	ASTPointer<Expression> m_condition;
@@ -442,6 +500,7 @@ class Continue: public Statement
 public:
 	Continue(Location const& _location): Statement(_location) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override {}
 };
 
@@ -450,6 +509,7 @@ class Break: public Statement
 public:
 	Break(Location const& _location): Statement(_location) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override {}
 };
 
@@ -457,8 +517,9 @@ class Return: public Statement
 {
 public:
 	Return(Location const& _location, ASTPointer<Expression> _expression):
-		Statement(_location), m_expression(_expression) {}
+		Statement(_location), m_expression(_expression), m_returnParameters(nullptr) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	void setFunctionReturnParameters(ParameterList& _parameters) { m_returnParameters = &_parameters; }
@@ -468,7 +529,7 @@ public:
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
 		return *m_returnParameters;
 	}
-	Expression* getExpression() const { return m_expression.get(); }
+	Expression const* getExpression() const { return m_expression.get(); }
 
 private:
 	ASTPointer<Expression> m_expression; ///< value to return, optional
@@ -489,10 +550,11 @@ public:
 					   ASTPointer<Expression> _value):
 		Statement(_location), m_variable(_variable), m_value(_value) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	VariableDeclaration const& getDeclaration() const { return *m_variable; }
-	Expression* getExpression() const { return m_value.get(); }
+	Expression const* getExpression() const { return m_value.get(); }
 
 private:
 	ASTPointer<VariableDeclaration> m_variable;
@@ -508,9 +570,10 @@ public:
 	ExpressionStatement(Location const& _location, ASTPointer<Expression> _expression):
 		Statement(_location), m_expression(_expression) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getExpression() const { return *m_expression; }
+	Expression const& getExpression() const { return *m_expression; }
 
 private:
 	ASTPointer<Expression> m_expression;
@@ -572,11 +635,12 @@ public:
 		if (asserts(Token::isAssignmentOp(_assignmentOperator))) BOOST_THROW_EXCEPTION(InternalCompilerError());
 	}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getLeftHandSide() const { return *m_leftHandSide; }
+	Expression const& getLeftHandSide() const { return *m_leftHandSide; }
 	Token::Value getAssignmentOperator() const { return m_assigmentOperator; }
-	Expression& getRightHandSide() const { return *m_rightHandSide; }
+	Expression const& getRightHandSide() const { return *m_rightHandSide; }
 
 private:
 	ASTPointer<Expression> m_leftHandSide;
@@ -599,11 +663,12 @@ public:
 		if (asserts(Token::isUnaryOp(_operator))) BOOST_THROW_EXCEPTION(InternalCompilerError());
 	}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	Token::Value getOperator() const { return m_operator; }
 	bool isPrefixOperation() const { return m_isPrefix; }
-	Expression& getSubExpression() const { return *m_subExpression; }
+	Expression const& getSubExpression() const { return *m_subExpression; }
 
 private:
 	Token::Value m_operator;
@@ -625,10 +690,11 @@ public:
 		if (asserts(Token::isBinaryOp(_operator) || Token::isCompareOp(_operator))) BOOST_THROW_EXCEPTION(InternalCompilerError());
 	}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getLeftExpression() const { return *m_left; }
+	Expression const& getLeftExpression() const { return *m_left; }
-	Expression& getRightExpression() const { return *m_right; }
+	Expression const& getRightExpression() const { return *m_right; }
 	Token::Value getOperator() const { return m_operator; }
 	Type const& getCommonType() const { return *m_commonType; }
 
@@ -652,10 +718,11 @@ public:
 				 std::vector<ASTPointer<Expression>> const& _arguments):
 		Expression(_location), m_expression(_expression), m_arguments(_arguments) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getExpression() const { return *m_expression; }
+	Expression const& getExpression() const { return *m_expression; }
-	std::vector<ASTPointer<Expression>> const& getArguments() const { return m_arguments; }
+	std::vector<ASTPointer<Expression const>> getArguments() const { return {m_arguments.begin(), m_arguments.end()}; }
 
 	/// Returns true if this is not an actual function call, but an explicit type conversion
 	/// or constructor call.
@@ -676,7 +743,8 @@ public:
 				 ASTPointer<ASTString> const& _memberName):
 		Expression(_location), m_expression(_expression), m_memberName(_memberName) {}
 	virtual void accept(ASTVisitor& _visitor) override;
-	Expression& getExpression() const { return *m_expression; }
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+	Expression const& getExpression() const { return *m_expression; }
 	ASTString const& getMemberName() const { return *m_memberName; }
 	virtual void checkTypeRequirements() override;
 
@@ -695,10 +763,11 @@ public:
 				ASTPointer<Expression> const& _index):
 		Expression(_location), m_base(_base), m_index(_index) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
-	Expression& getBaseExpression() const { return *m_base; }
+	Expression const& getBaseExpression() const { return *m_base; }
-	Expression& getIndexExpression() const { return *m_index; }
+	Expression const& getIndexExpression() const { return *m_index; }
 
 private:
 	ASTPointer<Expression> m_base;
@@ -722,20 +791,21 @@ class Identifier: public PrimaryExpression
 {
 public:
 	Identifier(Location const& _location, ASTPointer<ASTString> const& _name):
-		PrimaryExpression(_location), m_name(_name) {}
+		PrimaryExpression(_location), m_name(_name), m_referencedDeclaration(nullptr) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	ASTString const& getName() const { return *m_name; }
 
-	void setReferencedDeclaration(Declaration& _referencedDeclaration) { m_referencedDeclaration = &_referencedDeclaration; }
+	void setReferencedDeclaration(Declaration const& _referencedDeclaration) { m_referencedDeclaration = &_referencedDeclaration; }
-	Declaration* getReferencedDeclaration() { return m_referencedDeclaration; }
+	Declaration const* getReferencedDeclaration() const { return m_referencedDeclaration; }
 
 private:
 	ASTPointer<ASTString> m_name;
 
 	/// Declaration the name refers to.
-	Declaration* m_referencedDeclaration;
+	Declaration const* m_referencedDeclaration;
 };
 
 /**
@@ -752,6 +822,7 @@ public:
 		if (asserts(Token::isElementaryTypeName(_typeToken))) BOOST_THROW_EXCEPTION(InternalCompilerError());
 	}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	Token::Value getTypeToken() const { return m_typeToken; }
@@ -769,6 +840,7 @@ public:
 	Literal(Location const& _location, Token::Value _token, ASTPointer<ASTString> const& _value):
 		PrimaryExpression(_location), m_token(_token), m_value(_value) {}
 	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	Token::Value getToken() const { return m_token; }

libsolidity/ASTForward.h

@@ -34,6 +34,8 @@ namespace solidity
 {
 
 class ASTNode;
+class SourceUnit;
+class ImportDirective;
 class Declaration;
 class ContractDefinition;
 class StructDefinition;

libsolidity/ASTPrinter.cpp

@@ -30,7 +30,7 @@ namespace dev
 namespace solidity
 {
 
-ASTPrinter::ASTPrinter(ASTNode& _ast, string const& _source):
+ASTPrinter::ASTPrinter(ASTNode const& _ast, string const& _source):
 	m_indentation(0), m_source(_source), m_ast(&_ast)
 {
 }
@@ -43,28 +43,35 @@ void ASTPrinter::print(ostream& _stream)
 }
 
 
-bool ASTPrinter::visit(ContractDefinition& _node)
+bool ASTPrinter::visit(ImportDirective const& _node)
+{
+	writeLine("ImportDirective \"" + _node.getIdentifier() + "\"");
+	printSourcePart(_node);
+	return goDeeper();
+}
+
+bool ASTPrinter::visit(ContractDefinition const& _node)
 {
 	writeLine("ContractDefinition \"" + _node.getName() + "\"");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(StructDefinition& _node)
+bool ASTPrinter::visit(StructDefinition const& _node)
 {
 	writeLine("StructDefinition \"" + _node.getName() + "\"");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(ParameterList& _node)
+bool ASTPrinter::visit(ParameterList const& _node)
 {
 	writeLine("ParameterList");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(FunctionDefinition& _node)
+bool ASTPrinter::visit(FunctionDefinition const& _node)
 {
 	writeLine("FunctionDefinition \"" + _node.getName() + "\"" +
 			  (_node.isPublic() ? " - public" : "") +
@@ -73,112 +80,112 @@ bool ASTPrinter::visit(FunctionDefinition& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(VariableDeclaration& _node)
+bool ASTPrinter::visit(VariableDeclaration const& _node)
 {
 	writeLine("VariableDeclaration \"" + _node.getName() + "\"");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(TypeName& _node)
+bool ASTPrinter::visit(TypeName const& _node)
 {
 	writeLine("TypeName");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(ElementaryTypeName& _node)
+bool ASTPrinter::visit(ElementaryTypeName const& _node)
 {
 	writeLine(string("ElementaryTypeName ") + Token::toString(_node.getTypeName()));
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(UserDefinedTypeName& _node)
+bool ASTPrinter::visit(UserDefinedTypeName const& _node)
 {
 	writeLine("UserDefinedTypeName \"" + _node.getName() + "\"");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Mapping& _node)
+bool ASTPrinter::visit(Mapping const& _node)
 {
 	writeLine("Mapping");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Statement& _node)
+bool ASTPrinter::visit(Statement const& _node)
 {
 	writeLine("Statement");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Block& _node)
+bool ASTPrinter::visit(Block const& _node)
 {
 	writeLine("Block");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(IfStatement& _node)
+bool ASTPrinter::visit(IfStatement const& _node)
 {
 	writeLine("IfStatement");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(BreakableStatement& _node)
+bool ASTPrinter::visit(BreakableStatement const& _node)
 {
 	writeLine("BreakableStatement");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(WhileStatement& _node)
+bool ASTPrinter::visit(WhileStatement const& _node)
 {
 	writeLine("WhileStatement");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Continue& _node)
+bool ASTPrinter::visit(Continue const& _node)
 {
 	writeLine("Continue");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Break& _node)
+bool ASTPrinter::visit(Break const& _node)
 {
 	writeLine("Break");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Return& _node)
+bool ASTPrinter::visit(Return const& _node)
 {
 	writeLine("Return");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(VariableDefinition& _node)
+bool ASTPrinter::visit(VariableDefinition const& _node)
 {
 	writeLine("VariableDefinition");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(ExpressionStatement& _node)
+bool ASTPrinter::visit(ExpressionStatement const& _node)
 {
 	writeLine("ExpressionStatement");
 	printSourcePart(_node);
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Expression& _node)
+bool ASTPrinter::visit(Expression const& _node)
 {
 	writeLine("Expression");
 	printType(_node);
@@ -186,7 +193,7 @@ bool ASTPrinter::visit(Expression& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Assignment& _node)
+bool ASTPrinter::visit(Assignment const& _node)
 {
 	writeLine(string("Assignment using operator ") + Token::toString(_node.getAssignmentOperator()));
 	printType(_node);
@@ -194,7 +201,7 @@ bool ASTPrinter::visit(Assignment& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(UnaryOperation& _node)
+bool ASTPrinter::visit(UnaryOperation const& _node)
 {
 	writeLine(string("UnaryOperation (") + (_node.isPrefixOperation() ? "prefix" : "postfix") +
 			  ") " + Token::toString(_node.getOperator()));
@@ -203,7 +210,7 @@ bool ASTPrinter::visit(UnaryOperation& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(BinaryOperation& _node)
+bool ASTPrinter::visit(BinaryOperation const& _node)
 {
 	writeLine(string("BinaryOperation using operator ") + Token::toString(_node.getOperator()));
 	printType(_node);
@@ -211,7 +218,7 @@ bool ASTPrinter::visit(BinaryOperation& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(FunctionCall& _node)
+bool ASTPrinter::visit(FunctionCall const& _node)
 {
 	writeLine("FunctionCall");
 	printType(_node);
@@ -219,7 +226,7 @@ bool ASTPrinter::visit(FunctionCall& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(MemberAccess& _node)
+bool ASTPrinter::visit(MemberAccess const& _node)
 {
 	writeLine("MemberAccess to member " + _node.getMemberName());
 	printType(_node);
@@ -227,7 +234,7 @@ bool ASTPrinter::visit(MemberAccess& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(IndexAccess& _node)
+bool ASTPrinter::visit(IndexAccess const& _node)
 {
 	writeLine("IndexAccess");
 	printType(_node);
@@ -235,7 +242,7 @@ bool ASTPrinter::visit(IndexAccess& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(PrimaryExpression& _node)
+bool ASTPrinter::visit(PrimaryExpression const& _node)
 {
 	writeLine("PrimaryExpression");
 	printType(_node);
@@ -243,7 +250,7 @@ bool ASTPrinter::visit(PrimaryExpression& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Identifier& _node)
+bool ASTPrinter::visit(Identifier const& _node)
 {
 	writeLine(string("Identifier ") + _node.getName());
 	printType(_node);
@@ -251,7 +258,7 @@ bool ASTPrinter::visit(Identifier& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(ElementaryTypeNameExpression& _node)
+bool ASTPrinter::visit(ElementaryTypeNameExpression const& _node)
 {
 	writeLine(string("ElementaryTypeNameExpression ") + Token::toString(_node.getTypeToken()));
 	printType(_node);
@@ -259,7 +266,7 @@ bool ASTPrinter::visit(ElementaryTypeNameExpression& _node)
 	return goDeeper();
 }
 
-bool ASTPrinter::visit(Literal& _node)
+bool ASTPrinter::visit(Literal const& _node)
 {
 	char const* tokenString = Token::toString(_node.getToken());
 	if (!tokenString)
@@ -270,157 +277,157 @@ bool ASTPrinter::visit(Literal& _node)
 	return goDeeper();
 }
 
-void ASTPrinter::endVisit(ASTNode&)
+void ASTPrinter::endVisit(ImportDirective const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(ContractDefinition&)
+void ASTPrinter::endVisit(ContractDefinition const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(StructDefinition&)
+void ASTPrinter::endVisit(StructDefinition const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(ParameterList&)
+void ASTPrinter::endVisit(ParameterList const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(FunctionDefinition&)
+void ASTPrinter::endVisit(FunctionDefinition const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(VariableDeclaration&)
+void ASTPrinter::endVisit(VariableDeclaration const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(TypeName&)
+void ASTPrinter::endVisit(TypeName const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(ElementaryTypeName&)
+void ASTPrinter::endVisit(ElementaryTypeName const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(UserDefinedTypeName&)
+void ASTPrinter::endVisit(UserDefinedTypeName const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Mapping&)
+void ASTPrinter::endVisit(Mapping const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Statement&)
+void ASTPrinter::endVisit(Statement const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Block&)
+void ASTPrinter::endVisit(Block const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(IfStatement&)
+void ASTPrinter::endVisit(IfStatement const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(BreakableStatement&)
+void ASTPrinter::endVisit(BreakableStatement const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(WhileStatement&)
+void ASTPrinter::endVisit(WhileStatement const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Continue&)
+void ASTPrinter::endVisit(Continue const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Break&)
+void ASTPrinter::endVisit(Break const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Return&)
+void ASTPrinter::endVisit(Return const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(VariableDefinition&)
+void ASTPrinter::endVisit(VariableDefinition const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(ExpressionStatement&)
+void ASTPrinter::endVisit(ExpressionStatement const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Expression&)
+void ASTPrinter::endVisit(Expression const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Assignment&)
+void ASTPrinter::endVisit(Assignment const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(UnaryOperation&)
+void ASTPrinter::endVisit(UnaryOperation const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(BinaryOperation&)
+void ASTPrinter::endVisit(BinaryOperation const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(FunctionCall&)
+void ASTPrinter::endVisit(FunctionCall const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(MemberAccess&)
+void ASTPrinter::endVisit(MemberAccess const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(IndexAccess&)
+void ASTPrinter::endVisit(IndexAccess const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(PrimaryExpression&)
+void ASTPrinter::endVisit(PrimaryExpression const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Identifier&)
+void ASTPrinter::endVisit(Identifier const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(ElementaryTypeNameExpression&)
+void ASTPrinter::endVisit(ElementaryTypeNameExpression const&)
 {
 	m_indentation--;
 }
 
-void ASTPrinter::endVisit(Literal&)
+void ASTPrinter::endVisit(Literal const&)
 {
 	m_indentation--;
 }

libsolidity/ASTPrinter.h

@@ -33,77 +33,78 @@ namespace solidity
 /**
  * Pretty-printer for the abstract syntax tree (the "pretty" is arguable) for debugging purposes.
  */
-class ASTPrinter: public ASTVisitor
+class ASTPrinter: public ASTConstVisitor
 {
 public:
 	/// Create a printer for the given abstract syntax tree. If the source is specified,
 	/// the corresponding parts of the source are printed with each node.
-	ASTPrinter(ASTNode& _ast, std::string const& _source = std::string());
+	ASTPrinter(ASTNode const& _ast, std::string const& _source = std::string());
 	/// Output the string representation of the AST to _stream.
 	void print(std::ostream& _stream);
 
-	bool visit(ContractDefinition& _node) override;
+	bool visit(ImportDirective const& _node) override;
-	bool visit(StructDefinition& _node) override;
+	bool visit(ContractDefinition const& _node) override;
-	bool visit(ParameterList& _node) override;
+	bool visit(StructDefinition const& _node) override;
-	bool visit(FunctionDefinition& _node) override;
+	bool visit(ParameterList const& _node) override;
-	bool visit(VariableDeclaration& _node) override;
+	bool visit(FunctionDefinition const& _node) override;
-	bool visit(TypeName& _node) override;
+	bool visit(VariableDeclaration const& _node) override;
-	bool visit(ElementaryTypeName& _node) override;
+	bool visit(TypeName const& _node) override;
-	bool visit(UserDefinedTypeName& _node) override;
+	bool visit(ElementaryTypeName const& _node) override;
-	bool visit(Mapping& _node) override;
+	bool visit(UserDefinedTypeName const& _node) override;
-	bool visit(Statement& _node) override;
+	bool visit(Mapping const& _node) override;
-	bool visit(Block& _node) override;
+	bool visit(Statement const& _node) override;
-	bool visit(IfStatement& _node) override;
+	bool visit(Block const& _node) override;
-	bool visit(BreakableStatement& _node) override;
+	bool visit(IfStatement const& _node) override;
-	bool visit(WhileStatement& _node) override;
+	bool visit(BreakableStatement const& _node) override;
-	bool visit(Continue& _node) override;
+	bool visit(WhileStatement const& _node) override;
-	bool visit(Break& _node) override;
+	bool visit(Continue const& _node) override;
-	bool visit(Return& _node) override;
+	bool visit(Break const& _node) override;
-	bool visit(VariableDefinition& _node) override;
+	bool visit(Return const& _node) override;
-	bool visit(ExpressionStatement& _node) override;
+	bool visit(VariableDefinition const& _node) override;
-	bool visit(Expression& _node) override;
+	bool visit(ExpressionStatement const& _node) override;
-	bool visit(Assignment& _node) override;
+	bool visit(Expression const& _node) override;
-	bool visit(UnaryOperation& _node) override;
+	bool visit(Assignment const& _node) override;
-	bool visit(BinaryOperation& _node) override;
+	bool visit(UnaryOperation const& _node) override;
-	bool visit(FunctionCall& _node) override;
+	bool visit(BinaryOperation const& _node) override;
-	bool visit(MemberAccess& _node) override;
+	bool visit(FunctionCall const& _node) override;
-	bool visit(IndexAccess& _node) override;
+	bool visit(MemberAccess const& _node) override;
-	bool visit(PrimaryExpression& _node) override;
+	bool visit(IndexAccess const& _node) override;
-	bool visit(Identifier& _node) override;
+	bool visit(PrimaryExpression const& _node) override;
-	bool visit(ElementaryTypeNameExpression& _node) override;
+	bool visit(Identifier const& _node) override;
-	bool visit(Literal& _node) override;
+	bool visit(ElementaryTypeNameExpression const& _node) override;
+	bool visit(Literal const& _node) override;
 
-	void endVisit(ASTNode& _node) override;
+	void endVisit(ImportDirective const&) override;
-	void endVisit(ContractDefinition&) override;
+	void endVisit(ContractDefinition const&) override;
-	void endVisit(StructDefinition&) override;
+	void endVisit(StructDefinition const&) override;
-	void endVisit(ParameterList&) override;
+	void endVisit(ParameterList const&) override;
-	void endVisit(FunctionDefinition&) override;
+	void endVisit(FunctionDefinition const&) override;
-	void endVisit(VariableDeclaration&) override;
+	void endVisit(VariableDeclaration const&) override;
-	void endVisit(TypeName&) override;
+	void endVisit(TypeName const&) override;
-	void endVisit(ElementaryTypeName&) override;
+	void endVisit(ElementaryTypeName const&) override;
-	void endVisit(UserDefinedTypeName&) override;
+	void endVisit(UserDefinedTypeName const&) override;
-	void endVisit(Mapping&) override;
+	void endVisit(Mapping const&) override;
-	void endVisit(Statement&) override;
+	void endVisit(Statement const&) override;
-	void endVisit(Block&) override;
+	void endVisit(Block const&) override;
-	void endVisit(IfStatement&) override;
+	void endVisit(IfStatement const&) override;
-	void endVisit(BreakableStatement&) override;
+	void endVisit(BreakableStatement const&) override;
-	void endVisit(WhileStatement&) override;
+	void endVisit(WhileStatement const&) override;
-	void endVisit(Continue&) override;
+	void endVisit(Continue const&) override;
-	void endVisit(Break&) override;
+	void endVisit(Break const&) override;
-	void endVisit(Return&) override;
+	void endVisit(Return const&) override;
-	void endVisit(VariableDefinition&) override;
+	void endVisit(VariableDefinition const&) override;
-	void endVisit(ExpressionStatement&) override;
+	void endVisit(ExpressionStatement const&) override;
-	void endVisit(Expression&) override;
+	void endVisit(Expression const&) override;
-	void endVisit(Assignment&) override;
+	void endVisit(Assignment const&) override;
-	void endVisit(UnaryOperation&) override;
+	void endVisit(UnaryOperation const&) override;
-	void endVisit(BinaryOperation&) override;
+	void endVisit(BinaryOperation const&) override;
-	void endVisit(FunctionCall&) override;
+	void endVisit(FunctionCall const&) override;
-	void endVisit(MemberAccess&) override;
+	void endVisit(MemberAccess const&) override;
-	void endVisit(IndexAccess&) override;
+	void endVisit(IndexAccess const&) override;
-	void endVisit(PrimaryExpression&) override;
+	void endVisit(PrimaryExpression const&) override;
-	void endVisit(Identifier&) override;
+	void endVisit(Identifier const&) override;
-	void endVisit(ElementaryTypeNameExpression&) override;
+	void endVisit(ElementaryTypeNameExpression const&) override;
-	void endVisit(Literal&) override;
+	void endVisit(Literal const&) override;
 
 private:
 	void printSourcePart(ASTNode const& _node);
@@ -114,7 +115,7 @@ private:
 
 	int m_indentation;
 	std::string m_source;
-	ASTNode* m_ast;
+	ASTNode const* m_ast;
 	std::ostream* m_ostream;
 };
 

libsolidity/ASTVisitor.h

@@ -42,6 +42,8 @@ class ASTVisitor
 {
 public:
 	virtual bool visit(ASTNode&) { return true; }
+	virtual bool visit(SourceUnit&) { return true; }
+	virtual bool visit(ImportDirective&) { return true; }
 	virtual bool visit(ContractDefinition&) { return true; }
 	virtual bool visit(StructDefinition&) { return true; }
 	virtual bool visit(ParameterList&) { return true; }
@@ -74,6 +76,8 @@ public:
 	virtual bool visit(Literal&) { return true; }
 
 	virtual void endVisit(ASTNode&) { }
+	virtual void endVisit(SourceUnit&) { }
+	virtual void endVisit(ImportDirective&) { }
 	virtual void endVisit(ContractDefinition&) { }
 	virtual void endVisit(StructDefinition&) { }
 	virtual void endVisit(ParameterList&) { }
@@ -106,5 +110,77 @@ public:
 	virtual void endVisit(Literal&) { }
 };
 
+class ASTConstVisitor
+{
+public:
+	virtual bool visit(ASTNode const&) { return true; }
+	virtual bool visit(SourceUnit const&) { return true; }
+	virtual bool visit(ImportDirective const&) { return true; }
+	virtual bool visit(ContractDefinition const&) { return true; }
+	virtual bool visit(StructDefinition const&) { return true; }
+	virtual bool visit(ParameterList const&) { return true; }
+	virtual bool visit(FunctionDefinition const&) { return true; }
+	virtual bool visit(VariableDeclaration const&) { return true; }
+	virtual bool visit(TypeName const&) { return true; }
+	virtual bool visit(ElementaryTypeName const&) { return true; }
+	virtual bool visit(UserDefinedTypeName const&) { return true; }
+	virtual bool visit(Mapping const&) { return true; }
+	virtual bool visit(Statement const&) { return true; }
+	virtual bool visit(Block const&) { return true; }
+	virtual bool visit(IfStatement const&) { return true; }
+	virtual bool visit(BreakableStatement const&) { return true; }
+	virtual bool visit(WhileStatement const&) { return true; }
+	virtual bool visit(Continue const&) { return true; }
+	virtual bool visit(Break const&) { return true; }
+	virtual bool visit(Return const&) { return true; }
+	virtual bool visit(VariableDefinition const&) { return true; }
+	virtual bool visit(ExpressionStatement const&) { return true; }
+	virtual bool visit(Expression const&) { return true; }
+	virtual bool visit(Assignment const&) { return true; }
+	virtual bool visit(UnaryOperation const&) { return true; }
+	virtual bool visit(BinaryOperation const&) { return true; }
+	virtual bool visit(FunctionCall const&) { return true; }
+	virtual bool visit(MemberAccess const&) { return true; }
+	virtual bool visit(IndexAccess const&) { return true; }
+	virtual bool visit(PrimaryExpression const&) { return true; }
+	virtual bool visit(Identifier const&) { return true; }
+	virtual bool visit(ElementaryTypeNameExpression const&) { return true; }
+	virtual bool visit(Literal const&) { return true; }
+
+	virtual void endVisit(ASTNode const&) { }
+	virtual void endVisit(SourceUnit const&) { }
+	virtual void endVisit(ImportDirective const&) { }
+	virtual void endVisit(ContractDefinition const&) { }
+	virtual void endVisit(StructDefinition const&) { }
+	virtual void endVisit(ParameterList const&) { }
+	virtual void endVisit(FunctionDefinition const&) { }
+	virtual void endVisit(VariableDeclaration const&) { }
+	virtual void endVisit(TypeName const&) { }
+	virtual void endVisit(ElementaryTypeName const&) { }
+	virtual void endVisit(UserDefinedTypeName const&) { }
+	virtual void endVisit(Mapping const&) { }
+	virtual void endVisit(Statement const&) { }
+	virtual void endVisit(Block const&) { }
+	virtual void endVisit(IfStatement const&) { }
+	virtual void endVisit(BreakableStatement const&) { }
+	virtual void endVisit(WhileStatement const&) { }
+	virtual void endVisit(Continue const&) { }
+	virtual void endVisit(Break const&) { }
+	virtual void endVisit(Return const&) { }
+	virtual void endVisit(VariableDefinition const&) { }
+	virtual void endVisit(ExpressionStatement const&) { }
+	virtual void endVisit(Expression const&) { }
+	virtual void endVisit(Assignment const&) { }
+	virtual void endVisit(UnaryOperation const&) { }
+	virtual void endVisit(BinaryOperation const&) { }
+	virtual void endVisit(FunctionCall const&) { }
+	virtual void endVisit(MemberAccess const&) { }
+	virtual void endVisit(IndexAccess const&) { }
+	virtual void endVisit(PrimaryExpression const&) { }
+	virtual void endVisit(Identifier const&) { }
+	virtual void endVisit(ElementaryTypeNameExpression const&) { }
+	virtual void endVisit(Literal const&) { }
+};
+
 }
 }

libsolidity/AST_accept.h

@@ -0,0 +1,493 @@
+/*
+    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
+ * Implementation of the accept functions of AST nodes, included by AST.cpp to not clutter that
+ * file with these mechanical implementations.
+ */
+
+#pragma once
+
+#include <libsolidity/AST.h>
+#include <libsolidity/ASTVisitor.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+void SourceUnit::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		listAccept(m_nodes, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void SourceUnit::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		listAccept(m_nodes, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void ImportDirective::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ImportDirective::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ContractDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		listAccept(m_definedStructs, _visitor);
+		listAccept(m_stateVariables, _visitor);
+		listAccept(m_definedFunctions, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void ContractDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		listAccept(m_definedStructs, _visitor);
+		listAccept(m_stateVariables, _visitor);
+		listAccept(m_definedFunctions, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void StructDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		listAccept(m_members, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void StructDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		listAccept(m_members, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void StructDefinition::checkValidityOfMembers() const
+{
+	checkMemberTypes();
+	checkRecursion();
+}
+
+void ParameterList::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		listAccept(m_parameters, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void ParameterList::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		listAccept(m_parameters, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void FunctionDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_parameters->accept(_visitor);
+		if (m_returnParameters)
+			m_returnParameters->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void FunctionDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_parameters->accept(_visitor);
+		if (m_returnParameters)
+			m_returnParameters->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void VariableDeclaration::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		if (m_typeName)
+			m_typeName->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void VariableDeclaration::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		if (m_typeName)
+			m_typeName->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void TypeName::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void TypeName::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ElementaryTypeName::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ElementaryTypeName::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void UserDefinedTypeName::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void UserDefinedTypeName::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Mapping::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_keyType->accept(_visitor);
+		m_valueType->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Mapping::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_keyType->accept(_visitor);
+		m_valueType->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Block::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		listAccept(m_statements, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void Block::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		listAccept(m_statements, _visitor);
+	_visitor.endVisit(*this);
+}
+
+void IfStatement::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_condition->accept(_visitor);
+		m_trueBody->accept(_visitor);
+		if (m_falseBody)
+			m_falseBody->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void IfStatement::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_condition->accept(_visitor);
+		m_trueBody->accept(_visitor);
+		if (m_falseBody)
+			m_falseBody->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void WhileStatement::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_condition->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void WhileStatement::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_condition->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Continue::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Continue::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Break::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Break::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Return::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		if (m_expression)
+			m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void Return::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		if (m_expression)
+			m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void ExpressionStatement::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		if (m_expression)
+			m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void ExpressionStatement::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		if (m_expression)
+			m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void VariableDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_variable->accept(_visitor);
+		if (m_value)
+			m_value->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void VariableDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_variable->accept(_visitor);
+		if (m_value)
+			m_value->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Assignment::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_leftHandSide->accept(_visitor);
+		m_rightHandSide->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Assignment::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_leftHandSide->accept(_visitor);
+		m_rightHandSide->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void UnaryOperation::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		m_subExpression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void UnaryOperation::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		m_subExpression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void BinaryOperation::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_left->accept(_visitor);
+		m_right->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void BinaryOperation::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_left->accept(_visitor);
+		m_right->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void FunctionCall::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_expression->accept(_visitor);
+		listAccept(m_arguments, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void FunctionCall::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_expression->accept(_visitor);
+		listAccept(m_arguments, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void MemberAccess::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void MemberAccess::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		m_expression->accept(_visitor);
+	_visitor.endVisit(*this);
+}
+
+void IndexAccess::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_base->accept(_visitor);
+		m_index->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void IndexAccess::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_base->accept(_visitor);
+		m_index->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Identifier::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Identifier::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ElementaryTypeNameExpression::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void ElementaryTypeNameExpression::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Literal::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Literal::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+}
+}

libsolidity/BaseTypes.h

@@ -22,6 +22,8 @@
 
 #pragma once
 
+#include <memory>
+#include <string>
 #include <ostream>
 
 namespace dev
@@ -35,19 +37,19 @@ namespace solidity
  */
 struct Location
 {
-	Location(int _start, int _end): start(_start), end(_end) { }
+	Location(int _start, int _end, std::shared_ptr<std::string const> _sourceName):
+		start(_start), end(_end), sourceName(_sourceName) { }
 	Location(): start(-1), end(-1) { }
 
-	bool IsValid() const { return start >= 0 && end >= start; }
-
 	int start;
 	int end;
+	std::shared_ptr<std::string const> sourceName;
 };
 
 /// Stream output for Location (used e.g. in boost exceptions).
 inline std::ostream& operator<<(std::ostream& _out, Location const& _location)
 {
-	return _out << "[" << _location.start << "," << _location.end << ")";
+	return _out << *_location.sourceName << "[" << _location.start << "," << _location.end << ")";
 }
 
 }

libsolidity/Compiler.cpp

@@ -26,13 +26,14 @@
 #include <libsolidity/AST.h>
 #include <libsolidity/Compiler.h>
 #include <libsolidity/ExpressionCompiler.h>
+#include <libsolidity/CompilerUtils.h>
 
 using namespace std;
 
 namespace dev {
 namespace solidity {
 
-void Compiler::compileContract(ContractDefinition& _contract, vector<MagicVariableDeclaration const*> const& _magicGlobals)
+void Compiler::compileContract(ContractDefinition const& _contract, vector<MagicVariableDeclaration const*> const& _magicGlobals)
 {
 	m_context = CompilerContext(); // clear it just in case
 
@@ -135,7 +136,7 @@ unsigned Compiler::appendCalldataUnpacker(FunctionDefinition const& _function, b
 	for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
 	{
 		unsigned const numBytes = var->getType()->getCalldataEncodedSize();
-		if (numBytes == 0)
+		if (numBytes == 0 || numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
 								  << errinfo_sourceLocation(var->getLocation())
 								  << errinfo_comment("Type " + var->getType()->toString() + " not yet supported."));
@@ -154,18 +155,20 @@ void Compiler::appendReturnValuePacker(FunctionDefinition const& _function)
 	//@todo this can be also done more efficiently
 	unsigned dataOffset = 0;
 	vector<ASTPointer<VariableDeclaration>> const& parameters = _function.getReturnParameters();
+	unsigned stackDepth = CompilerUtils(m_context).getSizeOnStack(parameters);
 	for (unsigned i = 0; i < parameters.size(); ++i)
 	{
 		Type const& paramType = *parameters[i]->getType();
 		unsigned numBytes = paramType.getCalldataEncodedSize();
-		if (numBytes == 0)
+		if (numBytes == 0 || numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
 								  << errinfo_sourceLocation(parameters[i]->getLocation())
 								  << errinfo_comment("Type " + paramType.toString() + " not yet supported."));
-		m_context << eth::dupInstruction(parameters.size() - i);
+		CompilerUtils(m_context).copyToStackTop(stackDepth, paramType);
 		if (numBytes != 32)
 			m_context << (u256(1) << ((32 - numBytes) * 8)) << eth::Instruction::MUL;
 		m_context << u256(dataOffset) << eth::Instruction::MSTORE;
+		stackDepth -= paramType.getSizeOnStack();
 		dataOffset += numBytes;
 	}
 	// note that the stack is not cleaned up here
@@ -179,7 +182,7 @@ void Compiler::registerStateVariables(ContractDefinition const& _contract)
 		m_context.addStateVariable(*variable);
 }
 
-bool Compiler::visit(FunctionDefinition& _function)
+bool Compiler::visit(FunctionDefinition const& _function)
 {
 	//@todo to simplify this, the calling convention could by changed such that
 	// caller puts: [retarg0] ... [retargm] [return address] [arg0] ... [argn]
@@ -195,15 +198,12 @@ bool Compiler::visit(FunctionDefinition& _function)
 	// stack upon entry: [return address] [arg0] [arg1] ... [argn]
 	// reserve additional slots: [retarg0] ... [retargm] [localvar0] ... [localvarp]
 
-	unsigned const numArguments = _function.getParameters().size();
+	for (ASTPointer<VariableDeclaration const> const& variable: _function.getParameters())
-	unsigned const numReturnValues = _function.getReturnParameters().size();
-	unsigned const numLocalVariables = _function.getLocalVariables().size();
-
-	for (ASTPointer<VariableDeclaration> const& variable: _function.getParameters() + _function.getReturnParameters())
 		m_context.addVariable(*variable);
+	for (ASTPointer<VariableDeclaration const> const& variable: _function.getReturnParameters())
+		m_context.addAndInitializeVariable(*variable);
 	for (VariableDeclaration const* localVariable: _function.getLocalVariables())
-		m_context.addVariable(*localVariable);
+		m_context.addAndInitializeVariable(*localVariable);
-	m_context.initializeLocalVariables(numReturnValues + numLocalVariables);
 
 	_function.getBody().accept(*this);
 
@@ -215,12 +215,16 @@ bool Compiler::visit(FunctionDefinition& _function)
 	// Note that the fact that the return arguments are of increasing index is vital for this
 	// algorithm to work.
 
+	unsigned const argumentsSize = CompilerUtils::getSizeOnStack(_function.getParameters());
+	unsigned const returnValuesSize = CompilerUtils::getSizeOnStack(_function.getReturnParameters());
+	unsigned const localVariablesSize = CompilerUtils::getSizeOnStack(_function.getLocalVariables());
+
 	vector<int> stackLayout;
-	stackLayout.push_back(numReturnValues); // target of return address
+	stackLayout.push_back(returnValuesSize); // target of return address
-	stackLayout += vector<int>(numArguments, -1); // discard all arguments
+	stackLayout += vector<int>(argumentsSize, -1); // discard all arguments
-	for (unsigned i = 0; i < numReturnValues; ++i)
+	for (unsigned i = 0; i < returnValuesSize; ++i)
 		stackLayout.push_back(i);
-	stackLayout += vector<int>(numLocalVariables, -1);
+	stackLayout += vector<int>(localVariablesSize, -1);
 
 	while (stackLayout.back() != int(stackLayout.size() - 1))
 		if (stackLayout.back() < 0)
@@ -240,7 +244,7 @@ bool Compiler::visit(FunctionDefinition& _function)
 	return false;
 }
 
-bool Compiler::visit(IfStatement& _ifStatement)
+bool Compiler::visit(IfStatement const& _ifStatement)
 {
 	ExpressionCompiler::compileExpression(m_context, _ifStatement.getCondition());
 	eth::AssemblyItem trueTag = m_context.appendConditionalJump();
@@ -253,7 +257,7 @@ bool Compiler::visit(IfStatement& _ifStatement)
 	return false;
 }
 
-bool Compiler::visit(WhileStatement& _whileStatement)
+bool Compiler::visit(WhileStatement const& _whileStatement)
 {
 	eth::AssemblyItem loopStart = m_context.newTag();
 	eth::AssemblyItem loopEnd = m_context.newTag();
@@ -275,58 +279,53 @@ bool Compiler::visit(WhileStatement& _whileStatement)
 	return false;
 }
 
-bool Compiler::visit(Continue&)
+bool Compiler::visit(Continue const&)
 {
 	if (!m_continueTags.empty())
 		m_context.appendJumpTo(m_continueTags.back());
 	return false;
 }
 
-bool Compiler::visit(Break&)
+bool Compiler::visit(Break const&)
 {
 	if (!m_breakTags.empty())
 		m_context.appendJumpTo(m_breakTags.back());
 	return false;
 }
 
-bool Compiler::visit(Return& _return)
+bool Compiler::visit(Return const& _return)
 {
 	//@todo modifications are needed to make this work with functions returning multiple values
-	if (Expression* expression = _return.getExpression())
+	if (Expression const* expression = _return.getExpression())
 	{
 		ExpressionCompiler::compileExpression(m_context, *expression);
 		VariableDeclaration const& firstVariable = *_return.getFunctionReturnParameters().getParameters().front();
 		ExpressionCompiler::appendTypeConversion(m_context, *expression->getType(), *firstVariable.getType());
 
-		unsigned stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(firstVariable));
+		CompilerUtils(m_context).moveToStackVariable(firstVariable);
-		m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
 	}
 	m_context.appendJumpTo(m_returnTag);
 	return false;
 }
 
-bool Compiler::visit(VariableDefinition& _variableDefinition)
+bool Compiler::visit(VariableDefinition const& _variableDefinition)
 {
-	if (Expression* expression = _variableDefinition.getExpression())
+	if (Expression const* expression = _variableDefinition.getExpression())
 	{
 		ExpressionCompiler::compileExpression(m_context, *expression);
 		ExpressionCompiler::appendTypeConversion(m_context,
 												 *expression->getType(),
 												 *_variableDefinition.getDeclaration().getType());
-		unsigned baseStackOffset = m_context.getBaseStackOffsetOfVariable(_variableDefinition.getDeclaration());
+		CompilerUtils(m_context).moveToStackVariable(_variableDefinition.getDeclaration());
-		unsigned stackPosition = m_context.baseToCurrentStackOffset(baseStackOffset);
-		m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
 	}
 	return false;
 }
 
-bool Compiler::visit(ExpressionStatement& _expressionStatement)
+bool Compiler::visit(ExpressionStatement const& _expressionStatement)
 {
-	Expression& expression = _expressionStatement.getExpression();
+	Expression const& expression = _expressionStatement.getExpression();
 	ExpressionCompiler::compileExpression(m_context, expression);
-//	Type::Category category = expression.getType()->getCategory();
+	CompilerUtils(m_context).popStackElement(*expression.getType());
-	for (unsigned i = 0; i < expression.getType()->getSizeOnStack(); ++i)
-		m_context << eth::Instruction::POP;
 	return false;
 }
 

libsolidity/Compiler.h

@@ -27,12 +27,12 @@
 namespace dev {
 namespace solidity {
 
-class Compiler: private ASTVisitor
+class Compiler: private ASTConstVisitor
 {
 public:
 	Compiler(): m_returnTag(m_context.newTag()) {}
 
-	void compileContract(ContractDefinition& _contract, std::vector<MagicVariableDeclaration const*> const& _magicGlobals);
+	void compileContract(ContractDefinition const& _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); }
 
@@ -48,14 +48,14 @@ private:
 
 	void registerStateVariables(ContractDefinition const& _contract);
 
-	virtual bool visit(FunctionDefinition& _function) override;
+	virtual bool visit(FunctionDefinition const& _function) override;
-	virtual bool visit(IfStatement& _ifStatement) override;
+	virtual bool visit(IfStatement const& _ifStatement) override;
-	virtual bool visit(WhileStatement& _whileStatement) override;
+	virtual bool visit(WhileStatement const& _whileStatement) override;
-	virtual bool visit(Continue& _continue) override;
+	virtual bool visit(Continue const& _continue) override;
-	virtual bool visit(Break& _break) override;
+	virtual bool visit(Break const& _break) override;
-	virtual bool visit(Return& _return) override;
+	virtual bool visit(Return const& _return) override;
-	virtual bool visit(VariableDefinition& _variableDefinition) override;
+	virtual bool visit(VariableDefinition const& _variableDefinition) override;
-	virtual bool visit(ExpressionStatement& _expressionStatement) override;
+	virtual bool visit(ExpressionStatement const& _expressionStatement) override;
 
 
 	CompilerContext m_context;

libsolidity/CompilerContext.cpp

@@ -41,20 +41,30 @@ void CompilerContext::addStateVariable(VariableDeclaration const& _declaration)
 	m_stateVariablesSize += _declaration.getType()->getStorageSize();
 }
 
-void CompilerContext::initializeLocalVariables(unsigned _numVariables)
+void CompilerContext::addVariable(VariableDeclaration const& _declaration)
 {
-	if (_numVariables > 0)
+	m_localVariables[&_declaration] = m_localVariablesSize;
-	{
+	m_localVariablesSize += _declaration.getType()->getSizeOnStack();
+}
+
+void CompilerContext::addAndInitializeVariable(VariableDeclaration const& _declaration)
+{
+	addVariable(_declaration);
+
+	unsigned const size = _declaration.getType()->getSizeOnStack();
+	for (unsigned i = 0; i < size; ++i)
 		*this << u256(0);
-		for (unsigned i = 1; i < _numVariables; ++i)
+	m_asm.adjustDeposit(-size);
-			*this << eth::Instruction::DUP1;
+}
-		m_asm.adjustDeposit(-_numVariables);
+
-	}
+void CompilerContext::addFunction(FunctionDefinition const& _function)
+{
+	m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag()));
 }
 
 bool CompilerContext::isLocalVariable(Declaration const* _declaration) const
 {
-	return std::find(m_localVariables.begin(), m_localVariables.end(), _declaration) != m_localVariables.end();
+	return m_localVariables.count(_declaration) > 0;
 }
 
 eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition const& _function) const
@@ -67,10 +77,10 @@ eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition cons
 
 unsigned CompilerContext::getBaseStackOffsetOfVariable(Declaration const& _declaration) const
 {
-	auto res = find(begin(m_localVariables), end(m_localVariables), &_declaration);
+	auto res = m_localVariables.find(&_declaration);
 	if (asserts(res != m_localVariables.end()))
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Variable not found on stack."));
-	return unsigned(end(m_localVariables) - res - 1);
+	return m_localVariablesSize - res->second - 1;
 }
 
 unsigned CompilerContext::baseToCurrentStackOffset(unsigned _baseOffset) const

libsolidity/CompilerContext.h

@@ -25,6 +25,7 @@
 #include <ostream>
 #include <libevmcore/Instruction.h>
 #include <libevmcore/Assembly.h>
+#include <libsolidity/ASTForward.h>
 #include <libsolidity/Types.h>
 
 namespace dev {
@@ -43,9 +44,9 @@ public:
 	void addMagicGlobal(MagicVariableDeclaration const& _declaration);
 	void addStateVariable(VariableDeclaration const& _declaration);
 	void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); }
-	void initializeLocalVariables(unsigned _numVariables);
+	void addVariable(VariableDeclaration const& _declaration);
-	void addVariable(VariableDeclaration const& _declaration) { m_localVariables.push_back(&_declaration); }
+	void addAndInitializeVariable(VariableDeclaration const& _declaration);
-	void addFunction(FunctionDefinition const& _function) { m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag())); }
+	void addFunction(FunctionDefinition const& _function);
 
 	void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); }
 
@@ -98,8 +99,10 @@ private:
 	u256 m_stateVariablesSize;
 	/// Storage offsets of state variables
 	std::map<Declaration const*, u256> m_stateVariables;
-	/// Offsets of local variables on the stack.
+	/// Offsets of local variables on the stack (relative to stack base).
-	std::vector<Declaration const*> m_localVariables;
+	std::map<Declaration const*, unsigned> m_localVariables;
+	/// Sum of stack sizes of local variables
+	unsigned m_localVariablesSize;
 	/// Labels pointing to the entry points of funcitons.
 	std::map<Declaration const*, eth::AssemblyItem> m_functionEntryLabels;
 };

libsolidity/CompilerStack.cpp

@@ -36,22 +36,43 @@ namespace dev
 namespace solidity
 {
 
-CompilerStack::CompilerStack(): m_interfaceHandler(make_shared<InterfaceHandler>()) {}
+void CompilerStack::addSource(string const& _name, string const& _content)
+{
+	if (m_sources.count(_name))
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Source by given name already exists."));
+
+	reset(true);
+	m_sources[_name].scanner = make_shared<Scanner>(CharStream(_content), _name);
+}
 
 void CompilerStack::setSource(string const& _sourceCode)
 {
 	reset();
-	m_scanner = make_shared<Scanner>(CharStream(_sourceCode));
+	addSource("", _sourceCode);
 }
 
 void CompilerStack::parse()
 {
-	if (!m_scanner)
+	for (auto& sourcePair: m_sources)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Source not available."));
+	{
-	m_contractASTNode = Parser().parse(m_scanner);
+		sourcePair.second.scanner->reset();
+		sourcePair.second.ast = Parser().parse(sourcePair.second.scanner);
+	}
+	resolveImports();
+
 	m_globalContext = make_shared<GlobalContext>();
-	m_globalContext->setCurrentContract(*m_contractASTNode);
+	NameAndTypeResolver resolver(m_globalContext->getDeclarations());
-	NameAndTypeResolver(m_globalContext->getDeclarations()).resolveNamesAndTypes(*m_contractASTNode);
+	for (Source const* source: m_sourceOrder)
+		resolver.registerDeclarations(*source->ast);
+	for (Source const* source: m_sourceOrder)
+		for (ASTPointer<ASTNode> const& node: source->ast->getNodes())
+			if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+			{
+				m_globalContext->setCurrentContract(*contract);
+				resolver.updateDeclaration(*m_globalContext->getCurrentThis());
+				resolver.resolveNamesAndTypes(*contract);
+				m_contracts[contract->getName()].contract = contract;
+			}
 	m_parseSuccessful = true;
 }
 
@@ -61,54 +82,90 @@ void CompilerStack::parse(string const& _sourceCode)
 	parse();
 }
 
-bytes const& CompilerStack::compile(bool _optimize)
+vector<string> CompilerStack::getContractNames() const
 {
 	if (!m_parseSuccessful)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
-	m_bytecode.clear();
+	vector<string> contractNames;
-	m_compiler = make_shared<Compiler>();
+	for (auto const& contract: m_contracts)
-	m_compiler->compileContract(*m_contractASTNode, m_globalContext->getMagicVariables());
+		contractNames.push_back(contract.first);
-	return m_bytecode = m_compiler->getAssembledBytecode(_optimize);
+	return contractNames;
+}
+
+void CompilerStack::compile(bool _optimize)
+{
+	if (!m_parseSuccessful)
+		parse();
+	for (Source const* source: m_sourceOrder)
+		for (ASTPointer<ASTNode> const& node: source->ast->getNodes())
+			if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+			{
+				m_globalContext->setCurrentContract(*contract);
+				shared_ptr<Compiler> compiler = make_shared<Compiler>();
+				compiler->compileContract(*contract, m_globalContext->getMagicVariables());
+				Contract& compiledContract = m_contracts[contract->getName()];
+				compiledContract.bytecode = compiler->getAssembledBytecode(_optimize);
+				compiledContract.compiler = move(compiler);
+			}
 }
 
 bytes const& CompilerStack::compile(string const& _sourceCode, bool _optimize)
 {
 	parse(_sourceCode);
-	return compile(_optimize);
+	compile(_optimize);
+	return getBytecode();
 }
 
-void CompilerStack::streamAssembly(ostream& _outStream)
+bytes const& CompilerStack::getBytecode(string const& _contractName) const
 {
-	if (!m_compiler || m_bytecode.empty())
+	return getContract(_contractName).bytecode;
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
-	m_compiler->streamAssembly(_outStream);
 }
 
-std::string const& CompilerStack::getJsonDocumentation(DocumentationType _type)
+void CompilerStack::streamAssembly(ostream& _outStream, string const& _contractName) const
+{
+	getContract(_contractName).compiler->streamAssembly(_outStream);
+}
+
+string const& CompilerStack::getInterface(string const& _contractName) const
+{
+	return getJsonDocumentation(_contractName, DocumentationType::ABI_INTERFACE);
+}
+
+string const& CompilerStack::getJsonDocumentation(string const& _contractName, DocumentationType _type) const
 {
 	if (!m_parseSuccessful)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
 
-	auto createDocIfNotThere = [this, _type](std::unique_ptr<string>& _doc)
+	Contract const& contract = getContract(_contractName);
-	{
-		if (!_doc)
-			_doc = m_interfaceHandler->getDocumentation(m_contractASTNode, _type);
-	};
 
+	std::unique_ptr<string const>* doc;
 	switch (_type)
 	{
 	case DocumentationType::NATSPEC_USER:
-		createDocIfNotThere(m_userDocumentation);
+		doc = &contract.userDocumentation;
-		return *m_userDocumentation;
+		break;
 	case DocumentationType::NATSPEC_DEV:
-		createDocIfNotThere(m_devDocumentation);
+		doc = &contract.devDocumentation;
-		return *m_devDocumentation;
+		break;
 	case DocumentationType::ABI_INTERFACE:
-		createDocIfNotThere(m_interface);
+		doc = &contract.interface;
-		return *m_interface;
+		break;
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Illegal documentation type."));
 	}
+	if (!*doc)
+		*doc = contract.interfaceHandler->getDocumentation(*contract.contract, _type);
+	return *(*doc);
+}
 
-	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Illegal documentation type."));
+Scanner const& CompilerStack::getScanner(string const& _sourceName) const
+{
+	return *getSource(_sourceName).scanner;
+}
+
+SourceUnit const& CompilerStack::getAST(string const& _sourceName) const
+{
+	return *getSource(_sourceName).ast;
 }
 
 bytes CompilerStack::staticCompile(std::string const& _sourceCode, bool _optimize)
@@ -117,7 +174,70 @@ bytes CompilerStack::staticCompile(std::string const& _sourceCode, bool _optimiz
 	return stack.compile(_sourceCode, _optimize);
 }
 
+void CompilerStack::reset(bool _keepSources)
+{
+	m_parseSuccessful = false;
+	if (_keepSources)
+		for (auto sourcePair: m_sources)
+			sourcePair.second.reset();
+	else
+		m_sources.clear();
+	m_globalContext.reset();
+	m_sourceOrder.clear();
+	m_contracts.clear();
+}
+
+void CompilerStack::resolveImports()
+{
+	// topological sorting (depth first search) of the import graph, cutting potential cycles
+	vector<Source const*> sourceOrder;
+	set<Source const*> sourcesSeen;
+
+	function<void(Source const*)> toposort = [&](Source const* _source)
+	{
+		if (sourcesSeen.count(_source))
+			return;
+		sourcesSeen.insert(_source);
+		for (ASTPointer<ASTNode> const& node: _source->ast->getNodes())
+			if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
+			{
+				string const& id = import->getIdentifier();
+				if (!m_sources.count(id))
+					BOOST_THROW_EXCEPTION(ParserError()
+										  << errinfo_sourceLocation(import->getLocation())
+										  << errinfo_comment("Source not found."));
+				toposort(&m_sources[id]);
+			}
+		sourceOrder.push_back(_source);
+	};
+
+	for (auto const& sourcePair: m_sources)
+		toposort(&sourcePair.second);
+
+	swap(m_sourceOrder, sourceOrder);
+}
+
+CompilerStack::Contract const& CompilerStack::getContract(string const& _contractName) const
+{
+	if (m_contracts.empty())
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("No compiled contracts found."));
+	if (_contractName.empty())
+		return m_contracts.begin()->second;
+	auto it = m_contracts.find(_contractName);
+	if (it == m_contracts.end())
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Contract " + _contractName + " not found."));
+	return it->second;
+}
+
+CompilerStack::Source const& CompilerStack::getSource(string const& _sourceName) const
+{
+	auto it = m_sources.find(_sourceName);
+	if (it == m_sources.end())
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Given source file not found."));
+	return it->second;
+}
 
+CompilerStack::Contract::Contract(): interfaceHandler(make_shared<InterfaceHandler>()) {}
 
 }
 }

libsolidity/CompilerStack.h

@@ -25,6 +25,7 @@
 #include <ostream>
 #include <string>
 #include <memory>
+#include <boost/noncopyable.hpp>
 #include <libdevcore/Common.h>
 
 namespace dev {
@@ -33,6 +34,7 @@ namespace solidity {
 // forward declarations
 class Scanner;
 class ContractDefinition;
+class SourceUnit;
 class Compiler;
 class GlobalContext;
 class InterfaceHandler;
@@ -49,52 +51,85 @@ enum class DocumentationType: uint8_t
  * It holds state and can be used to either step through the compilation stages (and abort e.g.
  * before compilation to bytecode) or run the whole compilation in one call.
  */
-class CompilerStack
+class CompilerStack: boost::noncopyable
 {
 public:
-	CompilerStack();
+	CompilerStack(): m_parseSuccessful(false) {}
-	void reset() {  *this = CompilerStack(); }
+
+	/// Adds a source object (e.g. file) to the parser. After this, parse has to be called again.
+	void addSource(std::string const& _name, std::string const& _content);
 	void setSource(std::string const& _sourceCode);
+	/// Parses all source units that were added
 	void parse();
+	/// Sets the given source code as the only source unit and parses it.
 	void parse(std::string const& _sourceCode);
-	/// Compiles the contract that was previously parsed.
+	/// Returns a list of the contract names in the sources.
-	bytes const& compile(bool _optimize = false);
+	std::vector<std::string> getContractNames() const;
+
+	/// Compiles the source units that were previously added and parsed.
+	void compile(bool _optimize = false);
 	/// Parses and compiles the given source code.
+	/// @returns the compiled bytecode
 	bytes const& compile(std::string const& _sourceCode, bool _optimize = false);
 
-	bytes const& getBytecode() const { return m_bytecode; }
+	bytes const& getBytecode(std::string const& _contractName = "") const;
 	/// Streams a verbose version of the assembly to @a _outStream.
 	/// Prerequisite: Successful compilation.
-	void streamAssembly(std::ostream& _outStream);
+	void streamAssembly(std::ostream& _outStream, std::string const& _contractName = "") const;
 
 	/// Returns a string representing the contract interface in JSON.
 	/// Prerequisite: Successful call to parse or compile.
-	std::string const& getInterface();
+	std::string const& getInterface(std::string const& _contractName = "") const;
 	/// Returns a string representing the contract's documentation in JSON.
 	/// Prerequisite: Successful call to parse or compile.
 	/// @param type The type of the documentation to get.
-	/// Can be one of 3 types defined at @c documentation_type
+	/// Can be one of 3 types defined at @c DocumentationType
-	std::string const& getJsonDocumentation(DocumentationType type);
+	std::string const& getJsonDocumentation(std::string const& _contractName, DocumentationType _type) const;
 
 	/// Returns the previously used scanner, useful for counting lines during error reporting.
-	Scanner const& getScanner() const { return *m_scanner; }
+	Scanner const& getScanner(std::string const& _sourceName = "") const;
-	ContractDefinition& getAST() const { return *m_contractASTNode; }
+	SourceUnit const& getAST(std::string const& _sourceName = "") const;
 
 	/// Compile the given @a _sourceCode to bytecode. If a scanner is provided, it is used for
 	/// scanning the source code - this is useful for printing exception information.
 	static bytes staticCompile(std::string const& _sourceCode, bool _optimize = false);
 
 private:
-	std::shared_ptr<Scanner> m_scanner;
+	/**
-	std::shared_ptr<GlobalContext> m_globalContext;
+	 * Information pertaining to one source unit, filled gradually during parsing and compilation.
-	std::shared_ptr<ContractDefinition> m_contractASTNode;
+	 */
+	struct Source
+	{
+		std::shared_ptr<Scanner> scanner;
+		std::shared_ptr<SourceUnit> ast;
+		std::string interface;
+		void reset() { scanner.reset(); ast.reset(); interface.clear(); }
+	};
+
+	struct Contract
+	{
+		ContractDefinition* contract;
+		std::shared_ptr<Compiler> compiler;
+		bytes bytecode;
+		std::shared_ptr<InterfaceHandler> interfaceHandler;
+		mutable std::unique_ptr<std::string const> interface;
+		mutable std::unique_ptr<std::string const> userDocumentation;
+		mutable std::unique_ptr<std::string const> devDocumentation;
+
+		Contract();
+	};
+
+	void reset(bool _keepSources = false);
+	void resolveImports();
+
+	Contract const& getContract(std::string const& _contractName = "") const;
+	Source const& getSource(std::string const& _sourceName = "") const;
+
 	bool m_parseSuccessful;
-	std::unique_ptr<std::string> m_interface;
+	std::map<std::string const, Source> m_sources;
-	std::unique_ptr<std::string> m_userDocumentation;
+	std::shared_ptr<GlobalContext> m_globalContext;
-	std::unique_ptr<std::string> m_devDocumentation;
+	std::vector<Source const*> m_sourceOrder;
-	std::shared_ptr<Compiler> m_compiler;
+	std::map<std::string const, Contract> m_contracts;
-	std::shared_ptr<InterfaceHandler> m_interfaceHandler;
-	bytes m_bytecode;
 };
 
 }

libsolidity/CompilerUtils.cpp

@@ -0,0 +1,71 @@
+/*
+	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
+ * Routines used by both the compiler and the expression compiler.
+ */
+
+#include <libsolidity/CompilerUtils.h>
+#include <libsolidity/AST.h>
+#include <libevmcore/Instruction.h>
+
+using namespace std;
+
+namespace dev
+{
+namespace solidity
+{
+
+void CompilerUtils::moveToStackVariable(VariableDeclaration const& _variable)
+{
+	unsigned const stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(_variable));
+	unsigned const size = _variable.getType()->getSizeOnStack();
+	// move variable starting from its top end in the stack
+	if (stackPosition - size + 1 > 16)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_variable.getLocation())
+											  << errinfo_comment("Stack too deep."));
+	for (unsigned i = 0; i < size; ++i)
+		m_context << eth::swapInstruction(stackPosition - size + 1) << eth::Instruction::POP;
+}
+
+void CompilerUtils::copyToStackTop(unsigned _stackDepth, Type const& _type)
+{
+	if (_stackDepth > 16)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Stack too deep."));
+	unsigned const size = _type.getSizeOnStack();
+	for (unsigned i = 0; i < size; ++i)
+		m_context << eth::dupInstruction(_stackDepth);
+}
+
+void CompilerUtils::popStackElement(Type const& _type)
+{
+	unsigned const size = _type.getSizeOnStack();
+	for (unsigned i = 0; i < size; ++i)
+		m_context << eth::Instruction::POP;
+}
+
+unsigned CompilerUtils::getSizeOnStack(vector<shared_ptr<Type const>> const& _variableTypes)
+{
+	unsigned size = 0;
+	for (shared_ptr<Type const> const& type: _variableTypes)
+		size += type->getSizeOnStack();
+	return size;
+}
+
+}
+}

libsolidity/CompilerUtils.h

@@ -0,0 +1,63 @@
+/*
+	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
+ * Routines used by both the compiler and the expression compiler.
+ */
+
+#pragma once
+
+#include <libsolidity/CompilerContext.h>
+#include <libsolidity/ASTForward.h>
+
+namespace dev {
+namespace solidity {
+
+class Type; // forward
+
+class CompilerUtils
+{
+public:
+	CompilerUtils(CompilerContext& _context): m_context(_context) {}
+
+	/// Moves the value that is at the top of the stack to a stack variable.
+	void moveToStackVariable(VariableDeclaration const& _variable);
+	/// Copies a variable of type @a _type from a stack depth of @a _stackDepth to the top of the stack.
+	void copyToStackTop(unsigned _stackDepth, Type const& _type);
+	/// Removes the current value from the top of the stack.
+	void popStackElement(Type const& _type);
+
+	template <class T>
+	static unsigned getSizeOnStack(std::vector<T> const& _variables);
+	static unsigned getSizeOnStack(std::vector<std::shared_ptr<Type const>> const& _variableTypes);
+
+private:
+	CompilerContext& m_context;
+};
+
+template <class T>
+unsigned CompilerUtils::getSizeOnStack(std::vector<T> const& _variables)
+{
+	unsigned size = 0;
+	for (T const& variable: _variables)
+		size += variable->getType()->getSizeOnStack();
+	return size;
+}
+
+}
+}

libsolidity/DeclarationContainer.cpp

@@ -28,15 +28,15 @@ namespace dev
 namespace solidity
 {
 
-bool DeclarationContainer::registerDeclaration(Declaration& _declaration)
+bool DeclarationContainer::registerDeclaration(Declaration const& _declaration, bool _update)
 {
-	if (m_declarations.find(_declaration.getName()) != m_declarations.end())
+	if (!_update && m_declarations.find(_declaration.getName()) != m_declarations.end())
 		return false;
 	m_declarations[_declaration.getName()] = &_declaration;
 	return true;
 }
 
-Declaration* DeclarationContainer::resolveName(ASTString const& _name, bool _recursive) const
+Declaration const* DeclarationContainer::resolveName(ASTString const& _name, bool _recursive) const
 {
 	auto result = m_declarations.find(_name);
 	if (result != m_declarations.end())

libsolidity/DeclarationContainer.h

@@ -39,18 +39,19 @@ namespace solidity
 class DeclarationContainer
 {
 public:
-	explicit DeclarationContainer(Declaration* _enclosingDeclaration = nullptr, DeclarationContainer* _enclosingContainer = nullptr):
+	explicit DeclarationContainer(Declaration const* _enclosingDeclaration = nullptr,
+								  DeclarationContainer const* _enclosingContainer = nullptr):
 		m_enclosingDeclaration(_enclosingDeclaration), m_enclosingContainer(_enclosingContainer) {}
 	/// Registers the declaration in the scope unless its name is already declared. Returns true iff
 	/// it was not yet declared.
-	bool registerDeclaration(Declaration& _declaration);
+	bool registerDeclaration(Declaration const& _declaration, bool _update = false);
-	Declaration* resolveName(ASTString const& _name, bool _recursive = false) const;
+	Declaration const* resolveName(ASTString const& _name, bool _recursive = false) const;
-	Declaration* getEnclosingDeclaration() const { return m_enclosingDeclaration; }
+	Declaration const* getEnclosingDeclaration() const { return m_enclosingDeclaration; }
 
 private:
-	Declaration* m_enclosingDeclaration;
+	Declaration const* m_enclosingDeclaration;
-	DeclarationContainer* m_enclosingContainer;
+	DeclarationContainer const* m_enclosingContainer;
-	std::map<ASTString, Declaration*> m_declarations;
+	std::map<ASTString, Declaration const*> m_declarations;
 };
 
 }

libsolidity/Exceptions.h

@@ -38,7 +38,6 @@ struct CompilerError: virtual Exception {};
 struct InternalCompilerError: virtual Exception {};
 struct DocstringParsingError: virtual Exception {};
 
-typedef boost::error_info<struct tag_sourcePosition, int> errinfo_sourcePosition;
 typedef boost::error_info<struct tag_sourceLocation, Location> errinfo_sourceLocation;
 
 }

libsolidity/ExpressionCompiler.cpp

@@ -26,13 +26,14 @@
 #include <libsolidity/AST.h>
 #include <libsolidity/ExpressionCompiler.h>
 #include <libsolidity/CompilerContext.h>
+#include <libsolidity/CompilerUtils.h>
 
 using namespace std;
 
 namespace dev {
 namespace solidity {
 
-void ExpressionCompiler::compileExpression(CompilerContext& _context, Expression& _expression)
+void ExpressionCompiler::compileExpression(CompilerContext& _context, Expression const& _expression)
 {
 	ExpressionCompiler compiler(_context);
 	_expression.accept(compiler);
@@ -45,7 +46,7 @@ void ExpressionCompiler::appendTypeConversion(CompilerContext& _context,
 	compiler.appendTypeConversion(_typeOnStack, _targetType);
 }
 
-bool ExpressionCompiler::visit(Assignment& _assignment)
+bool ExpressionCompiler::visit(Assignment const& _assignment)
 {
 	_assignment.getRightHandSide().accept(*this);
 	appendTypeConversion(*_assignment.getRightHandSide().getType(), *_assignment.getType());
@@ -67,7 +68,7 @@ bool ExpressionCompiler::visit(Assignment& _assignment)
 	return false;
 }
 
-void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation)
+void ExpressionCompiler::endVisit(UnaryOperation const& _unaryOperation)
 {
 	//@todo type checking and creating code for an operator should be in the same place:
 	// the operator should know how to convert itself and to which types it applies, so
@@ -128,10 +129,10 @@ void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation)
 	}
 }
 
-bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation)
+bool ExpressionCompiler::visit(BinaryOperation const& _binaryOperation)
 {
-	Expression& leftExpression = _binaryOperation.getLeftExpression();
+	Expression const& leftExpression = _binaryOperation.getLeftExpression();
-	Expression& rightExpression = _binaryOperation.getRightExpression();
+	Expression const& rightExpression = _binaryOperation.getRightExpression();
 	Type const& commonType = _binaryOperation.getCommonType();
 	Token::Value const op = _binaryOperation.getOperator();
 
@@ -158,7 +159,7 @@ bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation)
 	return false;
 }
 
-bool ExpressionCompiler::visit(FunctionCall& _functionCall)
+bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 {
 	using Location = FunctionType::Location;
 	if (_functionCall.isTypeConversion())
@@ -166,7 +167,7 @@ bool ExpressionCompiler::visit(FunctionCall& _functionCall)
 		//@todo struct construction
 		if (asserts(_functionCall.getArguments().size() == 1))
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
-		Expression& firstArgument = *_functionCall.getArguments().front();
+		Expression const& firstArgument = *_functionCall.getArguments().front();
 		firstArgument.accept(*this);
 		if (firstArgument.getType()->getCategory() == Type::Category::CONTRACT &&
 				_functionCall.getType()->getCategory() == Type::Category::INTEGER)
@@ -174,18 +175,18 @@ bool ExpressionCompiler::visit(FunctionCall& _functionCall)
 			// explicit type conversion contract -> address, nothing to do.
 		}
 		else
-		{
 			appendTypeConversion(*firstArgument.getType(), *_functionCall.getType());
-		}
 	}
 	else
 	{
 		FunctionType const& function = dynamic_cast<FunctionType const&>(*_functionCall.getExpression().getType());
-		std::vector<ASTPointer<Expression>> const& arguments = _functionCall.getArguments();
+		std::vector<ASTPointer<Expression const>> arguments = _functionCall.getArguments();
 		if (asserts(arguments.size() == function.getParameterTypes().size()))
 			BOOST_THROW_EXCEPTION(InternalCompilerError());
 
-		if (function.getLocation() == Location::INTERNAL)
+		switch (function.getLocation())
+		{
+		case Location::INTERNAL:
 		{
 			// Calling convention: Caller pushes return address and arguments
 			// Callee removes them and pushes return values
@@ -201,74 +202,104 @@ bool ExpressionCompiler::visit(FunctionCall& _functionCall)
 			m_context.appendJump();
 			m_context << returnLabel;
 
+			unsigned returnParametersSize = CompilerUtils::getSizeOnStack(function.getReturnParameterTypes());
 			// callee adds return parameters, but removes arguments and return label
-			m_context.adjustStackOffset(function.getReturnParameterTypes().size() - arguments.size() - 1);
+			m_context.adjustStackOffset(returnParametersSize - CompilerUtils::getSizeOnStack(arguments) - 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;
+				CompilerUtils(m_context).popStackElement(*function.getReturnParameterTypes()[i]);
+			break;
 		}
-		else if (function.getLocation() == Location::EXTERNAL)
+		case Location::EXTERNAL:
-			BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("External function calls not implemented yet."));
-		else
 		{
-			switch (function.getLocation())
+			unsigned dataOffset = 1; // reserve one byte for the function index
-			{
+			for (unsigned i = 0; i < arguments.size(); ++i)
-			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},
+				arguments[i]->accept(*this);
-																   {Location::SHA256, 2},
+				Type const& type = *function.getParameterTypes()[i];
-																   {Location::RIPEMD160, 3}};
+				appendTypeConversion(*arguments[i]->getType(), type);
-				u256 contractAddress = contractAddresses.find(function.getLocation())->second;
+				unsigned const numBytes = type.getCalldataEncodedSize();
-				// @todo later, combine this code with external function call
+				if (numBytes == 0 || numBytes > 32)
-				for (unsigned i = 0; i < arguments.size(); ++i)
+					BOOST_THROW_EXCEPTION(CompilerError()
-				{
+										  << errinfo_sourceLocation(arguments[i]->getLocation())
-					arguments[i]->accept(*this);
+										  << errinfo_comment("Type " + type.toString() + " not yet supported."));
-					appendTypeConversion(*arguments[i]->getType(), *function.getParameterTypes()[i], true);
+				if (numBytes != 32)
-					// @todo move this once we actually use memory
+					m_context << (u256(1) << ((32 - numBytes) * 8)) << eth::Instruction::MUL;
-					m_context << u256(i * 32) << eth::Instruction::MSTORE;
+				m_context << u256(dataOffset) << eth::Instruction::MSTORE;
-				}
+				dataOffset += numBytes;
-				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:
+			//@todo only return the first return value for now
-				BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Function not yet implemented."));
+			unsigned retSize = function.getReturnParameterTypes().empty() ? 0
+									: function.getReturnParameterTypes().front()->getCalldataEncodedSize();
+			// CALL arguments: outSize, outOff, inSize, inOff, value, addr, gas (stack top)
+			m_context << u256(retSize) << u256(0) << u256(dataOffset) << u256(0) << u256(0);
+			_functionCall.getExpression().accept(*this); // pushes addr and function index
+			m_context << u256(0) << eth::Instruction::MSTORE8
+					  << u256(25) << eth::Instruction::GAS << eth::Instruction::SUB
+					  << eth::Instruction::CALL
+					  << eth::Instruction::POP; // @todo do not ignore failure indicator
+			if (retSize == 32)
+				m_context << u256(0) << eth::Instruction::MLOAD;
+			else if (retSize > 0)
+				m_context << (u256(1) << ((32 - retSize) * 8))
+						  << u256(0) << eth::Instruction::MLOAD << eth::Instruction::DIV;
+			break;
+		}
+		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("Invalid function type."));
 		}
 	}
 	return false;
 }
 
-void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
+void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
 {
 	ASTString const& member = _memberAccess.getMemberName();
 	switch (_memberAccess.getExpression().getType()->getCategory())
@@ -289,9 +320,11 @@ void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
 			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."));
+		ContractType const& type = dynamic_cast<ContractType const&>(*_memberAccess.getExpression().getType());
+		m_context << type.getFunctionIndex(member);
 		break;
+	}
 	case Type::Category::MAGIC:
 		// we can ignore the kind of magic and only look at the name of the member
 		if (member == "coinbase")
@@ -323,7 +356,7 @@ void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
 	{
 		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 = LValue(m_context, LValue::STORAGE, *_memberAccess.getType());
 		m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess);
 		break;
 	}
@@ -332,7 +365,7 @@ void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
 	}
 }
 
-bool ExpressionCompiler::visit(IndexAccess& _indexAccess)
+bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 {
 	_indexAccess.getBaseExpression().accept(*this);
 	_indexAccess.getIndexExpression().accept(*this);
@@ -343,36 +376,36 @@ bool ExpressionCompiler::visit(IndexAccess& _indexAccess)
 	m_context << u256(32) << eth::Instruction::MSTORE << u256(0) << eth::Instruction::MSTORE;
 	m_context << u256(64) << u256(0) << eth::Instruction::SHA3;
 
-	m_currentLValue = LValue(m_context, LValue::STORAGE);
+	m_currentLValue = LValue(m_context, LValue::STORAGE, *_indexAccess.getType());
 	m_currentLValue.retrieveValueIfLValueNotRequested(_indexAccess);
 
 	return false;
 }
 
-void ExpressionCompiler::endVisit(Identifier& _identifier)
+void ExpressionCompiler::endVisit(Identifier const& _identifier)
 {
-	Declaration* declaration = _identifier.getReferencedDeclaration();
+	Declaration const* declaration = _identifier.getReferencedDeclaration();
-	if (MagicVariableDeclaration* magicVar = dynamic_cast<MagicVariableDeclaration*>(declaration))
+	if (MagicVariableDeclaration const* magicVar = dynamic_cast<MagicVariableDeclaration const*>(declaration))
 	{
 		if (magicVar->getType()->getCategory() == Type::Category::CONTRACT) // must be "this"
 			m_context << eth::Instruction::ADDRESS;
 		return;
 	}
-	if (FunctionDefinition* functionDef = dynamic_cast<FunctionDefinition*>(declaration))
+	if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(declaration))
 	{
 		m_context << m_context.getFunctionEntryLabel(*functionDef).pushTag();
 		return;
 	}
-	if (/*VariableDeclaration* varDef = */dynamic_cast<VariableDeclaration*>(declaration))
+	if (dynamic_cast<VariableDeclaration const*>(declaration))
 	{
-		m_currentLValue.fromIdentifier(_identifier, *_identifier.getReferencedDeclaration());
+		m_currentLValue.fromIdentifier(_identifier, *declaration);
 		m_currentLValue.retrieveValueIfLValueNotRequested(_identifier);
 		return;
 	}
 	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Identifier type not expected in expression context."));
 }
 
-void ExpressionCompiler::endVisit(Literal& _literal)
+void ExpressionCompiler::endVisit(Literal const& _literal)
 {
 	switch (_literal.getType()->getCategory())
 	{
@@ -385,7 +418,7 @@ void ExpressionCompiler::endVisit(Literal& _literal)
 	}
 }
 
-void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation& _binaryOperation)
+void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryOperation)
 {
 	Token::Value const op = _binaryOperation.getOperator();
 	if (asserts(op == Token::OR || op == Token::AND))
@@ -532,6 +565,13 @@ void ExpressionCompiler::appendHighBitsCleanup(IntegerType const& _typeOnStack)
 		m_context << ((u256(1) << _typeOnStack.getNumBits()) - 1) << eth::Instruction::AND;
 }
 
+ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType,
+								   unsigned _baseStackOffset):
+	m_context(&_compilerContext), m_type(_type), m_baseStackOffset(_baseStackOffset),
+	m_stackSize(_dataType.getSizeOnStack())
+{
+}
+
 void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bool _remove) const
 {
 	switch (m_type)
@@ -542,7 +582,8 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 		if (stackPos >= 15) //@todo correct this by fetching earlier or moving to memory
 			BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation())
 												  << errinfo_comment("Stack too deep."));
-		*m_context << eth::dupInstruction(stackPos + 1);
+		for (unsigned i = 0; i < m_stackSize; ++i)
+			*m_context << eth::dupInstruction(stackPos + 1);
 		break;
 	}
 	case STORAGE:
@@ -550,7 +591,17 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 			break; // no distinction between value and reference for non-value types
 		if (!_remove)
 			*m_context << eth::Instruction::DUP1;
-		*m_context << eth::Instruction::SLOAD;
+		if (m_stackSize == 1)
+			*m_context << eth::Instruction::SLOAD;
+		else
+			for (unsigned i = 0; i < m_stackSize; ++i)
+			{
+				*m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1;
+				if (i + 1 < m_stackSize)
+					 *m_context << u256(1) << eth::Instruction::ADD;
+				else
+					*m_context << eth::Instruction::POP;
+			}
 		break;
 	case MEMORY:
 		if (!_expression.getType()->isValueType())
@@ -571,12 +622,13 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, bool
 	{
 	case STACK:
 	{
-		unsigned stackPos = m_context->baseToCurrentStackOffset(unsigned(m_baseStackOffset));
+		unsigned stackDiff = m_context->baseToCurrentStackOffset(unsigned(m_baseStackOffset)) - m_stackSize + 1;
-		if (stackPos > 16)
+		if (stackDiff > 16)
 			BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation())
 												  << errinfo_comment("Stack too deep."));
-		else if (stackPos > 0)
+		else if (stackDiff > 0)
-			*m_context << eth::swapInstruction(stackPos) << eth::Instruction::POP;
+			for (unsigned i = 0; i < m_stackSize; ++i)
+				*m_context << eth::swapInstruction(stackDiff) << eth::Instruction::POP;
 		if (!_move)
 			retrieveValue(_expression);
 		break;
@@ -584,9 +636,27 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, bool
 	case LValue::STORAGE:
 		if (!_expression.getType()->isValueType())
 			break; // no distinction between value and reference for non-value types
-		if (!_move)
+		// stack layout: value value ... value ref
-			*m_context << eth::Instruction::DUP2 << eth::Instruction::SWAP1;
+		if (!_move) // copy values
-		*m_context << eth::Instruction::SSTORE;
+		{
+			if (m_stackSize + 1 > 16)
+				BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation())
+													  << errinfo_comment("Stack too deep."));
+			for (unsigned i = 0; i < m_stackSize; ++i)
+				*m_context << eth::dupInstruction(m_stackSize + 1) << eth::Instruction::SWAP1;
+		}
+		if (m_stackSize > 0) // store high index value first
+			*m_context << u256(m_stackSize - 1) << eth::Instruction::ADD;
+		for (unsigned i = 0; i < m_stackSize; ++i)
+		{
+			if (i + 1 >= m_stackSize)
+				*m_context << eth::Instruction::SSTORE;
+			else
+				// v v ... v v r+x
+				*m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2
+						   << eth::Instruction::SSTORE
+						   << u256(1) << eth::Instruction::SWAP1 << eth::Instruction::SUB;
+		}
 		break;
 	case LValue::MEMORY:
 		if (!_expression.getType()->isValueType())
@@ -612,6 +682,7 @@ void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(Expression co
 
 void ExpressionCompiler::LValue::fromIdentifier(Identifier const& _identifier, Declaration const& _declaration)
 {
+	m_stackSize = _identifier.getType()->getSizeOnStack();
 	if (m_context->isLocalVariable(&_declaration))
 	{
 		m_type = STACK;

libsolidity/ExpressionCompiler.h

@@ -31,20 +31,21 @@ class AssemblyItem; // forward
 }
 namespace solidity {
 
-class CompilerContext; // forward
+// forward declarations
-class Type; // forward
+class CompilerContext;
-class IntegerType; // forward
+class Type;
+class IntegerType;
 
 /**
  * Compiler for expressions, i.e. converts an AST tree whose root is an Expression into a stream
  * of EVM instructions. It needs a compiler context that is the same for the whole compilation
  * unit.
  */
-class ExpressionCompiler: private ASTVisitor
+class ExpressionCompiler: private ASTConstVisitor
 {
 public:
 	/// Compile the given @a _expression into the @a _context.
-	static void compileExpression(CompilerContext& _context, Expression& _expression);
+	static void compileExpression(CompilerContext& _context, Expression const& _expression);
 
 	/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
 	static void appendTypeConversion(CompilerContext& _context, Type const& _typeOnStack, Type const& _targetType);
@@ -53,18 +54,18 @@ private:
 	ExpressionCompiler(CompilerContext& _compilerContext):
 		m_context(_compilerContext), m_currentLValue(m_context) {}
 
-	virtual bool visit(Assignment& _assignment) override;
+	virtual bool visit(Assignment const& _assignment) override;
-	virtual void endVisit(UnaryOperation& _unaryOperation) override;
+	virtual void endVisit(UnaryOperation const& _unaryOperation) override;
-	virtual bool visit(BinaryOperation& _binaryOperation) override;
+	virtual bool visit(BinaryOperation const& _binaryOperation) override;
-	virtual bool visit(FunctionCall& _functionCall) override;
+	virtual bool visit(FunctionCall const& _functionCall) override;
-	virtual void endVisit(MemberAccess& _memberAccess) override;
+	virtual void endVisit(MemberAccess const& _memberAccess) override;
-	virtual bool visit(IndexAccess& _indexAccess) override;
+	virtual bool visit(IndexAccess const& _indexAccess) override;
-	virtual void endVisit(Identifier& _identifier) override;
+	virtual void endVisit(Identifier const& _identifier) override;
-	virtual void endVisit(Literal& _literal) override;
+	virtual void endVisit(Literal const& _literal) override;
 
 	///@{
 	///@name Append code for various operator types
-	void appendAndOrOperatorCode(BinaryOperation& _binaryOperation);
+	void appendAndOrOperatorCode(BinaryOperation const& _binaryOperation);
 	void appendCompareOperatorCode(Token::Value _operator, Type const& _type);
 	void appendOrdinaryBinaryOperatorCode(Token::Value _operator, Type const& _type);
 
@@ -92,8 +93,7 @@ private:
 		enum LValueType { NONE, STACK, MEMORY, STORAGE };
 
 		explicit LValue(CompilerContext& _compilerContext): m_context(&_compilerContext) { reset(); }
-		LValue(CompilerContext& _compilerContext, LValueType _type, unsigned _baseStackOffset = 0):
+		LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType, 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
@@ -128,14 +128,12 @@ private:
 		/// If m_type is STACK, this is base stack offset (@see
 		/// CompilerContext::getBaseStackOffsetOfVariable) of a local variable.
 		unsigned m_baseStackOffset;
+		/// Size of the value of this lvalue on the stack.
+		unsigned m_stackSize;
 	};
 
 	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

@@ -68,17 +68,16 @@ void GlobalContext::setCurrentContract(ContractDefinition const& _contract)
 	m_currentContract = &_contract;
 }
 
-vector<Declaration*> GlobalContext::getDeclarations() const
+vector<Declaration const*> GlobalContext::getDeclarations() const
 {
-	vector<Declaration*> declarations;
+	vector<Declaration const*> declarations;
 	declarations.reserve(m_magicVariables.size() + 1);
-	for (ASTPointer<Declaration> const& variable: m_magicVariables)
+	for (ASTPointer<Declaration const> const& variable: m_magicVariables)
 		declarations.push_back(variable.get());
-	declarations.push_back(getCurrentThis());
 	return declarations;
 }
 
-MagicVariableDeclaration*GlobalContext::getCurrentThis() const
+MagicVariableDeclaration const* GlobalContext::getCurrentThis() const
 {
 	if (!m_thisPointer[m_currentContract])
 		m_thisPointer[m_currentContract] = make_shared<MagicVariableDeclaration>(

libsolidity/GlobalContext.h

@@ -47,15 +47,17 @@ class GlobalContext: private boost::noncopyable
 public:
 	GlobalContext();
 	void setCurrentContract(ContractDefinition const& _contract);
+	MagicVariableDeclaration const* getCurrentThis() const;
 
+	/// @returns all magic variables.
 	std::vector<MagicVariableDeclaration const*> getMagicVariables() const;
-	std::vector<Declaration*> getDeclarations() const;
+	/// @returns a vector of all implicit global declarations excluding "this".
+	std::vector<Declaration const*> getDeclarations() const;
 
 private:
-	MagicVariableDeclaration* getCurrentThis() const;
+	std::vector<std::shared_ptr<MagicVariableDeclaration const>> m_magicVariables;
-	std::vector<std::shared_ptr<MagicVariableDeclaration>> m_magicVariables;
 	ContractDefinition const* m_currentContract;
-	std::map<ContractDefinition const*, std::shared_ptr<MagicVariableDeclaration>> mutable m_thisPointer;
+	std::map<ContractDefinition const*, std::shared_ptr<MagicVariableDeclaration const>> mutable m_thisPointer;
 };
 
 }

libsolidity/InterfaceHandler.cpp

@@ -15,7 +15,7 @@ InterfaceHandler::InterfaceHandler()
 	m_lastTag = DocTagType::NONE;
 }
 
-std::unique_ptr<std::string> InterfaceHandler::getDocumentation(std::shared_ptr<ContractDefinition> _contractDef,
+std::unique_ptr<std::string> InterfaceHandler::getDocumentation(ContractDefinition& _contractDef,
 																DocumentationType _type)
 {
 	switch(_type)
@@ -32,11 +32,11 @@ std::unique_ptr<std::string> InterfaceHandler::getDocumentation(std::shared_ptr<
 	return nullptr;
 }
 
-std::unique_ptr<std::string> InterfaceHandler::getABIInterface(std::shared_ptr<ContractDefinition> _contractDef)
+std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinition& _contractDef)
 {
 	Json::Value methods(Json::arrayValue);
 
-	for (FunctionDefinition const* f: _contractDef->getInterfaceFunctions())
+	for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions())
 	{
 		Json::Value method;
 		Json::Value inputs(Json::arrayValue);
@@ -63,12 +63,12 @@ std::unique_ptr<std::string> InterfaceHandler::getABIInterface(std::shared_ptr<C
 	return std::unique_ptr<std::string>(new std::string(m_writer.write(methods)));
 }
 
-std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(std::shared_ptr<ContractDefinition> _contractDef)
+std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(ContractDefinition& _contractDef)
 {
 	Json::Value doc;
 	Json::Value methods(Json::objectValue);
 
-	for (FunctionDefinition const* f: _contractDef->getInterfaceFunctions())
+	for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions())
 	{
 		Json::Value user;
 		auto strPtr = f->getDocumentation();
@@ -88,14 +88,14 @@ std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(std::shared_
 	return std::unique_ptr<std::string>(new std::string(m_writer.write(doc)));
 }
 
-std::unique_ptr<std::string> InterfaceHandler::getDevDocumentation(std::shared_ptr<ContractDefinition> _contractDef)
+std::unique_ptr<std::string> InterfaceHandler::getDevDocumentation(ContractDefinition& _contractDef)
 {
 	// LTODO: Somewhere in this function warnings for mismatch of param names
 	// should be thrown
 	Json::Value doc;
 	Json::Value methods(Json::objectValue);
 
-	for (FunctionDefinition const* f: _contractDef->getInterfaceFunctions())
+	for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions())
 	{
 		Json::Value method;
 		auto strPtr = f->getDocumentation();

libsolidity/InterfaceHandler.h

@@ -59,23 +59,23 @@ public:
 	///                     types provided by @c DocumentationType
 	/// @return             A unique pointer contained string with the json
 	///                     representation of provided type
-	std::unique_ptr<std::string> getDocumentation(std::shared_ptr<ContractDefinition> _contractDef,
+	std::unique_ptr<std::string> getDocumentation(ContractDefinition& _contractDef,
 												  DocumentationType _type);
 	/// Get the ABI Interface of the contract
 	/// @param _contractDef The contract definition
 	/// @return             A unique pointer contained string with the json
 	///                     representation of the contract's ABI Interface
-	std::unique_ptr<std::string> getABIInterface(std::shared_ptr<ContractDefinition> _contractDef);
+	std::unique_ptr<std::string> getABIInterface(ContractDefinition& _contractDef);
 	/// Get the User documentation of the contract
 	/// @param _contractDef The contract definition
 	/// @return             A unique pointer contained string with the json
 	///                     representation of the contract's user documentation
-	std::unique_ptr<std::string> getUserDocumentation(std::shared_ptr<ContractDefinition> _contractDef);
+	std::unique_ptr<std::string> getUserDocumentation(ContractDefinition& _contractDef);
 	/// Get the Developer's documentation of the contract
 	/// @param _contractDef The contract definition
 	/// @return             A unique pointer contained string with the json
 	///                     representation of the contract's developer documentation
-	std::unique_ptr<std::string> getDevDocumentation(std::shared_ptr<ContractDefinition> _contractDef);
+	std::unique_ptr<std::string> getDevDocumentation(ContractDefinition& _contractDef);
 
 private:
 	void resetUser();

libsolidity/NameAndTypeResolver.cpp

@@ -32,15 +32,20 @@ namespace solidity
 {
 
 
-NameAndTypeResolver::NameAndTypeResolver(std::vector<Declaration*> const& _globals)
+NameAndTypeResolver::NameAndTypeResolver(std::vector<Declaration const*> const& _globals)
 {
-	for (Declaration* declaration: _globals)
+	for (Declaration const* declaration: _globals)
 		m_scopes[nullptr].registerDeclaration(*declaration);
 }
 
+void NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit)
+{
+	// The helper registers all declarations in m_scopes as a side-effect of its construction.
+	DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit);
+}
+
 void NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract)
 {
-	DeclarationRegistrationHelper registrar(m_scopes, _contract);
 	m_currentScope = &m_scopes[&_contract];
 	for (ASTPointer<StructDefinition> const& structDef: _contract.getDefinedStructs())
 		ReferencesResolver resolver(*structDef, *this, nullptr);
@@ -65,7 +70,14 @@ void NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract)
 	m_currentScope = &m_scopes[nullptr];
 }
 
-Declaration* NameAndTypeResolver::resolveName(ASTString const& _name, Declaration const* _scope) const
+void NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
+{
+	m_scopes[nullptr].registerDeclaration(_declaration, true);
+	if (asserts(_declaration.getScope() == nullptr))
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Updated declaration outside global scope."));
+}
+
+Declaration const* NameAndTypeResolver::resolveName(ASTString const& _name, Declaration const* _scope) const
 {
 	auto iterator = m_scopes.find(_scope);
 	if (iterator == end(m_scopes))
@@ -73,7 +85,7 @@ Declaration* NameAndTypeResolver::resolveName(ASTString const& _name, Declaratio
 	return iterator->second.resolveName(_name, false);
 }
 
-Declaration* NameAndTypeResolver::getNameFromCurrentScope(ASTString const& _name, bool _recursive)
+Declaration const* NameAndTypeResolver::getNameFromCurrentScope(ASTString const& _name, bool _recursive)
 {
 	return m_currentScope->resolveName(_name, _recursive);
 }
@@ -135,7 +147,7 @@ bool DeclarationRegistrationHelper::visit(VariableDeclaration& _declaration)
 	return true;
 }
 
-void DeclarationRegistrationHelper::enterNewSubScope(Declaration& _declaration)
+void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration)
 {
 	map<ASTNode const*, DeclarationContainer>::iterator iter;
 	bool newlyAdded;
@@ -193,15 +205,14 @@ bool ReferencesResolver::visit(Return& _return)
 	return true;
 }
 
-bool ReferencesResolver::visit(Mapping& _mapping)
+bool ReferencesResolver::visit(Mapping&)
 {
-	(void)_mapping;
 	return true;
 }
 
 bool ReferencesResolver::visit(UserDefinedTypeName& _typeName)
 {
-	Declaration* declaration = m_resolver.getNameFromCurrentScope(_typeName.getName());
+	Declaration const* declaration = m_resolver.getNameFromCurrentScope(_typeName.getName());
 	if (!declaration)
 		BOOST_THROW_EXCEPTION(DeclarationError() << errinfo_sourceLocation(_typeName.getLocation())
 												 << errinfo_comment("Undeclared identifier."));
@@ -211,7 +222,7 @@ bool ReferencesResolver::visit(UserDefinedTypeName& _typeName)
 
 bool ReferencesResolver::visit(Identifier& _identifier)
 {
-	Declaration* declaration = m_resolver.getNameFromCurrentScope(_identifier.getName());
+	Declaration const* declaration = m_resolver.getNameFromCurrentScope(_identifier.getName());
 	if (!declaration)
 		BOOST_THROW_EXCEPTION(DeclarationError() << errinfo_sourceLocation(_identifier.getLocation())
 												 << errinfo_comment("Undeclared identifier."));

libsolidity/NameAndTypeResolver.h

@@ -41,21 +41,25 @@ namespace solidity
 class NameAndTypeResolver: private boost::noncopyable
 {
 public:
-	explicit NameAndTypeResolver(std::vector<Declaration*> const& _globals);
+	explicit NameAndTypeResolver(std::vector<Declaration const*> const& _globals);
+	/// Registers all declarations found in the source unit.
+	void registerDeclarations(SourceUnit& _sourceUnit);
+	/// Resolves all names and types referenced from the given contract.
 	void resolveNamesAndTypes(ContractDefinition& _contract);
+	/// Updates the given global declaration (used for "this"). Not to be used with declarations
+	/// that create their own scope.
+	void updateDeclaration(Declaration const& _declaration);
 
 	/// Resolves the given @a _name inside the scope @a _scope. If @a _scope is omitted,
 	/// the global scope is used (i.e. the one containing only the contract).
 	/// @returns a pointer to the declaration on success or nullptr on failure.
-	Declaration* resolveName(ASTString const& _name, Declaration const* _scope = nullptr) const;
+	Declaration const* resolveName(ASTString const& _name, Declaration const* _scope = nullptr) const;
 
 	/// Resolves a name in the "current" scope. Should only be called during the initial
 	/// resolving phase.
-	Declaration* getNameFromCurrentScope(ASTString const& _name, bool _recursive = true);
+	Declaration const* getNameFromCurrentScope(ASTString const& _name, bool _recursive = true);
 
 private:
-	/// Throws if @a _struct contains a recursive loop. Note that recursion via mappings is fine.
-	void checkForRecursion(StructDefinition const& _struct);
 	void reset();
 
 	/// Maps nodes declaring a scope to scopes, i.e. ContractDefinition and FunctionDeclaration,
@@ -85,12 +89,12 @@ private:
 	void endVisit(VariableDefinition& _variableDefinition);
 	bool visit(VariableDeclaration& _declaration);
 
-	void enterNewSubScope(Declaration& _declaration);
+	void enterNewSubScope(Declaration const& _declaration);
 	void closeCurrentScope();
 	void registerDeclaration(Declaration& _declaration, bool _opensScope);
 
 	std::map<ASTNode const*, DeclarationContainer>& m_scopes;
-	Declaration* m_currentScope;
+	Declaration const* m_currentScope;
 	FunctionDefinition* m_currentFunction;
 };
 

libsolidity/Parser.cpp

@@ -20,30 +20,27 @@
  * Solidity parser.
  */
 
+#include <vector>
 #include <libdevcore/Log.h>
 #include <libsolidity/BaseTypes.h>
 #include <libsolidity/Parser.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Exceptions.h>
 
+using namespace std;
+
 namespace dev
 {
 namespace solidity
 {
 
-ASTPointer<ContractDefinition> Parser::parse(std::shared_ptr<Scanner> const& _scanner)
-{
-	m_scanner = _scanner;
-	return parseContractDefinition();
-}
-
-
 /// AST node factory that also tracks the begin and end position of an AST node
 /// while it is being parsed
 class Parser::ASTNodeFactory
 {
 public:
-	ASTNodeFactory(Parser const& _parser): m_parser(_parser), m_location(_parser.getPosition(), -1) {}
+	ASTNodeFactory(Parser const& _parser):
+		m_parser(_parser), m_location(_parser.getPosition(), -1, _parser.getSourceName()) {}
 
 	void markEndPosition() { m_location.end = m_parser.getEndPosition(); }
 	void setLocationEmpty() { m_location.end = m_location.start; }
@@ -55,7 +52,7 @@ public:
 	{
 		if (m_location.end < 0)
 			markEndPosition();
-		return std::make_shared<NodeType>(m_location, std::forward<Args>(_args)...);
+		return make_shared<NodeType>(m_location, forward<Args>(_args)...);
 	}
 
 private:
@@ -63,6 +60,33 @@ private:
 	Location m_location;
 };
 
+ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
+{
+	m_scanner = _scanner;
+	ASTNodeFactory nodeFactory(*this);
+	vector<ASTPointer<ASTNode>> nodes;
+	while (_scanner->getCurrentToken() != Token::EOS)
+	{
+		switch (m_scanner->getCurrentToken())
+		{
+		case Token::IMPORT:
+			nodes.push_back(parseImportDirective());
+			break;
+		case Token::CONTRACT:
+			nodes.push_back(parseContractDefinition());
+			break;
+		default:
+			BOOST_THROW_EXCEPTION(createParserError(std::string("Expected import directive or contract definition.")));
+		}
+	}
+	return nodeFactory.createNode<SourceUnit>(nodes);
+}
+
+std::shared_ptr<const string> const& Parser::getSourceName() const
+{
+	return m_scanner->getSourceName();
+}
+
 int Parser::getPosition() const
 {
 	return m_scanner->getCurrentLocation().start;
@@ -73,15 +97,27 @@ int Parser::getEndPosition() const
 	return m_scanner->getCurrentLocation().end;
 }
 
+ASTPointer<ImportDirective> Parser::parseImportDirective()
+{
+	ASTNodeFactory nodeFactory(*this);
+	expectToken(Token::IMPORT);
+	if (m_scanner->getCurrentToken() != Token::STRING_LITERAL)
+		BOOST_THROW_EXCEPTION(createParserError("Expected string literal (URL)."));
+	ASTPointer<ASTString> url = getLiteralAndAdvance();
+	nodeFactory.markEndPosition();
+	expectToken(Token::SEMICOLON);
+	return nodeFactory.createNode<ImportDirective>(url);
+}
+
 ASTPointer<ContractDefinition> Parser::parseContractDefinition()
 {
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::CONTRACT);
 	ASTPointer<ASTString> name = expectIdentifierToken();
 	expectToken(Token::LBRACE);
-	std::vector<ASTPointer<StructDefinition>> structs;
+	vector<ASTPointer<StructDefinition>> structs;
-	std::vector<ASTPointer<VariableDeclaration>> stateVariables;
+	vector<ASTPointer<VariableDeclaration>> stateVariables;
-	std::vector<ASTPointer<FunctionDefinition>> functions;
+	vector<ASTPointer<FunctionDefinition>> functions;
 	bool visibilityIsPublic = true;
 	while (true)
 	{
@@ -110,7 +146,6 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
 	}
 	nodeFactory.markEndPosition();
 	expectToken(Token::RBRACE);
-	expectToken(Token::EOS);
 	return nodeFactory.createNode<ContractDefinition>(name, structs, stateVariables, functions);
 }
 
@@ -119,7 +154,7 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic)
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<ASTString> docstring;
 	if (m_scanner->getCurrentCommentLiteral() != "")
-		docstring = std::make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
+		docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
 
 	expectToken(Token::FUNCTION);
 	ASTPointer<ASTString> name(expectIdentifierToken());
@@ -142,7 +177,7 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic)
 		// create an empty parameter list at a zero-length location
 		ASTNodeFactory nodeFactory(*this);
 		nodeFactory.setLocationEmpty();
-		returnParameters = nodeFactory.createNode<ParameterList>(std::vector<ASTPointer<VariableDeclaration>>());
+		returnParameters = nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
 	}
 	ASTPointer<Block> block = parseBlock();
 	nodeFactory.setEndPositionFromNode(block);
@@ -156,7 +191,7 @@ ASTPointer<StructDefinition> Parser::parseStructDefinition()
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::STRUCT);
 	ASTPointer<ASTString> name = expectIdentifierToken();
-	std::vector<ASTPointer<VariableDeclaration>> members;
+	vector<ASTPointer<VariableDeclaration>> members;
 	expectToken(Token::LBRACE);
 	while (m_scanner->getCurrentToken() != Token::RBRACE)
 	{
@@ -228,7 +263,7 @@ ASTPointer<Mapping> Parser::parseMapping()
 ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty)
 {
 	ASTNodeFactory nodeFactory(*this);
-	std::vector<ASTPointer<VariableDeclaration>> parameters;
+	vector<ASTPointer<VariableDeclaration>> parameters;
 	expectToken(Token::LPAREN);
 	if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN)
 	{
@@ -249,7 +284,7 @@ ASTPointer<Block> Parser::parseBlock()
 {
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::LBRACE);
-	std::vector<ASTPointer<Statement>> statements;
+	vector<ASTPointer<Statement>> statements;
 	while (m_scanner->getCurrentToken() != Token::RBRACE)
 		statements.push_back(parseStatement());
 	nodeFactory.markEndPosition();
@@ -447,7 +482,7 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
 		case Token::LPAREN:
 		{
 			m_scanner->next();
-			std::vector<ASTPointer<Expression>> arguments = parseFunctionCallArguments();
+			vector<ASTPointer<Expression>> arguments = parseFunctionCallArguments();
 			nodeFactory.markEndPosition();
 			expectToken(Token::RPAREN);
 			expression = nodeFactory.createNode<FunctionCall>(expression, arguments);
@@ -503,9 +538,9 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 	return expression;
 }
 
-std::vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
+vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
 {
-	std::vector<ASTPointer<Expression>> arguments;
+	vector<ASTPointer<Expression>> arguments;
 	if (m_scanner->getCurrentToken() != Token::RPAREN)
 	{
 		arguments.push_back(parseExpression());
@@ -521,7 +556,7 @@ std::vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
 void Parser::expectToken(Token::Value _value)
 {
 	if (m_scanner->getCurrentToken() != _value)
-		BOOST_THROW_EXCEPTION(createParserError(std::string("Expected token ") + std::string(Token::getName(_value))));
+		BOOST_THROW_EXCEPTION(createParserError(string("Expected token ") + string(Token::getName(_value))));
 	m_scanner->next();
 }
 
@@ -543,14 +578,15 @@ ASTPointer<ASTString> Parser::expectIdentifierToken()
 
 ASTPointer<ASTString> Parser::getLiteralAndAdvance()
 {
-	ASTPointer<ASTString> identifier = std::make_shared<ASTString>(m_scanner->getCurrentLiteral());
+	ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->getCurrentLiteral());
 	m_scanner->next();
 	return identifier;
 }
 
-ParserError Parser::createParserError(std::string const& _description) const
+ParserError Parser::createParserError(string const& _description) const
 {
-	return ParserError() << errinfo_sourcePosition(getPosition()) << errinfo_comment(_description);
+	return ParserError() << errinfo_sourceLocation(Location(getPosition(), getPosition(), getSourceName()))
+						 << errinfo_comment(_description);
 }
 
 

libsolidity/Parser.h

@@ -34,7 +34,8 @@ class Scanner;
 class Parser
 {
 public:
-	ASTPointer<ContractDefinition> parse(std::shared_ptr<Scanner> const& _scanner);
+	ASTPointer<SourceUnit> parse(std::shared_ptr<Scanner> const& _scanner);
+	std::shared_ptr<std::string const> const& getSourceName() const;
 
 private:
 	class ASTNodeFactory;
@@ -46,6 +47,7 @@ private:
 
 	///@{
 	///@name Parsing functions for the AST nodes
+	ASTPointer<ImportDirective> parseImportDirective();
 	ASTPointer<ContractDefinition> parseContractDefinition();
 	ASTPointer<FunctionDefinition> parseFunctionDefinition(bool _isPublic);
 	ASTPointer<StructDefinition> parseStructDefinition();

libsolidity/Scanner.cpp

@@ -143,17 +143,22 @@ private:
 }; // end of LiteralScope class
 
 
-void Scanner::reset(CharStream const& _source)
+void Scanner::reset(CharStream const& _source, string const& _sourceName)
 {
 	m_source = _source;
+	m_sourceName = make_shared<string const>(_sourceName);
+	reset();
+}
+
+void Scanner::reset()
+{
+	m_source.reset();
 	m_char = m_source.get();
 	skipWhitespace();
 	scanToken();
-
 	next();
 }
 
-
 bool Scanner::scanHexByte(char& o_scannedByte)
 {
 	char x = 0;

libsolidity/Scanner.h

@@ -79,6 +79,8 @@ public:
 	char advanceAndGet(size_t _chars=1);
 	char rollback(size_t _amount);
 
+	void reset() { m_pos = 0; }
+
 	///@{
 	///@name Error printing helper functions
 	/// Functions that help pretty-printing parse errors
@@ -99,11 +101,12 @@ class Scanner
 	friend class LiteralScope;
 public:
 
-	Scanner() { reset(CharStream()); }
+	explicit Scanner(CharStream const& _source = CharStream(), std::string const& _sourceName = "") { reset(_source, _sourceName); }
-	explicit Scanner(CharStream const& _source) { reset(_source); }
 
-	/// Resets the scanner as if newly constructed with _input as input.
+	/// Resets the scanner as if newly constructed with _source and _sourceName as input.
-	void reset(CharStream const& _source);
+	void reset(CharStream const& _source, std::string const& _sourceName);
+	/// Resets scanner to the start of input.
+	void reset();
 
 	/// Returns the next token and advances input
 	Token::Value next();
@@ -139,6 +142,8 @@ public:
 	std::string const& peekLiteral() const { return m_nextToken.literal; }
 	///@}
 
+	std::shared_ptr<std::string const> const& getSourceName() const { return m_sourceName; }
+
 	///@{
 	///@name Error printing helper functions
 	/// Functions that help pretty-printing parse errors
@@ -203,6 +208,7 @@ private:
 	TokenDesc m_nextToken;     // desc for next token (one token look-ahead)
 
 	CharStream m_source;
+	std::shared_ptr<std::string const> m_sourceName;
 
 	/// one character look-ahead, equals 0 at end of input
 	char m_char;

libsolidity/SourceReferenceFormatter.cpp

@@ -21,6 +21,7 @@
  */
 
 #include <libsolidity/SourceReferenceFormatter.h>
+#include <libsolidity/CompilerStack.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Exceptions.h>
 
@@ -38,7 +39,6 @@ void SourceReferenceFormatter::printSourceLocation(ostream& _stream,
 	int startLine;
 	int startColumn;
 	tie(startLine, startColumn) = _scanner.translatePositionToLineColumn(_location.start);
-	_stream << "starting at line " << (startLine + 1) << ", column " << (startColumn + 1) << "\n";
 	int endLine;
 	int endColumn;
 	tie(endLine, endColumn) = _scanner.translatePositionToLineColumn(_location.end);
@@ -58,37 +58,28 @@ void SourceReferenceFormatter::printSourceLocation(ostream& _stream,
 				<< "Spanning multiple lines.\n";
 }
 
-void SourceReferenceFormatter::printSourcePosition(ostream& _stream,
-												   int _position,
-												   const Scanner& _scanner)
-{
-	int line;
-	int column;
-	tie(line, column) = _scanner.translatePositionToLineColumn(_position);
-	_stream << "at line " << (line + 1) << ", column " << (column + 1) << endl
-			<< _scanner.getLineAtPosition(_position) << endl
-			<< string(column, ' ') << "^" << endl;
-}
-
 void SourceReferenceFormatter::printExceptionInformation(ostream& _stream,
 														 Exception const& _exception,
 														 string const& _name,
-														 Scanner const& _scanner)
+														 CompilerStack const& _compiler)
 {
-	_stream << _name;
+	Location const* location = boost::get_error_info<errinfo_sourceLocation>(_exception);
-	if (string const* description = boost::get_error_info<errinfo_comment>(_exception))
+	Scanner const* scanner;
-		_stream << ": " << *description;
 
-	if (int const* position = boost::get_error_info<errinfo_sourcePosition>(_exception))
+	if (location)
 	{
-		_stream << " ";
+		scanner = &_compiler.getScanner(*location->sourceName);
-		printSourcePosition(_stream, *position, _scanner);
+		int startLine;
-	}
+		int startColumn;
-	if (Location const* location = boost::get_error_info<errinfo_sourceLocation>(_exception))
+		tie(startLine, startColumn) = scanner->translatePositionToLineColumn(location->start);
-	{
+		_stream << *location->sourceName << ":" << (startLine + 1) << ":" << (startColumn + 1) << ": ";
-		_stream << " ";
-		printSourceLocation(_stream, *location, _scanner);
 	}
+	_stream << _name;
+	if (string const* description = boost::get_error_info<errinfo_comment>(_exception))
+		_stream << ": " << *description << endl;
+
+	if (location)
+		printSourceLocation(_stream, *location, *scanner);
 }
 
 }

libsolidity/SourceReferenceFormatter.h

@@ -34,14 +34,14 @@ namespace solidity
 {
 
 class Scanner; // forward
+class CompilerStack; // forward
 
 struct SourceReferenceFormatter
 {
 public:
 	static void printSourceLocation(std::ostream& _stream, Location const& _location, Scanner const& _scanner);
-	static void printSourcePosition(std::ostream& _stream, int _position, Scanner const& _scanner);
 	static void printExceptionInformation(std::ostream& _stream, Exception const& _exception,
-										  std::string const& _name, Scanner const& _scanner);
+										  std::string const& _name, CompilerStack const& _compiler);
 };
 
 }

libsolidity/Types.cpp

@@ -32,7 +32,7 @@ namespace dev
 namespace solidity
 {
 
-shared_ptr<Type> Type::fromElementaryTypeName(Token::Value _typeToken)
+shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
 {
 	if (asserts(Token::isElementaryTypeName(_typeToken)))
 		BOOST_THROW_EXCEPTION(InternalCompilerError());
@@ -44,33 +44,33 @@ shared_ptr<Type> Type::fromElementaryTypeName(Token::Value _typeToken)
 		if (bytes == 0)
 			bytes = 32;
 		int modifier = offset / 33;
-		return make_shared<IntegerType>(bytes * 8,
+		return make_shared<IntegerType const>(bytes * 8,
 										modifier == 0 ? IntegerType::Modifier::SIGNED :
 										modifier == 1 ? IntegerType::Modifier::UNSIGNED :
 										IntegerType::Modifier::HASH);
 	}
 	else if (_typeToken == Token::ADDRESS)
-		return make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS);
+		return make_shared<IntegerType const>(0, IntegerType::Modifier::ADDRESS);
 	else if (_typeToken == Token::BOOL)
-		return make_shared<BoolType>();
+		return make_shared<BoolType const>();
 	else
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unable to convert elementary typename " +
 																		 std::string(Token::toString(_typeToken)) + " to type."));
 }
 
-shared_ptr<Type> Type::fromUserDefinedTypeName(UserDefinedTypeName const& _typeName)
+shared_ptr<Type const> Type::fromUserDefinedTypeName(UserDefinedTypeName const& _typeName)
 {
 	Declaration const* declaration = _typeName.getReferencedDeclaration();
 	if (StructDefinition const* structDef = dynamic_cast<StructDefinition const*>(declaration))
-		return make_shared<StructType>(*structDef);
+		return make_shared<StructType const>(*structDef);
 	else if (FunctionDefinition const* function = dynamic_cast<FunctionDefinition const*>(declaration))
-		return make_shared<FunctionType>(*function);
+		return make_shared<FunctionType const>(*function);
 	else if (ContractDefinition const* contract = dynamic_cast<ContractDefinition const*>(declaration))
-		return make_shared<ContractType>(*contract);
+		return make_shared<ContractType const>(*contract);
-	return shared_ptr<Type>();
+	return shared_ptr<Type const>();
 }
 
-shared_ptr<Type> Type::fromMapping(Mapping const& _typeName)
+shared_ptr<Type const> Type::fromMapping(Mapping const& _typeName)
 {
 	shared_ptr<Type const> keyType = _typeName.getKeyType().toType();
 	if (!keyType)
@@ -78,28 +78,28 @@ shared_ptr<Type> Type::fromMapping(Mapping const& _typeName)
 	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);
+	return make_shared<MappingType const>(keyType, valueType);
 }
 
-shared_ptr<Type> Type::forLiteral(Literal const& _literal)
+shared_ptr<Type const> Type::forLiteral(Literal const& _literal)
 {
 	switch (_literal.getToken())
 	{
 	case Token::TRUE_LITERAL:
 	case Token::FALSE_LITERAL:
-		return make_shared<BoolType>();
+		return make_shared<BoolType const>();
 	case Token::NUMBER:
 		return IntegerType::smallestTypeForLiteral(_literal.getValue());
 	case Token::STRING_LITERAL:
-		return shared_ptr<Type>(); // @todo add string literals
+		return shared_ptr<Type const>(); // @todo add string literals
 	default:
-		return shared_ptr<Type>();
+		return shared_ptr<Type const>();
 	}
 }
 
 const MemberList Type::EmptyMemberList = MemberList();
 
-shared_ptr<IntegerType> IntegerType::smallestTypeForLiteral(string const& _literal)
+shared_ptr<IntegerType const> IntegerType::smallestTypeForLiteral(string const& _literal)
 {
 	bigint value(_literal);
 	bool isSigned = value < 0 || (!_literal.empty() && _literal.front() == '-');
@@ -108,8 +108,8 @@ shared_ptr<IntegerType> IntegerType::smallestTypeForLiteral(string const& _liter
 		value = ((-value) - 1) << 1;
 	unsigned bytes = max(bytesRequired(value), 1u);
 	if (bytes > 32)
-		return shared_ptr<IntegerType>();
+		return shared_ptr<IntegerType const>();
-	return make_shared<IntegerType>(bytes * 8, isSigned ? Modifier::SIGNED : Modifier::UNSIGNED);
+	return make_shared<IntegerType const>(bytes * 8, isSigned ? Modifier::SIGNED : Modifier::UNSIGNED);
 }
 
 IntegerType::IntegerType(int _bits, IntegerType::Modifier _modifier):
@@ -140,7 +140,7 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 
 bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
-	return _convertTo.getCategory() == getCategory();
+	return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::CONTRACT;
 }
 
 bool IntegerType::acceptsBinaryOperator(Token::Value _operator) const
@@ -247,6 +247,31 @@ string ContractType::toString() const
 	return "contract " + m_contract.getName();
 }
 
+MemberList const& ContractType::getMembers() const
+{
+	// We need to lazy-initialize it because of recursive references.
+	if (!m_members)
+	{
+		map<string, shared_ptr<Type const>> members;
+		for (FunctionDefinition const* function: m_contract.getInterfaceFunctions())
+			members[function->getName()] = make_shared<FunctionType>(*function, false);
+		m_members.reset(new MemberList(members));
+	}
+	return *m_members;
+}
+
+unsigned ContractType::getFunctionIndex(string const& _functionName) const
+{
+	unsigned index = 0;
+	for (FunctionDefinition const* function: m_contract.getInterfaceFunctions())
+	{
+		if (function->getName() == _functionName)
+			return index;
+		++index;
+	}
+	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Index of non-existing contract function requested."));
+}
+
 bool StructType::operator==(Type const& _other) const
 {
 	if (_other.getCategory() != getCategory())
@@ -302,7 +327,7 @@ u256 StructType::getStorageOffsetOfMember(string const& _name) const
 	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage offset of non-existing member requested."));
 }
 
-FunctionType::FunctionType(FunctionDefinition const& _function)
+FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal)
 {
 	TypePointers params;
 	TypePointers retParams;
@@ -314,7 +339,7 @@ FunctionType::FunctionType(FunctionDefinition const& _function)
 		retParams.push_back(var->getType());
 	swap(params, m_parameterTypes);
 	swap(retParams, m_returnParameterTypes);
-	m_location = Location::INTERNAL;
+	m_location = _isInternal ? Location::INTERNAL : Location::EXTERNAL;
 }
 
 bool FunctionType::operator==(Type const& _other) const
@@ -323,6 +348,8 @@ bool FunctionType::operator==(Type const& _other) const
 		return false;
 	FunctionType const& other = dynamic_cast<FunctionType const&>(_other);
 
+	if (m_location != other.m_location)
+		return false;
 	if (m_parameterTypes.size() != other.m_parameterTypes.size() ||
 			m_returnParameterTypes.size() != other.m_returnParameterTypes.size())
 		return false;

libsolidity/Types.h

@@ -80,15 +80,15 @@ public:
 	///@{
 	///@name Factory functions
 	/// Factory functions that convert an AST @ref TypeName to a Type.
-	static std::shared_ptr<Type> fromElementaryTypeName(Token::Value _typeToken);
+	static std::shared_ptr<Type const> fromElementaryTypeName(Token::Value _typeToken);
-	static std::shared_ptr<Type> fromUserDefinedTypeName(UserDefinedTypeName const& _typeName);
+	static std::shared_ptr<Type const> fromUserDefinedTypeName(UserDefinedTypeName const& _typeName);
-	static std::shared_ptr<Type> fromMapping(Mapping const& _typeName);
+	static std::shared_ptr<Type const> fromMapping(Mapping const& _typeName);
-	static std::shared_ptr<Type> fromFunction(FunctionDefinition const& _function);
+	static std::shared_ptr<Type const> fromFunction(FunctionDefinition const& _function);
 	/// @}
 
 	/// Auto-detect the proper type for a literal. @returns an empty pointer if the literal does
 	/// not fit any type.
-	static std::shared_ptr<Type> forLiteral(Literal const& _literal);
+	static std::shared_ptr<Type const> forLiteral(Literal const& _literal);
 
 	virtual Category getCategory() const = 0;
 	virtual bool isImplicitlyConvertibleTo(Type const& _other) const { return *this == _other; }
@@ -148,7 +148,7 @@ public:
 
 	/// @returns the smallest integer type for the given literal or an empty pointer
 	/// if no type fits.
-	static std::shared_ptr<IntegerType> smallestTypeForLiteral(std::string const& _literal);
+	static std::shared_ptr<IntegerType const> smallestTypeForLiteral(std::string const& _literal);
 
 	explicit IntegerType(int _bits, Modifier _modifier = Modifier::UNSIGNED);
 
@@ -214,10 +214,17 @@ public:
 	virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual bool operator==(Type const& _other) const override;
 	virtual u256 getStorageSize() const override;
+	virtual bool isValueType() const override { return true; }
 	virtual std::string toString() const override;
 
+	virtual MemberList const& getMembers() const override;
+
+	unsigned getFunctionIndex(std::string const& _functionName) const;
+
 private:
 	ContractDefinition const& m_contract;
+	/// List of member types, will be lazy-initialized because of recursive references.
+	mutable std::unique_ptr<MemberList> m_members;
 };
 
 /**
@@ -263,7 +270,7 @@ public:
 	enum class Location { INTERNAL, EXTERNAL, SEND, SHA3, SUICIDE, ECRECOVER, SHA256, RIPEMD160 };
 
 	virtual Category getCategory() const override { return Category::FUNCTION; }
-	explicit FunctionType(FunctionDefinition const& _function);
+	explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true);
 	FunctionType(TypePointers const& _parameterTypes, TypePointers const& _returnParameterTypes,
 				 Location _location = Location::INTERNAL):
 		m_parameterTypes(_parameterTypes), m_returnParameterTypes(_returnParameterTypes),
@@ -279,7 +286,7 @@ public:
 	virtual bool canLiveOutsideStorage() const override { return false; }
 	virtual unsigned getSizeOnStack() const override;
 
-	Location getLocation() const { return m_location; }
+	Location const& getLocation() const { return m_location; }
 
 private:
 	TypePointers m_parameterTypes;

libweb3jsonrpc/WebThreeStubServer.cpp

@@ -510,7 +510,7 @@ std::string WebThreeStubServer::eth_solidity(std::string const& _code)
 	catch (dev::Exception const& exception)
 	{
 		ostringstream error;
-		solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", compiler.getScanner());
+		solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", compiler);
 		cwarn << "Solidity compilation error: " << error.str();
 	}
 	catch (...)

mix/ConstantCompilationModel.cpp

@@ -46,7 +46,7 @@ CompilerResult ConstantCompilationModel::compile(QString _code)
 	catch (dev::Exception const& _exception)
 	{
 		ostringstream error;
-		solidity::SourceReferenceFormatter::printExceptionInformation(error, _exception, "Error", compiler.getScanner());
+		solidity::SourceReferenceFormatter::printExceptionInformation(error, _exception, "Error", compiler);
 		res.success = false;
 		res.comment = QString::fromStdString(error.str()).toHtmlEscaped();
 		res.hexCode = "";

solc/CMakeLists.txt

@@ -8,6 +8,8 @@ set(EXECUTABLE solc)
 
 add_executable(${EXECUTABLE} ${SRC_LIST})
 
+target_link_libraries(${EXECUTABLE} boost_filesystem)
+target_link_libraries(${EXECUTABLE} boost_program_options)
 target_link_libraries(${EXECUTABLE} solidity)
 
 install( TARGETS ${EXECUTABLE} DESTINATION bin )

solc/CommandLineInterface.cpp

@@ -0,0 +1,368 @@
+/*
+	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 Lefteris <lefteris@ethdev.com>
+ * @date 2014
+ * Solidity command line interface.
+ */
+#include "CommandLineInterface.h"
+
+#include <string>
+#include <iostream>
+#include <fstream>
+
+#include <boost/filesystem.hpp>
+
+#include "BuildInfo.h"
+#include <libdevcore/Common.h>
+#include <libdevcore/CommonData.h>
+#include <libdevcore/CommonIO.h>
+#include <libevmcore/Instruction.h>
+#include <libsolidity/Scanner.h>
+#include <libsolidity/Parser.h>
+#include <libsolidity/ASTPrinter.h>
+#include <libsolidity/NameAndTypeResolver.h>
+#include <libsolidity/Exceptions.h>
+#include <libsolidity/CompilerStack.h>
+#include <libsolidity/SourceReferenceFormatter.h>
+
+using namespace std;
+namespace po = boost::program_options;
+
+namespace dev
+{
+namespace solidity
+{
+
+static void version()
+{
+	cout << "solc, the solidity complier commandline interface " << dev::Version << endl
+		 << "  by Christian <c@ethdev.com> and Lefteris <lefteris@ethdev.com>, (c) 2014." << endl
+		 << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl;
+	exit(0);
+}
+
+static inline bool argToStdout(po::variables_map const& _args, const char* _name)
+{
+	return _args.count(_name) && _args[_name].as<OutputType>() != OutputType::FILE;
+}
+
+static bool needStdout(po::variables_map const& _args)
+{
+	return argToStdout(_args, "abi") || argToStdout(_args, "natspec-user") || argToStdout(_args, "natspec-dev") ||
+		   argToStdout(_args, "asm") || argToStdout(_args, "opcodes") || argToStdout(_args, "binary");
+}
+
+static inline bool outputToFile(OutputType type)
+{
+	return type == OutputType::FILE || type == OutputType::BOTH;
+}
+
+static inline bool outputToStdout(OutputType type)
+{
+	return type == OutputType::STDOUT || type == OutputType::BOTH;
+}
+
+static std::istream& operator>>(std::istream& _in, OutputType& io_output)
+{
+	std::string token;
+	_in >> token;
+	if (token == "stdout")
+		io_output = OutputType::STDOUT;
+	else if (token == "file")
+		io_output = OutputType::FILE;
+	else if (token == "both")
+		io_output = OutputType::BOTH;
+	else
+		throw boost::program_options::invalid_option_value(token);
+	return _in;
+}
+
+void CommandLineInterface::handleBinary(string const& _contract)
+{
+	auto choice = m_args["binary"].as<OutputType>();
+	if (outputToStdout(choice))
+	{
+		cout << "Binary: " << endl;
+		cout << toHex(m_compiler.getBytecode(_contract)) << endl;
+	}
+
+	if (outputToFile(choice))
+	{
+		ofstream outFile(_contract + ".binary");
+		outFile << toHex(m_compiler.getBytecode(_contract));
+		outFile.close();
+	}
+}
+
+void CommandLineInterface::handleOpcode(string const& _contract)
+{
+	// TODO: Figure out why the wrong operator << (from boost) is used here
+	auto choice = m_args["opcode"].as<OutputType>();
+	if (outputToStdout(choice))
+	{
+		cout << "Opcodes: " << endl;
+		dev::operator<<(cout, m_compiler.getBytecode(_contract));
+		cout << endl;
+	}
+
+	if (outputToFile(choice))
+	{
+		ofstream outFile(_contract + ".opcode");
+		dev::operator<<(outFile, m_compiler.getBytecode(_contract));
+		outFile.close();
+	}
+}
+
+void CommandLineInterface::handleBytecode(string const& _contract)
+{
+	if (m_args.count("opcodes"))
+		handleOpcode(_contract);
+	if (m_args.count("binary"))
+		handleBinary(_contract);
+}
+
+void CommandLineInterface::handleJson(DocumentationType _type,
+									  string const& _contract)
+{
+	std::string argName;
+	std::string suffix;
+	std::string title;
+	switch(_type)
+	{
+	case DocumentationType::ABI_INTERFACE:
+		argName = "abi";
+		suffix = ".abi";
+		title = "Contract ABI";
+		break;
+	case DocumentationType::NATSPEC_USER:
+		argName = "natspec-user";
+		suffix = ".docuser";
+		title = "User Documentation";
+		break;
+	case DocumentationType::NATSPEC_DEV:
+		argName = "natspec-dev";
+		suffix = ".docdev";
+		title = "Developer Documentation";
+		break;
+	default:
+		// should never happen
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation _type"));
+	}
+
+	if (m_args.count(argName))
+	{
+		auto choice = m_args[argName].as<OutputType>();
+		if (outputToStdout(choice))
+		{
+			cout << title << endl;
+			cout << m_compiler.getJsonDocumentation(_contract, _type);
+		}
+
+		if (outputToFile(choice))
+		{
+			ofstream outFile(_contract + suffix);
+			outFile << m_compiler.getJsonDocumentation(_contract, _type);
+			outFile.close();
+		}
+	}
+}
+
+bool CommandLineInterface::parseArguments(int argc, char** argv)
+{
+#define OUTPUT_TYPE_STR "Legal values:\n"				\
+		"\tstdout: Print it to standard output\n"		\
+		"\tfile: Print it to a file with same name\n"	\
+		"\tboth: Print both to a file and the stdout\n"
+	// Declare the supported options.
+	po::options_description desc("Allowed options");
+	desc.add_options()
+		("help", "Show help message and exit")
+		("version", "Show version and exit")
+		("optimize", po::value<bool>()->default_value(false), "Optimize bytecode for size")
+		("input-file", po::value<vector<string>>(), "input file")
+		("ast", po::value<OutputType>(),
+		 "Request to output the AST of the contract. " OUTPUT_TYPE_STR)
+		("asm", po::value<OutputType>(),
+		 "Request to output the EVM assembly of the contract. "	 OUTPUT_TYPE_STR)
+		("opcodes", po::value<OutputType>(),
+		 "Request to output the Opcodes of the contract. "	OUTPUT_TYPE_STR)
+		("binary", po::value<OutputType>(),
+		 "Request to output the contract in binary (hexadecimal). "	 OUTPUT_TYPE_STR)
+		("abi", po::value<OutputType>(),
+		 "Request to output the contract's ABI interface. "	 OUTPUT_TYPE_STR)
+		("natspec-user", po::value<OutputType>(),
+		 "Request to output the contract's Natspec user documentation. "  OUTPUT_TYPE_STR)
+		("natspec-dev", po::value<OutputType>(),
+		 "Request to output the contract's Natspec developer documentation. "  OUTPUT_TYPE_STR);
+#undef OUTPUT_TYPE_STR
+
+	// All positional options should be interpreted as input files
+	po::positional_options_description p;
+	p.add("input-file", -1);
+
+	// parse the compiler arguments
+	try
+	{
+		po::store(po::command_line_parser(argc, argv).options(desc).positional(p).allow_unregistered().run(), m_args);
+	}
+	catch (po::error const& exception)
+	{
+		cout << exception.what() << endl;
+		return false;
+	}
+	po::notify(m_args);
+
+	if (m_args.count("help"))
+	{
+		cout << desc;
+		return false;
+	}
+
+	if (m_args.count("version"))
+	{
+		version();
+		return false;
+	}
+
+	return true;
+}
+
+bool CommandLineInterface::processInput()
+{
+	if (!m_args.count("input-file"))
+	{
+		string s;
+		while (!cin.eof())
+		{
+			getline(cin, s);
+			m_sourceCodes["<stdin>"].append(s);
+		}
+	}
+	else
+		for (string const& infile: m_args["input-file"].as<vector<string>>())
+			m_sourceCodes[infile] = asString(dev::contents(infile));
+
+	try
+	{
+		for (auto const& sourceCode: m_sourceCodes)
+			m_compiler.addSource(sourceCode.first, sourceCode.second);
+		// TODO: Perhaps we should not compile unless requested
+		m_compiler.compile(m_args["optimize"].as<bool>());
+	}
+	catch (ParserError const& exception)
+	{
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Parser error", m_compiler);
+		return false;
+	}
+	catch (DeclarationError const& exception)
+	{
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Declaration error", m_compiler);
+		return false;
+	}
+	catch (TypeError const& exception)
+	{
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Type error", m_compiler);
+		return false;
+	}
+	catch (CompilerError const& exception)
+	{
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Compiler error", m_compiler);
+		return false;
+	}
+	catch (InternalCompilerError const& exception)
+	{
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Internal compiler error", m_compiler);
+		return false;
+	}
+	catch (Exception const& exception)
+	{
+		cerr << "Exception during compilation: " << boost::diagnostic_information(exception) << endl;
+		return false;
+	}
+	catch (...)
+	{
+		cerr << "Unknown exception during compilation." << endl;
+		return false;
+	}
+
+	return true;
+}
+
+void CommandLineInterface::actOnInput()
+{
+	// do we need AST output?
+	if (m_args.count("ast"))
+	{
+		auto choice = m_args["ast"].as<OutputType>();
+		if (outputToStdout(choice))
+		{
+			cout << "Syntax trees:" << endl << endl;
+			for (auto const& sourceCode: m_sourceCodes)
+			{
+				cout << endl << "======= " << sourceCode.first << " =======" << endl;
+				ASTPrinter printer(m_compiler.getAST(sourceCode.first), sourceCode.second);
+				printer.print(cout);
+			}
+		}
+
+		if (outputToFile(choice))
+		{
+			for (auto const& sourceCode: m_sourceCodes)
+			{
+				boost::filesystem::path p(sourceCode.first);
+				ofstream outFile(p.stem().string() + ".ast");
+				ASTPrinter printer(m_compiler.getAST(sourceCode.first), sourceCode.second);
+				printer.print(outFile);
+				outFile.close();
+			}
+		}
+	}
+
+	vector<string> contracts = m_compiler.getContractNames();
+	for (string const& contract: contracts)
+	{
+		if (needStdout(m_args))
+			cout << endl << "======= " << contract << " =======" << endl;
+
+		// do we need EVM assembly?
+		if (m_args.count("asm"))
+		{
+			auto choice = m_args["asm"].as<OutputType>();
+			if (outputToStdout(choice))
+			{
+				cout << "EVM assembly:" << endl;
+				m_compiler.streamAssembly(cout, contract);
+			}
+
+			if (outputToFile(choice))
+			{
+				ofstream outFile(contract + ".evm");
+				m_compiler.streamAssembly(outFile, contract);
+				outFile.close();
+			}
+		}
+
+		handleBytecode(contract);
+		handleJson(DocumentationType::ABI_INTERFACE, contract);
+		handleJson(DocumentationType::NATSPEC_DEV, contract);
+		handleJson(DocumentationType::NATSPEC_USER, contract);
+	} // end of contracts iteration
+}
+
+}
+}

solc/CommandLineInterface.h

@@ -0,0 +1,71 @@
+/*
+	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 Lefteris <lefteris@ethdev.com>
+ * @date 2014
+ * Solidity command line interface.
+ */
+#pragma once
+
+#include <boost/program_options.hpp>
+
+#include <libsolidity/CompilerStack.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+//forward declaration
+enum class DocumentationType: uint8_t;
+
+enum class OutputType: uint8_t
+{
+	STDOUT,
+	FILE,
+	BOTH
+};
+
+class CommandLineInterface
+{
+public:
+	CommandLineInterface() {}
+
+	/// Parse command line arguments and return false if we should not continue
+	bool parseArguments(int argc, char** argv);
+	/// Parse the files and create source code objects
+	bool processInput();
+	/// Perform actions on the input depending on provided compiler arguments
+	void actOnInput();
+
+private:
+	void handleBinary(std::string const& _contract);
+	void handleOpcode(std::string const& _contract);
+	void handleBytecode(std::string const& _contract);
+	void handleJson(DocumentationType _type,
+					std::string const& _contract);
+
+	/// Compiler arguments variable map
+	boost::program_options::variables_map m_args;
+	/// map of input files to source code strings
+	std::map<std::string, std::string> m_sourceCodes;
+	/// Solidity compiler stack
+	dev::solidity::CompilerStack m_compiler;
+};
+
+}
+}

solc/main.cpp

@@ -20,124 +20,16 @@
  * Solidity commandline compiler.
  */
 
-#include <string>
+#include "CommandLineInterface.h"
-#include <iostream>
-
-#include <libdevcore/Common.h>
-#include <libdevcore/CommonData.h>
-#include <libdevcore/CommonIO.h>
-#include <libevmcore/Instruction.h>
-#include <libsolidity/Scanner.h>
-#include <libsolidity/Parser.h>
-#include <libsolidity/ASTPrinter.h>
-#include <libsolidity/NameAndTypeResolver.h>
-#include <libsolidity/Exceptions.h>
-#include <libsolidity/CompilerStack.h>
-#include <libsolidity/SourceReferenceFormatter.h>
-
-using namespace std;
-using namespace dev;
-using namespace solidity;
-
-void help()
-{
-	cout << "Usage solc [OPTIONS] <file>" << endl
-		 << "Options:" << endl
-		 << "    -o,--optimize Optimize the bytecode for size." << endl
-		 << "    -h,--help     Show this help message and exit." << endl
-		 << "    -V,--version  Show the version and exit." << endl;
-	exit(0);
-}
-
-void version()
-{
-	cout << "solc, the solidity complier commandline interface " << dev::Version << endl
-		 << "  by Christian <c@ethdev.com>, (c) 2014." << endl
-		 << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl;
-	exit(0);
-}
 
 int main(int argc, char** argv)
 {
-	string infile;
+	dev::solidity::CommandLineInterface cli;
-	bool optimize = false;
+	if (!cli.parseArguments(argc, argv))
-	for (int i = 1; i < argc; ++i)
+		return 1;
-	{
+	if (!cli.processInput())
-		string arg = argv[i];
+		return 1;
-		if (arg == "-o" || arg == "--optimize")
+	cli.actOnInput();
-			optimize = true;
-		else if (arg == "-h" || arg == "--help")
-			help();
-		else if (arg == "-V" || arg == "--version")
-			version();
-		else
-			infile = argv[i];
-	}
-	string sourceCode;
-	if (infile.empty())
-	{
-		string s;
-		while (!cin.eof())
-		{
-			getline(cin, s);
-			sourceCode.append(s);
-		}
-	}
-	else
-		sourceCode = asString(dev::contents(infile));
-
-	CompilerStack compiler;
-	try
-	{
-		compiler.compile(sourceCode, optimize);
-	}
-	catch (ParserError const& exception)
-	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Parser error", compiler.getScanner());
-		return -1;
-	}
-	catch (DeclarationError const& exception)
-	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Declaration error", compiler.getScanner());
-		return -1;
-	}
-	catch (TypeError const& exception)
-	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Type error", compiler.getScanner());
-		return -1;
-	}
-	catch (CompilerError const& exception)
-	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Compiler error", compiler.getScanner());
-		return -1;
-	}
-	catch (InternalCompilerError const& exception)
-	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Internal compiler error", compiler.getScanner());
-		return -1;
-	}
-	catch (Exception const& exception)
-	{
-		cerr << "Exception during compilation: " << boost::diagnostic_information(exception) << endl;
-		return -1;
-	}
-	catch (...)
-	{
-		cerr << "Unknown exception during compilation." << endl;
-		return -1;
-	}
-
-	cout << "Syntax tree for the contract:" << endl;
-	ASTPrinter printer(compiler.getAST(), sourceCode);
-	printer.print(cout);
-	cout << "EVM assembly:" << endl;
-	compiler.streamAssembly(cout);
-	cout << "Opcodes:" << endl;
-	cout << eth::disassemble(compiler.getBytecode()) << endl;
-	cout << "Binary: " << toHex(compiler.getBytecode()) << endl;
-	cout << "Interface specification: " << compiler.getJsonDocumentation(DocumentationType::ABI_INTERFACE) << endl;
-	cout << "Natspec user documentation: " << compiler.getJsonDocumentation(DocumentationType::NATSPEC_USER) << endl;
-	cout << "Natspec developer documentation: " << compiler.getJsonDocumentation(DocumentationType::NATSPEC_DEV) << endl;
 
 	return 0;
 }

test/crypto.cpp

@@ -44,6 +44,14 @@ static CryptoPP::OID s_curveOID(CryptoPP::ASN1::secp256k1());
 static CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> s_params(s_curveOID);
 static CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP>::EllipticCurve s_curve(s_params.GetCurve());
 
+BOOST_AUTO_TEST_CASE(cryptopp_patch)
+{
+	KeyPair k = KeyPair::create();
+	bytes io_text;
+	s_secp256k1.decrypt(k.sec(), io_text);
+	BOOST_REQUIRE_EQUAL(io_text.size(), 0);
+}
+
 BOOST_AUTO_TEST_CASE(verify_secert)
 {
 	h256 empty;

test/solidityCompiler.cpp

@@ -46,16 +46,23 @@ namespace
 bytes compileContract(const string& _sourceCode)
 {
 	Parser parser;
-	ASTPointer<ContractDefinition> contract;
+	ASTPointer<SourceUnit> sourceUnit;
-	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
+	BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
 	NameAndTypeResolver resolver({});
-	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
+	resolver.registerDeclarations(*sourceUnit);
-
+	for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
-	Compiler compiler;
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
-	compiler.compileContract(*contract, {});
+		{
-	// debug
+			BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
-	//compiler.streamAssembly(cout);
+
-	return compiler.getAssembledBytecode();
+			Compiler compiler;
+			compiler.compileContract(*contract, {});
+			// debug
+			//compiler.streamAssembly(cout);
+			return compiler.getAssembledBytecode();
+		}
+	BOOST_FAIL("No contract found in source.");
+	return bytes();
 }
 
 /// Checks that @a _compiledCode is present starting from offset @a _offset in @a _expectation.
@@ -118,8 +125,8 @@ BOOST_AUTO_TEST_CASE(different_argument_numbers)
 					   byte(Instruction::JUMP), // end of f
 					   byte(Instruction::JUMPDEST), // beginning of g
 					   byte(Instruction::PUSH1), 0x0,
-					   byte(Instruction::DUP1), // initialized e and h
+					   byte(Instruction::PUSH1), 0x0, // initialized e and h
-					   byte(Instruction::PUSH1), byte(0x29 + shift), // ret address
+					   byte(Instruction::PUSH1), byte(0x2a + shift), // ret address
 					   byte(Instruction::PUSH1), 0x1, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
 					   byte(Instruction::PUSH1), 0x2, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
 					   byte(Instruction::PUSH1), 0x3, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),

test/solidityEndToEndTest.cpp

@@ -47,9 +47,11 @@ class ExecutionFramework
 public:
 	ExecutionFramework() { g_logVerbosity = 0; }
 
-	bytes const& compileAndRun(string const& _sourceCode, u256 const& _value = 0)
+	bytes const& compileAndRun(string const& _sourceCode, u256 const& _value = 0, string const& _contractName = "")
 	{
-		bytes code = dev::solidity::CompilerStack::staticCompile(_sourceCode);
+		dev::solidity::CompilerStack compiler;
+		compiler.compile(_sourceCode);
+		bytes code = compiler.getBytecode(_contractName);
 		sendMessage(code, true, _value);
 		BOOST_REQUIRE(!m_output.empty());
 		return m_output;
@@ -115,6 +117,7 @@ private:
 
 	void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
 	{
+		m_state.addBalance(m_sender, _value); // just in case
 		eth::Executive executive(m_state);
 		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());
@@ -127,7 +130,7 @@ private:
 		catch (...) {}
 		if (_isCreation)
 		{
-			BOOST_REQUIRE(!executive.create(Address(), _value, m_gasPrice, m_gas, &_data, Address()));
+			BOOST_REQUIRE(!executive.create(m_sender, _value, m_gasPrice, m_gas, &_data, m_sender));
 			m_contractAddress = executive.newAddress();
 			BOOST_REQUIRE(m_contractAddress);
 			BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
@@ -135,14 +138,16 @@ private:
 		else
 		{
 			BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
-			BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), _value, m_gasPrice, &_data, m_gas, Address()));
+			BOOST_REQUIRE(!executive.call(m_contractAddress, m_sender, _value, m_gasPrice, &_data, m_gas, m_sender));
 		}
 		BOOST_REQUIRE(executive.go());
+		m_state.noteSending(m_sender);
 		executive.finalize();
 		m_output = executive.out().toVector();
 	}
 
 protected:
+	Address m_sender;
 	Address m_contractAddress;
 	eth::State m_state;
 	u256 const m_gasPrice = 100 * eth::szabo;
@@ -898,6 +903,163 @@ BOOST_AUTO_TEST_CASE(ecrecover)
 	BOOST_CHECK(callContractFunction(0, h, v, r, s) == toBigEndian(addr));
 }
 
+BOOST_AUTO_TEST_CASE(inter_contract_calls)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function multiply(uint a, uint b) returns (uint c) {
+				return a * b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) returns (uint c) {
+				return h.multiply(a, b);
+			}
+			function getHelper() returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) {
+				h = Helper(haddress);
+			}
+		})";
+	compileAndRun(sourceCode, 0, "Helper");
+	u160 const helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_with_complex_parameters)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function sel(uint a, bool select, uint b) returns (uint c) {
+				if (select) return a; else return b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, bool select, uint b) returns (uint c) {
+				return h.sel(a, select, b) * 3;
+			}
+			function getHelper() returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) {
+				h = Helper(haddress);
+			}
+		})";
+	compileAndRun(sourceCode, 0, "Helper");
+	u160 const helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction(0, a, true, b) == toBigEndian(a * 3));
+	BOOST_REQUIRE(callContractFunction(0, a, false, b) == toBigEndian(b * 3));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_accessing_this)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function getAddress() returns (address addr) {
+				return address(this);
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper() returns (address addr) {
+				return h.getAddress();
+			}
+			function getHelper() returns (address addr) {
+				return address(h);
+			}
+			function setHelper(address addr) {
+				h = Helper(addr);
+			}
+		})";
+	compileAndRun(sourceCode, 0, "Helper");
+	u160 const helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
+	BOOST_REQUIRE(callContractFunction(0) == toBigEndian(helperAddress));
+}
+
+BOOST_AUTO_TEST_CASE(calls_to_this)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function invoke(uint a, uint b) returns (uint c) {
+				return this.multiply(a, b, 10);
+			}
+			function multiply(uint a, uint b, uint8 c) returns (uint ret) {
+				return a * b + c;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) returns (uint ret) {
+				return h.invoke(a, b);
+			}
+			function getHelper() returns (address addr) {
+				return address(h);
+			}
+			function setHelper(address addr) {
+				h = Helper(addr);
+			}
+		})";
+	compileAndRun(sourceCode, 0, "Helper");
+	u160 const helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b + 10));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
+{
+	// note that a reference to another contract's function occupies two stack slots,
+	// so this tests correct stack slot allocation
+	char const* sourceCode = R"(
+		contract Helper {
+			function multiply(uint a, uint b) returns (uint c) {
+				return a * b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) returns (uint c) {
+				var fu = h.multiply;
+				var y = 9;
+				var ret = fu(a, b);
+				return ret + y;
+			}
+			function getHelper() returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) {
+				h = Helper(haddress);
+			}
+		})";
+	compileAndRun(sourceCode, 0, "Helper");
+	u160 const helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b + 9));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/solidityExpressionCompiler.cpp

@@ -86,27 +86,34 @@ bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _
 							 vector<vector<string>> _localVariables = {})
 {
 	Parser parser;
-	ASTPointer<ContractDefinition> contract;
+	ASTPointer<SourceUnit> sourceUnit;
-	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
+	BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
 	NameAndTypeResolver resolver({});
-	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
+	resolver.registerDeclarations(*sourceUnit);
-	FirstExpressionExtractor extractor(*contract);
+	for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
-	BOOST_REQUIRE(extractor.getExpression() != nullptr);
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
-
+		{
-	CompilerContext context;
+			BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
-	for (vector<string> const& function: _functions)
+			FirstExpressionExtractor extractor(*contract);
-		context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
+			BOOST_REQUIRE(extractor.getExpression() != nullptr);
-	for (vector<string> const& variable: _localVariables)
+
-		context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver)));
+			CompilerContext context;
-
+			for (vector<string> const& function: _functions)
-	ExpressionCompiler::compileExpression(context, *extractor.getExpression());
+				context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
-
+			for (vector<string> const& variable: _localVariables)
-	for (vector<string> const& function: _functions)
+				context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver)));
-		context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
+
-	bytes instructions = context.getAssembledBytecode();
+			ExpressionCompiler::compileExpression(context, *extractor.getExpression());
-	// debug
+
-	// cout << eth::disassemble(instructions) << endl;
+			for (vector<string> const& function: _functions)
-	return instructions;
+				context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
+			bytes instructions = context.getAssembledBytecode();
+			// debug
+			// cout << eth::disassemble(instructions) << endl;
+			return instructions;
+		}
+	BOOST_FAIL("No contract found in source.");
+	return bytes();
 }
 
 } // end anonymous namespace

test/solidityJSONInterfaceTest.cpp

@@ -50,7 +50,7 @@ public:
 				msg += *extra;
 			BOOST_FAIL(msg);
 		}
-		std::string generatedInterfaceString = m_compilerStack.getJsonDocumentation(DocumentationType::ABI_INTERFACE);
+		std::string generatedInterfaceString = m_compilerStack.getJsonDocumentation("", DocumentationType::ABI_INTERFACE);
 		Json::Value generatedInterface;
 		m_reader.parse(generatedInterfaceString, generatedInterface);
 		Json::Value expectedInterface;

test/solidityNameAndTypeResolution.cpp

@@ -41,10 +41,12 @@ namespace
 void parseTextAndResolveNames(std::string const& _source)
 {
 	Parser parser;
-	ASTPointer<ContractDefinition> contract = parser.parse(
+	ASTPointer<SourceUnit> sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
-										   std::make_shared<Scanner>(CharStream(_source)));
 	NameAndTypeResolver resolver({});
-	resolver.resolveNamesAndTypes(*contract);
+	resolver.registerDeclarations(*sourceUnit);
+	for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+			resolver.resolveNamesAndTypes(*contract);
 }
 }
 

test/solidityNatspecJSON.cpp

@@ -55,9 +55,9 @@ public:
 		}
 
 		if (_userDocumentation)
-			generatedDocumentationString = m_compilerStack.getJsonDocumentation(DocumentationType::NATSPEC_USER);
+			generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_USER);
 		else
-			generatedDocumentationString = m_compilerStack.getJsonDocumentation(DocumentationType::NATSPEC_DEV);
+			generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_DEV);
 		Json::Value generatedDocumentation;
 		m_reader.parse(generatedDocumentationString, generatedDocumentation);
 		Json::Value expectedDocumentation;

test/solidityParser.cpp

@@ -21,13 +21,15 @@
  */
 
 #include <string>
-
+#include <memory>
 #include <libdevcore/Log.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Parser.h>
 #include <libsolidity/Exceptions.h>
 #include <boost/test/unit_test.hpp>
 
+using namespace std;
+
 namespace dev
 {
 namespace solidity
@@ -40,7 +42,12 @@ namespace
 ASTPointer<ContractDefinition> parseText(std::string const& _source)
 {
 	Parser parser;
-	return parser.parse(std::make_shared<Scanner>(CharStream(_source)));
+	ASTPointer<SourceUnit> sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
+	for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
+		if (ASTPointer<ContractDefinition> contract = dynamic_pointer_cast<ContractDefinition>(node))
+			return contract;
+	BOOST_FAIL("No contract found in source.");
+	return ASTPointer<ContractDefinition>();
 }
 }
 
@@ -380,6 +387,50 @@ BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
 	BOOST_CHECK_NO_THROW(parseText(text));
 }
 
+BOOST_AUTO_TEST_CASE(import_directive)
+{
+	char const* text = "import \"abc\";\n"
+					   "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseText(text));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_contracts)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n"
+					   "contract test2 {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseText(text));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
+{
+	char const* text = "import \"abc\";\n"
+					   "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n"
+					   "import \"def\";\n"
+					   "contract test2 {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n"
+					   "import \"ghi\";\n";
+	BOOST_CHECK_NO_THROW(parseText(text));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }