From 28f10f4783bd4365654191740069a7112be03d92 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 28 Apr 2017 13:09:48 +0200
Subject: Remove error label / invalid jump label.

---
 libsolidity/inlineasm/AsmCodeGen.cpp     | 2 --
 libsolidity/inlineasm/AsmScope.h         | 1 -
 libsolidity/inlineasm/AsmScopeFiller.cpp | 4 ----
 3 files changed, 7 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 9ef3e6e7..c19667b4 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -278,8 +278,6 @@ private:
 	{
 		if (_label.id == Scope::Label::unassignedLabelId)
 			_label.id = m_state.newLabelId();
-		else if (_label.id == Scope::Label::errorLabelId)
-			_label.id = size_t(m_state.assembly.errorTag().data());
 	}
 
 
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 37e0f0b8..b70bee67 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -73,7 +73,6 @@ struct Scope
 	struct Label
 	{
 		size_t id = unassignedLabelId;
-		static const size_t errorLabelId = -1;
 		static const size_t unassignedLabelId = 0;
 	};
 
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index de6fbdaa..4a651388 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -39,10 +39,6 @@ using namespace dev::solidity::assembly;
 ScopeFiller::ScopeFiller(ScopeFiller::Scopes& _scopes, ErrorList& _errors):
 	m_scopes(_scopes), m_errors(_errors)
 {
-	// Make the Solidity ErrorTag available to inline assembly
-	Scope::Label errorLabel;
-	errorLabel.id = Scope::Label::errorLabelId;
-	scope(nullptr).identifiers["invalidJumpLabel"] = errorLabel;
 	m_currentScope = &scope(nullptr);
 }
 
-- 
cgit v1.2.3


From d61f9c4d4ee99cf0d540e3a7b6c7f250bab5f7b6 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 1 May 2017 17:40:37 +0100
Subject: Disable labels in Julia

---
 libsolidity/inlineasm/AsmParser.cpp | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index d7f78958..8d54d47a 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -84,6 +84,7 @@ assembly::Statement Parser::parseStatement()
 	}
 	case Token::Return: // opcode
 	case Token::Byte: // opcode
+	case Token::Address: // opcode
 	default:
 		break;
 	}
@@ -119,6 +120,8 @@ assembly::Statement Parser::parseStatement()
 		else
 		{
 			// label
+			if (m_julia)
+				fatalParserError("Labels are not supported.");
 			Label label = createWithLocation<Label>(identifier.location);
 			label.name = identifier.name;
 			return label;
-- 
cgit v1.2.3


From f1f209db4032e7679ab39f0ac1591a43d943b153 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 09:24:35 +0100
Subject: Do not allow literal pushes in Julia

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 8d54d47a..07483f80 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -128,6 +128,8 @@ assembly::Statement Parser::parseStatement()
 		}
 	}
 	default:
+		if (m_julia)
+			fatalParserError("Call or assignment expected.");
 		break;
 	}
 	return statement;
-- 
cgit v1.2.3


From 804971973d09c97dd12d8a34d50b9c5b556ffee4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 09:25:12 +0100
Subject: Show better error message for Julia mode

---
 libsolidity/inlineasm/AsmParser.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 07483f80..d9b0b3e0 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -92,7 +92,7 @@ assembly::Statement Parser::parseStatement()
 	// Simple instruction (might turn into functional),
 	// literal,
 	// identifier (might turn into label or functional assignment)
-	Statement statement(parseElementaryOperation());
+	Statement statement(parseElementaryOperation(false));
 	switch (m_scanner->currentToken())
 	{
 	case Token::LParen:
@@ -214,7 +214,11 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		break;
 	}
 	default:
-		fatalParserError("Expected elementary inline assembly operation.");
+		fatalParserError(
+			m_julia ?
+			"Literal or identifier expected." :
+			"Expected elementary inline assembly operation."
+		);
 	}
 	m_scanner->next();
 	return ret;
@@ -322,7 +326,11 @@ assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _in
 		return ret;
 	}
 	else
-		fatalParserError("Assembly instruction or function name required in front of \"(\")");
+		fatalParserError(
+			m_julia ?
+			"Function name expected." :
+			"Assembly instruction or function name required in front of \"(\")"
+		);
 
 	return {};
 }
-- 
cgit v1.2.3


From c423e140eeccaa07ca8c461e86157a4d9dbb1195 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 26 Apr 2017 23:58:08 +0100
Subject: Add flag for JULIA printing

---
 libsolidity/inlineasm/AsmPrinter.h | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index a7a1de0a..038c6d85 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -45,6 +45,8 @@ struct Block;
 class AsmPrinter: public boost::static_visitor<std::string>
 {
 public:
+	explicit AsmPrinter(bool _julia = false): m_julia(_julia) {}
+
 	std::string operator()(assembly::Instruction const& _instruction);
 	std::string operator()(assembly::Literal const& _literal);
 	std::string operator()(assembly::Identifier const& _identifier);
@@ -56,6 +58,9 @@ public:
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
 	std::string operator()(assembly::Block const& _block);
+
+private:
+	bool m_julia = false;
 };
 
 }
-- 
cgit v1.2.3


From 07176e82de05bd4490b22f070cd11e36b84f734a Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 4 May 2017 09:26:59 +0100
Subject: Assert that invalid AST elements are not printed in Julia mode

---
 libsolidity/inlineasm/AsmPrinter.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 252e91f9..4a6f975d 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -21,8 +21,8 @@
  */
 
 #include <libsolidity/inlineasm/AsmPrinter.h>
-
 #include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/interface/Utils.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/replace.hpp>
@@ -40,6 +40,7 @@ using namespace dev::solidity::assembly;
 
 string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 {
+	solAssert(!m_julia, "");
 	return boost::to_lower_copy(instructionInfo(_instruction.instruction).name);
 }
 
@@ -83,6 +84,7 @@ string AsmPrinter::operator()(assembly::Identifier const& _identifier)
 
 string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functionalInstruction)
 {
+	solAssert(!m_julia, "");
 	return
 		(*this)(_functionalInstruction.instruction) +
 		"(" +
@@ -94,11 +96,13 @@ string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functional
 
 string AsmPrinter::operator()(assembly::Label const& _label)
 {
+	solAssert(!m_julia, "");
 	return _label.name + ":";
 }
 
 string AsmPrinter::operator()(assembly::Assignment const& _assignment)
 {
+	solAssert(!m_julia, "");
 	return "=: " + (*this)(_assignment.variableName);
 }
 
-- 
cgit v1.2.3


From d6396ee85fd21424568074c41a131e8c52961983 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 26 Apr 2017 23:58:34 +0100
Subject: Parse types in Julia mode

---
 libsolidity/inlineasm/AsmAnalysis.cpp    |  9 +++++----
 libsolidity/inlineasm/AsmCodeGen.cpp     |  2 +-
 libsolidity/inlineasm/AsmData.h          | 17 ++++++++++------
 libsolidity/inlineasm/AsmParser.cpp      | 34 ++++++++++++++++++++++++++------
 libsolidity/inlineasm/AsmParser.h        |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp     | 25 ++++++++++++++++++-----
 libsolidity/inlineasm/AsmPrinter.h       |  2 ++
 libsolidity/inlineasm/AsmScope.cpp       |  8 +++++---
 libsolidity/inlineasm/AsmScope.h         | 17 +++++++++++-----
 libsolidity/inlineasm/AsmScopeFiller.cpp | 16 ++++++++++-----
 libsolidity/inlineasm/AsmScopeFiller.h   |  3 ++-
 11 files changed, 98 insertions(+), 36 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index dad05a78..590f9ad6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -184,7 +184,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	solAssert(m_stackHeight - stackHeight == 1, "Invalid value size.");
-	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.name)).active = true;
+	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
 }
@@ -193,7 +193,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	Scope& bodyScope = scope(&_funDef.body);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
-		boost::get<Scope::Variable>(bodyScope.identifiers.at(var)).active = true;
+		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
@@ -232,8 +232,9 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		},
 		[&](Scope::Function const& _fun)
 		{
-			arguments = _fun.arguments;
-			returns = _fun.returns;
+			/// TODO: compare types too
+			arguments = _fun.arguments.size();
+			returns = _fun.returns.size();
 		}
 	)))
 	{
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index c19667b4..137a70f5 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -204,7 +204,7 @@ public:
 		int height = m_state.assembly.deposit();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
-		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.name));
+		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
 		var.stackHeight = height;
 		var.active = true;
 	}
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index d61b5803..363873ab 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -33,12 +33,17 @@ namespace solidity
 namespace assembly
 {
 
+using Type = std::string;
+
+struct TypedName { SourceLocation location; std::string name; Type type; };
+using TypedNameList = std::vector<TypedName>;
+
 /// What follows are the AST nodes for assembly.
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
-struct Literal { SourceLocation location; bool isNumber; std::string value; };
+struct Literal { SourceLocation location; bool isNumber; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
@@ -52,18 +57,18 @@ struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
 using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
-/// Functional assignment ("x := mload(20)", expects push-1-expression on the right hand
+/// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
-/// Functional instruction, e.g. "mul(mload(20), add(2, x))"
+/// Functional instruction, e.g. "mul(mload(20:u256), add(2:u256, x))"
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
-/// Block-scope variable declaration ("let x := mload(20)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; std::string name; std::shared_ptr<Statement> value; };
+/// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
+struct VariableDeclaration { SourceLocation location; TypedName variable; std::shared_ptr<Statement> value; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
-struct FunctionDefinition { SourceLocation location; std::string name; std::vector<std::string> arguments; std::vector<std::string> returns; Block body; };
+struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index d9b0b3e0..7ecad5ea 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -201,16 +201,26 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		}
 		else
 			ret = Identifier{location(), literal};
+		m_scanner->next();
 		break;
 	}
 	case Token::StringLiteral:
 	case Token::Number:
 	{
-		ret = Literal{
+		Literal literal{
 			location(),
 			m_scanner->currentToken() == Token::Number,
-			m_scanner->currentLiteral()
+			m_scanner->currentLiteral(),
+			""
 		};
+		m_scanner->next();
+		if (m_julia)
+		{
+			expectToken(Token::Colon);
+			literal.location.end = endPosition();
+			literal.type = expectAsmIdentifier();
+		}
+		ret = std::move(literal);
 		break;
 	}
 	default:
@@ -220,7 +230,6 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			"Expected elementary inline assembly operation."
 		);
 	}
-	m_scanner->next();
 	return ret;
 }
 
@@ -228,7 +237,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 {
 	VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
 	expectToken(Token::Let);
-	varDecl.name = expectAsmIdentifier();
+	varDecl.variable = parseTypedName();
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
 	varDecl.value.reset(new Statement(parseExpression()));
@@ -244,7 +253,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	expectToken(Token::LParen);
 	while (m_scanner->currentToken() != Token::RParen)
 	{
-		funDef.arguments.push_back(expectAsmIdentifier());
+		funDef.arguments.emplace_back(parseTypedName());
 		if (m_scanner->currentToken() == Token::RParen)
 			break;
 		expectToken(Token::Comma);
@@ -256,7 +265,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 		expectToken(Token::GreaterThan);
 		while (true)
 		{
-			funDef.returns.push_back(expectAsmIdentifier());
+			funDef.returns.emplace_back(parseTypedName());
 			if (m_scanner->currentToken() == Token::LBrace)
 				break;
 			expectToken(Token::Comma);
@@ -335,6 +344,19 @@ assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _in
 	return {};
 }
 
+TypedName Parser::parseTypedName()
+{
+	TypedName typedName = createWithLocation<TypedName>();
+	typedName.name = expectAsmIdentifier();
+	if (m_julia)
+	{
+		expectToken(Token::Colon);
+		typedName.location.end = endPosition();
+		typedName.type = expectAsmIdentifier();
+	}
+	return typedName;
+}
+
 string Parser::expectAsmIdentifier()
 {
 	string name = m_scanner->currentLiteral();
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index c55fd2ac..addc1725 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -69,6 +69,7 @@ protected:
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
 	Statement parseFunctionalInstruction(Statement&& _instruction);
+	TypedName parseTypedName();
 	std::string expectAsmIdentifier();
 
 private:
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 4a6f975d..94829371 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -47,7 +47,7 @@ string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 string AsmPrinter::operator()(assembly::Literal const& _literal)
 {
 	if (_literal.isNumber)
-		return _literal.value;
+		return _literal.value + appendTypeName(_literal.type);
 	string out;
 	for (char c: _literal.value)
 		if (c == '\\')
@@ -74,7 +74,7 @@ string AsmPrinter::operator()(assembly::Literal const& _literal)
 		}
 		else
 			out += c;
-	return "\"" + out + "\"";
+	return "\"" + out + "\"" + appendTypeName(_literal.type);
 }
 
 string AsmPrinter::operator()(assembly::Identifier const& _identifier)
@@ -113,14 +113,22 @@ string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalA
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
 {
-	return "let " + _variableDeclaration.name + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
+	return "let " + _variableDeclaration.variable.name + appendTypeName(_variableDeclaration.variable.type) + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
 }
 
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
 {
-	string out = "function " + _functionDefinition.name + "(" + boost::algorithm::join(_functionDefinition.arguments, ", ") + ")";
+	string out = "function " + _functionDefinition.name + "(";
+	for (auto const& argument: _functionDefinition.arguments)
+		out += argument.name + appendTypeName(argument.type) + ",";
+	out += ")";
 	if (!_functionDefinition.returns.empty())
-		out += " -> " + boost::algorithm::join(_functionDefinition.returns, ", ");
+	{
+		out += " -> ";
+		for (auto const& argument: _functionDefinition.returns)
+		    out += argument.name + appendTypeName(argument.type) + ",";
+	}
+
 	return out + "\n" + (*this)(_functionDefinition.body);
 }
 
@@ -145,3 +153,10 @@ string AsmPrinter::operator()(Block const& _block)
 	boost::replace_all(body, "\n", "\n    ");
 	return "{\n    " + body + "\n}";
 }
+
+string AsmPrinter::appendTypeName(std::string const& _type)
+{
+	if (m_julia)
+		return ":" + _type;
+	return "";
+}
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 038c6d85..282fd7e3 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -60,6 +60,8 @@ public:
 	std::string operator()(assembly::Block const& _block);
 
 private:
+	std::string appendTypeName(std::string const& _type);
+
 	bool m_julia = false;
 };
 
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 609dca16..e3f4615a 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -32,15 +32,17 @@ bool Scope::registerLabel(string const& _name)
 	return true;
 }
 
-bool Scope::registerVariable(string const& _name)
+bool Scope::registerVariable(string const& _name, JuliaType const& _type)
 {
 	if (exists(_name))
 		return false;
-	identifiers[_name] = Variable();
+	Variable variable;
+	variable.type = _type;
+	identifiers[_name] = variable;
 	return true;
 }
 
-bool Scope::registerFunction(string const& _name, size_t _arguments, size_t _returns)
+bool Scope::registerFunction(string const& _name, std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns)
 {
 	if (exists(_name))
 		return false;
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index b70bee67..dd45613d 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -61,6 +61,8 @@ struct GenericVisitor<>: public boost::static_visitor<> {
 
 struct Scope
 {
+	using JuliaType = std::string;
+
 	struct Variable
 	{
 		/// Used during code generation to store the stack height. @todo move there.
@@ -68,6 +70,7 @@ struct Scope
 		/// Used during analysis to check whether we already passed the declaration inside the block.
 		/// @todo move there.
 		bool active = false;
+		JuliaType type;
 	};
 
 	struct Label
@@ -78,18 +81,22 @@ struct Scope
 
 	struct Function
 	{
-		Function(size_t _arguments, size_t _returns): arguments(_arguments), returns(_returns) {}
-		size_t arguments = 0;
-		size_t returns = 0;
+		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
+		std::vector<JuliaType> arguments;
+		std::vector<JuliaType> returns;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
 	using Visitor = GenericVisitor<Variable const, Label const, Function const>;
 	using NonconstVisitor = GenericVisitor<Variable, Label, Function>;
 
-	bool registerVariable(std::string const& _name);
+	bool registerVariable(std::string const& _name, JuliaType const& _type);
 	bool registerLabel(std::string const& _name);
-	bool registerFunction(std::string const& _name, size_t _arguments, size_t _returns);
+	bool registerFunction(
+		std::string const& _name,
+		std::vector<JuliaType> const& _arguments,
+		std::vector<JuliaType> const& _returns
+	);
 
 	/// Looks up the identifier in this or super scopes and returns a valid pointer if found
 	/// or a nullptr if not found. Variable lookups up across function boundaries will fail, as
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 4a651388..eb10dbb3 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -59,13 +59,19 @@ bool ScopeFiller::operator()(Label const& _item)
 
 bool ScopeFiller::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	return registerVariable(_varDecl.name, _varDecl.location, *m_currentScope);
+	return registerVariable(_varDecl.variable, _varDecl.location, *m_currentScope);
 }
 
 bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	bool success = true;
-	if (!m_currentScope->registerFunction(_funDef.name, _funDef.arguments.size(), _funDef.returns.size()))
+	vector<Scope::JuliaType> arguments;
+	for (auto const& _argument: _funDef.arguments)
+		arguments.push_back(_argument.type);
+	vector<Scope::JuliaType> returns;
+	for (auto const& _return: _funDef.returns)
+		returns.push_back(_return.type);
+	if (!m_currentScope->registerFunction(_funDef.name, arguments, returns))
 	{
 		//@TODO secondary location
 		m_errors.push_back(make_shared<Error>(
@@ -102,14 +108,14 @@ bool ScopeFiller::operator()(Block const& _block)
 	return success;
 }
 
-bool ScopeFiller::registerVariable(string const& _name, SourceLocation const& _location, Scope& _scope)
+bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const& _location, Scope& _scope)
 {
-	if (!_scope.registerVariable(_name))
+	if (!_scope.registerVariable(_name.name, _name.type))
 	{
 		//@TODO secondary location
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::DeclarationError,
-			"Variable name " + _name + " already taken in this scope.",
+			"Variable name " + _name.name + " already taken in this scope.",
 			_location
 		));
 		return false;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index bb62948b..61428eea 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -34,6 +34,7 @@ namespace solidity
 namespace assembly
 {
 
+struct TypedName;
 struct Literal;
 struct Block;
 struct Label;
@@ -72,7 +73,7 @@ public:
 
 private:
 	bool registerVariable(
-		std::string const& _name,
+		TypedName const& _name,
 		SourceLocation const& _location,
 		Scope& _scope
 	);
-- 
cgit v1.2.3


From 8688b63fa624fbf14982c3c4340ab83c13144f66 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 3 May 2017 19:32:38 +0100
Subject: Use boost range adaptors in AsmPrinter

---
 libsolidity/inlineasm/AsmPrinter.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 94829371..f3b66aee 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -119,14 +119,22 @@ string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDecl
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
 {
 	string out = "function " + _functionDefinition.name + "(";
-	for (auto const& argument: _functionDefinition.arguments)
-		out += argument.name + appendTypeName(argument.type) + ",";
+	out += boost::algorithm::join(
+		_functionDefinition.arguments | boost::adaptors::transformed(
+			[this](TypedName argument) { return argument.name + appendTypeName(argument.type); }
+		),
+		", "
+	);
 	out += ")";
 	if (!_functionDefinition.returns.empty())
 	{
 		out += " -> ";
-		for (auto const& argument: _functionDefinition.returns)
-		    out += argument.name + appendTypeName(argument.type) + ",";
+		out += boost::algorithm::join(
+			_functionDefinition.returns | boost::adaptors::transformed(
+				[this](TypedName argument) { return argument.name + appendTypeName(argument.type); }
+			),
+			", "
+		);
 	}
 
 	return out + "\n" + (*this)(_functionDefinition.body);
-- 
cgit v1.2.3


From edd0afa3c35475990bacd8ffe64d15b3be40a036 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 18:26:33 +0100
Subject: Support true/false literals in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp |  2 +-
 libsolidity/inlineasm/AsmCodeGen.cpp  |  9 ++++++++-
 libsolidity/inlineasm/AsmData.h       |  3 ++-
 libsolidity/inlineasm/AsmParser.cpp   | 23 ++++++++++++++++++++++-
 libsolidity/inlineasm/AsmPrinter.cpp  | 10 +++++++++-
 5 files changed, 42 insertions(+), 5 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 590f9ad6..e03eea2e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -72,7 +72,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 {
 	++m_stackHeight;
-	if (!_literal.isNumber && _literal.value.size() > 32)
+	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 137a70f5..44e12b3e 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -118,8 +118,15 @@ public:
 	void operator()(assembly::Literal const& _literal)
 	{
 		m_state.assembly.setSourceLocation(_literal.location);
-		if (_literal.isNumber)
+		if (_literal.kind == assembly::LiteralKind::Number)
 			m_state.assembly.append(u256(_literal.value));
+		else if (_literal.kind == assembly::LiteralKind::Boolean)
+		{
+			if (_literal.value == "true")
+				m_state.assembly.append(u256(1));
+			else
+				m_state.assembly.append(u256(0));
+		}
 		else
 		{
 			solAssert(_literal.value.size() <= 32, "");
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 363873ab..8efe1f07 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -43,7 +43,8 @@ using TypedNameList = std::vector<TypedName>;
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
-struct Literal { SourceLocation location; bool isNumber; std::string value; Type type; };
+enum class LiteralKind { Number, Boolean, String };
+struct Literal { SourceLocation location; LiteralKind kind; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 7ecad5ea..079b9352 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -206,10 +206,29 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	}
 	case Token::StringLiteral:
 	case Token::Number:
+	case Token::TrueLiteral:
+	case Token::FalseLiteral:
 	{
+		LiteralKind kind = LiteralKind::Number;
+		switch (m_scanner->currentToken())
+		{
+		case Token::StringLiteral:
+			kind = LiteralKind::String;
+			break;
+		case Token::Number:
+			kind = LiteralKind::Number;
+			break;
+		case Token::TrueLiteral:
+		case Token::FalseLiteral:
+			kind = LiteralKind::Boolean;
+			break;
+		default:
+			break;
+		}
+
 		Literal literal{
 			location(),
-			m_scanner->currentToken() == Token::Number,
+			kind,
 			m_scanner->currentLiteral(),
 			""
 		};
@@ -220,6 +239,8 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			literal.location.end = endPosition();
 			literal.type = expectAsmIdentifier();
 		}
+		else if (kind == LiteralKind::Boolean)
+			fatalParserError("True and false are not valid literals.");
 		ret = std::move(literal);
 		break;
 	}
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index f3b66aee..636e61b8 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -46,8 +46,16 @@ string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 
 string AsmPrinter::operator()(assembly::Literal const& _literal)
 {
-	if (_literal.isNumber)
+	switch (_literal.kind)
+	{
+	case LiteralKind::Number:
 		return _literal.value + appendTypeName(_literal.type);
+	case LiteralKind::Boolean:
+		return ((_literal.value == "true") ? "true" : "false") + appendTypeName(_literal.type);
+	case LiteralKind::String:
+		break;
+	}
+
 	string out;
 	for (char c: _literal.value)
 		if (c == '\\')
-- 
cgit v1.2.3


From ebcb27e5c14549d114c116889c730c3a8cd82a86 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 17 May 2017 13:33:05 +0100
Subject: Accept bool as a type in Julia mode

---
 libsolidity/inlineasm/AsmParser.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 079b9352..a96984f5 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -381,7 +381,15 @@ TypedName Parser::parseTypedName()
 string Parser::expectAsmIdentifier()
 {
 	string name = m_scanner->currentLiteral();
-	if (!m_julia && instructions().count(name))
+	if (m_julia)
+	{
+		if (m_scanner->currentToken() == Token::Bool)
+		{
+			m_scanner->next();
+			return name;
+		}
+	}
+	else if (instructions().count(name))
 		fatalParserError("Cannot use instruction names for identifier names.");
 	expectToken(Token::Identifier);
 	return name;
-- 
cgit v1.2.3


From e2b21e1c9611fd94f8e7b91b0ecbb0ec39145758 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 28 Apr 2017 18:15:18 +0200
Subject: Refactor to abstract assembly to JULIA.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 143 +++++++++++++++++++++++------------
 libsolidity/inlineasm/AsmScope.h     |   4 +-
 libsolidity/inlineasm/AsmStack.h     |   4 +-
 3 files changed, 99 insertions(+), 52 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 44e12b3e..a6d7e76b 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -32,6 +32,8 @@
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
 
+#include <libjulia/backends/AbstractAssembly.h>
+
 #include <libdevcore/CommonIO.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -48,24 +50,61 @@ using namespace dev::solidity::assembly;
 
 struct GeneratorState
 {
-	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo, eth::Assembly& _assembly):
-		errors(_errors), info(_analysisInfo), assembly(_assembly) {}
+	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo):
+		errors(_errors), info(_analysisInfo) {}
+
+	ErrorList& errors;
+	AsmAnalysisInfo info;
+};
 
-	size_t newLabelId()
+class EthAssemblyAdapter: public julia::AbstractAssembly
+{
+public:
+	EthAssemblyAdapter(eth::Assembly& _assembly):
+		m_assembly(_assembly)
+	{
+	}
+	virtual void setSourceLocation(SourceLocation const& _location) override
+	{
+		m_assembly.setSourceLocation(_location);
+	}
+	virtual int stackHeight() const override { return m_assembly.deposit(); }
+	virtual void appendInstruction(solidity::Instruction _instruction) override
+	{
+		m_assembly.append(_instruction);
+	}
+	virtual void appendConstant(u256 const& _constant) override
+	{
+		m_assembly.append(_constant);
+	}
+	/// Append a label.
+	virtual void appendLabel(size_t _labelId) override
+	{
+		m_assembly.append(eth::AssemblyItem(eth::Tag, _labelId));
+	}
+	/// Append a label reference.
+	virtual void appendLabelReference(size_t _labelId) override
+	{
+		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
+	}
+	virtual size_t newLabel() override
+	{
+		return assemblyTagToIdentifier(m_assembly.newTag());
+	}
+	virtual void appendLinkerSymbol(std::string const& _linkerSymbol) override
 	{
-		return assemblyTagToIdentifier(assembly.newTag());
+		m_assembly.appendLibraryAddress(_linkerSymbol);
 	}
 
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
+private:
+	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag)
 	{
 		u256 id = _tag.data();
 		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
 		return size_t(id);
 	}
 
-	ErrorList& errors;
-	AsmAnalysisInfo info;
-	eth::Assembly& assembly;
+	eth::Assembly& m_assembly;
 };
 
 class CodeTransform: public boost::static_visitor<>
@@ -76,81 +115,84 @@ public:
 	/// @param _identifierAccess used to resolve identifiers external to the inline assembly
 	explicit CodeTransform(
 		GeneratorState& _state,
+		julia::AbstractAssembly& _assembly,
 		assembly::Block const& _block,
 		assembly::ExternalIdentifierAccess const& _identifierAccess = assembly::ExternalIdentifierAccess()
-	): CodeTransform(_state, _block, _identifierAccess, _state.assembly.deposit())
+	): CodeTransform(_state, _assembly, _block, _identifierAccess, _assembly.stackHeight())
 	{
 	}
 
 private:
 	CodeTransform(
 		GeneratorState& _state,
+		julia::AbstractAssembly& _assembly,
 		assembly::Block const& _block,
 		assembly::ExternalIdentifierAccess const& _identifierAccess,
-		int _initialDeposit
+		int _initialStackHeight
 	):
 		m_state(_state),
+		m_assembly(_assembly),
 		m_scope(*m_state.info.scopes.at(&_block)),
 		m_identifierAccess(_identifierAccess),
-		m_initialDeposit(_initialDeposit)
+		m_initialStackHeight(_initialStackHeight)
 	{
-		int blockStartDeposit = m_state.assembly.deposit();
+		int blockStartStackHeight = m_assembly.stackHeight();
 		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
 
-		m_state.assembly.setSourceLocation(_block.location);
+		m_assembly.setSourceLocation(_block.location);
 
 		// pop variables
 		for (auto const& identifier: m_scope.identifiers)
 			if (identifier.second.type() == typeid(Scope::Variable))
-				m_state.assembly.append(solidity::Instruction::POP);
+				m_assembly.appendInstruction(solidity::Instruction::POP);
 
-		int deposit = m_state.assembly.deposit() - blockStartDeposit;
+		int deposit = m_assembly.stackHeight() - blockStartStackHeight;
 		solAssert(deposit == 0, "Invalid stack height at end of block.");
 	}
 
 public:
 	void operator()(assembly::Instruction const& _instruction)
 	{
-		m_state.assembly.setSourceLocation(_instruction.location);
-		m_state.assembly.append(_instruction.instruction);
+		m_assembly.setSourceLocation(_instruction.location);
+		m_assembly.appendInstruction(_instruction.instruction);
 		checkStackHeight(&_instruction);
 	}
 	void operator()(assembly::Literal const& _literal)
 	{
-		m_state.assembly.setSourceLocation(_literal.location);
+		m_assembly.setSourceLocation(_literal.location);
 		if (_literal.kind == assembly::LiteralKind::Number)
-			m_state.assembly.append(u256(_literal.value));
+			m_assembly.appendConstant(u256(_literal.value));
 		else if (_literal.kind == assembly::LiteralKind::Boolean)
 		{
 			if (_literal.value == "true")
-				m_state.assembly.append(u256(1));
+				m_assembly.appendConstant(u256(1));
 			else
-				m_state.assembly.append(u256(0));
+				m_assembly.appendConstant(u256(0));
 		}
 		else
 		{
 			solAssert(_literal.value.size() <= 32, "");
-			m_state.assembly.append(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
+			m_assembly.appendConstant(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
 		}
 		checkStackHeight(&_literal);
 	}
 	void operator()(assembly::Identifier const& _identifier)
 	{
-		m_state.assembly.setSourceLocation(_identifier.location);
+		m_assembly.setSourceLocation(_identifier.location);
 		// First search internals, then externals.
 		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
 			[=](Scope::Variable& _var)
 			{
 				if (int heightDiff = variableHeightDiff(_var, _identifier.location, false))
-					m_state.assembly.append(solidity::dupInstruction(heightDiff));
+					m_assembly.appendInstruction(solidity::dupInstruction(heightDiff));
 				else
 					// Store something to balance the stack
-					m_state.assembly.append(u256(0));
+					m_assembly.appendConstant(u256(0));
 			},
 			[=](Scope::Label& _label)
 			{
 				assignLabelIdIfUnset(_label);
-				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
+				m_assembly.appendLabelReference(*_label.id);
 			},
 			[=](Scope::Function&)
 			{
@@ -164,14 +206,14 @@ public:
 			m_identifierAccess.generateCode,
 			"Identifier not found and no external access available."
 		);
-		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_state.assembly);
+		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_assembly);
 		checkStackHeight(&_identifier);
 	}
 	void operator()(FunctionalInstruction const& _instr)
 	{
 		for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
 		{
-			int height = m_state.assembly.deposit();
+			int height = m_assembly.stackHeight();
 			boost::apply_visitor(*this, *it);
 			expectDeposit(1, height);
 		}
@@ -184,31 +226,31 @@ public:
 	}
 	void operator()(Label const& _label)
 	{
-		m_state.assembly.setSourceLocation(_label.location);
+		m_assembly.setSourceLocation(_label.location);
 		solAssert(m_scope.identifiers.count(_label.name), "");
 		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers.at(_label.name));
 		assignLabelIdIfUnset(label);
-		m_state.assembly.append(eth::AssemblyItem(eth::Tag, label.id));
+		m_assembly.appendLabel(*label.id);
 		checkStackHeight(&_label);
 	}
 	void operator()(assembly::Assignment const& _assignment)
 	{
-		m_state.assembly.setSourceLocation(_assignment.location);
+		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
 	void operator()(FunctionalAssignment const& _assignment)
 	{
-		int height = m_state.assembly.deposit();
+		size_t height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
 		expectDeposit(1, height);
-		m_state.assembly.setSourceLocation(_assignment.location);
+		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
-		int height = m_state.assembly.deposit();
+		size_t height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
 		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
@@ -217,7 +259,7 @@ public:
 	}
 	void operator()(assembly::Block const& _block)
 	{
-		CodeTransform(m_state, _block, m_identifierAccess, m_initialDeposit);
+		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
 		checkStackHeight(&_block);
 	}
 	void operator()(assembly::FunctionDefinition const&)
@@ -233,8 +275,8 @@ private:
 		{
 			Scope::Variable const& _var = boost::get<Scope::Variable>(*var);
 			if (int heightDiff = variableHeightDiff(_var, _location, true))
-				m_state.assembly.append(solidity::swapInstruction(heightDiff - 1));
-			m_state.assembly.append(solidity::Instruction::POP);
+				m_assembly.appendInstruction(solidity::swapInstruction(heightDiff - 1));
+			m_assembly.appendInstruction(solidity::Instruction::POP);
 		}
 		else
 		{
@@ -242,16 +284,16 @@ private:
 				m_identifierAccess.generateCode,
 				"Identifier not found and no external access available."
 			);
-			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_state.assembly);
+			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_assembly);
 		}
 	}
 
 	/// Determines the stack height difference to the given variables. Automatically generates
 	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
 	/// errors and the (positive) stack height difference otherwise.
-	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
+	size_t variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
 	{
-		int heightDiff = m_state.assembly.deposit() - _var.stackHeight;
+		size_t heightDiff = m_assembly.stackHeight() - _var.stackHeight;
 		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
 		{
 			//@TODO move this to analysis phase.
@@ -268,14 +310,14 @@ private:
 
 	void expectDeposit(int _deposit, int _oldHeight)
 	{
-		solAssert(m_state.assembly.deposit() == _oldHeight + _deposit, "Invalid stack deposit.");
+		solAssert(m_assembly.stackHeight() == _oldHeight + _deposit, "Invalid stack deposit.");
 	}
 
 	void checkStackHeight(void const* _astElement)
 	{
 		solAssert(m_state.info.stackHeightInfo.count(_astElement), "Stack height for AST element not found.");
 		solAssert(
-			m_state.info.stackHeightInfo.at(_astElement) == m_state.assembly.deposit() - m_initialDeposit,
+			m_state.info.stackHeightInfo.at(_astElement) == m_assembly.stackHeight() - m_initialStackHeight,
 			"Stack height mismatch between analysis and code generation phase."
 		);
 	}
@@ -283,15 +325,16 @@ private:
 	/// Assigns the label's id to a value taken from eth::Assembly if it has not yet been set.
 	void assignLabelIdIfUnset(Scope::Label& _label)
 	{
-		if (_label.id == Scope::Label::unassignedLabelId)
-			_label.id = m_state.newLabelId();
+		if (!_label.id)
+			_label.id.reset(m_assembly.newLabel());
 	}
 
 
 	GeneratorState& m_state;
+	julia::AbstractAssembly& m_assembly;
 	Scope& m_scope;
 	ExternalIdentifierAccess m_identifierAccess;
-	int const m_initialDeposit;
+	int const m_initialStackHeight;
 };
 
 eth::Assembly assembly::CodeGenerator::assemble(
@@ -301,8 +344,9 @@ eth::Assembly assembly::CodeGenerator::assemble(
 )
 {
 	eth::Assembly assembly;
-	GeneratorState state(m_errors, _analysisInfo, assembly);
-	CodeTransform(state, _parsedData, _identifierAccess);
+	GeneratorState state(m_errors, _analysisInfo);
+	EthAssemblyAdapter assemblyAdapter(assembly);
+	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
 	return assembly;
 }
 
@@ -313,6 +357,7 @@ void assembly::CodeGenerator::assemble(
 	ExternalIdentifierAccess const& _identifierAccess
 )
 {
-	GeneratorState state(m_errors, _analysisInfo, _assembly);
-	CodeTransform(state, _parsedData, _identifierAccess);
+	GeneratorState state(m_errors, _analysisInfo);
+	EthAssemblyAdapter assemblyAdapter(_assembly);
+	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index dd45613d..70786dce 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -23,6 +23,7 @@
 #include <libsolidity/interface/Exceptions.h>
 
 #include <boost/variant.hpp>
+#include <boost/optional.hpp>
 
 #include <functional>
 #include <memory>
@@ -75,8 +76,7 @@ struct Scope
 
 	struct Label
 	{
-		size_t id = unassignedLabelId;
-		static const size_t unassignedLabelId = 0;
+		boost::optional<size_t> id;
 	};
 
 	struct Function
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index 77a7e02a..e223ccc9 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -24,6 +24,8 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
+#include <libjulia/backends/AbstractAssembly.h>
+
 #include <string>
 #include <functional>
 
@@ -51,7 +53,7 @@ struct ExternalIdentifierAccess
 	/// Resolve a an external reference given by the identifier in the given context.
 	/// @returns the size of the value (number of stack slots) or size_t(-1) if not found.
 	Resolver resolve;
-	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, eth::Assembly&)>;
+	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, julia::AbstractAssembly&)>;
 	/// Generate code for retrieving the value (rvalue context) or storing the value (lvalue context)
 	/// of an identifier. The code should be appended to the assembly. In rvalue context, the value is supposed
 	/// to be put onto the stack, in lvalue context, the value is assumed to be at the top of the stack.
-- 
cgit v1.2.3


From 69413ae32a07ebe51adf3eca295cef4dfcd513b4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 19 May 2017 20:12:12 +0200
Subject: Review changes.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index a6d7e76b..3591ba97 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -87,7 +87,7 @@ public:
 	{
 		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
 	}
-	virtual size_t newLabel() override
+	virtual size_t newLabelId() override
 	{
 		return assemblyTagToIdentifier(m_assembly.newTag());
 	}
@@ -241,7 +241,7 @@ public:
 	}
 	void operator()(FunctionalAssignment const& _assignment)
 	{
-		size_t height = m_assembly.stackHeight();
+		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
 		expectDeposit(1, height);
 		m_assembly.setSourceLocation(_assignment.location);
@@ -250,7 +250,7 @@ public:
 	}
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
-		size_t height = m_assembly.stackHeight();
+		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
 		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
@@ -291,9 +291,9 @@ private:
 	/// Determines the stack height difference to the given variables. Automatically generates
 	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
 	/// errors and the (positive) stack height difference otherwise.
-	size_t variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
+	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
 	{
-		size_t heightDiff = m_assembly.stackHeight() - _var.stackHeight;
+		int heightDiff = m_assembly.stackHeight() - _var.stackHeight;
 		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
 		{
 			//@TODO move this to analysis phase.
@@ -326,7 +326,7 @@ private:
 	void assignLabelIdIfUnset(Scope::Label& _label)
 	{
 		if (!_label.id)
-			_label.id.reset(m_assembly.newLabel());
+			_label.id.reset(m_assembly.newLabelId());
 	}
 
 
-- 
cgit v1.2.3


From 7f5601fd4b63e90313f1a9c1a53e08ba9757b452 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 19 May 2017 20:15:28 +0200
Subject: Add const

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 3591ba97..b8af9dc6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -97,7 +97,7 @@ public:
 	}
 
 private:
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag)
+	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
 		u256 id = _tag.data();
 		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
-- 
cgit v1.2.3


From 15b4d4def23bcf0feb93c67dccc137baa59d5102 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 18:35:40 +0100
Subject: Support multiple variables in a variable declaration in inline
 assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 28 ++++++++++++++++++++++++----
 libsolidity/inlineasm/AsmCodeGen.cpp     | 15 ++++++++++-----
 libsolidity/inlineasm/AsmData.h          |  2 +-
 libsolidity/inlineasm/AsmParser.cpp      | 20 +++++++++++++++++---
 libsolidity/inlineasm/AsmPrinter.cpp     | 16 +++++++++++++++-
 libsolidity/inlineasm/AsmScopeFiller.cpp |  5 ++++-
 6 files changed, 71 insertions(+), 15 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index e03eea2e..8d3d1fd2 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -181,12 +181,32 @@ bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
 
 bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 {
+	// The number of variable names and values must match. One exception
+	// is a single value, where a tuple assignment is assumed from a function.
+	if (_varDecl.variables.size() != _varDecl.values.size())
+	{
+		if (_varDecl.values.size() != 1)
+		{
+			m_errors.push_back(make_shared<Error>(
+				Error::Type::DeclarationError,
+				"Variable declaration name and value count mismatch.",
+				_varDecl.location
+			));
+			return false;
+		}
+	}
+
+	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
-	bool success = boost::apply_visitor(*this, *_varDecl.value);
-	solAssert(m_stackHeight - stackHeight == 1, "Invalid value size.");
-	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.variable.name)).active = true;
+	for (auto const& value: _varDecl.values)
+		if (!boost::apply_visitor(*this, value))
+			return false;
+	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
+
+	for (auto const& variable: _varDecl.variables)
+		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
-	return success;
+	return true;
 }
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index b8af9dc6..1063d552 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -251,11 +251,16 @@ public:
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
 		int height = m_assembly.stackHeight();
-		boost::apply_visitor(*this, *_varDecl.value);
-		expectDeposit(1, height);
-		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
-		var.stackHeight = height;
-		var.active = true;
+		int expectedItems = _varDecl.variables.size();
+		for (auto const& value: _varDecl.values)
+			boost::apply_visitor(*this, value);
+		expectDeposit(expectedItems, height);
+		for (auto const& variable: _varDecl.variables)
+		{
+			auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(variable.name));
+			var.stackHeight = height++;
+			var.active = true;
+		}
 	}
 	void operator()(assembly::Block const& _block)
 	{
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 8efe1f07..bf21ba00 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -65,7 +65,7 @@ struct FunctionalAssignment { SourceLocation location; Identifier variableName;
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
 /// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; TypedName variable; std::shared_ptr<Statement> value; };
+struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::vector<Statement> values; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index a96984f5..53954a49 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -258,11 +258,25 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 {
 	VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
 	expectToken(Token::Let);
-	varDecl.variable = parseTypedName();
+	while (true)
+	{
+		varDecl.variables.push_back(parseTypedName());
+		if (m_scanner->currentToken() == Token::Comma)
+			expectToken(Token::Comma);
+		else
+			break;
+	}
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
-	varDecl.value.reset(new Statement(parseExpression()));
-	varDecl.location.end = locationOf(*varDecl.value).end;
+	while (true)
+	{
+		varDecl.values.emplace_back(new Statement(parseExpression()));
+		if (m_scanner->currentToken() == Token::Comma)
+			expectToken(Token::Comma);
+		else
+			break;
+	}
+	varDecl.location.end = locationOf(varDecl.values.back()).end;
 	return varDecl;
 }
 
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 636e61b8..845aefb9 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -121,7 +121,21 @@ string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalA
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
 {
-	return "let " + _variableDeclaration.variable.name + appendTypeName(_variableDeclaration.variable.type) + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
+	string out = "let ";
+	out += boost::algorithm::join(
+		_variableDeclaration.variables | boost::adaptors::transformed(
+			[this](TypedName variable) { return variable.name + appendTypeName(variable.type); }
+		),
+		", "
+	);
+	out += " := ";
+	out += boost::algorithm::join(
+		_variableDeclaration.values | boost::adaptors::transformed(
+			[this](Statement statement) { return boost::apply_visitor(*this, statement); }
+		),
+		", "
+	);
+	return out;
 }
 
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index eb10dbb3..05b1b211 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -59,7 +59,10 @@ bool ScopeFiller::operator()(Label const& _item)
 
 bool ScopeFiller::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	return registerVariable(_varDecl.variable, _varDecl.location, *m_currentScope);
+	for (auto const& variable: _varDecl.variables)
+		if (!registerVariable(variable, _varDecl.location, *m_currentScope))
+			return false;
+	return true;
 }
 
 bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
-- 
cgit v1.2.3


From cb4966046d9871b63084ddcf0ff6fac8a4c322aa Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 18:56:29 +0100
Subject: Enable a single right hand item on let

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 21 ++-------------------
 libsolidity/inlineasm/AsmCodeGen.cpp  |  3 +--
 libsolidity/inlineasm/AsmData.h       |  2 +-
 libsolidity/inlineasm/AsmParser.cpp   | 11 ++---------
 libsolidity/inlineasm/AsmPrinter.cpp  |  7 +------
 5 files changed, 7 insertions(+), 37 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8d3d1fd2..5062fcf4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -181,32 +181,15 @@ bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
 
 bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	// The number of variable names and values must match. One exception
-	// is a single value, where a tuple assignment is assumed from a function.
-	if (_varDecl.variables.size() != _varDecl.values.size())
-	{
-		if (_varDecl.values.size() != 1)
-		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable declaration name and value count mismatch.",
-				_varDecl.location
-			));
-			return false;
-		}
-	}
-
 	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
-	for (auto const& value: _varDecl.values)
-		if (!boost::apply_visitor(*this, value))
-			return false;
+	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
 
 	for (auto const& variable: _varDecl.variables)
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
-	return true;
+	return success;
 }
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 1063d552..02d5ced0 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -252,8 +252,7 @@ public:
 	{
 		int height = m_assembly.stackHeight();
 		int expectedItems = _varDecl.variables.size();
-		for (auto const& value: _varDecl.values)
-			boost::apply_visitor(*this, value);
+		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(expectedItems, height);
 		for (auto const& variable: _varDecl.variables)
 		{
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index bf21ba00..65dfbadf 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -65,7 +65,7 @@ struct FunctionalAssignment { SourceLocation location; Identifier variableName;
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
 /// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::vector<Statement> values; };
+struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::shared_ptr<Statement> value; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 53954a49..73f70e3f 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -268,15 +268,8 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	}
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
-	while (true)
-	{
-		varDecl.values.emplace_back(new Statement(parseExpression()));
-		if (m_scanner->currentToken() == Token::Comma)
-			expectToken(Token::Comma);
-		else
-			break;
-	}
-	varDecl.location.end = locationOf(varDecl.values.back()).end;
+	varDecl.value.reset(new Statement(parseExpression()));
+	varDecl.location.end = locationOf(*varDecl.value).end;
 	return varDecl;
 }
 
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 845aefb9..219a57ad 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -129,12 +129,7 @@ string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDecl
 		", "
 	);
 	out += " := ";
-	out += boost::algorithm::join(
-		_variableDeclaration.values | boost::adaptors::transformed(
-			[this](Statement statement) { return boost::apply_visitor(*this, statement); }
-		),
-		", "
-	);
+	out += boost::apply_visitor(*this, *_variableDeclaration.value);
 	return out;
 }
 
-- 
cgit v1.2.3


From 3451a30e5cd6d8bceedba70bf9c5012f263b3ec8 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 21:10:05 +0100
Subject: Display actual error message and not assertion in analysis

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 5062fcf4..9e0ade2a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -184,7 +184,15 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
-	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
+	if ((m_stackHeight - stackHeight) != expectedItems)
+	{
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::DeclarationError,
+			"Variable count mismatch.",
+			_varDecl.location
+		));
+		return false;
+	}
 
 	for (auto const& variable: _varDecl.variables)
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
-- 
cgit v1.2.3


From f15d6ea45fd9470ba7ec1fcdc57796b268c0e7a5 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:02:11 +0100
Subject: Rename Assignment to StackAssignment

---
 libsolidity/inlineasm/AsmAnalysis.cpp   | 2 +-
 libsolidity/inlineasm/AsmAnalysis.h     | 4 ++--
 libsolidity/inlineasm/AsmAnalysisInfo.h | 4 ++--
 libsolidity/inlineasm/AsmCodeGen.cpp    | 2 +-
 libsolidity/inlineasm/AsmData.h         | 6 +++---
 libsolidity/inlineasm/AsmParser.cpp     | 2 +-
 libsolidity/inlineasm/AsmPrinter.cpp    | 2 +-
 libsolidity/inlineasm/AsmPrinter.h      | 4 ++--
 libsolidity/inlineasm/AsmScopeFiller.h  | 4 ++--
 9 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 9e0ade2a..ed0211d4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -160,7 +160,7 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	return success;
 }
 
-bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
+bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 {
 	bool success = checkAssignment(_assignment.variableName, size_t(-1));
 	m_info.stackHeightInfo[&_assignment] = m_stackHeight;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 426ee0d2..4f2a9d9e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -44,7 +44,7 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
@@ -73,7 +73,7 @@ public:
 	bool operator()(assembly::Identifier const&);
 	bool operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	bool operator()(assembly::Label const& _label);
-	bool operator()(assembly::Assignment const&);
+	bool operator()(assembly::StackAssignment const&);
 	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index e21eb2c5..6f5b1159 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -40,13 +40,13 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 02d5ced0..708073e1 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -233,7 +233,7 @@ public:
 		m_assembly.appendLabel(*label.id);
 		checkStackHeight(&_label);
 	}
-	void operator()(assembly::Assignment const& _assignment)
+	void operator()(assembly::StackAssignment const& _assignment)
 	{
 		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 65dfbadf..9d8610cf 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -50,14 +50,14 @@ struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
 /// Jump label ("name:")
 struct Label { SourceLocation location; std::string name; };
-/// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
-struct Assignment { SourceLocation location; Identifier variableName; };
+/// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
+struct StackAssignment { SourceLocation location; Identifier variableName; };
 struct FunctionalAssignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 /// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 73f70e3f..7c23e6b4 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -71,7 +71,7 @@ assembly::Statement Parser::parseStatement()
 	{
 		if (m_julia)
 			break;
-		assembly::Assignment assignment = createWithLocation<assembly::Assignment>();
+		assembly::StackAssignment assignment = createWithLocation<assembly::StackAssignment>();
 		m_scanner->next();
 		expectToken(Token::Colon);
 		assignment.variableName.location = location();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 219a57ad..8001f361 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -108,7 +108,7 @@ string AsmPrinter::operator()(assembly::Label const& _label)
 	return _label.name + ":";
 }
 
-string AsmPrinter::operator()(assembly::Assignment const& _assignment)
+string AsmPrinter::operator()(assembly::StackAssignment const& _assignment)
 {
 	solAssert(!m_julia, "");
 	return "=: " + (*this)(_assignment.variableName);
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 282fd7e3..c608f8cb 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -35,7 +35,7 @@ struct Literal;
 struct Identifier;
 struct FunctionalInstruction;
 struct Label;
-struct Assignment;
+struct StackAssignment;
 struct FunctionalAssignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
@@ -52,7 +52,7 @@ public:
 	std::string operator()(assembly::Identifier const& _identifier);
 	std::string operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	std::string operator()(assembly::Label const& _label);
-	std::string operator()(assembly::Assignment const& _assignment);
+	std::string operator()(assembly::StackAssignment const& _assignment);
 	std::string operator()(assembly::FunctionalAssignment const& _functionalAssignment);
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 61428eea..8aa96208 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -43,7 +43,7 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
@@ -64,7 +64,7 @@ public:
 	bool operator()(assembly::Identifier const&) { return true; }
 	bool operator()(assembly::FunctionalInstruction const&) { return true; }
 	bool operator()(assembly::Label const& _label);
-	bool operator()(assembly::Assignment const&) { return true; }
+	bool operator()(assembly::StackAssignment const&) { return true; }
 	bool operator()(assembly::FunctionalAssignment const&) { return true; }
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
-- 
cgit v1.2.3


From 187fa5075105008578fa2af467eda44bfa444144 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:07:00 +0100
Subject: Rename FunctionalAssignment to Assignment

---
 libsolidity/inlineasm/AsmAnalysis.cpp   |  2 +-
 libsolidity/inlineasm/AsmAnalysis.h     |  4 ++--
 libsolidity/inlineasm/AsmAnalysisInfo.h |  4 ++--
 libsolidity/inlineasm/AsmCodeGen.cpp    |  2 +-
 libsolidity/inlineasm/AsmData.h         |  8 ++++----
 libsolidity/inlineasm/AsmParser.cpp     | 11 +++++------
 libsolidity/inlineasm/AsmPrinter.cpp    |  4 ++--
 libsolidity/inlineasm/AsmPrinter.h      |  4 ++--
 libsolidity/inlineasm/AsmScopeFiller.h  |  4 ++--
 9 files changed, 21 insertions(+), 22 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ed0211d4..babb93b4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -168,7 +168,7 @@ bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 }
 
 
-bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
+bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
 {
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_assignment.value);
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 4f2a9d9e..f09e4b59 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -40,7 +40,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -74,7 +74,7 @@ public:
 	bool operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	bool operator()(assembly::Label const& _label);
 	bool operator()(assembly::StackAssignment const&);
-	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
+	bool operator()(assembly::Assignment const& _assignment);
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 6f5b1159..d2253c78 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -36,7 +36,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -46,7 +46,7 @@ struct FunctionCall;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 708073e1..53eafc96 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -239,7 +239,7 @@ public:
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
-	void operator()(FunctionalAssignment const& _assignment)
+	void operator()(assembly::Assignment const& _assignment)
 	{
 		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 9d8610cf..3d2c8cad 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -52,15 +52,15 @@ struct FunctionalInstruction;
 struct Label { SourceLocation location; std::string name; };
 /// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
 struct StackAssignment { SourceLocation location; Identifier variableName; };
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
-/// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+/// Assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
-struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
+struct Assignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
 /// Functional instruction, e.g. "mul(mload(20:u256), add(2:u256, x))"
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 7c23e6b4..ffd9f6e2 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -107,15 +107,14 @@ assembly::Statement Parser::parseStatement()
 		// while identifier:= (being followed by a non-colon) as identifier := (assignment).
 		if (m_scanner->currentToken() == Token::Assign && m_scanner->peekNextToken() != Token::Colon)
 		{
-			// functional assignment
-			FunctionalAssignment funAss = createWithLocation<FunctionalAssignment>(identifier.location);
+			assembly::Assignment assignment = createWithLocation<assembly::Assignment>(identifier.location);
 			if (!m_julia && instructions().count(identifier.name))
 				fatalParserError("Cannot use instruction names for identifier names.");
 			m_scanner->next();
-			funAss.variableName = identifier;
-			funAss.value.reset(new Statement(parseExpression()));
-			funAss.location.end = locationOf(*funAss.value).end;
-			return funAss;
+			assignment.variableName = identifier;
+			assignment.value.reset(new Statement(parseExpression()));
+			assignment.location.end = locationOf(*assignment.value).end;
+			return assignment;
 		}
 		else
 		{
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 8001f361..92b12423 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -114,9 +114,9 @@ string AsmPrinter::operator()(assembly::StackAssignment const& _assignment)
 	return "=: " + (*this)(_assignment.variableName);
 }
 
-string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalAssignment)
+string AsmPrinter::operator()(assembly::Assignment const& _assignment)
 {
-	return (*this)(_functionalAssignment.variableName) + " := " + boost::apply_visitor(*this, *_functionalAssignment.value);
+	return (*this)(_assignment.variableName) + " := " + boost::apply_visitor(*this, *_assignment.value);
 }
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index c608f8cb..423eeefa 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -36,7 +36,7 @@ struct Identifier;
 struct FunctionalInstruction;
 struct Label;
 struct StackAssignment;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
@@ -53,7 +53,7 @@ public:
 	std::string operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	std::string operator()(assembly::Label const& _label);
 	std::string operator()(assembly::StackAssignment const& _assignment);
-	std::string operator()(assembly::FunctionalAssignment const& _functionalAssignment);
+	std::string operator()(assembly::Assignment const& _assignment);
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 8aa96208..b1b0833b 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -39,7 +39,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -65,7 +65,7 @@ public:
 	bool operator()(assembly::FunctionalInstruction const&) { return true; }
 	bool operator()(assembly::Label const& _label);
 	bool operator()(assembly::StackAssignment const&) { return true; }
-	bool operator()(assembly::FunctionalAssignment const&) { return true; }
+	bool operator()(assembly::Assignment const&) { return true; }
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
-- 
cgit v1.2.3


From 4f738ff1c0975202f064900549eca4661d2f51a6 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:14:06 +0100
Subject: Reorder AsmData for readability

---
 libsolidity/inlineasm/AsmData.h | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 3d2c8cad..3b4048c3 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -40,6 +40,20 @@ using TypedNameList = std::vector<TypedName>;
 
 /// What follows are the AST nodes for assembly.
 
+struct Instruction;
+struct Literal;
+struct Label;
+struct StackAssignment;
+struct Identifier;
+struct Assignment;
+struct VariableDeclaration;
+struct FunctionalInstruction;
+struct FunctionDefinition;
+struct FunctionCall;
+struct Block;
+
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
@@ -47,17 +61,10 @@ enum class LiteralKind { Number, Boolean, String };
 struct Literal { SourceLocation location; LiteralKind kind; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
-struct FunctionalInstruction;
 /// Jump label ("name:")
 struct Label { SourceLocation location; std::string name; };
 /// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
 struct StackAssignment { SourceLocation location; Identifier variableName; };
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 /// Assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct Assignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
-- 
cgit v1.2.3


From b77b11781d174712bd141d0fd82e823cd2727aec Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:26:17 +0100
Subject: Rename parseFunctionalInstruction to parseCall

---
 libsolidity/inlineasm/AsmParser.cpp | 6 +++---
 libsolidity/inlineasm/AsmParser.h   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index ffd9f6e2..85ae9424 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -96,7 +96,7 @@ assembly::Statement Parser::parseStatement()
 	switch (m_scanner->currentToken())
 	{
 	case Token::LParen:
-		return parseFunctionalInstruction(std::move(statement));
+		return parseCall(std::move(statement));
 	case Token::Colon:
 	{
 		if (statement.type() != typeid(assembly::Identifier))
@@ -138,7 +138,7 @@ assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
 	if (m_scanner->currentToken() == Token::LParen)
-		return parseFunctionalInstruction(std::move(operation));
+		return parseCall(std::move(operation));
 	else
 		return operation;
 }
@@ -303,7 +303,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	return funDef;
 }
 
-assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _instruction)
+assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 {
 	if (_instruction.type() == typeid(Instruction))
 	{
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index addc1725..812762a6 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -68,7 +68,7 @@ protected:
 	Statement parseElementaryOperation(bool _onlySinglePusher = false);
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
-	Statement parseFunctionalInstruction(Statement&& _instruction);
+	Statement parseCall(Statement&& _instruction);
 	TypedName parseTypedName();
 	std::string expectAsmIdentifier();
 
-- 
cgit v1.2.3


From 74d41ad25fa53d3ac2e34bb082b467cb7dc56b99 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 23 May 2017 22:58:37 +0100
Subject: Fix scope assert in AsmAnalyzer

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index babb93b4..65b935f2 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -406,6 +406,7 @@ bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, Source
 
 Scope& AsmAnalyzer::scope(Block const* _block)
 {
+	solAssert(m_info.scopes.count(_block) == 1, "Scope requested but not present.");
 	auto scopePtr = m_info.scopes.at(_block);
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
-- 
cgit v1.2.3


From 56fe3a6ab93116438ea52634e891c71b995d7c3f Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 13:13:05 +0100
Subject: Better error messages during parsing functional instructions

---
 libsolidity/inlineasm/AsmParser.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 85ae9424..519bfa2e 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -321,6 +321,15 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		unsigned args = unsigned(instrInfo.args);
 		for (unsigned i = 0; i < args; ++i)
 		{
+			/// check for premature closing parentheses
+			if (m_scanner->currentToken() == Token::RParen)
+				fatalParserError(string(
+					"Expected " +
+					boost::lexical_cast<string>(args) +
+					" arguments, but received " +
+					boost::lexical_cast<string>(i)
+				));
+
 			ret.arguments.emplace_back(parseExpression());
 			if (i != args - 1)
 			{
-- 
cgit v1.2.3


From 338202ea96e0af8822dde3acc27aa45f79c8780b Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 13:27:58 +0100
Subject: Uniform error messages

---
 libsolidity/inlineasm/AsmParser.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 519bfa2e..530cd726 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -324,10 +324,11 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			/// check for premature closing parentheses
 			if (m_scanner->currentToken() == Token::RParen)
 				fatalParserError(string(
-					"Expected " +
+					"Expected expression (" +
+					instrInfo.name +
+					" expects " +
 					boost::lexical_cast<string>(args) +
-					" arguments, but received " +
-					boost::lexical_cast<string>(i)
+					" arguments)"
 				));
 
 			ret.arguments.emplace_back(parseExpression());
-- 
cgit v1.2.3


From b5080860d5f2d141b8fccceaa635378a86c996a8 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 28 Apr 2017 14:27:56 +0100
Subject: Implement switch statement in the assembly parser/printer

---
 libsolidity/inlineasm/AsmAnalysis.cpp   | 32 ++++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmAnalysis.h     |  2 ++
 libsolidity/inlineasm/AsmAnalysisInfo.h |  3 ++-
 libsolidity/inlineasm/AsmCodeGen.cpp    |  4 ++++
 libsolidity/inlineasm/AsmData.h         |  7 ++++++-
 libsolidity/inlineasm/AsmParser.cpp     | 30 ++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmParser.h       |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp    | 14 ++++++++++++++
 libsolidity/inlineasm/AsmPrinter.h      |  2 ++
 libsolidity/inlineasm/AsmScopeFiller.h  |  2 ++
 10 files changed, 95 insertions(+), 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 65b935f2..ecc63372 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -285,6 +285,38 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 	return success;
 }
 
+bool AsmAnalyzer::operator()(Switch const& _switch)
+{
+	int const initialStackHeight = m_stackHeight;
+	if (!boost::apply_visitor(*this, *_switch.expression))
+		return false;
+	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
+
+	map<string, bool> caseNames;
+	for (auto const& _case: _switch.cases)
+	{
+		/// Note: the parser ensures there is only one default case
+		if (caseNames[_case.name])
+		{
+			m_errors.push_back(make_shared<Error>(
+				Error::Type::DeclarationError,
+				"Duplicate case defined: " + _case.name,
+				_case.location
+			));
+			return false;
+		}
+		else
+			caseNames[_case.name] = true;
+
+		if (!(*this)(_case.body))
+			return false;
+	}
+
+	m_stackHeight--;
+
+	return true;
+}
+
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index f09e4b59..9f022b12 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -47,6 +47,7 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
@@ -78,6 +79,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
+	bool operator()(assembly::Switch const& _switch);
 	bool operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index d2253c78..18382db0 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -43,10 +43,11 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 53eafc96..5c66b125 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -266,6 +266,10 @@ public:
 		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
 		checkStackHeight(&_block);
 	}
+	void operator()(assembly::Switch const&)
+	{
+		solAssert(false, "Switch not removed during desugaring phase.");
+	}
 	void operator()(assembly::FunctionDefinition const&)
 	{
 		solAssert(false, "Function definition not removed during desugaring phase.");
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 3b4048c3..92ff1c5a 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -50,9 +50,10 @@ struct VariableDeclaration;
 struct FunctionalInstruction;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 struct Block;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
@@ -77,6 +78,10 @@ struct VariableDeclaration { SourceLocation location; TypedNameList variables; s
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
 struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
+/// Switch case or default case
+struct Case { SourceLocation location; std::string name; Block body; };
+/// Switch statement
+struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 530cd726..a3a25a42 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -67,6 +67,20 @@ assembly::Statement Parser::parseStatement()
 		return parseFunctionDefinition();
 	case Token::LBrace:
 		return parseBlock();
+	case Token::Switch:
+	{
+		assembly::Switch _switch = createWithLocation<assembly::Switch>();
+		m_scanner->next();
+		_switch.expression = make_shared<Statement>(parseExpression());
+		while (m_scanner->currentToken() == Token::Case)
+			_switch.cases.emplace_back(parseCase());
+		if (m_scanner->currentToken() == Token::Default)
+			_switch.cases.emplace_back(parseCase(true));
+		if (_switch.cases.size() == 0)
+			fatalParserError("Switch statement without any cases.");
+		_switch.location.end = _switch.cases.back().body.location.end;
+		return _switch;
+	}
 	case Token::Assign:
 	{
 		if (m_julia)
@@ -134,6 +148,22 @@ assembly::Statement Parser::parseStatement()
 	return statement;
 }
 
+assembly::Case Parser::parseCase(bool _defaultCase)
+{
+	assembly::Case _case = createWithLocation<assembly::Case>();
+	if (_defaultCase)
+		expectToken(Token::Default);
+	else
+	{
+		expectToken(Token::Case);
+		_case.name = expectAsmIdentifier();
+	}
+	expectToken(Token::Colon);
+	_case.body = parseBlock();
+	_case.location.end = _case.body.location.end;
+	return _case;
+}
+
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 812762a6..d1d0c1cc 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -62,6 +62,7 @@ protected:
 
 	Block parseBlock();
 	Statement parseStatement();
+	Case parseCase(bool _defaultCase = false);
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	std::map<std::string, dev::solidity::Instruction> const& instructions();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 92b12423..92200f84 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -167,6 +167,20 @@ string AsmPrinter::operator()(assembly::FunctionCall const& _functionCall)
 		")";
 }
 
+string AsmPrinter::operator()(Switch const& _switch)
+{
+	string out = "switch " + boost::apply_visitor(*this, *_switch.expression);
+	for (auto const& _case: _switch.cases)
+	{
+		if (_case.name.empty())
+			out += "\ndefault: ";
+		else
+			out += "\ncase " + _case.name + ": ";
+		out += (*this)(_case.body);
+	}
+	return out;
+}
+
 string AsmPrinter::operator()(Block const& _block)
 {
 	if (_block.statements.empty())
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 423eeefa..b0d7fc09 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -40,6 +40,7 @@ struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
@@ -57,6 +58,7 @@ public:
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
+	std::string operator()(assembly::Switch const& _switch);
 	std::string operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index b1b0833b..0f5a5dd6 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -46,6 +46,7 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
@@ -69,6 +70,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
+	bool operator()(assembly::Switch const&) { return true; };
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From 66eab1caf63f9221a279abf71de953524fe9c2ad Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 17 May 2017 11:21:37 +0100
Subject: Change switch case string to Literal

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 30 +++++++++++++++++++-----------
 libsolidity/inlineasm/AsmData.h       |  2 +-
 libsolidity/inlineasm/AsmParser.cpp   |  5 ++++-
 libsolidity/inlineasm/AsmPrinter.cpp  |  4 ++--
 4 files changed, 26 insertions(+), 15 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ecc63372..a83a93a8 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -292,21 +292,29 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 		return false;
 	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
-	map<string, bool> caseNames;
+	set<tuple<LiteralKind, string>> cases;
 	for (auto const& _case: _switch.cases)
 	{
-		/// Note: the parser ensures there is only one default case
-		if (caseNames[_case.name])
+		if (_case.value)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Duplicate case defined: " + _case.name,
-				_case.location
-			));
-			return false;
+			int const initialStackHeight = m_stackHeight;
+			if (!(*this)(*_case.value))
+				return false;
+			expectDeposit(1, initialStackHeight, _case.value->location);
+			m_stackHeight--;
+
+			/// Note: the parser ensures there is only one default case
+			auto val = make_tuple(_case.value->kind, _case.value->value);
+			if (!cases.insert(val).second)
+			{
+				m_errors.push_back(make_shared<Error>(
+					Error::Type::DeclarationError,
+					"Duplicate case defined",
+					_case.location
+				));
+				return false;
+			}
 		}
-		else
-			caseNames[_case.name] = true;
 
 		if (!(*this)(_case.body))
 			return false;
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 92ff1c5a..72afeef1 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -79,7 +79,7 @@ struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
 struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
 /// Switch case or default case
-struct Case { SourceLocation location; std::string name; Block body; };
+struct Case { SourceLocation location; std::shared_ptr<Literal> value; Block body; };
 /// Switch statement
 struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
 
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index a3a25a42..11b33218 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -156,7 +156,10 @@ assembly::Case Parser::parseCase(bool _defaultCase)
 	else
 	{
 		expectToken(Token::Case);
-		_case.name = expectAsmIdentifier();
+		assembly::Statement statement = parseElementaryOperation();
+		if (statement.type() != typeid(assembly::Literal))
+			fatalParserError("Literal expected.");
+		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
 	expectToken(Token::Colon);
 	_case.body = parseBlock();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 92200f84..1ef9d071 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -172,10 +172,10 @@ string AsmPrinter::operator()(Switch const& _switch)
 	string out = "switch " + boost::apply_visitor(*this, *_switch.expression);
 	for (auto const& _case: _switch.cases)
 	{
-		if (_case.name.empty())
+		if (!_case.value)
 			out += "\ndefault: ";
 		else
-			out += "\ncase " + _case.name + ": ";
+			out += "\ncase " + (*this)(*_case.value) + ": ";
 		out += (*this)(_case.body);
 	}
 	return out;
-- 
cgit v1.2.3


From db3d9e0416e7ac69ddf13eb6e2fd4e0a35dd1a63 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 17:54:55 +0100
Subject: Switch cases are not followed by colon

---
 libsolidity/inlineasm/AsmParser.cpp  | 1 -
 libsolidity/inlineasm/AsmPrinter.cpp | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 11b33218..63c08b15 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -161,7 +161,6 @@ assembly::Case Parser::parseCase(bool _defaultCase)
 			fatalParserError("Literal expected.");
 		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
-	expectToken(Token::Colon);
 	_case.body = parseBlock();
 	_case.location.end = _case.body.location.end;
 	return _case;
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 1ef9d071..e282e5e8 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -173,9 +173,9 @@ string AsmPrinter::operator()(Switch const& _switch)
 	for (auto const& _case: _switch.cases)
 	{
 		if (!_case.value)
-			out += "\ndefault: ";
+			out += "\ndefault ";
 		else
-			out += "\ncase " + (*this)(*_case.value) + ": ";
+			out += "\ncase " + (*this)(*_case.value) + " ";
 		out += (*this)(_case.body);
 	}
 	return out;
-- 
cgit v1.2.3


From e48e84ca2bfdf863a798c88c329796284b2a87cb Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 18:04:40 +0100
Subject: Check token within parseCase

---
 libsolidity/inlineasm/AsmParser.cpp | 14 ++++++++------
 libsolidity/inlineasm/AsmParser.h   |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 63c08b15..537a39a1 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -75,7 +75,7 @@ assembly::Statement Parser::parseStatement()
 		while (m_scanner->currentToken() == Token::Case)
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
-			_switch.cases.emplace_back(parseCase(true));
+			_switch.cases.emplace_back(parseCase());
 		if (_switch.cases.size() == 0)
 			fatalParserError("Switch statement without any cases.");
 		_switch.location.end = _switch.cases.back().body.location.end;
@@ -148,19 +148,21 @@ assembly::Statement Parser::parseStatement()
 	return statement;
 }
 
-assembly::Case Parser::parseCase(bool _defaultCase)
+assembly::Case Parser::parseCase()
 {
 	assembly::Case _case = createWithLocation<assembly::Case>();
-	if (_defaultCase)
-		expectToken(Token::Default);
-	else
+	if (m_scanner->currentToken() == Token::Default)
+		m_scanner->next();
+	else if (m_scanner->currentToken() == Token::Case)
 	{
-		expectToken(Token::Case);
+		m_scanner->next();
 		assembly::Statement statement = parseElementaryOperation();
 		if (statement.type() != typeid(assembly::Literal))
 			fatalParserError("Literal expected.");
 		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
+	else
+		fatalParserError("Case or default case expected.");
 	_case.body = parseBlock();
 	_case.location.end = _case.body.location.end;
 	return _case;
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index d1d0c1cc..138af337 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -62,7 +62,7 @@ protected:
 
 	Block parseBlock();
 	Statement parseStatement();
-	Case parseCase(bool _defaultCase = false);
+	Case parseCase();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	std::map<std::string, dev::solidity::Instruction> const& instructions();
-- 
cgit v1.2.3


From ba8a79c600e45618a5cd0bbfc044edbeab1e551c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 18:33:25 +0100
Subject: Do not stop on first switch error

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index a83a93a8..d022ecf6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -287,9 +287,11 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 
 bool AsmAnalyzer::operator()(Switch const& _switch)
 {
+	bool success = true;
+
 	int const initialStackHeight = m_stackHeight;
 	if (!boost::apply_visitor(*this, *_switch.expression))
-		return false;
+		success = false;
 	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
 	set<tuple<LiteralKind, string>> cases;
@@ -299,7 +301,7 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 		{
 			int const initialStackHeight = m_stackHeight;
 			if (!(*this)(*_case.value))
-				return false;
+				success = false;
 			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
@@ -312,17 +314,17 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 					"Duplicate case defined",
 					_case.location
 				));
-				return false;
+				success = false;
 			}
 		}
 
 		if (!(*this)(_case.body))
-			return false;
+			success = false;
 	}
 
 	m_stackHeight--;
 
-	return true;
+	return success;
 }
 
 bool AsmAnalyzer::operator()(Block const& _block)
-- 
cgit v1.2.3


From d745dd6542d488432453035763211fdad78c3a06 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 23 May 2017 20:51:33 +0100
Subject: Visit case bodies in scope filler

---
 libsolidity/inlineasm/AsmScopeFiller.cpp | 9 +++++++++
 libsolidity/inlineasm/AsmScopeFiller.h   | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 05b1b211..7eb6a9ed 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -97,6 +97,15 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 	return success;
 }
 
+bool ScopeFiller::operator()(Switch const& _switch)
+{
+	bool success = true;
+	for (auto const& _case: _switch.cases)
+		if (!(*this)(_case.body))
+			success = false;
+	return success;
+}
+
 bool ScopeFiller::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 0f5a5dd6..c7179b3b 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -70,7 +70,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
-	bool operator()(assembly::Switch const&) { return true; };
+	bool operator()(assembly::Switch const& _switch);
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From c64bd3378427b46b0ae37e5d39e8ca6586d697c2 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 14:33:10 +0100
Subject: Disallow instructions as a switch expression

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 537a39a1..847735f4 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -72,6 +72,8 @@ assembly::Statement Parser::parseStatement()
 		assembly::Switch _switch = createWithLocation<assembly::Switch>();
 		m_scanner->next();
 		_switch.expression = make_shared<Statement>(parseExpression());
+		if (_switch.expression->type() == typeid(assembly::Instruction))
+			fatalParserError("Instructions are not supported as expressions for switch.");
 		while (m_scanner->currentToken() == Token::Case)
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
-- 
cgit v1.2.3


From 05fcf1989ca619d197d22d3acab79b25ef7aa695 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 01:49:32 +0100
Subject: Better error messages for invalid switch cases

---
 libsolidity/inlineasm/AsmParser.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 847735f4..ccc735f7 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -78,6 +78,10 @@ assembly::Statement Parser::parseStatement()
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
 			_switch.cases.emplace_back(parseCase());
+		if (m_scanner->currentToken() == Token::Default)
+			fatalParserError("Only one default case allowed.");
+		else if (m_scanner->currentToken() == Token::Case)
+			fatalParserError("Case not allowed after default case.");
 		if (_switch.cases.size() == 0)
 			fatalParserError("Switch statement without any cases.");
 		_switch.location.end = _switch.cases.back().body.location.end;
-- 
cgit v1.2.3


From e410cec19ace7ae489c2c58f6d44519234a44ed7 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 09:41:53 +0100
Subject: Better error message for elementary operations

---
 libsolidity/inlineasm/AsmParser.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 530cd726..79e67af3 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -82,9 +82,6 @@ assembly::Statement Parser::parseStatement()
 		expectToken(Token::Identifier);
 		return assignment;
 	}
-	case Token::Return: // opcode
-	case Token::Byte: // opcode
-	case Token::Address: // opcode
 	default:
 		break;
 	}
@@ -247,7 +244,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		fatalParserError(
 			m_julia ?
 			"Literal or identifier expected." :
-			"Expected elementary inline assembly operation."
+			"Literal, identifier or instruction expected."
 		);
 	}
 	return ret;
@@ -259,7 +256,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	expectToken(Token::Let);
 	while (true)
 	{
-		varDecl.variables.push_back(parseTypedName());
+		varDecl.variables.emplace_back(parseTypedName());
 		if (m_scanner->currentToken() == Token::Comma)
 			expectToken(Token::Comma);
 		else
-- 
cgit v1.2.3


From 71b923cc36d33bf3e173f2210b33895df49fcbba Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 23 May 2017 19:11:14 +0200
Subject: Move EVM codegen to libjulia.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 238 -----------------------------------
 1 file changed, 238 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 5c66b125..ce2d8a1d 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -107,244 +107,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-class CodeTransform: public boost::static_visitor<>
-{
-public:
-	/// Create the code transformer which appends assembly to _state.assembly when called
-	/// with parsed assembly data.
-	/// @param _identifierAccess used to resolve identifiers external to the inline assembly
-	explicit CodeTransform(
-		GeneratorState& _state,
-		julia::AbstractAssembly& _assembly,
-		assembly::Block const& _block,
-		assembly::ExternalIdentifierAccess const& _identifierAccess = assembly::ExternalIdentifierAccess()
-	): CodeTransform(_state, _assembly, _block, _identifierAccess, _assembly.stackHeight())
-	{
-	}
-
-private:
-	CodeTransform(
-		GeneratorState& _state,
-		julia::AbstractAssembly& _assembly,
-		assembly::Block const& _block,
-		assembly::ExternalIdentifierAccess const& _identifierAccess,
-		int _initialStackHeight
-	):
-		m_state(_state),
-		m_assembly(_assembly),
-		m_scope(*m_state.info.scopes.at(&_block)),
-		m_identifierAccess(_identifierAccess),
-		m_initialStackHeight(_initialStackHeight)
-	{
-		int blockStartStackHeight = m_assembly.stackHeight();
-		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
-
-		m_assembly.setSourceLocation(_block.location);
-
-		// pop variables
-		for (auto const& identifier: m_scope.identifiers)
-			if (identifier.second.type() == typeid(Scope::Variable))
-				m_assembly.appendInstruction(solidity::Instruction::POP);
-
-		int deposit = m_assembly.stackHeight() - blockStartStackHeight;
-		solAssert(deposit == 0, "Invalid stack height at end of block.");
-	}
-
-public:
-	void operator()(assembly::Instruction const& _instruction)
-	{
-		m_assembly.setSourceLocation(_instruction.location);
-		m_assembly.appendInstruction(_instruction.instruction);
-		checkStackHeight(&_instruction);
-	}
-	void operator()(assembly::Literal const& _literal)
-	{
-		m_assembly.setSourceLocation(_literal.location);
-		if (_literal.kind == assembly::LiteralKind::Number)
-			m_assembly.appendConstant(u256(_literal.value));
-		else if (_literal.kind == assembly::LiteralKind::Boolean)
-		{
-			if (_literal.value == "true")
-				m_assembly.appendConstant(u256(1));
-			else
-				m_assembly.appendConstant(u256(0));
-		}
-		else
-		{
-			solAssert(_literal.value.size() <= 32, "");
-			m_assembly.appendConstant(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
-		}
-		checkStackHeight(&_literal);
-	}
-	void operator()(assembly::Identifier const& _identifier)
-	{
-		m_assembly.setSourceLocation(_identifier.location);
-		// First search internals, then externals.
-		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
-			[=](Scope::Variable& _var)
-			{
-				if (int heightDiff = variableHeightDiff(_var, _identifier.location, false))
-					m_assembly.appendInstruction(solidity::dupInstruction(heightDiff));
-				else
-					// Store something to balance the stack
-					m_assembly.appendConstant(u256(0));
-			},
-			[=](Scope::Label& _label)
-			{
-				assignLabelIdIfUnset(_label);
-				m_assembly.appendLabelReference(*_label.id);
-			},
-			[=](Scope::Function&)
-			{
-				solAssert(false, "Function not removed during desugaring.");
-			}
-		)))
-		{
-			return;
-		}
-		solAssert(
-			m_identifierAccess.generateCode,
-			"Identifier not found and no external access available."
-		);
-		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_assembly);
-		checkStackHeight(&_identifier);
-	}
-	void operator()(FunctionalInstruction const& _instr)
-	{
-		for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
-		{
-			int height = m_assembly.stackHeight();
-			boost::apply_visitor(*this, *it);
-			expectDeposit(1, height);
-		}
-		(*this)(_instr.instruction);
-		checkStackHeight(&_instr);
-	}
-	void operator()(assembly::FunctionCall const&)
-	{
-		solAssert(false, "Function call not removed during desugaring phase.");
-	}
-	void operator()(Label const& _label)
-	{
-		m_assembly.setSourceLocation(_label.location);
-		solAssert(m_scope.identifiers.count(_label.name), "");
-		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers.at(_label.name));
-		assignLabelIdIfUnset(label);
-		m_assembly.appendLabel(*label.id);
-		checkStackHeight(&_label);
-	}
-	void operator()(assembly::StackAssignment const& _assignment)
-	{
-		m_assembly.setSourceLocation(_assignment.location);
-		generateAssignment(_assignment.variableName, _assignment.location);
-		checkStackHeight(&_assignment);
-	}
-	void operator()(assembly::Assignment const& _assignment)
-	{
-		int height = m_assembly.stackHeight();
-		boost::apply_visitor(*this, *_assignment.value);
-		expectDeposit(1, height);
-		m_assembly.setSourceLocation(_assignment.location);
-		generateAssignment(_assignment.variableName, _assignment.location);
-		checkStackHeight(&_assignment);
-	}
-	void operator()(assembly::VariableDeclaration const& _varDecl)
-	{
-		int height = m_assembly.stackHeight();
-		int expectedItems = _varDecl.variables.size();
-		boost::apply_visitor(*this, *_varDecl.value);
-		expectDeposit(expectedItems, height);
-		for (auto const& variable: _varDecl.variables)
-		{
-			auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(variable.name));
-			var.stackHeight = height++;
-			var.active = true;
-		}
-	}
-	void operator()(assembly::Block const& _block)
-	{
-		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
-		checkStackHeight(&_block);
-	}
-	void operator()(assembly::Switch const&)
-	{
-		solAssert(false, "Switch not removed during desugaring phase.");
-	}
-	void operator()(assembly::FunctionDefinition const&)
-	{
-		solAssert(false, "Function definition not removed during desugaring phase.");
-	}
-
-private:
-	void generateAssignment(assembly::Identifier const& _variableName, SourceLocation const& _location)
-	{
-		auto var = m_scope.lookup(_variableName.name);
-		if (var)
-		{
-			Scope::Variable const& _var = boost::get<Scope::Variable>(*var);
-			if (int heightDiff = variableHeightDiff(_var, _location, true))
-				m_assembly.appendInstruction(solidity::swapInstruction(heightDiff - 1));
-			m_assembly.appendInstruction(solidity::Instruction::POP);
-		}
-		else
-		{
-			solAssert(
-				m_identifierAccess.generateCode,
-				"Identifier not found and no external access available."
-			);
-			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_assembly);
-		}
-	}
-
-	/// Determines the stack height difference to the given variables. Automatically generates
-	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
-	/// errors and the (positive) stack height difference otherwise.
-	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
-	{
-		int heightDiff = m_assembly.stackHeight() - _var.stackHeight;
-		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
-		{
-			//@TODO move this to analysis phase.
-			m_state.errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-				_location
-			));
-			return 0;
-		}
-		else
-			return heightDiff;
-	}
-
-	void expectDeposit(int _deposit, int _oldHeight)
-	{
-		solAssert(m_assembly.stackHeight() == _oldHeight + _deposit, "Invalid stack deposit.");
-	}
-
-	void checkStackHeight(void const* _astElement)
-	{
-		solAssert(m_state.info.stackHeightInfo.count(_astElement), "Stack height for AST element not found.");
-		solAssert(
-			m_state.info.stackHeightInfo.at(_astElement) == m_assembly.stackHeight() - m_initialStackHeight,
-			"Stack height mismatch between analysis and code generation phase."
-		);
-	}
-
-	/// Assigns the label's id to a value taken from eth::Assembly if it has not yet been set.
-	void assignLabelIdIfUnset(Scope::Label& _label)
-	{
-		if (!_label.id)
-			_label.id.reset(m_assembly.newLabelId());
-	}
-
-
-	GeneratorState& m_state;
-	julia::AbstractAssembly& m_assembly;
-	Scope& m_scope;
-	ExternalIdentifierAccess m_identifierAccess;
-	int const m_initialStackHeight;
-};
-
 eth::Assembly assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
-- 
cgit v1.2.3


From 261731f7eea48902983c55163d377e26bbca07da Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 23 May 2017 19:21:14 +0200
Subject: Adapt EVM codegen to new namespace.

---
 libsolidity/inlineasm/AsmAnalysis.cpp |  6 +++---
 libsolidity/inlineasm/AsmAnalysis.h   |  4 ++--
 libsolidity/inlineasm/AsmCodeGen.cpp  | 22 ++++++----------------
 libsolidity/inlineasm/AsmCodeGen.h    |  4 ++--
 libsolidity/inlineasm/AsmStack.cpp    |  4 ++--
 libsolidity/inlineasm/AsmStack.h      | 23 +++--------------------
 6 files changed, 18 insertions(+), 45 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index d022ecf6..60caaa1d 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -41,7 +41,7 @@ using namespace dev::solidity::assembly;
 AsmAnalyzer::AsmAnalyzer(
 	AsmAnalysisInfo& _analysisInfo,
 	ErrorList& _errors,
-	ExternalIdentifierAccess::Resolver const& _resolver
+	julia::ExternalIdentifierAccess::Resolver const& _resolver
 ):
 	m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors)
 {
@@ -123,7 +123,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	{
 		size_t stackSize(-1);
 		if (m_resolver)
-			stackSize = m_resolver(_identifier, IdentifierContext::RValue);
+			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue);
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
@@ -393,7 +393,7 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 		variableSize = 1;
 	}
 	else if (m_resolver)
-		variableSize = m_resolver(_variable, IdentifierContext::LValue);
+		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue);
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 9f022b12..613abf38 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -64,7 +64,7 @@ public:
 	AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
-		ExternalIdentifierAccess::Resolver const& _resolver = ExternalIdentifierAccess::Resolver()
+		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
 	);
 
 	bool analyze(assembly::Block const& _block);
@@ -94,7 +94,7 @@ private:
 	/// we enter the block.
 	int m_virtualVariablesInNextBlock = 0;
 	int m_stackHeight = 0;
-	ExternalIdentifierAccess::Resolver const& m_resolver;
+	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index ce2d8a1d..6a44faac 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -32,7 +32,8 @@
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
 
-#include <libjulia/backends/AbstractAssembly.h>
+#include <libjulia/backends/evm/AbstractAssembly.h>
+#include <libjulia/backends/evm/EVMCodeTransform.h>
 
 #include <libdevcore/CommonIO.h>
 
@@ -48,15 +49,6 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-struct GeneratorState
-{
-	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo):
-		errors(_errors), info(_analysisInfo) {}
-
-	ErrorList& errors;
-	AsmAnalysisInfo info;
-};
-
 class EthAssemblyAdapter: public julia::AbstractAssembly
 {
 public:
@@ -110,13 +102,12 @@ private:
 eth::Assembly assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
 	eth::Assembly assembly;
-	GeneratorState state(m_errors, _analysisInfo);
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
+	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 	return assembly;
 }
 
@@ -124,10 +115,9 @@ void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
 	eth::Assembly& _assembly,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
-	GeneratorState state(m_errors, _analysisInfo);
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
+	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index e830e047..1b43d2f6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -48,14 +48,14 @@ public:
 	eth::Assembly assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 	/// Performs code generation and appends generated to to _assembly.
 	void assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		eth::Assembly& _assembly,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
 private:
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index c2a7d8ea..2e63465f 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -42,7 +42,7 @@ using namespace dev::solidity::assembly;
 
 bool InlineAssemblyStack::parse(
 	shared_ptr<Scanner> const& _scanner,
-	ExternalIdentifierAccess::Resolver const& _resolver
+	julia::ExternalIdentifierAccess::Resolver const& _resolver
 )
 {
 	m_parserResult = make_shared<Block>();
@@ -73,7 +73,7 @@ eth::Assembly InlineAssemblyStack::assemble()
 bool InlineAssemblyStack::parseAndAssemble(
 	string const& _input,
 	eth::Assembly& _assembly,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
 	ErrorList errors;
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index e223ccc9..23072a88 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -24,7 +24,7 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
-#include <libjulia/backends/AbstractAssembly.h>
+#include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <string>
 #include <functional>
@@ -43,23 +43,6 @@ namespace assembly
 struct Block;
 struct Identifier;
 
-enum class IdentifierContext { LValue, RValue };
-
-/// Object that is used to resolve references and generate code for access to identifiers external
-/// to inline assembly (not used in standalone assembly mode).
-struct ExternalIdentifierAccess
-{
-	using Resolver = std::function<size_t(assembly::Identifier const&, IdentifierContext)>;
-	/// Resolve a an external reference given by the identifier in the given context.
-	/// @returns the size of the value (number of stack slots) or size_t(-1) if not found.
-	Resolver resolve;
-	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, julia::AbstractAssembly&)>;
-	/// Generate code for retrieving the value (rvalue context) or storing the value (lvalue context)
-	/// of an identifier. The code should be appended to the assembly. In rvalue context, the value is supposed
-	/// to be put onto the stack, in lvalue context, the value is assumed to be at the top of the stack.
-	CodeGenerator generateCode;
-};
-
 class InlineAssemblyStack
 {
 public:
@@ -67,7 +50,7 @@ public:
 	/// @return false or error.
 	bool parse(
 		std::shared_ptr<Scanner> const& _scanner,
-		ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = ExternalIdentifierAccess::Resolver()
+		julia::ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = julia::ExternalIdentifierAccess::Resolver()
 	);
 	/// Converts the parser result back into a string form (not necessarily the same form
 	/// as the source form, but it should parse into the same parsed form again).
@@ -79,7 +62,7 @@ public:
 	bool parseAndAssemble(
 		std::string const& _input,
 		eth::Assembly& _assembly,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
 	ErrorList const& errors() const { return m_errors; }
-- 
cgit v1.2.3


From dda497ca027f5dcd47c6e2b8d624b327c4478adc Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:19:11 +0100
Subject: Move constructor to AsmAnalyzer header

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 9 ---------
 libsolidity/inlineasm/AsmAnalysis.h   | 4 ++--
 2 files changed, 2 insertions(+), 11 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 60caaa1d..742d2c1a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -38,15 +38,6 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-AsmAnalyzer::AsmAnalyzer(
-	AsmAnalysisInfo& _analysisInfo,
-	ErrorList& _errors,
-	julia::ExternalIdentifierAccess::Resolver const& _resolver
-):
-	m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors)
-{
-}
-
 bool AsmAnalyzer::analyze(Block const& _block)
 {
 	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 613abf38..da4b7608 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -61,11 +61,11 @@ struct AsmAnalysisInfo;
 class AsmAnalyzer: public boost::static_visitor<bool>
 {
 public:
-	AsmAnalyzer(
+	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	);
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors) {}
 
 	bool analyze(assembly::Block const& _block);
 
-- 
cgit v1.2.3


From 3b75c5b45fdb1bfb49b4e157e031154c57b475f3 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:27:48 +0100
Subject: Validate that only basic types are used in Julia

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 20 ++++++++++++++++++++
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 21 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 742d2c1a..ca50fdbe 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -62,6 +62,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 
 bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 {
+	expectValidType(_literal.type, _literal.location);
 	++m_stackHeight;
 	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
@@ -186,7 +187,10 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	}
 
 	for (auto const& variable: _varDecl.variables)
+	{
+		expectValidType(variable.type, variable.location);
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
+	}
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
 }
@@ -195,7 +199,10 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	Scope& bodyScope = scope(&_funDef.body);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
+	{
+		expectValidType(var.type, var.location);
 		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
+	}
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
@@ -444,3 +451,16 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
 }
+
+void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
+{
+//	if (!m_julia)
+//		return;
+
+	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::TypeError,
+			"User defined types (\"" + type + "\") are not supported yet.",
+			_location
+		));
+}
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index da4b7608..8244df84 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -88,6 +88,7 @@ private:
 	bool checkAssignment(assembly::Identifier const& _assignment, size_t _valueSize = size_t(-1));
 	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
 	Scope& scope(assembly::Block const* _block);
+	void expectValidType(std::string const& type, SourceLocation const& _location);
 
 	/// This is used when we enter the body of a function definition. There, the parameters
 	/// and return parameters appear as variables which are already on the stack before
-- 
cgit v1.2.3


From 8fe79fe706fd64146ffbf345e0241b7c4357ce43 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 01:59:57 +0100
Subject: Introduce Julia mode in AsmAnalyzer

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 9 ++++++---
 libsolidity/inlineasm/AsmAnalysis.h   | 4 +++-
 libsolidity/inlineasm/AsmStack.cpp    | 4 ++--
 3 files changed, 11 insertions(+), 6 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ca50fdbe..eb6f8bc0 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -48,12 +48,14 @@ bool AsmAnalyzer::analyze(Block const& _block)
 
 bool AsmAnalyzer::operator()(Label const& _label)
 {
+	solAssert(!m_julia, "");
 	m_info.stackHeightInfo[&_label] = m_stackHeight;
 	return true;
 }
 
 bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 {
+	solAssert(!m_julia, "");
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
@@ -135,6 +137,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 
 bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 {
+	solAssert(!m_julia, "");
 	bool success = true;
 	for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
 	{
@@ -154,12 +157,12 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 
 bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 {
+	solAssert(!m_julia, "");
 	bool success = checkAssignment(_assignment.variableName, size_t(-1));
 	m_info.stackHeightInfo[&_assignment] = m_stackHeight;
 	return success;
 }
 
-
 bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
 {
 	int const stackHeight = m_stackHeight;
@@ -454,8 +457,8 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 
 void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
 {
-//	if (!m_julia)
-//		return;
+	if (!m_julia)
+		return;
 
 	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
 		m_errors.push_back(make_shared<Error>(
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 8244df84..87d41e11 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -64,8 +64,9 @@ public:
 	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
+		bool _julia = false,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors) {}
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors), m_julia(_julia) {}
 
 	bool analyze(assembly::Block const& _block);
 
@@ -99,6 +100,7 @@ private:
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
+	bool m_julia = false;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index 2e63465f..fe443c08 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -53,7 +53,7 @@ bool InlineAssemblyStack::parse(
 
 	*m_parserResult = std::move(*result);
 	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errors, _resolver)).analyze(*m_parserResult);
+	return (AsmAnalyzer(analysisInfo, m_errors, false, _resolver)).analyze(*m_parserResult);
 }
 
 string InlineAssemblyStack::toString()
@@ -84,7 +84,7 @@ bool InlineAssemblyStack::parseAndAssemble(
 	solAssert(parserResult, "");
 
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errors, _identifierAccess.resolve);
+	AsmAnalyzer analyzer(analysisInfo, errors, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
 	CodeGenerator(errors).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
-- 
cgit v1.2.3


From efadf7e41f73b83f3a7793562cc26f3e92b0211d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 20:42:17 +0100
Subject: Change error message for invalid type

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index eb6f8bc0..24eddf05 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -463,7 +463,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
-			"User defined types (\"" + type + "\") are not supported yet.",
+			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
 			_location
 		));
 }
-- 
cgit v1.2.3


From 2a50e869d060bd42faae9003fa563398ba8b79c1 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 20:43:28 +0100
Subject: Move builtin type list to the top

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 24eddf05..eeb7d0a6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -38,6 +38,12 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
+namespace {
+
+set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"};
+
+}
+
 bool AsmAnalyzer::analyze(Block const& _block)
 {
 	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
@@ -460,7 +466,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 	if (!m_julia)
 		return;
 
-	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
+	if (!builtinTypes.count(type))
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
 			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
-- 
cgit v1.2.3


From 9337003d5e623cd52c55001222b629543c859cd7 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:13:51 +0100
Subject: Use the new ParserBase API in AsmParser

---
 libsolidity/inlineasm/AsmParser.cpp | 66 ++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 605d27be..80409c63 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -50,16 +50,16 @@ assembly::Block Parser::parseBlock()
 {
 	assembly::Block block = createWithLocation<Block>();
 	expectToken(Token::LBrace);
-	while (m_scanner->currentToken() != Token::RBrace)
+	while (currentToken() != Token::RBrace)
 		block.statements.emplace_back(parseStatement());
 	block.location.end = endPosition();
-	m_scanner->next();
+	advance();
 	return block;
 }
 
 assembly::Statement Parser::parseStatement()
 {
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::Let:
 		return parseVariableDeclaration();
@@ -92,10 +92,10 @@ assembly::Statement Parser::parseStatement()
 		if (m_julia)
 			break;
 		assembly::StackAssignment assignment = createWithLocation<assembly::StackAssignment>();
-		m_scanner->next();
+		advance();
 		expectToken(Token::Colon);
 		assignment.variableName.location = location();
-		assignment.variableName.name = m_scanner->currentLiteral();
+		assignment.variableName.name = currentLiteral();
 		if (!m_julia && instructions().count(assignment.variableName.name))
 			fatalParserError("Identifier expected, got instruction name.");
 		assignment.location.end = endPosition();
@@ -110,7 +110,7 @@ assembly::Statement Parser::parseStatement()
 	// literal,
 	// identifier (might turn into label or functional assignment)
 	Statement statement(parseElementaryOperation(false));
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::LParen:
 		return parseCall(std::move(statement));
@@ -119,15 +119,15 @@ assembly::Statement Parser::parseStatement()
 		if (statement.type() != typeid(assembly::Identifier))
 			fatalParserError("Label name / variable name must precede \":\".");
 		assembly::Identifier const& identifier = boost::get<assembly::Identifier>(statement);
-		m_scanner->next();
+		advance();
 		// identifier:=: should be parsed as identifier: =: (i.e. a label),
 		// while identifier:= (being followed by a non-colon) as identifier := (assignment).
-		if (m_scanner->currentToken() == Token::Assign && m_scanner->peekNextToken() != Token::Colon)
+		if (currentToken() == Token::Assign && peekNextToken() != Token::Colon)
 		{
 			assembly::Assignment assignment = createWithLocation<assembly::Assignment>(identifier.location);
 			if (!m_julia && instructions().count(identifier.name))
 				fatalParserError("Cannot use instruction names for identifier names.");
-			m_scanner->next();
+			advance();
 			assignment.variableName = identifier;
 			assignment.value.reset(new Statement(parseExpression()));
 			assignment.location.end = locationOf(*assignment.value).end;
@@ -174,7 +174,7 @@ assembly::Case Parser::parseCase()
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
-	if (m_scanner->currentToken() == Token::LParen)
+	if (currentToken() == Token::LParen)
 		return parseCall(std::move(operation));
 	else
 		return operation;
@@ -207,7 +207,7 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 {
 	Statement ret;
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::Identifier:
 	case Token::Return:
@@ -215,14 +215,14 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	case Token::Address:
 	{
 		string literal;
-		if (m_scanner->currentToken() == Token::Return)
+		if (currentToken() == Token::Return)
 			literal = "return";
-		else if (m_scanner->currentToken() == Token::Byte)
+		else if (currentToken() == Token::Byte)
 			literal = "byte";
-		else if (m_scanner->currentToken() == Token::Address)
+		else if (currentToken() == Token::Address)
 			literal = "address";
 		else
-			literal = m_scanner->currentLiteral();
+			literal = currentLiteral();
 		// first search the set of instructions.
 		if (!m_julia && instructions().count(literal))
 		{
@@ -237,7 +237,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		}
 		else
 			ret = Identifier{location(), literal};
-		m_scanner->next();
+		advance();
 		break;
 	}
 	case Token::StringLiteral:
@@ -246,7 +246,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	case Token::FalseLiteral:
 	{
 		LiteralKind kind = LiteralKind::Number;
-		switch (m_scanner->currentToken())
+		switch (currentToken())
 		{
 		case Token::StringLiteral:
 			kind = LiteralKind::String;
@@ -265,10 +265,10 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		Literal literal{
 			location(),
 			kind,
-			m_scanner->currentLiteral(),
+			currentLiteral(),
 			""
 		};
-		m_scanner->next();
+		advance();
 		if (m_julia)
 		{
 			expectToken(Token::Colon);
@@ -297,7 +297,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	while (true)
 	{
 		varDecl.variables.emplace_back(parseTypedName());
-		if (m_scanner->currentToken() == Token::Comma)
+		if (currentToken() == Token::Comma)
 			expectToken(Token::Comma);
 		else
 			break;
@@ -315,22 +315,22 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	expectToken(Token::Function);
 	funDef.name = expectAsmIdentifier();
 	expectToken(Token::LParen);
-	while (m_scanner->currentToken() != Token::RParen)
+	while (currentToken() != Token::RParen)
 	{
 		funDef.arguments.emplace_back(parseTypedName());
-		if (m_scanner->currentToken() == Token::RParen)
+		if (currentToken() == Token::RParen)
 			break;
 		expectToken(Token::Comma);
 	}
 	expectToken(Token::RParen);
-	if (m_scanner->currentToken() == Token::Sub)
+	if (currentToken() == Token::Sub)
 	{
 		expectToken(Token::Sub);
 		expectToken(Token::GreaterThan);
 		while (true)
 		{
 			funDef.returns.emplace_back(parseTypedName());
-			if (m_scanner->currentToken() == Token::LBrace)
+			if (currentToken() == Token::LBrace)
 				break;
 			expectToken(Token::Comma);
 		}
@@ -359,7 +359,7 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		for (unsigned i = 0; i < args; ++i)
 		{
 			/// check for premature closing parentheses
-			if (m_scanner->currentToken() == Token::RParen)
+			if (currentToken() == Token::RParen)
 				fatalParserError(string(
 					"Expected expression (" +
 					instrInfo.name +
@@ -371,7 +371,7 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			ret.arguments.emplace_back(parseExpression());
 			if (i != args - 1)
 			{
-				if (m_scanner->currentToken() != Token::Comma)
+				if (currentToken() != Token::Comma)
 					fatalParserError(string(
 						"Expected comma (" +
 						instrInfo.name +
@@ -380,11 +380,11 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 						" arguments)"
 					));
 				else
-					m_scanner->next();
+					advance();
 			}
 		}
 		ret.location.end = endPosition();
-		if (m_scanner->currentToken() == Token::Comma)
+		if (currentToken() == Token::Comma)
 			fatalParserError(
 				string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
 			);
@@ -397,10 +397,10 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		ret.functionName = std::move(boost::get<Identifier>(_instruction));
 		ret.location = ret.functionName.location;
 		expectToken(Token::LParen);
-		while (m_scanner->currentToken() != Token::RParen)
+		while (currentToken() != Token::RParen)
 		{
 			ret.arguments.emplace_back(parseExpression());
-			if (m_scanner->currentToken() == Token::RParen)
+			if (currentToken() == Token::RParen)
 				break;
 			expectToken(Token::Comma);
 		}
@@ -433,12 +433,12 @@ TypedName Parser::parseTypedName()
 
 string Parser::expectAsmIdentifier()
 {
-	string name = m_scanner->currentLiteral();
+	string name = currentLiteral();
 	if (m_julia)
 	{
-		if (m_scanner->currentToken() == Token::Bool)
+		if (currentToken() == Token::Bool)
 		{
-			m_scanner->next();
+			advance();
 			return name;
 		}
 	}
-- 
cgit v1.2.3


From 9adff68ecc9fe725670c3752429d18d15379644b Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 24 May 2017 18:34:19 +0200
Subject: Introduce LabelID typedef.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 4 ++--
 libsolidity/inlineasm/AsmScope.h     | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 6a44faac..af3547fd 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -70,12 +70,12 @@ public:
 		m_assembly.append(_constant);
 	}
 	/// Append a label.
-	virtual void appendLabel(size_t _labelId) override
+	virtual void appendLabel(LabelID _labelId) override
 	{
 		m_assembly.append(eth::AssemblyItem(eth::Tag, _labelId));
 	}
 	/// Append a label reference.
-	virtual void appendLabelReference(size_t _labelId) override
+	virtual void appendLabelReference(LabelID _labelId) override
 	{
 		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
 	}
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 70786dce..498218b4 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -63,6 +63,7 @@ struct GenericVisitor<>: public boost::static_visitor<> {
 struct Scope
 {
 	using JuliaType = std::string;
+	using LabelID = size_t;
 
 	struct Variable
 	{
@@ -76,7 +77,7 @@ struct Scope
 
 	struct Label
 	{
-		boost::optional<size_t> id;
+		boost::optional<LabelID> id;
 	};
 
 	struct Function
-- 
cgit v1.2.3


From 4af55c78ebcacb5cfda1b573253cac6e6824d67a Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 26 May 2017 21:46:02 +0200
Subject: Introduce virtual blocks for function arguments.

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 15 ++++++++-------
 libsolidity/inlineasm/AsmAnalysis.h      |  4 ----
 libsolidity/inlineasm/AsmAnalysisInfo.h  |  3 +++
 libsolidity/inlineasm/AsmScopeFiller.cpp | 21 ++++++++++++++-------
 libsolidity/inlineasm/AsmScopeFiller.h   |  6 +++---
 5 files changed, 28 insertions(+), 21 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index eeb7d0a6..9f512f87 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -46,7 +46,7 @@ set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "
 
 bool AsmAnalyzer::analyze(Block const& _block)
 {
-	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
+	if (!(ScopeFiller(m_info, m_errors))(_block))
 		return false;
 
 	return (*this)(_block);
@@ -206,16 +206,17 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
-	Scope& bodyScope = scope(&_funDef.body);
+	Block const* virtualBlock = m_info.virtualBlocks.at(&_funDef).get();
+	solAssert(virtualBlock, "");
+	Scope& varScope = scope(virtualBlock);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
 	{
 		expectValidType(var.type, var.location);
-		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
+		boost::get<Scope::Variable>(varScope.identifiers.at(var.name)).active = true;
 	}
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
-	m_virtualVariablesInNextBlock = m_stackHeight;
 
 	bool success = (*this)(_funDef.body);
 
@@ -337,10 +338,10 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
+	auto previousScope = m_currentScope;
 	m_currentScope = &scope(&_block);
 
-	int const initialStackHeight = m_stackHeight - m_virtualVariablesInNextBlock;
-	m_virtualVariablesInNextBlock = 0;
+	int const initialStackHeight = m_stackHeight;
 
 	for (auto const& s: _block.statements)
 		if (!boost::apply_visitor(*this, s))
@@ -366,8 +367,8 @@ bool AsmAnalyzer::operator()(Block const& _block)
 		success = false;
 	}
 
-	m_currentScope = m_currentScope->superScope;
 	m_info.stackHeightInfo[&_block] = m_stackHeight;
+	m_currentScope = previousScope;
 	return success;
 }
 
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 87d41e11..14b18c4a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -91,10 +91,6 @@ private:
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
-	/// This is used when we enter the body of a function definition. There, the parameters
-	/// and return parameters appear as variables which are already on the stack before
-	/// we enter the block.
-	int m_virtualVariablesInNextBlock = 0;
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 18382db0..78c1fbe0 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -24,6 +24,7 @@
 
 #include <map>
 #include <memory>
+#include <vector>
 
 namespace dev
 {
@@ -55,6 +56,8 @@ struct AsmAnalysisInfo
 	using Scopes = std::map<assembly::Block const*, std::shared_ptr<Scope>>;
 	Scopes scopes;
 	StackHeightInfo stackHeightInfo;
+	/// Virtual blocks which will be used for scopes for function arguments and return values.
+	std::map<FunctionDefinition const*, std::shared_ptr<assembly::Block const>> virtualBlocks;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 7eb6a9ed..3fade842 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -22,6 +22,7 @@
 
 #include <libsolidity/inlineasm/AsmData.h>
 #include <libsolidity/inlineasm/AsmScope.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/interface/Utils.h>
@@ -36,8 +37,8 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-ScopeFiller::ScopeFiller(ScopeFiller::Scopes& _scopes, ErrorList& _errors):
-	m_scopes(_scopes), m_errors(_errors)
+ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors):
+	m_info(_info), m_errors(_errors)
 {
 	m_currentScope = &scope(nullptr);
 }
@@ -84,16 +85,22 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 		));
 		success = false;
 	}
-	Scope& body = scope(&_funDef.body);
-	body.superScope = m_currentScope;
-	body.functionScope = true;
+
+	auto virtualBlock = m_info.virtualBlocks[&_funDef] = make_shared<Block>();
+	Scope& varScope = scope(virtualBlock.get());
+	varScope.superScope = m_currentScope;
+	m_currentScope = &varScope;
+	varScope.functionScope = true;
 	for (auto const& var: _funDef.arguments + _funDef.returns)
-		if (!registerVariable(var, _funDef.location, body))
+		if (!registerVariable(var, _funDef.location, varScope))
 			success = false;
 
 	if (!(*this)(_funDef.body))
 		success = false;
 
+	solAssert(m_currentScope == &varScope, "");
+	m_currentScope = m_currentScope->superScope;
+
 	return success;
 }
 
@@ -137,7 +144,7 @@ bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const&
 
 Scope& ScopeFiller::scope(Block const* _block)
 {
-	auto& scope = m_scopes[_block];
+	auto& scope = m_info.scopes[_block];
 	if (!scope)
 		scope = make_shared<Scope>();
 	return *scope;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index c7179b3b..42e80141 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -49,6 +49,7 @@ struct FunctionCall;
 struct Switch;
 
 struct Scope;
+struct AsmAnalysisInfo;
 
 /**
  * Fills scopes with identifiers and checks for name clashes.
@@ -57,8 +58,7 @@ struct Scope;
 class ScopeFiller: public boost::static_visitor<bool>
 {
 public:
-	using Scopes = std::map<assembly::Block const*, std::shared_ptr<Scope>>;
-	ScopeFiller(Scopes& _scopes, ErrorList& _errors);
+	ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors);
 
 	bool operator()(assembly::Instruction const&) { return true; }
 	bool operator()(assembly::Literal const&) { return true; }
@@ -83,7 +83,7 @@ private:
 	Scope& scope(assembly::Block const* _block);
 
 	Scope* m_currentScope = nullptr;
-	Scopes& m_scopes;
+	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
 };
 
-- 
cgit v1.2.3


From 75e4a2be1b920ad88c34a261a84cef5f4635eb68 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 11 May 2017 09:58:45 +0100
Subject: Alias sha3 to keccak256 in inline assembly

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 80409c63..f891ddc9 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -200,6 +200,8 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 
 		// add alias for suicide
 		s_instructions["suicide"] = solidity::Instruction::SELFDESTRUCT;
+		// add alis for sha3
+		s_instructions["sha3"] = solidity::Instruction::KECCAK256;
 	}
 	return s_instructions;
 }
-- 
cgit v1.2.3


From 89b60ffbd4c2dde26fa5e9f1d750729b5c89373e Mon Sep 17 00:00:00 2001
From: Rhett Aultman <roadriverrail@gmail.com>
Date: Thu, 11 May 2017 06:26:35 -0700
Subject: Refactor error reporting

This commit introduces ErrorReporter, a utility class which consolidates
all of the error logging functionality into a common set of functions.
It also replaces all direct interactions with an ErrorList with calls to
an ErrorReporter.

This commit resolves issue #2209
---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 153 ++++++++++++-------------------
 libsolidity/inlineasm/AsmAnalysis.h      |   9 +-
 libsolidity/inlineasm/AsmCodeGen.cpp     |   4 +-
 libsolidity/inlineasm/AsmCodeGen.h       |   8 +-
 libsolidity/inlineasm/AsmParser.cpp      |   6 +-
 libsolidity/inlineasm/AsmParser.h        |   2 +-
 libsolidity/inlineasm/AsmScopeFiller.cpp |  33 +++----
 libsolidity/inlineasm/AsmScopeFiller.h   |   8 +-
 libsolidity/inlineasm/AsmStack.cpp       |  19 ++--
 libsolidity/inlineasm/AsmStack.h         |  10 +-
 10 files changed, 108 insertions(+), 144 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 9f512f87..22e43127 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -46,7 +46,7 @@ set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "
 
 bool AsmAnalyzer::analyze(Block const& _block)
 {
-	if (!(ScopeFiller(m_info, m_errors))(_block))
+	if (!(ScopeFiller(m_info, m_errorReporter))(_block))
 		return false;
 
 	return (*this)(_block);
@@ -74,11 +74,10 @@ bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 	++m_stackHeight;
 	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
-			"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)",
-			_literal.location
-		));
+		m_errorReporter.typeError(
+			_literal.location,
+			"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)"
+		);
 		return false;
 	}
 	m_info.stackHeightInfo[&_literal] = m_stackHeight;
@@ -87,18 +86,17 @@ bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 
 bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 {
-	size_t numErrorsBefore = m_errors.size();
+	size_t numErrorsBefore = m_errorReporter.errors().size();
 	bool success = true;
 	if (m_currentScope->lookup(_identifier.name, Scope::Visitor(
 		[&](Scope::Variable const& _var)
 		{
 			if (!_var.active)
 			{
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Variable " + _identifier.name + " used before it was declared.",
-					_identifier.location
-				));
+				m_errorReporter.declarationError(
+					_identifier.location,
+					"Variable " + _identifier.name + " used before it was declared."
+				);
 				success = false;
 			}
 			++m_stackHeight;
@@ -109,11 +107,10 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 		},
 		[&](Scope::Function const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Function " + _identifier.name + " used without being called.",
-				_identifier.location
-			));
+			m_errorReporter.typeError(
+				_identifier.location,
+				"Function " + _identifier.name + " used without being called."
+			);
 			success = false;
 		}
 	)))
@@ -127,12 +124,8 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
-			if (numErrorsBefore == m_errors.size())
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Identifier not found.",
-					_identifier.location
-				));
+			if (numErrorsBefore == m_errorReporter.errors().size())
+				m_errorReporter.declarationError(_identifier.location, "Identifier not found.");
 			success = false;
 		}
 		m_stackHeight += stackSize == size_t(-1) ? 1 : stackSize;
@@ -187,11 +180,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	if ((m_stackHeight - stackHeight) != expectedItems)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Variable count mismatch.",
-			_varDecl.location
-		));
+		m_errorReporter.declarationError(_varDecl.location, "Variable count mismatch.");
 		return false;
 	}
 
@@ -233,20 +222,18 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 	if (!m_currentScope->lookup(_funCall.functionName.name, Scope::Visitor(
 		[&](Scope::Variable const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Attempt to call variable instead of function.",
-				_funCall.functionName.location
-			));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Attempt to call variable instead of function."
+			);
 			success = false;
 		},
 		[&](Scope::Label const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Attempt to call label instead of function.",
-				_funCall.functionName.location
-				));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Attempt to call label instead of function."
+			);
 			success = false;
 		},
 		[&](Scope::Function const& _fun)
@@ -257,26 +244,18 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		}
 	)))
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Function not found.",
-			_funCall.functionName.location
-		));
+		m_errorReporter.declarationError(_funCall.functionName.location, "Function not found.");
 		success = false;
 	}
 	if (success)
 	{
 		if (_funCall.arguments.size() != arguments)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Expected " +
-				boost::lexical_cast<string>(arguments) +
-				" arguments but got " +
-				boost::lexical_cast<string>(_funCall.arguments.size()) +
-				".",
-				_funCall.functionName.location
-				));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Expected " + boost::lexical_cast<string>(arguments) + " arguments but got " +
+				boost::lexical_cast<string>(_funCall.arguments.size()) + "."
+			);
 			success = false;
 		}
 	}
@@ -317,11 +296,10 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 			auto val = make_tuple(_case.value->kind, _case.value->value);
 			if (!cases.insert(val).second)
 			{
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Duplicate case defined",
-					_case.location
-				));
+				m_errorReporter.declarationError(
+					_case.location,
+					"Duplicate case defined"
+				);
 				success = false;
 			}
 		}
@@ -354,16 +332,15 @@ bool AsmAnalyzer::operator()(Block const& _block)
 	int const stackDiff = m_stackHeight - initialStackHeight;
 	if (stackDiff != 0)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
+		m_errorReporter.declarationError(
+			_block.location,
 			"Unbalanced stack at the end of a block: " +
 			(
 				stackDiff > 0 ?
 				to_string(stackDiff) + string(" surplus item(s).") :
 				to_string(-stackDiff) + string(" missing item(s).")
-			),
-			_block.location
-		));
+			)
+		);
 		success = false;
 	}
 
@@ -375,27 +352,22 @@ bool AsmAnalyzer::operator()(Block const& _block)
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
 {
 	bool success = true;
-	size_t numErrorsBefore = m_errors.size();
+	size_t numErrorsBefore = m_errorReporter.errors().size();
 	size_t variableSize(-1);
 	if (Scope::Identifier const* var = m_currentScope->lookup(_variable.name))
 	{
 		// Check that it is a variable
 		if (var->type() != typeid(Scope::Variable))
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Assignment requires variable.",
-				_variable.location
-			));
+			m_errorReporter.typeError(_variable.location, "Assignment requires variable.");
 			success = false;
 		}
 		else if (!boost::get<Scope::Variable>(*var).active)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable " + _variable.name + " used before it was declared.",
-				_variable.location
-			));
+			m_errorReporter.declarationError(
+				_variable.location,
+				"Variable " + _variable.name + " used before it was declared."
+			);
 			success = false;
 		}
 		variableSize = 1;
@@ -405,12 +377,8 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
-		if (numErrorsBefore == m_errors.size())
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable not found or variable not lvalue.",
-				_variable.location
-			));
+		if (numErrorsBefore == m_errorReporter.errors().size())
+			m_errorReporter.declarationError(_variable.location, "Variable not found or variable not lvalue.");
 		success = false;
 	}
 	if (_valueSize == size_t(-1))
@@ -420,15 +388,14 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 
 	if (_valueSize != variableSize && variableSize != size_t(-1))
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
+		m_errorReporter.typeError(
+			_variable.location,
 			"Variable size (" +
 			to_string(variableSize) +
 			") and value size (" +
 			to_string(_valueSize) +
-			") do not match.",
-			_variable.location
-		));
+			") do not match."
+		);
 		success = false;
 	}
 	return success;
@@ -439,15 +406,14 @@ bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, Source
 	int stackDiff = m_stackHeight - _oldHeight;
 	if (stackDiff != _deposit)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
+		m_errorReporter.typeError(
+			_location,
 			"Expected instruction(s) to deposit " +
 			boost::lexical_cast<string>(_deposit) +
 			" item(s) to the stack, but did deposit " +
 			boost::lexical_cast<string>(stackDiff) +
-			" item(s).",
-			_location
-		));
+			" item(s)."
+		);
 		return false;
 	}
 	else
@@ -468,9 +434,8 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 		return;
 
 	if (!builtinTypes.count(type))
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
-			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
-			_location
-		));
+		m_errorReporter.typeError(
+			_location,
+			"\"" + type + "\" is not a valid type (user defined types are not yet supported)."
+		);
 }
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 14b18c4a..7e4d78df 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,8 +22,6 @@
 
 #include <libsolidity/inlineasm/AsmStack.h>
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -33,6 +31,7 @@ namespace dev
 {
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 
@@ -63,10 +62,10 @@ class AsmAnalyzer: public boost::static_visitor<bool>
 public:
 	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
-		ErrorList& _errors,
+		ErrorReporter& _errorReporter,
 		bool _julia = false,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors), m_julia(_julia) {}
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errorReporter(_errorReporter), m_julia(_julia) {}
 
 	bool analyze(assembly::Block const& _block);
 
@@ -95,7 +94,7 @@ private:
 	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 	bool m_julia = false;
 };
 
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index af3547fd..11494c2d 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -107,7 +107,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 	return assembly;
 }
 
@@ -119,5 +119,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index 1b43d2f6..f075fa93 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/interface/Exceptions.h>
 
 #include <functional>
 
@@ -35,6 +34,7 @@ class Assembly;
 }
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 struct Block;
@@ -42,8 +42,8 @@ struct Block;
 class CodeGenerator
 {
 public:
-	CodeGenerator(ErrorList& _errors):
-		m_errors(_errors) {}
+	CodeGenerator(ErrorReporter& _errorReporter):
+		m_errorReporter(_errorReporter) {}
 	/// Performs code generation and @returns the result.
 	eth::Assembly assemble(
 		Block const& _parsedData,
@@ -59,7 +59,7 @@ public:
 	);
 
 private:
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 80409c63..0f836406 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -21,10 +21,10 @@
  */
 
 #include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/parsing/Scanner.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <ctype.h>
 #include <algorithm>
-#include <libsolidity/parsing/Scanner.h>
-#include <libsolidity/interface/Exceptions.h>
 
 using namespace std;
 using namespace dev;
@@ -40,7 +40,7 @@ shared_ptr<assembly::Block> Parser::parse(std::shared_ptr<Scanner> const& _scann
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 	}
 	return nullptr;
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 138af337..e32b1d25 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -37,7 +37,7 @@ namespace assembly
 class Parser: public ParserBase
 {
 public:
-	explicit Parser(ErrorList& _errors, bool _julia = false): ParserBase(_errors), m_julia(_julia) {}
+	explicit Parser(ErrorReporter& _errorReporter, bool _julia = false): ParserBase(_errorReporter), m_julia(_julia) {}
 
 	/// Parses an inline assembly block starting with `{` and ending with `}`.
 	/// @returns an empty shared pointer on error.
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 3fade842..4d26dcf8 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -24,7 +24,7 @@
 #include <libsolidity/inlineasm/AsmScope.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -37,8 +37,8 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors):
-	m_info(_info), m_errors(_errors)
+ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorReporter& _errorReporter):
+	m_info(_info), m_errorReporter(_errorReporter)
 {
 	m_currentScope = &scope(nullptr);
 }
@@ -48,11 +48,10 @@ bool ScopeFiller::operator()(Label const& _item)
 	if (!m_currentScope->registerLabel(_item.name))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Label name " + _item.name + " already taken in this scope.",
-			_item.location
-		));
+		m_errorReporter.declarationError(
+			_item.location,
+			"Label name " + _item.name + " already taken in this scope."
+		);
 		return false;
 	}
 	return true;
@@ -78,11 +77,10 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 	if (!m_currentScope->registerFunction(_funDef.name, arguments, returns))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Function name " + _funDef.name + " already taken in this scope.",
-			_funDef.location
-		));
+		m_errorReporter.declarationError(
+			_funDef.location,
+			"Function name " + _funDef.name + " already taken in this scope."
+		);
 		success = false;
 	}
 
@@ -132,11 +130,10 @@ bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const&
 	if (!_scope.registerVariable(_name.name, _name.type))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Variable name " + _name.name + " already taken in this scope.",
-			_location
-		));
+		m_errorReporter.declarationError(
+			_location,
+			"Variable name " + _name.name + " already taken in this scope."
+		);
 		return false;
 	}
 	return true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 42e80141..1166d50f 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -20,8 +20,6 @@
 
 #pragma once
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -29,8 +27,10 @@
 
 namespace dev
 {
+struct SourceLocation;
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 
@@ -58,7 +58,7 @@ struct AsmAnalysisInfo;
 class ScopeFiller: public boost::static_visitor<bool>
 {
 public:
-	ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors);
+	ScopeFiller(AsmAnalysisInfo& _info, ErrorReporter& _errorReporter);
 
 	bool operator()(assembly::Instruction const&) { return true; }
 	bool operator()(assembly::Literal const&) { return true; }
@@ -84,7 +84,7 @@ private:
 
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index fe443c08..73b1604d 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -46,14 +46,14 @@ bool InlineAssemblyStack::parse(
 )
 {
 	m_parserResult = make_shared<Block>();
-	Parser parser(m_errors);
+	Parser parser(m_errorReporter);
 	auto result = parser.parse(_scanner);
 	if (!result)
 		return false;
 
 	*m_parserResult = std::move(*result);
 	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errors, false, _resolver)).analyze(*m_parserResult);
+	return (AsmAnalyzer(analysisInfo, m_errorReporter, false, _resolver)).analyze(*m_parserResult);
 }
 
 string InlineAssemblyStack::toString()
@@ -64,9 +64,9 @@ string InlineAssemblyStack::toString()
 eth::Assembly InlineAssemblyStack::assemble()
 {
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, m_errors);
+	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
 	solAssert(analyzer.analyze(*m_parserResult), "");
-	CodeGenerator codeGen(m_errors);
+	CodeGenerator codeGen(m_errorReporter);
 	return codeGen.assemble(*m_parserResult, analysisInfo);
 }
 
@@ -77,19 +77,20 @@ bool InlineAssemblyStack::parseAndAssemble(
 )
 {
 	ErrorList errors;
+	ErrorReporter errorReporter(errors);
 	auto scanner = make_shared<Scanner>(CharStream(_input), "--CODEGEN--");
-	auto parserResult = Parser(errors).parse(scanner);
-	if (!errors.empty())
+	auto parserResult = Parser(errorReporter).parse(scanner);
+	if (!errorReporter.errors().empty())
 		return false;
 	solAssert(parserResult, "");
 
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errors, false, _identifierAccess.resolve);
+	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
-	CodeGenerator(errors).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
+	CodeGenerator(errorReporter).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
 	// At this point, the assembly might be messed up, but we should throw an
 	// internal compiler error anyway.
-	return errors.empty();
+	return errorReporter.errors().empty();
 }
 
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index 23072a88..7452804d 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -22,9 +22,8 @@
 
 #pragma once
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <libjulia/backends/evm/AbstractAssembly.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 #include <string>
 #include <functional>
@@ -46,6 +45,8 @@ struct Identifier;
 class InlineAssemblyStack
 {
 public:
+	InlineAssemblyStack():
+		m_errorReporter(m_errorList) {}
 	/// Parse the given inline assembly chunk starting with `{` and ending with the corresponding `}`.
 	/// @return false or error.
 	bool parse(
@@ -65,11 +66,12 @@ public:
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
-	ErrorList const& errors() const { return m_errors; }
+	ErrorList const& errors() const { return m_errorReporter.errors(); }
 
 private:
 	std::shared_ptr<Block> m_parserResult;
-	ErrorList m_errors;
+	ErrorList m_errorList;
+	ErrorReporter m_errorReporter;
 };
 
 }
-- 
cgit v1.2.3


From 05004253ba9f7bf5a3d71d8ed590367619ebbe4f Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 14:16:01 +0200
Subject: Refactor to use expectExpression in analyzer.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 60 ++++++++++++++---------------------
 libsolidity/inlineasm/AsmAnalysis.h   |  7 +++-
 2 files changed, 29 insertions(+), 38 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 22e43127..8ed59bc9 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -139,13 +139,8 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	solAssert(!m_julia, "");
 	bool success = true;
 	for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
-	{
-		int const stackHeight = m_stackHeight;
-		if (!boost::apply_visitor(*this, arg))
-			success = false;
-		if (!expectDeposit(1, stackHeight, locationOf(arg)))
+		if (!expectExpression(arg))
 			success = false;
-	}
 	// Parser already checks that the number of arguments is correct.
 	solAssert(instructionInfo(_instr.instruction.instruction).args == int(_instr.arguments.size()), "");
 	if (!(*this)(_instr.instruction))
@@ -260,13 +255,8 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		}
 	}
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
-	{
-		int const stackHeight = m_stackHeight;
-		if (!boost::apply_visitor(*this, arg))
+		if (!expectExpression(arg))
 			success = false;
-		if (!expectDeposit(1, stackHeight, locationOf(arg)))
-			success = false;
-	}
 	m_stackHeight += int(returns) - int(arguments);
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
@@ -276,20 +266,16 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 {
 	bool success = true;
 
-	int const initialStackHeight = m_stackHeight;
-	if (!boost::apply_visitor(*this, *_switch.expression))
+	if (!expectExpression(*_switch.expression))
 		success = false;
-	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
 	set<tuple<LiteralKind, string>> cases;
 	for (auto const& _case: _switch.cases)
 	{
 		if (_case.value)
 		{
-			int const initialStackHeight = m_stackHeight;
-			if (!(*this)(*_case.value))
+			if (!expectExpression(*_case.value))
 				success = false;
-			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
 			/// Note: the parser ensures there is only one default case
@@ -349,6 +335,25 @@ bool AsmAnalyzer::operator()(Block const& _block)
 	return success;
 }
 
+bool AsmAnalyzer::expectExpression(Statement const& _statement)
+{
+	bool success = true;
+	int const initialHeight = m_stackHeight;
+	if (!boost::apply_visitor(*this, _statement))
+		success = false;
+	if (m_stackHeight - initialHeight != 1)
+	{
+		m_errorReporter.typeError(
+			locationOf(_statement),
+			"Expected instruction(s) to deposit one item to the stack but did deposit " +
+			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
+			" items."
+		);
+		success = false;
+	}
+	return success;
+}
+
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
 {
 	bool success = true;
@@ -401,25 +406,6 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 	return success;
 }
 
-bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, SourceLocation const& _location)
-{
-	int stackDiff = m_stackHeight - _oldHeight;
-	if (stackDiff != _deposit)
-	{
-		m_errorReporter.typeError(
-			_location,
-			"Expected instruction(s) to deposit " +
-			boost::lexical_cast<string>(_deposit) +
-			" item(s) to the stack, but did deposit " +
-			boost::lexical_cast<string>(stackDiff) +
-			" item(s)."
-		);
-		return false;
-	}
-	else
-		return true;
-}
-
 Scope& AsmAnalyzer::scope(Block const* _block)
 {
 	solAssert(m_info.scopes.count(_block) == 1, "Scope requested but not present.");
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 7e4d78df..e52e6302 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -47,6 +47,8 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+
 
 struct Scope;
 
@@ -83,10 +85,13 @@ public:
 	bool operator()(assembly::Block const& _block);
 
 private:
+	/// Visits the statement and expects it to deposit one item onto the stack.
+	bool expectExpression(Statement const& _statement);
+
 	/// Verifies that a variable to be assigned to exists and has the same size
 	/// as the value, @a _valueSize, unless that is equal to -1.
 	bool checkAssignment(assembly::Identifier const& _assignment, size_t _valueSize = size_t(-1));
-	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
+
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
-- 
cgit v1.2.3


From 40f3e4413b7eb36d32ab314dc1d854d8428116e6 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:31:07 +0200
Subject: Improved error message.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8ed59bc9..8fa72d7e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -345,7 +345,7 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	{
 		m_errorReporter.typeError(
 			locationOf(_statement),
-			"Expected instruction(s) to deposit one item to the stack but did deposit " +
+			"Expected expression to return one item to the stack but did return " +
 			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
 			" items."
 		);
-- 
cgit v1.2.3


From d5408f78ad2089beaabc60e7b876ad1ff0d276a1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:56:49 +0200
Subject: Add comma.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8fa72d7e..3edc01ad 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -345,7 +345,7 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	{
 		m_errorReporter.typeError(
 			locationOf(_statement),
-			"Expected expression to return one item to the stack but did return " +
+			"Expected expression to return one item to the stack, but did return " +
 			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
 			" items."
 		);
-- 
cgit v1.2.3


From 97cc968a133247e729ed1d189d35ef2b7b53b3d4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 24 May 2017 18:34:19 +0200
Subject: Initial EVM1.5 assembly implementation.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 19 ++++++++++++----
 libsolidity/inlineasm/AsmAnalysis.h   |  6 ++++-
 libsolidity/inlineasm/AsmCodeGen.cpp  | 43 +++++++++++++++++++++++++++++++----
 libsolidity/inlineasm/AsmScope.cpp    |  8 +++++++
 libsolidity/inlineasm/AsmScope.h      |  4 ++++
 5 files changed, 69 insertions(+), 11 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 3edc01ad..b59a8527 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -25,7 +25,7 @@
 #include <libsolidity/inlineasm/AsmScope.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -120,7 +120,10 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	{
 		size_t stackSize(-1);
 		if (m_resolver)
-			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue);
+		{
+			bool insideFunction = m_currentScope->insideFunction();
+			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue, insideFunction);
+		}
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
@@ -200,7 +203,8 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	}
 
 	int const stackHeight = m_stackHeight;
-	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
+	// 1 for return label, depends on VM version
+	m_stackHeight = 1 + _funDef.arguments.size() + _funDef.returns.size();
 
 	bool success = (*this)(_funDef.body);
 
@@ -254,10 +258,11 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 			success = false;
 		}
 	}
+	m_stackHeight += 1; // Return label, but depends on backend
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
 		if (!expectExpression(arg))
 			success = false;
-	m_stackHeight += int(returns) - int(arguments);
+	m_stackHeight += int(returns) - int(arguments) - 1; // Return label, but depends on backend
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
 }
@@ -295,6 +300,7 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	}
 
 	m_stackHeight--;
+	m_info.stackHeightInfo[&_switch] = m_stackHeight;
 
 	return success;
 }
@@ -378,7 +384,10 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 		variableSize = 1;
 	}
 	else if (m_resolver)
-		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue);
+	{
+		bool insideFunction = m_currentScope->insideFunction();
+		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue, insideFunction);
+	}
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e52e6302..d6f9de5b 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -20,7 +20,11 @@
 
 #pragma once
 
-#include <libsolidity/inlineasm/AsmStack.h>
+#include <libsolidity/interface/Exceptions.h>
+
+#include <libsolidity/interface/Exceptions.h>
+
+#include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
 
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 11494c2d..875d7ce4 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -87,13 +87,46 @@ public:
 	{
 		m_assembly.appendLibraryAddress(_linkerSymbol);
 	}
+	virtual void appendJump(int _stackDiffAfter) override
+	{
+		appendInstruction(solidity::Instruction::JUMP);
+		m_assembly.adjustDeposit(_stackDiffAfter);
+	}
+	virtual void appendJumpTo(LabelID _label, int _stackDiffAfter) override
+	{
+		appendLabelReference(_label);
+		appendJump(_stackDiffAfter);
+	}
+	virtual void appendJumpToIf(LabelID _label) override
+	{
+		appendLabelReference(_label);
+		appendInstruction(solidity::Instruction::JUMPI);
+	}
+	virtual void appendBeginsub(LabelID, int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "BEGINSUB not implemented for EVM 1.0");
+	}
+	/// Call a subroutine.
+	virtual void appendJumpsub(LabelID, int, int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "JUMPSUB not implemented for EVM 1.0");
+	}
+
+	/// Return from a subroutine.
+	virtual void appendReturnsub(int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
+	}
 
 private:
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
+	LabelID assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
 		u256 id = _tag.data();
-		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
-		return size_t(id);
+		solAssert(id <= std::numeric_limits<LabelID>::max(), "Tag id too large.");
+		return LabelID(id);
 	}
 
 	eth::Assembly& m_assembly;
@@ -107,7 +140,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 	return assembly;
 }
 
@@ -119,5 +152,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 }
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index e3f4615a..7a086846 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -79,3 +79,11 @@ bool Scope::exists(string const& _name)
 	else
 		return false;
 }
+
+bool Scope::insideFunction() const
+{
+	for (Scope const* s = this; s; s = s->superScope)
+		if (s->functionScope)
+			return true;
+	return false;
+}
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 498218b4..ad321f77 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -85,6 +85,7 @@ struct Scope
 		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
+		boost::optional<LabelID> id;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
@@ -123,6 +124,9 @@ struct Scope
 	/// across function and assembly boundaries).
 	bool exists(std::string const& _name);
 
+	/// @returns true if this scope is inside a function.
+	bool insideFunction() const;
+
 	Scope* superScope = nullptr;
 	/// If true, variables from the super scope are not visible here (other identifiers are),
 	/// but they are still taken into account to prevent shadowing.
-- 
cgit v1.2.3


From fefd3b866d982d95d05e5956d1af48b357162cc8 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 31 May 2017 12:15:43 +0200
Subject: Introduce machine-dependent stack adjustment.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index b59a8527..bfc6b2af 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -203,8 +203,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	}
 
 	int const stackHeight = m_stackHeight;
-	// 1 for return label, depends on VM version
-	m_stackHeight = 1 + _funDef.arguments.size() + _funDef.returns.size();
+	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
 
 	bool success = (*this)(_funDef.body);
 
@@ -258,11 +257,10 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 			success = false;
 		}
 	}
-	m_stackHeight += 1; // Return label, but depends on backend
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
 		if (!expectExpression(arg))
 			success = false;
-	m_stackHeight += int(returns) - int(arguments) - 1; // Return label, but depends on backend
+	m_stackHeight += int(returns) - int(arguments);
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
 }
-- 
cgit v1.2.3


From 0185f3cbf6aae954d8c59a556af0e150850022bc Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 31 May 2017 13:06:51 +0200
Subject: Correct stack height adjustment after returnsub.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 875d7ce4..dd91673b 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -115,7 +115,7 @@ public:
 	}
 
 	/// Return from a subroutine.
-	virtual void appendReturnsub(int) override
+	virtual void appendReturnsub(int, int) override
 	{
 		// TODO we could emulate that, though
 		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
-- 
cgit v1.2.3


From 19f707aeaa23b55a4a5940977a9d6351d1f06938 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 18:16:38 +0200
Subject: Some more comments.

---
 libsolidity/inlineasm/AsmAnalysis.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index d6f9de5b..75c0c43b 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,8 +22,6 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
-- 
cgit v1.2.3


From ef3d5874fefa6a86a30d4afdcfd269d599edda5d Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 6 Jun 2017 15:37:43 +0200
Subject: Remove error reporter from code generation phase.

---
 libsolidity/inlineasm/AsmCodeGen.cpp |  4 ++--
 libsolidity/inlineasm/AsmCodeGen.h   | 10 ++--------
 libsolidity/inlineasm/AsmStack.cpp   |  6 +++---
 3 files changed, 7 insertions(+), 13 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index dd91673b..217c6885 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -140,7 +140,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 	return assembly;
 }
 
@@ -152,5 +152,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index f075fa93..7a149d74 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -34,7 +34,6 @@ class Assembly;
 }
 namespace solidity
 {
-class ErrorReporter;
 namespace assembly
 {
 struct Block;
@@ -42,24 +41,19 @@ struct Block;
 class CodeGenerator
 {
 public:
-	CodeGenerator(ErrorReporter& _errorReporter):
-		m_errorReporter(_errorReporter) {}
 	/// Performs code generation and @returns the result.
-	eth::Assembly assemble(
+	static eth::Assembly assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 	/// Performs code generation and appends generated to to _assembly.
-	void assemble(
+	static void assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		eth::Assembly& _assembly,
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
-
-private:
-	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index 73b1604d..92eb8a7a 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -66,8 +66,7 @@ eth::Assembly InlineAssemblyStack::assemble()
 	AsmAnalysisInfo analysisInfo;
 	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
 	solAssert(analyzer.analyze(*m_parserResult), "");
-	CodeGenerator codeGen(m_errorReporter);
-	return codeGen.assemble(*m_parserResult, analysisInfo);
+	return CodeGenerator::assemble(*m_parserResult, analysisInfo);
 }
 
 bool InlineAssemblyStack::parseAndAssemble(
@@ -87,7 +86,8 @@ bool InlineAssemblyStack::parseAndAssemble(
 	AsmAnalysisInfo analysisInfo;
 	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
-	CodeGenerator(errorReporter).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
+	solAssert(errorReporter.errors().empty(), "");
+	CodeGenerator::assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
 	// At this point, the assembly might be messed up, but we should throw an
 	// internal compiler error anyway.
-- 
cgit v1.2.3


From b32d5e4cc011e91efb2e8399c692206bfeaf9ca3 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 7 Jun 2017 11:40:47 +0200
Subject: Visitor bugfix.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 23 +++++++++++++++++------
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 18 insertions(+), 6 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index bfc6b2af..13852880 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -277,8 +277,12 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	{
 		if (_case.value)
 		{
-			if (!expectExpression(*_case.value))
+			int const initialStackHeight = m_stackHeight;
+			// We cannot use "expectExpression" here because *_case.value is not a
+			// Statement and would be converted to a Statement otherwise.
+			if (!(*this)(*_case.value))
 				success = false;
+			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
 			/// Note: the parser ensures there is only one default case
@@ -345,17 +349,24 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	int const initialHeight = m_stackHeight;
 	if (!boost::apply_visitor(*this, _statement))
 		success = false;
-	if (m_stackHeight - initialHeight != 1)
+	if (!expectDeposit(1, initialHeight, locationOf(_statement)))
+		success = false;
+	return success;
+}
+
+bool AsmAnalyzer::expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location)
+{
+	if (m_stackHeight - _oldHeight != _deposit)
 	{
 		m_errorReporter.typeError(
-			locationOf(_statement),
+			_location,
 			"Expected expression to return one item to the stack, but did return " +
-			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
+			boost::lexical_cast<string>(m_stackHeight - _oldHeight) +
 			" items."
 		);
-		success = false;
+		return false;
 	}
-	return success;
+	return true;
 }
 
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 75c0c43b..dea9a972 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -89,6 +89,7 @@ public:
 private:
 	/// Visits the statement and expects it to deposit one item onto the stack.
 	bool expectExpression(Statement const& _statement);
+	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
 
 	/// Verifies that a variable to be assigned to exists and has the same size
 	/// as the value, @a _valueSize, unless that is equal to -1.
-- 
cgit v1.2.3


From 308a726ad180ae9240bca9fe673429db4a0e60e6 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 7 Jun 2017 14:15:39 +0200
Subject: Fix: Copy resolver.

---
 libsolidity/inlineasm/AsmAnalysis.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index dea9a972..e7748bcf 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -99,7 +99,7 @@ private:
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
-	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
+	julia::ExternalIdentifierAccess::Resolver m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorReporter& m_errorReporter;
-- 
cgit v1.2.3


From 6b3e7f79cf42edd031a2000978e394d818212b39 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 8 Jun 2017 15:52:15 +0200
Subject: Comments and consistent variable names.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 217c6885..0e4e744f 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -92,14 +92,14 @@ public:
 		appendInstruction(solidity::Instruction::JUMP);
 		m_assembly.adjustDeposit(_stackDiffAfter);
 	}
-	virtual void appendJumpTo(LabelID _label, int _stackDiffAfter) override
+	virtual void appendJumpTo(LabelID _labelId, int _stackDiffAfter) override
 	{
-		appendLabelReference(_label);
+		appendLabelReference(_labelId);
 		appendJump(_stackDiffAfter);
 	}
-	virtual void appendJumpToIf(LabelID _label) override
+	virtual void appendJumpToIf(LabelID _labelId) override
 	{
-		appendLabelReference(_label);
+		appendLabelReference(_labelId);
 		appendInstruction(solidity::Instruction::JUMPI);
 	}
 	virtual void appendBeginsub(LabelID, int) override
-- 
cgit v1.2.3


From 114c157b04f0ea1429b67d52c35e32f13c5ae9a4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 11:36:56 +0100
Subject: Remove obsolete AsmStack

---
 libsolidity/inlineasm/AsmStack.cpp | 96 --------------------------------------
 libsolidity/inlineasm/AsmStack.h   | 79 -------------------------------
 2 files changed, 175 deletions(-)
 delete mode 100644 libsolidity/inlineasm/AsmStack.cpp
 delete mode 100644 libsolidity/inlineasm/AsmStack.h

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
deleted file mode 100644
index 92eb8a7a..00000000
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity 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.
-
-	solidity 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 solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2016
- * Full-stack Solidity inline assember.
- */
-
-#include <libsolidity/inlineasm/AsmStack.h>
-
-#include <libsolidity/inlineasm/AsmParser.h>
-#include <libsolidity/inlineasm/AsmCodeGen.h>
-#include <libsolidity/inlineasm/AsmPrinter.h>
-#include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
-
-#include <libsolidity/parsing/Scanner.h>
-
-#include <libevmasm/Assembly.h>
-#include <libevmasm/SourceLocation.h>
-
-#include <memory>
-
-using namespace std;
-using namespace dev;
-using namespace dev::solidity;
-using namespace dev::solidity::assembly;
-
-bool InlineAssemblyStack::parse(
-	shared_ptr<Scanner> const& _scanner,
-	julia::ExternalIdentifierAccess::Resolver const& _resolver
-)
-{
-	m_parserResult = make_shared<Block>();
-	Parser parser(m_errorReporter);
-	auto result = parser.parse(_scanner);
-	if (!result)
-		return false;
-
-	*m_parserResult = std::move(*result);
-	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errorReporter, false, _resolver)).analyze(*m_parserResult);
-}
-
-string InlineAssemblyStack::toString()
-{
-	return AsmPrinter()(*m_parserResult);
-}
-
-eth::Assembly InlineAssemblyStack::assemble()
-{
-	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
-	solAssert(analyzer.analyze(*m_parserResult), "");
-	return CodeGenerator::assemble(*m_parserResult, analysisInfo);
-}
-
-bool InlineAssemblyStack::parseAndAssemble(
-	string const& _input,
-	eth::Assembly& _assembly,
-	julia::ExternalIdentifierAccess const& _identifierAccess
-)
-{
-	ErrorList errors;
-	ErrorReporter errorReporter(errors);
-	auto scanner = make_shared<Scanner>(CharStream(_input), "--CODEGEN--");
-	auto parserResult = Parser(errorReporter).parse(scanner);
-	if (!errorReporter.errors().empty())
-		return false;
-	solAssert(parserResult, "");
-
-	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
-	solAssert(analyzer.analyze(*parserResult), "");
-	solAssert(errorReporter.errors().empty(), "");
-	CodeGenerator::assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
-
-	// At this point, the assembly might be messed up, but we should throw an
-	// internal compiler error anyway.
-	return errorReporter.errors().empty();
-}
-
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
deleted file mode 100644
index 7452804d..00000000
--- a/libsolidity/inlineasm/AsmStack.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity 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.
-
-	solidity 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 solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2016
- * Full-stack Solidity inline assember.
- */
-
-#pragma once
-
-#include <libjulia/backends/evm/AbstractAssembly.h>
-#include <libsolidity/interface/ErrorReporter.h>
-
-#include <string>
-#include <functional>
-
-namespace dev
-{
-namespace eth
-{
-class Assembly;
-}
-namespace solidity
-{
-class Scanner;
-namespace assembly
-{
-struct Block;
-struct Identifier;
-
-class InlineAssemblyStack
-{
-public:
-	InlineAssemblyStack():
-		m_errorReporter(m_errorList) {}
-	/// Parse the given inline assembly chunk starting with `{` and ending with the corresponding `}`.
-	/// @return false or error.
-	bool parse(
-		std::shared_ptr<Scanner> const& _scanner,
-		julia::ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = julia::ExternalIdentifierAccess::Resolver()
-	);
-	/// Converts the parser result back into a string form (not necessarily the same form
-	/// as the source form, but it should parse into the same parsed form again).
-	std::string toString();
-
-	eth::Assembly assemble();
-
-	/// Parse and assemble a string in one run - for use in Solidity code generation itself.
-	bool parseAndAssemble(
-		std::string const& _input,
-		eth::Assembly& _assembly,
-		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
-	);
-
-	ErrorList const& errors() const { return m_errorReporter.errors(); }
-
-private:
-	std::shared_ptr<Block> m_parserResult;
-	ErrorList m_errorList;
-	ErrorReporter m_errorReporter;
-};
-
-}
-}
-}
-- 
cgit v1.2.3


From 1da3af161f94b28b816fd5522795aaae3af190f3 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 12:45:56 +0100
Subject: Simplify CodeGenerator by remove seldom used case

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 11 -----------
 libsolidity/inlineasm/AsmCodeGen.h   |  6 ------
 2 files changed, 17 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 0e4e744f..27750453 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -132,17 +132,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-eth::Assembly assembly::CodeGenerator::assemble(
-	Block const& _parsedData,
-	AsmAnalysisInfo& _analysisInfo,
-	julia::ExternalIdentifierAccess const& _identifierAccess
-)
-{
-	eth::Assembly assembly;
-	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
-	return assembly;
-}
 
 void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index 7a149d74..2a36a590 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -41,12 +41,6 @@ struct Block;
 class CodeGenerator
 {
 public:
-	/// Performs code generation and @returns the result.
-	static eth::Assembly assemble(
-		Block const& _parsedData,
-		AsmAnalysisInfo& _analysisInfo,
-		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
-	);
 	/// Performs code generation and appends generated to to _assembly.
 	static void assemble(
 		Block const& _parsedData,
-- 
cgit v1.2.3


From bf2b5c746ab92d1227c5a4d1f6c7458b2450faa1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 9 Jun 2017 14:44:38 +0200
Subject: Use lowercase when reporting instruction error.

---
 libsolidity/inlineasm/AsmParser.cpp | 38 +++++++++++++++++++++++++++----------
 libsolidity/inlineasm/AsmParser.h   |  3 ++-
 2 files changed, 30 insertions(+), 11 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 3200b360..68a9cb03 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -206,6 +206,20 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 	return s_instructions;
 }
 
+std::map<dev::solidity::Instruction, string> const& Parser::instructionNames()
+{
+	static map<dev::solidity::Instruction, string> s_instructionNames;
+	if (s_instructionNames.empty())
+	{
+		for (auto const& instr: instructions())
+			s_instructionNames[instr.second] = instr.first;
+		// set the ambiguous instructions to a clear default
+		s_instructionNames[solidity::Instruction::SELFDESTRUCT] = "selfdestruct";
+		s_instructionNames[solidity::Instruction::KECCAK256] = "keccak256";
+	}
+	return s_instructionNames;
+}
+
 assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 {
 	Statement ret;
@@ -233,7 +247,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			{
 				InstructionInfo info = dev::solidity::instructionInfo(instr);
 				if (info.ret != 1)
-					fatalParserError("Instruction " + info.name + " not allowed in this context.");
+					fatalParserError("Instruction \"" + literal + "\" not allowed in this context.");
 			}
 			ret = Instruction{location(), instr};
 		}
@@ -363,9 +377,9 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			/// check for premature closing parentheses
 			if (currentToken() == Token::RParen)
 				fatalParserError(string(
-					"Expected expression (" +
-					instrInfo.name +
-					" expects " +
+					"Expected expression (\"" +
+					instructionNames().at(instr) +
+					"\" expects " +
 					boost::lexical_cast<string>(args) +
 					" arguments)"
 				));
@@ -375,9 +389,9 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			{
 				if (currentToken() != Token::Comma)
 					fatalParserError(string(
-						"Expected comma (" +
-						instrInfo.name +
-						" expects " +
+						"Expected comma (\"" +
+						instructionNames().at(instr) +
+						"\" expects " +
 						boost::lexical_cast<string>(args) +
 						" arguments)"
 					));
@@ -387,9 +401,13 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		}
 		ret.location.end = endPosition();
 		if (currentToken() == Token::Comma)
-			fatalParserError(
-				string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
-			);
+			fatalParserError(string(
+				"Expected ')' (\"" +
+				instructionNames().at(instr) +
+				"\" expects " +
+				boost::lexical_cast<string>(args) +
+				" arguments)"
+			));
 		expectToken(Token::RParen);
 		return ret;
 	}
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index e32b1d25..5fafad23 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -65,7 +65,8 @@ protected:
 	Case parseCase();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
-	std::map<std::string, dev::solidity::Instruction> const& instructions();
+	static std::map<std::string, dev::solidity::Instruction> const& instructions();
+	static std::map<dev::solidity::Instruction, std::string> const& instructionNames();
 	Statement parseElementaryOperation(bool _onlySinglePusher = false);
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
-- 
cgit v1.2.3


From 05af6c92556acac917983b1a8e0e9e62d28de573 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 21:51:54 +0100
Subject: Warn if returndatasize/returndatacopy is used

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 20 +++++++++++++++++++-
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 20 insertions(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 13852880..36ac0e75 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -65,6 +65,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
+	warnOnFutureInstruction(_instruction.instruction, _instruction.location);
 	return true;
 }
 
@@ -149,6 +150,7 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	if (!(*this)(_instr.instruction))
 		success = false;
 	m_info.stackHeightInfo[&_instr] = m_stackHeight;
+	warnOnFutureInstruction(_instr.instruction.instruction, _instr.location);
 	return success;
 }
 
@@ -431,7 +433,6 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
 }
-
 void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
 {
 	if (!m_julia)
@@ -443,3 +444,20 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 			"\"" + type + "\" is not a valid type (user defined types are not yet supported)."
 		);
 }
+
+void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
+{
+	switch (_instr)
+	{
+	case solidity::Instruction::RETURNDATASIZE:
+	case solidity::Instruction::RETURNDATACOPY:
+		m_errorReporter.warning(
+			_location,
+			"The RETURNDATASIZE/RETURNDATACOPY instructions are only available after "
+			"the Metropolis hard fork. Before that they act as an invalid instruction."
+		);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e7748bcf..55b409ba 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -97,6 +97,7 @@ private:
 
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
+	void warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
-- 
cgit v1.2.3


From 45d96959f88e951af0e2ccf0217f19d75da66ed1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 13 Jun 2017 21:58:25 +0200
Subject: Move LabelIDs to generation phase.

---
 libsolidity/inlineasm/AsmScope.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index ad321f77..5e22c6e7 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -75,17 +75,13 @@ struct Scope
 		JuliaType type;
 	};
 
-	struct Label
-	{
-		boost::optional<LabelID> id;
-	};
+	struct Label { };
 
 	struct Function
 	{
 		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
-		boost::optional<LabelID> id;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
-- 
cgit v1.2.3


From c554145f4d7063422a5e105e2b600b640cf3d8d1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:01:06 +0200
Subject: Move stack height to generation phase.

---
 libsolidity/inlineasm/AsmScope.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 5e22c6e7..23cf61f2 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -67,8 +67,6 @@ struct Scope
 
 	struct Variable
 	{
-		/// Used during code generation to store the stack height. @todo move there.
-		int stackHeight = 0;
 		/// Used during analysis to check whether we already passed the declaration inside the block.
 		/// @todo move there.
 		bool active = false;
-- 
cgit v1.2.3


From 1bf717fd6513dda5336f95104cebfc0f041f3682 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:03:08 +0200
Subject: Remove struct constructor.

---
 libsolidity/inlineasm/AsmScope.cpp | 2 +-
 libsolidity/inlineasm/AsmScope.h   | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 7a086846..1db5ca41 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -46,7 +46,7 @@ bool Scope::registerFunction(string const& _name, std::vector<JuliaType> const&
 {
 	if (exists(_name))
 		return false;
-	identifiers[_name] = Function(_arguments, _returns);
+	identifiers[_name] = Function{_arguments, _returns};
 	return true;
 }
 
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 23cf61f2..c8e38c8a 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -77,7 +77,6 @@ struct Scope
 
 	struct Function
 	{
-		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
 	};
-- 
cgit v1.2.3


From 154002cda05a75203b625d23ce507787bd5fa5e4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:07:13 +0200
Subject: Move "active variable" to analysis phase.

---
 libsolidity/inlineasm/AsmAnalysis.cpp |  8 ++++----
 libsolidity/inlineasm/AsmAnalysis.h   |  8 +++++---
 libsolidity/inlineasm/AsmScope.h      | 10 +---------
 3 files changed, 10 insertions(+), 16 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 13852880..bb30fce1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -91,7 +91,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	if (m_currentScope->lookup(_identifier.name, Scope::Visitor(
 		[&](Scope::Variable const& _var)
 		{
-			if (!_var.active)
+			if (!m_activeVariables.count(&_var))
 			{
 				m_errorReporter.declarationError(
 					_identifier.location,
@@ -185,7 +185,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	for (auto const& variable: _varDecl.variables)
 	{
 		expectValidType(variable.type, variable.location);
-		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
+		m_activeVariables.insert(&boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)));
 	}
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
@@ -199,7 +199,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	for (auto const& var: _funDef.arguments + _funDef.returns)
 	{
 		expectValidType(var.type, var.location);
-		boost::get<Scope::Variable>(varScope.identifiers.at(var.name)).active = true;
+		m_activeVariables.insert(&boost::get<Scope::Variable>(varScope.identifiers.at(var.name)));
 	}
 
 	int const stackHeight = m_stackHeight;
@@ -382,7 +382,7 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 			m_errorReporter.typeError(_variable.location, "Assignment requires variable.");
 			success = false;
 		}
-		else if (!boost::get<Scope::Variable>(*var).active)
+		else if (!m_activeVariables.count(&boost::get<Scope::Variable>(*var)))
 		{
 			m_errorReporter.declarationError(
 				_variable.location,
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e7748bcf..cd195d97 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,6 +22,8 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
+#include <libsolidity/inlineasm/AsmScope.h>
+
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
@@ -51,9 +53,6 @@ struct FunctionCall;
 struct Switch;
 using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
-
-struct Scope;
-
 struct AsmAnalysisInfo;
 
 /**
@@ -101,6 +100,9 @@ private:
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
 	Scope* m_currentScope = nullptr;
+	/// Variables that are active at the current point in assembly (as opposed to
+	/// "part of the scope but not yet declared")
+	std::set<Scope::Variable const*> m_activeVariables;
 	AsmAnalysisInfo& m_info;
 	ErrorReporter& m_errorReporter;
 	bool m_julia = false;
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index c8e38c8a..de9119e0 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -65,16 +65,8 @@ struct Scope
 	using JuliaType = std::string;
 	using LabelID = size_t;
 
-	struct Variable
-	{
-		/// Used during analysis to check whether we already passed the declaration inside the block.
-		/// @todo move there.
-		bool active = false;
-		JuliaType type;
-	};
-
+	struct Variable { JuliaType type; };
 	struct Label { };
-
 	struct Function
 	{
 		std::vector<JuliaType> arguments;
-- 
cgit v1.2.3


From 1b1f35762e7d761a6a97f825699972472ba44888 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 13 Jun 2017 18:38:55 +0200
Subject: Enforce function arguments when parsing functional instructions.

---
 libsolidity/inlineasm/AsmParser.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 68a9cb03..f9b073ba 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -174,6 +174,19 @@ assembly::Case Parser::parseCase()
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
+	if (operation.type() == typeid(Instruction))
+	{
+		Instruction const& instr = boost::get<Instruction>(operation);
+		int args = instructionInfo(instr.instruction).args;
+		if (args > 0 && currentToken() != Token::LParen)
+			fatalParserError(string(
+				"Expected token \"(\" (\"" +
+				instructionNames().at(instr.instruction) +
+				"\" expects " +
+				boost::lexical_cast<string>(args) +
+				" arguments)"
+			));
+	}
 	if (currentToken() == Token::LParen)
 		return parseCall(std::move(operation));
 	else
-- 
cgit v1.2.3


From 494b9dbfaae2b1cf4c4d76e0be457b1e077af30c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 20:00:13 +0100
Subject: Issue warning for using CREATE2 in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 7bcbde91..a3d38cc9 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -449,12 +449,13 @@ void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLo
 {
 	switch (_instr)
 	{
+	case solidity::Instruction::CREATE2:
 	case solidity::Instruction::RETURNDATASIZE:
 	case solidity::Instruction::RETURNDATACOPY:
 		m_errorReporter.warning(
 			_location,
-			"The RETURNDATASIZE/RETURNDATACOPY instructions are only available after "
-			"the Metropolis hard fork. Before that they act as an invalid instruction."
+			"The \"" + _instr + "\" instruction is only available after " +
+			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
 		break;
 	default:
-- 
cgit v1.2.3


From a921bd0ae4afbd6eb55d65beb832546971a65dd4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 20:03:32 +0100
Subject: Display user friendly instruction name

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index a3d38cc9..630e0abf 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -447,18 +447,25 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 
 void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
 {
+	string instr;
 	switch (_instr)
 	{
 	case solidity::Instruction::CREATE2:
+		instr = "create2";
+		break;
 	case solidity::Instruction::RETURNDATASIZE:
+		instr = "returndatasize";
+		break;
 	case solidity::Instruction::RETURNDATACOPY:
-		m_errorReporter.warning(
-			_location,
-			"The \"" + _instr + "\" instruction is only available after " +
-			"the Metropolis hard fork. Before that it acts as an invalid instruction."
-		);
+		instr = "returndatacopy";
 		break;
 	default:
 		break;
 	}
+	if (!instr.empty())
+		m_errorReporter.warning(
+			_location,
+			"The \"" + instr + "\" instruction is only available after " +
+			"the Metropolis hard fork. Before that it acts as an invalid instruction."
+		);
 }
-- 
cgit v1.2.3


From c20cdd0a0574c350b5cde7b38e87321479cecab3 Mon Sep 17 00:00:00 2001
From: Dimitry <winsvega@mail.ru>
Date: Thu, 8 Jun 2017 17:44:03 +0300
Subject: add new opcode instructions to the parser

STATICCALL        0xfa  6 inputs  (gas address mem1 mem2 mem3 mem4)
---
 libsolidity/inlineasm/AsmAnalysis.cpp | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 630e0abf..1a529118 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -29,6 +29,7 @@
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/algorithm/string.hpp>
 
 #include <memory>
 #include <functional>
@@ -447,25 +448,18 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 
 void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
 {
-	string instr;
-	switch (_instr)
-	{
-	case solidity::Instruction::CREATE2:
-		instr = "create2";
-		break;
-	case solidity::Instruction::RETURNDATASIZE:
-		instr = "returndatasize";
-		break;
-	case solidity::Instruction::RETURNDATACOPY:
-		instr = "returndatacopy";
-		break;
-	default:
-		break;
-	}
-	if (!instr.empty())
+	static set<solidity::Instruction> futureInstructions{
+		solidity::Instruction::CREATE2,
+		solidity::Instruction::RETURNDATACOPY,
+		solidity::Instruction::RETURNDATASIZE,
+		solidity::Instruction::STATICCALL
+	};
+	if (futureInstructions.count(_instr))
 		m_errorReporter.warning(
 			_location,
-			"The \"" + instr + "\" instruction is only available after " +
+			"The \"" +
+			boost::to_lower_copy(instructionInfo(_instr).name)
+			+ "\" instruction is only available after " +
 			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
 }
-- 
cgit v1.2.3


From 47925bc14e80d0c33c491dabc3c3dd3ea787b63c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 28 Apr 2017 14:33:52 +0100
Subject: Parse for statement in assembly parser / printer

---
 libsolidity/inlineasm/AsmAnalysis.cpp    |  5 +++++
 libsolidity/inlineasm/AsmAnalysis.h      |  4 +++-
 libsolidity/inlineasm/AsmAnalysisInfo.h  |  3 ++-
 libsolidity/inlineasm/AsmData.h          |  4 +++-
 libsolidity/inlineasm/AsmParser.cpp      | 16 ++++++++++++++++
 libsolidity/inlineasm/AsmParser.h        |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp     | 13 +++++++++++++
 libsolidity/inlineasm/AsmPrinter.h       |  2 ++
 libsolidity/inlineasm/AsmScopeFiller.cpp |  5 +++++
 libsolidity/inlineasm/AsmScopeFiller.h   |  2 ++
 10 files changed, 52 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 1a529118..68c940e7 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -310,6 +310,11 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	return success;
 }
 
+bool AsmAnalyzer::operator()(assembly::ForLoop const&)
+{
+	solAssert(false, "For loop not supported.");
+}
+
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 2516722a..5cdf72b1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -51,7 +51,8 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+struct ForLoop;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block, ForLoop>;
 
 struct AsmAnalysisInfo;
 
@@ -83,6 +84,7 @@ public:
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
 	bool operator()(assembly::Switch const& _switch);
+	bool operator()(assembly::ForLoop const& _forLoop);
 	bool operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 78c1fbe0..a75413a2 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -45,10 +45,11 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 72afeef1..c2458bd7 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -51,9 +51,10 @@ struct FunctionalInstruction;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 struct Block;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
@@ -82,6 +83,7 @@ struct FunctionDefinition { SourceLocation location; std::string name; TypedName
 struct Case { SourceLocation location; std::shared_ptr<Literal> value; Block body; };
 /// Switch statement
 struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
+struct ForLoop { SourceLocation location; Block pre; std::shared_ptr<Statement> condition; Block post; Block body; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index f9b073ba..d282a30d 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -87,6 +87,8 @@ assembly::Statement Parser::parseStatement()
 		_switch.location.end = _switch.cases.back().body.location.end;
 		return _switch;
 	}
+	case Token::For:
+		return parseForLoop();
 	case Token::Assign:
 	{
 		if (m_julia)
@@ -171,6 +173,20 @@ assembly::Case Parser::parseCase()
 	return _case;
 }
 
+assembly::ForLoop Parser::parseForLoop()
+{
+	ForLoop forLoop = createWithLocation<ForLoop>();
+	expectToken(Token::For);
+	forLoop.pre = parseBlock();
+	forLoop.condition = make_shared<Statement>(parseExpression());
+	if (forLoop.condition->type() == typeid(assembly::Instruction))
+		fatalParserError("Instructions are not supported as conditions for the for statement.");
+	forLoop.post = parseBlock();
+	forLoop.body = parseBlock();
+	forLoop.location.end = forLoop.body.location.end;
+	return forLoop;
+}
+
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 5fafad23..45708afd 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -63,6 +63,7 @@ protected:
 	Block parseBlock();
 	Statement parseStatement();
 	Case parseCase();
+	ForLoop parseForLoop();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	static std::map<std::string, dev::solidity::Instruction> const& instructions();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index e282e5e8..0d06fedd 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -181,6 +181,19 @@ string AsmPrinter::operator()(Switch const& _switch)
 	return out;
 }
 
+string AsmPrinter::operator()(assembly::ForLoop const& _forLoop)
+{
+	string out = "for ";
+	out += (*this)(_forLoop.pre);
+	out += "\n";
+	out += boost::apply_visitor(*this, *_forLoop.condition);
+	out += "\n";
+	out += (*this)(_forLoop.post);
+	out += "\n";
+	out += (*this)(_forLoop.body);
+	return out;
+}
+
 string AsmPrinter::operator()(Block const& _block)
 {
 	if (_block.statements.empty())
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index b0d7fc09..8808b058 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -41,6 +41,7 @@ struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
@@ -59,6 +60,7 @@ public:
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
 	std::string operator()(assembly::Switch const& _switch);
+	std::string operator()(assembly::ForLoop const& _forLoop);
 	std::string operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 4d26dcf8..1aac902a 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -111,6 +111,11 @@ bool ScopeFiller::operator()(Switch const& _switch)
 	return success;
 }
 
+bool ScopeFiller::operator()(ForLoop const&)
+{
+	solAssert(false, "For loop not supported.");
+}
+
 bool ScopeFiller::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 1166d50f..f04352c9 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -47,6 +47,7 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 
 struct Scope;
 struct AsmAnalysisInfo;
@@ -71,6 +72,7 @@ public:
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
 	bool operator()(assembly::Switch const& _switch);
+	bool operator()(assembly::ForLoop const& _forLoop);
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From 49b11121179040d438dd8795a710f3d9de3de789 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 14:16:12 +0200
Subject: For loops analysis.

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 26 ++++++++++++++++++++++++--
 libsolidity/inlineasm/AsmScopeFiller.cpp | 19 +++++++++++++++++--
 2 files changed, 41 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 68c940e7..548f1a74 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -310,9 +310,31 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	return success;
 }
 
-bool AsmAnalyzer::operator()(assembly::ForLoop const&)
+bool AsmAnalyzer::operator()(assembly::ForLoop const& _for)
 {
-	solAssert(false, "For loop not supported.");
+	Scope* originalScope = m_currentScope;
+
+	bool success = true;
+	if (!(*this)(_for.pre))
+		success = false;
+	// The block was closed already, but we re-open it again and stuff the
+	// condition, the body and the post part inside.
+	m_stackHeight += scope(&_for.pre).numberOfVariables();
+	m_currentScope = &scope(&_for.pre);
+
+	if (!expectExpression(*_for.condition))
+		success = false;
+	m_stackHeight--;
+	if (!(*this)(_for.body))
+		success = false;
+	if (!(*this)(_for.post))
+		success = false;
+
+	m_stackHeight -= scope(&_for.pre).numberOfVariables();
+	m_info.stackHeightInfo[&_for] = m_stackHeight;
+	m_currentScope = originalScope;
+
+	return success;
 }
 
 bool AsmAnalyzer::operator()(Block const& _block)
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 1aac902a..3bef9cec 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -111,9 +111,24 @@ bool ScopeFiller::operator()(Switch const& _switch)
 	return success;
 }
 
-bool ScopeFiller::operator()(ForLoop const&)
+bool ScopeFiller::operator()(ForLoop const& _forLoop)
 {
-	solAssert(false, "For loop not supported.");
+	Scope* originalScope = m_currentScope;
+
+	bool success = true;
+	if (!(*this)(_forLoop.pre))
+		success = false;
+	m_currentScope = &scope(&_forLoop.pre);
+	if (!boost::apply_visitor(*this, *_forLoop.condition))
+		success = false;
+	if (!(*this)(_forLoop.body))
+		success = false;
+	if (!(*this)(_forLoop.post))
+		success = false;
+
+	m_currentScope = originalScope;
+
+	return success;
 }
 
 bool ScopeFiller::operator()(Block const& _block)
-- 
cgit v1.2.3


From 8e5c4bf21dfd9cfaa8de35aef034bb32be290a48 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:41:51 +0200
Subject: Add include file to forward-declare inline assembly structs.

---
 libsolidity/inlineasm/AsmAnalysis.h     | 17 ++---------
 libsolidity/inlineasm/AsmAnalysisInfo.h | 18 ++----------
 libsolidity/inlineasm/AsmData.h         | 23 +++------------
 libsolidity/inlineasm/AsmDataForward.h  | 52 +++++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmPrinter.h      | 15 ++--------
 libsolidity/inlineasm/AsmScopeFiller.h  | 16 ++--------
 6 files changed, 64 insertions(+), 77 deletions(-)
 create mode 100644 libsolidity/inlineasm/AsmDataForward.h

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 5cdf72b1..76d2eba1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -26,6 +26,8 @@
 
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -39,21 +41,6 @@ class ErrorReporter;
 namespace assembly
 {
 
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block, ForLoop>;
-
 struct AsmAnalysisInfo;
 
 /**
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index a75413a2..bd3b28c4 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <map>
@@ -33,24 +35,8 @@ namespace solidity
 namespace assembly
 {
 
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
-
 struct AsmAnalysisInfo
 {
 	using StackHeightInfo = std::map<void const*, int>;
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index c2458bd7..db5840bc 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -22,10 +22,13 @@
 
 #pragma once
 
-#include <boost/variant.hpp>
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <libevmasm/Instruction.h>
 #include <libevmasm/SourceLocation.h>
 
+#include <boost/variant.hpp>
+
 namespace dev
 {
 namespace solidity
@@ -38,24 +41,6 @@ using Type = std::string;
 struct TypedName { SourceLocation location; std::string name; Type type; };
 using TypedNameList = std::vector<TypedName>;
 
-/// What follows are the AST nodes for assembly.
-
-struct Instruction;
-struct Literal;
-struct Label;
-struct StackAssignment;
-struct Identifier;
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionalInstruction;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-struct Block;
-
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
-
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
diff --git a/libsolidity/inlineasm/AsmDataForward.h b/libsolidity/inlineasm/AsmDataForward.h
new file mode 100644
index 00000000..4ead7ff5
--- /dev/null
+++ b/libsolidity/inlineasm/AsmDataForward.h
@@ -0,0 +1,52 @@
+/*
+	This file is part of solidity.
+
+	solidity 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.
+
+	solidity 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 solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2016
+ * Forward declaration of classes for inline assembly / JULIA AST
+ */
+
+#pragma once
+
+#include <boost/variant.hpp>
+
+namespace dev
+{
+namespace solidity
+{
+namespace assembly
+{
+
+struct Instruction;
+struct Literal;
+struct Label;
+struct StackAssignment;
+struct Identifier;
+struct Assignment;
+struct VariableDeclaration;
+struct FunctionalInstruction;
+struct FunctionDefinition;
+struct FunctionCall;
+struct Switch;
+struct ForLoop;
+struct Block;
+
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
+
+}
+}
+}
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 8808b058..f57dddc8 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -22,6 +22,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 namespace dev
@@ -30,19 +32,6 @@ namespace solidity
 {
 namespace assembly
 {
-struct Instruction;
-struct Literal;
-struct Identifier;
-struct FunctionalInstruction;
-struct Label;
-struct StackAssignment;
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
 {
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index f04352c9..80c03d2c 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -35,20 +37,6 @@ namespace assembly
 {
 
 struct TypedName;
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-
 struct Scope;
 struct AsmAnalysisInfo;
 
-- 
cgit v1.2.3


From 78b49db779376b8ddedc0abb91a82a3384def4f1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:47:11 +0200
Subject: Helper to count the number of variables in a scope.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 4 +---
 libsolidity/inlineasm/AsmScope.cpp    | 9 +++++++++
 libsolidity/inlineasm/AsmScope.h      | 2 ++
 3 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 548f1a74..2891ec95 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -349,9 +349,7 @@ bool AsmAnalyzer::operator()(Block const& _block)
 		if (!boost::apply_visitor(*this, s))
 			success = false;
 
-	for (auto const& identifier: scope(&_block).identifiers)
-		if (identifier.second.type() == typeid(Scope::Variable))
-			--m_stackHeight;
+	m_stackHeight -= scope(&_block).numberOfVariables();
 
 	int const stackDiff = m_stackHeight - initialStackHeight;
 	if (stackDiff != 0)
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 1db5ca41..315d5953 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -80,6 +80,15 @@ bool Scope::exists(string const& _name)
 		return false;
 }
 
+size_t Scope::numberOfVariables() const
+{
+	size_t count = 0;
+	for (auto const& identifier: identifiers)
+		if (identifier.second.type() == typeid(Scope::Variable))
+			count++;
+	return count;
+}
+
 bool Scope::insideFunction() const
 {
 	for (Scope const* s = this; s; s = s->superScope)
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index de9119e0..cc240565 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -109,6 +109,8 @@ struct Scope
 	/// across function and assembly boundaries).
 	bool exists(std::string const& _name);
 
+	/// @returns the number of variables directly registered inside the scope.
+	size_t numberOfVariables() const;
 	/// @returns true if this scope is inside a function.
 	bool insideFunction() const;
 
-- 
cgit v1.2.3


From 868b5ad3aa9741609e9cd79d6033ee4b172dbe2f Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 9 Jun 2017 13:59:16 +0200
Subject: Split block code generation into main and finalize.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 27750453..3c7c62c6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -141,5 +141,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess)(_parsedData);
 }
-- 
cgit v1.2.3


From d5f8ce90c7a76870e5a9d0fe6f9fd709a7383572 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 21 Jun 2017 21:50:57 +0100
Subject: Merge interface/Exceptions and interface/Utils

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 1 -
 libsolidity/inlineasm/AsmPrinter.cpp     | 2 +-
 libsolidity/inlineasm/AsmScopeFiller.cpp | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 2891ec95..b0d044ae 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -26,7 +26,6 @@
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/ErrorReporter.h>
-#include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/algorithm/string.hpp>
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 0d06fedd..062ff453 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -22,7 +22,7 @@
 
 #include <libsolidity/inlineasm/AsmPrinter.h>
 #include <libsolidity/inlineasm/AsmData.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/replace.hpp>
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 3bef9cec..5b3174b8 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -25,7 +25,7 @@
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/ErrorReporter.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 #include <boost/range/adaptor/reversed.hpp>
 
-- 
cgit v1.2.3


From 5cf2332d6d273e6c9ac4c2b2bdb41c18b9cbf535 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 23:55:34 +0100
Subject: Support appendAssemblySize() in AbstractAssembly

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 3c7c62c6..2bbd1b70 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -121,6 +121,11 @@ public:
 		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
 	}
 
+	virtual void appendAssemblySize() override
+	{
+		m_assembly.appendProgramSize();
+	}
+
 private:
 	LabelID assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
-- 
cgit v1.2.3


From d4fecc7b11586a108578a1834b634981bc854f91 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 19:10:26 +0100
Subject: Warn on JUMP/JUMPI in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 13 ++++++++++---
 libsolidity/inlineasm/AsmAnalysis.h   |  2 +-
 2 files changed, 11 insertions(+), 4 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index b0d044ae..7e00ffae 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -65,7 +65,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
-	warnOnFutureInstruction(_instruction.instruction, _instruction.location);
+	warnOnInstructions(_instruction.instruction, _instruction.location);
 	return true;
 }
 
@@ -150,7 +150,6 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	if (!(*this)(_instr.instruction))
 		success = false;
 	m_info.stackHeightInfo[&_instr] = m_stackHeight;
-	warnOnFutureInstruction(_instr.instruction.instruction, _instr.location);
 	return success;
 }
 
@@ -470,7 +469,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 		);
 }
 
-void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
+void AsmAnalyzer::warnOnInstructions(solidity::Instruction _instr, SourceLocation const& _location)
 {
 	static set<solidity::Instruction> futureInstructions{
 		solidity::Instruction::CREATE2,
@@ -486,4 +485,12 @@ void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLo
 			+ "\" instruction is only available after " +
 			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
+
+	if (_instr == solidity::Instruction::JUMP || _instr == solidity::Instruction::JUMPI)
+		m_errorReporter.warning(
+			_location,
+			"Jump instructions are low-level EVM features that can lead to "
+			"incorrect stack access. Because of that they are discouraged. "
+			"Please consider using \"switch\" or \"for\" statements instead."
+		);
 }
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 76d2eba1..9b2a8f9c 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -85,7 +85,7 @@ private:
 
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
-	void warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location);
+	void warnOnInstructions(solidity::Instruction _instr, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
-- 
cgit v1.2.3


From 7798a2711213823de409577226f2f1c7f7f2e861 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 14:38:23 +0100
Subject: Add Julia mode as an option to EVMCodeTransform

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'libsolidity/inlineasm')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 2bbd1b70..74743737 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -137,7 +137,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-
 void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
@@ -146,5 +145,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess)(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, false, _identifierAccess)(_parsedData);
 }
-- 
cgit v1.2.3