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-12-17 15:23:18 +00:00
|
|
|
#include <libsolidity/Utils.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-12-06 01:19:10 +00:00
|
|
|
shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2015-01-12 11:46:52 +00:00
|
|
|
solAssert(Token::isElementaryTypeName(_typeToken), "Elementary type name expected.");
|
2014-11-05 13:20:56 +00:00
|
|
|
|
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;
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerType>(bytes * 8,
|
2014-11-05 10:38:26 +00:00
|
|
|
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)
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS);
|
2014-10-16 12:08:54 +00:00
|
|
|
else if (_typeToken == Token::BOOL)
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<BoolType>();
|
2014-12-11 13:19:11 +00:00
|
|
|
else if (Token::STRING0 <= _typeToken && _typeToken <= Token::STRING32)
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<StaticStringType>(int(_typeToken) - int(Token::STRING0));
|
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-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-12-06 01:19:10 +00:00
|
|
|
shared_ptr<Type const> Type::fromUserDefinedTypeName(UserDefinedTypeName const& _typeName)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-20 17:33:23 +00:00
|
|
|
Declaration const* declaration = _typeName.getReferencedDeclaration();
|
|
|
|
if (StructDefinition const* structDef = dynamic_cast<StructDefinition const*>(declaration))
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<StructType>(*structDef);
|
2014-11-20 17:33:23 +00:00
|
|
|
else if (FunctionDefinition const* function = dynamic_cast<FunctionDefinition const*>(declaration))
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<FunctionType>(*function);
|
2014-11-20 17:33:23 +00:00
|
|
|
else if (ContractDefinition const* contract = dynamic_cast<ContractDefinition const*>(declaration))
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<ContractType>(*contract);
|
2014-12-06 01:19:10 +00:00
|
|
|
return shared_ptr<Type const>();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-12-06 01:19:10 +00:00
|
|
|
shared_ptr<Type const> Type::fromMapping(Mapping const& _typeName)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-11-10 16:31:09 +00:00
|
|
|
shared_ptr<Type const> keyType = _typeName.getKeyType().toType();
|
2014-11-20 17:33:23 +00:00
|
|
|
if (!keyType)
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Error resolving type name."));
|
2014-11-10 16:31:09 +00:00
|
|
|
shared_ptr<Type const> valueType = _typeName.getValueType().toType();
|
2014-11-20 17:33:23 +00:00
|
|
|
if (!valueType)
|
|
|
|
BOOST_THROW_EXCEPTION(_typeName.getValueType().createTypeError("Invalid type name"));
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<MappingType>(keyType, valueType);
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2014-12-06 01:19:10 +00:00
|
|
|
shared_ptr<Type const> 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:
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<BoolType>();
|
2014-10-13 16:22:15 +00:00
|
|
|
case Token::NUMBER:
|
2014-12-19 10:31:17 +00:00
|
|
|
return IntegerConstantType::fromLiteral(_literal.getValue());
|
2014-10-13 16:22:15 +00:00
|
|
|
case Token::STRING_LITERAL:
|
2014-12-09 17:46:18 +00:00
|
|
|
//@todo put larger strings into dynamic strings
|
|
|
|
return StaticStringType::smallestTypeForLiteral(_literal.getValue());
|
2014-10-13 16:22:15 +00:00
|
|
|
default:
|
2015-01-07 20:35:35 +00:00
|
|
|
return shared_ptr<Type>();
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-18 17:53:43 +00:00
|
|
|
TypePointer Type::commonType(TypePointer const& _a, TypePointer const& _b)
|
|
|
|
{
|
|
|
|
if (_b->isImplicitlyConvertibleTo(*_a))
|
|
|
|
return _a;
|
|
|
|
else if (_a->isImplicitlyConvertibleTo(*_b))
|
|
|
|
return _b;
|
|
|
|
else
|
|
|
|
return TypePointer();
|
|
|
|
}
|
|
|
|
|
2014-11-20 09:19:43 +00:00
|
|
|
const MemberList Type::EmptyMemberList = MemberList();
|
|
|
|
|
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;
|
2014-12-17 15:23:18 +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
|
|
|
|
{
|
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-12-04 18:38:24 +00:00
|
|
|
return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::CONTRACT;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2015-01-06 18:08:24 +00:00
|
|
|
TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2015-01-06 18:08:24 +00:00
|
|
|
// "delete" is ok for all integer types
|
2014-10-20 10:41:56 +00:00
|
|
|
if (_operator == Token::DELETE)
|
2015-01-14 12:52:03 +00:00
|
|
|
return make_shared<VoidType>();
|
2015-01-06 18:08:24 +00:00
|
|
|
// no further unary operators for addresses
|
|
|
|
else if (isAddress())
|
|
|
|
return TypePointer();
|
|
|
|
// "~" is ok for all other types
|
|
|
|
else if (_operator == Token::BIT_NOT)
|
|
|
|
return shared_from_this();
|
|
|
|
// nothing else for hashes
|
|
|
|
else if (isHash())
|
|
|
|
return TypePointer();
|
|
|
|
// for non-hash integers, we allow +, -, ++ and --
|
|
|
|
else if (_operator == Token::ADD || _operator == Token::SUB ||
|
|
|
|
_operator == Token::INC || _operator == Token::DEC)
|
|
|
|
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
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-01-06 17:55:31 +00:00
|
|
|
TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
|
2014-12-18 17:53:43 +00:00
|
|
|
{
|
2014-12-19 10:31:17 +00:00
|
|
|
if (_other->getCategory() != Category::INTEGER_CONSTANT && _other->getCategory() != getCategory())
|
2014-12-18 17:53:43 +00:00
|
|
|
return TypePointer();
|
2015-01-06 17:55:31 +00:00
|
|
|
auto commonType = dynamic_pointer_cast<IntegerType const>(Type::commonType(shared_from_this(), _other));
|
2014-12-18 17:53:43 +00:00
|
|
|
|
|
|
|
if (!commonType)
|
|
|
|
return TypePointer();
|
|
|
|
|
2014-12-28 12:35:58 +00:00
|
|
|
// All integer types can be compared
|
|
|
|
if (Token::isCompareOp(_operator))
|
|
|
|
return commonType;
|
|
|
|
|
|
|
|
// Nothing else can be done with addresses, but hashes can receive bit operators
|
2014-12-18 17:53:43 +00:00
|
|
|
if (commonType->isAddress())
|
2014-12-28 12:35:58 +00:00
|
|
|
return TypePointer();
|
|
|
|
else if (commonType->isHash() && !Token::isBitOp(_operator))
|
|
|
|
return TypePointer();
|
|
|
|
else
|
|
|
|
return commonType;
|
2014-12-18 17:53:43 +00:00
|
|
|
}
|
|
|
|
|
2014-11-25 13:43:23 +00:00
|
|
|
const MemberList IntegerType::AddressMemberList =
|
2015-01-12 11:46:52 +00:00
|
|
|
MemberList({{"balance", make_shared<IntegerType >(256)},
|
2015-01-12 12:29:16 +00:00
|
|
|
{"callstring32", make_shared<FunctionType>(strings{"string32"}, strings{},
|
|
|
|
FunctionType::Location::BARE)},
|
|
|
|
{"callstring32string32", make_shared<FunctionType>(strings{"string32", "string32"},
|
|
|
|
strings{}, FunctionType::Location::BARE)},
|
|
|
|
{"send", make_shared<FunctionType>(strings{"uint"}, strings{}, FunctionType::Location::SEND)}});
|
2014-11-21 18:14:56 +00:00
|
|
|
|
2014-12-19 10:31:17 +00:00
|
|
|
shared_ptr<IntegerConstantType const> IntegerConstantType::fromLiteral(string const& _literal)
|
|
|
|
{
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerConstantType>(bigint(_literal));
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerConstantType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
|
|
|
TypePointer integerType = getIntegerType();
|
|
|
|
return integerType && integerType->isImplicitlyConvertibleTo(_convertTo);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerConstantType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
|
|
|
TypePointer integerType = getIntegerType();
|
|
|
|
return integerType && integerType->isExplicitlyConvertibleTo(_convertTo);
|
|
|
|
}
|
|
|
|
|
|
|
|
TypePointer IntegerConstantType::unaryOperatorResult(Token::Value _operator) const
|
|
|
|
{
|
|
|
|
bigint value;
|
|
|
|
switch (_operator)
|
|
|
|
{
|
|
|
|
case Token::BIT_NOT:
|
|
|
|
value = ~m_value;
|
|
|
|
break;
|
|
|
|
case Token::ADD:
|
|
|
|
value = m_value;
|
|
|
|
break;
|
|
|
|
case Token::SUB:
|
|
|
|
value = -m_value;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return TypePointer();
|
|
|
|
}
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerConstantType>(value);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
|
|
|
|
{
|
|
|
|
if (_other->getCategory() == Category::INTEGER)
|
|
|
|
{
|
|
|
|
shared_ptr<IntegerType const> integerType = getIntegerType();
|
|
|
|
if (!integerType)
|
|
|
|
return TypePointer();
|
|
|
|
return integerType->binaryOperatorResult(_operator, _other);
|
|
|
|
}
|
|
|
|
else if (_other->getCategory() != getCategory())
|
|
|
|
return TypePointer();
|
|
|
|
|
|
|
|
IntegerConstantType const& other = dynamic_cast<IntegerConstantType const&>(*_other);
|
|
|
|
if (Token::isCompareOp(_operator))
|
|
|
|
{
|
|
|
|
shared_ptr<IntegerType const> thisIntegerType = getIntegerType();
|
|
|
|
shared_ptr<IntegerType const> otherIntegerType = other.getIntegerType();
|
|
|
|
if (!thisIntegerType || !otherIntegerType)
|
|
|
|
return TypePointer();
|
|
|
|
return thisIntegerType->binaryOperatorResult(_operator, otherIntegerType);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bigint value;
|
|
|
|
switch (_operator)
|
|
|
|
{
|
|
|
|
case Token::BIT_OR:
|
|
|
|
value = m_value | other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::BIT_XOR:
|
|
|
|
value = m_value ^ other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::BIT_AND:
|
|
|
|
value = m_value & other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::ADD:
|
|
|
|
value = m_value + other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::SUB:
|
|
|
|
value = m_value - other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::MUL:
|
|
|
|
value = m_value * other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::DIV:
|
|
|
|
if (other.m_value == 0)
|
|
|
|
return TypePointer();
|
|
|
|
value = m_value / other.m_value;
|
|
|
|
break;
|
|
|
|
case Token::MOD:
|
|
|
|
if (other.m_value == 0)
|
|
|
|
return TypePointer();
|
|
|
|
value = m_value % other.m_value;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return TypePointer();
|
|
|
|
}
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerConstantType>(value);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IntegerConstantType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
return m_value == dynamic_cast<IntegerConstantType const&>(_other).m_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
string IntegerConstantType::toString() const
|
|
|
|
{
|
|
|
|
return "int_const " + m_value.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
u256 IntegerConstantType::literalValue(Literal const*) const
|
|
|
|
{
|
|
|
|
// we ignore the literal and hope that the type was correctly determined
|
|
|
|
solAssert(m_value <= u256(-1), "Integer constant too large.");
|
|
|
|
solAssert(m_value >= -(bigint(1) << 255), "Integer constant too small.");
|
|
|
|
if (m_value >= 0)
|
|
|
|
return u256(m_value);
|
|
|
|
else
|
|
|
|
return s2u(s256(m_value));
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_ptr<IntegerType const> IntegerConstantType::getIntegerType() const
|
|
|
|
{
|
|
|
|
bigint value = m_value;
|
|
|
|
bool negative = (value < 0);
|
|
|
|
if (negative) // convert to positive number of same bit requirements
|
|
|
|
value = ((-value) - 1) << 1;
|
|
|
|
if (value > u256(-1))
|
|
|
|
return shared_ptr<IntegerType const>();
|
|
|
|
else
|
2015-01-07 20:35:35 +00:00
|
|
|
return make_shared<IntegerType>(max(bytesRequired(value), 1u) * 8,
|
|
|
|
negative ? IntegerType::Modifier::SIGNED
|
|
|
|
: IntegerType::Modifier::UNSIGNED);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2014-12-09 17:46:18 +00:00
|
|
|
shared_ptr<StaticStringType> StaticStringType::smallestTypeForLiteral(string const& _literal)
|
|
|
|
{
|
2014-12-11 13:19:11 +00:00
|
|
|
if (_literal.length() <= 32)
|
2014-12-09 17:46:18 +00:00
|
|
|
return make_shared<StaticStringType>(_literal.length());
|
|
|
|
return shared_ptr<StaticStringType>();
|
|
|
|
}
|
|
|
|
|
|
|
|
StaticStringType::StaticStringType(int _bytes): m_bytes(_bytes)
|
|
|
|
{
|
2014-12-17 15:23:18 +00:00
|
|
|
solAssert(m_bytes >= 0 && m_bytes <= 32,
|
|
|
|
"Invalid byte number for static string type: " + dev::toString(m_bytes));
|
2014-12-09 17:46:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool StaticStringType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
|
|
|
if (_convertTo.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
StaticStringType const& convertTo = dynamic_cast<StaticStringType const&>(_convertTo);
|
|
|
|
return convertTo.m_bytes >= m_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StaticStringType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
StaticStringType const& other = dynamic_cast<StaticStringType const&>(_other);
|
|
|
|
return other.m_bytes == m_bytes;
|
|
|
|
}
|
|
|
|
|
2014-12-19 10:31:17 +00:00
|
|
|
u256 StaticStringType::literalValue(const Literal* _literal) const
|
2014-12-09 17:46:18 +00:00
|
|
|
{
|
2014-12-19 10:31:17 +00:00
|
|
|
solAssert(_literal, "");
|
2014-12-09 17:46:18 +00:00
|
|
|
u256 value = 0;
|
2014-12-19 10:31:17 +00:00
|
|
|
for (char c: _literal->getValue())
|
2014-12-09 17:46:18 +00:00
|
|
|
value = (value << 8) | byte(c);
|
2014-12-19 10:31:17 +00:00
|
|
|
return value << ((32 - _literal->getValue().length()) * 8);
|
2014-12-09 17:46:18 +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-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, "");
|
|
|
|
if (_literal->getToken() == Token::TRUE_LITERAL)
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(1);
|
2014-12-19 10:31:17 +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
|
|
|
}
|
|
|
|
|
2015-01-14 12:52:03 +00:00
|
|
|
TypePointer BoolType::unaryOperatorResult(Token::Value _operator) const
|
|
|
|
{
|
|
|
|
if (_operator == Token::DELETE)
|
|
|
|
return make_shared<VoidType>();
|
|
|
|
return (_operator == Token::NOT) ? shared_from_this() : TypePointer();
|
|
|
|
}
|
|
|
|
|
2015-01-06 17:55:31 +00:00
|
|
|
TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
|
2014-12-18 17:53:43 +00:00
|
|
|
{
|
|
|
|
if (getCategory() != _other->getCategory())
|
|
|
|
return TypePointer();
|
|
|
|
if (Token::isCompareOp(_operator) || _operator == Token::AND || _operator == Token::OR)
|
2015-01-06 17:55:31 +00:00
|
|
|
return _other;
|
2014-12-18 17:53:43 +00:00
|
|
|
else
|
|
|
|
return TypePointer();
|
|
|
|
}
|
|
|
|
|
2015-01-07 21:54:56 +00:00
|
|
|
bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-11-20 17:33:23 +00:00
|
|
|
{
|
2015-01-07 21:54:56 +00:00
|
|
|
if (*this == _convertTo)
|
2014-11-20 17:33:23 +00:00
|
|
|
return true;
|
|
|
|
if (_convertTo.getCategory() == Category::INTEGER)
|
|
|
|
return dynamic_cast<IntegerType const&>(_convertTo).isAddress();
|
2015-01-19 22:34:49 +00:00
|
|
|
if (_convertTo.getCategory() == Category::CONTRACT)
|
|
|
|
{
|
|
|
|
auto const& bases = getContractDefinition().getLinearizedBaseContracts();
|
|
|
|
return find(bases.begin(), bases.end(),
|
|
|
|
&dynamic_cast<ContractType const&>(_convertTo).getContractDefinition()) != bases.end();
|
|
|
|
}
|
2014-11-20 17:33:23 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-07 21:54:56 +00:00
|
|
|
bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
2015-01-19 22:34:49 +00:00
|
|
|
return isImplicitlyConvertibleTo(_convertTo) || _convertTo.getCategory() == Category::INTEGER ||
|
|
|
|
_convertTo.getCategory() == Category::CONTRACT;
|
2015-01-07 21:54:56 +00:00
|
|
|
}
|
|
|
|
|
2015-01-14 12:52:03 +00:00
|
|
|
TypePointer ContractType::unaryOperatorResult(Token::Value _operator) const
|
|
|
|
{
|
|
|
|
return _operator == Token::DELETE ? make_shared<VoidType>() : TypePointer();
|
|
|
|
}
|
|
|
|
|
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-11-20 17:33:23 +00:00
|
|
|
string ContractType::toString() const
|
|
|
|
{
|
|
|
|
return "contract " + m_contract.getName();
|
|
|
|
}
|
|
|
|
|
2014-12-04 18:38:24 +00:00
|
|
|
MemberList const& ContractType::getMembers() const
|
|
|
|
{
|
|
|
|
// We need to lazy-initialize it because of recursive references.
|
|
|
|
if (!m_members)
|
|
|
|
{
|
2015-01-07 21:54:56 +00:00
|
|
|
// All address members and all interface functions
|
|
|
|
map<string, shared_ptr<Type const>> members(IntegerType::AddressMemberList.begin(),
|
|
|
|
IntegerType::AddressMemberList.end());
|
2015-01-08 23:27:26 +00:00
|
|
|
for (auto const& it: m_contract.getInterfaceFunctions())
|
|
|
|
members[it.second->getName()] = make_shared<FunctionType>(*it.second, false);
|
2014-12-04 18:38:24 +00:00
|
|
|
m_members.reset(new MemberList(members));
|
|
|
|
}
|
|
|
|
return *m_members;
|
|
|
|
}
|
|
|
|
|
2014-12-12 15:49:26 +00:00
|
|
|
shared_ptr<FunctionType const> const& ContractType::getConstructorType() const
|
|
|
|
{
|
|
|
|
if (!m_constructorType)
|
|
|
|
{
|
2014-12-16 15:15:34 +00:00
|
|
|
FunctionDefinition const* constructor = m_contract.getConstructor();
|
|
|
|
if (constructor)
|
2015-01-07 20:35:35 +00:00
|
|
|
m_constructorType = make_shared<FunctionType>(*constructor);
|
2014-12-12 15:49:26 +00:00
|
|
|
else
|
2015-01-07 20:35:35 +00:00
|
|
|
m_constructorType = make_shared<FunctionType>(TypePointers(), TypePointers());
|
2014-12-12 15:49:26 +00:00
|
|
|
}
|
|
|
|
return m_constructorType;
|
|
|
|
}
|
|
|
|
|
2015-01-08 16:18:31 +00:00
|
|
|
u256 ContractType::getFunctionIdentifier(string const& _functionName) const
|
2014-12-04 18:38:24 +00:00
|
|
|
{
|
2015-01-07 15:39:21 +00:00
|
|
|
auto interfaceFunctions = m_contract.getInterfaceFunctions();
|
|
|
|
for (auto it = interfaceFunctions.cbegin(); it != interfaceFunctions.cend(); ++it)
|
|
|
|
if (it->second->getName() == _functionName)
|
2015-01-08 16:18:31 +00:00
|
|
|
return FixedHash<4>::Arith(it->first);
|
|
|
|
|
2015-01-07 21:54:56 +00:00
|
|
|
return Invalid256;
|
2014-12-04 18:38:24 +00:00
|
|
|
}
|
|
|
|
|
2015-01-14 12:52:03 +00:00
|
|
|
TypePointer StructType::unaryOperatorResult(Token::Value _operator) const
|
|
|
|
{
|
|
|
|
return _operator == Token::DELETE ? make_shared<VoidType>() : TypePointer();
|
|
|
|
}
|
|
|
|
|
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-11-07 01:06:37 +00:00
|
|
|
u256 StructType::getStorageSize() const
|
|
|
|
{
|
|
|
|
u256 size = 0;
|
2014-11-20 09:19:43 +00:00
|
|
|
for (pair<string, shared_ptr<Type const>> const& member: getMembers())
|
|
|
|
size += member.second->getStorageSize();
|
2014-11-07 01:06:37 +00:00
|
|
|
return max<u256>(1, size);
|
|
|
|
}
|
|
|
|
|
2014-11-13 00:12:57 +00:00
|
|
|
bool StructType::canLiveOutsideStorage() const
|
|
|
|
{
|
2014-11-20 09:19:43 +00:00
|
|
|
for (pair<string, shared_ptr<Type const>> const& member: getMembers())
|
|
|
|
if (!member.second->canLiveOutsideStorage())
|
2014-11-13 00:12:57 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
string StructType::toString() const
|
|
|
|
{
|
|
|
|
return string("struct ") + m_struct.getName();
|
|
|
|
}
|
|
|
|
|
2014-11-20 09:19:43 +00:00
|
|
|
MemberList const& StructType::getMembers() const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2014-11-20 09:19:43 +00:00
|
|
|
// We need to lazy-initialize it because of recursive references.
|
|
|
|
if (!m_members)
|
|
|
|
{
|
|
|
|
map<string, shared_ptr<Type const>> members;
|
|
|
|
for (ASTPointer<VariableDeclaration> const& variable: m_struct.getMembers())
|
|
|
|
members[variable->getName()] = variable->getType();
|
|
|
|
m_members.reset(new MemberList(members));
|
|
|
|
}
|
|
|
|
return *m_members;
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2014-11-20 09:19:43 +00:00
|
|
|
u256 StructType::getStorageOffsetOfMember(string const& _name) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
|
|
|
//@todo cache member offset?
|
|
|
|
u256 offset;
|
2014-11-20 09:19:43 +00:00
|
|
|
for (ASTPointer<VariableDeclaration> variable: m_struct.getMembers())
|
|
|
|
{
|
|
|
|
if (variable->getName() == _name)
|
|
|
|
return offset;
|
2014-12-02 16:53:25 +00:00
|
|
|
offset += variable->getType()->getStorageSize();
|
2014-11-20 09:19:43 +00:00
|
|
|
}
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage offset of non-existing member requested."));
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2015-01-14 10:01:42 +00:00
|
|
|
FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal):
|
|
|
|
m_location(_isInternal ? Location::INTERNAL : Location::EXTERNAL)
|
2014-11-25 13:43:23 +00:00
|
|
|
{
|
|
|
|
TypePointers params;
|
|
|
|
TypePointers retParams;
|
|
|
|
params.reserve(_function.getParameters().size());
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
|
|
|
|
params.push_back(var->getType());
|
|
|
|
retParams.reserve(_function.getReturnParameters().size());
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _function.getReturnParameters())
|
|
|
|
retParams.push_back(var->getType());
|
|
|
|
swap(params, m_parameterTypes);
|
|
|
|
swap(retParams, m_returnParameterTypes);
|
|
|
|
}
|
|
|
|
|
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);
|
2014-11-25 13:43:23 +00:00
|
|
|
|
2014-12-04 18:38:24 +00:00
|
|
|
if (m_location != other.m_location)
|
|
|
|
return false;
|
2014-11-25 13:43:23 +00:00
|
|
|
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;
|
2015-01-12 11:47:37 +00:00
|
|
|
//@todo this is ugly, but cannot be prevented right now
|
|
|
|
if (m_gasSet != other.m_gasSet || m_valueSet != other.m_valueSet)
|
|
|
|
return false;
|
2014-11-25 13:43:23 +00:00
|
|
|
return true;
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2014-11-13 00:12:57 +00:00
|
|
|
string FunctionType::toString() const
|
|
|
|
{
|
2014-11-25 13:43:23 +00:00
|
|
|
string name = "function (";
|
|
|
|
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
|
|
|
|
name += (*it)->toString() + (it + 1 == m_parameterTypes.end() ? "" : ",");
|
|
|
|
name += ") returns (";
|
|
|
|
for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
|
|
|
|
name += (*it)->toString() + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
|
|
|
|
return name + ")";
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2014-11-25 17:23:39 +00:00
|
|
|
unsigned FunctionType::getSizeOnStack() const
|
2015-01-12 11:47:37 +00:00
|
|
|
{
|
|
|
|
unsigned size = 0;
|
|
|
|
if (m_location == Location::EXTERNAL)
|
|
|
|
size = 2;
|
|
|
|
else if (m_location == Location::INTERNAL || m_location == Location::BARE)
|
|
|
|
size = 1;
|
|
|
|
if (m_gasSet)
|
|
|
|
size++;
|
|
|
|
if (m_valueSet)
|
|
|
|
size++;
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
MemberList const& FunctionType::getMembers() const
|
2014-11-25 17:23:39 +00:00
|
|
|
{
|
|
|
|
switch (m_location)
|
|
|
|
{
|
|
|
|
case Location::EXTERNAL:
|
2015-01-13 17:12:19 +00:00
|
|
|
case Location::CREATION:
|
2015-01-12 11:47:37 +00:00
|
|
|
case Location::ECRECOVER:
|
|
|
|
case Location::SHA256:
|
|
|
|
case Location::RIPEMD160:
|
2014-12-10 22:01:40 +00:00
|
|
|
case Location::BARE:
|
2015-01-12 11:47:37 +00:00
|
|
|
if (!m_members)
|
|
|
|
{
|
|
|
|
map<string, TypePointer> members{
|
|
|
|
{"gas", make_shared<FunctionType>(parseElementaryTypeVector({"uint"}),
|
|
|
|
TypePointers{copyAndSetGasOrValue(true, false)},
|
|
|
|
Location::SET_GAS, m_gasSet, m_valueSet)},
|
|
|
|
{"value", make_shared<FunctionType>(parseElementaryTypeVector({"uint"}),
|
|
|
|
TypePointers{copyAndSetGasOrValue(false, true)},
|
|
|
|
Location::SET_VALUE, m_gasSet, m_valueSet)}};
|
2015-01-13 17:12:19 +00:00
|
|
|
if (m_location == Location::CREATION)
|
|
|
|
members.erase("gas");
|
2015-01-12 11:47:37 +00:00
|
|
|
m_members.reset(new MemberList(members));
|
|
|
|
}
|
|
|
|
return *m_members;
|
2014-11-25 17:23:39 +00:00
|
|
|
default:
|
2015-01-12 11:47:37 +00:00
|
|
|
return EmptyMemberList;
|
2014-11-25 17:23:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-07 09:45:59 +00:00
|
|
|
string FunctionType::getCanonicalSignature() const
|
2015-01-07 01:27:05 +00:00
|
|
|
{
|
2015-01-07 09:45:59 +00:00
|
|
|
string ret = "(";
|
2015-01-07 01:27:05 +00:00
|
|
|
|
2015-01-07 09:45:59 +00:00
|
|
|
for (auto it = m_parameterTypes.cbegin(); it != m_parameterTypes.cend(); ++it)
|
|
|
|
ret += (*it)->toString() + (it + 1 == m_parameterTypes.cend() ? "" : ",");
|
2015-01-07 01:27:05 +00:00
|
|
|
|
|
|
|
return ret + ")";
|
|
|
|
}
|
|
|
|
|
2015-01-12 12:29:16 +00:00
|
|
|
TypePointers FunctionType::parseElementaryTypeVector(strings const& _types)
|
2015-01-12 11:46:52 +00:00
|
|
|
{
|
|
|
|
TypePointers pointers;
|
|
|
|
pointers.reserve(_types.size());
|
|
|
|
for (string const& type: _types)
|
|
|
|
pointers.push_back(Type::fromElementaryTypeName(Token::fromIdentifierOrKeyword(type)));
|
|
|
|
return pointers;
|
|
|
|
}
|
|
|
|
|
2015-01-12 11:47:37 +00:00
|
|
|
TypePointer FunctionType::copyAndSetGasOrValue(bool _setGas, bool _setValue) const
|
|
|
|
{
|
|
|
|
return make_shared<FunctionType>(m_parameterTypes, m_returnParameterTypes, m_location,
|
|
|
|
m_gasSet || _setGas, m_valueSet || _setValue);
|
|
|
|
}
|
|
|
|
|
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-11-13 00:12:57 +00:00
|
|
|
string MappingType::toString() const
|
|
|
|
{
|
|
|
|
return "mapping(" + getKeyType()->toString() + " => " + getValueType()->toString() + ")";
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-01-19 18:18:34 +00:00
|
|
|
MemberList const& TypeType::getMembers() const
|
|
|
|
{
|
|
|
|
// We need to lazy-initialize it because of recursive references.
|
|
|
|
if (!m_members)
|
|
|
|
{
|
|
|
|
map<string, TypePointer> members;
|
|
|
|
if (m_actualType->getCategory() == Category::CONTRACT && m_currentContract != nullptr)
|
|
|
|
{
|
|
|
|
ContractDefinition const& contract = dynamic_cast<ContractType const&>(*m_actualType).getContractDefinition();
|
|
|
|
vector<ContractDefinition const*> currentBases = m_currentContract->getLinearizedBaseContracts();
|
|
|
|
if (find(currentBases.begin(), currentBases.end(), &contract) != currentBases.end())
|
|
|
|
// We are accessing the type of a base contract, so add all public and private
|
|
|
|
// functions. Note that this does not add inherited functions on purpose.
|
|
|
|
for (ASTPointer<FunctionDefinition> const& f: contract.getDefinedFunctions())
|
2015-01-20 14:58:04 +00:00
|
|
|
if (!f->isConstructor())
|
2015-01-19 18:18:34 +00:00
|
|
|
members[f->getName()] = make_shared<FunctionType>(*f);
|
|
|
|
}
|
|
|
|
m_members.reset(new MemberList(members));
|
|
|
|
}
|
|
|
|
return *m_members;
|
|
|
|
}
|
|
|
|
|
2015-01-22 00:02:38 +00:00
|
|
|
ModifierType::ModifierType(const ModifierDefinition& _modifier)
|
|
|
|
{
|
|
|
|
TypePointers params;
|
|
|
|
params.reserve(_modifier.getParameters().size());
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _modifier.getParameters())
|
|
|
|
params.push_back(var->getType());
|
|
|
|
swap(params, m_parameterTypes);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ModifierType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
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() const
|
|
|
|
{
|
|
|
|
string name = "modifier (";
|
|
|
|
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
|
|
|
|
name += (*it)->toString() + (it + 1 == m_parameterTypes.end() ? "" : ",");
|
|
|
|
return name + ")";
|
|
|
|
}
|
2015-01-19 18:18:34 +00:00
|
|
|
|
2014-11-24 12:23:58 +00:00
|
|
|
MagicType::MagicType(MagicType::Kind _kind):
|
|
|
|
m_kind(_kind)
|
|
|
|
{
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
|
|
|
case Kind::BLOCK:
|
2015-01-07 20:35:35 +00:00
|
|
|
m_members = MemberList({{"coinbase", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)},
|
2015-01-15 18:59:35 +00:00
|
|
|
{"timestamp", make_shared<IntegerType>(256)},
|
|
|
|
{"blockhash", make_shared<FunctionType>(strings{"uint"}, strings{"hash"}, FunctionType::Location::BLOCKHASH)},
|
2015-01-07 20:35:35 +00:00
|
|
|
{"difficulty", make_shared<IntegerType>(256)},
|
|
|
|
{"number", make_shared<IntegerType>(256)},
|
|
|
|
{"gaslimit", make_shared<IntegerType>(256)}});
|
2014-11-24 12:23:58 +00:00
|
|
|
break;
|
|
|
|
case Kind::MSG:
|
2015-01-07 20:35:35 +00:00
|
|
|
m_members = MemberList({{"sender", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)},
|
|
|
|
{"gas", make_shared<IntegerType>(256)},
|
|
|
|
{"value", make_shared<IntegerType>(256)}});
|
2014-11-24 12:23:58 +00:00
|
|
|
break;
|
|
|
|
case Kind::TX:
|
2015-01-07 20:35:35 +00:00
|
|
|
m_members = MemberList({{"origin", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)},
|
|
|
|
{"gasprice", make_shared<IntegerType>(256)}});
|
2014-11-24 12:23:58 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MagicType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.getCategory() != getCategory())
|
|
|
|
return false;
|
|
|
|
MagicType const& other = dynamic_cast<MagicType const&>(_other);
|
|
|
|
return other.m_kind == m_kind;
|
|
|
|
}
|
|
|
|
|
|
|
|
string MagicType::toString() const
|
|
|
|
{
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
|
|
|
case Kind::BLOCK:
|
|
|
|
return "block";
|
|
|
|
case Kind::MSG:
|
|
|
|
return "msg";
|
|
|
|
case Kind::TX:
|
|
|
|
return "tx";
|
|
|
|
default:
|
|
|
|
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of magic."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-16 12:08:54 +00:00
|
|
|
}
|
|
|
|
}
|