Provide interface for calls in JSON and some other formatting changes.

alethzero/MainWin.cpp

@@ -1602,15 +1602,15 @@ void Main::on_data_textChanged()
 		}
 		else if (src.substr(0, 8) == "contract") // improve this heuristic
 		{
-			shared_ptr<solidity::Scanner> scanner = make_shared<solidity::Scanner>();
+			dev::solidity::CompilerStack compiler;
 			try
 			{
-				m_data = dev::solidity::CompilerStack::compile(src, scanner, m_enableOptimizer);
+				m_data = compiler.compile(src, m_enableOptimizer);
 			}
 			catch (dev::Exception const& exception)
 			{
 				ostringstream error;
-				solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", *scanner);
+				solidity::SourceReferenceFormatter::printExceptionInformation(error, exception, "Error", compiler.getScanner());
 				solidity = "<h4>Solidity</h4><pre>" + QString::fromStdString(error.str()).toHtmlEscaped() + "</pre>";
 			}
 			catch (...)

libdevcore/CommonData.cpp

@@ -29,14 +29,20 @@ using namespace dev;
 
 std::string dev::escaped(std::string const& _s, bool _all)
 {
+	static const map<char, char> prettyEscapes{{'\r', 'r'}, {'\n', 'n'}, {'\t', 't'}, {'\v', 'v'}};
 	std::string ret;
-	ret.reserve(_s.size());
+	ret.reserve(_s.size() + 2);
 	ret.push_back('"');
 	for (auto i: _s)
 		if (i == '"' && !_all)
 			ret += "\\\"";
 		else if (i == '\\' && !_all)
 			ret += "\\\\";
+		else if (prettyEscapes.count(i))
+		{
+			ret += '\\';
+			ret += prettyEscapes.find(i)->second;
+		}
 		else if (i < ' ' || _all)
 		{
 			ret += "\\x";

libsolidity/AST.cpp

@@ -263,6 +263,21 @@ TypeError ASTNode::createTypeError(string const& _description)
 	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 Block::checkTypeRequirements()
 {
 	for (shared_ptr<Statement> const& statement: m_statements)

libsolidity/AST.h

@@ -120,6 +120,8 @@ public:
 	std::vector<ASTPointer<VariableDeclaration>> const& getStateVariables() const { return m_stateVariables; }
 	std::vector<ASTPointer<FunctionDefinition>> const& getDefinedFunctions() const { return m_definedFunctions; }
 
+	/// Returns the functions that make up the calling interface in the intended order.
+	std::vector<FunctionDefinition const*> getInterfaceFunctions() const;
 private:
 	std::vector<ASTPointer<StructDefinition>> m_definedStructs;
 	std::vector<ASTPointer<VariableDeclaration>> m_stateVariables;

libsolidity/ASTPrinter.cpp

@@ -30,8 +30,8 @@ namespace dev
 namespace solidity
 {
 
-ASTPrinter::ASTPrinter(ASTPointer<ASTNode> const& _ast, string const& _source):
+ASTPrinter::ASTPrinter(ASTNode& _ast, string const& _source):
-	m_indentation(0), m_source(_source), m_ast(_ast)
+	m_indentation(0), m_source(_source), m_ast(&_ast)
 {
 }
 
@@ -430,8 +430,8 @@ void ASTPrinter::printSourcePart(ASTNode const& _node)
 	if (!m_source.empty())
 	{
 		Location const& location(_node.getLocation());
-		*m_ostream << getIndentation() << "   Source: |"
+		*m_ostream << getIndentation() << "   Source: "
-				   << m_source.substr(location.start, location.end - location.start) << "|" << endl;
+				   << escaped(m_source.substr(location.start, location.end - location.start), false) << endl;
 	}
 }
 

libsolidity/ASTPrinter.h

@@ -38,7 +38,7 @@ class ASTPrinter: public ASTVisitor
 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(ASTPointer<ASTNode> const& _ast, std::string const& _source = std::string());
+	ASTPrinter(ASTNode& _ast, std::string const& _source = std::string());
 	/// Output the string representation of the AST to _stream.
 	void print(std::ostream& _stream);
 
@@ -114,7 +114,7 @@ private:
 
 	int m_indentation;
 	std::string m_source;
-	ASTPointer<ASTNode> m_ast;
+	ASTNode* m_ast;
 	std::ostream* m_ostream;
 };
 

libsolidity/CompilerStack.cpp

@@ -34,17 +34,101 @@ namespace dev
 namespace solidity
 {
 
-bytes CompilerStack::compile(std::string const& _sourceCode, shared_ptr<Scanner> _scanner,
+void CompilerStack::setSource(string const& _sourceCode)
-							 bool _optimize)
 {
-	if (!_scanner)
+	reset();
-		_scanner = make_shared<Scanner>();
+	m_scanner = make_shared<Scanner>(CharStream(_sourceCode));
-	_scanner->reset(CharStream(_sourceCode));
+}
+
+void CompilerStack::parse()
+{
+	if (!m_scanner)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Source not available."));
+	m_contractASTNode = Parser().parse(m_scanner);
+	NameAndTypeResolver().resolveNamesAndTypes(*m_contractASTNode);
+	m_parseSuccessful = true;
+}
+
+void CompilerStack::parse(string const& _sourceCode)
+{
+	setSource(_sourceCode);
+	parse();
+}
+
+bytes const& CompilerStack::compile(bool _optimize)
+{
+	if (!m_parseSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+	m_bytecode.clear();
+	m_compiler = make_shared<Compiler>();
+	m_compiler->compileContract(*m_contractASTNode);
+	return m_bytecode = m_compiler->getAssembledBytecode(_optimize);
+}
 
-	ASTPointer<ContractDefinition> contract = Parser().parse(_scanner);
+bytes const& CompilerStack::compile(string const& _sourceCode, bool _optimize)
-	NameAndTypeResolver().resolveNamesAndTypes(*contract);
+{
-	return Compiler::compile(*contract, _optimize);
+	parse(_sourceCode);
+	return compile(_optimize);
 }
 
+void CompilerStack::streamAssembly(ostream& _outStream)
+{
+	if (!m_compiler || m_bytecode.empty())
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
+	m_compiler->streamAssembly(_outStream);
+}
+
+string const& CompilerStack::getInterface()
+{
+	if (!m_parseSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+	if (m_interface.empty())
+	{
+		stringstream interface;
+		interface << '[';
+		vector<FunctionDefinition const*> exportedFunctions = m_contractASTNode->getInterfaceFunctions();
+		unsigned functionsCount = exportedFunctions.size();
+		for (FunctionDefinition const* f: exportedFunctions)
+		{
+			auto streamVariables = [&](vector<ASTPointer<VariableDeclaration>> const& _vars)
+			{
+				unsigned varCount = _vars.size();
+				for (ASTPointer<VariableDeclaration> const& var: _vars)
+				{
+					interface << "{"
+							  << "\"name\":" << escaped(var->getName(), false) << ","
+							  << "\"type\":" << escaped(var->getType()->toString(), false)
+							  << "}";
+					if (--varCount > 0)
+						interface << ",";
+				}
+			};
+
+			interface << '{'
+					  << "\"name\":" << escaped(f->getName(), false) << ","
+					  << "\"inputs\":[";
+			streamVariables(f->getParameters());
+			interface << "],"
+					  << "\"outputs\":[";
+			streamVariables(f->getReturnParameters());
+			interface << "]"
+					  << "}";
+			if (--functionsCount > 0)
+				interface << ",";
+		}
+		interface << ']';
+		m_interface = interface.str();
+	}
+	return m_interface;
+}
+
+bytes CompilerStack::staticCompile(std::string const& _sourceCode, bool _optimize)
+{
+	CompilerStack stack;
+	return stack.compile(_sourceCode, _optimize);
+}
+
+
+
 }
 }

libsolidity/CompilerStack.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <ostream>
 #include <string>
 #include <memory>
 #include <libdevcore/Common.h>
@@ -30,13 +31,51 @@ namespace dev {
 namespace solidity {
 
 class Scanner; // forward
+class ContractDefinition; // forward
+class Compiler; // forward
 
+/**
+ * Easy to use and self-contained Solidity compiler with as few header dependencies as possible.
+ * 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
 {
 public:
+	CompilerStack() {}
+	void reset() {  *this = CompilerStack(); }
+	void setSource(std::string const& _sourceCode);
+	void parse();
+	void parse(std::string const& _sourceCode);
+	/// Compiles the contract that was previously parsed.
+	bytes const& compile(bool _optimize = false);
+	/// Parses and compiles the given source code.
+	bytes const& compile(std::string const& _sourceCode, bool _optimize = false);
+
+	bytes const& getBytecode() const { return m_bytecode; }
+	/// Streams a verbose version of the assembly to @a _outStream.
+	/// Prerequisite: Successful compilation.
+	void streamAssembly(std::ostream& _outStream);
+
+	/// Returns a string representing the contract interface in JSON.
+	/// Prerequisite: Successful call to parse or compile.
+	std::string const& getInterface();
+
+	/// 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; }
+
 	/// 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 compile(std::string const& _sourceCode, std::shared_ptr<Scanner> _scanner = std::shared_ptr<Scanner>(), bool _optimize = false);
+	static bytes staticCompile(std::string const& _sourceCode, bool _optimize = false);
+
+private:
+	std::shared_ptr<Scanner> m_scanner;
+	std::shared_ptr<ContractDefinition> m_contractASTNode;
+	bool m_parseSuccessful;
+	std::string m_interface;
+	std::shared_ptr<Compiler> m_compiler;
+	bytes m_bytecode;
 };
 
 }

solc/main.cpp

@@ -26,12 +26,13 @@
 #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/Compiler.h>
+#include <libsolidity/CompilerStack.h>
 #include <libsolidity/SourceReferenceFormatter.h>
 
 using namespace std;
@@ -85,48 +86,34 @@ int main(int argc, char** argv)
 	else
 		sourceCode = asString(dev::contents(infile));
 
-	ASTPointer<ContractDefinition> ast;
+	CompilerStack compiler;
-	shared_ptr<Scanner> scanner = make_shared<Scanner>(CharStream(sourceCode));
-	Parser parser;
-	bytes instructions;
-	Compiler compiler;
 	try
 	{
-		ast = parser.parse(scanner);
+		compiler.compile(sourceCode, optimize);
-
-		NameAndTypeResolver resolver;
-		resolver.resolveNamesAndTypes(*ast.get());
-
-		cout << "Syntax tree for the contract:" << endl;
-		dev::solidity::ASTPrinter printer(ast, sourceCode);
-		printer.print(cout);
-
-		compiler.compileContract(*ast);
-		instructions = compiler.getAssembledBytecode(optimize);
 	}
 	catch (ParserError const& exception)
 	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Parser error", *scanner);
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Parser error", compiler.getScanner());
 		return -1;
 	}
 	catch (DeclarationError const& exception)
 	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Declaration error", *scanner);
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Declaration error", compiler.getScanner());
 		return -1;
 	}
 	catch (TypeError const& exception)
 	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Type error", *scanner);
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Type error", compiler.getScanner());
 		return -1;
 	}
 	catch (CompilerError const& exception)
 	{
-		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Compiler error", *scanner);
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Compiler error", compiler.getScanner());
 		return -1;
 	}
 	catch (InternalCompilerError const& exception)
 	{
-		cerr << "Internal compiler error: " << boost::diagnostic_information(exception) << endl;
+		SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Internal compiler error", compiler.getScanner());
 		return -1;
 	}
 	catch (Exception const& exception)
@@ -140,11 +127,15 @@ int main(int argc, char** argv)
 		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(instructions) << endl;
+	cout << eth::disassemble(compiler.getBytecode()) << endl;
-	cout << "Binary: " << toHex(instructions) << endl;
+	cout << "Binary: " << toHex(compiler.getBytecode()) << endl;
+	cout << "Interface specification: " << compiler.getInterface() << endl;
 
 	return 0;
 }

test/solidityEndToEndTest.cpp

@@ -43,7 +43,7 @@ public:
 
 	bytes const& compileAndRun(std::string const& _sourceCode)
 	{
-		bytes code = dev::solidity::CompilerStack::compile(_sourceCode);
+		bytes code = dev::solidity::CompilerStack::staticCompile(_sourceCode);
 		sendMessage(code, true);
 		BOOST_REQUIRE(!m_output.empty());
 		return m_output;