cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1698 from ethereum/exp-notation

Browse Source 
Fix scientific notation in number literals
This commit is contained in:
chriseth 2017-03-15 14:55:45 +01:00 committed by GitHub
commit 0c8a766146
8 changed files with 159 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog.md
View File

@ -7,6 +7,7 @@ Features:
* Introduce ``.transfer(value)`` for sending Ether.
* Code generator: Support ``revert()`` to abort with rolling back, but not consuming all gas.
* Inline assembly: Support ``revert`` (EIP140) as an opcode.
* Parser: Support scientific notation in numbers (e.g. ``2e8`` and ``200e-2``).
* Type system: Support explicit conversion of external function to address.
* Type system: Warn if base of exponentiation is literal (result type might be unexpected).

3
docs/types.rst
View File

@ -202,6 +202,9 @@ Octal literals do not exist in Solidity and leading zeros are invalid.
Decimal fraction literals are formed by a ``.`` with at least one number on
one side. Examples include ``1.``, ``.1`` and ``1.3``.
Scientific notation is also supported, where the base can have fractions, while the exponent cannot.
Examples include ``2e10``, ``-2e10``, ``2e-10``, ``2.5e1``.
Number literal expressions retain arbitrary precision until they are converted to a non-literal type (i.e. by
using them together with a non-literal expression).
This means that computations do not overflow and divisions do not truncate

109
libsolidity/ast/Types.cpp
View File

@ -32,6 +32,7 @@
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/range/adaptor/reversed.hpp>
#include <boost/range/adaptor/sliced.hpp>
#include <boost/range/adaptor/transformed.hpp>
@ -571,39 +572,99 @@ TypePointer FixedPointType::binaryOperatorResult(Token::Value _operator, TypePoi
return commonType;
}
tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)
tuple<bool, rational> RationalNumberType::parseRational(string const& _value)
{
rational x;
rational value;
try
{
rational numerator;
rational denominator(1);
auto radixPoint = find(_value.begin(), _value.end(), '.');
auto radixPoint = find(_literal.value().begin(), _literal.value().end(), '.');
if (radixPoint != _literal.value().end())
if (radixPoint != _value.end())
{
if (
!all_of(radixPoint + 1, _literal.value().end(), ::isdigit) ||
!all_of(_literal.value().begin(), radixPoint, ::isdigit)
!all_of(radixPoint + 1, _value.end(), ::isdigit) ||
!all_of(_value.begin(), radixPoint, ::isdigit)
)
return make_tuple(false, rational(0));
//Only decimal notation allowed here, leading zeros would switch to octal.
// Only decimal notation allowed here, leading zeros would switch to octal.
auto fractionalBegin = find_if_not(
radixPoint + 1,
_literal.value().end(),
_value.end(),
[](char const& a) { return a == '0'; }
);
denominator = bigint(string(fractionalBegin, _literal.value().end()));
rational numerator;
rational denominator(1);
denominator = bigint(string(fractionalBegin, _value.end()));
denominator /= boost::multiprecision::pow(
bigint(10),
distance(radixPoint + 1, _literal.value().end())
distance(radixPoint + 1, _value.end())
);
numerator = bigint(string(_literal.value().begin(), radixPoint));
x = numerator + denominator;
numerator = bigint(string(_value.begin(), radixPoint));
value = numerator + denominator;
}
else
x = bigint(_literal.value());
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
{
auto expPoint = find(_literal.value().begin(), _literal.value().end(), 'e');
if (expPoint == _literal.value().end())
expPoint = find(_literal.value().begin(), _literal.value().end(), 'E');
if (boost::starts_with(_literal.value(), "0x"))
{
// process as hex
value = bigint(_literal.value());
}
else if (expPoint != _literal.value().end())
{
// parse the exponent
bigint exp = bigint(string(expPoint + 1, _literal.value().end()));
if (exp > numeric_limits<int32_t>::max() || exp < numeric_limits<int32_t>::min())
return make_tuple(false, rational(0));
// parse the base
tuple<bool, rational> base = parseRational(string(_literal.value().begin(), expPoint));
if (!get<0>(base))
return make_tuple(false, rational(0));
value = get<1>(base);
if (exp < 0)
{
exp *= -1;
value /= boost::multiprecision::pow(
bigint(10),
exp.convert_to<int32_t>()
);
}
else
value *= boost::multiprecision::pow(
bigint(10),
exp.convert_to<int32_t>()
);
}
else
{
// parse as rational number
tuple<bool, rational> tmp = parseRational(_literal.value());
if (!get<0>(tmp))
return tmp;
value = get<1>(tmp);
}
}
catch (...)
{
@ -616,33 +677,33 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
case Literal::SubDenomination::Second:
break;
case Literal::SubDenomination::Szabo:
x *= bigint("1000000000000");
value *= bigint("1000000000000");
break;
case Literal::SubDenomination::Finney:
x *= bigint("1000000000000000");
value *= bigint("1000000000000000");
break;
case Literal::SubDenomination::Ether:
x *= bigint("1000000000000000000");
value *= bigint("1000000000000000000");
break;
case Literal::SubDenomination::Minute:
x *= bigint("60");
value *= bigint("60");
break;
case Literal::SubDenomination::Hour:
x *= bigint("3600");
value *= bigint("3600");
break;
case Literal::SubDenomination::Day:
x *= bigint("86400");
value *= bigint("86400");
break;
case Literal::SubDenomination::Week:
x *= bigint("604800");
value *= bigint("604800");
break;
case Literal::SubDenomination::Year:
x *= bigint("31536000");
value *= bigint("31536000");
break;
}
return make_tuple(true, x);
return make_tuple(true, value);
}
bool RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo) const

3
libsolidity/ast/Types.h
View File

@ -416,6 +416,9 @@ public:
private:
rational m_value;
/// @returns true if the literal is a valid rational number.
static std::tuple<bool, rational> parseRational(std::string const& _value);
};
/**

33
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -9233,6 +9233,39 @@ BOOST_AUTO_TEST_CASE(revert)
BOOST_CHECK(callContractFunction("a()") == encodeArgs(u256(42)));
}
BOOST_AUTO_TEST_CASE(scientific_notation)
{
char const* sourceCode = R"(
contract C {
function f() returns (uint) {
return 2e10 wei;
}
function g() returns (uint) {
return 200e-2 wei;
}
function h() returns (uint) {
return 2.5e1;
}
function i() returns (int) {
return -2e10;
}
function j() returns (int) {
return -200e-2;
}
function k() returns (int) {
return -2.5e1;
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(20000000000)));
BOOST_CHECK(callContractFunction("g()") == encodeArgs(u256(2)));
BOOST_CHECK(callContractFunction("h()") == encodeArgs(u256(25)));
BOOST_CHECK(callContractFunction("i()") == encodeArgs(u256(-20000000000)));
BOOST_CHECK(callContractFunction("j()") == encodeArgs(u256(-2)));
BOOST_CHECK(callContractFunction("k()") == encodeArgs(u256(-25)));
}
BOOST_AUTO_TEST_SUITE_END()
}

24
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -2790,18 +2790,6 @@ BOOST_AUTO_TEST_CASE(literal_strings)
CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(invalid_integer_literal_exp)
{
char const* text = R"(
contract Foo {
function f() {
var x = 1e2;
}
}
)";
CHECK_ERROR(text, TypeError, "");
}
BOOST_AUTO_TEST_CASE(memory_structs_with_mappings)
{
char const* text = R"(
@ -4951,18 +4939,6 @@ BOOST_AUTO_TEST_CASE(external_function_type_to_uint)
CHECK_ERROR(text, TypeError, "Explicit type conversion not allowed");
}
BOOST_AUTO_TEST_CASE(invalid_fixed_point_literal)
{
char const* text = R"(
contract A {
function a() {
.8E0;
}
}
)";
CHECK_ERROR(text, TypeError, "");
}
BOOST_AUTO_TEST_CASE(shift_constant_left_negative_rvalue)
{
char const* text = R"(

15
test/libsolidity/SolidityParser.cpp
View File

@ -1479,6 +1479,21 @@ BOOST_AUTO_TEST_CASE(function_type_state_variable)
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(scientific_notation)
{
char const* text = R"(
contract test {
uint256 a = 2e10;
uint256 b = 2E10;
uint256 c = 200e-2;
uint256 d = 2E10 wei;
uint256 e = 2.5e10;
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_SUITE_END()
}

17
test/libsolidity/SolidityScanner.cpp
View File

@ -115,9 +115,21 @@ BOOST_AUTO_TEST_CASE(octal_numbers)
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
}
BOOST_AUTO_TEST_CASE(scientific_notation)
{
Scanner scanner(CharStream("var x = 2e10;"));
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Var);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.next(), Token::Assign);
BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "2e10");
BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
}
BOOST_AUTO_TEST_CASE(negative_numbers)
{
Scanner scanner(CharStream("var x = -.2 + -0x78 + -7.3 + 8.9;"));
Scanner scanner(CharStream("var x = -.2 + -0x78 + -7.3 + 8.9 + 2e-2;"));
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Var);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.next(), Token::Assign);
@ -135,6 +147,9 @@ BOOST_AUTO_TEST_CASE(negative_numbers)
BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "8.9");
BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "2e-2");
BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
}