Browse Source

SHA3 of string literals now should work

cl-refactor
Lefteris Karapetsas 10 years ago
parent
commit
8d239921e9
  1. 14
      libsolidity/AST.cpp
  2. 11
      libsolidity/ExpressionCompiler.cpp
  3. 2
      libsolidity/ExpressionCompiler.h
  4. 1
      libsolidity/Types.h
  5. 45
      test/SolidityEndToEndTest.cpp

14
libsolidity/AST.cpp

@ -493,19 +493,9 @@ void FunctionCall::checkTypeRequirements()
if (m_names.empty())
{
for (size_t i = 0; i < m_arguments.size(); ++i)
{
if (functionType->getLocation() == FunctionType::Location::SHA3)
{
#if 0 // are we sure we want that? Literal constant nums can't live outside storage and so sha3(42) will fail
if (!m_arguments[i]->getType()->canLiveOutsideStorage())
BOOST_THROW_EXCEPTION(createTypeError("SHA3 called with argument that can't live outside storage"));
#endif
if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[0]))
BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError("SHA3 argument can't be converted to hash"));
} else if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
if (functionType->getLocation() != FunctionType::Location::SHA3 &&
!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
BOOST_THROW_EXCEPTION(createTypeError("Invalid type for argument in function call."));
}
}
else if (functionType->getLocation() == FunctionType::Location::SHA3)
BOOST_THROW_EXCEPTION(createTypeError("Named arguments can't be used for SHA3."));

11
libsolidity/ExpressionCompiler.cpp

@ -851,22 +851,23 @@ unsigned ExpressionCompiler::appendArgumentsCopyToMemory(vector<ASTPointer<Expre
// without type conversion
for (unsigned i = 0; i < _arguments.size(); ++i)
{
bool wantPadding = (_arguments[i]->getType()->getCategory() == Type::Category::STRING) ? false : true;
_arguments[i]->accept(*this);
length += moveTypeToMemory(*_arguments[i]->getType()->getRealType(), _arguments[i]->getLocation(), _memoryOffset + length);
length += moveTypeToMemory(*_arguments[i]->getType()->getRealType(), _arguments[i]->getLocation(), _memoryOffset + length, wantPadding);
}
return length;
}
unsigned ExpressionCompiler::moveTypeToMemory(Type const& _type, Location const& _location, unsigned _memoryOffset)
unsigned ExpressionCompiler::moveTypeToMemory(Type const& _type, Location const& _location, unsigned _memoryOffset, bool _padToWordBoundaries)
{
unsigned const c_numBytes = CompilerUtils::getPaddedSize(_type.getCalldataEncodedSize());
unsigned const encodedSize = _type.getCalldataEncodedSize();
unsigned const c_numBytes = _padToWordBoundaries ? CompilerUtils::getPaddedSize(encodedSize) : encodedSize;
if (c_numBytes == 0 || c_numBytes > 32)
BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_sourceLocation(_location)
<< errinfo_comment("Type " + _type.toString() + " not yet supported."));
bool const c_leftAligned = _type.getCategory() == Type::Category::STRING;
bool const c_padToWords = true;
return CompilerUtils(m_context).storeInMemory(_memoryOffset, c_numBytes, c_leftAligned, c_padToWords);
return CompilerUtils(m_context).storeInMemory(_memoryOffset, c_numBytes, c_leftAligned, _padToWordBoundaries);
}
unsigned ExpressionCompiler::appendTypeConversionAndMoveToMemory(Type const& _expectedType, Type const& _type,

2
libsolidity/ExpressionCompiler.h

@ -103,7 +103,7 @@ private:
Location const& _location, unsigned _memoryOffset = 0);
/// Appends code that moves a type to memory
/// @returns the number of bytes copied to memory
unsigned moveTypeToMemory(Type const& _type, Location const& _location, unsigned _memoryOffset);
unsigned moveTypeToMemory(Type const& _type, Location const& _location, unsigned _memoryOffset, bool _padToWordBoundaries = true);
/// Appends code that evaluates a single expression and copies it to memory (with optional offset).
/// @returns the number of bytes copied to memory
unsigned appendExpressionCopyToMemory(Type const& _expectedType, Expression const& _expression,

1
libsolidity/Types.h

@ -249,6 +249,7 @@ public:
virtual std::string toString() const override { return "string" + dev::toString(m_bytes); }
virtual u256 literalValue(Literal const* _literal) const override;
virtual TypePointer getRealType() const override { return std::make_shared<StaticStringType>(m_bytes); }
int getNumBytes() const { return m_bytes; }

45
test/SolidityEndToEndTest.cpp

@ -2099,7 +2099,6 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments)
{
char const* sourceCode = R"(
contract c {
// function foo(uint a) returns (hash d)
function foo(uint a, uint b, uint c) returns (hash d)
{
d = sha3(a, b, c);
@ -2114,6 +2113,50 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments)
toBigEndian(u256(13)))));
}
BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_numeric_literals)
{
char const* sourceCode = R"(
contract c {
function foo(uint a, uint16 b) returns (hash d)
{
d = sha3(a, b, 145);
}
})";
compileAndRun(sourceCode);
BOOST_CHECK(callContractFunction("foo(uint256,uint16)", 10, 12) == encodeArgs(
dev::sha3(
toBigEndian(u256(10)) +
toBigEndian(u256(12)) +
toBigEndian(u256(145)))));
}
BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_string_literals)
{
char const* sourceCode = R"(
contract c {
function foo() returns (hash d)
{
d = sha3("foo");
}
function bar(uint a, uint16 b) returns (hash d)
{
d = sha3(a, b, 145, "foo");
}
})";
compileAndRun(sourceCode);
BOOST_CHECK(callContractFunction("foo()") == encodeArgs(dev::sha3("foo")));
#if 0 // work in progress
BOOST_CHECK(callContractFunction("bar(uint256,uint16)", 10, 12) == encodeArgs(
dev::sha3(
toBigEndian(u256(10)) +
toBigEndian(u256(12)) +
toBigEndian(u256(145)) +
asBytes("foo")))));
#endif
}
BOOST_AUTO_TEST_SUITE_END()
}

Loading…
Cancel
Save