Merge pull request #5416 from ethereum/develop

Merge develop into release for 0.5.0

1 files changed, 77 insertions, 0 deletions

diff --git a/libyul/optimiser/SyntacticalEquality.cpp b/libyul/optimiser/SyntacticalEquality.cpp
new file mode 100644
index 00000000..66912383
--- /dev/null
+++ b/libyul/optimiser/SyntacticalEquality.cpp
@@ -0,0 +1,77 @@
+/*(
+	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/>.
+*/
+/**
+ * Component that can compare ASTs for equality on a syntactic basis.
+ */
+
+#include <libyul/optimiser/SyntacticalEquality.h>
+
+#include <libyul/Exceptions.h>
+
+#include <libsolidity/inlineasm/AsmData.h>
+
+#include <libdevcore/CommonData.h>
+
+using namespace std;
+using namespace dev;
+using namespace dev::yul;
+
+bool SyntacticalEqualityChecker::equal(Expression const& _e1, Expression const& _e2)
+{
+	if (_e1.type() != _e2.type())
+		return false;
+	// TODO This somehow calls strcmp - WHERE?
+
+	// TODO This should be replaced by some kind of AST walker as soon as it gets
+	// more complex.
+	if (_e1.type() == typeid(FunctionalInstruction))
+	{
+		auto const& e1 = boost::get<FunctionalInstruction>(_e1);
+		auto const& e2 = boost::get<FunctionalInstruction>(_e2);
+		return
+			e1.instruction == e2.instruction &&
+			equalVector(e1.arguments, e2.arguments);
+	}
+	else if (_e1.type() == typeid(FunctionCall))
+	{
+		auto const& e1 = boost::get<FunctionCall>(_e1);
+		auto const& e2 = boost::get<FunctionCall>(_e2);
+		return
+			equal(e1.functionName, e2.functionName) &&
+			equalVector(e1.arguments, e2.arguments);
+	}
+	else if (_e1.type() == typeid(Identifier))
+		return boost::get<Identifier>(_e1).name == boost::get<Identifier>(_e2).name;
+	else if (_e1.type() == typeid(Literal))
+	{
+		auto const& e1 = boost::get<Literal>(_e1);
+		auto const& e2 = boost::get<Literal>(_e2);
+		return e1.kind == e2.kind && e1.value == e2.value && e1.type == e2.type;
+	}
+	else
+	{
+		assertThrow(false, OptimizerException, "Invalid expression");
+	}
+	return false;
+}
+
+bool SyntacticalEqualityChecker::equalVector(vector<Expression> const& _e1, vector<Expression> const& _e2)
+{
+	return _e1.size() == _e2.size() &&
+		std::equal(begin(_e1), end(_e1), begin(_e2), SyntacticalEqualityChecker::equal);
+
+}