From 8a506b505f4725e8a76bbad8399562099e4510c3 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 16 Oct 2014 14:08:54 +0200 Subject: Corrected coding style. --- Parser.cpp | 288 +++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 164 insertions(+), 124 deletions(-) (limited to 'Parser.cpp') 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 . + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . */ /** * @author Christian @@ -26,13 +26,14 @@ #include #include -namespace dev { -namespace solidity { +namespace dev +{ +namespace solidity +{ ptr Parser::parse(std::shared_ptr 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& _node) @@ -58,7 +65,7 @@ public: /// @todo: check that this actually uses perfect forwarding template - ptr createNode(Args&&... _args) + ptr createNode(Args&& ... _args) { if (m_location.end < 0) markEndPosition(); @@ -84,62 +91,73 @@ int Parser::getEndPosition() const ptr Parser::parseContractDefinition() { ASTNodeFactory nodeFactory(*this); - expectToken(Token::CONTRACT); ptr name = expectIdentifierToken(); expectToken(Token::LBRACE); - vecptr structs; vecptr stateVariables; vecptr 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(name, structs, stateVariables, functions); } ptr Parser::parseFunctionDefinition(bool _isPublic) { ASTNodeFactory nodeFactory(*this); - expectToken(Token::FUNCTION); ptr name(expectIdentifierToken()); ptr parameters(parseParameterList()); bool isDeclaredConst = false; - if (m_scanner->getCurrentToken() == Token::CONST) { + if (m_scanner->getCurrentToken() == Token::CONST) + { isDeclaredConst = true; m_scanner->next(); } ptr 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 Parser::parseFunctionDefinition(bool _isPublic) ptr block = parseBlock(); nodeFactory.setEndPositionFromNode(block); return nodeFactory.createNode(name, _isPublic, parameters, - isDeclaredConst, returnParameters, block); + isDeclaredConst, returnParameters, block); } ptr Parser::parseStructDefinition() { ASTNodeFactory nodeFactory(*this); - expectToken(Token::STRUCT); ptr name = expectIdentifierToken(); vecptr 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(name, members); } ptr Parser::parseVariableDeclaration(bool _allowVar) { ASTNodeFactory nodeFactory(*this); - ptr type = parseTypeName(_allowVar); nodeFactory.markEndPosition(); return nodeFactory.createNode(type, expectIdentifierToken()); @@ -183,58 +199,63 @@ ptr Parser::parseTypeName(bool _allowVar) { ptr type; Token::Value token = m_scanner->getCurrentToken(); - if (Token::IsElementaryTypeName(token)) { + if (Token::isElementaryTypeName(token)) + { type = ASTNodeFactory(*this).createNode(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(expectIdentifierToken()); - } else { + } + else + { throwExpectationError("Expected type name"); } - return type; } ptr 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 keyType; keyType = ASTNodeFactory(*this).createNode(m_scanner->getCurrentToken()); m_scanner->next(); - expectToken(Token::ARROW); bool const allowVar = false; ptr valueType = parseTypeName(allowVar); nodeFactory.markEndPosition(); expectToken(Token::RPAREN); - return nodeFactory.createNode(keyType, valueType); } ptr Parser::parseParameterList(bool _allowEmpty) { ASTNodeFactory nodeFactory(*this); - vecptr 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 Parser::parseBlock() ASTNodeFactory nodeFactory(*this); expectToken(Token::LBRACE); vecptr statements; - while (m_scanner->getCurrentToken() != Token::RBRACE) { + while (m_scanner->getCurrentToken() != Token::RBRACE) + { statements.push_back(parseStatement()); } nodeFactory.markEndPosition(); @@ -260,16 +282,15 @@ ptr Parser::parseBlock() ptr Parser::parseStatement() { ptr 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(); break; @@ -277,28 +298,32 @@ ptr Parser::parseStatement() statement = ASTNodeFactory(*this).createNode(); break; case Token::RETURN: + { + ASTNodeFactory nodeFactory(*this); + ptr expression; + if (m_scanner->next() != Token::SEMICOLON) { - ASTNodeFactory nodeFactory(*this); - ptr expression; - if (m_scanner->next() != Token::SEMICOLON) { - expression = parseExpression(); - nodeFactory.setEndPositionFromNode(expression); - } - statement = nodeFactory.createNode(expression); + expression = parseExpression(); + nodeFactory.setEndPositionFromNode(expression); } - break; + statement = nodeFactory.createNode(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 Parser::parseIfStatement() expectToken(Token::RPAREN); ptr trueBody = parseStatement(); ptr 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(condition, trueBody, falseBody); @@ -344,11 +372,14 @@ ptr Parser::parseVariableDefinition() bool const allowVar = true; ptr variable = parseVariableDeclaration(allowVar); ptr 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(variable, value); @@ -358,9 +389,8 @@ ptr Parser::parseExpression() { ASTNodeFactory nodeFactory(*this); ptr expression = parseBinaryExpression(); - if (!Token::IsAssignmentOp(m_scanner->getCurrentToken())) + if (!Token::isAssignmentOp(m_scanner->getCurrentToken())) return expression; - Token::Value assignmentOperator = expectAssignmentOperator(); ptr rightHandSide = parseExpression(); nodeFactory.setEndPositionFromNode(rightHandSide); @@ -371,9 +401,11 @@ ptr Parser::parseBinaryExpression(int _minPrecedence) { ASTNodeFactory nodeFactory(*this); ptr 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 right = parseBinaryExpression(precedence + 1); @@ -388,17 +420,20 @@ ptr 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 subExpression = parseUnaryExpression(); nodeFactory.setEndPositionFromNode(subExpression); return nodeFactory.createNode(token, subExpression, true); - } else { + } + else + { // potential postfix expression ptr 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 Parser::parseLeftHandSideExpression() { ASTNodeFactory nodeFactory(*this); ptr expression = parsePrimaryExpression(); - - while (true) { - switch (m_scanner->getCurrentToken()) { + while (true) + { + switch (m_scanner->getCurrentToken()) + { case Token::LBRACK: - { - m_scanner->next(); - ptr index = parseExpression(); - nodeFactory.markEndPosition(); - expectToken(Token::RBRACK); - expression = nodeFactory.createNode(expression, index); - } - break; + { + m_scanner->next(); + ptr index = parseExpression(); + nodeFactory.markEndPosition(); + expectToken(Token::RBRACK); + expression = nodeFactory.createNode(expression, index); + } + break; case Token::PERIOD: - { - m_scanner->next(); - nodeFactory.markEndPosition(); - expression = nodeFactory.createNode(expression, expectIdentifierToken()); - } - break; + { + m_scanner->next(); + nodeFactory.markEndPosition(); + expression = nodeFactory.createNode(expression, expectIdentifierToken()); + } + break; case Token::LPAREN: - { - m_scanner->next(); - vecptr arguments = parseFunctionCallArguments(); - nodeFactory.markEndPosition(); - expectToken(Token::RPAREN); - expression = nodeFactory.createNode(expression, arguments); - } - break; + { + m_scanner->next(); + vecptr arguments = parseFunctionCallArguments(); + nodeFactory.markEndPosition(); + expectToken(Token::RPAREN); + expression = nodeFactory.createNode(expression, arguments); + } + break; default: return expression; } @@ -449,8 +485,8 @@ ptr Parser::parsePrimaryExpression() ASTNodeFactory nodeFactory(*this); Token::Value token = m_scanner->getCurrentToken(); ptr expression; - - switch (token) { + switch (token) + { case Token::TRUE_LITERAL: case Token::FALSE_LITERAL: expression = nodeFactory.createNode(token, ptr()); @@ -466,18 +502,21 @@ ptr Parser::parsePrimaryExpression() expression = nodeFactory.createNode(getLiteralAndAdvance()); break; case Token::LPAREN: - { - m_scanner->next(); - ptr expression = parseExpression(); - expectToken(Token::RPAREN); - return expression; - } + { + m_scanner->next(); + ptr expression = parseExpression(); + expectToken(Token::RPAREN); + return expression; + } default: - if (Token::IsElementaryTypeName(token)) { + if (Token::isElementaryTypeName(token)) + { // used for casts expression = nodeFactory.createNode(token); m_scanner->next(); - } else { + } + else + { throwExpectationError("Expected primary expression."); return ptr(); // this is not reached } @@ -488,9 +527,11 @@ ptr Parser::parsePrimaryExpression() vecptr Parser::parseFunctionCallArguments() { vecptr 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 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 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())); } -} } +} +} -- cgit v1.2.3