From 5de93e6acb81b9a39c1e8f1772dde81d5131e7e3 Mon Sep 17 00:00:00 2001 From: liana Date: Fri, 23 Jan 2015 17:36:12 +0100 Subject: [PATCH 1/5] - added conversion for string/hash of equal sizes - added tests --- ExpressionCompiler.cpp | 30 ++++++++++++++++++++++++++++-- Types.cpp | 16 ++++++++++++++++ Types.h | 3 ++- 3 files changed, 46 insertions(+), 3 deletions(-) diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index 60c5c4ded..66ca2ec14 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -628,7 +628,33 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con return; Type::Category stackTypeCategory = _typeOnStack.getCategory(); Type::Category targetTypeCategory = _targetType.getCategory(); - if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT || + + if (stackTypeCategory == Type::Category::STRING && targetTypeCategory == Type::Category::INTEGER) + { + // conversion from string to hash. no need to clean the high bit + // only to shift right because of opposite alignment + IntegerType const& targetIntegerType = dynamic_cast(_targetType); + StaticStringType const& sourceStringType = dynamic_cast(_typeOnStack); + if (targetIntegerType.isHash()) + { + solAssert(targetIntegerType.getNumBits() == sourceStringType.getNumBytes() * 8, "The size should be the same."); + m_context << u256(std::pow(2, 256 - sourceStringType.getNumBytes() * 8)) << + eth::Instruction::SWAP1 << eth::Instruction::DIV; + } + } + else if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER) + { + // conversion from hash to string. no need to clean the high bit + // only to shift left because of opposite alignment + StaticStringType const& targetStringType = dynamic_cast(_targetType); + IntegerType const& sourceIntegerType = dynamic_cast(_typeOnStack); + if (sourceIntegerType.isHash()) + { + solAssert(sourceIntegerType.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); + m_context << u256(std::pow(2, 256 - sourceIntegerType.getNumBits())) << eth::Instruction::MUL; + } + } + else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT || stackTypeCategory == Type::Category::INTEGER_CONSTANT) { solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, ""); @@ -657,7 +683,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con } else if (stackTypeCategory == Type::Category::STRING) { - solAssert(targetTypeCategory == Type::Category::STRING, ""); + solAssert(targetTypeCategory == Type::Category::STRING || targetTypeCategory == Type::Category::INTEGER, "Invalid type conversion requested."); // nothing to do, strings are high-order-bit-aligned //@todo clear lower-order bytes if we allow explicit conversion to shorter strings } diff --git a/Types.cpp b/Types.cpp index 2446c513c..28f516218 100644 --- a/Types.cpp +++ b/Types.cpp @@ -140,6 +140,11 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const { + if (_convertTo.getCategory() == Category::STRING) + { + StaticStringType const& convertTo = dynamic_cast(_convertTo); + return isHash() && (m_bits == convertTo.getNumBytes() * 8); + } return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::CONTRACT; } @@ -367,6 +372,17 @@ bool StaticStringType::isImplicitlyConvertibleTo(Type const& _convertTo) const return convertTo.m_bytes >= m_bytes; } +bool StaticStringType::isExplicitlyConvertibleTo(Type const& _convertTo) const +{ + if (_convertTo.getCategory() == Category::INTEGER) + { + IntegerType const& convertTo = dynamic_cast(_convertTo); + if (convertTo.isHash() && (m_bytes * 8 == convertTo.getNumBits())) + return true; + } + return isImplicitlyConvertibleTo(_convertTo); +} + bool StaticStringType::operator==(Type const& _other) const { if (_other.getCategory() != getCategory()) diff --git a/Types.h b/Types.h index e6c99fe3b..e4742966f 100644 --- a/Types.h +++ b/Types.h @@ -233,9 +233,10 @@ public: /// if no type fits. static std::shared_ptr smallestTypeForLiteral(std::string const& _literal); - StaticStringType(int _bytes); + explicit StaticStringType(int _bytes); virtual bool isImplicitlyConvertibleTo(Type const& _convertTo) const override; + virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override; virtual bool operator==(Type const& _other) const override; virtual unsigned getCalldataEncodedSize() const override { return m_bytes; } From 3075fc598deebb17010c30f1d75eb170edaf83cd Mon Sep 17 00:00:00 2001 From: liana Date: Fri, 23 Jan 2015 18:09:46 +0100 Subject: [PATCH 2/5] - corrected assert --- ExpressionCompiler.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index 66ca2ec14..9d282c1cb 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -683,7 +683,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con } else if (stackTypeCategory == Type::Category::STRING) { - solAssert(targetTypeCategory == Type::Category::STRING || targetTypeCategory == Type::Category::INTEGER, "Invalid type conversion requested."); + solAssert(targetTypeCategory == Type::Category::STRING, "Invalid type conversion requested."); // nothing to do, strings are high-order-bit-aligned //@todo clear lower-order bytes if we allow explicit conversion to shorter strings } From ef885d0212cecb14a76d28d57581a57bc286efbd Mon Sep 17 00:00:00 2001 From: liana Date: Mon, 26 Jan 2015 13:24:16 +0100 Subject: [PATCH 3/5] - modifications according to PR review --- ExpressionCompiler.cpp | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index 9d282c1cb..2c3b4078e 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -629,17 +629,25 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con Type::Category stackTypeCategory = _typeOnStack.getCategory(); Type::Category targetTypeCategory = _targetType.getCategory(); - if (stackTypeCategory == Type::Category::STRING && targetTypeCategory == Type::Category::INTEGER) + if (stackTypeCategory == Type::Category::STRING) { - // conversion from string to hash. no need to clean the high bit - // only to shift right because of opposite alignment - IntegerType const& targetIntegerType = dynamic_cast(_targetType); - StaticStringType const& sourceStringType = dynamic_cast(_typeOnStack); - if (targetIntegerType.isHash()) + if (targetTypeCategory == Type::Category::INTEGER) { - solAssert(targetIntegerType.getNumBits() == sourceStringType.getNumBytes() * 8, "The size should be the same."); - m_context << u256(std::pow(2, 256 - sourceStringType.getNumBytes() * 8)) << - eth::Instruction::SWAP1 << eth::Instruction::DIV; + // conversion from string to hash. no need to clean the high bit + // only to shift right because of opposite alignment + IntegerType const& targetIntegerType = dynamic_cast(_targetType); + StaticStringType const& sourceStringType = dynamic_cast(_typeOnStack); + if (targetIntegerType.isHash()) + { + solAssert(targetIntegerType.getNumBits() == sourceStringType.getNumBytes() * 8, "The size should be the same."); + m_context << (u256(1) << 256 - sourceStringType.getNumBytes() * 8) << + eth::Instruction::SWAP1 << eth::Instruction::DIV; + } + } + else { + solAssert(targetTypeCategory == Type::Category::STRING, "Invalid type conversion requested."); + // nothing to do, strings are high-order-bit-aligned + //@todo clear lower-order bytes if we allow explicit conversion to shorter strings } } else if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER) @@ -651,7 +659,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con if (sourceIntegerType.isHash()) { solAssert(sourceIntegerType.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); - m_context << u256(std::pow(2, 256 - sourceIntegerType.getNumBits())) << eth::Instruction::MUL; + m_context << (u256(1) << 256 - sourceIntegerType.getNumBits()) << eth::Instruction::MUL; } } else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT || @@ -681,12 +689,6 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con appendHighBitsCleanup(targetType); } } - else if (stackTypeCategory == Type::Category::STRING) - { - solAssert(targetTypeCategory == Type::Category::STRING, "Invalid type conversion requested."); - // nothing to do, strings are high-order-bit-aligned - //@todo clear lower-order bytes if we allow explicit conversion to shorter strings - } else if (_typeOnStack != _targetType) // All other types should not be convertible to non-equal types. BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid type conversion requested.")); From 6ba82b14273d033571b4ea96a49603f2e1304ff0 Mon Sep 17 00:00:00 2001 From: liana Date: Tue, 27 Jan 2015 12:55:40 +0100 Subject: [PATCH 4/5] -redesigned appendTypeConversion function --- ExpressionCompiler.cpp | 72 ++++++++++++++++++++++-------------------- 1 file changed, 37 insertions(+), 35 deletions(-) diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index 2c3b4078e..630a5e911 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -636,11 +636,11 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con // conversion from string to hash. no need to clean the high bit // only to shift right because of opposite alignment IntegerType const& targetIntegerType = dynamic_cast(_targetType); - StaticStringType const& sourceStringType = dynamic_cast(_typeOnStack); + StaticStringType const& typeOnStack = dynamic_cast(_typeOnStack); if (targetIntegerType.isHash()) { - solAssert(targetIntegerType.getNumBits() == sourceStringType.getNumBytes() * 8, "The size should be the same."); - m_context << (u256(1) << 256 - sourceStringType.getNumBytes() * 8) << + solAssert(targetIntegerType.getNumBits() == typeOnStack.getNumBytes() * 8, "The size should be the same."); + m_context << (u256(1) << 256 - typeOnStack.getNumBytes() * 8) << eth::Instruction::SWAP1 << eth::Instruction::DIV; } } @@ -650,43 +650,45 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con //@todo clear lower-order bytes if we allow explicit conversion to shorter strings } } - else if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER) - { - // conversion from hash to string. no need to clean the high bit - // only to shift left because of opposite alignment - StaticStringType const& targetStringType = dynamic_cast(_targetType); - IntegerType const& sourceIntegerType = dynamic_cast(_typeOnStack); - if (sourceIntegerType.isHash()) - { - solAssert(sourceIntegerType.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); - m_context << (u256(1) << 256 - sourceIntegerType.getNumBits()) << eth::Instruction::MUL; - } - } else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT || stackTypeCategory == Type::Category::INTEGER_CONSTANT) { - solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, ""); - IntegerType addressType(0, IntegerType::Modifier::ADDRESS); - IntegerType const& targetType = targetTypeCategory == Type::Category::INTEGER - ? dynamic_cast(_targetType) : addressType; - if (stackTypeCategory == Type::Category::INTEGER_CONSTANT) + if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER) { - IntegerConstantType const& constType = dynamic_cast(_typeOnStack); - // We know that the stack is clean, we only have to clean for a narrowing conversion - // where cleanup is forced. - if (targetType.getNumBits() < constType.getIntegerType()->getNumBits() && _cleanupNeeded) - appendHighBitsCleanup(targetType); - } - else + // conversion from hash to string. no need to clean the high bit + // only to shift left because of opposite alignment + StaticStringType const& targetStringType = dynamic_cast(_targetType); + IntegerType const& typeOnStack = dynamic_cast(_typeOnStack); + if (typeOnStack.isHash()) + { + solAssert(typeOnStack.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); + m_context << (u256(1) << 256 - typeOnStack.getNumBits()) << eth::Instruction::MUL; + } + } else { - IntegerType const& typeOnStack = stackTypeCategory == Type::Category::INTEGER - ? dynamic_cast(_typeOnStack) : addressType; - // Widening: clean up according to source type width - // Non-widening and force: clean up according to target type bits - if (targetType.getNumBits() > typeOnStack.getNumBits()) - appendHighBitsCleanup(typeOnStack); - else if (_cleanupNeeded) - appendHighBitsCleanup(targetType); + solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, ""); + IntegerType addressType(0, IntegerType::Modifier::ADDRESS); + IntegerType const& targetType = targetTypeCategory == Type::Category::INTEGER + ? dynamic_cast(_targetType) : addressType; + if (stackTypeCategory == Type::Category::INTEGER_CONSTANT) + { + IntegerConstantType const& constType = dynamic_cast(_typeOnStack); + // We know that the stack is clean, we only have to clean for a narrowing conversion + // where cleanup is forced. + if (targetType.getNumBits() < constType.getIntegerType()->getNumBits() && _cleanupNeeded) + appendHighBitsCleanup(targetType); + } + else + { + IntegerType const& typeOnStack = stackTypeCategory == Type::Category::INTEGER + ? dynamic_cast(_typeOnStack) : addressType; + // Widening: clean up according to source type width + // Non-widening and force: clean up according to target type bits + if (targetType.getNumBits() > typeOnStack.getNumBits()) + appendHighBitsCleanup(typeOnStack); + else if (_cleanupNeeded) + appendHighBitsCleanup(targetType); + } } } else if (_typeOnStack != _targetType) From cad3d87482464017870080c54e3392bc5503ab20 Mon Sep 17 00:00:00 2001 From: liana Date: Tue, 27 Jan 2015 13:21:20 +0100 Subject: [PATCH 5/5] - cosmetic changes --- ExpressionCompiler.cpp | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index 630a5e911..bd8c86531 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -637,14 +637,12 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con // only to shift right because of opposite alignment IntegerType const& targetIntegerType = dynamic_cast(_targetType); StaticStringType const& typeOnStack = dynamic_cast(_typeOnStack); - if (targetIntegerType.isHash()) - { - solAssert(targetIntegerType.getNumBits() == typeOnStack.getNumBytes() * 8, "The size should be the same."); - m_context << (u256(1) << 256 - typeOnStack.getNumBytes() * 8) << - eth::Instruction::SWAP1 << eth::Instruction::DIV; - } + solAssert(targetIntegerType.isHash(), "Only conversion between String and Hash is allowed."); + solAssert(targetIntegerType.getNumBits() == typeOnStack.getNumBytes() * 8, "The size should be the same."); + m_context << (u256(1) << (256 - typeOnStack.getNumBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV; } - else { + else + { solAssert(targetTypeCategory == Type::Category::STRING, "Invalid type conversion requested."); // nothing to do, strings are high-order-bit-aligned //@todo clear lower-order bytes if we allow explicit conversion to shorter strings @@ -659,17 +657,16 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con // only to shift left because of opposite alignment StaticStringType const& targetStringType = dynamic_cast(_targetType); IntegerType const& typeOnStack = dynamic_cast(_typeOnStack); - if (typeOnStack.isHash()) - { - solAssert(typeOnStack.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); - m_context << (u256(1) << 256 - typeOnStack.getNumBits()) << eth::Instruction::MUL; - } - } else + solAssert(typeOnStack.isHash(), "Only conversion between String and Hash is allowed."); + solAssert(typeOnStack.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same."); + m_context << (u256(1) << (256 - typeOnStack.getNumBits())) << eth::Instruction::MUL; + } + else { solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, ""); IntegerType addressType(0, IntegerType::Modifier::ADDRESS); IntegerType const& targetType = targetTypeCategory == Type::Category::INTEGER - ? dynamic_cast(_targetType) : addressType; + ? dynamic_cast(_targetType) : addressType; if (stackTypeCategory == Type::Category::INTEGER_CONSTANT) { IntegerConstantType const& constType = dynamic_cast(_typeOnStack); @@ -681,7 +678,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con else { IntegerType const& typeOnStack = stackTypeCategory == Type::Category::INTEGER - ? dynamic_cast(_typeOnStack) : addressType; + ? dynamic_cast(_typeOnStack) : addressType; // Widening: clean up according to source type width // Non-widening and force: clean up according to target type bits if (targetType.getNumBits() > typeOnStack.getNumBits())