/*

This file is part of solidity.

solidity 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.

solidity 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.

You should have received a copy of the GNU General Public License

along with solidity. If not, see <http://www.gnu.org/licenses/>.

*/

// SPDX-License-Identifier: GPL-3.0

/**

* @author Christian <c@ethdev.com>

* @date 2014

* Solidity data types

*/

#include <libsolidity/ast/Types.h>

#include <libsolidity/ast/AST.h>

#include <libsolidity/ast/TypeProvider.h>

#include <libsolidity/analysis/ConstantEvaluator.h>

#include <libsolutil/Algorithms.h>

#include <libsolutil/CommonData.h>

#include <libsolutil/CommonIO.h>

#include <libsolutil/FunctionSelector.h>

#include <libsolutil/Keccak256.h>

#include <libsolutil/StringUtils.h>

#include <libsolutil/UTF8.h>

#include <libsolutil/Visitor.h>

#include <boost/algorithm/string.hpp>

#include <boost/algorithm/string/classification.hpp>

#include <boost/algorithm/string/join.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include <boost/algorithm/string/replace.hpp>

#include <boost/algorithm/string/split.hpp>

#include <range/v3/view/enumerate.hpp>

#include <range/v3/view/reverse.hpp>

#include <range/v3/view/tail.hpp>

#include <range/v3/view/transform.hpp>

#include <range/v3/view/filter.hpp>

#include <limits>

#include <unordered_set>

#include <utility>

using namespace std;

using namespace solidity;

using namespace solidity::langutil;

using namespace solidity::frontend;

namespace

{

/// Checks whether _mantissa * (10 ** _expBase10) fits into 4096 bits.

bool fitsPrecisionBase10(bigint const& _mantissa, uint32_t _expBase10)

{

double const log2Of10AwayFromZero = 3.3219280948873624;

return fitsPrecisionBaseX(_mantissa, log2Of10AwayFromZero, _expBase10);

}

/// Checks whether _value fits into IntegerType _type.

BoolResult fitsIntegerType(bigint const& _value, IntegerType const& _type)

{

if (_value < 0 && !_type.isSigned())

return BoolResult::err("Cannot implicitly convert signed literal to unsigned type.");

if (_type.minValue() > _value || _value > _type.maxValue())

return BoolResult::err("Literal is too large to fit in " + _type.toString(false) + ".");

return true;

}

/// Checks whether _value fits into _bits bits when having 1 bit as the sign bit

/// if _signed is true.

bool fitsIntoBits(bigint const& _value, unsigned _bits, bool _signed)

{

return fitsIntegerType(

_value,

*TypeProvider::integer(

_bits,

_signed ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned

)

);

}

util::Result<TypePointers> transformParametersToExternal(TypePointers const& _parameters, bool _inLibrary)

{

TypePointers transformed;

for (auto const& type: _parameters)

{

if (!type)

return util::Result<TypePointers>::err("Type information not present.");

else if (Type const* ext = type->interfaceType(_inLibrary).get())

transformed.push_back(ext);

else

return util::Result<TypePointers>::err("Parameter should have external type.");

}

return transformed;

}

string toStringInParentheses(TypePointers const& _types, bool _withoutDataLocation)

{

return '(' + util::joinHumanReadable(

_types | ranges::views::transform([&](auto const* _type) { return _type->toString(_withoutDataLocation); }),

","

) + ')';

}

}

MemberList::Member::Member(Declaration const* _declaration, Type const* _type):

Member(_declaration, _type, _declaration->name())

{}

MemberList::Member::Member(Declaration const* _declaration, Type const* _type, string _name):

name(std::move(_name)),

type(_type),

declaration(_declaration)

{

}

void Type::clearCache() const

{

m_members.clear();

m_stackItems.reset();

m_stackSize.reset();

}

void StorageOffsets::computeOffsets(TypePointers const& _types)

{

bigint slotOffset = 0;

unsigned byteOffset = 0;

map<size_t, pair<u256, unsigned>> offsets;

for (size_t i = 0; i < _types.size(); ++i)

{

Type const* type = _types[i];

if (!type->canBeStored())

continue;

if (byteOffset + type->storageBytes() > 32)

{

// would overflow, go to next slot

++slotOffset;

byteOffset = 0;

}

solAssert(slotOffset < bigint(1) << 256 ,"Object too large for storage.");

offsets[i] = make_pair(u256(slotOffset), byteOffset);

solAssert(type->storageSize() >= 1, "Invalid storage size.");

if (type->storageSize() == 1 && byteOffset + type->storageBytes() <= 32)

byteOffset += type->storageBytes();

else

{

slotOffset += type->storageSize();

byteOffset = 0;

}

}

if (byteOffset > 0)

++slotOffset;

solAssert(slotOffset < bigint(1) << 256, "Object too large for storage.");

m_storageSize = u256(slotOffset);

swap(m_offsets, offsets);

}

pair<u256, unsigned> const* StorageOffsets::offset(size_t _index) const

{

if (m_offsets.count(_index))

return &m_offsets.at(_index);

else

return nullptr;

}

void MemberList::combine(MemberList const & _other)

{

m_memberTypes += _other.m_memberTypes;

}

pair<u256, unsigned> const* MemberList::memberStorageOffset(string const& _name) const

{

StorageOffsets const& offsets = storageOffsets();

for (auto&& [index, member]: m_memberTypes | ranges::views::enumerate)

if (member.name == _name)

return offsets.offset(index);

return nullptr;

}

u256 const& MemberList::storageSize() const

{

return storageOffsets().storageSize();

}

StorageOffsets const& MemberList::storageOffsets() const {

return m_storageOffsets.init([&]{

TypePointers memberTypes;

memberTypes.reserve(m_memberTypes.size());

for (auto const& member: m_memberTypes)

memberTypes.push_back(member.type);

StorageOffsets storageOffsets;

storageOffsets.computeOffsets(memberTypes);

return storageOffsets;

});

}

/// Helper functions for type identifier

namespace

{

string parenthesizeIdentifier(string const& _internal)

{

return "(" + _internal + ")";

}

template <class Range>

string identifierList(Range const&& _list)

{

return parenthesizeIdentifier(boost::algorithm::join(_list, ","));

}

string richIdentifier(Type const* _type)

{

return _type ? _type->richIdentifier() : "";

}

string identifierList(vector<Type const*> const& _list)

{

return identifierList(_list | ranges::views::transform(richIdentifier));

}

string identifierList(Type const* _type)

{

return parenthesizeIdentifier(richIdentifier(_type));

}

string identifierList(Type const* _type1, Type const* _type2)

{

TypePointers list;

list.push_back(_type1);

list.push_back(_type2);

return identifierList(list);

}

string parenthesizeUserIdentifier(string const& _internal)

{

return parenthesizeIdentifier(_internal);

}

}

string Type::escapeIdentifier(string const& _identifier)

{

string ret = _identifier;

// FIXME: should be _$$$_

boost::algorithm::replace_all(ret, "$", "$$$");

boost::algorithm::replace_all(ret, ",", "_$_");

boost::algorithm::replace_all(ret, "(", "$_");

boost::algorithm::replace_all(ret, ")", "_$");

return ret;

}

string Type::identifier() const

{

string ret = escapeIdentifier(richIdentifier());

solAssert(ret.find_first_of("0123456789") != 0, "Identifier cannot start with a number.");

solAssert(

ret.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMONPQRSTUVWXYZ_$") == string::npos,

"Identifier contains invalid characters."

);

return ret;

}

Type const* Type::commonType(Type const* _a, Type const* _b)

{

if (!_a || !_b)

return nullptr;

else if (_a->mobileType() && _b->isImplicitlyConvertibleTo(*_a->mobileType()))

return _a->mobileType();

else if (_b->mobileType() && _a->isImplicitlyConvertibleTo(*_b->mobileType()))

return _b->mobileType();

else

return nullptr;

}

char const* Type::categoryName(Type::Category _category)

{

switch (_category)

{

case Category::Address: return "address";

case Category::Integer: return "integer";

case Category::RationalNumber: return "rational number literal";

case Category::StringLiteral: return "string literal";

case Category::Bool: return "boolean";

case Category::FixedPoint: return "fixed-point number";

case Category::Array: return "array";

case Category::ArraySlice: return "array slice";

case Category::FixedBytes: return "fixed-size byte array";

case Category::Contract: return "contract";

case Category::Struct: return "struct";

case Category::Function: return "function";

case Category::Enum: return "enum";

case Category::UserDefinedValueType: return "user-defined value type";

case Category::Tuple: return "tuple";

case Category::Mapping: return "mapping";

case Category::TypeType: return "type of a type";

case Category::Modifier: return "modifier";

case Category::Magic: return "magic variable";

case Category::Module: return "module";

case Category::InaccessibleDynamic: return "inaccessible dynamic value";

}

util::unreachable();

}

MemberList const& Type::members(ASTNode const* _currentScope) const

{

if (!m_members[_currentScope])

{

solAssert(

_currentScope == nullptr ||

dynamic_cast<SourceUnit const*>(_currentScope) ||

dynamic_cast<ContractDefinition const*>(_currentScope),

"");

MemberList::MemberMap members = nativeMembers(_currentScope);

if (_currentScope)

members += attachedFunctions(*this, *_currentScope);

m_members[_currentScope] = make_unique<MemberList>(std::move(members));

}

return *m_members[_currentScope];

}

Type const* Type::fullEncodingType(bool _inLibraryCall, bool _encoderV2, bool) const

{

Type const* encodingType = mobileType();

if (encodingType)

encodingType = encodingType->interfaceType(_inLibraryCall);

if (encodingType)

encodingType = encodingType->encodingType();

// Structs are fine in the following circumstances:

// - ABIv2 or,

// - storage struct for a library

if (_inLibraryCall && encodingType && encodingType->dataStoredIn(DataLocation::Storage))

return encodingType;

Type const* baseType = encodingType;

while (auto const* arrayType = dynamic_cast<ArrayType const*>(baseType))

{

baseType = arrayType->baseType();

auto const* baseArrayType = dynamic_cast<ArrayType const*>(baseType);

if (!_encoderV2 && baseArrayType && baseArrayType->isDynamicallySized())

return nullptr;

}

if (!_encoderV2 && dynamic_cast<StructType const*>(baseType))

return nullptr;

return encodingType;

}

namespace

{

vector<UsingForDirective const*> usingForDirectivesForType(Type const& _type, ASTNode const& _scope)

{

vector<UsingForDirective const*> usingForDirectives;

SourceUnit const* sourceUnit = dynamic_cast<SourceUnit const*>(&_scope);

if (auto const* contract = dynamic_cast<ContractDefinition const*>(&_scope))

{

sourceUnit = &contract->sourceUnit();

usingForDirectives += contract->usingForDirectives();

}

else

solAssert(sourceUnit, "");

usingForDirectives += ASTNode::filteredNodes<UsingForDirective>(sourceUnit->nodes());

if (Declaration const* typeDefinition = _type.typeDefinition())

if (auto const* sourceUnit = dynamic_cast<SourceUnit const*>(typeDefinition->scope()))

for (auto usingFor: ASTNode::filteredNodes<UsingForDirective>(sourceUnit->nodes()))

// We do not yet compare the type name because of normalization.

if (usingFor->global() && usingFor->typeName())

usingForDirectives.emplace_back(usingFor);

// Normalise data location of type.

DataLocation typeLocation = DataLocation::Storage;

if (auto refType = dynamic_cast<ReferenceType const*>(&_type))

typeLocation = refType->location();

return usingForDirectives | ranges::views::filter([&](UsingForDirective const* _directive) -> bool {

// Convert both types to pointers for comparison to see if the `using for` directive applies.

// Note that at this point we don't yet know if the functions are actually usable with the type.

// `_type` may not be convertible to the function parameter type.

return

!_directive->typeName() ||

*TypeProvider::withLocationIfReference(typeLocation, &_type, true) ==

*TypeProvider::withLocationIfReference(

typeLocation,

_directive->typeName()->annotation().type,

true

);

}) | ranges::to<vector<UsingForDirective const*>>;

}

}

set<FunctionDefinition const*, ASTNode::CompareByID> Type::operatorDefinitions(

Token _token,

ASTNode const& _scope,

bool _unary

) const

{

if (!typeDefinition())

return {};

set<FunctionDefinition const*, ASTNode::CompareByID> matchingDefinitions;

for (UsingForDirective const* directive: usingForDirectivesForType(*this, _scope))

for (auto const& [identifierPath, operator_]: directive->functionsAndOperators())

{

if (operator_ != _token)

continue;

auto const& functionDefinition = dynamic_cast<FunctionDefinition const&>(

*identifierPath->annotation().referencedDeclaration

);

auto const* functionType = dynamic_cast<FunctionType const*>(

functionDefinition.libraryFunction() ? functionDefinition.typeViaContractName() : functionDefinition.type()

);

solAssert(functionType && !functionType->parameterTypes().empty());

size_t parameterCount = functionDefinition.parameterList().parameters().size();

if (*this == *functionType->parameterTypes().front() && (_unary ? parameterCount == 1 : parameterCount == 2))

matchingDefinitions.insert(&functionDefinition);

}

return matchingDefinitions;

}

MemberList::MemberMap Type::attachedFunctions(Type const& _type, ASTNode const& _scope)

{

MemberList::MemberMap members;

set<pair<string, Declaration const*>> seenFunctions;

auto addFunction = [&](FunctionDefinition const& _function, optional<string> _name = {})

{

if (!_name)

_name = _function.name();

Type const* functionType =

_function.libraryFunction() ? _function.typeViaContractName() : _function.type();

solAssert(functionType, "");

FunctionType const* withBoundFirstArgument =

dynamic_cast<FunctionType const&>(*functionType).withBoundFirstArgument();

solAssert(withBoundFirstArgument, "");

if (_type.isImplicitlyConvertibleTo(*withBoundFirstArgument->selfType()))

if (seenFunctions.insert(make_pair(*_name, &_function)).second)

members.emplace_back(&_function, withBoundFirstArgument, *_name);

};

for (UsingForDirective const* ufd: usingForDirectivesForType(_type, _scope))

for (auto const& [identifierPath, operator_]: ufd->functionsAndOperators())

{

if (operator_.has_value())

// Functions used to define operators are not automatically attached to the type.

// I.e. `using {f, f as +} for T` allows `T x; x.f()` but `using {f as +} for T` does not.

continue;

solAssert(identifierPath);

Declaration const* declaration = identifierPath->annotation().referencedDeclaration;

solAssert(declaration);

if (ContractDefinition const* library = dynamic_cast<ContractDefinition const*>(declaration))

{

solAssert(library->isLibrary());

for (FunctionDefinition const* function: library->definedFunctions())

{

if (!function->isOrdinary() || !function->isVisibleAsLibraryMember() || function->parameters().empty())

continue;

addFunction(*function);

}

}

else

addFunction(

dynamic_cast<FunctionDefinition const&>(*declaration),

identifierPath->path().back()

);

}

return members;

}

AddressType::AddressType(StateMutability _stateMutability):

m_stateMutability(_stateMutability)

{

solAssert(m_stateMutability == StateMutability::Payable || m_stateMutability == StateMutability::NonPayable, "");

}

string AddressType::richIdentifier() const

{

if (m_stateMutability == StateMutability::Payable)

return "t_address_payable";

else

return "t_address";

}

BoolResult AddressType::isImplicitlyConvertibleTo(Type const& _other) const

{

if (_other.category() != category())

return false;

AddressType const& other = dynamic_cast<AddressType const&>(_other);

return other.m_stateMutability <= m_stateMutability;

}

BoolResult AddressType::isExplicitlyConvertibleTo(Type const& _convertTo) const

{

if ((_convertTo.category() == category()) || isImplicitlyConvertibleTo(_convertTo))

return true;

else if (auto const* contractType = dynamic_cast<ContractType const*>(&_convertTo))

return (m_stateMutability >= StateMutability::Payable) || !contractType->isPayable();

else if (m_stateMutability == StateMutability::NonPayable)

{

if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))

return (!integerType->isSigned() && integerType->numBits() == 160);

else if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(&_convertTo))

return (fixedBytesType->numBytes() == 20);

}

return false;

}

string AddressType::toString(bool) const

{

if (m_stateMutability == StateMutability::Payable)

return "address payable";

else

return "address";

}

string AddressType::canonicalName() const

{

return "address";

}

u256 AddressType::literalValue(Literal const* _literal) const

{

solAssert(_literal, "");

solAssert(_literal->value().substr(0, 2) == "0x", "");

return u256(_literal->valueWithoutUnderscores());

}

TypeResult AddressType::unaryOperatorResult(Token _operator) const

{

return _operator == Token::Delete ? TypeProvider::emptyTuple() : nullptr;

}

TypeResult AddressType::binaryOperatorResult(Token _operator, Type const* _other) const

{

if (!TokenTraits::isCompareOp(_operator))

return TypeResult::err("Arithmetic operations on addresses are not supported. Convert to integer first before using them.");

return Type::commonType(this, _other);

}

bool AddressType::operator==(Type const& _other) const

{

if (_other.category() != category())

return false;

AddressType const& other = dynamic_cast<AddressType const&>(_other);

return other.m_stateMutability == m_stateMutability;

}

MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const

{

MemberList::MemberMap members = {

{"balance", TypeProvider::uint256()},

{"code", TypeProvider::array(DataLocation::Memory)},

{"codehash", TypeProvider::fixedBytes(32)},

{"call", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareCall, StateMutability::Payable)},

{"callcode", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareCallCode, StateMutability::Payable)},

{"delegatecall", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareDelegateCall, StateMutability::NonPayable)},

{"staticcall", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareStaticCall, StateMutability::View)}

};

if (m_stateMutability == StateMutability::Payable)

{

members.emplace_back(MemberList::Member{"send", TypeProvider::function(strings{"uint"}, strings{"bool"}, FunctionType::Kind::Send, StateMutability::NonPayable)});

members.emplace_back(MemberList::Member{"transfer", TypeProvider::function(strings{"uint"}, strings(), FunctionType::Kind::Transfer, StateMutability::NonPayable)});

}

return members;

}

namespace

{

bool isValidShiftAndAmountType(Token _operator, Type const& _shiftAmountType)

{

// Disable >>> here.

if (_operator == Token::SHR)

return false;

else if (IntegerType const* otherInt = dynamic_cast<decltype(otherInt)>(&_shiftAmountType))

return !otherInt->isSigned();

else if (RationalNumberType const* otherRat = dynamic_cast<decltype(otherRat)>(&_shiftAmountType))

return !otherRat->isFractional() && otherRat->integerType() && !otherRat->integerType()->isSigned();

else

return false;

}

}

IntegerType::IntegerType(unsigned _bits, IntegerType::Modifier _modifier):

m_bits(_bits), m_modifier(_modifier)

{

solAssert(

m_bits > 0 && m_bits <= 256 && m_bits % 8 == 0,

"Invalid bit number for integer type: " + util::toString(m_bits)

);

}

string IntegerType::richIdentifier() const

{

return "t_" + string(isSigned() ? "" : "u") + "int" + to_string(numBits());

}

BoolResult IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const

{

if (_convertTo.category() == category())

{

IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);

// disallowing unsigned to signed conversion of different bits

if (isSigned() != convertTo.isSigned())

return false;

else if (convertTo.m_bits < m_bits)

return false;

else

return true;

}

else if (_convertTo.category() == Category::FixedPoint)

{

FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);

return maxValue() <= convertTo.maxIntegerValue() && minValue() >= convertTo.minIntegerValue();

}

else

return false;

}

BoolResult IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const

{

if (isImplicitlyConvertibleTo(_convertTo))

return true;

else if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))

return (numBits() == integerType->numBits()) || (isSigned() == integerType->isSigned());

else if (auto addressType = dynamic_cast<AddressType const*>(&_convertTo))

return

(addressType->stateMutability() != StateMutability::Payable) &&

!isSigned() &&

(numBits() == 160);

else if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(&_convertTo))

return (!isSigned() && (numBits() == fixedBytesType->numBytes() * 8));

else if (dynamic_cast<EnumType const*>(&_convertTo))

return true;

else if (auto fixedPointType = dynamic_cast<FixedPointType const*>(&_convertTo))

return (isSigned() == fixedPointType->isSigned()) && (numBits() == fixedPointType->numBits());

return false;

}

TypeResult IntegerType::unaryOperatorResult(Token _operator) const

{

// "delete" is ok for all integer types

if (_operator == Token::Delete)

return TypeResult{TypeProvider::emptyTuple()};

// unary negation only on signed types

else if (_operator == Token::Sub)

return isSigned() ? TypeResult{this} : TypeResult::err("Unary negation is only allowed for signed integers.");

else if (_operator == Token::Inc || _operator == Token::Dec || _operator == Token::BitNot)

return TypeResult{this};

else

return TypeResult::err("");

}

bool IntegerType::operator==(Type const& _other) const

{

if (_other.category() != category())

return false;

IntegerType const& other = dynamic_cast<IntegerType const&>(_other);

return other.m_bits == m_bits && other.m_modifier == m_modifier;

}

string IntegerType::toString(bool) const

{

string prefix = isSigned() ? "int" : "uint";

return prefix + util::toString(m_bits);

}

u256 IntegerType::min() const

{

if (isSigned())

return s2u(s256(minValue()));

else

return u256(minValue());

}

u256 IntegerType::max() const

{

if (isSigned())

return s2u(s256(maxValue()));

else

return u256(maxValue());

}

bigint IntegerType::minValue() const

{

if (isSigned())

return -(bigint(1) << (m_bits - 1));

else

return bigint(0);

}

bigint IntegerType::maxValue() const

{

if (isSigned())

return (bigint(1) << (m_bits - 1)) - 1;

else

return (bigint(1) << m_bits) - 1;

}

TypeResult IntegerType::binaryOperatorResult(Token _operator, Type const* _other) const

{

if (

_other->category() != Category::RationalNumber &&

_other->category() != Category::FixedPoint &&

_other->category() != category()

)

return nullptr;

if (TokenTraits::isShiftOp(_operator))

{

// Shifts are not symmetric with respect to the type

if (isValidShiftAndAmountType(_operator, *_other))

return this;

else

return nullptr;

}

else if (Token::Exp == _operator)

{

if (auto otherIntType = dynamic_cast<IntegerType const*>(_other))

{

if (otherIntType->isSigned())

return TypeResult::err("Exponentiation power is not allowed to be a signed integer type.");

}

else if (dynamic_cast<FixedPointType const*>(_other))

return nullptr;

else if (auto rationalNumberType = dynamic_cast<RationalNumberType const*>(_other))

{

if (rationalNumberType->isFractional())

return TypeResult::err("Exponent is fractional.");

if (!rationalNumberType->integerType())

return TypeResult::err("Exponent too large.");

if (rationalNumberType->isNegative())

return TypeResult::err("Exponentiation power is not allowed to be a negative integer literal.");

}

return this;

}

auto commonType = Type::commonType(this, _other); //might be an integer or fixed point

if (!commonType)

return nullptr;

// All integer types can be compared

if (TokenTraits::isCompareOp(_operator))

return commonType;

if (TokenTraits::isBooleanOp(_operator))

return nullptr;

return commonType;

}

FixedPointType::FixedPointType(unsigned _totalBits, unsigned _fractionalDigits, FixedPointType::Modifier _modifier):

m_totalBits(_totalBits), m_fractionalDigits(_fractionalDigits), m_modifier(_modifier)

{

solAssert(

8 <= m_totalBits && m_totalBits <= 256 && m_totalBits % 8 == 0 && m_fractionalDigits <= 80,

"Invalid bit number(s) for fixed type: " +

util::toString(_totalBits) + "x" + util::toString(_fractionalDigits)

);

}

string FixedPointType::richIdentifier() const

{

return "t_" + string(isSigned() ? "" : "u") + "fixed" + to_string(m_totalBits) + "x" + to_string(m_fractionalDigits);

}

BoolResult FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const

{

if (_convertTo.category() == category())

{

FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);

if (convertTo.fractionalDigits() < m_fractionalDigits)

return BoolResult::err("Too many fractional digits.");

if (convertTo.numBits() < m_totalBits)

return false;

else

return convertTo.maxIntegerValue() >= maxIntegerValue() && convertTo.minIntegerValue() <= minIntegerValue();

}

return false;

}

BoolResult FixedPointType::isExplicitlyConvertibleTo(Type const& _convertTo) const

{

return _convertTo.category() == category() || _convertTo.category() == Category::Integer;

}

TypeResult FixedPointType::unaryOperatorResult(Token _operator) const

{

switch (_operator)

{

case Token::Delete:

// "delete" is ok for all fixed types

return TypeResult{TypeProvider::emptyTuple()};

case Token::Add:

case Token::Sub:

case Token::Inc:

case Token::Dec:

// for fixed, we allow +, -, ++ and --

return this;

default:

return nullptr;

}

}

bool FixedPointType::operator==(Type const& _other) const

{

if (_other.category() != category())

return false;

FixedPointType const& other = dynamic_cast<FixedPointType const&>(_other);

return other.m_totalBits == m_totalBits && other.m_fractionalDigits == m_fractionalDigits && other.m_modifier == m_modifier;

}

string FixedPointType::toString(bool) const

{

string prefix = isSigned() ? "fixed" : "ufixed";

return prefix + util::toString(m_totalBits) + "x" + util::toString(m_fractionalDigits);

}

bigint FixedPointType::maxIntegerValue() const

{

bigint maxValue = (bigint(1) << (m_totalBits - (isSigned() ? 1 : 0))) - 1;

return maxValue / boost::multiprecision::pow(bigint(10), m_fractionalDigits);

}

bigint FixedPointType::minIntegerValue() const

{

if (isSigned())

{

bigint minValue = -(bigint(1) << (m_totalBits - (isSigned() ? 1 : 0)));

return minValue / boost::multiprecision::pow(bigint(10), m_fractionalDigits);

}

else

return bigint(0);

}

TypeResult FixedPointType::binaryOperatorResult(Token _operator, Type const* _other) const

{

auto commonType = Type::commonType(this, _other);

if (!commonType)

return nullptr;

// All fixed types can be compared

if (TokenTraits::isCompareOp(_operator))

return commonType;

if (TokenTraits::isBitOp(_operator) || TokenTraits::isBooleanOp(_operator) || _operator == Token::Exp)

return nullptr;

return commonType;

}

IntegerType const* FixedPointType::asIntegerType() const

{

return TypeProvider::integer(numBits(), isSigned() ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned);

}

tuple<bool, rational> RationalNumberType::parseRational(string const& _value)

{

rational value;

try

{

auto radixPoint = find(_value.begin(), _value.end(), '.');

if (radixPoint != _value.end())

{

if (

!all_of(radixPoint + 1, _value.end(), util::isDigit) ||

!all_of(_value.begin(), radixPoint, util::isDigit)

)

return make_tuple(false, rational(0));

// Only decimal notation allowed here, leading zeros would switch to octal.

auto fractionalBegin = find_if_not(

radixPoint + 1,

_value.end(),

[](char const& a) { return a == '0'; }

);

rational numerator;

rational denominator(1);

denominator = bigint(string(fractionalBegin, _value.end()));

denominator /= boost::multiprecision::pow(

bigint(10),

static_cast<unsigned>(distance(radixPoint + 1, _value.end()))

);

numerator = bigint(string(_value.begin(), radixPoint));

value = numerator + denominator;

}

else

value = bigint(_value);

return make_tuple(true, value);

}

catch (...)

{

return make_tuple(false, rational(0));

}

}

tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)

{

rational value;

try

{

ASTString valueString = _literal.valueWithoutUnderscores();

auto expPoint = find(valueString.begin(), valueString.end(), 'e');

if (expPoint == valueString.end())

expPoint = find(valueString.begin(), valueString.end(), 'E');

if (boost::starts_with(valueString, "0x"))

{

// process as hex

value = bigint(valueString);

}

else if (expPoint != valueString.end())

{

// Parse mantissa and exponent. Checks numeric limit.

tuple<bool, rational> mantissa = parseRational(string(valueString.begin(), expPoint));

if (!get<0>(mantissa))

return make_tuple(false, rational(0));

value = get<1>(mantissa);

// 0E... is always zero.

if (value == 0)

return make_tuple(true, rational(0));

bigint exp = bigint(string(expPoint + 1, valueString.end()));

if (exp > numeric_limits<int32_t>::max() || exp < numeric_limits<int32_t>::min())

return make_tuple(false, rational(0));

uint32_t expAbs = bigint(abs(exp)).convert_to<uint32_t>();

if (exp < 0)

{

if (!fitsPrecisionBase10(abs(value.denominator()), expAbs))

return make_tuple(false, rational(0));

value /= boost::multiprecision::pow(

bigint(10),

expAbs

);

}

else if (exp > 0)

{

if (!fitsPrecisionBase10(abs(value.numerator()), expAbs))

return make_tuple(false, rational(0));

value *= boost::multiprecision::pow(

bigint(10),

expAbs

);

}

}

else

{

// parse as rational number

tuple<bool, rational> tmp = parseRational(valueString);

if (!get<0>(tmp))

return tmp;

value = get<1>(tmp);

}

}

catch (...)

{

return make_tuple(false, rational(0));

}

switch (_literal.subDenomination())