mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-12-17 17:05:31 +00:00
Update lexer to not include - in numbers.
This CL removes the parsing of a `-` in front of numerics when lexed. This will cause the number to become a UnaryOperator negation then the number instead of a negative number. Bug: tint:1679, tint:1141, tint:1570 Change-Id: I217c0ffcbe5be934c8d56bd83141b47ade83bc60 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/106463 Reviewed-by: Ben Clayton <bclayton@google.com> Kokoro: Kokoro <noreply+kokoro@google.com> Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair
committed by
Dawn LUCI CQ
Dawn LUCI CQ
parent
63463c2f77
commit
b3b027d3cd
@@ -328,9 +328,6 @@ Token Lexer::try_float() {
|
||||
auto source = begin_source();
|
||||
bool has_mantissa_digits = false;
|
||||
|
||||
if (matches(end, '-')) {
|
||||
end++;
|
||||
}
|
||||
while (end < length() && is_digit(at(end))) {
|
||||
has_mantissa_digits = true;
|
||||
end++;
|
||||
@@ -426,7 +423,6 @@ Token Lexer::try_hex_float() {
|
||||
constexpr uint64_t kExponentMask = (1 << kExponentBits) - 1;
|
||||
constexpr int64_t kExponentMax = kExponentMask; // Including NaN / inf
|
||||
constexpr uint64_t kExponentLeftShift = kMantissaBits;
|
||||
constexpr uint64_t kSignBit = kTotalBits - 1;
|
||||
constexpr uint64_t kOne = 1;
|
||||
|
||||
auto start = pos();
|
||||
@@ -434,16 +430,8 @@ Token Lexer::try_hex_float() {
|
||||
|
||||
auto source = begin_source();
|
||||
|
||||
// clang-format off
|
||||
// -?0[xX]([0-9a-fA-F]*.?[0-9a-fA-F]+ | [0-9a-fA-F]+.[0-9a-fA-F]*)(p|P)(+|-)?[0-9]+ // NOLINT
|
||||
// clang-format on
|
||||
// 0[xX]([0-9a-fA-F]*.?[0-9a-fA-F]+ | [0-9a-fA-F]+.[0-9a-fA-F]*)(p|P)(+|-)?[0-9]+ // NOLINT
|
||||
|
||||
// -?
|
||||
uint64_t sign_bit = 0;
|
||||
if (matches(end, '-')) {
|
||||
sign_bit = 1;
|
||||
end++;
|
||||
}
|
||||
// 0[xX]
|
||||
if (matches(end, '0') && (matches(end + 1, 'x') || matches(end + 1, 'X'))) {
|
||||
end += 2;
|
||||
@@ -696,7 +684,7 @@ Token Lexer::try_hex_float() {
|
||||
}
|
||||
|
||||
// Combine sign, mantissa, and exponent
|
||||
uint64_t result_u64 = sign_bit << kSignBit;
|
||||
uint64_t result_u64 = 0;
|
||||
result_u64 |= mantissa;
|
||||
result_u64 |= (static_cast<uint64_t>(signed_exponent) & kExponentMask) << kExponentLeftShift;
|
||||
|
||||
@@ -856,10 +844,6 @@ Token Lexer::try_hex_integer() {
|
||||
|
||||
auto source = begin_source();
|
||||
|
||||
if (matches(curr, '-')) {
|
||||
curr++;
|
||||
}
|
||||
|
||||
if (matches(curr, '0') && (matches(curr + 1, 'x') || matches(curr + 1, 'X'))) {
|
||||
curr += 2;
|
||||
} else {
|
||||
@@ -880,10 +864,6 @@ Token Lexer::try_integer() {
|
||||
|
||||
auto source = begin_source();
|
||||
|
||||
if (matches(curr, '-')) {
|
||||
curr++;
|
||||
}
|
||||
|
||||
if (curr >= length() || !is_digit(at(curr))) {
|
||||
return {};
|
||||
}
|
||||
|
||||
@@ -426,57 +426,35 @@ INSTANTIATE_TEST_SUITE_P(LexerTest,
|
||||
// No decimal, with 'f' suffix
|
||||
FloatData{"0f", 0.0},
|
||||
FloatData{"1f", 1.0},
|
||||
FloatData{"-0f", 0.0},
|
||||
FloatData{"-1f", -1.0},
|
||||
// No decimal, with 'h' suffix
|
||||
FloatData{"0h", 0.0},
|
||||
FloatData{"1h", 1.0},
|
||||
FloatData{"-0h", 0.0},
|
||||
FloatData{"-1h", -1.0},
|
||||
|
||||
// Zero, with decimal.
|
||||
FloatData{"0.0", 0.0},
|
||||
FloatData{"0.", 0.0},
|
||||
FloatData{".0", 0.0},
|
||||
FloatData{"-0.0", 0.0},
|
||||
FloatData{"-0.", 0.0},
|
||||
FloatData{"-.0", 0.0},
|
||||
// Zero, with decimal and 'f' suffix
|
||||
FloatData{"0.0f", 0.0},
|
||||
FloatData{"0.f", 0.0},
|
||||
FloatData{".0f", 0.0},
|
||||
FloatData{"-0.0f", 0.0},
|
||||
FloatData{"-0.f", 0.0},
|
||||
FloatData{"-.0f", 0.0},
|
||||
// Zero, with decimal and 'h' suffix
|
||||
FloatData{"0.0h", 0.0},
|
||||
FloatData{"0.h", 0.0},
|
||||
FloatData{".0h", 0.0},
|
||||
FloatData{"-0.0h", 0.0},
|
||||
FloatData{"-0.h", 0.0},
|
||||
FloatData{"-.0h", 0.0},
|
||||
|
||||
// Non-zero with decimal
|
||||
FloatData{"5.7", 5.7},
|
||||
FloatData{"5.", 5.},
|
||||
FloatData{".7", .7},
|
||||
FloatData{"-5.7", -5.7},
|
||||
FloatData{"-5.", -5.},
|
||||
FloatData{"-.7", -.7},
|
||||
// Non-zero with decimal and 'f' suffix
|
||||
FloatData{"5.7f", static_cast<double>(5.7f)},
|
||||
FloatData{"5.f", static_cast<double>(5.f)},
|
||||
FloatData{".7f", static_cast<double>(.7f)},
|
||||
FloatData{"-5.7f", static_cast<double>(-5.7f)},
|
||||
FloatData{"-5.f", static_cast<double>(-5.f)},
|
||||
FloatData{"-.7f", static_cast<double>(-.7f)},
|
||||
// Non-zero with decimal and 'h' suffix
|
||||
FloatData{"5.7h", static_cast<double>(f16::Quantize(5.7f))},
|
||||
FloatData{"5.h", static_cast<double>(f16::Quantize(5.f))},
|
||||
FloatData{".7h", static_cast<double>(f16::Quantize(.7f))},
|
||||
FloatData{"-5.7h", static_cast<double>(f16::Quantize(-5.7f))},
|
||||
FloatData{"-5.h", static_cast<double>(f16::Quantize(-5.f))},
|
||||
FloatData{"-.7h", static_cast<double>(f16::Quantize(-.7f))},
|
||||
|
||||
// No decimal, with exponent
|
||||
FloatData{"1e5", 1e5},
|
||||
@@ -532,7 +510,6 @@ TEST_P(FloatTest_Invalid, Handles) {
|
||||
INSTANTIATE_TEST_SUITE_P(LexerTest,
|
||||
FloatTest_Invalid,
|
||||
testing::Values(".",
|
||||
"-.",
|
||||
// Need a mantissa digit
|
||||
".e5",
|
||||
".E5",
|
||||
@@ -545,9 +522,7 @@ INSTANTIATE_TEST_SUITE_P(LexerTest,
|
||||
".e-",
|
||||
// Overflow
|
||||
"2.5e+256f",
|
||||
"-2.5e+127f",
|
||||
"6.5520e+4h",
|
||||
"-6.5e+12h",
|
||||
// Decimal exponent must immediately
|
||||
// follow the 'e'.
|
||||
"2.5e 12",
|
||||
@@ -791,12 +766,9 @@ INSTANTIATE_TEST_SUITE_P(Dec_AInt,
|
||||
testing::Combine(testing::Values('\0'), // No suffix
|
||||
testing::ValuesIn(std::vector<ParseIntegerCase>{
|
||||
{"0", 0},
|
||||
{"-2", -2},
|
||||
{"2", 2},
|
||||
{"123", 123},
|
||||
{"2147483647", 2147483647},
|
||||
{"-2147483648", -2147483648LL},
|
||||
{"-9223372036854775808", -9223372036854775807LL - 1},
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(Dec_u32,
|
||||
@@ -813,11 +785,8 @@ INSTANTIATE_TEST_SUITE_P(Dec_i32,
|
||||
testing::Combine(testing::Values('i'), // Suffix
|
||||
testing::ValuesIn(std::vector<ParseIntegerCase>{
|
||||
{"0i", 0u},
|
||||
{"-0i", 0u},
|
||||
{"123i", 123},
|
||||
{"-123i", -123},
|
||||
{"2147483647i", 2147483647},
|
||||
{"-2147483647i", -2147483647ll},
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(Hex_AInt,
|
||||
@@ -828,16 +797,10 @@ INSTANTIATE_TEST_SUITE_P(Hex_AInt,
|
||||
{"0X0", 0},
|
||||
{"0x42", 66},
|
||||
{"0X42", 66},
|
||||
{"-0x42", -66},
|
||||
{"-0X42", -66},
|
||||
{"0xeF1Abc9", 0xeF1Abc9},
|
||||
{"0XeF1Abc9", 0xeF1Abc9},
|
||||
{"-0xeF1Abc9", -0xeF1Abc9},
|
||||
{"-0XeF1Abc9", -0xeF1Abc9},
|
||||
{"0x80000000", 0x80000000},
|
||||
{"0X80000000", 0X80000000},
|
||||
{"-0x80000000", -0x80000000ll},
|
||||
{"-0X80000000", -0X80000000ll},
|
||||
{"0x7FFFFFFF", 0x7fffffff},
|
||||
{"0X7FFFFFFF", 0x7fffffff},
|
||||
{"0x7fffffff", 0x7fffffff},
|
||||
@@ -845,7 +808,6 @@ INSTANTIATE_TEST_SUITE_P(Hex_AInt,
|
||||
{"0x7FfFfFfF", 0x7fffffff},
|
||||
{"0X7FfFfFfF", 0x7fffffff},
|
||||
{"0x7fffffffffffffff", 0x7fffffffffffffffll},
|
||||
{"-0x7fffffffffffffff", -0x7fffffffffffffffll},
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(Hex_u32,
|
||||
@@ -869,22 +831,13 @@ INSTANTIATE_TEST_SUITE_P(Hex_i32,
|
||||
testing::ValuesIn(std::vector<ParseIntegerCase>{
|
||||
{"0x0i", 0},
|
||||
{"0x42i", 66},
|
||||
{"-0x0i", 0},
|
||||
{"-0x42i", -66},
|
||||
{"0xeF1Abc9i", 250719177},
|
||||
{"-0xeF1Abc9i", -250719177},
|
||||
{"0x7FFFFFFFi", 0x7fffffff},
|
||||
{"-0x7FFFFFFFi", -0x7fffffff},
|
||||
{"0X7FFFFFFFi", 0x7fffffff},
|
||||
{"-0X7FFFFFFFi", -0x7fffffff},
|
||||
{"0x7fffffffi", 0x7fffffff},
|
||||
{"-0x7fffffffi", -0x7fffffff},
|
||||
{"0X7fffffffi", 0x7fffffff},
|
||||
{"-0X7fffffffi", -0x7fffffff},
|
||||
{"0x7FfFfFfFi", 0x7fffffff},
|
||||
{"-0x7FfFfFfFi", -0x7fffffff},
|
||||
{"0X7FfFfFfFi", 0x7fffffff},
|
||||
{"-0X7FfFfFfFi", -0x7fffffff},
|
||||
})));
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ParseIntegerTest_CannotBeRepresented
|
||||
@@ -920,9 +873,8 @@ INSTANTIATE_TEST_SUITE_P(i32,
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(u32,
|
||||
ParseIntegerTest_CannotBeRepresented,
|
||||
testing::Combine(testing::Values("u32"), // type
|
||||
testing::Values("4294967296u", //
|
||||
"-1u")));
|
||||
testing::Combine(testing::Values("u32"), // type
|
||||
testing::Values("4294967296u")));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ParseIntegerTest_LeadingZeros
|
||||
@@ -942,7 +894,7 @@ TEST_P(ParseIntegerTest_LeadingZeros, Parse) {
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(LeadingZero,
|
||||
ParseIntegerTest_LeadingZeros,
|
||||
testing::Values("01234", "0000", "-00", "00u"));
|
||||
testing::Values("01234", "0000", "00u"));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ParseIntegerTest_NoSignificantDigits
|
||||
@@ -962,18 +914,7 @@ TEST_P(ParseIntegerTest_NoSignificantDigits, Parse) {
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(LeadingZero,
|
||||
ParseIntegerTest_NoSignificantDigits,
|
||||
testing::Values("0x",
|
||||
"0X",
|
||||
"-0x",
|
||||
"-0X",
|
||||
"0xu",
|
||||
"0Xu",
|
||||
"-0xu",
|
||||
"-0Xu",
|
||||
"0xi",
|
||||
"0Xi",
|
||||
"-0xi",
|
||||
"-0Xi"));
|
||||
testing::Values("0x", "0X", "0xu", "0Xu", "0xi", "0Xi"));
|
||||
|
||||
struct TokenData {
|
||||
const char* input;
|
||||
|
||||
@@ -37,7 +37,7 @@ TEST_F(ParserImplTest, ArgumentExpressionList_ParsesEmptyList) {
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ArgumentExpressionList_ParsesMultiple) {
|
||||
auto p = parser("(a, -33, 1+2)");
|
||||
auto p = parser("(a, 33, 1+2)");
|
||||
auto e = p->expect_argument_expression_list("argument list");
|
||||
ASSERT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_FALSE(e.errored);
|
||||
|
||||
@@ -67,32 +67,6 @@ TEST_F(ParserImplTest, ConstLiteral_Int) {
|
||||
ast::IntLiteralExpression::Suffix::kI);
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}}));
|
||||
}
|
||||
{
|
||||
auto p = parser("-234");
|
||||
auto c = p->const_literal();
|
||||
EXPECT_TRUE(c.matched);
|
||||
EXPECT_FALSE(c.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(c.value, nullptr);
|
||||
ASSERT_TRUE(c->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->value, -234);
|
||||
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->suffix,
|
||||
ast::IntLiteralExpression::Suffix::kNone);
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}}));
|
||||
}
|
||||
{
|
||||
auto p = parser("-234i");
|
||||
auto c = p->const_literal();
|
||||
EXPECT_TRUE(c.matched);
|
||||
EXPECT_FALSE(c.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(c.value, nullptr);
|
||||
ASSERT_TRUE(c->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->value, -234);
|
||||
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->suffix,
|
||||
ast::IntLiteralExpression::Suffix::kI);
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 6u}}));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_Uint) {
|
||||
@@ -108,15 +82,6 @@ TEST_F(ParserImplTest, ConstLiteral_Uint) {
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}}));
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_Uint_Negative) {
|
||||
auto p = parser("-234u");
|
||||
auto c = p->const_literal();
|
||||
EXPECT_FALSE(c.matched);
|
||||
EXPECT_TRUE(c.errored);
|
||||
EXPECT_EQ(p->error(), "1:1: value cannot be represented as 'u32'");
|
||||
ASSERT_EQ(c.value, nullptr);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_InvalidFloat_IncompleteExponent) {
|
||||
auto p = parser("1.0e+");
|
||||
auto c = p->const_literal();
|
||||
@@ -174,15 +139,11 @@ using FloatLiteralTestCaseList = std::vector<FloatLiteralTestCase>;
|
||||
INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float,
|
||||
ParserImplFloatLiteralTest,
|
||||
testing::ValuesIn(FloatLiteralTestCaseList{
|
||||
{"0.0", 0.0}, // Zero
|
||||
{"1.0", 1.0}, // One
|
||||
{"-1.0", -1.0}, // MinusOne
|
||||
{"1000000000.0", 1e9}, // Billion
|
||||
{"-0.0", std::copysign(0.0, -5.0)}, // NegativeZero
|
||||
{"0.0", MakeDouble(0, 0, 0)}, // Zero
|
||||
{"-0.0", MakeDouble(1, 0, 0)}, // NegativeZero
|
||||
{"1.0", MakeDouble(0, 1023, 0)}, // One
|
||||
{"-1.0", MakeDouble(1, 1023, 0)}, // NegativeOne
|
||||
{"0.0", 0.0}, // Zero
|
||||
{"1.0", 1.0}, // One
|
||||
{"1000000000.0", 1e9}, // Billion
|
||||
{"0.0", MakeDouble(0, 0, 0)}, // Zero
|
||||
{"1.0", MakeDouble(0, 1023, 0)}, // One
|
||||
|
||||
{"234.e12", 234.e12},
|
||||
{"234.e12f", static_cast<double>(234.e12f)},
|
||||
@@ -190,47 +151,29 @@ INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float,
|
||||
|
||||
// Tiny cases
|
||||
{"1e-5000", 0.0},
|
||||
{"-1e-5000", 0.0},
|
||||
{"1e-5000f", 0.0},
|
||||
{"-1e-5000f", 0.0},
|
||||
{"1e-50f", 0.0},
|
||||
{"-1e-50f", 0.0},
|
||||
{"1e-5000h", 0.0},
|
||||
{"-1e-5000h", 0.0},
|
||||
{"1e-50h", 0.0},
|
||||
{"-1e-50h", 0.0},
|
||||
{"1e-8h", 0.0}, // The smallest positive subnormal f16 is 5.96e-8
|
||||
{"-1e-8h", 0.0},
|
||||
|
||||
// Nearly overflow
|
||||
{"1.e308", 1.e308},
|
||||
{"-1.e308", -1.e308},
|
||||
{"1.8e307", 1.8e307},
|
||||
{"-1.8e307", -1.8e307},
|
||||
{"1.798e307", 1.798e307},
|
||||
{"-1.798e307", -1.798e307},
|
||||
{"1.7977e307", 1.7977e307},
|
||||
{"-1.7977e307", -1.7977e307},
|
||||
|
||||
// Nearly overflow
|
||||
{"1e38f", static_cast<double>(1e38f)},
|
||||
{"-1e38f", static_cast<double>(-1e38f)},
|
||||
{"4.0e37f", static_cast<double>(4.0e37f)},
|
||||
{"-4.0e37f", static_cast<double>(-4.0e37f)},
|
||||
{"3.5e37f", static_cast<double>(3.5e37f)},
|
||||
{"-3.5e37f", static_cast<double>(-3.5e37f)},
|
||||
{"3.403e37f", static_cast<double>(3.403e37f)},
|
||||
{"-3.403e37f", static_cast<double>(-3.403e37f)},
|
||||
|
||||
// Nearly overflow
|
||||
{"6e4h", 6e4},
|
||||
{"-6e4h", -6e4},
|
||||
{"8.0e3h", 8.0e3},
|
||||
{"-8.0e3h", -8.0e3},
|
||||
{"3.5e3h", 3.5e3},
|
||||
{"-3.5e3h", -3.5e3},
|
||||
{"3.403e3h", 3.402e3}, // Quantized
|
||||
{"-3.403e3h", -3.402e3}, // Quantized
|
||||
{"3.403e3h", 3.402e3}, // Quantized
|
||||
}));
|
||||
|
||||
const double NegInf = MakeDouble(1, 0x7FF, 0);
|
||||
@@ -246,11 +189,6 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x1p-1", 0x1p-1},
|
||||
{"0x1p-2", 0x1p-2},
|
||||
{"0x1.8p-1", 0x1.8p-1},
|
||||
{"-0x0p+0", -0x0p+0},
|
||||
{"-0x1p+0", -0x1p+0},
|
||||
{"-0x1p-1", -0x1p-1},
|
||||
{"-0x1p-2", -0x1p-2},
|
||||
{"-0x1.8p-1", -0x1.8p-1},
|
||||
{"0x0.4p+1", 0x0.4p+1},
|
||||
{"0x0.02p+3", 0x0.02p+3},
|
||||
{"0x4.4p+1", 0x4.4p+1},
|
||||
@@ -260,43 +198,28 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x1p+9", 0x1p+9},
|
||||
{"0x1p+10", 0x1p+10},
|
||||
{"0x1.02p+10", 0x1.02p+10},
|
||||
{"-0x1p+9", -0x1p+9},
|
||||
{"-0x1p+10", -0x1p+10},
|
||||
{"-0x1.02p+10", -0x1.02p+10},
|
||||
|
||||
// Small numbers
|
||||
{"0x1p-9", 0x1p-9},
|
||||
{"0x1p-10", 0x1p-10},
|
||||
{"0x1.02p-3", 0x1.02p-3},
|
||||
{"-0x1p-9", -0x1p-9},
|
||||
{"-0x1p-10", -0x1p-10},
|
||||
{"-0x1.02p-3", -0x1.02p-3},
|
||||
|
||||
// Near lowest non-denorm
|
||||
{"0x1p-1020", 0x1p-1020},
|
||||
{"0x1p-1021", 0x1p-1021},
|
||||
{"-0x1p-1020", -0x1p-1020},
|
||||
{"-0x1p-1021", -0x1p-1021},
|
||||
|
||||
{"0x1p-124f", 0x1p-124},
|
||||
{"0x1p-125f", 0x1p-125},
|
||||
{"-0x1p-124f", -0x1p-124},
|
||||
{"-0x1p-125f", -0x1p-125},
|
||||
|
||||
{"0x1p-12h", 0x1p-12},
|
||||
{"0x1p-13h", 0x1p-13},
|
||||
{"-0x1p-12h", -0x1p-12},
|
||||
{"-0x1p-13h", -0x1p-13},
|
||||
|
||||
// Lowest non-denorm
|
||||
{"0x1p-1022", 0x1p-1022},
|
||||
{"-0x1p-1022", -0x1p-1022},
|
||||
|
||||
{"0x1p-126f", 0x1p-126},
|
||||
{"-0x1p-126f", -0x1p-126},
|
||||
|
||||
{"0x1p-14h", 0x1p-14},
|
||||
{"-0x1p-14h", -0x1p-14},
|
||||
|
||||
// Denormalized values
|
||||
{"0x1p-1023", 0x1p-1023},
|
||||
@@ -305,10 +228,6 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x0.2p-1021", 0x0.2p-1021},
|
||||
{"0x1p-1025", 0x1p-1025},
|
||||
{"0x1p-1026", 0x1p-1026},
|
||||
{"-0x1p-1023", -0x1p-1023},
|
||||
{"-0x1p-1024", -0x1p-1024},
|
||||
{"-0x1p-1025", -0x1p-1025},
|
||||
{"-0x1p-1026", -0x1p-1026},
|
||||
{"0x1.8p-1023", 0x1.8p-1023},
|
||||
{"0x1.8p-1024", 0x1.8p-1024},
|
||||
|
||||
@@ -318,10 +237,6 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x0.2p-125f", 0x0.2p-125},
|
||||
{"0x1p-129f", 0x1p-129},
|
||||
{"0x1p-130f", 0x1p-130},
|
||||
{"-0x1p-127f", -0x1p-127},
|
||||
{"-0x1p-128f", -0x1p-128},
|
||||
{"-0x1p-129f", -0x1p-129},
|
||||
{"-0x1p-130f", -0x1p-130},
|
||||
{"0x1.8p-127f", 0x1.8p-127},
|
||||
{"0x1.8p-128f", 0x1.8p-128},
|
||||
|
||||
@@ -331,52 +246,31 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x0.2p-13h", 0x0.2p-13},
|
||||
{"0x1p-17h", 0x1p-17},
|
||||
{"0x1p-18h", 0x1p-18},
|
||||
{"-0x1p-15h", -0x1p-15},
|
||||
{"-0x1p-16h", -0x1p-16},
|
||||
{"-0x1p-17h", -0x1p-17},
|
||||
{"-0x1p-18h", -0x1p-18},
|
||||
{"0x1.8p-15h", 0x1.8p-15},
|
||||
{"0x1.8p-16h", 0x1.8p-16},
|
||||
|
||||
// F64 extremities
|
||||
{"0x1p-1074", 0x1p-1074}, // +SmallestDenormal
|
||||
{"0x1p-1073", 0x1p-1073}, // +BiggerDenormal
|
||||
{"0x1.ffffffffffffep-1023", 0x1.ffffffffffffep-1023}, // +LargestDenormal
|
||||
{"0x0.fffffffffffffp-1022", 0x0.fffffffffffffp-1022}, // +LargestDenormal
|
||||
{"-0x1p-1074", -0x1p-1074}, // -SmallestDenormal
|
||||
{"-0x1p-1073", -0x1p-1073}, // -BiggerDenormal
|
||||
{"-0x1.ffffffffffffep-1023", -0x1.ffffffffffffep-1023}, // -LargestDenormal
|
||||
{"-0x0.fffffffffffffp-1022", -0x0.fffffffffffffp-1022}, // -LargestDenormal
|
||||
{"0x1p-1074", 0x1p-1074}, // +SmallestDenormal
|
||||
{"0x1p-1073", 0x1p-1073}, // +BiggerDenormal
|
||||
{"0x1.ffffffffffffep-1023", 0x1.ffffffffffffep-1023}, // +LargestDenormal
|
||||
{"0x0.fffffffffffffp-1022", 0x0.fffffffffffffp-1022}, // +LargestDenormal
|
||||
|
||||
{"0x0.cafebeeff000dp-1022", 0x0.cafebeeff000dp-1022}, // +Subnormal
|
||||
{"-0x0.cafebeeff000dp-1022", -0x0.cafebeeff000dp-1022}, // -Subnormal
|
||||
{"0x1.2bfaf8p-1052", 0x1.2bfaf8p-1052}, // +Subnormal
|
||||
{"-0x1.2bfaf8p-1052", -0x1.2bfaf8p-1052}, // +Subnormal
|
||||
{"0x1.55554p-1055", 0x1.55554p-1055}, // +Subnormal
|
||||
{"-0x1.55554p-1055", -0x1.55554p-1055}, // -Subnormal
|
||||
{"0x0.cafebeeff000dp-1022", 0x0.cafebeeff000dp-1022}, // +Subnormal
|
||||
{"0x1.2bfaf8p-1052", 0x1.2bfaf8p-1052}, // +Subnormal
|
||||
{"0x1.55554p-1055", 0x1.55554p-1055}, // +Subnormal
|
||||
{"0x1.fffffffffffp-1027", 0x1.fffffffffffp-1027}, // +Subnormal, = 0x0.0fffffffffff8p-1022
|
||||
{"-0x1.fffffffffffp-1027", -0x1.fffffffffffp-1027}, // -Subnormal
|
||||
|
||||
// F32 extremities
|
||||
{"0x1p-149f", 0x1p-149}, // +SmallestDenormal
|
||||
{"0x1p-148f", 0x1p-148}, // +BiggerDenormal
|
||||
{"0x1.fffffcp-127f", 0x1.fffffcp-127}, // +LargestDenormal
|
||||
{"0x0.fffffep-126f", 0x0.fffffep-126}, // +LargestDenormal
|
||||
{"0x1.0p-126f", 0x1.0p-126}, // +SmallestNormal
|
||||
{"0x8.0p-129f", 0x8.0p-129}, // +SmallestNormal
|
||||
{"-0x1p-149f", -0x1p-149}, // -SmallestDenormal
|
||||
{"-0x1p-148f", -0x1p-148}, // -BiggerDenormal
|
||||
{"-0x1.fffffcp-127f", -0x1.fffffcp-127}, // -LargestDenormal
|
||||
{"-0x0.fffffep-126f", -0x0.fffffep-126}, // -LargestDenormal
|
||||
{"-0x1.0p-126f", -0x1.0p-126}, // -SmallestNormal
|
||||
{"-0x8.0p-129f", -0x8.0p-129}, // -SmallestNormal
|
||||
{"0x1p-149f", 0x1p-149}, // +SmallestDenormal
|
||||
{"0x1p-148f", 0x1p-148}, // +BiggerDenormal
|
||||
{"0x1.fffffcp-127f", 0x1.fffffcp-127}, // +LargestDenormal
|
||||
{"0x0.fffffep-126f", 0x0.fffffep-126}, // +LargestDenormal
|
||||
{"0x1.0p-126f", 0x1.0p-126}, // +SmallestNormal
|
||||
{"0x8.0p-129f", 0x8.0p-129}, // +SmallestNormal
|
||||
|
||||
{"0x0.cafebp-129f", 0x0.cafebp-129}, // +Subnormal
|
||||
{"-0x0.cafebp-129f", -0x0.cafebp-129}, // -Subnormal
|
||||
{"0x1.2bfaf8p-127f", 0x1.2bfaf8p-127}, // +Subnormal
|
||||
{"-0x1.2bfaf8p-127f", -0x1.2bfaf8p-127}, // -Subnormal
|
||||
{"0x1.55554p-130f", 0x1.55554p-130}, // +Subnormal
|
||||
{"-0x1.55554p-130f", -0x1.55554p-130}, // -Subnormal
|
||||
{"0x0.cafebp-129f", 0x0.cafebp-129}, // +Subnormal
|
||||
{"0x1.2bfaf8p-127f", 0x1.2bfaf8p-127}, // +Subnormal
|
||||
{"0x1.55554p-130f", 0x1.55554p-130}, // +Subnormal
|
||||
|
||||
// F32 exactly representable
|
||||
{"0x1.000002p+0f", 0x1.000002p+0},
|
||||
@@ -385,31 +279,20 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x8.00003p+0f", 0x8.00003p+0},
|
||||
{"0x2.123p+0f", 0x2.123p+0},
|
||||
{"0x2.cafefp+0f", 0x2.cafefp+0},
|
||||
{"0x0.0000fep-126f", 0x0.0000fep-126}, // Subnormal
|
||||
{"-0x0.0000fep-126f", -0x0.0000fep-126}, // Subnormal
|
||||
{"0x3.f8p-144f", 0x3.f8p-144}, // Subnormal
|
||||
{"-0x3.f8p-144f", -0x3.f8p-144}, // Subnormal
|
||||
{"0x0.0000fep-126f", 0x0.0000fep-126}, // Subnormal
|
||||
{"0x3.f8p-144f", 0x3.f8p-144}, // Subnormal
|
||||
|
||||
// F16 extremities
|
||||
{"0x1p-24h", 0x1p-24}, // +SmallestDenormal
|
||||
{"0x1p-23h", 0x1p-23}, // +BiggerDenormal
|
||||
{"0x1.ff8p-15h", 0x1.ff8p-15}, // +LargestDenormal
|
||||
{"0x0.ffcp-14h", 0x0.ffcp-14}, // +LargestDenormal
|
||||
{"0x1.0p-14h", 0x1.0p-14}, // +SmallestNormal
|
||||
{"0x8.0p-17h", 0x8.0p-17}, // +SmallestNormal
|
||||
{"-0x1p-24h", -0x1p-24}, // -SmallestDenormal
|
||||
{"-0x1p-23h", -0x1p-23}, // -BiggerDenormal
|
||||
{"-0x1.ff8p-15h", -0x1.ff8p-15}, // -LargestDenormal
|
||||
{"-0x0.ffcp-14h", -0x0.ffcp-14}, // -LargestDenormal
|
||||
{"-0x1.0p-14h", -0x1.0p-14}, // -SmallestNormal
|
||||
{"-0x8.0p-17h", -0x8.0p-17}, // -SmallestNormal
|
||||
{"0x1p-24h", 0x1p-24}, // +SmallestDenormal
|
||||
{"0x1p-23h", 0x1p-23}, // +BiggerDenormal
|
||||
{"0x1.ff8p-15h", 0x1.ff8p-15}, // +LargestDenormal
|
||||
{"0x0.ffcp-14h", 0x0.ffcp-14}, // +LargestDenormal
|
||||
{"0x1.0p-14h", 0x1.0p-14}, // +SmallestNormal
|
||||
{"0x8.0p-17h", 0x8.0p-17}, // +SmallestNormal
|
||||
|
||||
{"0x0.a8p-19h", 0x0.a8p-19}, // +Subnormal
|
||||
{"-0x0.a8p-19h", -0x0.a8p-19}, // -Subnormal
|
||||
{"0x1.7ap-17h", 0x1.7ap-17}, // +Subnormal
|
||||
{"-0x1.7ap-17h", -0x1.7ap-17}, // -Subnormal
|
||||
{"0x1.dp-20h", 0x1.dp-20}, // +Subnormal
|
||||
{"-0x1.dp-20h", -0x1.dp-20}, // -Subnormal
|
||||
{"0x0.a8p-19h", 0x0.a8p-19}, // +Subnormal
|
||||
{"0x1.7ap-17h", 0x1.7ap-17}, // +Subnormal
|
||||
{"0x1.dp-20h", 0x1.dp-20}, // +Subnormal
|
||||
|
||||
// F16 exactly representable
|
||||
{"0x1.004p+0h", 0x1.004p+0},
|
||||
@@ -418,20 +301,14 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x8.06p+0h", 0x8.06p+0},
|
||||
{"0x2.128p+0h", 0x2.128p+0},
|
||||
{"0x2.ca8p+0h", 0x2.ca8p+0},
|
||||
{"0x0.0fcp-14h", 0x0.0fcp-14}, // Subnormal
|
||||
{"-0x0.0fcp-14h", -0x0.0fcp-14}, // Subnormal
|
||||
{"0x3.f00p-20h", 0x3.f00p-20}, // Subnormal
|
||||
{"-0x3.f00p-20h", -0x3.f00p-20}, // Subnormal
|
||||
{"0x0.0fcp-14h", 0x0.0fcp-14}, // Subnormal
|
||||
{"0x3.f00p-20h", 0x3.f00p-20}, // Subnormal
|
||||
|
||||
// Underflow -> Zero
|
||||
{"0x1p-1075", 0.0}, // Exponent underflows
|
||||
{"-0x1p-1075", 0.0},
|
||||
{"0x1p-5000", 0.0},
|
||||
{"-0x1p-5000", 0.0},
|
||||
{"0x0.00000000000000000000001p-1022", 0.0}, // Fraction causes underflow
|
||||
{"-0x0.0000000000000000000001p-1023", -0.0},
|
||||
{"0x0.01p-1073", -0.0},
|
||||
{"-0x0.01p-1073", -0.0}, // Fraction causes additional underflow
|
||||
|
||||
{"0x1.0p-9223372036854774784", 0}, // -(INT64_MAX - 1023) (smallest valid exponent)
|
||||
|
||||
@@ -443,22 +320,14 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x0p-9999999999", 0.0},
|
||||
// Same, but with very large positive exponents that would cause overflow
|
||||
// if the mantissa were non-zero.
|
||||
{"0x0p+10000000000000000000", 0.0}, // 10 quintillion (10,000,000,000,000,000,000)
|
||||
{"0x0p+100000000000000000000", 0.0}, // 100 quintillion (100,000,000,000,000,000,000)
|
||||
{"-0x0p+100000000000000000000", 0.0}, // As above 2, but negative mantissa
|
||||
{"-0x0p+1000000000000000000000", 0.0},
|
||||
{"0x0p+10000000000000000000", 0.0}, // 10 quintillion (10,000,000,000,000,000,000)
|
||||
{"0x0p+100000000000000000000", 0.0}, // 100 quintillion (100,000,000,000,000,000,000)
|
||||
{"0x0.00p+10000000000000000000", 0.0}, // As above 4, but with fractional part
|
||||
{"0x0.00p+100000000000000000000", 0.0},
|
||||
{"-0x0.00p+100000000000000000000", 0.0},
|
||||
{"-0x0.00p+1000000000000000000000", 0.0},
|
||||
{"0x0p-10000000000000000000", 0.0}, // As above 8, but with negative exponents
|
||||
{"0x0p-100000000000000000000", 0.0},
|
||||
{"-0x0p-100000000000000000000", 0.0},
|
||||
{"-0x0p-1000000000000000000000", 0.0},
|
||||
{"0x0.00p-10000000000000000000", 0.0},
|
||||
{"0x0.00p-100000000000000000000", 0.0},
|
||||
{"-0x0.00p-100000000000000000000", 0.0},
|
||||
{"-0x0.00p-1000000000000000000000", 0.0},
|
||||
|
||||
// Test parsing
|
||||
{"0x0p0", 0.0},
|
||||
@@ -476,37 +345,24 @@ FloatLiteralTestCaseList HexFloatCases() {
|
||||
{"0x0.4p+1", 2 * 0.25},
|
||||
{"0x0.4p+2", 4 * 0.25},
|
||||
{"0x123Ep+1", 9340.0},
|
||||
{"-0x123Ep+1", -9340.0},
|
||||
{"0x1a2b3cP12", 7.024656384e+09},
|
||||
{"-0x1a2b3cP12", -7.024656384e+09},
|
||||
|
||||
// Examples without a binary exponent part.
|
||||
{"0x1.", 1.0},
|
||||
{"0x.8", 0.5},
|
||||
{"0x1.8", 1.5},
|
||||
{"-0x1.", -1.0},
|
||||
{"-0x.8", -0.5},
|
||||
{"-0x1.8", -1.5},
|
||||
|
||||
// Examples with a binary exponent and a 'f' suffix.
|
||||
{"0x1.p0f", 1.0},
|
||||
{"0x.8p2f", 2.0},
|
||||
{"0x1.8p-1f", 0.75},
|
||||
{"0x2p-2f", 0.5}, // No binary point
|
||||
{"-0x1.p0f", -1.0},
|
||||
{"-0x.8p2f", -2.0},
|
||||
{"-0x1.8p-1f", -0.75},
|
||||
{"-0x2p-2f", -0.5}, // No binary point
|
||||
|
||||
// Examples with a binary exponent and a 'h' suffix.
|
||||
{"0x1.p0h", 1.0},
|
||||
{"0x.8p2h", 2.0},
|
||||
{"0x1.8p-1h", 0.75},
|
||||
{"0x2p-2h", 0.5}, // No binary point
|
||||
{"-0x1.p0h", -1.0},
|
||||
{"-0x.8p2h", -2.0},
|
||||
{"-0x1.8p-1h", -0.75},
|
||||
{"-0x2p-2h", -0.5}, // No binary point
|
||||
};
|
||||
}
|
||||
INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_HexFloat,
|
||||
@@ -532,11 +388,9 @@ std::vector<FloatLiteralTestCase> UpperCase0X(const ARR& cases) {
|
||||
using UpperCase0XTest = ::testing::Test;
|
||||
TEST_F(UpperCase0XTest, Samples) {
|
||||
const auto cases = FloatLiteralTestCaseList{
|
||||
{"absent", 0.0}, {"0x", 1.0}, {"0X", 2.0}, {"-0x", 3.0},
|
||||
{"-0X", 4.0}, {" 0x1p1", 5.0}, {" -0x1p", 6.0}, {" examine ", 7.0}};
|
||||
{"absent", 0.0}, {"0x", 1.0}, {"0X", 2.0}, {" 0x1p1", 5.0}, {" examine ", 7.0}};
|
||||
const auto expected = FloatLiteralTestCaseList{
|
||||
{"absent", 0.0}, {"0X", 1.0}, {"0X", 2.0}, {"-0X", 3.0},
|
||||
{"-0X", 4.0}, {" 0X1p1", 5.0}, {" -0X1p", 6.0}, {" examine ", 7.0}};
|
||||
{"absent", 0.0}, {"0X", 1.0}, {"0X", 2.0}, {" 0X1p1", 5.0}, {" examine ", 7.0}};
|
||||
|
||||
auto result = UpperCase0X(cases);
|
||||
EXPECT_THAT(result, ::testing::ElementsAreArray(expected));
|
||||
@@ -625,11 +479,6 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
"0x1.0018p+1024",
|
||||
"0x1.01ep+1024",
|
||||
"0x1.fffffep+1024",
|
||||
"-0x1.8p+1024",
|
||||
"-0x1.0002p+1024",
|
||||
"-0x1.0018p+1024",
|
||||
"-0x1.01ep+1024",
|
||||
"-0x1.fffffep+1024",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -642,11 +491,6 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
"0x1.0018p+128f",
|
||||
"0x1.01ep+128f",
|
||||
"0x1.fffffep+128f",
|
||||
"-0x1.8p+128f",
|
||||
"-0x1.0002p+128f",
|
||||
"-0x1.0018p+128f",
|
||||
"-0x1.01ep+128f",
|
||||
"-0x1.fffffep+128f",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -659,11 +503,6 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
"0x1.018p+16h",
|
||||
"0x1.1ep+16h",
|
||||
"0x1.ffcp+16h",
|
||||
"-0x1.8p+16h",
|
||||
"-0x1.004p+16h",
|
||||
"-0x1.018p+16h",
|
||||
"-0x1.1ep+16h",
|
||||
"-0x1.ffcp+16h",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -672,17 +511,11 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'abstract-float'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"0x1p+1024",
|
||||
"-0x1p+1024",
|
||||
"0x1.1p+1024",
|
||||
"-0x1.1p+1024",
|
||||
"0x1p+1025",
|
||||
"-0x1p+1025",
|
||||
"0x32p+1023",
|
||||
"-0x32p+1023",
|
||||
"0x32p+5000",
|
||||
"-0x32p+5000",
|
||||
"0x1.0p9223372036854774784",
|
||||
"-0x1.0p9223372036854774784",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -691,15 +524,10 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'f32'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"0x1p+128f",
|
||||
"-0x1p+128f",
|
||||
"0x1.1p+128f",
|
||||
"-0x1.1p+128f",
|
||||
"0x1p+129f",
|
||||
"-0x1p+129f",
|
||||
"0x32p+127f",
|
||||
"-0x32p+127f",
|
||||
"0x32p+500f",
|
||||
"-0x32p+500f",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -708,15 +536,10 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'f16'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"0x1p+16h",
|
||||
"-0x1p+16h",
|
||||
"0x1.1p+16h",
|
||||
"-0x1.1p+16h",
|
||||
"0x1p+17h",
|
||||
"-0x1p+17h",
|
||||
"0x32p+15h",
|
||||
"-0x32p+15h",
|
||||
"0x32p+500h",
|
||||
"-0x32p+500h",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -724,32 +547,22 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
ParserImplInvalidLiteralTest,
|
||||
testing::Combine(testing::Values("1:1: value cannot be exactly represented as 'f32'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"0x1.000001p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x1.0000008p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x1.0000000000001p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x8.0000f8p+0f", // Quantizes to 0x8.0000fp+0
|
||||
"0x8.000038p+0f", // Quantizes to 0x8.00003p+0
|
||||
"0x2.cafef00dp+0f", // Quantizes to 0x2.cafefp+0
|
||||
"0x0.0000ffp-126f", // Subnormal, quantizes to 0x0.0000fep-126
|
||||
"0x3.fcp-144f", // Subnormal, quantizes to 0x3.f8p-144
|
||||
"-0x0.0000ffp-126f", // Subnormal, quantizes to -0x0.0000fep-126
|
||||
"-0x3.fcp-144f", // Subnormal, quantizes to -0x3.f8p-144
|
||||
"0x0.ffffffp-126f", // Subnormal, quantizes to 0x0.fffffep-144
|
||||
"0x0.fffffe0000001p-126f", // Subnormal, quantizes to 0x0.fffffep-144
|
||||
"-0x0.ffffffp-126f", // Subnormal, quantizes to -0x0.fffffep-144
|
||||
"-0x0.fffffe0000001p-126f", // Subnormal, quantizes to -0x0.fffffep-144
|
||||
"0x1.8p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.4p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.000002p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.0000000000001p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"-0x1.8p-149f", // Subnormal, quantizes to -0x1.0p-149f
|
||||
"-0x1.4p-149f", // Subnormal, quantizes to -0x1.0p-149f
|
||||
"-0x1.000002p-149f", // Subnormal, quantizes to -0x1.0p-149f
|
||||
"-0x1.0000000000001p-149f", // Subnormal, quantizes to -0x1.0p-149f
|
||||
"0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"-0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to -0.0
|
||||
"-0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to -0.0
|
||||
"0x1.000001p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x1.0000008p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x1.0000000000001p+0f", // Quantizes to 0x1.0p+0
|
||||
"0x8.0000f8p+0f", // Quantizes to 0x8.0000fp+0
|
||||
"0x8.000038p+0f", // Quantizes to 0x8.00003p+0
|
||||
"0x2.cafef00dp+0f", // Quantizes to 0x2.cafefp+0
|
||||
"0x0.0000ffp-126f", // Subnormal, quantizes to 0x0.0000fep-126
|
||||
"0x3.fcp-144f", // Subnormal, quantizes to 0x3.f8p-144
|
||||
"0x0.ffffffp-126f", // Subnormal, quantizes to 0x0.fffffep-144
|
||||
"0x0.fffffe0000001p-126f", // Subnormal, quantizes to 0x0.fffffep-144
|
||||
"0x1.8p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.4p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.000002p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.0000000000001p-149f", // Subnormal, quantizes to 0x1.0p-149f
|
||||
"0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -768,26 +581,15 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
"0x4.011p+0h", // Quantizes to 0x4.01p+0
|
||||
"0x0.0fep-14h", // Subnormal, quantizes to 0x0.0fcp-14
|
||||
"0x3.f8p-20h", // Subnormal, quantizes to 0x3.f0p-20
|
||||
"-0x0.0fep-14h", // Subnormal, quantizes to -0x0.0fcp-14
|
||||
"-0x3.f8p-20h", // Subnormal, quantizes to -0x3.f0p-20
|
||||
"0x0.ffep-14h", // Subnormal, quantizes to 0x0.ffcp-14
|
||||
"0x0.ffe0000000001p-14h", // Subnormal, quantizes to 0x0.ffcp-14
|
||||
"0x0.fffffffffffffp-14h", // Subnormal, quantizes to 0x0.ffcp-14
|
||||
"-0x0.ffep-14h", // Subnormal, quantizes to -0x0.ffcp-14
|
||||
"-0x0.ffe0000000001p-14h", // Subnormal, quantizes to -0x0.ffcp-14
|
||||
"-0x0.fffffffffffffp-14h", // Subnormal, quantizes to -0x0.ffcp-14
|
||||
"0x1.8p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.4p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.004p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.0000000000001p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"-0x1.8p-24h", // Subnormal, quantizes to -0x1.0p-24f
|
||||
"-0x1.4p-24h", // Subnormal, quantizes to -0x1.0p-24f
|
||||
"-0x1.004p-24h", // Subnormal, quantizes to -0x1.0p-24f
|
||||
"-0x1.0000000000001p-24h", // Subnormal, quantizes to -0x1.0p-24f
|
||||
"0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"-0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to -0.0
|
||||
"-0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to -0.0
|
||||
"0x1.8p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.4p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.004p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.0000000000001p-24h", // Subnormal, quantizes to 0x1.0p-24f
|
||||
"0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
"0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to 0.0
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -796,15 +598,10 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'abstract-float'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"1.e309",
|
||||
"-1.e309",
|
||||
"1.8e308",
|
||||
"-1.8e308",
|
||||
"1.798e308",
|
||||
"-1.798e308",
|
||||
"1.7977e308",
|
||||
"-1.7977e308",
|
||||
"1.2e+5000",
|
||||
"-1.2e+5000",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -813,15 +610,10 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'f32'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"1e39f",
|
||||
"-1e39f",
|
||||
"4.0e38f",
|
||||
"-4.0e38f",
|
||||
"3.5e38f",
|
||||
"-3.5e38f",
|
||||
"3.403e38f",
|
||||
"-3.403e38f",
|
||||
"1.2e+256f",
|
||||
"-1.2e+256f",
|
||||
})));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
@@ -830,17 +622,11 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
testing::Combine(testing::Values("1:1: value cannot be represented as 'f16'"),
|
||||
testing::ValuesIn(std::vector<const char*>{
|
||||
"1.0e5h",
|
||||
"-1.0e5h",
|
||||
"7.0e4h",
|
||||
"-7.0e4h",
|
||||
"6.6e4h",
|
||||
"-6.6e4h",
|
||||
"6.56e4h",
|
||||
"-6.56e4h",
|
||||
"6.554e4h",
|
||||
"-6.554e4h",
|
||||
"1.2e+32h",
|
||||
"-1.2e+32h",
|
||||
})));
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_FloatHighest) {
|
||||
@@ -863,29 +649,6 @@ TEST_F(ParserImplTest, ConstLiteral_FloatHighest) {
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 42u}}));
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_FloatLowest) {
|
||||
// Some compilers complain if you test floating point numbers for equality.
|
||||
// So say it via two inequalities.
|
||||
const auto lowest = std::numeric_limits<float>::lowest();
|
||||
const auto expected_lowest = -340282346638528859811704183484516925440.0f;
|
||||
if (lowest < expected_lowest || lowest > expected_lowest) {
|
||||
GTEST_SKIP() << "std::numeric_limits<float>::lowest() is not as expected for "
|
||||
"this target";
|
||||
}
|
||||
|
||||
auto p = parser("-340282346638528859811704183484516925440.0");
|
||||
auto c = p->const_literal();
|
||||
EXPECT_TRUE(c.matched);
|
||||
EXPECT_FALSE(c.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(c.value, nullptr);
|
||||
ASSERT_TRUE(c->Is<ast::FloatLiteralExpression>());
|
||||
EXPECT_EQ(c->As<ast::FloatLiteralExpression>()->value, std::numeric_limits<float>::lowest());
|
||||
EXPECT_EQ(c->As<ast::FloatLiteralExpression>()->suffix,
|
||||
ast::FloatLiteralExpression::Suffix::kNone);
|
||||
EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 43u}}));
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, ConstLiteral_True) {
|
||||
auto p = parser("true");
|
||||
auto c = p->const_literal();
|
||||
|
||||
@@ -269,6 +269,124 @@ TEST_F(ParserImplTest, Expression_InvalidAssociativity) {
|
||||
EXPECT_EQ(p->error(), R"(1:7: mixing '&&' and '||' requires parenthesis)");
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_SubtractionNoSpace) {
|
||||
auto p = parser("(2-1)");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
ASSERT_TRUE(e->Is<ast::BinaryExpression>());
|
||||
auto* b = e->As<ast::BinaryExpression>();
|
||||
EXPECT_TRUE(b->IsSubtract());
|
||||
|
||||
ASSERT_TRUE(b->lhs->Is<ast::IntLiteralExpression>());
|
||||
ASSERT_TRUE(b->rhs->Is<ast::IntLiteralExpression>());
|
||||
|
||||
EXPECT_EQ(b->lhs->As<ast::IntLiteralExpression>()->value, 2);
|
||||
EXPECT_EQ(b->rhs->As<ast::IntLiteralExpression>()->value, 1);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_NegatedNumber) {
|
||||
auto p = parser("-1");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
|
||||
auto* b = e->As<ast::UnaryOpExpression>();
|
||||
EXPECT_EQ(b->op, ast::UnaryOp::kNegation);
|
||||
|
||||
ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 1);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_MaxI32) {
|
||||
auto p = parser("2147483647");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 2147483647);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_MinI32) {
|
||||
auto p = parser("-2147483648");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
|
||||
auto* b = e->As<ast::UnaryOpExpression>();
|
||||
EXPECT_EQ(b->op, ast::UnaryOp::kNegation);
|
||||
|
||||
ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 2147483648);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_MaxU32) {
|
||||
auto p = parser("4294967295");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
|
||||
EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 4294967295);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_MaxF32) {
|
||||
const auto highest = std::numeric_limits<float>::max();
|
||||
const auto expected_highest = 340282346638528859811704183484516925440.0f;
|
||||
if (highest < expected_highest || highest > expected_highest) {
|
||||
GTEST_SKIP() << "std::numeric_limits<float>::max() is not as expected for "
|
||||
"this target";
|
||||
}
|
||||
|
||||
auto p = parser("340282346638528859811704183484516925440.0f");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::FloatLiteralExpression>());
|
||||
EXPECT_EQ(e->As<ast::FloatLiteralExpression>()->value,
|
||||
340282346638528859811704183484516925440.0f);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, Expression_MinF32) {
|
||||
const auto lowest = std::numeric_limits<float>::lowest();
|
||||
const auto expected_lowest = -340282346638528859811704183484516925440.0f;
|
||||
if (lowest < expected_lowest || lowest > expected_lowest) {
|
||||
GTEST_SKIP() << "std::numeric_limits<float>::lowest() is not as expected for "
|
||||
"this target";
|
||||
}
|
||||
|
||||
auto p = parser("-340282346638528859811704183484516925440.0f");
|
||||
auto e = p->expression();
|
||||
EXPECT_TRUE(e.matched);
|
||||
EXPECT_FALSE(e.errored);
|
||||
EXPECT_FALSE(p->has_error()) << p->error();
|
||||
ASSERT_NE(e.value, nullptr);
|
||||
|
||||
ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
|
||||
auto* b = e->As<ast::UnaryOpExpression>();
|
||||
EXPECT_EQ(b->op, ast::UnaryOp::kNegation);
|
||||
|
||||
ASSERT_TRUE(b->expr->Is<ast::FloatLiteralExpression>());
|
||||
EXPECT_EQ(b->expr->As<ast::FloatLiteralExpression>()->value,
|
||||
340282346638528859811704183484516925440.0f);
|
||||
}
|
||||
|
||||
namespace mixing_binary_ops {
|
||||
|
||||
struct BinaryOperatorInfo {
|
||||
|
||||
Reference in New Issue
Block a user