Compiler for assignments.

1 files changed, 90 insertions, 23 deletions

diff --git a/Compiler.cpp b/Compiler.cpp
index 4244a3e0..dbb38324 100644
--- a/Compiler.cpp
+++ b/Compiler.cpp
@@ -81,22 +81,29 @@ AssemblyItems ExpressionCompiler::compileExpression(CompilerContext& _context,
 	return compiler.getAssemblyItems();
 }
 
-void ExpressionCompiler::endVisit(Assignment& _assignment)
+bool ExpressionCompiler::visit(Assignment& _assignment)
 {
+	m_currentLValue = nullptr;
+	_assignment.getLeftHandSide().accept(*this);
+
 	Expression& rightHandSide = _assignment.getRightHandSide();
 	Token::Value op = _assignment.getAssignmentOperator();
 	if (op != Token::ASSIGN)
 	{
 		// compound assignment
-		// @todo retrieve lvalue value
 		rightHandSide.accept(*this);
 		Type const& resultType = *_assignment.getType();
 		cleanHigherOrderBitsIfNeeded(*rightHandSide.getType(), resultType);
 		appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), resultType);
 	}
 	else
+	{
+		append(eth::Instruction::POP); //@todo do not retrieve the value in the first place
 		rightHandSide.accept(*this);
-	// @todo store value
+	}
+
+	storeInLValue(_assignment);
+	return false;
 }
 
 void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation)
@@ -114,30 +121,31 @@ void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation)
 		append(eth::Instruction::BNOT);
 		break;
 	case Token::DELETE: // delete
+	{
 		// a -> a xor a (= 0).
-		// @todo this should also be an assignment
 		// @todo semantics change for complex types
 		append(eth::Instruction::DUP1);
 		append(eth::Instruction::XOR);
+		storeInLValue(_unaryOperation);
 		break;
+	}
 	case Token::INC: // ++ (pre- or postfix)
-		// @todo this should also be an assignment
-		if (_unaryOperation.isPrefixOperation())
-		{
-			append(eth::Instruction::PUSH1);
-			append(1);
-			append(eth::Instruction::ADD);
-		}
-		break;
 	case Token::DEC: // -- (pre- or postfix)
-		// @todo this should also be an assignment
-		if (_unaryOperation.isPrefixOperation())
+		if (!_unaryOperation.isPrefixOperation())
+			append(eth::Instruction::DUP1);
+		append(eth::Instruction::PUSH1);
+		append(1);
+		if (_unaryOperation.getOperator() == Token::INC)
+			append(eth::Instruction::ADD);
+		else
 		{
-			append(eth::Instruction::PUSH1);
-			append(1);
 			append(eth::Instruction::SWAP1); //@todo avoid this
 			append(eth::Instruction::SUB);
 		}
+		if (_unaryOperation.isPrefixOperation())
+			storeInLValue(_unaryOperation);
+		else
+			moveToLValue(_unaryOperation);
 		break;
 	case Token::ADD: // +
 		// unary add, so basically no-op
@@ -190,28 +198,38 @@ void ExpressionCompiler::endVisit(FunctionCall& _functionCall)
 {
 	if (_functionCall.isTypeConversion())
 	{
-		//@todo binary representation for all supported types (bool and int) is the same, so no-op
-		// here for now.
+		//@todo we only have integers and bools for now which cannot be explicitly converted
+		assert(_functionCall.getArguments().size() == 1);
+		cleanHigherOrderBitsIfNeeded(*_functionCall.getArguments().front()->getType(),
+									 *_functionCall.getType());
 	}
 	else
 	{
-		//@todo
+		//@todo: arguments are already on the stack
+		// push return label (below arguments?)
+		// jump to function label
+		// discard all but the first function return argument
 	}
 }
 
-void ExpressionCompiler::endVisit(MemberAccess& _memberAccess)
+void ExpressionCompiler::endVisit(MemberAccess&)
 {
 
 }
 
-void ExpressionCompiler::endVisit(IndexAccess& _indexAccess)
+void ExpressionCompiler::endVisit(IndexAccess&)
 {
 
 }
 
 void ExpressionCompiler::endVisit(Identifier& _identifier)
 {
-
+	m_currentLValue = _identifier.getReferencedDeclaration();
+	unsigned stackPos = stackPositionOfLValue();
+	if (stackPos >= 15) //@todo correct this by fetching earlier or moving to memory
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_identifier.getLocation())
+											  << errinfo_comment("Stack too deep."));
+	appendDup(stackPos + 1);
 }
 
 void ExpressionCompiler::endVisit(Literal& _literal)
@@ -224,7 +242,7 @@ void ExpressionCompiler::endVisit(Literal& _literal)
 		bytes value = _literal.getType()->literalToBigEndian(_literal);
 		assert(value.size() <= 32);
 		assert(!value.empty());
-		append(static_cast<byte>(eth::Instruction::PUSH1) + static_cast<byte>(value.size() - 1));
+		appendPush(value.size());
 		append(value);
 		break;
 	}
@@ -391,6 +409,24 @@ uint32_t ExpressionCompiler::appendConditionalJump()
 	return label;
 }
 
+void ExpressionCompiler::appendPush(unsigned _number)
+{
+	assert(1 <= _number && _number <= 32);
+	append(eth::Instruction(unsigned(eth::Instruction::PUSH1) + _number - 1));
+}
+
+void ExpressionCompiler::appendDup(unsigned _number)
+{
+	assert(1 <= _number && _number <= 16);
+	append(eth::Instruction(unsigned(eth::Instruction::DUP1) + _number - 1));
+}
+
+void ExpressionCompiler::appendSwap(unsigned _number)
+{
+	assert(1 <= _number && _number <= 16);
+	append(eth::Instruction(unsigned(eth::Instruction::SWAP1) + _number - 1));
+}
+
 void ExpressionCompiler::append(bytes const& _data)
 {
 	m_assemblyItems.reserve(m_assemblyItems.size() + _data.size());
@@ -398,6 +434,37 @@ void ExpressionCompiler::append(bytes const& _data)
 		append(b);
 }
 
+void ExpressionCompiler::storeInLValue(Expression const& _expression)
+{
+	assert(m_currentLValue);
+	moveToLValue(_expression);
+	unsigned stackPos = stackPositionOfLValue();
+	if (stackPos > 16)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation())
+											  << errinfo_comment("Stack too deep."));
+	if (stackPos >= 1)
+		appendDup(stackPos);
+}
+
+void ExpressionCompiler::moveToLValue(Expression const& _expression)
+{
+	assert(m_currentLValue);
+	unsigned stackPos = stackPositionOfLValue();
+	if (stackPos > 16)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation())
+											  << errinfo_comment("Stack too deep."));
+	else if (stackPos > 0)
+	{
+		appendSwap(stackPos);
+		append(eth::Instruction::POP);
+	}
+}
+
+unsigned ExpressionCompiler::stackPositionOfLValue() const
+{
+	return 8; // @todo ask the context and track stack changes due to m_assemblyItems
+}
+
 
 
 }