solidity/libsolidity/ast/Types.cpp

2557 lines
74 KiB
C++
Raw Normal View History

2014-10-13 16:22:15 +00:00
/*
This file is part of solidity.
2014-10-13 16:22:15 +00:00
solidity is free software: you can redistribute it and/or modify
2014-10-16 12:08:54 +00:00
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
solidity is distributed in the hope that it will be useful,
2014-10-16 12:08:54 +00:00
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 solidity. 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
*/
2015-10-20 22:21:52 +00:00
#include <libsolidity/ast/Types.h>
#include <limits>
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/adaptor/sliced.hpp>
2014-10-23 19:46:39 +00:00
#include <libdevcore/CommonIO.h>
2014-10-20 10:41:56 +00:00
#include <libdevcore/CommonData.h>
#include <libdevcore/SHA3.h>
#include <libdevcore/UTF8.h>
2015-10-20 22:21:52 +00:00
#include <libsolidity/interface/Utils.h>
#include <libsolidity/ast/AST.h>
2014-10-13 16:22:15 +00:00
using namespace std;
2015-06-30 19:08:34 +00:00
using namespace dev;
using namespace dev::solidity;
2014-10-13 16:22:15 +00:00
2015-03-13 18:48:24 +00:00
void StorageOffsets::computeOffsets(TypePointers const& _types)
2015-03-13 09:52:34 +00:00
{
2015-03-13 18:48:24 +00:00
bigint slotOffset = 0;
unsigned byteOffset = 0;
map<size_t, pair<u256, unsigned>> offsets;
for (size_t i = 0; i < _types.size(); ++i)
2015-03-13 09:52:34 +00:00
{
2015-03-13 18:48:24 +00:00
TypePointer const& type = _types[i];
if (!type->canBeStored())
continue;
2015-08-31 16:44:29 +00:00
if (byteOffset + type->storageBytes() > 32)
2015-03-13 09:52:34 +00:00
{
2015-03-13 18:48:24 +00:00
// would overflow, go to next slot
2015-03-13 09:52:34 +00:00
++slotOffset;
2015-03-13 18:48:24 +00:00
byteOffset = 0;
}
2015-03-13 09:52:34 +00:00
if (slotOffset >= bigint(1) << 256)
BOOST_THROW_EXCEPTION(Error(Error::Type::TypeError) << errinfo_comment("Object too large for storage."));
2015-03-13 18:48:24 +00:00
offsets[i] = make_pair(u256(slotOffset), byteOffset);
2015-08-31 16:44:29 +00:00
solAssert(type->storageSize() >= 1, "Invalid storage size.");
if (type->storageSize() == 1 && byteOffset + type->storageBytes() <= 32)
byteOffset += type->storageBytes();
2015-03-13 18:48:24 +00:00
else
{
2015-08-31 16:44:29 +00:00
slotOffset += type->storageSize();
2015-03-13 18:48:24 +00:00
byteOffset = 0;
}
2015-03-13 09:52:34 +00:00
}
2015-03-13 18:48:24 +00:00
if (byteOffset > 0)
++slotOffset;
if (slotOffset >= bigint(1) << 256)
BOOST_THROW_EXCEPTION(Error(Error::Type::TypeError) << errinfo_comment("Object too large for storage."));
2015-03-13 18:48:24 +00:00
m_storageSize = u256(slotOffset);
swap(m_offsets, offsets);
}
2015-08-31 16:44:29 +00:00
pair<u256, unsigned> const* StorageOffsets::offset(size_t _index) const
2015-03-13 18:48:24 +00:00
{
if (m_offsets.count(_index))
return &m_offsets.at(_index);
2015-03-13 09:52:34 +00:00
else
return nullptr;
}
2015-03-16 18:00:09 +00:00
MemberList& MemberList::operator=(MemberList&& _other)
{
assert(&_other != this);
2016-02-18 12:29:02 +00:00
m_memberTypes = move(_other.m_memberTypes);
m_storageOffsets = move(_other.m_storageOffsets);
2015-03-16 18:27:53 +00:00
return *this;
2015-03-16 18:00:09 +00:00
}
2015-11-25 13:23:35 +00:00
void MemberList::combine(MemberList const & _other)
{
m_memberTypes += _other.m_memberTypes;
}
2016-02-18 12:29:02 +00:00
pair<u256, unsigned> const* MemberList::memberStorageOffset(string const& _name) const
2015-03-13 18:48:24 +00:00
{
if (!m_storageOffsets)
{
TypePointers memberTypes;
memberTypes.reserve(m_memberTypes.size());
for (auto const& member: m_memberTypes)
memberTypes.push_back(member.type);
2015-03-13 18:48:24 +00:00
m_storageOffsets.reset(new StorageOffsets());
m_storageOffsets->computeOffsets(memberTypes);
}
for (size_t index = 0; index < m_memberTypes.size(); ++index)
if (m_memberTypes[index].name == _name)
2015-08-31 16:44:29 +00:00
return m_storageOffsets->offset(index);
2015-03-13 18:48:24 +00:00
return nullptr;
}
2015-08-31 16:44:29 +00:00
u256 const& MemberList::storageSize() const
2015-03-13 09:52:34 +00:00
{
// trigger lazy computation
2015-08-31 16:44:29 +00:00
memberStorageOffset("");
return m_storageOffsets->storageSize();
2015-03-13 09:52:34 +00:00
}
TypePointer Type::fromElementaryTypeName(ElementaryTypeNameToken const& _type)
2014-10-13 16:22:15 +00:00
{
solAssert(Token::isElementaryTypeName(_type.token()),
"Expected an elementary type name but got " + _type.toString()
);
2014-11-05 13:20:56 +00:00
Token::Value token = _type.token();
2016-05-10 09:15:41 +00:00
unsigned m = _type.firstNumber();
unsigned n = _type.secondNumber();
switch (token)
2014-10-16 12:08:54 +00:00
{
case Token::IntM:
return make_shared<IntegerType>(m, IntegerType::Modifier::Signed);
case Token::UIntM:
return make_shared<IntegerType>(m, IntegerType::Modifier::Unsigned);
case Token::BytesM:
return make_shared<FixedBytesType>(m);
case Token::FixedMxN:
return make_shared<FixedPointType>(m, n, FixedPointType::Modifier::Signed);
case Token::UFixedMxN:
return make_shared<FixedPointType>(m, n, FixedPointType::Modifier::Unsigned);
case Token::Int:
return make_shared<IntegerType>(256, IntegerType::Modifier::Signed);
case Token::UInt:
return make_shared<IntegerType>(256, IntegerType::Modifier::Unsigned);
case Token::Fixed:
return make_shared<FixedPointType>(128, 128, FixedPointType::Modifier::Signed);
case Token::UFixed:
return make_shared<FixedPointType>(128, 128, FixedPointType::Modifier::Unsigned);
case Token::Byte:
2015-03-11 16:41:12 +00:00
return make_shared<FixedBytesType>(1);
case Token::Address:
return make_shared<IntegerType>(0, IntegerType::Modifier::Address);
case Token::Bool:
return make_shared<BoolType>();
case Token::Bytes:
2015-06-17 10:01:39 +00:00
return make_shared<ArrayType>(DataLocation::Storage);
case Token::String:
2015-06-17 10:01:39 +00:00
return make_shared<ArrayType>(DataLocation::Storage, true);
//no types found
default:
2015-06-17 10:01:39 +00:00
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment(
"Unable to convert elementary typename " + _type.toString() + " to type."
2015-06-17 10:01:39 +00:00
));
}
2014-10-13 16:22:15 +00:00
}
2015-02-10 16:53:43 +00:00
TypePointer Type::fromElementaryTypeName(string const& _name)
{
unsigned short firstNum;
unsigned short secondNum;
Token::Value token;
tie(token, firstNum, secondNum) = Token::fromIdentifierOrKeyword(_name);
return fromElementaryTypeName(ElementaryTypeNameToken(token, firstNum, secondNum));
2015-02-10 16:53:43 +00:00
}
TypePointer Type::forLiteral(Literal const& _literal)
2014-10-13 16:22:15 +00:00
{
2015-08-31 16:44:29 +00:00
switch (_literal.token())
2014-10-16 12:08:54 +00:00
{
case Token::TrueLiteral:
case Token::FalseLiteral:
return make_shared<BoolType>();
case Token::Number:
{
tuple<bool, rational> validLiteral = RationalNumberType::isValidLiteral(_literal);
if (get<0>(validLiteral) == true)
return make_shared<RationalNumberType>(get<1>(validLiteral));
else
2016-05-10 10:42:38 +00:00
return TypePointer();
}
case Token::StringLiteral:
return make_shared<StringLiteralType>(_literal);
2014-10-13 16:22:15 +00:00
default:
2016-05-10 10:42:38 +00:00
return TypePointer();
2014-10-13 16:22:15 +00:00
}
}
TypePointer Type::commonType(TypePointer const& _a, TypePointer const& _b)
{
2016-10-21 10:30:58 +00:00
if (!_a || !_b)
return TypePointer();
else if (_b->isImplicitlyConvertibleTo(*_a->mobileType()))
return _a->mobileType();
else if (_a->isImplicitlyConvertibleTo(*_b->mobileType()))
return _b->mobileType();
else
return TypePointer();
}
2015-11-25 13:23:35 +00:00
MemberList const& Type::members(ContractDefinition const* _currentScope) const
{
if (!m_members[_currentScope])
{
MemberList::MemberMap members = nativeMembers(_currentScope);
if (_currentScope)
members += boundFunctions(*this, *_currentScope);
2015-11-25 13:23:35 +00:00
m_members[_currentScope] = unique_ptr<MemberList>(new MemberList(move(members)));
}
return *m_members[_currentScope];
}
MemberList::MemberMap Type::boundFunctions(Type const& _type, ContractDefinition const& _scope)
{
// Normalise data location of type.
TypePointer type = ReferenceType::copyForLocationIfReference(DataLocation::Storage, _type.shared_from_this());
set<Declaration const*> seenFunctions;
MemberList::MemberMap members;
for (ContractDefinition const* contract: _scope.annotation().linearizedBaseContracts)
for (UsingForDirective const* ufd: contract->usingForDirectives())
{
if (ufd->typeName() && *type != *ReferenceType::copyForLocationIfReference(
DataLocation::Storage,
ufd->typeName()->annotation().type
))
continue;
auto const& library = dynamic_cast<ContractDefinition const&>(
*ufd->libraryName().annotation().referencedDeclaration
);
for (FunctionDefinition const* function: library.definedFunctions())
2015-11-25 13:23:35 +00:00
{
if (!function->isVisibleInDerivedContracts() || seenFunctions.count(function))
2015-11-25 13:23:35 +00:00
continue;
seenFunctions.insert(function);
FunctionType funType(*function, false);
2015-11-25 13:23:35 +00:00
if (auto fun = funType.asMemberFunction(true, true))
2016-10-14 18:30:38 +00:00
if (_type.isImplicitlyConvertibleTo(*fun->selfType()))
members.push_back(MemberList::Member(function->name(), fun, function));
2015-11-25 13:23:35 +00:00
}
}
return members;
}
2014-11-20 09:19:43 +00:00
bool isValidShiftAndAmountType(Token::Value _operator, Type const& _shiftAmountType)
{
// Disable >>> here.
if (_operator == Token::SHR)
return false;
else if (IntegerType const* otherInt = dynamic_cast<decltype(otherInt)>(&_shiftAmountType))
return !otherInt->isAddress();
else if (RationalNumberType const* otherRat = dynamic_cast<decltype(otherRat)>(&_shiftAmountType))
return otherRat->integerType() && !otherRat->integerType()->isSigned();
else
return false;
}
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())
2014-11-07 16:34:15 +00:00
m_bits = 160;
2016-02-18 12:29:02 +00:00
solAssert(
m_bits > 0 && m_bits <= 256 && m_bits % 8 == 0,
"Invalid bit number for integer type: " + dev::toString(_bits)
);
2014-10-13 16:22:15 +00:00
}
bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{
if (_convertTo.category() == category())
2016-05-10 10:42:38 +00:00
{
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
if (convertTo.m_bits < m_bits)
return false;
if (isAddress())
return convertTo.isAddress();
else if (isSigned())
return convertTo.isSigned();
else
return !convertTo.isSigned() || convertTo.m_bits > m_bits;
}
else if (_convertTo.category() == Category::FixedPoint)
{
FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);
if (convertTo.integerBits() < m_bits || isAddress())
return false;
else if (isSigned())
return convertTo.isSigned();
else
return !convertTo.isSigned() || convertTo.integerBits() > m_bits;
}
2014-10-13 16:22:15 +00:00
else
return false;
2014-10-13 16:22:15 +00:00
}
bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
2014-10-13 16:22:15 +00:00
{
2015-08-31 16:44:29 +00:00
return _convertTo.category() == category() ||
_convertTo.category() == Category::Contract ||
_convertTo.category() == Category::Enum ||
_convertTo.category() == Category::FixedBytes ||
_convertTo.category() == Category::FixedPoint;
2014-10-13 16:22:15 +00:00
}
TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const
2014-10-13 16:22:15 +00:00
{
// "delete" is ok for all integer types
if (_operator == Token::Delete)
return make_shared<TupleType>();
// no further unary operators for addresses
else if (isAddress())
return TypePointer();
// for non-address integers, we allow +, -, ++ and --
else if (_operator == Token::Add || _operator == Token::Sub ||
2015-03-04 16:35:23 +00:00
_operator == Token::Inc || _operator == Token::Dec ||
2016-08-09 14:27:50 +00:00
_operator == Token::BitNot)
return shared_from_this();
else
return TypePointer();
2014-10-20 10:41:56 +00:00
}
2014-10-29 18:28:30 +00:00
bool IntegerType::operator==(Type const& _other) const
2014-10-20 10:41:56 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-10-20 10:41:56 +00:00
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
}
string IntegerType::toString(bool) const
2014-10-16 15:57:27 +00:00
{
if (isAddress())
return "address";
string prefix = isSigned() ? "int" : "uint";
2014-10-16 15:57:27 +00:00
return prefix + dev::toString(m_bits);
}
TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{
2016-05-13 03:10:49 +00:00
if (
_other->category() != Category::RationalNumber &&
_other->category() != Category::FixedPoint &&
_other->category() != category()
)
return TypePointer();
if (Token::isShiftOp(_operator))
{
// Shifts are not symmetric with respect to the type
if (isAddress())
return TypePointer();
if (isValidShiftAndAmountType(_operator, *_other))
return shared_from_this();
else
return TypePointer();
}
auto commonType = Type::commonType(shared_from_this(), _other); //might be a integer or fixed point
if (!commonType)
return TypePointer();
// All integer types can be compared
if (Token::isCompareOp(_operator))
return commonType;
if (Token::isBooleanOp(_operator))
return TypePointer();
if (auto intType = dynamic_pointer_cast<IntegerType const>(commonType))
2016-05-18 20:53:36 +00:00
{
2016-10-24 18:12:31 +00:00
// Nothing else can be done with addresses
if (intType->isAddress())
return TypePointer();
2016-10-24 18:12:31 +00:00
// Signed EXP is not allowed
if (Token::Exp == _operator && intType->isSigned())
return TypePointer();
2016-05-18 20:53:36 +00:00
}
else if (auto fixType = dynamic_pointer_cast<FixedPointType const>(commonType))
if (Token::Exp == _operator)
return TypePointer();
return commonType;
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap IntegerType::nativeMembers(ContractDefinition const*) const
{
if (isAddress())
return {
{"balance", make_shared<IntegerType >(256)},
{"call", make_shared<FunctionType>(strings(), strings{"bool"}, FunctionType::Location::Bare, true, false, true)},
{"callcode", make_shared<FunctionType>(strings(), strings{"bool"}, FunctionType::Location::BareCallCode, true, false, true)},
{"delegatecall", make_shared<FunctionType>(strings(), strings{"bool"}, FunctionType::Location::BareDelegateCall, true)},
2015-11-25 13:23:35 +00:00
{"send", make_shared<FunctionType>(strings{"uint"}, strings{"bool"}, FunctionType::Location::Send)}
};
else
return MemberList::MemberMap();
}
2014-11-21 18:14:56 +00:00
FixedPointType::FixedPointType(int _integerBits, int _fractionalBits, FixedPointType::Modifier _modifier):
m_integerBits(_integerBits), m_fractionalBits(_fractionalBits), m_modifier(_modifier)
{
solAssert(
m_integerBits + m_fractionalBits > 0 &&
m_integerBits + m_fractionalBits <= 256 &&
m_integerBits % 8 == 0 &&
m_fractionalBits % 8 == 0,
"Invalid bit number(s) for fixed type: " +
dev::toString(_integerBits) + "x" + dev::toString(_fractionalBits)
);
}
bool FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{
if (_convertTo.category() == category())
{
FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);
if (convertTo.m_integerBits < m_integerBits || convertTo.m_fractionalBits < m_fractionalBits)
return false;
else if (isSigned())
return convertTo.isSigned();
else
return !convertTo.isSigned() || (convertTo.m_integerBits > m_integerBits);
}
return false;
}
bool FixedPointType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{
return _convertTo.category() == category() ||
_convertTo.category() == Category::Integer ||
_convertTo.category() == Category::FixedBytes;
}
TypePointer FixedPointType::unaryOperatorResult(Token::Value _operator) const
{
// "delete" is ok for all fixed types
if (_operator == Token::Delete)
return make_shared<TupleType>();
// for fixed, we allow +, -, ++ and --
else if (
_operator == Token::Add ||
_operator == Token::Sub ||
_operator == Token::Inc ||
2016-08-09 14:27:50 +00:00
_operator == Token::Dec
)
return shared_from_this();
else
return TypePointer();
}
bool FixedPointType::operator==(Type const& _other) const
{
if (_other.category() != category())
return false;
FixedPointType const& other = dynamic_cast<FixedPointType const&>(_other);
return other.m_integerBits == m_integerBits && other.m_fractionalBits == m_fractionalBits && other.m_modifier == m_modifier;
}
string FixedPointType::toString(bool) const
{
string prefix = isSigned() ? "fixed" : "ufixed";
return prefix + dev::toString(m_integerBits) + "x" + dev::toString(m_fractionalBits);
}
TypePointer FixedPointType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{
if (
2016-05-18 20:53:36 +00:00
_other->category() != Category::RationalNumber &&
_other->category() != category() &&
_other->category() != Category::Integer
)
return TypePointer();
auto commonType = Type::commonType(shared_from_this(), _other); //might be fixed point or integer
if (!commonType)
return TypePointer();
// All fixed types can be compared
if (Token::isCompareOp(_operator))
return commonType;
if (Token::isBitOp(_operator) || Token::isBooleanOp(_operator))
return TypePointer();
if (auto fixType = dynamic_pointer_cast<FixedPointType const>(commonType))
2016-05-18 20:53:36 +00:00
{
if (Token::Exp == _operator)
return TypePointer();
2016-05-18 20:53:36 +00:00
}
else if (auto intType = dynamic_pointer_cast<IntegerType const>(commonType))
if (intType->isAddress())
return TypePointer();
return commonType;
}
tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)
{
rational x;
try
{
rational numerator;
rational denominator(1);
auto radixPoint = find(_literal.value().begin(), _literal.value().end(), '.');
if (radixPoint != _literal.value().end())
{
if (
!all_of(radixPoint + 1, _literal.value().end(), ::isdigit) ||
!all_of(_literal.value().begin(), radixPoint, ::isdigit)
)
2016-10-20 09:33:17 +00:00
return make_tuple(false, rational(0));
//Only decimal notation allowed here, leading zeros would switch to octal.
2016-05-10 10:42:38 +00:00
auto fractionalBegin = find_if_not(
radixPoint + 1,
_literal.value().end(),
[](char const& a) { return a == '0'; }
);
denominator = bigint(string(fractionalBegin, _literal.value().end()));
denominator /= boost::multiprecision::pow(
bigint(10),
distance(radixPoint + 1, _literal.value().end())
);
numerator = bigint(string(_literal.value().begin(), radixPoint));
x = numerator + denominator;
}
else
x = bigint(_literal.value());
}
catch (...)
2015-02-06 12:38:10 +00:00
{
return make_tuple(false, rational(0));
2015-02-06 12:38:10 +00:00
}
switch (_literal.subDenomination())
{
case Literal::SubDenomination::None:
case Literal::SubDenomination::Wei:
case Literal::SubDenomination::Second:
break;
case Literal::SubDenomination::Szabo:
x *= bigint("1000000000000");
break;
case Literal::SubDenomination::Finney:
x *= bigint("1000000000000000");
break;
case Literal::SubDenomination::Ether:
x *= bigint("1000000000000000000");
break;
case Literal::SubDenomination::Minute:
x *= bigint("60");
break;
case Literal::SubDenomination::Hour:
x *= bigint("3600");
break;
case Literal::SubDenomination::Day:
x *= bigint("86400");
break;
case Literal::SubDenomination::Week:
x *= bigint("604800");
break;
case Literal::SubDenomination::Year:
x *= bigint("31536000");
break;
}
return make_tuple(true, x);
2014-12-19 10:31:17 +00:00
}
bool RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo) const
2014-12-19 10:31:17 +00:00
{
if (_convertTo.category() == Category::Integer)
{
auto targetType = dynamic_cast<IntegerType const*>(&_convertTo);
if (m_value == 0)
return true;
2016-05-10 12:30:24 +00:00
if (isFractional())
return false;
int forSignBit = (targetType->isSigned() ? 1 : 0);
if (m_value > 0)
{
2016-05-10 12:30:24 +00:00
if (m_value.numerator() <= (u256(-1) >> (256 - targetType->numBits() + forSignBit)))
return true;
}
2016-05-10 12:30:24 +00:00
else if (targetType->isSigned() && -m_value.numerator() <= (u256(1) << (targetType->numBits() - forSignBit)))
return true;
return false;
}
else if (_convertTo.category() == Category::FixedPoint)
{
if (auto fixed = fixedPointType())
{
2016-05-10 10:42:38 +00:00
// We disallow implicit conversion if we would have to truncate (fixedPointType()
// can return a type that requires truncation).
2016-05-10 11:31:10 +00:00
rational value = m_value * (bigint(1) << fixed->fractionalBits());
2016-05-10 10:42:38 +00:00
return value.denominator() == 1 && fixed->isImplicitlyConvertibleTo(_convertTo);
}
return false;
}
2015-08-31 16:44:29 +00:00
else if (_convertTo.category() == Category::FixedBytes)
2015-06-04 16:06:06 +00:00
{
FixedBytesType const& fixedBytes = dynamic_cast<FixedBytesType const&>(_convertTo);
2016-05-10 12:30:24 +00:00
if (!isFractional())
{
if (integerType())
return fixedBytes.numBytes() * 8 >= integerType()->numBits();
return false;
}
else
return false;
2015-06-04 16:06:06 +00:00
}
return false;
2014-12-19 10:31:17 +00:00
}
bool RationalNumberType::isExplicitlyConvertibleTo(Type const& _convertTo) const
2014-12-19 10:31:17 +00:00
{
2016-05-10 10:42:38 +00:00
TypePointer mobType = mobileType();
return mobType && mobType->isExplicitlyConvertibleTo(_convertTo);
2014-12-19 10:31:17 +00:00
}
TypePointer RationalNumberType::unaryOperatorResult(Token::Value _operator) const
2014-12-19 10:31:17 +00:00
{
rational value;
2014-12-19 10:31:17 +00:00
switch (_operator)
{
case Token::BitNot:
2016-05-10 12:30:24 +00:00
if (isFractional())
return TypePointer();
value = ~m_value.numerator();
2014-12-19 10:31:17 +00:00
break;
case Token::Add:
value = +(m_value);
2014-12-19 10:31:17 +00:00
break;
case Token::Sub:
value = -(m_value);
2014-12-19 10:31:17 +00:00
break;
2015-03-04 18:55:52 +00:00
case Token::After:
return shared_from_this();
2014-12-19 10:31:17 +00:00
default:
return TypePointer();
}
return make_shared<RationalNumberType>(value);
2014-12-19 10:31:17 +00:00
}
TypePointer RationalNumberType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
2014-12-19 10:31:17 +00:00
{
2016-05-10 10:42:38 +00:00
if (_other->category() == Category::Integer || _other->category() == Category::FixedPoint)
{
2016-05-10 10:42:38 +00:00
auto mobile = mobileType();
if (!mobile)
return TypePointer();
2016-05-10 10:42:38 +00:00
return mobile->binaryOperatorResult(_operator, _other);
}
2015-08-31 16:44:29 +00:00
else if (_other->category() != category())
2014-12-19 10:31:17 +00:00
return TypePointer();
RationalNumberType const& other = dynamic_cast<RationalNumberType const&>(*_other);
2014-12-19 10:31:17 +00:00
if (Token::isCompareOp(_operator))
{
2016-05-10 10:42:38 +00:00
// Since we do not have a "BoolConstantType", we have to do the acutal comparison
// at runtime and convert to mobile typse first. Such a comparison is not a very common
// use-case and will be optimized away.
TypePointer thisMobile = mobileType();
TypePointer otherMobile = other.mobileType();
if (!thisMobile || !otherMobile)
return TypePointer();
return thisMobile->binaryOperatorResult(_operator, otherMobile);
2014-12-19 10:31:17 +00:00
}
else
{
rational value;
2016-05-10 12:30:24 +00:00
bool fractional = isFractional() || other.isFractional();
2014-12-19 10:31:17 +00:00
switch (_operator)
{
//bit operations will only be enabled for integers and fixed types that resemble integers
case Token::BitOr:
if (fractional)
return TypePointer();
value = m_value.numerator() | other.m_value.numerator();
2014-12-19 10:31:17 +00:00
break;
case Token::BitXor:
if (fractional)
return TypePointer();
value = m_value.numerator() ^ other.m_value.numerator();
2014-12-19 10:31:17 +00:00
break;
case Token::BitAnd:
if (fractional)
return TypePointer();
value = m_value.numerator() & other.m_value.numerator();
2014-12-19 10:31:17 +00:00
break;
case Token::Add:
value = m_value + other.m_value;
2014-12-19 10:31:17 +00:00
break;
case Token::Sub:
value = m_value - other.m_value;
2014-12-19 10:31:17 +00:00
break;
case Token::Mul:
2014-12-19 10:31:17 +00:00
value = m_value * other.m_value;
break;
case Token::Div:
2014-12-19 10:31:17 +00:00
if (other.m_value == 0)
return TypePointer();
else
value = m_value / other.m_value;
2014-12-19 10:31:17 +00:00
break;
case Token::Mod:
2014-12-19 10:31:17 +00:00
if (other.m_value == 0)
return TypePointer();
else if (fractional)
{
2016-04-11 21:35:17 +00:00
rational tempValue = m_value / other.m_value;
value = m_value - (tempValue.numerator() / tempValue.denominator()) * other.m_value;
}
else
value = m_value.numerator() % other.m_value.numerator();
break;
case Token::Exp:
{
2016-05-10 10:42:38 +00:00
using boost::multiprecision::pow;
2016-05-10 12:30:24 +00:00
if (other.isFractional())
2015-02-10 14:43:13 +00:00
return TypePointer();
2016-05-10 10:42:38 +00:00
else if (abs(other.m_value) > numeric_limits<uint32_t>::max())
return TypePointer(); // This will need too much memory to represent.
uint32_t exponent = abs(other.m_value).numerator().convert_to<uint32_t>();
bigint numerator = pow(m_value.numerator(), exponent);
bigint denominator = pow(m_value.denominator(), exponent);
if (other.m_value >= 0)
value = rational(numerator, denominator);
else
2016-05-10 10:42:38 +00:00
// invert
value = rational(denominator, numerator);
break;
}
2016-05-17 15:04:10 +00:00
case Token::SHL:
{
using boost::multiprecision::pow;
if (fractional)
return TypePointer();
else if (other.m_value < 0)
2016-05-17 15:04:10 +00:00
return TypePointer();
else if (other.m_value > numeric_limits<uint32_t>::max())
return TypePointer();
uint32_t exponent = other.m_value.numerator().convert_to<uint32_t>();
2016-05-17 15:04:10 +00:00
value = m_value.numerator() * pow(bigint(2), exponent);
break;
}
2016-09-07 23:26:14 +00:00
// NOTE: we're using >> (SAR) to denote right shifting. The type of the LValue
// determines the resulting type and the type of shift (SAR or SHR).
case Token::SAR:
2016-05-17 15:04:10 +00:00
{
using boost::multiprecision::pow;
if (fractional)
return TypePointer();
else if (other.m_value < 0)
2016-05-17 15:04:10 +00:00
return TypePointer();
else if (other.m_value > numeric_limits<uint32_t>::max())
return TypePointer();
uint32_t exponent = other.m_value.numerator().convert_to<uint32_t>();
2016-05-17 15:04:10 +00:00
value = rational(m_value.numerator() / pow(bigint(2), exponent), 1);
break;
}
2014-12-19 10:31:17 +00:00
default:
return TypePointer();
}
return make_shared<RationalNumberType>(value);
2014-12-19 10:31:17 +00:00
}
}
bool RationalNumberType::operator==(Type const& _other) const
2014-12-19 10:31:17 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-12-19 10:31:17 +00:00
return false;
RationalNumberType const& other = dynamic_cast<RationalNumberType const&>(_other);
return m_value == other.m_value;
2014-12-19 10:31:17 +00:00
}
string RationalNumberType::toString(bool) const
2014-12-19 10:31:17 +00:00
{
2016-05-10 12:30:24 +00:00
if (!isFractional())
return "int_const " + m_value.numerator().str();
return "rational_const " + m_value.numerator().str() + '/' + m_value.denominator().str();
2014-12-19 10:31:17 +00:00
}
u256 RationalNumberType::literalValue(Literal const*) const
2014-12-19 10:31:17 +00:00
{
2016-05-10 11:31:10 +00:00
// We ignore the literal and hope that the type was correctly determined to represent
// its value.
u256 value;
bigint shiftedValue;
2016-05-10 12:30:24 +00:00
if (!isFractional())
2016-05-10 11:31:10 +00:00
shiftedValue = m_value.numerator();
else
{
auto fixed = fixedPointType();
2016-05-10 11:31:10 +00:00
solAssert(!!fixed, "");
rational shifted = m_value * (bigint(1) << fixed->fractionalBits());
// truncate
shiftedValue = shifted.numerator() / shifted.denominator();
}
2016-05-10 11:31:10 +00:00
2014-12-19 10:31:17 +00:00
// we ignore the literal and hope that the type was correctly determined
solAssert(shiftedValue <= u256(-1), "Integer constant too large.");
solAssert(shiftedValue >= -(bigint(1) << 255), "Number constant too small.");
2014-12-19 10:31:17 +00:00
if (m_value >= 0)
value = u256(shiftedValue);
2014-12-19 10:31:17 +00:00
else
value = s2u(s256(shiftedValue));
return value;
2014-12-19 10:31:17 +00:00
}
TypePointer RationalNumberType::mobileType() const
2015-02-06 12:42:51 +00:00
{
2016-05-10 12:30:24 +00:00
if (!isFractional())
return integerType();
else
return fixedPointType();
2015-02-06 12:42:51 +00:00
}
shared_ptr<IntegerType const> RationalNumberType::integerType() const
2014-12-19 10:31:17 +00:00
{
2016-05-10 12:30:24 +00:00
solAssert(!isFractional(), "integerType() called for fractional number.");
bigint value = m_value.numerator();
2014-12-19 10:31:17 +00:00
bool negative = (value < 0);
if (negative) // convert to positive number of same bit requirements
value = ((0 - value) - 1) << 1;
2014-12-19 10:31:17 +00:00
if (value > u256(-1))
return shared_ptr<IntegerType const>();
else
return make_shared<IntegerType>(
max(bytesRequired(value), 1u) * 8,
negative ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned
);
2014-12-19 10:31:17 +00:00
}
shared_ptr<FixedPointType const> RationalNumberType::fixedPointType() const
{
bool negative = (m_value < 0);
2016-04-11 23:12:11 +00:00
unsigned fractionalBits = 0;
2016-05-10 11:31:10 +00:00
rational value = abs(m_value); // We care about the sign later.
rational maxValue = negative ?
rational(bigint(1) << 255, 1):
rational((bigint(1) << 256) - 1, 1);
while (value * 0x100 <= maxValue && value.denominator() != 1 && fractionalBits < 256)
{
2016-04-11 23:12:11 +00:00
value *= 0x100;
fractionalBits += 8;
}
2016-04-11 23:12:11 +00:00
if (value > maxValue)
return shared_ptr<FixedPointType const>();
2016-04-11 23:12:11 +00:00
// u256(v) is the actual value that will be put on the stack
// From here on, very similar to integerType()
bigint v = value.numerator() / value.denominator();
2016-05-10 11:31:10 +00:00
if (negative)
// modify value to satisfy bit requirements for negative numbers:
// add one bit for sign and decrement because negative numbers can be larger
v = (v - 1) << 1;
if (v > u256(-1))
2016-04-11 23:12:11 +00:00
return shared_ptr<FixedPointType const>();
unsigned totalBits = bytesRequired(v) * 8;
solAssert(totalBits <= 256, "");
unsigned integerBits = totalBits >= fractionalBits ? totalBits - fractionalBits : 0;
// Special case: Numbers between -1 and 0 have their sign bit in the fractional part.
if (negative && abs(m_value) < 1 && totalBits > fractionalBits)
{
fractionalBits += 8;
integerBits = 0;
}
if (integerBits > 256 || fractionalBits > 256 || fractionalBits + integerBits > 256)
return shared_ptr<FixedPointType const>();
2016-05-10 11:31:10 +00:00
if (integerBits == 0 && fractionalBits == 0)
{
integerBits = 0;
fractionalBits = 8;
}
2016-04-11 23:12:11 +00:00
return make_shared<FixedPointType>(
integerBits, fractionalBits,
negative ? FixedPointType::Modifier::Signed : FixedPointType::Modifier::Unsigned
);
}
StringLiteralType::StringLiteralType(Literal const& _literal):
2015-08-31 16:44:29 +00:00
m_value(_literal.value())
{
}
bool StringLiteralType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{
if (auto fixedBytes = dynamic_cast<FixedBytesType const*>(&_convertTo))
return size_t(fixedBytes->numBytes()) >= m_value.size();
else if (auto arrayType = dynamic_cast<ArrayType const*>(&_convertTo))
return
arrayType->isByteArray() &&
!(arrayType->dataStoredIn(DataLocation::Storage) && arrayType->isPointer()) &&
2016-11-25 13:36:44 +00:00
!(arrayType->isString() && !isValidUTF8());
else
return false;
}
bool StringLiteralType::operator==(const Type& _other) const
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
return false;
return m_value == dynamic_cast<StringLiteralType const&>(_other).m_value;
}
std::string StringLiteralType::toString(bool) const
{
2016-08-08 18:12:52 +00:00
size_t invalidSequence;
if (!dev::validateUTF8(m_value, invalidSequence))
return "literal_string (contains invalid UTF-8 sequence at position " + dev::toString(invalidSequence) + ")";
return "literal_string \"" + m_value + "\"";
}
TypePointer StringLiteralType::mobileType() const
{
return make_shared<ArrayType>(DataLocation::Memory, true);
}
bool StringLiteralType::isValidUTF8() const
{
return dev::validateUTF8(m_value);
}
shared_ptr<FixedBytesType> FixedBytesType::smallestTypeForLiteral(string const& _literal)
2014-12-09 17:46:18 +00:00
{
2014-12-11 13:19:11 +00:00
if (_literal.length() <= 32)
return make_shared<FixedBytesType>(_literal.length());
return shared_ptr<FixedBytesType>();
2014-12-09 17:46:18 +00:00
}
FixedBytesType::FixedBytesType(int _bytes): m_bytes(_bytes)
2014-12-09 17:46:18 +00:00
{
solAssert(m_bytes >= 0 && m_bytes <= 32,
"Invalid byte number for fixed bytes type: " + dev::toString(m_bytes));
2014-12-09 17:46:18 +00:00
}
bool FixedBytesType::isImplicitlyConvertibleTo(Type const& _convertTo) const
2014-12-09 17:46:18 +00:00
{
2015-08-31 16:44:29 +00:00
if (_convertTo.category() != category())
2014-12-09 17:46:18 +00:00
return false;
FixedBytesType const& convertTo = dynamic_cast<FixedBytesType const&>(_convertTo);
2014-12-09 17:46:18 +00:00
return convertTo.m_bytes >= m_bytes;
}
bool FixedBytesType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{
2015-08-31 16:44:29 +00:00
return _convertTo.category() == Category::Integer ||
_convertTo.category() == Category::FixedPoint ||
2015-08-31 16:44:29 +00:00
_convertTo.category() == Category::Contract ||
_convertTo.category() == category();
}
TypePointer FixedBytesType::unaryOperatorResult(Token::Value _operator) const
{
// "delete" and "~" is okay for FixedBytesType
if (_operator == Token::Delete)
return make_shared<TupleType>();
else if (_operator == Token::BitNot)
return shared_from_this();
return TypePointer();
}
TypePointer FixedBytesType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{
if (Token::isShiftOp(_operator))
{
if (isValidShiftAndAmountType(_operator, *_other))
return shared_from_this();
else
return TypePointer();
}
auto commonType = dynamic_pointer_cast<FixedBytesType const>(Type::commonType(shared_from_this(), _other));
if (!commonType)
return TypePointer();
// FixedBytes can be compared and have bitwise operators applied to them
if (Token::isCompareOp(_operator) || Token::isBitOp(_operator))
return commonType;
return TypePointer();
}
2016-02-03 20:34:24 +00:00
MemberList::MemberMap FixedBytesType::nativeMembers(const ContractDefinition*) const
{
return MemberList::MemberMap{MemberList::Member{"length", make_shared<IntegerType>(8)}};
}
bool FixedBytesType::operator==(Type const& _other) const
2014-12-09 17:46:18 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-12-09 17:46:18 +00:00
return false;
FixedBytesType const& other = dynamic_cast<FixedBytesType const&>(_other);
2014-12-09 17:46:18 +00:00
return other.m_bytes == m_bytes;
}
2014-12-19 10:31:17 +00:00
u256 BoolType::literalValue(Literal const* _literal) const
2014-10-13 16:22:15 +00:00
{
2014-12-19 10:31:17 +00:00
solAssert(_literal, "");
2015-08-31 16:44:29 +00:00
if (_literal->token() == Token::TrueLiteral)
return u256(1);
2015-08-31 16:44:29 +00:00
else if (_literal->token() == Token::FalseLiteral)
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
}
TypePointer BoolType::unaryOperatorResult(Token::Value _operator) const
{
if (_operator == Token::Delete)
return make_shared<TupleType>();
return (_operator == Token::Not) ? shared_from_this() : TypePointer();
}
TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{
2015-08-31 16:44:29 +00:00
if (category() != _other->category())
return TypePointer();
if (Token::isCompareOp(_operator) || _operator == Token::And || _operator == Token::Or)
return _other;
else
return TypePointer();
}
2015-01-07 21:54:56 +00:00
bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{
2015-01-07 21:54:56 +00:00
if (*this == _convertTo)
return true;
2015-08-31 16:44:29 +00:00
if (_convertTo.category() == Category::Integer)
return dynamic_cast<IntegerType const&>(_convertTo).isAddress();
2015-08-31 16:44:29 +00:00
if (_convertTo.category() == Category::Contract)
{
auto const& bases = contractDefinition().annotation().linearizedBaseContracts;
2015-01-27 13:32:59 +00:00
if (m_super && bases.size() <= 1)
return false;
return find(m_super ? ++bases.begin() : bases.begin(), bases.end(),
2015-08-31 16:44:29 +00:00
&dynamic_cast<ContractType const&>(_convertTo).contractDefinition()) != bases.end();
}
return false;
}
2015-01-07 21:54:56 +00:00
bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{
2015-09-01 09:19:02 +00:00
return
isImplicitlyConvertibleTo(_convertTo) ||
_convertTo.category() == Category::Integer ||
_convertTo.category() == Category::Contract;
2015-01-07 21:54:56 +00:00
}
TypePointer ContractType::unaryOperatorResult(Token::Value _operator) const
{
return _operator == Token::Delete ? make_shared<TupleType>() : TypePointer();
}
2015-06-26 17:14:26 +00:00
TypePointer ReferenceType::unaryOperatorResult(Token::Value _operator) const
{
if (_operator != Token::Delete)
return TypePointer();
// delete can be used on everything except calldata references or storage pointers
// (storage references are ok)
switch (location())
{
case DataLocation::CallData:
return TypePointer();
case DataLocation::Memory:
return make_shared<TupleType>();
2015-06-26 17:14:26 +00:00
case DataLocation::Storage:
return m_isPointer ? TypePointer() : make_shared<TupleType>();
2015-06-26 22:13:53 +00:00
default:
solAssert(false, "");
2015-06-26 17:14:26 +00:00
}
2015-06-29 11:23:02 +00:00
return TypePointer();
2015-06-26 17:14:26 +00:00
}
2015-06-17 10:01:39 +00:00
TypePointer ReferenceType::copyForLocationIfReference(DataLocation _location, TypePointer const& _type)
{
if (auto type = dynamic_cast<ReferenceType const*>(_type.get()))
return type->copyForLocation(_location, false);
return _type;
}
TypePointer ReferenceType::copyForLocationIfReference(TypePointer const& _type) const
{
return copyForLocationIfReference(m_location, _type);
}
string ReferenceType::stringForReferencePart() const
{
switch (m_location)
{
2015-06-17 10:01:39 +00:00
case DataLocation::Storage:
return string("storage ") + (m_isPointer ? "pointer" : "ref");
2015-06-17 10:01:39 +00:00
case DataLocation::CallData:
return "calldata";
2015-06-17 10:01:39 +00:00
case DataLocation::Memory:
return "memory";
}
2015-06-12 08:48:47 +00:00
solAssert(false, "");
return "";
}
bool ArrayType::isImplicitlyConvertibleTo(const Type& _convertTo) const
2015-02-10 08:00:50 +00:00
{
2015-08-31 16:44:29 +00:00
if (_convertTo.category() != category())
2015-02-27 13:50:06 +00:00
return false;
auto& convertTo = dynamic_cast<ArrayType const&>(_convertTo);
2015-05-28 14:20:50 +00:00
if (convertTo.isByteArray() != isByteArray() || convertTo.isString() != isString())
2015-02-27 13:50:06 +00:00
return false;
// memory/calldata to storage can be converted, but only to a direct storage reference
2015-06-17 10:01:39 +00:00
if (convertTo.location() == DataLocation::Storage && location() != DataLocation::Storage && convertTo.isPointer())
2015-02-27 13:50:06 +00:00
return false;
2015-06-17 10:01:39 +00:00
if (convertTo.location() == DataLocation::CallData && location() != convertTo.location())
return false;
2015-06-17 10:01:39 +00:00
if (convertTo.location() == DataLocation::Storage && !convertTo.isPointer())
{
// Less restrictive conversion, since we need to copy anyway.
2015-08-31 16:44:29 +00:00
if (!baseType()->isImplicitlyConvertibleTo(*convertTo.baseType()))
return false;
if (convertTo.isDynamicallySized())
return true;
2015-08-31 16:44:29 +00:00
return !isDynamicallySized() && convertTo.length() >= length();
}
else
{
2015-06-23 12:55:33 +00:00
// Conversion to storage pointer or to memory, we de not copy element-for-element here, so
// require that the base type is the same, not only convertible.
// This disallows assignment of nested dynamic arrays from storage to memory for now.
if (
2015-08-31 16:44:29 +00:00
*copyForLocationIfReference(location(), baseType()) !=
*copyForLocationIfReference(location(), convertTo.baseType())
2015-06-23 12:55:33 +00:00
)
return false;
if (isDynamicallySized() != convertTo.isDynamicallySized())
return false;
// We also require that the size is the same.
2015-08-31 16:44:29 +00:00
if (!isDynamicallySized() && length() != convertTo.length())
return false;
2015-02-27 13:50:06 +00:00
return true;
}
2015-02-10 08:00:50 +00:00
}
bool ArrayType::isExplicitlyConvertibleTo(const Type& _convertTo) const
{
if (isImplicitlyConvertibleTo(_convertTo))
return true;
// allow conversion bytes <-> string
2015-08-31 16:44:29 +00:00
if (_convertTo.category() != category())
return false;
auto& convertTo = dynamic_cast<ArrayType const&>(_convertTo);
if (convertTo.location() != location())
return false;
if (!isByteArray() || !convertTo.isByteArray())
return false;
return true;
}
bool ArrayType::operator==(Type const& _other) const
2015-02-09 17:45:00 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2015-02-09 17:45:00 +00:00
return false;
ArrayType const& other = dynamic_cast<ArrayType const&>(_other);
2015-05-28 14:20:50 +00:00
if (
!ReferenceType::operator==(other) ||
2015-05-28 14:20:50 +00:00
other.isByteArray() != isByteArray() ||
other.isString() != isString() ||
other.isDynamicallySized() != isDynamicallySized()
)
2015-02-27 13:50:06 +00:00
return false;
if (*other.baseType() != *baseType())
return false;
2015-08-31 16:44:29 +00:00
return isDynamicallySized() || length() == other.length();
2015-02-09 17:45:00 +00:00
}
2015-08-31 16:44:29 +00:00
unsigned ArrayType::calldataEncodedSize(bool _padded) const
2015-03-03 10:28:56 +00:00
{
if (isDynamicallySized())
return 32;
2015-08-31 16:44:29 +00:00
bigint size = bigint(length()) * (isByteArray() ? 1 : baseType()->calldataEncodedSize(_padded));
2015-03-05 17:22:17 +00:00
size = ((size + 31) / 32) * 32;
2015-03-03 10:28:56 +00:00
solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
return unsigned(size);
}
2015-08-31 16:44:29 +00:00
u256 ArrayType::storageSize() const
2015-02-22 18:15:41 +00:00
{
if (isDynamicallySized())
return 1;
2015-03-16 16:52:19 +00:00
bigint size;
2015-08-31 16:44:29 +00:00
unsigned baseBytes = baseType()->storageBytes();
2015-03-16 16:52:19 +00:00
if (baseBytes == 0)
size = 1;
else if (baseBytes < 32)
2015-02-22 18:15:41 +00:00
{
2015-03-16 16:52:19 +00:00
unsigned itemsPerSlot = 32 / baseBytes;
2015-08-31 16:44:29 +00:00
size = (bigint(length()) + (itemsPerSlot - 1)) / itemsPerSlot;
2015-02-22 18:15:41 +00:00
}
2015-03-16 16:52:19 +00:00
else
2015-08-31 16:44:29 +00:00
size = bigint(length()) * baseType()->storageSize();
2015-03-16 16:52:19 +00:00
if (size >= bigint(1) << 256)
BOOST_THROW_EXCEPTION(Error(Error::Type::TypeError) << errinfo_comment("Array too large for storage."));
2015-03-16 16:52:19 +00:00
return max<u256>(1, u256(size));
2015-02-22 18:15:41 +00:00
}
2015-08-31 16:44:29 +00:00
unsigned ArrayType::sizeOnStack() const
2015-02-10 13:57:01 +00:00
{
2015-06-17 10:01:39 +00:00
if (m_location == DataLocation::CallData)
2015-03-03 10:28:56 +00:00
// offset [length] (stack top)
return 1 + (isDynamicallySized() ? 1 : 0);
2015-02-10 13:57:01 +00:00
else
// storage slot or memory offset
// byte offset inside storage value is omitted
2015-02-10 13:57:01 +00:00
return 1;
}
string ArrayType::toString(bool _short) const
{
string ret;
2015-05-28 14:20:50 +00:00
if (isString())
ret = "string";
2015-05-28 14:20:50 +00:00
else if (isByteArray())
ret = "bytes";
else
{
2015-08-31 16:44:29 +00:00
ret = baseType()->toString(_short) + "[";
if (!isDynamicallySized())
2015-08-31 16:44:29 +00:00
ret += length().str();
ret += "]";
}
if (!_short)
ret += " " + stringForReferencePart();
return ret;
}
string ArrayType::canonicalName(bool _addDataLocation) const
{
string ret;
if (isString())
ret = "string";
else if (isByteArray())
ret = "bytes";
else
{
ret = baseType()->canonicalName(false) + "[";
if (!isDynamicallySized())
ret += length().str();
ret += "]";
}
if (_addDataLocation && location() == DataLocation::Storage)
ret += " storage";
return ret;
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap ArrayType::nativeMembers(ContractDefinition const*) const
{
2015-11-25 13:23:35 +00:00
MemberList::MemberMap members;
if (!isString())
{
2015-11-25 13:23:35 +00:00
members.push_back({"length", make_shared<IntegerType>(256)});
if (isDynamicallySized() && location() == DataLocation::Storage)
members.push_back({"push", make_shared<FunctionType>(
TypePointers{baseType()},
TypePointers{make_shared<IntegerType>(256)},
strings{string()},
strings{string()},
isByteArray() ? FunctionType::Location::ByteArrayPush : FunctionType::Location::ArrayPush
)});
}
2015-11-25 13:23:35 +00:00
return members;
}
TypePointer ArrayType::encodingType() const
2015-03-19 15:48:54 +00:00
{
if (location() == DataLocation::Storage)
return make_shared<IntegerType>(256);
else
return this->copyForLocation(DataLocation::Memory, true);
}
2015-10-02 20:34:47 +00:00
TypePointer ArrayType::decodingType() const
{
if (location() == DataLocation::Storage)
return make_shared<IntegerType>(256);
else
return shared_from_this();
}
TypePointer ArrayType::interfaceType(bool _inLibrary) const
{
// Note: This has to fulfill canBeUsedExternally(_inLibrary) == !!interfaceType(_inLibrary)
if (_inLibrary && location() == DataLocation::Storage)
return shared_from_this();
2015-05-28 14:20:50 +00:00
if (m_arrayKind != ArrayKind::Ordinary)
2015-06-24 15:25:36 +00:00
return this->copyForLocation(DataLocation::Memory, true);
TypePointer baseExt = m_baseType->interfaceType(_inLibrary);
if (!baseExt)
2015-03-19 15:48:54 +00:00
return TypePointer();
2015-08-31 16:44:29 +00:00
if (m_baseType->category() == Category::Array && m_baseType->isDynamicallySized())
2015-03-19 15:48:54 +00:00
return TypePointer();
if (isDynamicallySized())
2016-02-18 12:29:02 +00:00
return make_shared<ArrayType>(DataLocation::Memory, baseExt);
2015-03-19 15:48:54 +00:00
else
2016-02-18 12:29:02 +00:00
return make_shared<ArrayType>(DataLocation::Memory, baseExt, m_length);
2015-03-19 15:48:54 +00:00
}
bool ArrayType::canBeUsedExternally(bool _inLibrary) const
{
// Note: This has to fulfill canBeUsedExternally(_inLibrary) == !!interfaceType(_inLibrary)
if (_inLibrary && location() == DataLocation::Storage)
return true;
else if (m_arrayKind != ArrayKind::Ordinary)
return true;
else if (!m_baseType->canBeUsedExternally(_inLibrary))
return false;
else if (m_baseType->category() == Category::Array && m_baseType->isDynamicallySized())
return false;
else
return true;
}
u256 ArrayType::memorySize() const
{
solAssert(!isDynamicallySized(), "");
solAssert(m_location == DataLocation::Memory, "");
bigint size = bigint(m_length) * m_baseType->memoryHeadSize();
solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit u256.");
return u256(size);
}
2015-06-17 10:01:39 +00:00
TypePointer ArrayType::copyForLocation(DataLocation _location, bool _isPointer) const
{
auto copy = make_shared<ArrayType>(_location);
copy->m_isPointer = _isPointer;
2015-05-28 14:20:50 +00:00
copy->m_arrayKind = m_arrayKind;
copy->m_baseType = copy->copyForLocationIfReference(m_baseType);
copy->m_hasDynamicLength = m_hasDynamicLength;
copy->m_length = m_length;
return copy;
}
2014-10-29 18:28:30 +00:00
bool ContractType::operator==(Type const& _other) const
2014-10-20 10:41:56 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
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);
2015-01-27 13:32:59 +00:00
return other.m_contract == m_contract && other.m_super == m_super;
2014-10-13 16:22:15 +00:00
}
string ContractType::toString(bool) const
{
return
string(m_contract.isLibrary() ? "library " : "contract ") +
string(m_super ? "super " : "") +
m_contract.name();
}
string ContractType::canonicalName(bool) const
{
return m_contract.annotation().canonicalName;
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap ContractType::nativeMembers(ContractDefinition const*) const
2014-12-04 18:38:24 +00:00
{
2015-11-25 13:23:35 +00:00
// All address members and all interface functions
MemberList::MemberMap members(IntegerType(120, IntegerType::Modifier::Address).nativeMembers(nullptr));
if (m_super)
2014-12-04 18:38:24 +00:00
{
2015-11-25 13:23:35 +00:00
// add the most derived of all functions which are visible in derived contracts
auto bases = m_contract.annotation().linearizedBaseContracts;
solAssert(bases.size() >= 1, "linearizedBaseContracts should at least contain the most derived contract.");
// `sliced(1, ...)` ignores the most derived contract, which should not be searchable from `super`.
for (ContractDefinition const* base: bases | boost::adaptors::sliced(1, bases.size()))
2015-11-25 13:23:35 +00:00
for (FunctionDefinition const* function: base->definedFunctions())
{
if (!function->isVisibleInDerivedContracts())
continue;
auto functionType = make_shared<FunctionType>(*function, true);
bool functionWithEqualArgumentsFound = false;
for (auto const& member: members)
{
2015-11-25 13:23:35 +00:00
if (member.name != function->name())
continue;
2015-11-25 13:23:35 +00:00
auto memberType = dynamic_cast<FunctionType const*>(member.type.get());
solAssert(!!memberType, "Override changes type.");
if (!memberType->hasEqualArgumentTypes(*functionType))
continue;
functionWithEqualArgumentsFound = true;
break;
}
2015-11-25 13:23:35 +00:00
if (!functionWithEqualArgumentsFound)
members.push_back(MemberList::Member(
function->name(),
functionType,
function
));
}
2014-12-04 18:38:24 +00:00
}
else if (!m_contract.isLibrary())
{
2015-11-25 13:23:35 +00:00
for (auto const& it: m_contract.interfaceFunctions())
members.push_back(MemberList::Member(
it.second->declaration().name(),
it.second->asMemberFunction(m_contract.isLibrary()),
&it.second->declaration()
));
}
2015-11-25 13:23:35 +00:00
return members;
2014-12-04 18:38:24 +00:00
}
shared_ptr<FunctionType const> const& ContractType::newExpressionType() const
2014-12-12 15:49:26 +00:00
{
if (!m_constructorType)
m_constructorType = FunctionType::newExpressionType(m_contract);
2014-12-12 15:49:26 +00:00
return m_constructorType;
}
2015-08-31 16:44:29 +00:00
vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVariables() const
{
vector<VariableDeclaration const*> variables;
for (ContractDefinition const* contract: boost::adaptors::reverse(m_contract.annotation().linearizedBaseContracts))
for (VariableDeclaration const* variable: contract->stateVariables())
if (!variable->isConstant())
variables.push_back(variable);
TypePointers types;
for (auto variable: variables)
types.push_back(variable->annotation().type);
StorageOffsets offsets;
offsets.computeOffsets(types);
vector<tuple<VariableDeclaration const*, u256, unsigned>> variablesAndOffsets;
for (size_t index = 0; index < variables.size(); ++index)
2015-08-31 16:44:29 +00:00
if (auto const* offset = offsets.offset(index))
variablesAndOffsets.push_back(make_tuple(variables[index], offset->first, offset->second));
return variablesAndOffsets;
}
bool StructType::isImplicitlyConvertibleTo(const Type& _convertTo) const
{
2015-08-31 16:44:29 +00:00
if (_convertTo.category() != category())
return false;
auto& convertTo = dynamic_cast<StructType const&>(_convertTo);
// memory/calldata to storage can be converted, but only to a direct storage reference
2015-06-17 10:01:39 +00:00
if (convertTo.location() == DataLocation::Storage && location() != DataLocation::Storage && convertTo.isPointer())
return false;
2015-06-17 10:01:39 +00:00
if (convertTo.location() == DataLocation::CallData && location() != convertTo.location())
return false;
return this->m_struct == convertTo.m_struct;
}
2014-10-29 18:28:30 +00:00
bool StructType::operator==(Type const& _other) const
2014-10-13 16:22:15 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
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 ReferenceType::operator==(other) && other.m_struct == m_struct;
2014-10-13 16:22:15 +00:00
}
2015-08-31 16:44:29 +00:00
unsigned StructType::calldataEncodedSize(bool _padded) const
2015-06-24 15:25:36 +00:00
{
unsigned size = 0;
2015-11-19 17:02:04 +00:00
for (auto const& member: members(nullptr))
2015-06-24 15:25:36 +00:00
if (!member.type->canLiveOutsideStorage())
return 0;
else
{
2015-08-31 16:44:29 +00:00
unsigned memberSize = member.type->calldataEncodedSize(_padded);
2015-06-24 15:25:36 +00:00
if (memberSize == 0)
return 0;
size += memberSize;
}
return size;
}
2015-06-30 09:54:51 +00:00
u256 StructType::memorySize() const
{
u256 size;
2015-11-19 17:02:04 +00:00
for (auto const& member: members(nullptr))
2015-06-30 09:54:51 +00:00
if (member.type->canLiveOutsideStorage())
size += member.type->memoryHeadSize();
return size;
}
2015-08-31 16:44:29 +00:00
u256 StructType::storageSize() const
2014-11-07 01:06:37 +00:00
{
2015-11-19 17:02:04 +00:00
return max<u256>(1, members(nullptr).storageSize());
2014-11-07 01:06:37 +00:00
}
string StructType::toString(bool _short) const
2014-11-13 00:12:57 +00:00
{
string ret = "struct " + m_struct.annotation().canonicalName;
if (!_short)
ret += " " + stringForReferencePart();
return ret;
2014-11-13 00:12:57 +00:00
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap StructType::nativeMembers(ContractDefinition const*) const
2014-11-13 00:12:57 +00:00
{
2015-11-25 13:23:35 +00:00
MemberList::MemberMap members;
for (ASTPointer<VariableDeclaration> const& variable: m_struct.members())
2014-11-20 09:19:43 +00:00
{
2015-11-25 13:23:35 +00:00
TypePointer type = variable->annotation().type;
// Skip all mapping members if we are not in storage.
if (location() != DataLocation::Storage && !type->canLiveOutsideStorage())
continue;
members.push_back(MemberList::Member(
variable->name(),
copyForLocationIfReference(type),
variable.get())
);
2014-11-20 09:19:43 +00:00
}
2015-11-25 13:23:35 +00:00
return members;
2014-11-13 00:12:57 +00:00
}
TypePointer StructType::interfaceType(bool _inLibrary) const
{
if (_inLibrary && location() == DataLocation::Storage)
return shared_from_this();
else
return TypePointer();
}
2015-06-17 10:01:39 +00:00
TypePointer StructType::copyForLocation(DataLocation _location, bool _isPointer) const
{
auto copy = make_shared<StructType>(m_struct, _location);
copy->m_isPointer = _isPointer;
return copy;
}
string StructType::canonicalName(bool _addDataLocation) const
{
string ret = m_struct.annotation().canonicalName;
if (_addDataLocation && location() == DataLocation::Storage)
ret += " storage";
return ret;
}
2015-06-30 19:08:34 +00:00
FunctionTypePointer StructType::constructorType() const
{
TypePointers paramTypes;
strings paramNames;
2015-11-19 17:02:04 +00:00
for (auto const& member: members(nullptr))
2015-06-30 19:08:34 +00:00
{
if (!member.type->canLiveOutsideStorage())
continue;
paramNames.push_back(member.name);
paramTypes.push_back(copyForLocationIfReference(DataLocation::Memory, member.type));
}
return make_shared<FunctionType>(
paramTypes,
TypePointers{copyForLocation(DataLocation::Memory, false)},
paramNames,
strings(),
FunctionType::Location::Internal
);
}
2015-08-31 16:44:29 +00:00
pair<u256, unsigned> const& StructType::storageOffsetsOfMember(string const& _name) const
2014-11-13 00:12:57 +00:00
{
2015-11-19 17:02:04 +00:00
auto const* offsets = members(nullptr).memberStorageOffset(_name);
2015-03-13 18:48:24 +00:00
solAssert(offsets, "Storage offset of non-existing member requested.");
return *offsets;
2014-11-13 00:12:57 +00:00
}
2015-06-30 09:54:51 +00:00
u256 StructType::memoryOffsetOfMember(string const& _name) const
{
u256 offset;
2015-11-19 17:02:04 +00:00
for (auto const& member: members(nullptr))
2015-06-30 09:54:51 +00:00
if (member.name == _name)
return offset;
else
offset += member.type->memoryHeadSize();
solAssert(false, "Member not found in struct.");
return 0;
}
set<string> StructType::membersMissingInMemory() const
{
set<string> missing;
2015-08-31 16:44:29 +00:00
for (ASTPointer<VariableDeclaration> const& variable: m_struct.members())
if (!variable->annotation().type->canLiveOutsideStorage())
2015-08-31 16:44:29 +00:00
missing.insert(variable->name());
return missing;
}
TypePointer EnumType::unaryOperatorResult(Token::Value _operator) const
{
return _operator == Token::Delete ? make_shared<TupleType>() : TypePointer();
}
bool EnumType::operator==(Type const& _other) const
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
return false;
EnumType const& other = dynamic_cast<EnumType const&>(_other);
return other.m_enum == m_enum;
}
2015-08-31 16:44:29 +00:00
unsigned EnumType::storageBytes() const
2015-03-13 09:52:34 +00:00
{
2016-11-07 17:15:59 +00:00
size_t elements = numberOfMembers();
2015-03-13 09:52:34 +00:00
if (elements <= 1)
return 1;
else
return dev::bytesRequired(elements - 1);
}
string EnumType::toString(bool) const
{
return string("enum ") + m_enum.annotation().canonicalName;
}
string EnumType::canonicalName(bool) const
{
return m_enum.annotation().canonicalName;
}
2016-11-07 17:15:59 +00:00
size_t EnumType::numberOfMembers() const
{
return m_enum.members().size();
};
bool EnumType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{
return _convertTo == *this || _convertTo.category() == Category::Integer;
}
2016-05-10 09:15:41 +00:00
unsigned EnumType::memberValue(ASTString const& _member) const
{
2016-05-10 09:15:41 +00:00
unsigned index = 0;
2015-08-31 16:44:29 +00:00
for (ASTPointer<EnumValue> const& decl: m_enum.members())
{
2015-08-31 16:44:29 +00:00
if (decl->name() == _member)
return index;
++index;
}
BOOST_THROW_EXCEPTION(m_enum.createTypeError("Requested unknown enum value ." + _member));
}
2015-10-14 13:19:50 +00:00
bool TupleType::isImplicitlyConvertibleTo(Type const& _other) const
{
if (auto tupleType = dynamic_cast<TupleType const*>(&_other))
{
TypePointers const& targets = tupleType->components();
if (targets.empty())
return components().empty();
if (components().size() != targets.size() && !targets.front() && !targets.back())
return false; // (,a,) = (1,2,3,4) - unable to position `a` in the tuple.
size_t minNumValues = targets.size();
if (!targets.back() || !targets.front())
--minNumValues; // wildcards can also match 0 components
if (components().size() < minNumValues)
return false;
if (components().size() > targets.size() && targets.front() && targets.back())
return false; // larger source and no wildcard
bool fillRight = !targets.back() || targets.front();
for (size_t i = 0; i < min(targets.size(), components().size()); ++i)
{
auto const& s = components()[fillRight ? i : components().size() - i - 1];
auto const& t = targets[fillRight ? i : targets.size() - i - 1];
if (!s && t)
return false;
else if (s && t && !s->isImplicitlyConvertibleTo(*t))
return false;
}
return true;
}
else
return false;
}
bool TupleType::operator==(Type const& _other) const
{
if (auto tupleType = dynamic_cast<TupleType const*>(&_other))
return components() == tupleType->components();
else
return false;
}
string TupleType::toString(bool _short) const
{
2015-10-14 13:19:50 +00:00
if (components().empty())
return "tuple()";
string str = "tuple(";
2015-10-14 13:19:50 +00:00
for (auto const& t: components())
2015-10-12 21:02:35 +00:00
str += (t ? t->toString(_short) : "") + ",";
str.pop_back();
return str + ")";
}
u256 TupleType::storageSize() const
{
BOOST_THROW_EXCEPTION(
2015-10-13 10:22:57 +00:00
InternalCompilerError() <<
errinfo_comment("Storage size of non-storable tuple type requested.")
);
}
unsigned TupleType::sizeOnStack() const
{
unsigned size = 0;
2015-10-14 13:19:50 +00:00
for (auto const& t: components())
2015-10-12 21:02:35 +00:00
size += t ? t->sizeOnStack() : 0;
return size;
}
2015-10-14 13:19:50 +00:00
TypePointer TupleType::mobileType() const
2015-10-12 21:02:35 +00:00
{
2015-10-14 13:19:50 +00:00
TypePointers mobiles;
for (auto const& c: components())
2016-10-21 10:30:58 +00:00
{
if (c)
{
auto mt = c->mobileType();
if (!mt)
return TypePointer();
mobiles.push_back(mt);
}
else
mobiles.push_back(TypePointer());
}
2015-10-14 13:19:50 +00:00
return make_shared<TupleType>(mobiles);
}
TypePointer TupleType::closestTemporaryType(TypePointer const& _targetType) const
{
solAssert(!!_targetType, "");
TypePointers const& targetComponents = dynamic_cast<TupleType const&>(*_targetType).components();
bool fillRight = !targetComponents.empty() && (!targetComponents.back() || targetComponents.front());
TypePointers tempComponents(targetComponents.size());
for (size_t i = 0; i < min(targetComponents.size(), components().size()); ++i)
2015-10-12 21:02:35 +00:00
{
2015-10-14 13:19:50 +00:00
size_t si = fillRight ? i : components().size() - i - 1;
size_t ti = fillRight ? i : targetComponents.size() - i - 1;
if (components()[si] && targetComponents[ti])
2015-10-14 22:42:36 +00:00
tempComponents[ti] = components()[si]->closestTemporaryType(targetComponents[ti]);
2015-10-12 21:02:35 +00:00
}
2015-10-14 13:19:50 +00:00
return make_shared<TupleType>(tempComponents);
2015-10-12 21:02:35 +00:00
}
FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal):
2015-02-09 13:08:48 +00:00
m_location(_isInternal ? Location::Internal : Location::External),
m_isConstant(_function.isDeclaredConst()),
2016-11-09 14:14:16 +00:00
m_isPayable(_isInternal ? false : _function.isPayable()),
2015-01-29 16:28:14 +00:00
m_declaration(&_function)
{
TypePointers params;
vector<string> paramNames;
TypePointers retParams;
vector<string> retParamNames;
2015-08-31 16:44:29 +00:00
params.reserve(_function.parameters().size());
paramNames.reserve(_function.parameters().size());
for (ASTPointer<VariableDeclaration> const& var: _function.parameters())
{
2015-08-31 16:44:29 +00:00
paramNames.push_back(var->name());
params.push_back(var->annotation().type);
}
2015-08-31 16:44:29 +00:00
retParams.reserve(_function.returnParameters().size());
retParamNames.reserve(_function.returnParameters().size());
for (ASTPointer<VariableDeclaration> const& var: _function.returnParameters())
{
2015-08-31 16:44:29 +00:00
retParamNames.push_back(var->name());
retParams.push_back(var->annotation().type);
}
swap(params, m_parameterTypes);
swap(paramNames, m_parameterNames);
swap(retParams, m_returnParameterTypes);
swap(retParamNames, m_returnParameterNames);
}
FunctionType::FunctionType(VariableDeclaration const& _varDecl):
2015-02-09 13:08:48 +00:00
m_location(Location::External), m_isConstant(true), m_declaration(&_varDecl)
{
2015-04-02 15:03:02 +00:00
TypePointers paramTypes;
vector<string> paramNames;
auto returnType = _varDecl.annotation().type;
while (true)
{
2015-04-02 15:03:02 +00:00
if (auto mappingType = dynamic_cast<MappingType const*>(returnType.get()))
{
2015-08-31 16:44:29 +00:00
paramTypes.push_back(mappingType->keyType());
paramNames.push_back("");
2015-08-31 16:44:29 +00:00
returnType = mappingType->valueType();
}
2015-04-02 15:03:02 +00:00
else if (auto arrayType = dynamic_cast<ArrayType const*>(returnType.get()))
{
2015-06-17 10:01:39 +00:00
if (arrayType->isByteArray())
// Return byte arrays as as whole.
break;
2015-08-31 16:44:29 +00:00
returnType = arrayType->baseType();
2015-04-02 15:03:02 +00:00
paramNames.push_back("");
paramTypes.push_back(make_shared<IntegerType>(256));
}
else
break;
}
2015-02-06 18:57:08 +00:00
TypePointers retParams;
vector<string> retParamNames;
if (auto structType = dynamic_cast<StructType const*>(returnType.get()))
{
2015-11-19 17:02:04 +00:00
for (auto const& member: structType->members(nullptr))
2015-08-31 16:44:29 +00:00
if (member.type->category() != Category::Mapping)
2015-02-06 18:57:08 +00:00
{
2015-06-17 10:01:39 +00:00
if (auto arrayType = dynamic_cast<ArrayType const*>(member.type.get()))
if (!arrayType->isByteArray())
continue;
retParams.push_back(member.type);
2015-06-17 10:01:39 +00:00
retParamNames.push_back(member.name);
2015-02-06 18:57:08 +00:00
}
}
else
{
2015-06-17 10:01:39 +00:00
retParams.push_back(ReferenceType::copyForLocationIfReference(
DataLocation::Memory,
returnType
));
2015-02-06 18:57:08 +00:00
retParamNames.push_back("");
}
2015-04-02 15:03:02 +00:00
swap(paramTypes, m_parameterTypes);
swap(paramNames, m_parameterNames);
swap(retParams, m_returnParameterTypes);
swap(retParamNames, m_returnParameterNames);
}
FunctionType::FunctionType(EventDefinition const& _event):
m_location(Location::Event), m_isConstant(true), m_declaration(&_event)
2015-01-29 13:35:28 +00:00
{
TypePointers params;
vector<string> paramNames;
2015-08-31 16:44:29 +00:00
params.reserve(_event.parameters().size());
paramNames.reserve(_event.parameters().size());
for (ASTPointer<VariableDeclaration> const& var: _event.parameters())
2015-01-29 13:35:28 +00:00
{
2015-08-31 16:44:29 +00:00
paramNames.push_back(var->name());
params.push_back(var->annotation().type);
2015-01-29 13:35:28 +00:00
}
swap(params, m_parameterTypes);
swap(paramNames, m_parameterNames);
}
2016-09-27 19:37:32 +00:00
FunctionType::FunctionType(FunctionTypeName const& _typeName):
m_location(_typeName.visibility() == VariableDeclaration::Visibility::External ? Location::External : Location::Internal),
m_isConstant(_typeName.isDeclaredConst()),
m_isPayable(_typeName.isPayable())
{
2016-11-09 14:14:16 +00:00
if (_typeName.isPayable())
{
2016-11-09 14:14:16 +00:00
solAssert(m_location == Location::External, "Internal payable function type used.");
solAssert(!m_isConstant, "Payable constant function");
}
2016-09-27 19:37:32 +00:00
for (auto const& t: _typeName.parameterTypes())
{
solAssert(t->annotation().type, "Type not set for parameter.");
if (m_location == Location::External)
solAssert(
t->annotation().type->canBeUsedExternally(false),
"Internal type used as parameter for external function."
);
2016-09-27 19:37:32 +00:00
m_parameterTypes.push_back(t->annotation().type);
}
for (auto const& t: _typeName.returnParameterTypes())
{
solAssert(t->annotation().type, "Type not set for return parameter.");
if (m_location == Location::External)
solAssert(
t->annotation().type->canBeUsedExternally(false),
"Internal type used as return parameter for external function."
);
2016-09-27 19:37:32 +00:00
m_returnParameterTypes.push_back(t->annotation().type);
}
}
FunctionTypePointer FunctionType::newExpressionType(ContractDefinition const& _contract)
{
FunctionDefinition const* constructor = _contract.constructor();
TypePointers parameters;
strings parameterNames;
bool payable = false;
if (constructor)
{
for (ASTPointer<VariableDeclaration> const& var: constructor->parameters())
{
parameterNames.push_back(var->name());
parameters.push_back(var->annotation().type);
}
payable = constructor->isPayable();
}
return make_shared<FunctionType>(
parameters,
TypePointers{make_shared<ContractType>(_contract)},
parameterNames,
strings{""},
Location::Creation,
false,
nullptr,
false,
payable
);
}
2016-02-18 12:29:02 +00:00
vector<string> FunctionType::parameterNames() const
2015-11-25 13:23:35 +00:00
{
if (!bound())
return m_parameterNames;
return vector<string>(m_parameterNames.cbegin() + 1, m_parameterNames.cend());
}
TypePointers FunctionType::parameterTypes() const
{
if (!bound())
return m_parameterTypes;
return TypePointers(m_parameterTypes.cbegin() + 1, m_parameterTypes.cend());
}
2014-10-29 18:28:30 +00:00
bool FunctionType::operator==(Type const& _other) const
2014-10-20 10:41:56 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-10-20 10:41:56 +00:00
return false;
FunctionType const& other = dynamic_cast<FunctionType const&>(_other);
2014-12-04 18:38:24 +00:00
if (m_location != other.m_location)
return false;
2015-01-29 16:28:14 +00:00
if (m_isConstant != other.isConstant())
return false;
if (m_parameterTypes.size() != other.m_parameterTypes.size() ||
m_returnParameterTypes.size() != other.m_returnParameterTypes.size())
return false;
auto typeCompare = [](TypePointer const& _a, TypePointer const& _b) -> bool { return *_a == *_b; };
if (!equal(m_parameterTypes.cbegin(), m_parameterTypes.cend(),
other.m_parameterTypes.cbegin(), typeCompare))
return false;
if (!equal(m_returnParameterTypes.cbegin(), m_returnParameterTypes.cend(),
other.m_returnParameterTypes.cbegin(), typeCompare))
return false;
//@todo this is ugly, but cannot be prevented right now
if (m_gasSet != other.m_gasSet || m_valueSet != other.m_valueSet)
return false;
if (bound() != other.bound())
return false;
if (bound() && *selfType() != *other.selfType())
return false;
return true;
2014-10-20 10:41:56 +00:00
}
2016-11-09 08:36:38 +00:00
TypePointer FunctionType::unaryOperatorResult(Token::Value _operator) const
{
if (_operator == Token::Value::Delete)
return make_shared<TupleType>();
return TypePointer();
}
string FunctionType::canonicalName(bool) const
{
solAssert(m_location == Location::External, "");
return "function";
}
string FunctionType::toString(bool _short) const
2014-11-13 00:12:57 +00:00
{
string name = "function (";
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
name += (*it)->toString(_short) + (it + 1 == m_parameterTypes.end() ? "" : ",");
name += ")";
2016-09-27 19:37:32 +00:00
if (m_isConstant)
name += " constant";
2016-09-27 19:37:32 +00:00
if (m_isPayable)
name += " payable";
2016-09-27 19:37:32 +00:00
if (m_location == Location::External)
name += " external";
if (!m_returnParameterTypes.empty())
{
name += " returns (";
for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
name += (*it)->toString(_short) + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
name += ")";
}
return name;
2014-11-13 00:12:57 +00:00
}
2016-09-27 19:37:32 +00:00
unsigned FunctionType::calldataEncodedSize(bool _padded) const
{
unsigned size = storageBytes();
if (_padded)
size = ((size + 31) / 32) * 32;
return size;
}
2015-08-31 16:44:29 +00:00
u256 FunctionType::storageSize() const
2015-03-13 09:52:34 +00:00
{
2016-09-27 19:37:32 +00:00
if (m_location == Location::External || m_location == Location::Internal)
return 1;
else
BOOST_THROW_EXCEPTION(
InternalCompilerError()
<< errinfo_comment("Storage size of non-storable function type requested."));
}
unsigned FunctionType::storageBytes() const
{
if (m_location == Location::External)
return 20 + 4;
else if (m_location == Location::Internal)
return 8; // it should really not be possible to create larger programs
else
BOOST_THROW_EXCEPTION(
InternalCompilerError()
<< errinfo_comment("Storage size of non-storable function type requested."));
2015-03-13 09:52:34 +00:00
}
2015-08-31 16:44:29 +00:00
unsigned FunctionType::sizeOnStack() const
{
2015-02-22 17:38:32 +00:00
Location location = m_location;
if (m_location == Location::SetGas || m_location == Location::SetValue)
{
solAssert(m_returnParameterTypes.size() == 1, "");
location = dynamic_cast<FunctionType const&>(*m_returnParameterTypes.front()).m_location;
}
unsigned size = 0;
if (location == Location::External || location == Location::CallCode || location == Location::DelegateCall)
size = 2;
else if (location == Location::Bare || location == Location::BareCallCode || location == Location::BareDelegateCall)
size = 1;
else if (location == Location::Internal)
size = 1;
else if (location == Location::ArrayPush || location == Location::ByteArrayPush)
size = 1;
if (m_gasSet)
size++;
if (m_valueSet)
size++;
2015-11-25 13:23:35 +00:00
if (bound())
size += m_parameterTypes.front()->sizeOnStack();
return size;
}
FunctionTypePointer FunctionType::interfaceFunctionType() const
{
// Note that m_declaration might also be a state variable!
solAssert(m_declaration, "Declaration needed to determine interface function type.");
bool isLibraryFunction = dynamic_cast<ContractDefinition const&>(*m_declaration->scope()).isLibrary();
TypePointers paramTypes;
TypePointers retParamTypes;
for (auto type: m_parameterTypes)
2015-03-27 16:07:32 +00:00
{
if (auto ext = type->interfaceType(isLibraryFunction))
paramTypes.push_back(ext);
else
return FunctionTypePointer();
2015-03-27 16:07:32 +00:00
}
for (auto type: m_returnParameterTypes)
2015-03-27 16:07:32 +00:00
{
if (auto ext = type->interfaceType(isLibraryFunction))
retParamTypes.push_back(ext);
else
return FunctionTypePointer();
2015-03-27 16:07:32 +00:00
}
auto variable = dynamic_cast<VariableDeclaration const*>(m_declaration);
if (variable && retParamTypes.empty())
return FunctionTypePointer();
return make_shared<FunctionType>(
paramTypes, retParamTypes,
m_parameterNames, m_returnParameterNames,
m_location, m_arbitraryParameters,
m_declaration, m_isConstant, m_isPayable
);
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap FunctionType::nativeMembers(ContractDefinition const*) const
2014-11-25 17:23:39 +00:00
{
switch (m_location)
{
2015-02-09 13:08:48 +00:00
case Location::External:
case Location::Creation:
case Location::ECRecover:
case Location::SHA256:
case Location::RIPEMD160:
2015-02-09 13:08:48 +00:00
case Location::Bare:
case Location::BareCallCode:
case Location::BareDelegateCall:
2015-11-25 13:23:35 +00:00
{
MemberList::MemberMap members;
if (m_location != Location::BareDelegateCall && m_location != Location::DelegateCall)
{
if (m_isPayable)
members.push_back(MemberList::Member(
"value",
make_shared<FunctionType>(
parseElementaryTypeVector({"uint"}),
TypePointers{copyAndSetGasOrValue(false, true)},
strings(),
strings(),
Location::SetValue,
false,
nullptr,
false,
false,
m_gasSet,
m_valueSet
)
));
}
2015-11-25 13:23:35 +00:00
if (m_location != Location::Creation)
members.push_back(MemberList::Member(
"gas",
make_shared<FunctionType>(
parseElementaryTypeVector({"uint"}),
TypePointers{copyAndSetGasOrValue(true, false)},
strings(),
strings(),
Location::SetGas,
false,
nullptr,
false,
false,
m_gasSet,
m_valueSet
2015-11-25 13:23:35 +00:00
)
));
2015-11-25 13:23:35 +00:00
return members;
}
2014-11-25 17:23:39 +00:00
default:
2015-11-25 13:23:35 +00:00
return MemberList::MemberMap();
2014-11-25 17:23:39 +00:00
}
}
2016-09-28 17:22:23 +00:00
TypePointer FunctionType::encodingType() const
{
// Only external functions can be encoded, internal functions cannot leave code boundaries.
if (m_location == Location::External)
return shared_from_this();
else
return TypePointer();
}
TypePointer FunctionType::interfaceType(bool /*_inLibrary*/) const
2016-09-27 19:37:32 +00:00
{
2016-10-19 14:39:16 +00:00
if (m_location == Location::External)
return shared_from_this();
2016-10-19 14:39:16 +00:00
else
return TypePointer();
2016-09-27 19:37:32 +00:00
}
bool FunctionType::canTakeArguments(TypePointers const& _argumentTypes, TypePointer const& _selfType) const
{
solAssert(!bound() || _selfType, "");
if (bound() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
return false;
2015-11-25 13:23:35 +00:00
TypePointers paramTypes = parameterTypes();
if (takesArbitraryParameters())
return true;
2015-08-31 16:44:29 +00:00
else if (_argumentTypes.size() != paramTypes.size())
return false;
else
2016-02-18 12:29:02 +00:00
return equal(
_argumentTypes.cbegin(),
_argumentTypes.cend(),
2015-08-31 16:44:29 +00:00
paramTypes.cbegin(),
[](TypePointer const& argumentType, TypePointer const& parameterType)
{
return argumentType->isImplicitlyConvertibleTo(*parameterType);
}
);
}
bool FunctionType::hasEqualArgumentTypes(FunctionType const& _other) const
{
if (m_parameterTypes.size() != _other.m_parameterTypes.size())
return false;
return equal(
m_parameterTypes.cbegin(),
m_parameterTypes.cend(),
_other.m_parameterTypes.cbegin(),
[](TypePointer const& _a, TypePointer const& _b) -> bool { return *_a == *_b; }
);
}
bool FunctionType::isBareCall() const
{
switch (m_location)
{
case Location::Bare:
case Location::BareCallCode:
case Location::BareDelegateCall:
case Location::ECRecover:
case Location::SHA256:
case Location::RIPEMD160:
return true;
default:
return false;
}
}
string FunctionType::externalSignature() const
{
solAssert(m_declaration != nullptr, "External signature of function needs declaration");
bool _inLibrary = dynamic_cast<ContractDefinition const&>(*m_declaration->scope()).isLibrary();
string ret = m_declaration->name() + "(";
FunctionTypePointer external = interfaceFunctionType();
2015-04-21 08:59:48 +00:00
solAssert(!!external, "External function type requested.");
2015-08-31 16:44:29 +00:00
TypePointers externalParameterTypes = external->parameterTypes();
for (auto it = externalParameterTypes.cbegin(); it != externalParameterTypes.cend(); ++it)
{
solAssert(!!(*it), "Parameter should have external type");
ret += (*it)->canonicalName(_inLibrary) + (it + 1 == externalParameterTypes.cend() ? "" : ",");
}
return ret + ")";
}
u256 FunctionType::externalIdentifier() const
{
2016-10-05 10:30:28 +00:00
return FixedHash<4>::Arith(FixedHash<4>(dev::keccak256(externalSignature())));
}
2015-01-12 12:29:16 +00:00
TypePointers FunctionType::parseElementaryTypeVector(strings const& _types)
{
TypePointers pointers;
pointers.reserve(_types.size());
for (string const& type: _types)
2015-02-10 16:53:43 +00:00
pointers.push_back(Type::fromElementaryTypeName(type));
return pointers;
}
TypePointer FunctionType::copyAndSetGasOrValue(bool _setGas, bool _setValue) const
{
return make_shared<FunctionType>(
m_parameterTypes,
m_returnParameterTypes,
m_parameterNames,
m_returnParameterNames,
m_location,
m_arbitraryParameters,
2015-06-22 16:05:13 +00:00
m_declaration,
m_isConstant,
m_isPayable,
m_gasSet || _setGas,
2015-11-25 13:23:35 +00:00
m_valueSet || _setValue,
m_bound
);
}
2015-11-25 13:23:35 +00:00
FunctionTypePointer FunctionType::asMemberFunction(bool _inLibrary, bool _bound) const
2015-06-22 16:05:13 +00:00
{
if (_bound && m_parameterTypes.empty())
return FunctionTypePointer();
2015-06-22 18:50:29 +00:00
TypePointers parameterTypes;
for (auto const& t: m_parameterTypes)
{
auto refType = dynamic_cast<ReferenceType const*>(t.get());
if (refType && refType->location() == DataLocation::CallData)
parameterTypes.push_back(refType->copyForLocation(DataLocation::Memory, false));
else
parameterTypes.push_back(t);
}
Location location = m_location;
if (_inLibrary)
{
solAssert(!!m_declaration, "Declaration has to be available.");
if (!m_declaration->isPublic())
location = Location::Internal; // will be inlined
else
location = Location::DelegateCall;
}
2016-06-01 21:39:19 +00:00
TypePointers returnParameterTypes = m_returnParameterTypes;
if (location != Location::Internal)
{
2016-06-01 21:39:19 +00:00
// Alter dynamic types to be non-accessible.
for (auto& param: returnParameterTypes)
if (param->isDynamicallySized())
param = make_shared<InaccessibleDynamicType>();
}
2015-06-22 16:05:13 +00:00
return make_shared<FunctionType>(
2015-06-22 18:50:29 +00:00
parameterTypes,
2015-06-22 16:05:13 +00:00
returnParameterTypes,
m_parameterNames,
2016-06-01 21:39:19 +00:00
m_returnParameterNames,
location,
2015-06-22 16:05:13 +00:00
m_arbitraryParameters,
m_declaration,
m_isConstant,
m_isPayable,
2015-06-22 16:05:13 +00:00
m_gasSet,
2015-11-25 13:23:35 +00:00
m_valueSet,
_bound
2015-06-22 16:05:13 +00:00
);
}
vector<string> const FunctionType::parameterTypeNames(bool _addDataLocation) const
{
vector<string> names;
2015-11-25 13:23:35 +00:00
for (TypePointer const& t: parameterTypes())
names.push_back(t->canonicalName(_addDataLocation));
return names;
}
vector<string> const FunctionType::returnParameterTypeNames(bool _addDataLocation) const
{
vector<string> names;
for (TypePointer const& t: m_returnParameterTypes)
names.push_back(t->canonicalName(_addDataLocation));
return names;
}
2015-11-25 13:23:35 +00:00
TypePointer FunctionType::selfType() const
{
solAssert(bound(), "Function is not bound.");
solAssert(m_parameterTypes.size() > 0, "Function has no self type.");
2015-11-25 13:23:35 +00:00
return m_parameterTypes.at(0);
}
2015-08-31 16:44:29 +00:00
ASTPointer<ASTString> FunctionType::documentation() const
{
2015-01-29 16:28:14 +00:00
auto function = dynamic_cast<Documented const*>(m_declaration);
if (function)
2015-08-31 16:44:29 +00:00
return function->documentation();
return ASTPointer<ASTString>();
}
2014-10-29 18:28:30 +00:00
bool MappingType::operator==(Type const& _other) const
2014-10-20 10:41:56 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-10-20 10:41:56 +00:00
return false;
MappingType const& other = dynamic_cast<MappingType const&>(_other);
return *other.m_keyType == *m_keyType && *other.m_valueType == *m_valueType;
}
string MappingType::toString(bool _short) const
2014-11-13 00:12:57 +00:00
{
2015-08-31 16:44:29 +00:00
return "mapping(" + keyType()->toString(_short) + " => " + valueType()->toString(_short) + ")";
2014-11-13 00:12:57 +00:00
}
string MappingType::canonicalName(bool) const
{
return "mapping(" + keyType()->canonicalName(false) + " => " + valueType()->canonicalName(false) + ")";
}
2014-10-29 18:28:30 +00:00
bool TypeType::operator==(Type const& _other) const
2014-10-20 10:41:56 +00:00
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
2014-10-20 10:41:56 +00:00
return false;
TypeType const& other = dynamic_cast<TypeType const&>(_other);
2015-08-31 16:44:29 +00:00
return *actualType() == *other.actualType();
2014-10-20 10:41:56 +00:00
}
2014-10-13 16:22:15 +00:00
2015-08-31 16:44:29 +00:00
u256 TypeType::storageSize() const
2015-03-13 09:52:34 +00:00
{
BOOST_THROW_EXCEPTION(
InternalCompilerError()
<< errinfo_comment("Storage size of non-storable type type requested."));
}
2015-09-10 17:40:07 +00:00
unsigned TypeType::sizeOnStack() const
{
if (auto contractType = dynamic_cast<ContractType const*>(m_actualType.get()))
if (contractType->contractDefinition().isLibrary())
return 1;
return 0;
}
2015-11-25 13:23:35 +00:00
MemberList::MemberMap TypeType::nativeMembers(ContractDefinition const* _currentScope) const
2015-01-19 18:18:34 +00:00
{
2015-11-25 13:23:35 +00:00
MemberList::MemberMap members;
if (m_actualType->category() == Category::Contract)
2015-01-19 18:18:34 +00:00
{
2015-11-25 13:23:35 +00:00
ContractDefinition const& contract = dynamic_cast<ContractType const&>(*m_actualType).contractDefinition();
bool isBase = false;
if (_currentScope != nullptr)
{
auto const& currentBases = _currentScope->annotation().linearizedBaseContracts;
isBase = (find(currentBases.begin(), currentBases.end(), &contract) != currentBases.end());
}
2015-11-25 13:23:35 +00:00
if (contract.isLibrary())
for (FunctionDefinition const* function: contract.definedFunctions())
if (function->isVisibleInDerivedContracts())
members.push_back(MemberList::Member(
function->name(),
FunctionType(*function).asMemberFunction(true),
function
));
if (isBase)
{
// We are accessing the type of a base contract, so add all public and protected
// members. Note that this does not add inherited functions on purpose.
for (Declaration const* decl: contract.inheritableMembers())
members.push_back(MemberList::Member(decl->name(), decl->type(), decl));
}
else
{
for (auto const& stru: contract.definedStructs())
members.push_back(MemberList::Member(stru->name(), stru->type(), stru));
for (auto const& enu: contract.definedEnums())
members.push_back(MemberList::Member(enu->name(), enu->type(), enu));
}
2015-01-19 18:18:34 +00:00
}
2015-11-25 13:23:35 +00:00
else if (m_actualType->category() == Category::Enum)
{
EnumDefinition const& enumDef = dynamic_cast<EnumType const&>(*m_actualType).enumDefinition();
auto enumType = make_shared<EnumType>(enumDef);
for (ASTPointer<EnumValue> const& enumValue: enumDef.members())
members.push_back(MemberList::Member(enumValue->name(), enumType));
}
return members;
2015-01-19 18:18:34 +00:00
}
ModifierType::ModifierType(const ModifierDefinition& _modifier)
{
TypePointers params;
2015-08-31 16:44:29 +00:00
params.reserve(_modifier.parameters().size());
for (ASTPointer<VariableDeclaration> const& var: _modifier.parameters())
params.push_back(var->annotation().type);
swap(params, m_parameterTypes);
}
2015-08-31 16:44:29 +00:00
u256 ModifierType::storageSize() const
2015-03-13 09:52:34 +00:00
{
BOOST_THROW_EXCEPTION(
InternalCompilerError()
<< errinfo_comment("Storage size of non-storable type type requested."));
}
bool ModifierType::operator==(Type const& _other) const
{
2015-08-31 16:44:29 +00:00
if (_other.category() != category())
return false;
ModifierType const& other = dynamic_cast<ModifierType const&>(_other);
if (m_parameterTypes.size() != other.m_parameterTypes.size())
return false;
auto typeCompare = [](TypePointer const& _a, TypePointer const& _b) -> bool { return *_a == *_b; };
if (!equal(m_parameterTypes.cbegin(), m_parameterTypes.cend(),
other.m_parameterTypes.cbegin(), typeCompare))
return false;
return true;
}
string ModifierType::toString(bool _short) const
{
string name = "modifier (";
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
name += (*it)->toString(_short) + (it + 1 == m_parameterTypes.end() ? "" : ",");
return name + ")";
}
2015-01-19 18:18:34 +00:00
2015-12-15 14:46:03 +00:00
bool ModuleType::operator==(Type const& _other) const
2015-11-25 13:23:35 +00:00
{
2015-12-15 14:46:03 +00:00
if (_other.category() != category())
return false;
return &m_sourceUnit == &dynamic_cast<ModuleType const&>(_other).m_sourceUnit;
}
MemberList::MemberMap ModuleType::nativeMembers(ContractDefinition const*) const
{
MemberList::MemberMap symbols;
for (auto const& symbolName: m_sourceUnit.annotation().exportedSymbols)
for (Declaration const* symbol: symbolName.second)
symbols.push_back(MemberList::Member(symbolName.first, symbol->type(), symbol));
return symbols;
}
string ModuleType::toString(bool) const
{
return string("module \"") + m_sourceUnit.annotation().path + string("\"");
2015-11-25 13:23:35 +00:00
}
bool MagicType::operator==(Type const& _other) const
{
if (_other.category() != category())
return false;
MagicType const& other = dynamic_cast<MagicType const&>(_other);
return other.m_kind == m_kind;
}
MemberList::MemberMap MagicType::nativeMembers(ContractDefinition const*) const
2014-11-24 12:23:58 +00:00
{
switch (m_kind)
{
2015-02-09 13:08:48 +00:00
case Kind::Block:
2015-11-25 13:23:35 +00:00
return MemberList::MemberMap({
{"coinbase", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"timestamp", make_shared<IntegerType>(256)},
{"blockhash", make_shared<FunctionType>(strings{"uint"}, strings{"bytes32"}, FunctionType::Location::BlockHash)},
{"difficulty", make_shared<IntegerType>(256)},
{"number", make_shared<IntegerType>(256)},
{"gaslimit", make_shared<IntegerType>(256)}
2015-06-08 10:09:24 +00:00
});
2015-02-09 13:08:48 +00:00
case Kind::Message:
2015-11-25 13:23:35 +00:00
return MemberList::MemberMap({
{"sender", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"gas", make_shared<IntegerType>(256)},
{"value", make_shared<IntegerType>(256)},
2015-06-17 10:01:39 +00:00
{"data", make_shared<ArrayType>(DataLocation::CallData)},
{"sig", make_shared<FixedBytesType>(4)}
2015-06-08 10:09:24 +00:00
});
2015-02-09 13:08:48 +00:00
case Kind::Transaction:
2015-11-25 13:23:35 +00:00
return MemberList::MemberMap({
{"origin", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"gasprice", make_shared<IntegerType>(256)}
2015-06-08 10:09:24 +00:00
});
2014-11-24 12:23:58 +00:00
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
}
}
string MagicType::toString(bool) const
2014-11-24 12:23:58 +00:00
{
switch (m_kind)
{
2015-02-09 13:08:48 +00:00
case Kind::Block:
2014-11-24 12:23:58 +00:00
return "block";
2015-02-09 13:08:48 +00:00
case Kind::Message:
2014-11-24 12:23:58 +00:00
return "msg";
2015-02-09 13:08:48 +00:00
case Kind::Transaction:
2014-11-24 12:23:58 +00:00
return "tx";
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
}
}