Merge remote-tracking branch 'ethereum/develop' into sol_overloadingFunctions

1 files changed, 25 insertions, 21 deletions

diff --git a/Compiler.cpp b/Compiler.cpp
index 5eeb0c3e..8e263449 100644
--- a/Compiler.cpp
+++ b/Compiler.cpp
@@ -20,12 +20,12 @@
  * Solidity compiler.
  */
 
+#include <libsolidity/Compiler.h>
 #include <algorithm>
 #include <boost/range/adaptor/reversed.hpp>
 #include <libevmcore/Instruction.h>
 #include <libevmcore/Assembly.h>
 #include <libsolidity/AST.h>
-#include <libsolidity/Compiler.h>
 #include <libsolidity/ExpressionCompiler.h>
 #include <libsolidity/CompilerUtils.h>
 
@@ -132,7 +132,7 @@ void Compiler::packIntoContractCreator(ContractDefinition const& _contract, Comp
 
 void Compiler::appendBaseConstructor(FunctionDefinition const& _constructor)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_constructor);
+	CompilerContext::LocationSetter locationSetter(m_context, _constructor);
 	FunctionType constructorType(_constructor);
 	if (!constructorType.getParameterTypes().empty())
 	{
@@ -146,7 +146,7 @@ void Compiler::appendBaseConstructor(FunctionDefinition const& _constructor)
 
 void Compiler::appendConstructor(FunctionDefinition const& _constructor)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_constructor);
+	CompilerContext::LocationSetter locationSetter(m_context, _constructor);
 	// copy constructor arguments from code to memory and then to stack, they are supplied after the actual program
 	unsigned argumentSize = 0;
 	for (ASTPointer<VariableDeclaration> const& var: _constructor.getParameters())
@@ -192,10 +192,12 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract)
 	for (auto const& it: interfaceFunctions)
 	{
 		FunctionTypePointer const& functionType = it.second;
+		solAssert(functionType->hasDeclaration(), "");
+		CompilerContext::LocationSetter locationSetter(m_context, functionType->getDeclaration());
 		m_context << callDataUnpackerEntryPoints.at(it.first);
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
 		appendCalldataUnpacker(functionType->getParameterTypes());
-		m_context.appendJumpTo(m_context.getFunctionEntryLabel(it.second->getDeclaration()));
+		m_context.appendJumpTo(m_context.getFunctionEntryLabel(functionType->getDeclaration()));
 		m_context << returnTag;
 		appendReturnValuePacker(functionType->getReturnParameterTypes());
 	}
@@ -226,6 +228,7 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool
 				{
 					// Retrieve data start offset by adding length to start offset of previous dynamic type
 					unsigned stackDepth = m_context.getStackHeight() - stackHeightOfPreviousDynamicArgument;
+					solAssert(stackDepth <= 16, "Stack too deep.");
 					m_context << eth::dupInstruction(stackDepth) << eth::dupInstruction(stackDepth);
 					ArrayUtils(m_context).convertLengthToSize(*previousDynamicType, true);
 					m_context << eth::Instruction::ADD;
@@ -271,22 +274,21 @@ void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters)
 
 void Compiler::registerStateVariables(ContractDefinition const& _contract)
 {
-	for (ContractDefinition const* contract: boost::adaptors::reverse(_contract.getLinearizedBaseContracts()))
-		for (ASTPointer<VariableDeclaration> const& variable: contract->getStateVariables())
-			m_context.addStateVariable(*variable);
+	for (auto const& var: ContractType(_contract).getStateVariables())
+		m_context.addStateVariable(*get<0>(var), get<1>(var), get<2>(var));
 }
 
 void Compiler::initializeStateVariables(ContractDefinition const& _contract)
 {
 	for (ASTPointer<VariableDeclaration> const& variable: _contract.getStateVariables())
-		if (variable->getValue())
+		if (variable->getValue() && !variable->isConstant())
 			ExpressionCompiler(m_context, m_optimize).appendStateVariableInitialization(*variable);
 }
 
 bool Compiler::visit(VariableDeclaration const& _variableDeclaration)
 {
 	solAssert(_variableDeclaration.isStateVariable(), "Compiler visit to non-state variable declaration.");
-	CompilerContext::LocationSetter locationSetter(m_context, &_variableDeclaration);
+	CompilerContext::LocationSetter locationSetter(m_context, _variableDeclaration);
 
 	m_context.startFunction(_variableDeclaration);
 	m_breakTags.clear();
@@ -300,7 +302,7 @@ bool Compiler::visit(VariableDeclaration const& _variableDeclaration)
 
 bool Compiler::visit(FunctionDefinition const& _function)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_function);
+	CompilerContext::LocationSetter locationSetter(m_context, _function);
 	//@todo to simplify this, the calling convention could by changed such that
 	// caller puts: [retarg0] ... [retargm] [return address] [arg0] ... [argn]
 	// although note that this reduces the size of the visible stack
@@ -357,6 +359,7 @@ bool Compiler::visit(FunctionDefinition const& _function)
 		stackLayout.push_back(i);
 	stackLayout += vector<int>(c_localVariablesSize, -1);
 
+	solAssert(stackLayout.size() <= 17, "Stack too deep.");
 	while (stackLayout.back() != int(stackLayout.size() - 1))
 		if (stackLayout.back() < 0)
 		{
@@ -376,15 +379,16 @@ bool Compiler::visit(FunctionDefinition const& _function)
 		m_context.removeVariable(*localVariable);
 
 	m_context.adjustStackOffset(-(int)c_returnValuesSize);
+
 	if (!_function.isConstructor())
-		m_context << eth::Instruction::JUMP;
+		m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction);
 	return false;
 }
 
 bool Compiler::visit(IfStatement const& _ifStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_ifStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _ifStatement);
 	compileExpression(_ifStatement.getCondition());
 	eth::AssemblyItem trueTag = m_context.appendConditionalJump();
 	if (_ifStatement.getFalseStatement())
@@ -401,7 +405,7 @@ bool Compiler::visit(IfStatement const& _ifStatement)
 bool Compiler::visit(WhileStatement const& _whileStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_whileStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _whileStatement);
 	eth::AssemblyItem loopStart = m_context.newTag();
 	eth::AssemblyItem loopEnd = m_context.newTag();
 	m_continueTags.push_back(loopStart);
@@ -427,7 +431,7 @@ bool Compiler::visit(WhileStatement const& _whileStatement)
 bool Compiler::visit(ForStatement const& _forStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_forStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _forStatement);
 	eth::AssemblyItem loopStart = m_context.newTag();
 	eth::AssemblyItem loopEnd = m_context.newTag();
 	m_continueTags.push_back(loopStart);
@@ -464,7 +468,7 @@ bool Compiler::visit(ForStatement const& _forStatement)
 
 bool Compiler::visit(Continue const& _continueStatement)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_continueStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _continueStatement);
 	if (!m_continueTags.empty())
 		m_context.appendJumpTo(m_continueTags.back());
 	return false;
@@ -472,7 +476,7 @@ bool Compiler::visit(Continue const& _continueStatement)
 
 bool Compiler::visit(Break const& _breakStatement)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_breakStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _breakStatement);
 	if (!m_breakTags.empty())
 		m_context.appendJumpTo(m_breakTags.back());
 	return false;
@@ -480,7 +484,7 @@ bool Compiler::visit(Break const& _breakStatement)
 
 bool Compiler::visit(Return const& _return)
 {
-	CompilerContext::LocationSetter locationSetter(m_context, &_return);
+	CompilerContext::LocationSetter locationSetter(m_context, _return);
 	//@todo modifications are needed to make this work with functions returning multiple values
 	if (Expression const* expression = _return.getExpression())
 	{
@@ -499,7 +503,7 @@ bool Compiler::visit(Return const& _return)
 bool Compiler::visit(VariableDeclarationStatement const& _variableDeclarationStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_variableDeclarationStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _variableDeclarationStatement);
 	if (Expression const* expression = _variableDeclarationStatement.getExpression())
 	{
 		compileExpression(*expression, _variableDeclarationStatement.getDeclaration().getType());
@@ -512,7 +516,7 @@ bool Compiler::visit(VariableDeclarationStatement const& _variableDeclarationSta
 bool Compiler::visit(ExpressionStatement const& _expressionStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_expressionStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _expressionStatement);
 	Expression const& expression = _expressionStatement.getExpression();
 	compileExpression(expression);
 	CompilerUtils(m_context).popStackElement(*expression.getType());
@@ -523,7 +527,7 @@ bool Compiler::visit(ExpressionStatement const& _expressionStatement)
 bool Compiler::visit(PlaceholderStatement const& _placeholderStatement)
 {
 	StackHeightChecker checker(m_context);
-	CompilerContext::LocationSetter locationSetter(m_context, &_placeholderStatement);
+	CompilerContext::LocationSetter locationSetter(m_context, _placeholderStatement);
 	++m_modifierDepth;
 	appendModifierOrFunctionCode();
 	--m_modifierDepth;
@@ -550,7 +554,7 @@ void Compiler::appendModifierOrFunctionCode()
 		}
 
 		ModifierDefinition const& modifier = m_context.getFunctionModifier(modifierInvocation->getName()->getName());
-		CompilerContext::LocationSetter locationSetter(m_context, &modifier);
+		CompilerContext::LocationSetter locationSetter(m_context, modifier);
 		solAssert(modifier.getParameters().size() == modifierInvocation->getArguments().size(), "");
 		for (unsigned i = 0; i < modifier.getParameters().size(); ++i)
 		{