[llvm-commits] [llvm] r66845 - /llvm/trunk/lib/Support/APFloat.cpp
Chris Lattner
sabre at nondot.org
Thu Mar 12 16:59:56 PDT 2009
Author: lattner
Date: Thu Mar 12 18:59:55 2009
New Revision: 66845
URL: http://llvm.org/viewvc/llvm-project?rev=66845&view=rev
Log:
static functions don't need an anonymous namespace.
Modified:
llvm/trunk/lib/Support/APFloat.cpp
Modified: llvm/trunk/lib/Support/APFloat.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APFloat.cpp?rev=66845&r1=66844&r2=66845&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APFloat.cpp (original)
+++ llvm/trunk/lib/Support/APFloat.cpp Thu Mar 12 18:59:55 2009
@@ -75,484 +75,482 @@
/ (351 * integerPartWidth));
}
-/* Put a bunch of private, handy routines in an anonymous namespace. */
-namespace {
+/* A bunch of private, handy routines. */
- static inline unsigned int
- partCountForBits(unsigned int bits)
- {
- return ((bits) + integerPartWidth - 1) / integerPartWidth;
- }
+static inline unsigned int
+partCountForBits(unsigned int bits)
+{
+ return ((bits) + integerPartWidth - 1) / integerPartWidth;
+}
- /* Returns 0U-9U. Return values >= 10U are not digits. */
- static inline unsigned int
- decDigitValue(unsigned int c)
- {
- return c - '0';
- }
+/* Returns 0U-9U. Return values >= 10U are not digits. */
+static inline unsigned int
+decDigitValue(unsigned int c)
+{
+ return c - '0';
+}
- static unsigned int
- hexDigitValue(unsigned int c)
- {
- unsigned int r;
+static unsigned int
+hexDigitValue(unsigned int c)
+{
+ unsigned int r;
- r = c - '0';
- if(r <= 9)
- return r;
+ r = c - '0';
+ if(r <= 9)
+ return r;
- r = c - 'A';
- if(r <= 5)
- return r + 10;
+ r = c - 'A';
+ if(r <= 5)
+ return r + 10;
- r = c - 'a';
- if(r <= 5)
- return r + 10;
+ r = c - 'a';
+ if(r <= 5)
+ return r + 10;
- return -1U;
- }
+ return -1U;
+}
- static inline void
- assertArithmeticOK(const llvm::fltSemantics &semantics) {
- assert(semantics.arithmeticOK
- && "Compile-time arithmetic does not support these semantics");
- }
+static inline void
+assertArithmeticOK(const llvm::fltSemantics &semantics) {
+ assert(semantics.arithmeticOK
+ && "Compile-time arithmetic does not support these semantics");
+}
- /* Return the value of a decimal exponent of the form
- [+-]ddddddd.
+/* Return the value of a decimal exponent of the form
+ [+-]ddddddd.
- If the exponent overflows, returns a large exponent with the
- appropriate sign. */
- static int
- readExponent(const char *p)
- {
- bool isNegative;
- unsigned int absExponent;
- const unsigned int overlargeExponent = 24000; /* FIXME. */
+ If the exponent overflows, returns a large exponent with the
+ appropriate sign. */
+static int
+readExponent(const char *p)
+{
+ bool isNegative;
+ unsigned int absExponent;
+ const unsigned int overlargeExponent = 24000; /* FIXME. */
- isNegative = (*p == '-');
- if (*p == '-' || *p == '+')
- p++;
+ isNegative = (*p == '-');
+ if (*p == '-' || *p == '+')
+ p++;
- absExponent = decDigitValue(*p++);
- assert (absExponent < 10U);
+ absExponent = decDigitValue(*p++);
+ assert (absExponent < 10U);
- for (;;) {
- unsigned int value;
+ for (;;) {
+ unsigned int value;
- value = decDigitValue(*p);
- if (value >= 10U)
- break;
+ value = decDigitValue(*p);
+ if (value >= 10U)
+ break;
- p++;
- value += absExponent * 10;
- if (absExponent >= overlargeExponent) {
- absExponent = overlargeExponent;
- break;
- }
- absExponent = value;
+ p++;
+ value += absExponent * 10;
+ if (absExponent >= overlargeExponent) {
+ absExponent = overlargeExponent;
+ break;
}
-
- if (isNegative)
- return -(int) absExponent;
- else
- return (int) absExponent;
+ absExponent = value;
}
- /* 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)
- {
- int unsignedExponent;
- bool negative, overflow;
- int exponent;
+ if (isNegative)
+ return -(int) absExponent;
+ else
+ return (int) absExponent;
+}
- /* Move past the exponent letter and sign to the digits. */
+/* 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)
+{
+ int unsignedExponent;
+ bool negative, overflow;
+ int exponent;
+
+ /* Move past the exponent letter and sign to the digits. */
+ p++;
+ negative = *p == '-';
+ if(*p == '-' || *p == '+')
p++;
- negative = *p == '-';
- if(*p == '-' || *p == '+')
- p++;
- unsignedExponent = 0;
- overflow = false;
- for(;;) {
- unsigned int value;
-
- value = decDigitValue(*p);
- if(value >= 10U)
- break;
+ unsignedExponent = 0;
+ overflow = false;
+ for(;;) {
+ unsigned int value;
- p++;
- unsignedExponent = unsignedExponent * 10 + value;
- if(unsignedExponent > 65535)
- overflow = true;
- }
+ value = decDigitValue(*p);
+ if(value >= 10U)
+ break;
- if(exponentAdjustment > 65535 || exponentAdjustment < -65536)
+ p++;
+ unsignedExponent = unsignedExponent * 10 + value;
+ if(unsignedExponent > 65535)
overflow = true;
+ }
- if(!overflow) {
- exponent = unsignedExponent;
- if(negative)
- exponent = -exponent;
- exponent += exponentAdjustment;
- if(exponent > 65535 || exponent < -65536)
- overflow = true;
- }
-
- if(overflow)
- exponent = negative ? -65536: 65535;
+ if(exponentAdjustment > 65535 || exponentAdjustment < -65536)
+ overflow = true;
- return exponent;
+ if(!overflow) {
+ exponent = unsignedExponent;
+ if(negative)
+ exponent = -exponent;
+ exponent += exponentAdjustment;
+ if(exponent > 65535 || exponent < -65536)
+ overflow = true;
}
- static const char *
- skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
- {
- *dot = 0;
+ if(overflow)
+ exponent = negative ? -65536: 65535;
+
+ return exponent;
+}
+
+static const char *
+skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
+{
+ *dot = 0;
+ while(*p == '0')
+ p++;
+
+ if(*p == '.') {
+ *dot = p++;
while(*p == '0')
p++;
+ }
- if(*p == '.') {
- *dot = p++;
- while(*p == '0')
- p++;
- }
+ return p;
+}
- return p;
- }
+/* Given a normal decimal floating point number of the form
- /* Given a normal decimal floating point number of the form
+ dddd.dddd[eE][+-]ddd
- dddd.dddd[eE][+-]ddd
+ where the decimal point and exponent are optional, fill out the
+ structure D. Exponent is appropriate if the significand is
+ treated as an integer, and normalizedExponent if the significand
+ is taken to have the decimal point after a single leading
+ non-zero digit.
- where the decimal point and exponent are optional, fill out the
- structure D. Exponent is appropriate if the significand is
- treated as an integer, and normalizedExponent if the significand
- is taken to have the decimal point after a single leading
- non-zero digit.
+ If the value is zero, V->firstSigDigit points to a non-digit, and
+ the return exponent is zero.
+*/
+struct decimalInfo {
+ const char *firstSigDigit;
+ const char *lastSigDigit;
+ int exponent;
+ int normalizedExponent;
+};
+
+static void
+interpretDecimal(const char *p, decimalInfo *D)
+{
+ const char *dot;
+
+ p = skipLeadingZeroesAndAnyDot (p, &dot);
+
+ D->firstSigDigit = p;
+ D->exponent = 0;
+ D->normalizedExponent = 0;
- If the value is zero, V->firstSigDigit points to a non-digit, and
- the return exponent is zero.
- */
- struct decimalInfo {
- const char *firstSigDigit;
- const char *lastSigDigit;
- int exponent;
- int normalizedExponent;
- };
-
- static void
- interpretDecimal(const char *p, decimalInfo *D)
- {
- const char *dot;
-
- p = skipLeadingZeroesAndAnyDot (p, &dot);
-
- D->firstSigDigit = p;
- D->exponent = 0;
- D->normalizedExponent = 0;
-
- for (;;) {
- if (*p == '.') {
- assert(dot == 0);
- dot = p++;
- }
- if (decDigitValue(*p) >= 10U)
- break;
- p++;
+ for (;;) {
+ if (*p == '.') {
+ assert(dot == 0);
+ dot = p++;
}
+ 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);
-
- /* Implied decimal point? */
- if (!dot)
- dot = p;
-
- /* Drop insignificant trailing zeroes. */
- do
- do
- p--;
- while (*p == '0');
- while (*p == '.');
-
- /* Adjust the exponents for any decimal point. */
- D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
- D->normalizedExponent = (D->exponent +
- static_cast<exponent_t>((p - D->firstSigDigit)
- - (dot > D->firstSigDigit && dot < p)));
- }
-
- D->lastSigDigit = p;
- }
-
- /* Return the trailing fraction of a hexadecimal number.
- DIGITVALUE is the first hex digit of the fraction, P points to
- the next digit. */
- static lostFraction
- trailingHexadecimalFraction(const char *p, unsigned int digitValue)
- {
- unsigned int hexDigit;
-
- /* If the first trailing digit isn't 0 or 8 we can work out the
- fraction immediately. */
- if(digitValue > 8)
- return lfMoreThanHalf;
- else if(digitValue < 8 && digitValue > 0)
- return lfLessThanHalf;
+ /* If number is all zerooes accept any exponent. */
+ if (p != D->firstSigDigit) {
+ if (*p == 'e' || *p == 'E')
+ D->exponent = readExponent(p + 1);
- /* Otherwise we need to find the first non-zero digit. */
- while(*p == '0')
- p++;
+ /* Implied decimal point? */
+ if (!dot)
+ dot = p;
- hexDigit = hexDigitValue(*p);
+ /* Drop insignificant trailing zeroes. */
+ do
+ do
+ p--;
+ while (*p == '0');
+ while (*p == '.');
- /* If we ran off the end it is exactly zero or one-half, otherwise
- a little more. */
- if(hexDigit == -1U)
- return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
- else
- return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
+ /* Adjust the exponents for any decimal point. */
+ D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
+ D->normalizedExponent = (D->exponent +
+ static_cast<exponent_t>((p - D->firstSigDigit)
+ - (dot > D->firstSigDigit && dot < p)));
}
- /* Return the fraction lost were a bignum truncated losing the least
- significant BITS bits. */
- static lostFraction
- lostFractionThroughTruncation(const integerPart *parts,
- unsigned int partCount,
- unsigned int bits)
- {
- unsigned int lsb;
-
- lsb = APInt::tcLSB(parts, partCount);
-
- /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
- if(bits <= lsb)
- return lfExactlyZero;
- if(bits == lsb + 1)
- return lfExactlyHalf;
- if(bits <= partCount * integerPartWidth
- && APInt::tcExtractBit(parts, bits - 1))
- return lfMoreThanHalf;
+ D->lastSigDigit = p;
+}
+
+/* Return the trailing fraction of a hexadecimal number.
+ DIGITVALUE is the first hex digit of the fraction, P points to
+ the next digit. */
+static lostFraction
+trailingHexadecimalFraction(const char *p, unsigned int digitValue)
+{
+ unsigned int hexDigit;
+ /* If the first trailing digit isn't 0 or 8 we can work out the
+ fraction immediately. */
+ if(digitValue > 8)
+ return lfMoreThanHalf;
+ else if(digitValue < 8 && digitValue > 0)
return lfLessThanHalf;
- }
- /* Shift DST right BITS bits noting lost fraction. */
- static lostFraction
- shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
- {
- lostFraction lost_fraction;
+ /* Otherwise we need to find the first non-zero digit. */
+ while(*p == '0')
+ p++;
- lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
+ hexDigit = hexDigitValue(*p);
- APInt::tcShiftRight(dst, parts, bits);
+ /* If we ran off the end it is exactly zero or one-half, otherwise
+ a little more. */
+ if(hexDigit == -1U)
+ return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
+ else
+ return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
+}
- return lost_fraction;
- }
+/* Return the fraction lost were a bignum truncated losing the least
+ significant BITS bits. */
+static lostFraction
+lostFractionThroughTruncation(const integerPart *parts,
+ unsigned int partCount,
+ unsigned int bits)
+{
+ unsigned int lsb;
- /* Combine the effect of two lost fractions. */
- static lostFraction
- combineLostFractions(lostFraction moreSignificant,
- lostFraction lessSignificant)
- {
- if(lessSignificant != lfExactlyZero) {
- if(moreSignificant == lfExactlyZero)
- moreSignificant = lfLessThanHalf;
- else if(moreSignificant == lfExactlyHalf)
- moreSignificant = lfMoreThanHalf;
- }
+ lsb = APInt::tcLSB(parts, partCount);
- return moreSignificant;
- }
+ /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
+ if(bits <= lsb)
+ return lfExactlyZero;
+ if(bits == lsb + 1)
+ return lfExactlyHalf;
+ if(bits <= partCount * integerPartWidth
+ && APInt::tcExtractBit(parts, bits - 1))
+ return lfMoreThanHalf;
+
+ return lfLessThanHalf;
+}
- /* The error from the true value, in half-ulps, on multiplying two
- floating point numbers, which differ from the value they
- approximate by at most HUE1 and HUE2 half-ulps, is strictly less
- than the returned value.
+/* Shift DST right BITS bits noting lost fraction. */
+static lostFraction
+shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
+{
+ lostFraction lost_fraction;
- See "How to Read Floating Point Numbers Accurately" by William D
- Clinger. */
- static unsigned int
- HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
- {
- assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
+ lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
- if (HUerr1 + HUerr2 == 0)
- return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
- else
- return inexactMultiply + 2 * (HUerr1 + HUerr2);
+ APInt::tcShiftRight(dst, parts, bits);
+
+ return lost_fraction;
+}
+
+/* Combine the effect of two lost fractions. */
+static lostFraction
+combineLostFractions(lostFraction moreSignificant,
+ lostFraction lessSignificant)
+{
+ if(lessSignificant != lfExactlyZero) {
+ if(moreSignificant == lfExactlyZero)
+ moreSignificant = lfLessThanHalf;
+ else if(moreSignificant == lfExactlyHalf)
+ moreSignificant = lfMoreThanHalf;
}
- /* The number of ulps from the boundary (zero, or half if ISNEAREST)
- when the least significant BITS are truncated. BITS cannot be
- zero. */
- static integerPart
- ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
- {
- unsigned int count, partBits;
- integerPart part, boundary;
+ return moreSignificant;
+}
- assert (bits != 0);
+/* The error from the true value, in half-ulps, on multiplying two
+ floating point numbers, which differ from the value they
+ approximate by at most HUE1 and HUE2 half-ulps, is strictly less
+ than the returned value.
- bits--;
- count = bits / integerPartWidth;
- partBits = bits % integerPartWidth + 1;
+ See "How to Read Floating Point Numbers Accurately" by William D
+ Clinger. */
+static unsigned int
+HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
+{
+ assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
- part = parts[count] & (~(integerPart) 0 >> (integerPartWidth - partBits));
+ if (HUerr1 + HUerr2 == 0)
+ return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
+ else
+ return inexactMultiply + 2 * (HUerr1 + HUerr2);
+}
- if (isNearest)
- boundary = (integerPart) 1 << (partBits - 1);
- else
- boundary = 0;
+/* The number of ulps from the boundary (zero, or half if ISNEAREST)
+ when the least significant BITS are truncated. BITS cannot be
+ zero. */
+static integerPart
+ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
+{
+ unsigned int count, partBits;
+ integerPart part, boundary;
- if (count == 0) {
- if (part - boundary <= boundary - part)
- return part - boundary;
- else
- return boundary - part;
- }
+ assert (bits != 0);
- if (part == boundary) {
- while (--count)
- if (parts[count])
- return ~(integerPart) 0; /* A lot. */
+ bits--;
+ count = bits / integerPartWidth;
+ partBits = bits % integerPartWidth + 1;
- return parts[0];
- } else if (part == boundary - 1) {
- while (--count)
- if (~parts[count])
- return ~(integerPart) 0; /* A lot. */
+ part = parts[count] & (~(integerPart) 0 >> (integerPartWidth - partBits));
- return -parts[0];
- }
+ if (isNearest)
+ boundary = (integerPart) 1 << (partBits - 1);
+ else
+ boundary = 0;
- return ~(integerPart) 0; /* A lot. */
+ if (count == 0) {
+ if (part - boundary <= boundary - part)
+ return part - boundary;
+ else
+ return boundary - part;
}
- /* Place pow(5, power) in DST, and return the number of parts used.
- DST must be at least one part larger than size of the answer. */
- static unsigned int
- powerOf5(integerPart *dst, unsigned int power)
- {
- static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
- 15625, 78125 };
- static integerPart pow5s[maxPowerOfFiveParts * 2 + 5] = { 78125 * 5 };
- static unsigned int partsCount[16] = { 1 };
+ if (part == boundary) {
+ while (--count)
+ if (parts[count])
+ return ~(integerPart) 0; /* A lot. */
- integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
- unsigned int result;
+ return parts[0];
+ } else if (part == boundary - 1) {
+ while (--count)
+ if (~parts[count])
+ return ~(integerPart) 0; /* A lot. */
- assert(power <= maxExponent);
+ return -parts[0];
+ }
- p1 = dst;
- p2 = scratch;
+ return ~(integerPart) 0; /* A lot. */
+}
- *p1 = firstEightPowers[power & 7];
- power >>= 3;
+/* Place pow(5, power) in DST, and return the number of parts used.
+ DST must be at least one part larger than size of the answer. */
+static unsigned int
+powerOf5(integerPart *dst, unsigned int power)
+{
+ static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
+ 15625, 78125 };
+ static integerPart pow5s[maxPowerOfFiveParts * 2 + 5] = { 78125 * 5 };
+ static unsigned int partsCount[16] = { 1 };
- result = 1;
- pow5 = pow5s;
+ integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
+ unsigned int result;
- for (unsigned int n = 0; power; power >>= 1, n++) {
- unsigned int pc;
+ assert(power <= maxExponent);
- pc = partsCount[n];
+ p1 = dst;
+ p2 = scratch;
- /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
- if (pc == 0) {
- pc = partsCount[n - 1];
- APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
- pc *= 2;
- if (pow5[pc - 1] == 0)
- pc--;
- partsCount[n] = pc;
- }
+ *p1 = firstEightPowers[power & 7];
+ power >>= 3;
- if (power & 1) {
- integerPart *tmp;
+ result = 1;
+ pow5 = pow5s;
- APInt::tcFullMultiply(p2, p1, pow5, result, pc);
- result += pc;
- if (p2[result - 1] == 0)
- result--;
-
- /* Now result is in p1 with partsCount parts and p2 is scratch
- space. */
- tmp = p1, p1 = p2, p2 = tmp;
- }
+ for (unsigned int n = 0; power; power >>= 1, n++) {
+ unsigned int pc;
- pow5 += pc;
+ pc = partsCount[n];
+
+ /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
+ if (pc == 0) {
+ pc = partsCount[n - 1];
+ APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
+ pc *= 2;
+ if (pow5[pc - 1] == 0)
+ pc--;
+ partsCount[n] = pc;
}
- if (p1 != dst)
- APInt::tcAssign(dst, p1, result);
+ if (power & 1) {
+ integerPart *tmp;
- return result;
- }
+ APInt::tcFullMultiply(p2, p1, pow5, result, pc);
+ result += pc;
+ if (p2[result - 1] == 0)
+ result--;
- /* Zero at the end to avoid modular arithmetic when adding one; used
- when rounding up during hexadecimal output. */
- static const char hexDigitsLower[] = "0123456789abcdef0";
- static const char hexDigitsUpper[] = "0123456789ABCDEF0";
- static const char infinityL[] = "infinity";
- static const char infinityU[] = "INFINITY";
- static const char NaNL[] = "nan";
- static const char NaNU[] = "NAN";
+ /* Now result is in p1 with partsCount parts and p2 is scratch
+ space. */
+ tmp = p1, p1 = p2, p2 = tmp;
+ }
- /* Write out an integerPart in hexadecimal, starting with the most
- significant nibble. Write out exactly COUNT hexdigits, return
- COUNT. */
- static unsigned int
- partAsHex (char *dst, integerPart part, unsigned int count,
- const char *hexDigitChars)
- {
- unsigned int result = count;
+ pow5 += pc;
+ }
- assert (count != 0 && count <= integerPartWidth / 4);
+ if (p1 != dst)
+ APInt::tcAssign(dst, p1, result);
- part >>= (integerPartWidth - 4 * count);
- while (count--) {
- dst[count] = hexDigitChars[part & 0xf];
- part >>= 4;
- }
+ return result;
+}
- return result;
+/* Zero at the end to avoid modular arithmetic when adding one; used
+ when rounding up during hexadecimal output. */
+static const char hexDigitsLower[] = "0123456789abcdef0";
+static const char hexDigitsUpper[] = "0123456789ABCDEF0";
+static const char infinityL[] = "infinity";
+static const char infinityU[] = "INFINITY";
+static const char NaNL[] = "nan";
+static const char NaNU[] = "NAN";
+
+/* Write out an integerPart in hexadecimal, starting with the most
+ significant nibble. Write out exactly COUNT hexdigits, return
+ COUNT. */
+static unsigned int
+partAsHex (char *dst, integerPart part, unsigned int count,
+ const char *hexDigitChars)
+{
+ unsigned int result = count;
+
+ assert (count != 0 && count <= integerPartWidth / 4);
+
+ part >>= (integerPartWidth - 4 * count);
+ while (count--) {
+ dst[count] = hexDigitChars[part & 0xf];
+ part >>= 4;
}
- /* Write out an unsigned decimal integer. */
- static char *
- writeUnsignedDecimal (char *dst, unsigned int n)
- {
- char buff[40], *p;
+ return result;
+}
- p = buff;
- do
- *p++ = '0' + n % 10;
- while (n /= 10);
+/* Write out an unsigned decimal integer. */
+static char *
+writeUnsignedDecimal (char *dst, unsigned int n)
+{
+ char buff[40], *p;
- do
- *dst++ = *--p;
- while (p != buff);
+ p = buff;
+ do
+ *p++ = '0' + n % 10;
+ while (n /= 10);
- return dst;
- }
+ do
+ *dst++ = *--p;
+ while (p != buff);
- /* Write out a signed decimal integer. */
- static char *
- writeSignedDecimal (char *dst, int value)
- {
- if (value < 0) {
- *dst++ = '-';
- dst = writeUnsignedDecimal(dst, -(unsigned) value);
- } else
- dst = writeUnsignedDecimal(dst, value);
+ return dst;
+}
- return dst;
- }
+/* Write out a signed decimal integer. */
+static char *
+writeSignedDecimal (char *dst, int value)
+{
+ if (value < 0) {
+ *dst++ = '-';
+ dst = writeUnsignedDecimal(dst, -(unsigned) value);
+ } else
+ dst = writeUnsignedDecimal(dst, value);
+
+ return dst;
}
/* Constructors. */
More information about the llvm-commits
mailing list