1 files changed, 56 insertions, 21 deletions

diff --git a/CompilerStack.h b/CompilerStack.h
index 8dc546fb..34178841 100644
--- a/CompilerStack.h
+++ b/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 DocumentationType: unsigned short
  * 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();
-	void reset() {  *this = CompilerStack(); }
+	CompilerStack(): m_parseSuccessful(false) {}
+
+	/// 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.
-	bytes const& compile(bool _optimize = false);
+	/// Returns a list of the contract names in the sources.
+	std::vector<std::string> getContractNames();
+
+	/// Compiles the source units that were prevously 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 = "");
 	/// 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 = "");
 
 	/// 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 = "");
 	/// 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
-	std::string const& getJsonDocumentation(enum DocumentationType type);
+	/// Can be one of 3 types defined at @c DocumentationType
+	std::string const& getJsonDocumentation(std::string const& _contractName, enum DocumentationType _type);
 
 	/// Returns the previously used scanner, useful for counting lines during error reporting.
-	Scanner const& getScanner() const { return *m_scanner; }
-	ContractDefinition& getAST() const { return *m_contractASTNode; }
+	Scanner const& getScanner(std::string const& _sourceName = "");
+	SourceUnit& getAST(std::string const& _sourceName = "");
 
 	/// 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;
-	std::shared_ptr<ContractDefinition> m_contractASTNode;
+	/**
+	 * Information pertaining to one source unit, filled gradually during parsing and compilation.
+	 */
+	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;
+		std::unique_ptr<std::string> interface;
+		std::unique_ptr<std::string> userDocumentation;
+		std::unique_ptr<std::string> devDocumentation;
+
+		Contract();
+	};
+
+	void reset(bool _keepSources = false);
+	void resolveImports();
+
+	Contract& getContract(std::string const& _contractName = "");
+	Source& getSource(std::string const& _sourceName = "");
+
 	bool m_parseSuccessful;
-	std::unique_ptr<std::string> m_interface;
-	std::unique_ptr<std::string> m_userDocumentation;
-	std::unique_ptr<std::string> m_devDocumentation;
-	std::shared_ptr<Compiler> m_compiler;
-	std::shared_ptr<InterfaceHandler> m_interfaceHandler;
-	bytes m_bytecode;
+	std::map<std::string, Source> m_sources;
+	std::shared_ptr<GlobalContext> m_globalContext;
+	std::vector<Source const*> m_sourceOrder;
+	std::map<std::string, Contract> m_contracts;
 };
 
 }