diff options
Diffstat (limited to 'Parser.cpp')
| -rw-r--r-- | Parser.cpp | 172 |
1 files changed, 86 insertions, 86 deletions
@@ -31,7 +31,7 @@ namespace dev namespace solidity { -ptr<ContractDefinition> Parser::parse(std::shared_ptr<Scanner> const& _scanner) +ASTPointer<ContractDefinition> Parser::parse(std::shared_ptr<Scanner> const& _scanner) { m_scanner = _scanner; return parseContractDefinition(); @@ -48,10 +48,10 @@ public: void markEndPosition() { m_location.end = m_parser.getEndPosition(); } void setLocationEmpty() { m_location.end = m_location.start; } /// Set the end position to the one of the given node. - void setEndPositionFromNode(ptr<ASTNode> const& _node) { m_location.end = _node->getLocation().end; } + void setEndPositionFromNode(ASTPointer<ASTNode> const& _node) { m_location.end = _node->getLocation().end; } template <class NodeType, typename... Args> - ptr<NodeType> createNode(Args&& ... _args) + ASTPointer<NodeType> createNode(Args&& ... _args) { if (m_location.end < 0) markEndPosition(); @@ -74,15 +74,15 @@ int Parser::getEndPosition() const } -ptr<ContractDefinition> Parser::parseContractDefinition() +ASTPointer<ContractDefinition> Parser::parseContractDefinition() { ASTNodeFactory nodeFactory(*this); expectToken(Token::CONTRACT); - ptr<ASTString> name = expectIdentifierToken(); + ASTPointer<ASTString> name = expectIdentifierToken(); expectToken(Token::LBRACE); - std::vector<ptr<StructDefinition>> structs; - std::vector<ptr<VariableDeclaration>> stateVariables; - std::vector<ptr<FunctionDefinition>> functions; + std::vector<ASTPointer<StructDefinition>> structs; + std::vector<ASTPointer<VariableDeclaration>> stateVariables; + std::vector<ASTPointer<FunctionDefinition>> functions; bool visibilityIsPublic = true; while (true) { @@ -115,19 +115,19 @@ ptr<ContractDefinition> Parser::parseContractDefinition() return nodeFactory.createNode<ContractDefinition>(name, structs, stateVariables, functions); } -ptr<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic) +ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic) { ASTNodeFactory nodeFactory(*this); expectToken(Token::FUNCTION); - ptr<ASTString> name(expectIdentifierToken()); - ptr<ParameterList> parameters(parseParameterList()); + ASTPointer<ASTString> name(expectIdentifierToken()); + ASTPointer<ParameterList> parameters(parseParameterList()); bool isDeclaredConst = false; if (m_scanner->getCurrentToken() == Token::CONST) { isDeclaredConst = true; m_scanner->next(); } - ptr<ParameterList> returnParameters; + ASTPointer<ParameterList> returnParameters; if (m_scanner->getCurrentToken() == Token::RETURNS) { bool const permitEmptyParameterList = false; @@ -139,20 +139,20 @@ ptr<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic) // create an empty parameter list at a zero-length location ASTNodeFactory nodeFactory(*this); nodeFactory.setLocationEmpty(); - returnParameters = nodeFactory.createNode<ParameterList>(std::vector<ptr<VariableDeclaration>>()); + returnParameters = nodeFactory.createNode<ParameterList>(std::vector<ASTPointer<VariableDeclaration>>()); } - ptr<Block> block = parseBlock(); + ASTPointer<Block> block = parseBlock(); nodeFactory.setEndPositionFromNode(block); return nodeFactory.createNode<FunctionDefinition>(name, _isPublic, parameters, isDeclaredConst, returnParameters, block); } -ptr<StructDefinition> Parser::parseStructDefinition() +ASTPointer<StructDefinition> Parser::parseStructDefinition() { ASTNodeFactory nodeFactory(*this); expectToken(Token::STRUCT); - ptr<ASTString> name = expectIdentifierToken(); - std::vector<ptr<VariableDeclaration>> members; + ASTPointer<ASTString> name = expectIdentifierToken(); + std::vector<ASTPointer<VariableDeclaration>> members; expectToken(Token::LBRACE); while (m_scanner->getCurrentToken() != Token::RBRACE) { @@ -165,17 +165,17 @@ ptr<StructDefinition> Parser::parseStructDefinition() return nodeFactory.createNode<StructDefinition>(name, members); } -ptr<VariableDeclaration> Parser::parseVariableDeclaration(bool _allowVar) +ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(bool _allowVar) { ASTNodeFactory nodeFactory(*this); - ptr<TypeName> type = parseTypeName(_allowVar); + ASTPointer<TypeName> type = parseTypeName(_allowVar); nodeFactory.markEndPosition(); return nodeFactory.createNode<VariableDeclaration>(type, expectIdentifierToken()); } -ptr<TypeName> Parser::parseTypeName(bool _allowVar) +ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar) { - ptr<TypeName> type; + ASTPointer<TypeName> type; Token::Value token = m_scanner->getCurrentToken(); if (Token::isElementaryTypeName(token)) { @@ -203,28 +203,28 @@ ptr<TypeName> Parser::parseTypeName(bool _allowVar) return type; } -ptr<Mapping> Parser::parseMapping() +ASTPointer<Mapping> Parser::parseMapping() { ASTNodeFactory nodeFactory(*this); expectToken(Token::MAPPING); expectToken(Token::LPAREN); if (!Token::isElementaryTypeName(m_scanner->getCurrentToken())) throwExpectationError("Expected elementary type name for mapping key type"); - ptr<ElementaryTypeName> keyType; + ASTPointer<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); + ASTPointer<TypeName> valueType = parseTypeName(allowVar); nodeFactory.markEndPosition(); expectToken(Token::RPAREN); return nodeFactory.createNode<Mapping>(keyType, valueType); } -ptr<ParameterList> Parser::parseParameterList(bool _allowEmpty) +ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty) { ASTNodeFactory nodeFactory(*this); - std::vector<ptr<VariableDeclaration>> parameters; + std::vector<ASTPointer<VariableDeclaration>> parameters; expectToken(Token::LPAREN); if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN) { @@ -241,11 +241,11 @@ ptr<ParameterList> Parser::parseParameterList(bool _allowEmpty) return nodeFactory.createNode<ParameterList>(parameters); } -ptr<Block> Parser::parseBlock() +ASTPointer<Block> Parser::parseBlock() { ASTNodeFactory nodeFactory(*this); expectToken(Token::LBRACE); - std::vector<ptr<Statement>> statements; + std::vector<ASTPointer<Statement>> statements; while (m_scanner->getCurrentToken() != Token::RBRACE) statements.push_back(parseStatement()); nodeFactory.markEndPosition(); @@ -253,9 +253,9 @@ ptr<Block> Parser::parseBlock() return nodeFactory.createNode<Block>(statements); } -ptr<Statement> Parser::parseStatement() +ASTPointer<Statement> Parser::parseStatement() { - ptr<Statement> statement; + ASTPointer<Statement> statement; switch (m_scanner->getCurrentToken()) { case Token::IF: @@ -274,7 +274,7 @@ ptr<Statement> Parser::parseStatement() case Token::RETURN: { ASTNodeFactory nodeFactory(*this); - ptr<Expression> expression; + ASTPointer<Expression> expression; if (m_scanner->next() != Token::SEMICOLON) { expression = parseExpression(); @@ -301,15 +301,15 @@ ptr<Statement> Parser::parseStatement() return statement; } -ptr<IfStatement> Parser::parseIfStatement() +ASTPointer<IfStatement> Parser::parseIfStatement() { ASTNodeFactory nodeFactory(*this); expectToken(Token::IF); expectToken(Token::LPAREN); - ptr<Expression> condition = parseExpression(); + ASTPointer<Expression> condition = parseExpression(); expectToken(Token::RPAREN); - ptr<Statement> trueBody = parseStatement(); - ptr<Statement> falseBody; + ASTPointer<Statement> trueBody = parseStatement(); + ASTPointer<Statement> falseBody; if (m_scanner->getCurrentToken() == Token::ELSE) { m_scanner->next(); @@ -321,24 +321,24 @@ ptr<IfStatement> Parser::parseIfStatement() return nodeFactory.createNode<IfStatement>(condition, trueBody, falseBody); } -ptr<WhileStatement> Parser::parseWhileStatement() +ASTPointer<WhileStatement> Parser::parseWhileStatement() { ASTNodeFactory nodeFactory(*this); expectToken(Token::WHILE); expectToken(Token::LPAREN); - ptr<Expression> condition = parseExpression(); + ASTPointer<Expression> condition = parseExpression(); expectToken(Token::RPAREN); - ptr<Statement> body = parseStatement(); + ASTPointer<Statement> body = parseStatement(); nodeFactory.setEndPositionFromNode(body); return nodeFactory.createNode<WhileStatement>(condition, body); } -ptr<VariableDefinition> Parser::parseVariableDefinition() +ASTPointer<VariableDefinition> Parser::parseVariableDefinition() { ASTNodeFactory nodeFactory(*this); bool const allowVar = true; - ptr<VariableDeclaration> variable = parseVariableDeclaration(allowVar); - ptr<Expression> value; + ASTPointer<VariableDeclaration> variable = parseVariableDeclaration(allowVar); + ASTPointer<Expression> value; if (m_scanner->getCurrentToken() == Token::ASSIGN) { m_scanner->next(); @@ -350,22 +350,22 @@ ptr<VariableDefinition> Parser::parseVariableDefinition() return nodeFactory.createNode<VariableDefinition>(variable, value); } -ptr<Expression> Parser::parseExpression() +ASTPointer<Expression> Parser::parseExpression() { ASTNodeFactory nodeFactory(*this); - ptr<Expression> expression = parseBinaryExpression(); + ASTPointer<Expression> expression = parseBinaryExpression(); if (!Token::isAssignmentOp(m_scanner->getCurrentToken())) return expression; Token::Value assignmentOperator = expectAssignmentOperator(); - ptr<Expression> rightHandSide = parseExpression(); + ASTPointer<Expression> rightHandSide = parseExpression(); nodeFactory.setEndPositionFromNode(rightHandSide); return nodeFactory.createNode<Assignment>(expression, assignmentOperator, rightHandSide); } -ptr<Expression> Parser::parseBinaryExpression(int _minPrecedence) +ASTPointer<Expression> Parser::parseBinaryExpression(int _minPrecedence) { ASTNodeFactory nodeFactory(*this); - ptr<Expression> expression = parseUnaryExpression(); + ASTPointer<Expression> expression = parseUnaryExpression(); int precedence = Token::precedence(m_scanner->getCurrentToken()); for (; precedence >= _minPrecedence; --precedence) { @@ -373,7 +373,7 @@ ptr<Expression> Parser::parseBinaryExpression(int _minPrecedence) { Token::Value op = m_scanner->getCurrentToken(); m_scanner->next(); - ptr<Expression> right = parseBinaryExpression(precedence + 1); + ASTPointer<Expression> right = parseBinaryExpression(precedence + 1); nodeFactory.setEndPositionFromNode(right); expression = nodeFactory.createNode<BinaryOperation>(expression, op, right); } @@ -381,7 +381,7 @@ ptr<Expression> Parser::parseBinaryExpression(int _minPrecedence) return expression; } -ptr<Expression> Parser::parseUnaryExpression() +ASTPointer<Expression> Parser::parseUnaryExpression() { ASTNodeFactory nodeFactory(*this); Token::Value token = m_scanner->getCurrentToken(); @@ -389,14 +389,14 @@ ptr<Expression> Parser::parseUnaryExpression() { // prefix expression m_scanner->next(); - ptr<Expression> subExpression = parseUnaryExpression(); + ASTPointer<Expression> subExpression = parseUnaryExpression(); nodeFactory.setEndPositionFromNode(subExpression); return nodeFactory.createNode<UnaryOperation>(token, subExpression, true); } else { // potential postfix expression - ptr<Expression> subExpression = parseLeftHandSideExpression(); + ASTPointer<Expression> subExpression = parseLeftHandSideExpression(); token = m_scanner->getCurrentToken(); if (!Token::isCountOp(token)) return subExpression; @@ -406,38 +406,38 @@ ptr<Expression> Parser::parseUnaryExpression() } } -ptr<Expression> Parser::parseLeftHandSideExpression() +ASTPointer<Expression> Parser::parseLeftHandSideExpression() { ASTNodeFactory nodeFactory(*this); - ptr<Expression> expression = parsePrimaryExpression(); + ASTPointer<Expression> expression = parsePrimaryExpression(); 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); - } + { + m_scanner->next(); + ASTPointer<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()); - } + { + m_scanner->next(); + nodeFactory.markEndPosition(); + expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken()); + } break; case Token::LPAREN: - { - m_scanner->next(); - std::vector<ptr<Expression>> arguments = parseFunctionCallArguments(); - nodeFactory.markEndPosition(); - expectToken(Token::RPAREN); - expression = nodeFactory.createNode<FunctionCall>(expression, arguments); - } + { + m_scanner->next(); + std::vector<ASTPointer<Expression>> arguments = parseFunctionCallArguments(); + nodeFactory.markEndPosition(); + expectToken(Token::RPAREN); + expression = nodeFactory.createNode<FunctionCall>(expression, arguments); + } break; default: return expression; @@ -445,16 +445,16 @@ ptr<Expression> Parser::parseLeftHandSideExpression() } } -ptr<Expression> Parser::parsePrimaryExpression() +ASTPointer<Expression> Parser::parsePrimaryExpression() { ASTNodeFactory nodeFactory(*this); Token::Value token = m_scanner->getCurrentToken(); - ptr<Expression> expression; + ASTPointer<Expression> expression; switch (token) { case Token::TRUE_LITERAL: case Token::FALSE_LITERAL: - expression = nodeFactory.createNode<Literal>(token, ptr<ASTString>()); + expression = nodeFactory.createNode<Literal>(token, ASTPointer<ASTString>()); m_scanner->next(); break; case Token::NUMBER: @@ -467,12 +467,12 @@ 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(); + ASTPointer<Expression> expression = parseExpression(); + expectToken(Token::RPAREN); + return expression; + } default: if (Token::isElementaryTypeName(token)) { @@ -483,16 +483,16 @@ ptr<Expression> Parser::parsePrimaryExpression() else { throwExpectationError("Expected primary expression."); - return ptr<Expression>(); // this is not reached + return ASTPointer<Expression>(); // this is not reached } break; } return expression; } -std::vector<ptr<Expression>> Parser::parseFunctionCallArguments() +std::vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments() { - std::vector<ptr<Expression>> arguments; + std::vector<ASTPointer<Expression>> arguments; if (m_scanner->getCurrentToken() != Token::RPAREN) { arguments.push_back(parseExpression()); @@ -521,16 +521,16 @@ Token::Value Parser::expectAssignmentOperator() return op; } -ptr<ASTString> Parser::expectIdentifierToken() +ASTPointer<ASTString> Parser::expectIdentifierToken() { if (m_scanner->getCurrentToken() != Token::IDENTIFIER) throwExpectationError("Expected identifier"); return getLiteralAndAdvance(); } -ptr<ASTString> Parser::getLiteralAndAdvance() +ASTPointer<ASTString> Parser::getLiteralAndAdvance() { - ptr<ASTString> identifier = std::make_shared<ASTString>(m_scanner->getCurrentLiteral()); + ASTPointer<ASTString> identifier = std::make_shared<ASTString>(m_scanner->getCurrentLiteral()); m_scanner->next(); return identifier; } |