2017-11-28 11:45:37 +00:00
|
|
|
/*
|
|
|
|
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/>.
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* Creates an independent copy of an AST, renaming identifiers to be unique.
|
|
|
|
*/
|
|
|
|
|
2018-10-15 09:52:35 +00:00
|
|
|
#include <libyul/optimiser/ASTCopier.h>
|
2017-11-28 11:45:37 +00:00
|
|
|
|
2018-10-15 09:52:35 +00:00
|
|
|
#include <libyul/Exceptions.h>
|
2017-11-28 11:45:37 +00:00
|
|
|
|
2018-11-23 10:18:57 +00:00
|
|
|
#include <libyul/AsmData.h>
|
2017-11-28 11:45:37 +00:00
|
|
|
|
|
|
|
#include <libdevcore/Common.h>
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
using namespace dev;
|
2018-11-21 11:42:34 +00:00
|
|
|
using namespace yul;
|
2017-11-28 11:45:37 +00:00
|
|
|
|
2017-12-08 13:01:22 +00:00
|
|
|
Statement ASTCopier::operator()(ExpressionStatement const& _statement)
|
|
|
|
{
|
|
|
|
return ExpressionStatement{ _statement.location, translate(_statement.expression) };
|
|
|
|
}
|
|
|
|
|
2017-11-28 11:45:37 +00:00
|
|
|
Statement ASTCopier::operator()(VariableDeclaration const& _varDecl)
|
|
|
|
{
|
|
|
|
return VariableDeclaration{
|
|
|
|
_varDecl.location,
|
|
|
|
translateVector(_varDecl.variables),
|
|
|
|
translate(_varDecl.value)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(Assignment const& _assignment)
|
|
|
|
{
|
|
|
|
return Assignment{
|
|
|
|
_assignment.location,
|
|
|
|
translateVector(_assignment.variableNames),
|
|
|
|
translate(_assignment.value)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-12-08 13:01:22 +00:00
|
|
|
Expression ASTCopier::operator()(FunctionCall const& _call)
|
2017-11-28 11:45:37 +00:00
|
|
|
{
|
|
|
|
return FunctionCall{
|
|
|
|
_call.location,
|
|
|
|
translate(_call.functionName),
|
|
|
|
translateVector(_call.arguments)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-12-08 13:01:22 +00:00
|
|
|
Expression ASTCopier::operator()(Identifier const& _identifier)
|
2017-11-28 11:45:37 +00:00
|
|
|
{
|
2019-04-11 10:58:27 +00:00
|
|
|
return translate(_identifier);
|
2017-11-28 11:45:37 +00:00
|
|
|
}
|
|
|
|
|
2017-12-08 13:01:22 +00:00
|
|
|
Expression ASTCopier::operator()(Literal const& _literal)
|
2017-11-28 11:45:37 +00:00
|
|
|
{
|
|
|
|
return translate(_literal);
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(If const& _if)
|
|
|
|
{
|
|
|
|
return If{_if.location, translate(_if.condition), translate(_if.body)};
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(Switch const& _switch)
|
|
|
|
{
|
|
|
|
return Switch{_switch.location, translate(_switch.expression), translateVector(_switch.cases)};
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(FunctionDefinition const& _function)
|
|
|
|
{
|
2018-10-29 14:12:02 +00:00
|
|
|
YulString translatedName = translateIdentifier(_function.name);
|
2017-11-28 11:45:37 +00:00
|
|
|
|
|
|
|
enterFunction(_function);
|
|
|
|
ScopeGuard g([&]() { this->leaveFunction(_function); });
|
|
|
|
|
|
|
|
return FunctionDefinition{
|
|
|
|
_function.location,
|
2018-10-29 14:12:02 +00:00
|
|
|
translatedName,
|
2017-11-28 11:45:37 +00:00
|
|
|
translateVector(_function.parameters),
|
|
|
|
translateVector(_function.returnVariables),
|
|
|
|
translate(_function.body)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(ForLoop const& _forLoop)
|
|
|
|
{
|
|
|
|
enterScope(_forLoop.pre);
|
|
|
|
ScopeGuard g([&]() { this->leaveScope(_forLoop.pre); });
|
|
|
|
|
|
|
|
return ForLoop{
|
|
|
|
_forLoop.location,
|
|
|
|
translate(_forLoop.pre),
|
|
|
|
translate(_forLoop.condition),
|
|
|
|
translate(_forLoop.post),
|
|
|
|
translate(_forLoop.body)
|
|
|
|
};
|
|
|
|
}
|
2019-03-04 14:38:05 +00:00
|
|
|
Statement ASTCopier::operator()(Break const& _break)
|
|
|
|
{
|
|
|
|
return Break{ _break };
|
|
|
|
}
|
|
|
|
|
|
|
|
Statement ASTCopier::operator()(Continue const& _continue)
|
|
|
|
{
|
|
|
|
return Continue{ _continue };
|
|
|
|
}
|
2017-11-28 11:45:37 +00:00
|
|
|
|
2019-11-06 01:06:00 +00:00
|
|
|
Statement ASTCopier::operator()(Leave const& _leaveStatement)
|
2019-10-28 14:25:02 +00:00
|
|
|
{
|
2019-11-06 01:06:00 +00:00
|
|
|
return Leave{_leaveStatement};
|
2019-10-28 14:25:02 +00:00
|
|
|
}
|
|
|
|
|
2017-11-28 11:45:37 +00:00
|
|
|
Statement ASTCopier::operator ()(Block const& _block)
|
|
|
|
{
|
|
|
|
return translate(_block);
|
|
|
|
}
|
|
|
|
|
2017-12-08 13:01:22 +00:00
|
|
|
Expression ASTCopier::translate(Expression const& _expression)
|
|
|
|
{
|
|
|
|
return _expression.apply_visitor(static_cast<ExpressionCopier&>(*this));
|
|
|
|
}
|
|
|
|
|
2017-11-28 11:45:37 +00:00
|
|
|
Statement ASTCopier::translate(Statement const& _statement)
|
|
|
|
{
|
2017-12-08 13:01:22 +00:00
|
|
|
return _statement.apply_visitor(static_cast<StatementCopier&>(*this));
|
2017-11-28 11:45:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Block ASTCopier::translate(Block const& _block)
|
|
|
|
{
|
|
|
|
enterScope(_block);
|
|
|
|
ScopeGuard g([&]() { this->leaveScope(_block); });
|
|
|
|
|
|
|
|
return Block{_block.location, translateVector(_block.statements)};
|
|
|
|
}
|
|
|
|
|
|
|
|
Case ASTCopier::translate(Case const& _case)
|
|
|
|
{
|
|
|
|
return Case{_case.location, translate(_case.value), translate(_case.body)};
|
|
|
|
}
|
|
|
|
|
|
|
|
Identifier ASTCopier::translate(Identifier const& _identifier)
|
|
|
|
{
|
|
|
|
return Identifier{_identifier.location, translateIdentifier(_identifier.name)};
|
|
|
|
}
|
|
|
|
|
|
|
|
Literal ASTCopier::translate(Literal const& _literal)
|
|
|
|
{
|
|
|
|
return _literal;
|
|
|
|
}
|
|
|
|
|
|
|
|
TypedName ASTCopier::translate(TypedName const& _typedName)
|
|
|
|
{
|
|
|
|
return TypedName{_typedName.location, translateIdentifier(_typedName.name), _typedName.type};
|
|
|
|
}
|
|
|
|
|