[Minor] Reformat file to fix tabs/spaces mess

1 files changed, 249 insertions, 250 deletions

diff --git a/contrib/fpconv/fpconv.c b/contrib/fpconv/fpconv.c
index 3b96af270..71818828f 100644
--- a/contrib/fpconv/fpconv.c
+++ b/contrib/fpconv/fpconv.c
@@ -14,290 +14,283 @@
 #define minv(a, b) ((a) < (b) ? (a) : (b))
 
 static uint64_t tens[] = {
-    10000000000000000000U, 1000000000000000000U, 100000000000000000U,
-    10000000000000000U, 1000000000000000U, 100000000000000U,
-    10000000000000U, 1000000000000U, 100000000000U,
-    10000000000U, 1000000000U, 100000000U,
-    10000000U, 1000000U, 100000U,
-    10000U, 1000U, 100U,
-    10U, 1U
+		10000000000000000000U, 1000000000000000000U, 100000000000000000U,
+		10000000000000000U, 1000000000000000U, 100000000000000U,
+		10000000000000U, 1000000000000U, 100000000000U,
+		10000000000U, 1000000000U, 100000000U,
+		10000000U, 1000000U, 100000U,
+		10000U, 1000U, 100U,
+		10U, 1U
 };
 
-static inline uint64_t get_dbits(double d)
-{
-    union {
-        double   dbl;
-        uint64_t i;
-    } dbl_bits = { d };
+static inline uint64_t get_dbits (double d) {
+	union {
+		double dbl;
+		uint64_t i;
+	} dbl_bits = {d};
 
-    return dbl_bits.i;
+	return dbl_bits.i;
 }
 
-static Fp build_fp(double d)
-{
-    uint64_t bits = get_dbits(d);
+static Fp build_fp (double d) {
+	uint64_t bits = get_dbits (d);
 
-    Fp fp;
-    fp.frac = bits & fracmask;
-    fp.exp = (bits & expmask) >> 52;
+	Fp fp;
+	fp.frac = bits & fracmask;
+	fp.exp = (bits & expmask) >> 52u;
 
-    if(fp.exp) {
-        fp.frac += hiddenbit;
-        fp.exp -= expbias;
+	if (fp.exp) {
+		fp.frac += hiddenbit;
+		fp.exp -= expbias;
 
-    } else {
-        fp.exp = -expbias + 1;
-    }
+	}
+	else {
+		fp.exp = -expbias + 1;
+	}
 
-    return fp;
+	return fp;
 }
 
-static void normalize(Fp* fp)
-{
-    while ((fp->frac & hiddenbit) == 0) {
-        fp->frac <<= 1;
-        fp->exp--;
-    }
+static void normalize (Fp *fp) {
+	while ((fp->frac & hiddenbit) == 0) {
+		fp->frac <<= 1u;
+		fp->exp--;
+	}
 
-    int shift = 64 - 52 - 1;
-    fp->frac <<= shift;
-    fp->exp -= shift;
+	const unsigned int shift = 64 - 52 - 1;
+	fp->frac <<= shift;
+	fp->exp -= shift;
 }
 
-static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper)
-{
-    upper->frac = (fp->frac << 1) + 1;
-    upper->exp  = fp->exp - 1;
+static void get_normalized_boundaries (Fp *fp, Fp *lower, Fp *upper) {
+	upper->frac = (fp->frac << 1u) + 1u;
+	upper->exp = fp->exp - 1u;
 
-    while ((upper->frac & (hiddenbit << 1)) == 0) {
-        upper->frac <<= 1;
-        upper->exp--;
-    }
+	while ((upper->frac & (hiddenbit << 1u)) == 0) {
+		upper->frac <<= 1u;
+		upper->exp--;
+	}
 
-    int u_shift = 64 - 52 - 2;
+	const unsigned int u_shift = 64 - 52 - 2;
 
-    upper->frac <<= u_shift;
-    upper->exp = upper->exp - u_shift;
+	upper->frac <<= u_shift;
+	upper->exp = upper->exp - u_shift;
 
 
-    int l_shift = fp->frac == hiddenbit ? 2 : 1;
+	unsigned int l_shift = fp->frac == hiddenbit ? 2u : 1u;
 
-    lower->frac = (fp->frac << l_shift) - 1;
-    lower->exp = fp->exp - l_shift;
+	lower->frac = (fp->frac << l_shift) - 1;
+	lower->exp = fp->exp - l_shift;
 
 
-    lower->frac <<= lower->exp - upper->exp;
-    lower->exp = upper->exp;
+	lower->frac <<= lower->exp - upper->exp;
+	lower->exp = upper->exp;
 }
 
-static Fp multiply(Fp* a, Fp* b)
-{
-    const uint64_t lomask = 0x00000000FFFFFFFF;
+static Fp multiply (Fp *a, Fp *b) {
+	const uint64_t lomask = 0x00000000FFFFFFFFu;
 
-    uint64_t ah_bl = (a->frac >> 32)    * (b->frac & lomask);
-    uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);
-    uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
-    uint64_t ah_bh = (a->frac >> 32)    * (b->frac >> 32);
+	uint64_t ah_bl = (a->frac >> 32u) * (b->frac & lomask);
+	uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32u);
+	uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
+	uint64_t ah_bh = (a->frac >> 32u) * (b->frac >> 32u);
 
-    uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);
-    /* round up */
-    tmp += 1U << 31;
+	uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32u);
+	/* round up */
+	tmp += 1U << 31u;
 
-    Fp fp = {
-        ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32),
-        a->exp + b->exp + 64
-    };
+	Fp fp = {
+			ah_bh + (ah_bl >> 32u) + (al_bh >> 32u) + (tmp >> 32u),
+			a->exp + b->exp + 64u
+	};
 
-    return fp;
+	return fp;
 }
 
-static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac)
-{
-    while (rem < frac && delta - rem >= kappa &&
-           (rem + kappa < frac || frac - rem > rem + kappa - frac)) {
+static void round_digit (char *digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac) {
+	while (rem < frac && delta - rem >= kappa &&
+		   (rem + kappa < frac || frac - rem > rem + kappa - frac)) {
 
-        digits[ndigits - 1]--;
-        rem += kappa;
-    }
+		digits[ndigits - 1]--;
+		rem += kappa;
+	}
 }
 
-static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K)
-{
-    uint64_t wfrac = upper->frac - fp->frac;
-    uint64_t delta = upper->frac - lower->frac;
+static int generate_digits (Fp *fp, Fp *upper, Fp *lower, char *digits, int *K) {
+	uint64_t wfrac = upper->frac - fp->frac;
+	uint64_t delta = upper->frac - lower->frac;
 
-    Fp one;
-    one.frac = 1ULL << -upper->exp;
-    one.exp  = upper->exp;
+	Fp one;
+	one.frac = 1ULL << -upper->exp;
+	one.exp = upper->exp;
 
-    uint64_t part1 = upper->frac >> -one.exp;
-    uint64_t part2 = upper->frac & (one.frac - 1);
+	uint64_t part1 = upper->frac >> -one.exp;
+	uint64_t part2 = upper->frac & (one.frac - 1);
 
-    int idx = 0, kappa = 10;
-    uint64_t* divp;
-    /* 1000000000 */
-    for(divp = tens + 10; kappa > 0; divp++) {
+	int idx = 0, kappa = 10;
+	uint64_t *divp;
+	/* 1000000000 */
+	for (divp = tens + 10; kappa > 0; divp++) {
 
-        uint64_t div = *divp;
-        unsigned digit = part1 / div;
+		uint64_t div = *divp;
+		unsigned digit = part1 / div;
 
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
+		if (digit || idx) {
+			digits[idx++] = digit + '0';
+		}
 
-        part1 -= digit * div;
-        kappa--;
+		part1 -= digit * div;
+		kappa--;
 
-        uint64_t tmp = (part1 <<-one.exp) + part2;
-        if (tmp <= delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac);
+		uint64_t tmp = (part1 << -one.exp) + part2;
+		if (tmp <= delta) {
+			*K += kappa;
+			round_digit (digits, idx, delta, tmp, div << -one.exp, wfrac);
 
-            return idx;
-        }
-    }
+			return idx;
+		}
+	}
 
-    /* 10 */
-    uint64_t* unit = tens + 18;
+	/* 10 */
+	uint64_t *unit = tens + 18;
 
-    while(true) {
-        part2 *= 10;
-        delta *= 10;
-        kappa--;
+	while (true) {
+		part2 *= 10;
+		delta *= 10;
+		kappa--;
 
-        unsigned digit = part2 >> -one.exp;
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
+		unsigned digit = part2 >> -one.exp;
+		if (digit || idx) {
+			digits[idx++] = digit + '0';
+		}
 
-        part2 &= one.frac - 1;
-        if (part2 < delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, part2, one.frac, wfrac * *unit);
+		part2 &= one.frac - 1;
+		if (part2 < delta) {
+			*K += kappa;
+			round_digit (digits, idx, delta, part2, one.frac, wfrac * *unit);
 
-            return idx;
-        }
+			return idx;
+		}
 
-        unit--;
-    }
+		unit--;
+	}
 }
 
-static int grisu2(double d, char* digits, int* K)
-{
-    Fp w = build_fp(d);
+static int grisu2 (double d, char *digits, int *K) {
+	Fp w = build_fp (d);
 
-    Fp lower, upper;
-    get_normalized_boundaries(&w, &lower, &upper);
+	Fp lower, upper;
+	get_normalized_boundaries (&w, &lower, &upper);
 
-    normalize(&w);
+	normalize (&w);
 
-    int k;
-    Fp cp = find_cachedpow10(upper.exp, &k);
+	int k;
+	Fp cp = find_cachedpow10 (upper.exp, &k);
 
-    w     = multiply(&w,     &cp);
-    upper = multiply(&upper, &cp);
-    lower = multiply(&lower, &cp);
+	w = multiply (&w, &cp);
+	upper = multiply (&upper, &cp);
+	lower = multiply (&lower, &cp);
 
-    lower.frac++;
-    upper.frac--;
+	lower.frac++;
+	upper.frac--;
 
-    *K = -k;
+	*K = -k;
 
-    return generate_digits(&w, &upper, &lower, digits, K);
+	return generate_digits (&w, &upper, &lower, digits, K);
 }
 
-static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg,
-		bool scientific)
-{
-    int exp = absv(K + ndigits - 1);
-
-    /* write plain integer */
-    if(K >= 0 && (exp < (ndigits + 7))) {
-        memcpy(dest, digits, ndigits);
-        memset(dest + ndigits, '0', K);
-
-        return ndigits + K;
-    }
-
-    /* write decimal w/o scientific notation */
-    if(!scientific || (K < 0 && (K > -7 || exp < 4))) {
-        int offset = ndigits - absv(K);
-        /* fp < 1.0 -> write leading zero */
-        if(offset <= 0) {
-            offset = -offset;
-            dest[0] = '0';
-            dest[1] = '.';
-
-            /* We have up to 21 characters in output available */
-            if (offset + ndigits <= 21) {
-            	memset(dest + 2, '0', offset);
-            	memcpy(dest + offset + 2, digits, ndigits);
-
-            	return ndigits + 2 + offset;
-            }
-            else {
-            	goto scientific_fallback;
-            }
-
-        /* fp > 1.0 */
-        } else {
-            /* Overflow check */
-            if (ndigits <= 23) {
-            	memcpy(dest, digits, offset);
-            	dest[offset] = '.';
-            	memcpy(dest + offset + 1, digits + offset, ndigits - offset);
-            	return ndigits + 1;
-            }
-
-            goto scientific_fallback;
-        }
-    }
-
-scientific_fallback:
-    /* write decimal w/ scientific notation */
-    ndigits = minv(ndigits, 18 - neg);
-
-    int idx = 0;
-    dest[idx++] = digits[0];
-
-    if(ndigits > 1) {
-        dest[idx++] = '.';
-        memcpy(dest + idx, digits + 1, ndigits - 1);
-        idx += ndigits - 1;
-    }
-
-    dest[idx++] = 'e';
-
-    char sign = K + ndigits - 1 < 0 ? '-' : '+';
-    dest[idx++] = sign;
-
-    int cent = 0;
-
-    if(exp > 99) {
-        cent = exp / 100;
-        dest[idx++] = cent + '0';
-        exp -= cent * 100;
-    }
-    if(exp > 9) {
-        int dec = exp / 10;
-        dest[idx++] = dec + '0';
-        exp -= dec * 10;
-
-    } else if(cent) {
-        dest[idx++] = '0';
-    }
-
-    dest[idx++] = exp % 10 + '0';
-
-    return idx;
+static int emit_digits (char *digits, int ndigits, char *dest, int K, bool neg,
+						bool scientific) {
+	int exp = absv(K + ndigits - 1);
+
+	/* write plain integer */
+	if (K >= 0 && (exp < (ndigits + 7))) {
+		memcpy(dest, digits, ndigits);
+		memset(dest + ndigits, '0', K);
+
+		return ndigits + K;
+	}
+
+	/* write decimal w/o scientific notation */
+	if (!scientific || (K < 0 && (K > -7 || exp < 4))) {
+		int offset = ndigits - absv(K);
+		/* fp < 1.0 -> write leading zero */
+		if (offset <= 0) {
+			offset = -offset;
+			dest[0] = '0';
+			dest[1] = '.';
+
+			/* We have up to 21 characters in output available */
+			if (offset + ndigits <= 21) {
+				memset(dest + 2, '0', offset);
+				memcpy(dest + offset + 2, digits, ndigits);
+
+				return ndigits + 2 + offset;
+			}
+			else {
+				goto scientific_fallback;
+			}
+
+			/* fp > 1.0 */
+		}
+		else {
+			/* Overflow check */
+			if (ndigits <= 23) {
+				memcpy(dest, digits, offset);
+				dest[offset] = '.';
+				memcpy(dest + offset + 1, digits + offset, ndigits - offset);
+				return ndigits + 1;
+			}
+
+			goto scientific_fallback;
+		}
+	}
+
+	scientific_fallback:
+	/* write decimal w/ scientific notation */
+	ndigits = minv(ndigits, 18 - neg);
+
+	int idx = 0;
+	dest[idx++] = digits[0];
+
+	if (ndigits > 1) {
+		dest[idx++] = '.';
+		memcpy(dest + idx, digits + 1, ndigits - 1);
+		idx += ndigits - 1;
+	}
+
+	dest[idx++] = 'e';
+
+	char sign = K + ndigits - 1 < 0 ? '-' : '+';
+	dest[idx++] = sign;
+
+	int cent = 0;
+
+	if (exp > 99) {
+		cent = exp / 100;
+		dest[idx++] = cent + '0';
+		exp -= cent * 100;
+	}
+	if (exp > 9) {
+		int dec = exp / 10;
+		dest[idx++] = dec + '0';
+		exp -= dec * 10;
+
+	}
+	else if (cent) {
+		dest[idx++] = '0';
+	}
+
+	dest[idx++] = exp % 10 + '0';
+
+	return idx;
 }
 
-static int filter_special(double fp, char* dest)
-{
+static int filter_special (double fp, char *dest) {
 	int nchars = 3;
 
-    if(fp == 0.0) {
-		if(get_dbits(fp) & signmask) {
+	if (fp == 0.0) {
+		if (get_dbits (fp) & signmask) {
 			dest[0] = '-';
 			dest[1] = '0';
 			return 2;
@@ -306,56 +299,62 @@ static int filter_special(double fp, char* dest)
 			dest[0] = '0';
 			return 1;
 		}
-    }
+	}
 
-    uint64_t bits = get_dbits(fp);
+	uint64_t bits = get_dbits (fp);
 
-    bool nan = (bits & expmask) == expmask;
+	bool nan = (bits & expmask) == expmask;
 
-    if(!nan) {
-        return 0;
-    }
+	if (!nan) {
+		return 0;
+	}
 
-    if(bits & fracmask) {
-        dest[0] = 'n'; dest[1] = 'a'; dest[2] = 'n';
-    } else {
-		if(get_dbits(fp) & signmask) {
+	if (bits & fracmask) {
+		dest[0] = 'n';
+		dest[1] = 'a';
+		dest[2] = 'n';
+	}
+	else {
+		if (get_dbits (fp) & signmask) {
 			dest[0] = '-';
-			dest[1] = 'i'; dest[2] = 'n'; dest[3] = 'f';
+			dest[1] = 'i';
+			dest[2] = 'n';
+			dest[3] = 'f';
 			nchars = 4;
 		}
 		else {
-			dest[0] = 'i'; dest[1] = 'n'; dest[2] = 'f';
+			dest[0] = 'i';
+			dest[1] = 'n';
+			dest[2] = 'f';
 		}
-    }
+	}
 
-    return nchars;
+	return nchars;
 }
 
-int fpconv_dtoa(double d, char dest[24], bool scientific)
-{
-    char digits[18];
+int fpconv_dtoa (double d, char dest[24], bool scientific) {
+	char digits[18];
 
-    int str_len = 0;
-    bool neg = false;
+	int str_len = 0;
+	bool neg = false;
 
 
-    int spec = filter_special(d, dest + str_len);
+	int spec = filter_special (d, dest + str_len);
 
-    if(spec) {
-        return str_len + spec;
-    }
+	if (spec) {
+		return str_len + spec;
+	}
 
-	if(get_dbits(d) & signmask) {
+	if (get_dbits (d) & signmask) {
 		dest[0] = '-';
 		str_len++;
 		neg = true;
 	}
 
-    int K = 0;
-    int ndigits = grisu2(d, digits, &K);
+	int K = 0;
+	int ndigits = grisu2 (d, digits, &K);
 
-    str_len += emit_digits(digits, ndigits, dest + str_len, K, neg, scientific);
+	str_len += emit_digits (digits, ndigits, dest + str_len, K, neg, scientific);
 
-    return str_len;
+	return str_len;
 }