1 files changed, 100 insertions, 38 deletions

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 46a2730d..0fc0a34f 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -62,6 +62,8 @@ assembly::Statement Parser::parseStatement()
 	{
 	case Token::Let:
 		return parseVariableDeclaration();
+	case Token::Function:
+		return parseFunctionDefinition();
 	case Token::LBrace:
 		return parseBlock();
 	case Token::Assign:
@@ -214,10 +216,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 {
 	VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
 	expectToken(Token::Let);
-	varDecl.name = m_scanner->currentLiteral();
-	if (instructions().count(varDecl.name))
-		fatalParserError("Cannot use instruction names for identifier names.");
-	expectToken(Token::Identifier);
+	varDecl.name = expectAsmIdentifier();
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
 	varDecl.value.reset(new Statement(parseExpression()));
@@ -225,44 +224,107 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	return varDecl;
 }
 
-FunctionalInstruction Parser::parseFunctionalInstruction(assembly::Statement&& _instruction)
+assembly::FunctionDefinition Parser::parseFunctionDefinition()
 {
-	if (_instruction.type() != typeid(Instruction))
-		fatalParserError("Assembly instruction required in front of \"(\")");
-	FunctionalInstruction ret;
-	ret.instruction = std::move(boost::get<Instruction>(_instruction));
-	ret.location = ret.instruction.location;
-	solidity::Instruction instr = ret.instruction.instruction;
-	InstructionInfo instrInfo = instructionInfo(instr);
-	if (solidity::Instruction::DUP1 <= instr && instr <= solidity::Instruction::DUP16)
-		fatalParserError("DUPi instructions not allowed for functional notation");
-	if (solidity::Instruction::SWAP1 <= instr && instr <= solidity::Instruction::SWAP16)
-		fatalParserError("SWAPi instructions not allowed for functional notation");
-
+	FunctionDefinition funDef = createWithLocation<FunctionDefinition>();
+	expectToken(Token::Function);
+	funDef.name = expectAsmIdentifier();
 	expectToken(Token::LParen);
-	unsigned args = unsigned(instrInfo.args);
-	for (unsigned i = 0; i < args; ++i)
+	while (m_scanner->currentToken() != Token::RParen)
 	{
-		ret.arguments.emplace_back(parseExpression());
-		if (i != args - 1)
+		funDef.arguments.push_back(expectAsmIdentifier());
+		if (m_scanner->currentToken() == Token::RParen)
+			break;
+		expectToken(Token::Comma);
+	}
+	expectToken(Token::RParen);
+	if (m_scanner->currentToken() == Token::Sub)
+	{
+		expectToken(Token::Sub);
+		expectToken(Token::GreaterThan);
+		expectToken(Token::LParen);
+		while (true)
 		{
-			if (m_scanner->currentToken() != Token::Comma)
-				fatalParserError(string(
-					"Expected comma (" +
-					instrInfo.name +
-					" expects " +
-					boost::lexical_cast<string>(args) +
-					" arguments)"
-				));
-			else
-				m_scanner->next();
+			funDef.returns.push_back(expectAsmIdentifier());
+			if (m_scanner->currentToken() == Token::RParen)
+				break;
+			expectToken(Token::Comma);
 		}
+		expectToken(Token::RParen);
 	}
-	ret.location.end = endPosition();
-	if (m_scanner->currentToken() == Token::Comma)
-		fatalParserError(
-			string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
-		);
-	expectToken(Token::RParen);
-	return ret;
+	funDef.body = parseBlock();
+	funDef.location.end = funDef.body.location.end;
+	return funDef;
+}
+
+assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _instruction)
+{
+	if (_instruction.type() == typeid(Instruction))
+	{
+		FunctionalInstruction ret;
+		ret.instruction = std::move(boost::get<Instruction>(_instruction));
+		ret.location = ret.instruction.location;
+		solidity::Instruction instr = ret.instruction.instruction;
+		InstructionInfo instrInfo = instructionInfo(instr);
+		if (solidity::Instruction::DUP1 <= instr && instr <= solidity::Instruction::DUP16)
+			fatalParserError("DUPi instructions not allowed for functional notation");
+		if (solidity::Instruction::SWAP1 <= instr && instr <= solidity::Instruction::SWAP16)
+			fatalParserError("SWAPi instructions not allowed for functional notation");
+		expectToken(Token::LParen);
+		unsigned args = unsigned(instrInfo.args);
+		for (unsigned i = 0; i < args; ++i)
+		{
+			ret.arguments.emplace_back(parseExpression());
+			if (i != args - 1)
+			{
+				if (m_scanner->currentToken() != Token::Comma)
+					fatalParserError(string(
+						"Expected comma (" +
+						instrInfo.name +
+						" expects " +
+						boost::lexical_cast<string>(args) +
+						" arguments)"
+					));
+				else
+					m_scanner->next();
+			}
+		}
+		ret.location.end = endPosition();
+		if (m_scanner->currentToken() == Token::Comma)
+			fatalParserError(
+				string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
+			);
+		expectToken(Token::RParen);
+		return ret;
+	}
+	else if (_instruction.type() == typeid(Identifier))
+	{
+		FunctionCall ret;
+		ret.functionName = std::move(boost::get<Identifier>(_instruction));
+		ret.location = ret.functionName.location;
+		expectToken(Token::LParen);
+		while (m_scanner->currentToken() != Token::RParen)
+		{
+			ret.arguments.emplace_back(parseExpression());
+			if (m_scanner->currentToken() == Token::RParen)
+				break;
+			expectToken(Token::Comma);
+		}
+		ret.location.end = endPosition();
+		expectToken(Token::RParen);
+		return ret;
+	}
+	else
+		fatalParserError("Assembly instruction or function name required in front of \"(\")");
+
+	return {};
+}
+
+string Parser::expectAsmIdentifier()
+{
+	string name = m_scanner->currentLiteral();
+	if (instructions().count(name))
+		fatalParserError("Cannot use instruction names for identifier names.");
+	expectToken(Token::Identifier);
+	return name;
 }