solidity/libyul/ObjectParser.cpp

212 lines
6.0 KiB
C++

/*
This file is part of solidity.
solidity 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.
solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
*/
// SPDX-License-Identifier: GPL-3.0
/**
* Parser for Yul code and data object container.
*/
#include <libyul/AST.h>
#include <libyul/ObjectParser.h>
#include <libyul/AsmParser.h>
#include <libyul/Exceptions.h>
#include <liblangutil/Token.h>
#include <liblangutil/Scanner.h>
#include <libsolutil/StringUtils.h>
#include <regex>
using namespace std;
using namespace solidity;
using namespace solidity::yul;
using namespace solidity::util;
using namespace solidity::langutil;
shared_ptr<Object> ObjectParser::parse(shared_ptr<Scanner> const& _scanner, bool _reuseScanner)
{
m_recursionDepth = 0;
try
{
shared_ptr<Object> object;
m_scanner = _scanner;
m_sourceNameMapping = tryParseSourceNameMapping();
if (currentToken() == Token::LBrace)
{
// Special case: Code-only form.
object = make_shared<Object>();
object->name = "object"_yulstring;
object->code = parseBlock();
if (!object->code)
return nullptr;
}
else
object = parseObject();
if (object && !_reuseScanner)
expectToken(Token::EOS);
return object;
}
catch (FatalError const&)
{
if (m_errorReporter.errors().empty())
throw; // Something is weird here, rather throw again.
}
return nullptr;
}
shared_ptr<Object> ObjectParser::parseObject(Object* _containingObject)
{
RecursionGuard guard(*this);
if (currentToken() != Token::Identifier || currentLiteral() != "object")
fatalParserError(4294_error, "Expected keyword \"object\".");
advance();
shared_ptr<Object> ret = make_shared<Object>();
ret->name = parseUniqueName(_containingObject);
expectToken(Token::LBrace);
ret->code = parseCode();
while (currentToken() != Token::RBrace)
{
if (currentToken() == Token::Identifier && currentLiteral() == "object")
parseObject(ret.get());
else if (currentToken() == Token::Identifier && currentLiteral() == "data")
parseData(*ret);
else
fatalParserError(8143_error, "Expected keyword \"data\" or \"object\" or \"}\".");
}
if (_containingObject)
addNamedSubObject(*_containingObject, ret->name, ret);
expectToken(Token::RBrace);
return ret;
}
shared_ptr<Block> ObjectParser::parseCode()
{
if (currentToken() != Token::Identifier || currentLiteral() != "code")
fatalParserError(4846_error, "Expected keyword \"code\".");
advance();
return parseBlock();
}
optional<ObjectParser::SourceNameMap> ObjectParser::tryParseSourceNameMapping() const
{
// @use-src 0:"abc.sol", 1:"foo.sol", 2:"bar.sol"
//
// UseSrcList := UseSrc (',' UseSrc)*
// UseSrc := [0-9]+ ':' FileName
// FileName := "(([^\"]|\.)*)"
// Matches some "@use-src TEXT".
static std::regex const lineRE = std::regex(
"(^|\\s)@use-src\\b",
std::regex_constants::ECMAScript | std::regex_constants::optimize
);
std::smatch sm;
if (!std::regex_search(m_scanner->currentCommentLiteral(), sm, lineRE))
return nullopt;
solAssert(sm.size() == 2, "");
auto text = m_scanner->currentCommentLiteral().substr(static_cast<size_t>(sm.position() + sm.length()));
Scanner scanner(make_shared<CharStream>(text, ""));
if (scanner.currentToken() == Token::EOS)
return SourceNameMap{};
SourceNameMap sourceNames;
while (scanner.currentToken() != Token::EOS)
{
if (scanner.currentToken() != Token::Number)
break;
auto sourceIndex = toUnsignedInt(scanner.currentLiteral());
if (!sourceIndex)
break;
if (scanner.next() != Token::Colon)
break;
if (scanner.next() != Token::StringLiteral)
break;
sourceNames[*sourceIndex] = make_shared<string const>(scanner.currentLiteral());
Token const next = scanner.next();
if (next == Token::EOS)
return {move(sourceNames)};
if (next != Token::Comma)
break;
scanner.next();
}
m_errorReporter.syntaxError(
9804_error,
m_scanner->currentCommentLocation(),
"Error parsing arguments to @use-src. Expected: <number> \":\" \"<filename>\", ..."
);
return nullopt;
}
shared_ptr<Block> ObjectParser::parseBlock()
{
Parser parser(m_errorReporter, m_dialect, m_sourceNameMapping);
shared_ptr<Block> block = parser.parse(m_scanner, true);
yulAssert(block || m_errorReporter.hasErrors(), "Invalid block but no error!");
return block;
}
void ObjectParser::parseData(Object& _containingObject)
{
yulAssert(
currentToken() == Token::Identifier && currentLiteral() == "data",
"parseData called on wrong input."
);
advance();
YulString name = parseUniqueName(&_containingObject);
if (currentToken() == Token::HexStringLiteral)
expectToken(Token::HexStringLiteral, false);
else
expectToken(Token::StringLiteral, false);
addNamedSubObject(_containingObject, name, make_shared<Data>(name, asBytes(currentLiteral())));
advance();
}
YulString ObjectParser::parseUniqueName(Object const* _containingObject)
{
expectToken(Token::StringLiteral, false);
YulString name{currentLiteral()};
if (name.empty())
parserError(3287_error, "Object name cannot be empty.");
else if (_containingObject && _containingObject->name == name)
parserError(8311_error, "Object name cannot be the same as the name of the containing object.");
else if (_containingObject && _containingObject->subIndexByName.count(name))
parserError(8794_error, "Object name \"" + name.str() + "\" already exists inside the containing object.");
advance();
return name;
}
void ObjectParser::addNamedSubObject(Object& _container, YulString _name, shared_ptr<ObjectNode> _subObject)
{
_container.subIndexByName[_name] = _container.subObjects.size();
_container.subObjects.emplace_back(std::move(_subObject));
}