2014-10-13 16:22:15 +00:00
|
|
|
/*
|
2014-10-16 12:08:54 +00:00
|
|
|
This file is part of cpp-ethereum.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
cpp-ethereum 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.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
cpp-ethereum 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.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2014-10-13 16:22:15 +00:00
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* @author Christian <c@ethdev.com>
|
|
|
|
* @date 2014
|
|
|
|
* Solidity data types
|
|
|
|
*/
|
|
|
|
|
2014-10-23 19:46:39 +00:00
|
|
|
#include <libdevcore/CommonIO.h>
|
2014-10-20 10:41:56 +00:00
|
|
|
#include <libdevcore/CommonData.h>
|
2014-10-13 16:22:15 +00:00
|
|
|
#include <libsolidity/Types.h>
|
|
|
|
#include <libsolidity/AST.h>
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
using namespace std;
|
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
namespace dev
|
|
|
|
{
|
|
|
|
namespace solidity
|
|
|
|
{
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
shared_ptr<Type> Type::fromElementaryTypeName(Token::Value _typeToken)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-05 13:20:56 +00:00
|
|
|
if (asserts(Token::isElementaryTypeName(_typeToken)))
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError());
|
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
if (Token::INT <= _typeToken && _typeToken <= Token::HASH256)
|
|
|
|
{
|
2014-10-13 16:22:15 +00:00
|
|
|
int offset = _typeToken - Token::INT;
|
2014-11-05 10:38:26 +00:00
|
|
|
int bytes = offset % 33;
|
|
|
|
if (bytes == 0)
|
|
|
|
bytes = 32;
|
|
|
|
int modifier = offset / 33;
|
|
|
|
return make_shared<IntegerType>(bytes * 8,
|
|
|
|
modifier == 0 ? IntegerType::Modifier::SIGNED :
|
|
|
|
modifier == 1 ? IntegerType::Modifier::UNSIGNED :
|
|
|
|
IntegerType::Modifier::HASH);
|
2014-10-16 12:08:54 +00:00
|
|
|
}
|
|
|
|
else if (_typeToken == Token::ADDRESS)
|
2014-11-04 12:24:35 +00:00
|
|
|
return make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS);
|
2014-10-16 12:08:54 +00:00
|
|
|
else if (_typeToken == Token::BOOL)
|
2014-11-04 12:24:35 +00:00
|
|
|
return make_shared<BoolType>();
|
2014-10-16 12:08:54 +00:00
|
|
|
else
|
2014-11-05 13:20:56 +00:00
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unable to convert elementary typename " +
|
|
|
|
std::string(Token::toString(_typeToken)) + " to type."));
|
2014-11-04 12:24:35 +00:00
|
|
|
return shared_ptr<Type>();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
shared_ptr<Type> Type::fromUserDefinedTypeName(UserDefinedTypeName const& _typeName)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-04 12:24:35 +00:00
|
|
|
return make_shared<StructType>(*_typeName.getReferencedStruct());
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
shared_ptr<Type> Type::fromMapping(Mapping const&)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-05 13:20:56 +00:00
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Mapping types not yet implemented."));
|
2014-11-04 12:24:35 +00:00
|
|
|
return shared_ptr<Type>();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
shared_ptr<Type> Type::forLiteral(Literal const& _literal)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-10-16 12:08:54 +00:00
|
|
|
switch (_literal.getToken())
|
|
|
|
{
|
2014-10-13 16:22:15 +00:00
|
|
|
case Token::TRUE_LITERAL:
|
|
|
|
case Token::FALSE_LITERAL:
|
2014-11-04 12:24:35 +00:00
|
|
|
return make_shared<BoolType>();
|
2014-10-13 16:22:15 +00:00
|
|
|
case Token::NUMBER:
|
|
|
|
return IntegerType::smallestTypeForLiteral(_literal.getValue());
|
|
|
|
case Token::STRING_LITERAL:
|
2014-11-04 12:24:35 +00:00
|
|
|
return shared_ptr<Type>(); // @todo
|
2014-10-13 16:22:15 +00:00
|
|
|
default:
|
2014-11-04 12:24:35 +00:00
|
|
|
return shared_ptr<Type>();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
shared_ptr<IntegerType> IntegerType::smallestTypeForLiteral(string const& _literal)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-04 12:24:35 +00:00
|
|
|
bigint value(_literal);
|
2014-11-05 07:40:21 +00:00
|
|
|
bool isSigned = value < 0 || (!_literal.empty() && _literal.front() == '-');
|
|
|
|
if (isSigned)
|
|
|
|
// convert to positive number of same bit requirements
|
|
|
|
value = ((-value) - 1) << 1;
|
2014-11-04 12:24:35 +00:00
|
|
|
unsigned bytes = max(bytesRequired(value), 1u);
|
|
|
|
if (bytes > 32)
|
|
|
|
return shared_ptr<IntegerType>();
|
2014-11-05 07:40:21 +00:00
|
|
|
return make_shared<IntegerType>(bytes * 8, isSigned ? Modifier::SIGNED : Modifier::UNSIGNED);
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-10-22 22:24:07 +00:00
|
|
|
IntegerType::IntegerType(int _bits, IntegerType::Modifier _modifier):
|
|
|
|
m_bits(_bits), m_modifier(_modifier)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
|
|
|
if (isAddress())
|
|
|
|
_bits = 160;
|
2014-11-05 13:20:56 +00:00
|
|
|
if (asserts(_bits > 0 && _bits <= 256 && _bits % 8 == 0))
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid bit number for integer type: " + dev::toString(_bits)));
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_convertTo.getCategory() != getCategory())
|
2014-10-13 16:22:15 +00:00
|
|
|
return false;
|
|
|
|
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
|
|
|
|
if (convertTo.m_bits < m_bits)
|
|
|
|
return false;
|
|
|
|
if (isAddress())
|
|
|
|
return convertTo.isAddress();
|
|
|
|
else if (isHash())
|
|
|
|
return convertTo.isHash();
|
|
|
|
else if (isSigned())
|
|
|
|
return convertTo.isSigned();
|
|
|
|
else
|
|
|
|
return !convertTo.isSigned() || convertTo.m_bits > m_bits;
|
|
|
|
}
|
|
|
|
|
2014-10-20 11:02:06 +00:00
|
|
|
bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-10-20 10:41:56 +00:00
|
|
|
return _convertTo.getCategory() == getCategory();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerType::acceptsBinaryOperator(Token::Value _operator) const
|
|
|
|
{
|
2014-10-16 12:08:54 +00:00
|
|
|
if (isAddress())
|
|
|
|
return Token::isCompareOp(_operator);
|
|
|
|
else if (isHash())
|
|
|
|
return Token::isCompareOp(_operator) || Token::isBitOp(_operator);
|
|
|
|
else
|
2014-10-15 13:54:41 +00:00
|
|
|
return true;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerType::acceptsUnaryOperator(Token::Value _operator) const
|
|
|
|
{
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_operator == Token::DELETE)
|
|
|
|
return true;
|
|
|
|
if (isAddress())
|
|
|
|
return false;
|
|
|
|
if (_operator == Token::BIT_NOT)
|
|
|
|
return true;
|
|
|
|
if (isHash())
|
|
|
|
return false;
|
|
|
|
return _operator == Token::ADD || _operator == Token::SUB ||
|
|
|
|
_operator == Token::INC || _operator == Token::DEC;
|
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool IntegerType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
IntegerType const& other = dynamic_cast<IntegerType const&>(_other);
|
|
|
|
return other.m_bits == m_bits && other.m_modifier == m_modifier;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
string IntegerType::toString() const
|
2014-10-16 15:57:27 +00:00
|
|
|
{
|
|
|
|
if (isAddress())
|
|
|
|
return "address";
|
2014-11-04 12:24:35 +00:00
|
|
|
string prefix = isHash() ? "hash" : (isSigned() ? "int" : "uint");
|
2014-10-16 15:57:27 +00:00
|
|
|
return prefix + dev::toString(m_bits);
|
|
|
|
}
|
|
|
|
|
2014-10-31 16:20:27 +00:00
|
|
|
u256 IntegerType::literalValue(Literal const& _literal) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
bigint value(_literal.getValue());
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(value);
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2014-10-20 11:02:06 +00:00
|
|
|
bool BoolType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-10-15 13:54:41 +00:00
|
|
|
// conversion to integer is fine, but not to address
|
|
|
|
// this is an example of explicit conversions being not transitive (though implicit should be)
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_convertTo.getCategory() == getCategory())
|
2014-10-16 12:08:54 +00:00
|
|
|
{
|
2014-10-15 13:54:41 +00:00
|
|
|
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
|
|
|
|
if (!convertTo.isAddress())
|
|
|
|
return true;
|
|
|
|
}
|
2014-10-13 16:22:15 +00:00
|
|
|
return isImplicitlyConvertibleTo(_convertTo);
|
|
|
|
}
|
|
|
|
|
2014-10-31 16:20:27 +00:00
|
|
|
u256 BoolType::literalValue(Literal const& _literal) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_literal.getToken() == Token::TRUE_LITERAL)
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(1);
|
2014-10-20 10:41:56 +00:00
|
|
|
else if (_literal.getToken() == Token::FALSE_LITERAL)
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(0);
|
2014-10-20 10:41:56 +00:00
|
|
|
else
|
2014-11-05 13:20:56 +00:00
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Bool type constructed from non-boolean literal."));
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool ContractType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
2014-10-13 16:22:15 +00:00
|
|
|
return false;
|
2014-10-20 10:41:56 +00:00
|
|
|
ContractType const& other = dynamic_cast<ContractType const&>(_other);
|
|
|
|
return other.m_contract == m_contract;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool StructType::operator==(Type const& _other) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_other.getCategory() != getCategory())
|
2014-10-13 16:22:15 +00:00
|
|
|
return false;
|
2014-10-20 10:41:56 +00:00
|
|
|
StructType const& other = dynamic_cast<StructType const&>(_other);
|
|
|
|
return other.m_struct == m_struct;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool FunctionType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
FunctionType const& other = dynamic_cast<FunctionType const&>(_other);
|
|
|
|
return other.m_function == m_function;
|
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool MappingType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
MappingType const& other = dynamic_cast<MappingType const&>(_other);
|
|
|
|
return *other.m_keyType == *m_keyType && *other.m_valueType == *m_valueType;
|
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool TypeType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
TypeType const& other = dynamic_cast<TypeType const&>(_other);
|
|
|
|
return *getActualType() == *other.getActualType();
|
|
|
|
}
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
}
|
|
|
|
}
|