cerc-io/solidity
11
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

Cleanup & polish numbers-with-underscores parsing, also improving tests.

Browse Source
This commit is contained in:
Christian Parpart
2018-08-08 13:38:46 +02:00
committed by Christian Parpart
parent 09a36cba02
commit b9222808f6
12 changed files with 183 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libsolidity/analysis/SyntaxChecker.cpp
+24 -25
View File
@@ -188,39 +188,38 @@ bool SyntaxChecker::visit(Throw const& _throwStatement)
bool SyntaxChecker::visit(Literal const& _literal)
{
if (!_literal.isHexNumber())
if (_literal.token() != Token::Number)
return true;
// We have a hex literal. Do underscore validation
solAssert(_literal.value().substr(0, 2) == "0x", "");
ASTString value = _literal.value().substr(2); // Skip the 0x
vector<ASTString> parts;
boost::split(parts, value, boost::is_any_of("_"));
if (parts.size() == 1) // no underscores
return true;
// Everything except first and last part must be 4 chars in length
for (size_t i = 1; i + 1 < parts.size(); ++i)
ASTString const& value = _literal.value();
solAssert(!value.empty(), "");
// Generic checks no matter what base this number literal is of:
if (value.back() == '_')
{
if (parts[i].size() != 4)
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. Found inner part with " + to_string(parts[i].size()) + " digits (has to be 4 digits).");
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No trailing underscores allowed.");
return true;
}
// Validate rightmost block
if (parts.back().size() == 4) // If ends with 4 digits, then no need to validate first block
if (value.find("__") != ASTString::npos)
{
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. Only one consecutive underscores between digits allowed.");
return true;
// Validate leftmost block
// If first part is 4 digits then last part's length has to be even to avoid ambiguity over zero padding
if (parts.front().size() == 4)
{
if (parts.back().size() % 2 == 0)
return true;
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. If the first part has 4 digits, it is assumed to be a byte sequence instead of a number and thus the last part should have an even number of digits.");
}
else
if (!_literal.isHexNumber()) // decimal literal
{
// Both first and last part is invalid
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. First or last part must have 4 digits.");
if (value.find("._") != ASTString::npos)
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscores in front of the fraction part allowed.");
if (value.find("_.") != ASTString::npos)
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscores in front of the fraction part allowed.");
if (value.find("_e") != ASTString::npos)
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscore at the end of the mantissa allowed.");
if (value.find("e_") != ASTString::npos)
m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscore in front of exponent allowed.");
}
return true;
libsolidity/ast/Types.cpp
+11 -10
View File
@@ -773,21 +773,22 @@ 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');
ASTString valueString = _literal.value();
boost::erase_all(valueString, "_");// Remove underscore separators
if (boost::starts_with(_literal.value(), "0x"))
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
ASTString valueString = _literal.value();
boost::erase_all(valueString, "_");// Remove underscore separators
value = bigint(valueString);
}
else if (expPoint != _literal.value().end())
else if (expPoint != valueString.end())
{
// Parse mantissa and exponent. Checks numeric limit.
tuple<bool, rational> mantissa = parseRational(string(_literal.value().begin(), expPoint));
tuple<bool, rational> mantissa = parseRational(string(valueString.begin(), expPoint));
if (!get<0>(mantissa))
return make_tuple(false, rational(0));
@@ -797,7 +798,7 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
if (value == 0)
return make_tuple(true, rational(0));
bigint exp = bigint(string(expPoint + 1, _literal.value().end()));
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));
@@ -826,7 +827,7 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
else
{
// parse as rational number
tuple<bool, rational> tmp = parseRational(_literal.value());
tuple<bool, rational> tmp = parseRational(valueString);
if (!get<0>(tmp))
return tmp;
value = get<1>(tmp);
libsolidity/parsing/Scanner.cpp
+31 -29
View File
@@ -724,28 +724,18 @@ Token::Value Scanner::scanHexString()
return Token::StringLiteral;
}
// Parse for regex [:digit:]+(_[:digit:]+)*
void Scanner::scanDecimalDigits()
{
// Parse for regex [:digit:]+(_[:digit:]+)*
// MUST begin with a decimal digit.
if (!isDecimalDigit(m_char))
return;
do
{
if (!isDecimalDigit(m_char))
return;
while (isDecimalDigit(m_char))
addLiteralCharAndAdvance();
// May continue with decimal digit or underscore for grouping.
do addLiteralCharAndAdvance();
while (!m_source.isPastEndOfInput() && (isDecimalDigit(m_char) || m_char == '_'));
if (m_char == '_')
{
advance();
if (!isDecimalDigit(m_char)) // Trailing underscore. Rollback and allow next step to flag it as illegal
{
rollback(1);
return;
}
}
}
while (isDecimalDigit(m_char));
// Defer further validation of underscore to SyntaxChecker.
}
Token::Value Scanner::scanNumber(char _charSeen)
@@ -756,6 +746,8 @@ Token::Value Scanner::scanNumber(char _charSeen)
{
// we have already seen a decimal point of the float
addLiteralChar('.');
if (m_char == '_')
return Token::Illegal;
scanDecimalDigits(); // we know we have at least one digit
}
else
@@ -773,17 +765,9 @@ Token::Value Scanner::scanNumber(char _charSeen)
addLiteralCharAndAdvance();
if (!isHexDigit(m_char))
return Token::Illegal; // we must have at least one hex digit after 'x'/'X'
char last = m_char;
while (isHexDigit(m_char) || m_char == '_') // Unlike decimal digits, we keep the underscores for later validation
{
if (m_char == '_' && last == '_')
return Token::Illegal; // Double underscore
last = m_char;
while (isHexDigit(m_char) || m_char == '_') // We keep the underscores for later validation
addLiteralCharAndAdvance();
}
if (last == '_')
return Token::Illegal; // Trailing underscore
}
else if (isDecimalDigit(m_char))
// We do not allow octal numbers
@@ -795,9 +779,17 @@ Token::Value Scanner::scanNumber(char _charSeen)
scanDecimalDigits(); // optional
if (m_char == '.')
{
// A '.' has to be followed by a number.
if (!m_source.isPastEndOfInput(1) && m_source.get(1) == '_')
{
// Assume the input may be a floating point number with leading '_' in fraction part.
// Recover by consuming it all but returning `Illegal` right away.
addLiteralCharAndAdvance(); // '.'
addLiteralCharAndAdvance(); // '_'
scanDecimalDigits();
}
if (m_source.isPastEndOfInput() || !isDecimalDigit(m_source.get(1)))
{
// A '.' has to be followed by a number.
literal.complete();
return Token::Number;
}
@@ -812,8 +804,18 @@ Token::Value Scanner::scanNumber(char _charSeen)
solAssert(kind != HEX, "'e'/'E' must be scanned as part of the hex number");
if (kind != DECIMAL)
return Token::Illegal;
else if (!m_source.isPastEndOfInput(1) && m_source.get(1) == '_')
{
// Recover from wrongly placed underscore as delimiter in literal with scientific
// notation by consuming until the end.
addLiteralCharAndAdvance(); // 'e'
addLiteralCharAndAdvance(); // '_'
scanDecimalDigits();
literal.complete();
return Token::Number;
}
// scan exponent
addLiteralCharAndAdvance();
addLiteralCharAndAdvance(); // 'e' | 'E'
if (m_char == '+' || m_char == '-')
addLiteralCharAndAdvance();
if (!isDecimalDigit(m_char))