[llvm-commits] [llvm] r79210 - in /llvm/trunk: include/llvm/ADT/APFloat.h lib/Support/APFloat.cpp unittests/ADT/APFloatTest.cpp
Erick Tryzelaar
idadesub at users.sourceforge.net
Sun Aug 16 16:36:19 PDT 2009
Author: erickt
Date: Sun Aug 16 18:36:19 2009
New Revision: 79210
URL: http://llvm.org/viewvc/llvm-project?rev=79210&view=rev
Log:
Modify APFloat to take a StringRef instead of a c string.
This also adds unit tests to APFloat that mainly tests the
string handling of APFloat, but not much else of it's api.
Added:
llvm/trunk/unittests/ADT/APFloatTest.cpp
Modified:
llvm/trunk/include/llvm/ADT/APFloat.h
llvm/trunk/lib/Support/APFloat.cpp
Modified: llvm/trunk/include/llvm/ADT/APFloat.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/APFloat.h?rev=79210&r1=79209&r2=79210&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/APFloat.h (original)
+++ llvm/trunk/include/llvm/ADT/APFloat.h Sun Aug 16 18:36:19 2009
@@ -109,6 +109,7 @@
typedef signed short exponent_t;
struct fltSemantics;
+ struct StringRef;
/* When bits of a floating point number are truncated, this enum is
used to indicate what fraction of the LSB those bits represented.
@@ -172,7 +173,7 @@
};
// Constructors.
- APFloat(const fltSemantics &, const char *);
+ APFloat(const fltSemantics &, const StringRef &);
APFloat(const fltSemantics &, integerPart);
APFloat(const fltSemantics &, fltCategory, bool negative, unsigned type=0);
explicit APFloat(double d);
@@ -234,7 +235,7 @@
bool, roundingMode);
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
bool, roundingMode);
- opStatus convertFromString(const char *, roundingMode);
+ opStatus convertFromString(const StringRef&, roundingMode);
APInt bitcastToAPInt() const;
double convertToDouble() const;
float convertToFloat() const;
@@ -312,8 +313,8 @@
roundingMode, bool *) const;
opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
roundingMode);
- opStatus convertFromHexadecimalString(const char *, roundingMode);
- opStatus convertFromDecimalString (const char *, roundingMode);
+ opStatus convertFromHexadecimalString(const StringRef&, roundingMode);
+ opStatus convertFromDecimalString (const StringRef&, roundingMode);
char *convertNormalToHexString(char *, unsigned int, bool,
roundingMode) const;
opStatus roundSignificandWithExponent(const integerPart *, unsigned int,
Modified: llvm/trunk/lib/Support/APFloat.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APFloat.cpp?rev=79210&r1=79209&r2=79210&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APFloat.cpp (original)
+++ llvm/trunk/lib/Support/APFloat.cpp Sun Aug 16 18:36:19 2009
@@ -13,6 +13,7 @@
//===----------------------------------------------------------------------===//
#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
@@ -123,27 +124,30 @@
If the exponent overflows, returns a large exponent with the
appropriate sign. */
static int
-readExponent(const char *p)
+readExponent(StringRef::iterator begin, StringRef::iterator end)
{
bool isNegative;
unsigned int absExponent;
const unsigned int overlargeExponent = 24000; /* FIXME. */
+ StringRef::iterator p = begin;
+
+ assert(p != end && "Exponent has no digits");
isNegative = (*p == '-');
- if (*p == '-' || *p == '+')
+ if (*p == '-' || *p == '+') {
p++;
+ assert(p != end && "Exponent has no digits");
+ }
absExponent = decDigitValue(*p++);
- assert (absExponent < 10U);
+ assert(absExponent < 10U && "Invalid character in exponent");
- for (;;) {
+ for (; p != end; ++p) {
unsigned int value;
value = decDigitValue(*p);
- if (value >= 10U)
- break;
+ assert(value < 10U && "Invalid character in exponent");
- p++;
value += absExponent * 10;
if (absExponent >= overlargeExponent) {
absExponent = overlargeExponent;
@@ -152,6 +156,8 @@
absExponent = value;
}
+ assert(p == end && "Invalid exponent in exponent");
+
if (isNegative)
return -(int) absExponent;
else
@@ -161,7 +167,8 @@
/* This is ugly and needs cleaning up, but I don't immediately see
how whilst remaining safe. */
static int
-totalExponent(const char *p, int exponentAdjustment)
+totalExponent(StringRef::iterator p, StringRef::iterator end,
+ int exponentAdjustment)
{
int unsignedExponent;
bool negative, overflow;
@@ -175,14 +182,12 @@
unsignedExponent = 0;
overflow = false;
- for(;;) {
+ for(; p != end; ++p) {
unsigned int value;
value = decDigitValue(*p);
- if(value >= 10U)
- break;
+ assert(value < 10U && "Invalid character in exponent");
- p++;
unsignedExponent = unsignedExponent * 10 + value;
if(unsignedExponent > 65535)
overflow = true;
@@ -206,16 +211,21 @@
return exponent;
}
-static const char *
-skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
-{
- *dot = 0;
- while(*p == '0')
+static StringRef::iterator
+skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
+ StringRef::iterator *dot)
+{
+ StringRef::iterator p = begin;
+ *dot = end;
+ while(*p == '0' && p != end)
p++;
if(*p == '.') {
*dot = p++;
- while(*p == '0')
+
+ assert(end - begin != 1 && "String cannot be just a dot");
+
+ while(*p == '0' && p != end)
p++;
}
@@ -243,41 +253,50 @@
};
static void
-interpretDecimal(const char *p, decimalInfo *D)
+interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
+ decimalInfo *D)
{
- const char *dot;
-
- p = skipLeadingZeroesAndAnyDot (p, &dot);
+ StringRef::iterator dot = end;
+ StringRef::iterator p = skipLeadingZeroesAndAnyDot (begin, end, &dot);
D->firstSigDigit = p;
D->exponent = 0;
D->normalizedExponent = 0;
- for (;;) {
+ for (; p != end; ++p) {
if (*p == '.') {
- assert(dot == 0);
+ assert(dot == end && "Multiple dots in float");
dot = p++;
+ if (p == end)
+ break;
}
if (decDigitValue(*p) >= 10U)
break;
- p++;
}
- /* If number is all zerooes accept any exponent. */
- if (p != D->firstSigDigit) {
- if (*p == 'e' || *p == 'E')
- D->exponent = readExponent(p + 1);
+ if (p != end) {
+ assert((*p == 'e' || *p == 'E') && "Invalid character in digit string");
+
+ /* p points to the first non-digit in the string */
+ if (*p == 'e' || *p == 'E') {
+ D->exponent = readExponent(p + 1, end);
+ }
/* Implied decimal point? */
- if (!dot)
+ if (dot == end)
dot = p;
+ }
+ /* If number is all zeroes accept any exponent. */
+ if (p != D->firstSigDigit) {
/* Drop insignificant trailing zeroes. */
- do
+ if (p != begin) {
do
- p--;
- while (*p == '0');
- while (*p == '.');
+ do
+ p--;
+ while (p != begin && *p == '0');
+ while (p != begin && *p == '.');
+ }
/* Adjust the exponents for any decimal point. */
D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
@@ -293,7 +312,8 @@
DIGITVALUE is the first hex digit of the fraction, P points to
the next digit. */
static lostFraction
-trailingHexadecimalFraction(const char *p, unsigned int digitValue)
+trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
+ unsigned int digitValue)
{
unsigned int hexDigit;
@@ -308,6 +328,8 @@
while(*p == '0')
p++;
+ assert(p != end && "Invalid trailing hexadecimal fraction!");
+
hexDigit = hexDigitValue(*p);
/* If we ran off the end it is exactly zero or one-half, otherwise
@@ -681,7 +703,7 @@
makeNaN(type);
}
-APFloat::APFloat(const fltSemantics &ourSemantics, const char *text)
+APFloat::APFloat(const fltSemantics &ourSemantics, const StringRef& text)
{
assertArithmeticOK(ourSemantics);
initialize(&ourSemantics);
@@ -2107,13 +2129,13 @@
}
APFloat::opStatus
-APFloat::convertFromHexadecimalString(const char *p,
+APFloat::convertFromHexadecimalString(const StringRef &s,
roundingMode rounding_mode)
{
lostFraction lost_fraction;
integerPart *significand;
unsigned int bitPos, partsCount;
- const char *dot, *firstSignificantDigit;
+ StringRef::iterator dot, firstSignificantDigit;
zeroSignificand();
exponent = 0;
@@ -2124,10 +2146,10 @@
bitPos = partsCount * integerPartWidth;
/* Skip leading zeroes and any (hexa)decimal point. */
- p = skipLeadingZeroesAndAnyDot(p, &dot);
+ StringRef::iterator p = skipLeadingZeroesAndAnyDot(s.begin(), s.end(), &dot);
firstSignificantDigit = p;
- for(;;) {
+ for(; p != s.end();) {
integerPart hex_value;
if(*p == '.') {
@@ -2143,21 +2165,26 @@
p++;
- /* Store the number whilst 4-bit nibbles remain. */
- if(bitPos) {
- bitPos -= 4;
- hex_value <<= bitPos % integerPartWidth;
- significand[bitPos / integerPartWidth] |= hex_value;
- } else {
- lost_fraction = trailingHexadecimalFraction(p, hex_value);
- while(hexDigitValue(*p) != -1U)
- p++;
+ if (p == s.end()) {
break;
+ } else {
+ /* Store the number whilst 4-bit nibbles remain. */
+ if(bitPos) {
+ bitPos -= 4;
+ hex_value <<= bitPos % integerPartWidth;
+ significand[bitPos / integerPartWidth] |= hex_value;
+ } else {
+ lost_fraction = trailingHexadecimalFraction(p, s.end(), hex_value);
+ while(p != s.end() && hexDigitValue(*p) != -1U)
+ p++;
+ break;
+ }
}
}
/* Hex floats require an exponent but not a hexadecimal point. */
- assert(*p == 'p' || *p == 'P');
+ assert(p != s.end() && (*p == 'p' || *p == 'P') &&
+ "Hex strings require an exponent");
/* Ignore the exponent if we are zero. */
if(p != firstSignificantDigit) {
@@ -2180,7 +2207,7 @@
expAdjustment -= partsCount * integerPartWidth;
/* Adjust for the given exponent. */
- exponent = totalExponent(p, expAdjustment);
+ exponent = totalExponent(p, s.end(), expAdjustment);
}
return normalize(rounding_mode, lost_fraction);
@@ -2272,13 +2299,14 @@
}
APFloat::opStatus
-APFloat::convertFromDecimalString(const char *p, roundingMode rounding_mode)
+APFloat::convertFromDecimalString(const StringRef &str, roundingMode rounding_mode)
{
decimalInfo D;
opStatus fs;
/* Scan the text. */
- interpretDecimal(p, &D);
+ StringRef::iterator p = str.begin();
+ interpretDecimal(p, str.end(), &D);
/* Handle the quick cases. First the case of no significant digits,
i.e. zero, and then exponents that are obviously too large or too
@@ -2333,10 +2361,14 @@
multiplier = 1;
do {
- if (*p == '.')
+ if (*p == '.') {
p++;
-
+ if (p == str.end()) {
+ break;
+ }
+ }
decValue = decDigitValue(*p++);
+ assert(decValue < 10U && "Invalid character in digit string");
multiplier *= 10;
val = val * 10 + decValue;
/* The maximum number that can be multiplied by ten with any
@@ -2364,20 +2396,31 @@
}
APFloat::opStatus
-APFloat::convertFromString(const char *p, roundingMode rounding_mode)
+APFloat::convertFromString(const StringRef &str, roundingMode rounding_mode)
{
assertArithmeticOK(*semantics);
+ assert(!str.empty() && "Invalid string length");
/* Handle a leading minus sign. */
- if(*p == '-')
- sign = 1, p++;
- else
+ StringRef::iterator p = str.begin();
+ size_t slen = str.size();
+ unsigned isNegative = str.front() == '-';
+ if(isNegative) {
+ sign = 1;
+ p++;
+ slen--;
+ assert(slen && "String is only a minus!");
+ } else {
sign = 0;
+ }
- if(p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
- return convertFromHexadecimalString(p + 2, rounding_mode);
+ if(slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
+ assert(slen - 2 && "Invalid string");
+ return convertFromHexadecimalString(str.substr(isNegative + 2),
+ rounding_mode);
+ }
- return convertFromDecimalString(p, rounding_mode);
+ return convertFromDecimalString(str.substr(isNegative), rounding_mode);
}
/* Write out a hexadecimal representation of the floating point value
@@ -2744,7 +2787,7 @@
float
APFloat::convertToFloat() const
{
- assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
+ assert(semantics == (const llvm::fltSemantics*)&IEEEsingle && "Float semantics are not IEEEsingle");
APInt api = bitcastToAPInt();
return api.bitsToFloat();
}
@@ -2752,7 +2795,7 @@
double
APFloat::convertToDouble() const
{
- assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
+ assert(semantics == (const llvm::fltSemantics*)&IEEEdouble && "Float semantics are not IEEEdouble");
APInt api = bitcastToAPInt();
return api.bitsToDouble();
}
Added: llvm/trunk/unittests/ADT/APFloatTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/APFloatTest.cpp?rev=79210&view=auto
==============================================================================
--- llvm/trunk/unittests/ADT/APFloatTest.cpp (added)
+++ llvm/trunk/unittests/ADT/APFloatTest.cpp Sun Aug 16 18:36:19 2009
@@ -0,0 +1,106 @@
+//===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <ostream>
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/SmallString.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(APFloatTest, Zero) {
+ ASSERT_EQ(0.0f, APFloat(APFloat::IEEEsingle, 0.0f).convertToFloat());
+ ASSERT_EQ(-0.0f, APFloat(APFloat::IEEEsingle, -0.0f).convertToFloat());
+
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, 0.0).convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, -0.0).convertToDouble());
+}
+
+TEST(APFloatTest, SemanticsDeath) {
+ ASSERT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle");
+}
+
+TEST(APFloatTest, fromString) {
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e0").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-0").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
+
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
+ ASSERT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
+
+ ASSERT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1\02", 3)).convertToDouble());
+}
+
+TEST(APFloatTest, StringDeath) {
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String is only a minus!");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "."), "String cannot be just a dot");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "String cannot be just a dot");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "String cannot be just a dot");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."),"String cannot be just a dot");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0e"), "Exponent has no digits");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0e+"), "Exponent has no digits");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0e-"), "Exponent has no digits");
+
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in digit string");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in digit string");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in digit string");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in digit string");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
+
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in digit string");
+
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Hex strings require an exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Hex strings require an exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Hex strings require an exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Hex strings require an exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
+
+ ASSERT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
+}
+
+}
More information about the llvm-commits
mailing list