A first version of Natspec warning popup

- Runtime Contract code hash can now be retrieved from the Compiler

- Using the hash the Natspec handler stores and later retrieves Natspec
  JSON for a given contract.

4 files changed, 24 insertions, 13 deletions

diff --git a/Compiler.cpp b/Compiler.cpp
index 782a7efe..bd6571b9 100644
--- a/Compiler.cpp
+++ b/Compiler.cpp
@@ -50,10 +50,9 @@ void Compiler::compileContract(ContractDefinition const& _contract, vector<Magic
 			function->accept(*this);
 
 	// Swap the runtime context with the creation-time context
-	CompilerContext runtimeContext;
-	swap(m_context, runtimeContext);
+	swap(m_context, m_runtimeContext);
 	initializeContext(_contract, _magicGlobals, _contracts);
-	packIntoContractCreator(_contract, runtimeContext);
+	packIntoContractCreator(_contract, m_runtimeContext);
 }
 
 void Compiler::initializeContext(ContractDefinition const& _contract, vector<MagicVariableDeclaration const*> const& _magicGlobals,
diff --git a/Compiler.h b/Compiler.h
index e83d1ed3..c229a7a8 100644
--- a/Compiler.h
+++ b/Compiler.h
@@ -35,6 +35,7 @@ public:
 	void compileContract(ContractDefinition const& _contract, std::vector<MagicVariableDeclaration const*> const& _magicGlobals,
 						 std::map<ContractDefinition const*, bytes const*> const& _contracts);
 	bytes getAssembledBytecode() { return m_context.getAssembledBytecode(m_optimize); }
+	bytes getRuntimeBytecode() { return m_runtimeContext.getAssembledBytecode(m_optimize);}
 	void streamAssembly(std::ostream& _stream) const { m_context.streamAssembly(_stream); }
 
 private:
@@ -70,6 +71,7 @@ private:
 
 	bool const m_optimize;
 	CompilerContext m_context;
+	CompilerContext m_runtimeContext;
 	std::vector<eth::AssemblyItem> m_breakTags; ///< tag to jump to for a "break" statement
 	std::vector<eth::AssemblyItem> m_continueTags; ///< tag to jump to for a "continue" statement
 	eth::AssemblyItem m_returnTag; ///< tag to jump to for a "return" statement
diff --git a/CompilerStack.cpp b/CompilerStack.cpp
index f0d2e7f7..b0642349 100644
--- a/CompilerStack.cpp
+++ b/CompilerStack.cpp
@@ -30,6 +30,8 @@
 #include <libsolidity/CompilerStack.h>
 #include <libsolidity/InterfaceHandler.h>
 
+#include <libdevcrypto/SHA3.h>
+
 using namespace std;
 
 namespace dev
@@ -117,6 +119,7 @@ void CompilerStack::compile(bool _optimize)
 										  contractBytecode);
 				Contract& compiledContract = m_contracts[contract->getName()];
 				compiledContract.bytecode = compiler->getAssembledBytecode();
+				compiledContract.runtimeBytecode = compiler->getRuntimeBytecode();
 				compiledContract.compiler = move(compiler);
 				contractBytecode[compiledContract.contract] = &compiledContract.bytecode;
 			}
@@ -134,6 +137,16 @@ bytes const& CompilerStack::getBytecode(string const& _contractName) const
 	return getContract(_contractName).bytecode;
 }
 
+bytes const& CompilerStack::getRuntimeBytecode(std::string const& _contractName) const
+{
+	return getContract(_contractName).runtimeBytecode;
+}
+
+dev::h256 CompilerStack::getContractCodeHash(std::string const& _contractName) const
+{
+	return dev::sha3(getRuntimeBytecode(_contractName));
+}
+
 void CompilerStack::streamAssembly(ostream& _outStream, string const& _contractName) const
 {
 	getContract(_contractName).compiler->streamAssembly(_outStream);
@@ -218,13 +231,6 @@ bytes CompilerStack::staticCompile(std::string const& _sourceCode, bool _optimiz
 	return stack.compile(_sourceCode, _optimize);
 }
 
-dev::h256 CompilerStack::getContractCodeHash(std::string const& _contractName)
-{
-	//LTODO
-	(void) _contractName;
-	return dev::h256("");
-}
-
 void CompilerStack::reset(bool _keepSources)
 {
 	m_parseSuccessful = false;
diff --git a/CompilerStack.h b/CompilerStack.h
index da0adf57..202f1b32 100644
--- a/CompilerStack.h
+++ b/CompilerStack.h
@@ -76,7 +76,13 @@ public:
 	/// @returns the compiled bytecode
 	bytes const& compile(std::string const& _sourceCode, bool _optimize = false);
 
+	/// Gets the assembled bytecode for a contract
 	bytes const& getBytecode(std::string const& _contractName = "") const;
+	/// Get the runtime context's bytecode for a contract
+	bytes const& getRuntimeBytecode(std::string const& _contractName = "") const;
+	/// Get the runtime context's code hash for a contract
+	dev::h256 getContractCodeHash(std::string const& _contractName = "") const;
+
 	/// Streams a verbose version of the assembly to @a _outStream.
 	/// Prerequisite: Successful compilation.
 	void streamAssembly(std::ostream& _outStream, std::string const& _contractName = "") const;
@@ -108,9 +114,6 @@ public:
 	/// scanning the source code - this is useful for printing exception information.
 	static bytes staticCompile(std::string const& _sourceCode, bool _optimize = false);
 
-	/// Get the runtime context's code hash for a contract. LTODO
-	dev::h256 getContractCodeHash(std::string const& _contractName);
-
 private:
 	/**
 	 * Information pertaining to one source unit, filled gradually during parsing and compilation.
@@ -128,6 +131,7 @@ private:
 		ContractDefinition const* contract = nullptr;
 		std::shared_ptr<Compiler> compiler;
 		bytes bytecode;
+		bytes runtimeBytecode;
 		std::shared_ptr<InterfaceHandler> interfaceHandler;
 		mutable std::unique_ptr<std::string const> interface;
 		mutable std::unique_ptr<std::string const> solidityInterface;