solidity/libsolidity/Parser.cpp

1083 lines
34 KiB
C++
Raw Normal View History

/*
2014-10-16 12:08:54 +00:00
This file is part of cpp-ethereum.
2014-10-16 12:08:54 +00:00
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.
2014-10-16 12:08:54 +00:00
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.
2014-10-16 12:08:54 +00:00
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>
* @date 2014
* Solidity parser.
*/
2014-12-03 06:46:55 +00:00
#include <vector>
2014-10-15 12:45:51 +00:00
#include <libdevcore/Log.h>
#include <libevmasm/SourceLocation.h>
2014-10-15 12:45:51 +00:00
#include <libsolidity/Parser.h>
#include <libsolidity/Scanner.h>
#include <libsolidity/Exceptions.h>
#include <libsolidity/InterfaceHandler.h>
2014-12-03 06:47:08 +00:00
using namespace std;
2014-10-16 12:08:54 +00:00
namespace dev
{
namespace solidity
{
/// AST node factory that also tracks the begin and end position of an AST node
/// while it is being parsed
class Parser::ASTNodeFactory
{
public:
ASTNodeFactory(Parser const& _parser):
m_parser(_parser), m_location(_parser.getPosition(), -1, _parser.getSourceName()) {}
ASTNodeFactory(Parser const& _parser, ASTPointer<ASTNode> const& _childNode):
m_parser(_parser), m_location(_childNode->getLocation()) {}
2014-10-13 16:22:15 +00:00
2014-10-16 21:49:45 +00:00
void markEndPosition() { m_location.end = m_parser.getEndPosition(); }
void setLocation(SourceLocation const& _location) { m_location = _location; }
2014-10-16 21:49:45 +00:00
void setLocationEmpty() { m_location.end = m_location.start; }
2014-10-09 10:28:37 +00:00
/// Set the end position to the one of the given node.
void setEndPositionFromNode(ASTPointer<ASTNode> const& _node) { m_location.end = _node->getLocation().end; }
2014-10-09 10:28:37 +00:00
template <class NodeType, typename... Args>
ASTPointer<NodeType> createNode(Args&& ... _args)
2014-10-09 10:28:37 +00:00
{
if (m_location.end < 0)
markEndPosition();
2014-12-03 06:47:08 +00:00
return make_shared<NodeType>(m_location, forward<Args>(_args)...);
2014-10-09 10:28:37 +00:00
}
private:
Parser const& m_parser;
SourceLocation m_location;
};
2014-12-03 06:46:55 +00:00
ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
{
m_scanner = _scanner;
ASTNodeFactory nodeFactory(*this);
vector<ASTPointer<ASTNode>> nodes;
while (_scanner->getCurrentToken() != Token::EOS)
{
switch (m_scanner->getCurrentToken())
{
case Token::Import:
2014-12-03 06:46:55 +00:00
nodes.push_back(parseImportDirective());
break;
case Token::Contract:
2014-12-03 06:46:55 +00:00
nodes.push_back(parseContractDefinition());
break;
default:
BOOST_THROW_EXCEPTION(createParserError(std::string("Expected import directive or contract definition.")));
}
}
return nodeFactory.createNode<SourceUnit>(nodes);
}
std::shared_ptr<const string> const& Parser::getSourceName() const
{
return m_scanner->getSourceName();
}
int Parser::getPosition() const
{
2014-10-09 10:28:37 +00:00
return m_scanner->getCurrentLocation().start;
}
int Parser::getEndPosition() const
{
2014-10-09 10:28:37 +00:00
return m_scanner->getCurrentLocation().end;
}
2014-12-03 06:46:55 +00:00
ASTPointer<ImportDirective> Parser::parseImportDirective()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Import);
if (m_scanner->getCurrentToken() != Token::StringLiteral)
2014-12-03 06:46:55 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected string literal (URL)."));
ASTPointer<ASTString> url = getLiteralAndAdvance();
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
2014-12-03 06:46:55 +00:00
return nodeFactory.createNode<ImportDirective>(url);
}
ASTPointer<ContractDefinition> Parser::parseContractDefinition()
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
2015-01-20 16:41:09 +00:00
ASTPointer<ASTString> docString;
if (m_scanner->getCurrentCommentLiteral() != "")
2015-01-20 16:41:09 +00:00
docString = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::Contract);
ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<InheritanceSpecifier>> baseContracts;
2014-12-03 06:47:08 +00:00
vector<ASTPointer<StructDefinition>> structs;
2015-02-09 17:08:56 +00:00
vector<ASTPointer<EnumDefinition>> enums;
2014-12-03 06:47:08 +00:00
vector<ASTPointer<VariableDeclaration>> stateVariables;
vector<ASTPointer<FunctionDefinition>> functions;
2015-01-21 10:16:18 +00:00
vector<ASTPointer<ModifierDefinition>> modifiers;
2015-01-29 13:35:28 +00:00
vector<ASTPointer<EventDefinition>> events;
if (m_scanner->getCurrentToken() == Token::Is)
2015-01-15 15:15:01 +00:00
do
{
m_scanner->next();
baseContracts.push_back(parseInheritanceSpecifier());
2015-01-15 15:15:01 +00:00
}
while (m_scanner->getCurrentToken() == Token::Comma);
expectToken(Token::LBrace);
2014-10-16 12:08:54 +00:00
while (true)
{
2014-10-09 10:28:37 +00:00
Token::Value currentToken = m_scanner->getCurrentToken();
if (currentToken == Token::RBrace)
2014-10-09 10:28:37 +00:00
break;
else if (currentToken == Token::Function)
functions.push_back(parseFunctionDefinition(name.get()));
else if (currentToken == Token::Struct)
2014-10-09 10:28:37 +00:00
structs.push_back(parseStructDefinition());
2015-02-09 17:08:56 +00:00
else if (currentToken == Token::Enum)
enums.push_back(parseEnumDefinition());
else if (currentToken == Token::Identifier || currentToken == Token::Mapping ||
2014-10-16 12:08:54 +00:00
Token::isElementaryTypeName(currentToken))
{
2015-01-29 13:35:28 +00:00
VarDeclParserOptions options;
options.isStateVariable = true;
options.allowInitialValue = true;
2015-01-29 13:35:28 +00:00
stateVariables.push_back(parseVariableDeclaration(options));
expectToken(Token::Semicolon);
2014-10-16 12:08:54 +00:00
}
else if (currentToken == Token::Modifier)
2015-01-21 10:16:18 +00:00
modifiers.push_back(parseModifierDefinition());
else if (currentToken == Token::Event)
2015-01-29 13:35:28 +00:00
events.push_back(parseEventDefinition());
2014-10-16 12:08:54 +00:00
else
2015-01-21 10:16:18 +00:00
BOOST_THROW_EXCEPTION(createParserError("Function, variable, struct or modifier declaration expected."));
2014-10-09 10:28:37 +00:00
}
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
return nodeFactory.createNode<ContractDefinition>(
name,
docString,
baseContracts,
structs,
enums,
stateVariables,
functions,
modifiers,
events
);
}
ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
{
ASTNodeFactory nodeFactory(*this);
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() == Token::LParen)
{
m_scanner->next();
2015-01-29 17:26:00 +00:00
arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
return nodeFactory.createNode<InheritanceSpecifier>(name, arguments);
}
2015-02-02 16:24:09 +00:00
Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token)
{
Declaration::Visibility visibility(Declaration::Visibility::Default);
if (_token == Token::Public)
visibility = Declaration::Visibility::Public;
2015-02-22 18:37:54 +00:00
else if (_token == Token::Internal)
visibility = Declaration::Visibility::Internal;
else if (_token == Token::Private)
visibility = Declaration::Visibility::Private;
2015-02-13 23:43:02 +00:00
else if (_token == Token::External)
visibility = Declaration::Visibility::External;
2015-02-02 16:24:09 +00:00
else
solAssert(false, "Invalid visibility specifier.");
m_scanner->next();
return visibility;
}
ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const* _contractName)
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
ASTPointer<ASTString> docstring;
if (m_scanner->getCurrentCommentLiteral() != "")
2014-12-03 06:47:08 +00:00
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::Function);
2015-01-29 21:50:20 +00:00
ASTPointer<ASTString> name;
if (m_scanner->getCurrentToken() == Token::LParen)
2015-01-29 21:50:20 +00:00
name = make_shared<ASTString>(); // anonymous function
else
name = expectIdentifierToken();
VarDeclParserOptions options;
options.allowLocationSpecifier = true;
ASTPointer<ParameterList> parameters(parseParameterList(options));
2014-10-09 10:28:37 +00:00
bool isDeclaredConst = false;
Declaration::Visibility visibility(Declaration::Visibility::Default);
vector<ASTPointer<ModifierInvocation>> modifiers;
while (true)
2014-10-16 12:08:54 +00:00
{
2015-02-02 16:24:09 +00:00
Token::Value token = m_scanner->getCurrentToken();
if (token == Token::Const)
{
isDeclaredConst = true;
m_scanner->next();
}
else if (token == Token::Identifier)
modifiers.push_back(parseModifierInvocation());
2015-02-02 16:24:09 +00:00
else if (Token::isVisibilitySpecifier(token))
{
if (visibility != Declaration::Visibility::Default)
2015-02-02 16:24:09 +00:00
BOOST_THROW_EXCEPTION(createParserError("Multiple visibility specifiers."));
visibility = parseVisibilitySpecifier(token);
}
else
break;
2014-10-09 10:28:37 +00:00
}
ASTPointer<ParameterList> returnParameters;
if (m_scanner->getCurrentToken() == Token::Returns)
2014-10-16 12:08:54 +00:00
{
bool const permitEmptyParameterList = false;
2014-10-09 10:28:37 +00:00
m_scanner->next();
returnParameters = parseParameterList(options, permitEmptyParameterList);
2014-10-16 12:08:54 +00:00
}
else
2015-01-30 20:43:19 +00:00
returnParameters = createEmptyParameterList();
ASTPointer<Block> block = ASTPointer<Block>();
nodeFactory.markEndPosition();
if (m_scanner->getCurrentToken() != Token::Semicolon)
{
block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
}
else
m_scanner->next(); // just consume the ';'
bool const c_isConstructor = (_contractName && *name == *_contractName);
2015-02-02 16:24:09 +00:00
return nodeFactory.createNode<FunctionDefinition>(name, visibility, c_isConstructor, docstring,
parameters, isDeclaredConst, modifiers,
returnParameters, block);
}
ASTPointer<StructDefinition> Parser::parseStructDefinition()
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Struct);
ASTPointer<ASTString> name = expectIdentifierToken();
2014-12-03 06:47:08 +00:00
vector<ASTPointer<VariableDeclaration>> members;
expectToken(Token::LBrace);
while (m_scanner->getCurrentToken() != Token::RBrace)
2014-10-16 12:08:54 +00:00
{
2015-01-29 13:35:28 +00:00
members.push_back(parseVariableDeclaration());
expectToken(Token::Semicolon);
2014-10-09 10:28:37 +00:00
}
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<StructDefinition>(name, members);
}
ASTPointer<EnumValue> Parser::parseEnumValue()
2015-02-09 17:08:56 +00:00
{
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
return nodeFactory.createNode<EnumValue>(expectIdentifierToken());
2015-02-09 17:08:56 +00:00
}
ASTPointer<EnumDefinition> Parser::parseEnumDefinition()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Enum);
ASTPointer<ASTString> name = expectIdentifierToken();
2015-02-13 16:34:46 +00:00
vector<ASTPointer<EnumValue>> members;
2015-02-09 17:08:56 +00:00
expectToken(Token::LBrace);
while (m_scanner->getCurrentToken() != Token::RBrace)
2015-02-09 17:08:56 +00:00
{
members.push_back(parseEnumValue());
2015-02-09 17:08:56 +00:00
if (m_scanner->getCurrentToken() == Token::RBrace)
break;
expectToken(Token::Comma);
if (m_scanner->getCurrentToken() != Token::Identifier)
2015-02-13 14:59:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected Identifier after ','"));
2015-02-09 17:08:56 +00:00
}
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
return nodeFactory.createNode<EnumDefinition>(name, members);
}
ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
VarDeclParserOptions const& _options,
ASTPointer<TypeName> const& _lookAheadArrayType
)
{
ASTNodeFactory nodeFactory = _lookAheadArrayType ?
ASTNodeFactory(*this, _lookAheadArrayType) : ASTNodeFactory(*this);
ASTPointer<TypeName> type;
if (_lookAheadArrayType)
type = _lookAheadArrayType;
else
{
type = parseTypeName(_options.allowVar);
if (type != nullptr)
nodeFactory.setEndPositionFromNode(type);
}
2015-01-29 13:35:28 +00:00
bool isIndexed = false;
bool isDeclaredConst = false;
Declaration::Visibility visibility(Declaration::Visibility::Default);
VariableDeclaration::Location location = VariableDeclaration::Location::Default;
ASTPointer<ASTString> identifier;
while (true)
{
Token::Value token = m_scanner->getCurrentToken();
if (_options.isStateVariable && Token::isVariableVisibilitySpecifier(token))
{
if (visibility != Declaration::Visibility::Default)
BOOST_THROW_EXCEPTION(createParserError("Visibility already specified."));
visibility = parseVisibilitySpecifier(token);
}
else
{
if (_options.allowIndexed && token == Token::Indexed)
isIndexed = true;
else if (token == Token::Const)
isDeclaredConst = true;
else if (_options.allowLocationSpecifier && Token::isLocationSpecifier(token))
{
if (location != VariableDeclaration::Location::Default)
BOOST_THROW_EXCEPTION(createParserError("Location already specified."));
if (!type)
BOOST_THROW_EXCEPTION(createParserError("Location specifier needs explicit type name."));
location = (
token == Token::Memory ?
VariableDeclaration::Location::Memory :
VariableDeclaration::Location::Storage
);
}
else
break;
m_scanner->next();
}
}
nodeFactory.markEndPosition();
if (_options.allowEmptyName && m_scanner->getCurrentToken() != Token::Identifier)
{
identifier = make_shared<ASTString>("");
2015-02-09 10:09:03 +00:00
solAssert(type != nullptr, "");
nodeFactory.setEndPositionFromNode(type);
}
else
identifier = expectIdentifierToken();
ASTPointer<Expression> value;
if (_options.allowInitialValue)
{
if (m_scanner->getCurrentToken() == Token::Assign)
{
m_scanner->next();
value = parseExpression();
nodeFactory.setEndPositionFromNode(value);
}
}
2015-06-05 12:45:47 +00:00
return nodeFactory.createNode<VariableDeclaration>(
type,
identifier,
value,
visibility,
_options.isStateVariable,
isIndexed,
isDeclaredConst,
location
);
}
2015-01-21 10:16:18 +00:00
ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
{
ScopeGuard resetModifierFlag([this]() { m_insideModifier = false; });
m_insideModifier = true;
ASTNodeFactory nodeFactory(*this);
ASTPointer<ASTString> docstring;
if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::Modifier);
2015-01-21 10:16:18 +00:00
ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters;
if (m_scanner->getCurrentToken() == Token::LParen)
{
VarDeclParserOptions options;
options.allowIndexed = true;
options.allowLocationSpecifier = true;
parameters = parseParameterList(options);
}
2015-01-21 10:16:18 +00:00
else
2015-01-30 20:43:19 +00:00
parameters = createEmptyParameterList();
2015-01-21 10:16:18 +00:00
ASTPointer<Block> block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
return nodeFactory.createNode<ModifierDefinition>(name, docstring, parameters, block);
}
2015-01-29 13:35:28 +00:00
ASTPointer<EventDefinition> Parser::parseEventDefinition()
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<ASTString> docstring;
if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::Event);
2015-01-29 13:35:28 +00:00
ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters;
if (m_scanner->getCurrentToken() == Token::LParen)
{
VarDeclParserOptions options;
options.allowIndexed = true;
parameters = parseParameterList(options);
}
2015-01-30 20:43:19 +00:00
else
parameters = createEmptyParameterList();
bool anonymous = false;
if (m_scanner->getCurrentToken() == Token::Anonymous)
{
anonymous = true;
m_scanner->next();
}
2015-01-29 13:35:28 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<EventDefinition>(name, docstring, parameters, anonymous);
2015-01-29 13:35:28 +00:00
}
ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
{
ASTNodeFactory nodeFactory(*this);
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() == Token::LParen)
{
m_scanner->next();
2015-01-29 17:26:00 +00:00
arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
return nodeFactory.createNode<ModifierInvocation>(name, arguments);
}
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> Parser::parseIdentifier()
{
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
return nodeFactory.createNode<Identifier>(expectIdentifierToken());
}
ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<TypeName> type;
2014-10-09 10:28:37 +00:00
Token::Value token = m_scanner->getCurrentToken();
2014-10-16 12:08:54 +00:00
if (Token::isElementaryTypeName(token))
{
2014-10-09 10:28:37 +00:00
type = ASTNodeFactory(*this).createNode<ElementaryTypeName>(token);
m_scanner->next();
2014-10-16 12:08:54 +00:00
}
else if (token == Token::Var)
2014-10-16 12:08:54 +00:00
{
2014-10-13 16:22:15 +00:00
if (!_allowVar)
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected explicit type name."));
2014-10-09 10:28:37 +00:00
m_scanner->next();
2014-10-16 12:08:54 +00:00
}
else if (token == Token::Mapping)
2014-10-09 10:28:37 +00:00
type = parseMapping();
else if (token == Token::Identifier)
2014-10-16 12:08:54 +00:00
{
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
type = nodeFactory.createNode<UserDefinedTypeName>(expectIdentifierToken());
2014-10-16 12:08:54 +00:00
}
else
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected type name"));
if (type)
// Parse "[...]" postfixes for arrays.
while (m_scanner->getCurrentToken() == Token::LBrack)
{
m_scanner->next();
ASTPointer<Expression> length;
if (m_scanner->getCurrentToken() != Token::RBrack)
length = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
type = nodeFactory.createNode<ArrayTypeName>(type, length);
}
2014-10-09 10:28:37 +00:00
return type;
}
ASTPointer<Mapping> Parser::parseMapping()
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Mapping);
expectToken(Token::LParen);
2014-10-16 12:08:54 +00:00
if (!Token::isElementaryTypeName(m_scanner->getCurrentToken()))
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected elementary type name for mapping key type"));
ASTPointer<ElementaryTypeName> keyType;
2014-10-09 10:28:37 +00:00
keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(m_scanner->getCurrentToken());
m_scanner->next();
expectToken(Token::Arrow);
2014-10-13 16:22:15 +00:00
bool const allowVar = false;
ASTPointer<TypeName> valueType = parseTypeName(allowVar);
2014-10-09 10:28:37 +00:00
nodeFactory.markEndPosition();
expectToken(Token::RParen);
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<Mapping>(keyType, valueType);
}
ASTPointer<ParameterList> Parser::parseParameterList(
VarDeclParserOptions const& _options,
bool _allowEmpty
)
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<VariableDeclaration>> parameters;
VarDeclParserOptions options(_options);
options.allowEmptyName = true;
expectToken(Token::LParen);
if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
2015-01-29 13:35:28 +00:00
parameters.push_back(parseVariableDeclaration(options));
while (m_scanner->getCurrentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
expectToken(Token::Comma);
2015-01-29 13:35:28 +00:00
parameters.push_back(parseVariableDeclaration(options));
2014-10-09 10:28:37 +00:00
}
}
nodeFactory.markEndPosition();
m_scanner->next();
return nodeFactory.createNode<ParameterList>(parameters);
}
ASTPointer<Block> Parser::parseBlock()
{
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::LBrace);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<Statement>> statements;
while (m_scanner->getCurrentToken() != Token::RBrace)
2014-10-09 10:28:37 +00:00
statements.push_back(parseStatement());
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<Block>(statements);
}
ASTPointer<Statement> Parser::parseStatement()
2014-10-09 10:28:37 +00:00
{
ASTPointer<Statement> statement;
2014-10-16 12:08:54 +00:00
switch (m_scanner->getCurrentToken())
{
case Token::If:
2014-10-09 10:28:37 +00:00
return parseIfStatement();
case Token::While:
2014-10-09 10:28:37 +00:00
return parseWhileStatement();
case Token::For:
return parseForStatement();
case Token::LBrace:
2014-10-09 10:28:37 +00:00
return parseBlock();
2014-10-16 12:08:54 +00:00
// starting from here, all statements must be terminated by a semicolon
case Token::Continue:
statement = ASTNodeFactory(*this).createNode<Continue>();
m_scanner->next();
break;
case Token::Break:
statement = ASTNodeFactory(*this).createNode<Break>();
m_scanner->next();
break;
case Token::Return:
2014-10-16 12:08:54 +00:00
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression;
if (m_scanner->next() != Token::Semicolon)
{
2014-10-16 12:08:54 +00:00
expression = parseExpression();
nodeFactory.setEndPositionFromNode(expression);
}
2014-10-16 12:08:54 +00:00
statement = nodeFactory.createNode<Return>(expression);
2015-01-21 10:16:18 +00:00
break;
2014-10-16 12:08:54 +00:00
}
case Token::Identifier:
2015-01-21 10:16:18 +00:00
if (m_insideModifier && m_scanner->getCurrentLiteral() == "_")
{
statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>();
m_scanner->next();
return statement;
}
// fall-through
default:
statement = parseSimpleStatement();
}
expectToken(Token::Semicolon);
return statement;
}
ASTPointer<IfStatement> Parser::parseIfStatement()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::If);
expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RParen);
ASTPointer<Statement> trueBody = parseStatement();
ASTPointer<Statement> falseBody;
if (m_scanner->getCurrentToken() == Token::Else)
2014-10-16 12:08:54 +00:00
{
m_scanner->next();
falseBody = parseStatement();
nodeFactory.setEndPositionFromNode(falseBody);
2014-10-16 12:08:54 +00:00
}
else
nodeFactory.setEndPositionFromNode(trueBody);
return nodeFactory.createNode<IfStatement>(condition, trueBody, falseBody);
}
ASTPointer<WhileStatement> Parser::parseWhileStatement()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::While);
expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
return nodeFactory.createNode<WhileStatement>(condition, body);
}
ASTPointer<ForStatement> Parser::parseForStatement()
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<Statement> initExpression;
ASTPointer<Expression> conditionExpression;
ASTPointer<ExpressionStatement> loopExpression;
expectToken(Token::For);
expectToken(Token::LParen);
// LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RParen?
if (m_scanner->getCurrentToken() != Token::Semicolon)
initExpression = parseSimpleStatement();
expectToken(Token::Semicolon);
if (m_scanner->getCurrentToken() != Token::Semicolon)
conditionExpression = parseExpression();
expectToken(Token::Semicolon);
if (m_scanner->getCurrentToken() != Token::RParen)
loopExpression = parseExpressionStatement();
expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
return nodeFactory.createNode<ForStatement>(initExpression,
conditionExpression,
loopExpression,
body);
}
ASTPointer<Statement> Parser::parseSimpleStatement()
{
// These two cases are very hard to distinguish:
// x[7 * 20 + 3] a; - x[7 * 20 + 3] = 9;
// In the first case, x is a type name, in the second it is the name of a variable.
2015-02-23 13:38:44 +00:00
switch (peekStatementType())
{
case LookAheadInfo::VariableDeclarationStatement:
return parseVariableDeclarationStatement();
2015-02-23 13:38:44 +00:00
case LookAheadInfo::ExpressionStatement:
return parseExpressionStatement();
2015-02-23 13:55:06 +00:00
default:
break;
2015-02-23 13:38:44 +00:00
}
// At this point, we have '(Identifier|ElementaryTypeName) "["'.
// We parse '(Identifier|ElementaryTypeName) ( "[" Expression "]" )+' and then decide whether to hand this over
// to ExpressionStatement or create a VariableDeclarationStatement out of it.
ASTPointer<PrimaryExpression> primary;
if (m_scanner->getCurrentToken() == Token::Identifier)
primary = parseIdentifier();
else
{
primary = ASTNodeFactory(*this).createNode<ElementaryTypeNameExpression>(m_scanner->getCurrentToken());
m_scanner->next();
}
vector<pair<ASTPointer<Expression>, SourceLocation>> indices;
solAssert(m_scanner->getCurrentToken() == Token::LBrack, "");
SourceLocation indexLocation = primary->getLocation();
do
{
expectToken(Token::LBrack);
ASTPointer<Expression> index;
if (m_scanner->getCurrentToken() != Token::RBrack)
index = parseExpression();
indexLocation.end = getEndPosition();
indices.push_back(make_pair(index, indexLocation));
expectToken(Token::RBrack);
}
while (m_scanner->getCurrentToken() == Token::LBrack);
if (m_scanner->getCurrentToken() == Token::Identifier || Token::isLocationSpecifier(m_scanner->getCurrentToken()))
2015-02-23 13:38:44 +00:00
return parseVariableDeclarationStatement(typeNameIndexAccessStructure(primary, indices));
else
2015-02-23 13:38:44 +00:00
return parseExpressionStatement(expressionFromIndexAccessStructure(primary, indices));
}
ASTPointer<VariableDeclarationStatement> Parser::parseVariableDeclarationStatement(
ASTPointer<TypeName> const& _lookAheadArrayType)
{
2015-01-29 13:35:28 +00:00
VarDeclParserOptions options;
options.allowVar = true;
options.allowInitialValue = true;
options.allowLocationSpecifier = true;
ASTPointer<VariableDeclaration> variable = parseVariableDeclaration(options, _lookAheadArrayType);
ASTNodeFactory nodeFactory(*this, variable);
return nodeFactory.createNode<VariableDeclarationStatement>(variable);
}
ASTPointer<ExpressionStatement> Parser::parseExpressionStatement(
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> const& _lookAheadIndexAccessStructure)
{
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> expression = parseExpression(_lookAheadIndexAccessStructure);
return ASTNodeFactory(*this, expression).createNode<ExpressionStatement>(expression);
}
ASTPointer<Expression> Parser::parseExpression(
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> const& _lookAheadIndexAccessStructure)
{
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> expression = parseBinaryExpression(4, _lookAheadIndexAccessStructure);
2014-10-16 12:08:54 +00:00
if (!Token::isAssignmentOp(m_scanner->getCurrentToken()))
return expression;
Token::Value assignmentOperator = expectAssignmentOperator();
ASTPointer<Expression> rightHandSide = parseExpression();
ASTNodeFactory nodeFactory(*this, expression);
nodeFactory.setEndPositionFromNode(rightHandSide);
return nodeFactory.createNode<Assignment>(expression, assignmentOperator, rightHandSide);
}
ASTPointer<Expression> Parser::parseBinaryExpression(int _minPrecedence,
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> const& _lookAheadIndexAccessStructure)
{
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> expression = parseUnaryExpression(_lookAheadIndexAccessStructure);
ASTNodeFactory nodeFactory(*this, expression);
2014-10-16 12:08:54 +00:00
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();
ASTPointer<Expression> right = parseBinaryExpression(precedence + 1);
nodeFactory.setEndPositionFromNode(right);
expression = nodeFactory.createNode<BinaryOperation>(expression, op, right);
}
return expression;
}
ASTPointer<Expression> Parser::parseUnaryExpression(
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> const& _lookAheadIndexAccessStructure)
{
2015-02-23 13:38:44 +00:00
ASTNodeFactory nodeFactory = _lookAheadIndexAccessStructure ?
ASTNodeFactory(*this, _lookAheadIndexAccessStructure) : ASTNodeFactory(*this);
Token::Value token = m_scanner->getCurrentToken();
2015-02-23 13:38:44 +00:00
if (!_lookAheadIndexAccessStructure && (Token::isUnaryOp(token) || Token::isCountOp(token)))
2014-10-16 12:08:54 +00:00
{
// prefix expression
m_scanner->next();
ASTPointer<Expression> subExpression = parseUnaryExpression();
nodeFactory.setEndPositionFromNode(subExpression);
return nodeFactory.createNode<UnaryOperation>(token, subExpression, true);
2014-10-16 12:08:54 +00:00
}
else
{
// potential postfix expression
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> subExpression = parseLeftHandSideExpression(_lookAheadIndexAccessStructure);
token = m_scanner->getCurrentToken();
2014-10-16 12:08:54 +00:00
if (!Token::isCountOp(token))
return subExpression;
nodeFactory.markEndPosition();
m_scanner->next();
return nodeFactory.createNode<UnaryOperation>(token, subExpression, false);
}
}
ASTPointer<Expression> Parser::parseLeftHandSideExpression(
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> const& _lookAheadIndexAccessStructure)
{
2015-02-23 13:38:44 +00:00
ASTNodeFactory nodeFactory = _lookAheadIndexAccessStructure ?
ASTNodeFactory(*this, _lookAheadIndexAccessStructure) : ASTNodeFactory(*this);
2015-01-13 17:12:19 +00:00
ASTPointer<Expression> expression;
2015-02-23 13:38:44 +00:00
if (_lookAheadIndexAccessStructure)
expression = _lookAheadIndexAccessStructure;
else if (m_scanner->getCurrentToken() == Token::New)
2015-01-13 17:12:19 +00:00
{
expectToken(Token::New);
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> contractName(parseIdentifier());
nodeFactory.setEndPositionFromNode(contractName);
2015-01-13 17:12:19 +00:00
expression = nodeFactory.createNode<NewExpression>(contractName);
}
else
expression = parsePrimaryExpression();
2014-10-16 12:08:54 +00:00
while (true)
{
switch (m_scanner->getCurrentToken())
{
case Token::LBrack:
{
m_scanner->next();
ASTPointer<Expression> index;
if (m_scanner->getCurrentToken() != Token::RBrack)
index = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexAccess>(expression, index);
}
2014-10-16 12:08:54 +00:00
break;
case Token::Period:
{
m_scanner->next();
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
}
2014-10-16 12:08:54 +00:00
break;
case Token::LParen:
{
m_scanner->next();
2015-01-29 17:26:00 +00:00
vector<ASTPointer<Expression>> arguments;
2015-02-03 20:25:08 +00:00
vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
2015-01-29 17:26:00 +00:00
expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names);
}
2014-10-16 12:08:54 +00:00
break;
default:
return expression;
}
}
}
ASTPointer<Expression> Parser::parsePrimaryExpression()
{
ASTNodeFactory nodeFactory(*this);
Token::Value token = m_scanner->getCurrentToken();
ASTPointer<Expression> expression;
2014-10-16 12:08:54 +00:00
switch (token)
{
case Token::TrueLiteral:
case Token::FalseLiteral:
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
case Token::Number:
2015-02-06 12:38:10 +00:00
if (Token::isEtherSubdenomination(m_scanner->peekNextToken()))
{
ASTPointer<ASTString> literal = getLiteralAndAdvance();
nodeFactory.markEndPosition();
Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->getCurrentToken());
m_scanner->next();
expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
break;
}
2015-03-04 16:35:23 +00:00
if (Token::isTimeSubdenomination(m_scanner->peekNextToken()))
{
ASTPointer<ASTString> literal = getLiteralAndAdvance();
nodeFactory.markEndPosition();
Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->getCurrentToken());
m_scanner->next();
expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
break;
}
2015-02-06 12:38:10 +00:00
// fall-through
case Token::StringLiteral:
nodeFactory.markEndPosition();
2015-02-06 12:38:10 +00:00
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
case Token::Identifier:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
break;
case Token::LParen:
{
m_scanner->next();
ASTPointer<Expression> expression = parseExpression();
expectToken(Token::RParen);
return expression;
}
default:
2014-10-16 12:08:54 +00:00
if (Token::isElementaryTypeName(token))
{
// used for casts
expression = nodeFactory.createNode<ElementaryTypeNameExpression>(token);
m_scanner->next();
2014-10-16 12:08:54 +00:00
}
else
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected primary expression."));
2014-10-16 21:49:45 +00:00
break;
2014-10-09 10:28:37 +00:00
}
return expression;
}
2015-01-29 17:26:00 +00:00
vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments()
{
2014-12-03 06:47:08 +00:00
vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
arguments.push_back(parseExpression());
while (m_scanner->getCurrentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
expectToken(Token::Comma);
arguments.push_back(parseExpression());
}
}
return arguments;
}
2015-02-03 20:25:08 +00:00
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::parseFunctionCallArguments()
2015-01-29 17:26:00 +00:00
{
2015-02-03 20:25:08 +00:00
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
2015-01-29 17:26:00 +00:00
Token::Value token = m_scanner->getCurrentToken();
if (token == Token::LBrace)
2015-01-29 17:26:00 +00:00
{
// call({arg1 : 1, arg2 : 2 })
expectToken(Token::LBrace);
while (m_scanner->getCurrentToken() != Token::RBrace)
2015-01-29 17:26:00 +00:00
{
2015-02-03 20:45:16 +00:00
ret.second.push_back(expectIdentifierToken());
expectToken(Token::Colon);
2015-02-03 20:25:08 +00:00
ret.first.push_back(parseExpression());
2015-01-29 17:26:00 +00:00
if (m_scanner->getCurrentToken() == Token::Comma)
expectToken(Token::Comma);
2015-01-29 17:26:00 +00:00
else
break;
}
expectToken(Token::RBrace);
2015-01-29 17:26:00 +00:00
}
else
2015-02-03 20:25:08 +00:00
ret.first = parseFunctionCallListArguments();
return ret;
2015-01-29 17:26:00 +00:00
}
2015-02-23 13:38:44 +00:00
Parser::LookAheadInfo Parser::peekStatementType() const
{
// Distinguish between variable declaration (and potentially assignment) and expression statement
// (which include assignments to other expressions and pre-declared variables).
// We have a variable declaration if we get a keyword that specifies a type name.
// If it is an identifier or an elementary type name followed by an identifier, we also have
// a variable declaration.
// If we get an identifier followed by a "[", it can be both ("type[9] a;" or "arr[9] = 7;").
// In all other cases, we have an expression statement.
Token::Value token(m_scanner->getCurrentToken());
bool mightBeTypeName = (Token::isElementaryTypeName(token) || token == Token::Identifier);
if (token == Token::Mapping || token == Token::Var)
2015-02-23 13:38:44 +00:00
return LookAheadInfo::VariableDeclarationStatement;
if (mightBeTypeName)
{
Token::Value next = m_scanner->peekNextToken();
if (next == Token::Identifier || Token::isLocationSpecifier(next))
return LookAheadInfo::VariableDeclarationStatement;
if (m_scanner->peekNextToken() == Token::LBrack)
return LookAheadInfo::IndexAccessStructure;
}
2015-02-23 13:38:44 +00:00
return LookAheadInfo::ExpressionStatement;
}
2015-02-23 13:38:44 +00:00
ASTPointer<TypeName> Parser::typeNameIndexAccessStructure(
ASTPointer<PrimaryExpression> const& _primary, vector<pair<ASTPointer<Expression>, SourceLocation>> const& _indices)
{
ASTNodeFactory nodeFactory(*this, _primary);
ASTPointer<TypeName> type;
if (auto identifier = dynamic_cast<Identifier const*>(_primary.get()))
type = nodeFactory.createNode<UserDefinedTypeName>(make_shared<ASTString>(identifier->getName()));
else if (auto typeName = dynamic_cast<ElementaryTypeNameExpression const*>(_primary.get()))
type = nodeFactory.createNode<ElementaryTypeName>(typeName->getTypeToken());
else
solAssert(false, "Invalid type name for array look-ahead.");
for (auto const& lengthExpression: _indices)
{
nodeFactory.setLocation(lengthExpression.second);
type = nodeFactory.createNode<ArrayTypeName>(type, lengthExpression.first);
}
return type;
}
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> Parser::expressionFromIndexAccessStructure(
ASTPointer<PrimaryExpression> const& _primary, vector<pair<ASTPointer<Expression>, SourceLocation>> const& _indices)
{
ASTNodeFactory nodeFactory(*this, _primary);
ASTPointer<Expression> expression(_primary);
for (auto const& index: _indices)
{
nodeFactory.setLocation(index.second);
expression = nodeFactory.createNode<IndexAccess>(expression, index.first);
}
return expression;
}
void Parser::expectToken(Token::Value _value)
{
2014-10-09 10:28:37 +00:00
if (m_scanner->getCurrentToken() != _value)
2014-12-03 06:47:08 +00:00
BOOST_THROW_EXCEPTION(createParserError(string("Expected token ") + string(Token::getName(_value))));
2014-10-09 10:28:37 +00:00
m_scanner->next();
}
Token::Value Parser::expectAssignmentOperator()
{
Token::Value op = m_scanner->getCurrentToken();
2014-10-16 12:08:54 +00:00
if (!Token::isAssignmentOp(op))
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected assignment operator"));
m_scanner->next();
return op;
}
ASTPointer<ASTString> Parser::expectIdentifierToken()
{
if (m_scanner->getCurrentToken() != Token::Identifier)
2014-10-23 17:22:30 +00:00
BOOST_THROW_EXCEPTION(createParserError("Expected identifier"));
return getLiteralAndAdvance();
}
ASTPointer<ASTString> Parser::getLiteralAndAdvance()
{
2014-12-03 06:47:08 +00:00
ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->getCurrentLiteral());
2014-10-09 10:28:37 +00:00
m_scanner->next();
return identifier;
}
2015-01-30 20:43:19 +00:00
ASTPointer<ParameterList> Parser::createEmptyParameterList()
{
ASTNodeFactory nodeFactory(*this);
nodeFactory.setLocationEmpty();
return nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
}
2014-12-03 06:47:08 +00:00
ParserError Parser::createParserError(string const& _description) const
{
return ParserError() << errinfo_sourceLocation(SourceLocation(getPosition(), getPosition(), getSourceName()))
<< errinfo_comment(_description);
}
2014-10-16 12:08:54 +00:00
}
}