Corrected coding style.

1 files changed, 164 insertions, 124 deletions

diff --git a/Parser.cpp b/Parser.cpp
index b2815411..5a329ae7 100644
--- a/Parser.cpp
+++ b/Parser.cpp
@@ -1,18 +1,18 @@
 /*
-	This file is part of cpp-ethereum.
+    This file is part of cpp-ethereum.
 
-	cpp-ethereum 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.
+    cpp-ethereum 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.
 
-	cpp-ethereum 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.
+    cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+    You should have received a copy of the GNU General Public License
+    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
 /**
  * @author Christian <c@ethdev.com>
@@ -26,13 +26,14 @@
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Exceptions.h>
 
-namespace dev {
-namespace solidity {
+namespace dev
+{
+namespace solidity
+{
 
 ptr<ContractDefinition> Parser::parse(std::shared_ptr<Scanner> const& _scanner)
 {
 	m_scanner = _scanner;
-
 	return parseContractDefinition();
 }
 
@@ -46,9 +47,15 @@ public:
 		: m_parser(_parser), m_location(_parser.getPosition(), -1)
 	{}
 
-	void markEndPosition() { m_location.end = m_parser.getEndPosition(); }
+	void markEndPosition()
+	{
+		m_location.end = m_parser.getEndPosition();
+	}
 
-	void setLocationEmpty() { m_location.end = m_location.start; }
+	void setLocationEmpty()
+	{
+		m_location.end = m_location.start;
+	}
 
 	/// Set the end position to the one of the given node.
 	void setEndPositionFromNode(const ptr<ASTNode>& _node)
@@ -58,7 +65,7 @@ public:
 
 	/// @todo: check that this actually uses perfect forwarding
 	template <class NodeType, typename... Args>
-	ptr<NodeType> createNode(Args&&... _args)
+	ptr<NodeType> createNode(Args&& ... _args)
 	{
 		if (m_location.end < 0)
 			markEndPosition();
@@ -84,62 +91,73 @@ int Parser::getEndPosition() const
 ptr<ContractDefinition> Parser::parseContractDefinition()
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	expectToken(Token::CONTRACT);
 	ptr<ASTString> name = expectIdentifierToken();
 	expectToken(Token::LBRACE);
-
 	vecptr<StructDefinition> structs;
 	vecptr<VariableDeclaration> stateVariables;
 	vecptr<FunctionDefinition> functions;
 	bool visibilityIsPublic = true;
-	while (true) {
+	while (true)
+	{
 		Token::Value currentToken = m_scanner->getCurrentToken();
-		if (currentToken == Token::RBRACE) {
+		if (currentToken == Token::RBRACE)
+		{
 			break;
-		} else if (currentToken == Token::PUBLIC || currentToken == Token::PRIVATE) {
+		}
+		else if (currentToken == Token::PUBLIC || currentToken == Token::PRIVATE)
+		{
 			visibilityIsPublic = (m_scanner->getCurrentToken() == Token::PUBLIC);
 			m_scanner->next();
 			expectToken(Token::COLON);
-		} else if (currentToken == Token::FUNCTION) {
+		}
+		else if (currentToken == Token::FUNCTION)
+		{
 			functions.push_back(parseFunctionDefinition(visibilityIsPublic));
-		} else if (currentToken == Token::STRUCT) {
+		}
+		else if (currentToken == Token::STRUCT)
+		{
 			structs.push_back(parseStructDefinition());
-		} else if (currentToken == Token::IDENTIFIER || currentToken == Token::MAPPING ||
-				   Token::IsElementaryTypeName(currentToken)) {
+		}
+		else if (currentToken == Token::IDENTIFIER || currentToken == Token::MAPPING ||
+				 Token::isElementaryTypeName(currentToken))
+		{
 			bool const allowVar = false;
 			stateVariables.push_back(parseVariableDeclaration(allowVar));
 			expectToken(Token::SEMICOLON);
-		} else {
+		}
+		else
+		{
 			throwExpectationError("Function, variable or struct declaration expected.");
 		}
 	}
 	nodeFactory.markEndPosition();
-
 	expectToken(Token::RBRACE);
 	expectToken(Token::EOS);
-
 	return nodeFactory.createNode<ContractDefinition>(name, structs, stateVariables, functions);
 }
 
 ptr<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic)
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	expectToken(Token::FUNCTION);
 	ptr<ASTString> name(expectIdentifierToken());
 	ptr<ParameterList> parameters(parseParameterList());
 	bool isDeclaredConst = false;
-	if (m_scanner->getCurrentToken() == Token::CONST) {
+	if (m_scanner->getCurrentToken() == Token::CONST)
+	{
 		isDeclaredConst = true;
 		m_scanner->next();
 	}
 	ptr<ParameterList> returnParameters;
-	if (m_scanner->getCurrentToken() == Token::RETURNS) {
+	if (m_scanner->getCurrentToken() == Token::RETURNS)
+	{
 		const bool permitEmptyParameterList = false;
 		m_scanner->next();
 		returnParameters = parseParameterList(permitEmptyParameterList);
-	} else {
+	}
+	else
+	{
 		// create an empty parameter list at a zero-length location
 		ASTNodeFactory nodeFactory(*this);
 		nodeFactory.setLocationEmpty();
@@ -148,32 +166,30 @@ ptr<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic)
 	ptr<Block> block = parseBlock();
 	nodeFactory.setEndPositionFromNode(block);
 	return nodeFactory.createNode<FunctionDefinition>(name, _isPublic, parameters,
-													  isDeclaredConst, returnParameters, block);
+			isDeclaredConst, returnParameters, block);
 }
 
 ptr<StructDefinition> Parser::parseStructDefinition()
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	expectToken(Token::STRUCT);
 	ptr<ASTString> name = expectIdentifierToken();
 	vecptr<VariableDeclaration> members;
 	expectToken(Token::LBRACE);
-	while (m_scanner->getCurrentToken() != Token::RBRACE) {
+	while (m_scanner->getCurrentToken() != Token::RBRACE)
+	{
 		bool const allowVar = false;
 		members.push_back(parseVariableDeclaration(allowVar));
 		expectToken(Token::SEMICOLON);
 	}
 	nodeFactory.markEndPosition();
 	expectToken(Token::RBRACE);
-
 	return nodeFactory.createNode<StructDefinition>(name, members);
 }
 
 ptr<VariableDeclaration> Parser::parseVariableDeclaration(bool _allowVar)
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	ptr<TypeName> type = parseTypeName(_allowVar);
 	nodeFactory.markEndPosition();
 	return nodeFactory.createNode<VariableDeclaration>(type, expectIdentifierToken());
@@ -183,58 +199,63 @@ ptr<TypeName> Parser::parseTypeName(bool _allowVar)
 {
 	ptr<TypeName> type;
 	Token::Value token = m_scanner->getCurrentToken();
-	if (Token::IsElementaryTypeName(token)) {
+	if (Token::isElementaryTypeName(token))
+	{
 		type = ASTNodeFactory(*this).createNode<ElementaryTypeName>(token);
 		m_scanner->next();
-	} else if (token == Token::VAR) {
+	}
+	else if (token == Token::VAR)
+	{
 		if (!_allowVar)
 			throwExpectationError("Expected explicit type name.");
 		m_scanner->next();
-	} else if (token == Token::MAPPING) {
+	}
+	else if (token == Token::MAPPING)
+	{
 		type = parseMapping();
-	} else if (token == Token::IDENTIFIER) {
+	}
+	else if (token == Token::IDENTIFIER)
+	{
 		ASTNodeFactory nodeFactory(*this);
 		nodeFactory.markEndPosition();
 		type = nodeFactory.createNode<UserDefinedTypeName>(expectIdentifierToken());
-	} else {
+	}
+	else
+	{
 		throwExpectationError("Expected type name");
 	}
-
 	return type;
 }
 
 ptr<Mapping> Parser::parseMapping()
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	expectToken(Token::MAPPING);
 	expectToken(Token::LPAREN);
-
-	if (!Token::IsElementaryTypeName(m_scanner->getCurrentToken()))
+	if (!Token::isElementaryTypeName(m_scanner->getCurrentToken()))
 		throwExpectationError("Expected elementary type name for mapping key type");
 	ptr<ElementaryTypeName> keyType;
 	keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(m_scanner->getCurrentToken());
 	m_scanner->next();
-
 	expectToken(Token::ARROW);
 	bool const allowVar = false;
 	ptr<TypeName> valueType = parseTypeName(allowVar);
 	nodeFactory.markEndPosition();
 	expectToken(Token::RPAREN);
-
 	return nodeFactory.createNode<Mapping>(keyType, valueType);
 }
 
 ptr<ParameterList> Parser::parseParameterList(bool _allowEmpty)
 {
 	ASTNodeFactory nodeFactory(*this);
-
 	vecptr<VariableDeclaration> parameters;
 	expectToken(Token::LPAREN);
-	if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN) {
+	if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN)
+	{
 		bool const allowVar = false;
 		parameters.push_back(parseVariableDeclaration(allowVar));
-		while (m_scanner->getCurrentToken() != Token::RPAREN) {
+		while (m_scanner->getCurrentToken() != Token::RPAREN)
+		{
 			expectToken(Token::COMMA);
 			parameters.push_back(parseVariableDeclaration(allowVar));
 		}
@@ -249,7 +270,8 @@ ptr<Block> Parser::parseBlock()
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::LBRACE);
 	vecptr<Statement> statements;
-	while (m_scanner->getCurrentToken() != Token::RBRACE) {
+	while (m_scanner->getCurrentToken() != Token::RBRACE)
+	{
 		statements.push_back(parseStatement());
 	}
 	nodeFactory.markEndPosition();
@@ -260,16 +282,15 @@ ptr<Block> Parser::parseBlock()
 ptr<Statement> Parser::parseStatement()
 {
 	ptr<Statement> statement;
-
-	switch (m_scanner->getCurrentToken()) {
+	switch (m_scanner->getCurrentToken())
+	{
 	case Token::IF:
 		return parseIfStatement();
 	case Token::WHILE:
 		return parseWhileStatement();
 	case Token::LBRACE:
 		return parseBlock();
-
-	// starting from here, all statements must be terminated by a semicolon
+		// starting from here, all statements must be terminated by a semicolon
 	case Token::CONTINUE:
 		statement = ASTNodeFactory(*this).createNode<Continue>();
 		break;
@@ -277,28 +298,32 @@ ptr<Statement> Parser::parseStatement()
 		statement = ASTNodeFactory(*this).createNode<Break>();
 		break;
 	case Token::RETURN:
+	{
+		ASTNodeFactory nodeFactory(*this);
+		ptr<Expression> expression;
+		if (m_scanner->next() != Token::SEMICOLON)
 		{
-			ASTNodeFactory nodeFactory(*this);
-			ptr<Expression> expression;
-			if (m_scanner->next() != Token::SEMICOLON) {
-				expression = parseExpression();
-				nodeFactory.setEndPositionFromNode(expression);
-			}
-			statement = nodeFactory.createNode<Return>(expression);
+			expression = parseExpression();
+			nodeFactory.setEndPositionFromNode(expression);
 		}
-		break;
+		statement = nodeFactory.createNode<Return>(expression);
+	}
+	break;
 	default:
 		// distinguish between variable definition (and potentially assignment) and expressions
 		// (which include assignments to other expressions and pre-declared variables)
 		// We have a variable definition if we ge a keyword that specifies a type name, or
 		// in the case of a user-defined type, we have two identifiers following each other.
 		if (m_scanner->getCurrentToken() == Token::MAPPING ||
-				m_scanner->getCurrentToken() == Token::VAR ||
-				Token::IsElementaryTypeName(m_scanner->getCurrentToken()) ||
-				(m_scanner->getCurrentToken() == Token::IDENTIFIER &&
-				 m_scanner->peek() == Token::IDENTIFIER)) {
+			m_scanner->getCurrentToken() == Token::VAR ||
+			Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
+			(m_scanner->getCurrentToken() == Token::IDENTIFIER &&
+			 m_scanner->peek() == Token::IDENTIFIER))
+		{
 			statement = parseVariableDefinition();
-		} else {
+		}
+		else
+		{
 			// "ordinary" expression
 			statement = parseExpression();
 		}
@@ -316,11 +341,14 @@ ptr<IfStatement> Parser::parseIfStatement()
 	expectToken(Token::RPAREN);
 	ptr<Statement> trueBody = parseStatement();
 	ptr<Statement> falseBody;
-	if (m_scanner->getCurrentToken() == Token::ELSE) {
+	if (m_scanner->getCurrentToken() == Token::ELSE)
+	{
 		m_scanner->next();
 		falseBody = parseStatement();
 		nodeFactory.setEndPositionFromNode(falseBody);
-	} else {
+	}
+	else
+	{
 		nodeFactory.setEndPositionFromNode(trueBody);
 	}
 	return nodeFactory.createNode<IfStatement>(condition, trueBody, falseBody);
@@ -344,11 +372,14 @@ ptr<VariableDefinition> Parser::parseVariableDefinition()
 	bool const allowVar = true;
 	ptr<VariableDeclaration> variable = parseVariableDeclaration(allowVar);
 	ptr<Expression> value;
-	if (m_scanner->getCurrentToken() == Token::ASSIGN) {
+	if (m_scanner->getCurrentToken() == Token::ASSIGN)
+	{
 		m_scanner->next();
 		value = parseExpression();
 		nodeFactory.setEndPositionFromNode(value);
-	} else {
+	}
+	else
+	{
 		nodeFactory.setEndPositionFromNode(variable);
 	}
 	return nodeFactory.createNode<VariableDefinition>(variable, value);
@@ -358,9 +389,8 @@ ptr<Expression> Parser::parseExpression()
 {
 	ASTNodeFactory nodeFactory(*this);
 	ptr<Expression> expression = parseBinaryExpression();
-	if (!Token::IsAssignmentOp(m_scanner->getCurrentToken()))
+	if (!Token::isAssignmentOp(m_scanner->getCurrentToken()))
 		return expression;
-
 	Token::Value assignmentOperator = expectAssignmentOperator();
 	ptr<Expression> rightHandSide = parseExpression();
 	nodeFactory.setEndPositionFromNode(rightHandSide);
@@ -371,9 +401,11 @@ ptr<Expression> Parser::parseBinaryExpression(int _minPrecedence)
 {
 	ASTNodeFactory nodeFactory(*this);
 	ptr<Expression> expression = parseUnaryExpression();
-	int precedence = Token::Precedence(m_scanner->getCurrentToken());
-	for (; precedence >= _minPrecedence; --precedence) {
-		while (Token::Precedence(m_scanner->getCurrentToken()) == precedence) {
+	int precedence = Token::precedence(m_scanner->getCurrentToken());
+	for (; precedence >= _minPrecedence; --precedence)
+	{
+		while (Token::precedence(m_scanner->getCurrentToken()) == precedence)
+		{
 			Token::Value op = m_scanner->getCurrentToken();
 			m_scanner->next();
 			ptr<Expression> right = parseBinaryExpression(precedence + 1);
@@ -388,17 +420,20 @@ ptr<Expression> Parser::parseUnaryExpression()
 {
 	ASTNodeFactory nodeFactory(*this);
 	Token::Value token = m_scanner->getCurrentToken();
-	if (Token::IsUnaryOp(token) || Token::IsCountOp(token)) {
+	if (Token::isUnaryOp(token) || Token::isCountOp(token))
+	{
 		// prefix expression
 		m_scanner->next();
 		ptr<Expression> subExpression = parseUnaryExpression();
 		nodeFactory.setEndPositionFromNode(subExpression);
 		return nodeFactory.createNode<UnaryOperation>(token, subExpression, true);
-	} else {
+	}
+	else
+	{
 		// potential postfix expression
 		ptr<Expression> subExpression = parseLeftHandSideExpression();
 		token = m_scanner->getCurrentToken();
-		if (!Token::IsCountOp(token))
+		if (!Token::isCountOp(token))
 			return subExpression;
 		nodeFactory.markEndPosition();
 		m_scanner->next();
@@ -410,34 +445,35 @@ ptr<Expression> Parser::parseLeftHandSideExpression()
 {
 	ASTNodeFactory nodeFactory(*this);
 	ptr<Expression> expression = parsePrimaryExpression();
-
-	while (true) {
-		switch (m_scanner->getCurrentToken()) {
+	while (true)
+	{
+		switch (m_scanner->getCurrentToken())
+		{
 		case Token::LBRACK:
-			{
-				m_scanner->next();
-				ptr<Expression> index = parseExpression();
-				nodeFactory.markEndPosition();
-				expectToken(Token::RBRACK);
-				expression = nodeFactory.createNode<IndexAccess>(expression, index);
-			}
-			break;
+		{
+			m_scanner->next();
+			ptr<Expression> index = parseExpression();
+			nodeFactory.markEndPosition();
+			expectToken(Token::RBRACK);
+			expression = nodeFactory.createNode<IndexAccess>(expression, index);
+		}
+		break;
 		case Token::PERIOD:
-			{
-				m_scanner->next();
-				nodeFactory.markEndPosition();
-				expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
-			}
-			break;
+		{
+			m_scanner->next();
+			nodeFactory.markEndPosition();
+			expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
+		}
+		break;
 		case Token::LPAREN:
-			{
-				m_scanner->next();
-				vecptr<Expression> arguments = parseFunctionCallArguments();
-				nodeFactory.markEndPosition();
-				expectToken(Token::RPAREN);
-				expression = nodeFactory.createNode<FunctionCall>(expression, arguments);
-			}
-			break;
+		{
+			m_scanner->next();
+			vecptr<Expression> arguments = parseFunctionCallArguments();
+			nodeFactory.markEndPosition();
+			expectToken(Token::RPAREN);
+			expression = nodeFactory.createNode<FunctionCall>(expression, arguments);
+		}
+		break;
 		default:
 			return expression;
 		}
@@ -449,8 +485,8 @@ ptr<Expression> Parser::parsePrimaryExpression()
 	ASTNodeFactory nodeFactory(*this);
 	Token::Value token = m_scanner->getCurrentToken();
 	ptr<Expression> expression;
-
-	switch (token) {
+	switch (token)
+	{
 	case Token::TRUE_LITERAL:
 	case Token::FALSE_LITERAL:
 		expression = nodeFactory.createNode<Literal>(token, ptr<ASTString>());
@@ -466,18 +502,21 @@ ptr<Expression> Parser::parsePrimaryExpression()
 		expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
 		break;
 	case Token::LPAREN:
-		{
-			m_scanner->next();
-			ptr<Expression> expression = parseExpression();
-			expectToken(Token::RPAREN);
-			return expression;
-		}
+	{
+		m_scanner->next();
+		ptr<Expression> expression = parseExpression();
+		expectToken(Token::RPAREN);
+		return expression;
+	}
 	default:
-		if (Token::IsElementaryTypeName(token)) {
+		if (Token::isElementaryTypeName(token))
+		{
 			// used for casts
 			expression = nodeFactory.createNode<ElementaryTypeNameExpression>(token);
 			m_scanner->next();
-		} else {
+		}
+		else
+		{
 			throwExpectationError("Expected primary expression.");
 			return ptr<Expression>(); // this is not reached
 		}
@@ -488,9 +527,11 @@ ptr<Expression> Parser::parsePrimaryExpression()
 vecptr<Expression> Parser::parseFunctionCallArguments()
 {
 	vecptr<Expression> arguments;
-	if (m_scanner->getCurrentToken() != Token::RPAREN) {
+	if (m_scanner->getCurrentToken() != Token::RPAREN)
+	{
 		arguments.push_back(parseExpression());
-		while (m_scanner->getCurrentToken() != Token::RPAREN) {
+		while (m_scanner->getCurrentToken() != Token::RPAREN)
+		{
 			expectToken(Token::COMMA);
 			arguments.push_back(parseExpression());
 		}
@@ -501,14 +542,14 @@ vecptr<Expression> Parser::parseFunctionCallArguments()
 void Parser::expectToken(Token::Value _value)
 {
 	if (m_scanner->getCurrentToken() != _value)
-		throwExpectationError(std::string("Expected token ") + std::string(Token::Name(_value)));
+		throwExpectationError(std::string("Expected token ") + std::string(Token::getName(_value)));
 	m_scanner->next();
 }
 
 Token::Value Parser::expectAssignmentOperator()
 {
 	Token::Value op = m_scanner->getCurrentToken();
-	if (!Token::IsAssignmentOp(op))
+	if (!Token::isAssignmentOp(op))
 		throwExpectationError(std::string("Expected assignment operator"));
 	m_scanner->next();
 	return op;
@@ -518,7 +559,6 @@ ptr<ASTString> Parser::expectIdentifierToken()
 {
 	if (m_scanner->getCurrentToken() != Token::IDENTIFIER)
 		throwExpectationError("Expected identifier");
-
 	return getLiteralAndAdvance();
 }
 
@@ -540,9 +580,9 @@ void Parser::throwExpectationError(const std::string& _description)
 		<< ", column " << (column + 1) << "\n"
 		<< m_scanner->getLineAtPosition(getPosition()) << "\n"
 		<< std::string(column, ' ') << "^";
-
 	BOOST_THROW_EXCEPTION(ParserError() << errinfo_comment(buf.str()));
 }
 
 
-} }
+}
+}