Fix trailing whitespace in scripts and misc. files

Source/wtf/dtoa/fast-dtoa.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 18 matching lines @@
 
 #include "fast-dtoa.h"
 
 #include "cached-powers.h"
 #include "diy-fp.h"
 #include "double.h"
 
 namespace WTF {
 
 namespace double_conversion {
-    
+
     // The minimal and maximal target exponent define the range of w's binary
     // exponent, where 'w' is the result of multiplying the input by a cached power
     // of ten.
     //
     // A different range might be chosen on a different platform, to optimize digit
     // generation, but a smaller range requires more powers of ten to be cached.
     static const int kMinimalTargetExponent = -60;
     static const int kMaximalTargetExponent = -32;
-    
-    
+
+
     // Adjusts the last digit of the generated number, and screens out generated
     // solutions that may be inaccurate. A solution may be inaccurate if it is
     // outside the safe interval, or if we cannot prove that it is closer to the
     // input than a neighboring representation of the same length.
     //
     // Input: * buffer containing the digits of too_high / 10^kappa
     //        * the buffer's length
     //        * distance_too_high_w == (too_high - w).f() * unit
     //        * unsafe_interval == (too_high - too_low).f() * unit
     //        * rest = (too_high - buffer * 10^kappa).f() * unit
@@ skipping 10 matching lines @@
                           uint64_t ten_kappa,
                           uint64_t unit) {
         uint64_t small_distance = distance_too_high_w - unit;
         uint64_t big_distance = distance_too_high_w + unit;
         // Let w_low  = too_high - big_distance, and
         //     w_high = too_high - small_distance.
         // Note: w_low < w < w_high
         //
         // The real w (* unit) must lie somewhere inside the interval
         // ]w_low; w_high[ (often written as "(w_low; w_high)")
-        
+
         // Basically the buffer currently contains a number in the unsafe interval
         // ]too_low; too_high[ with too_low < w < too_high
         //
         //  too_high - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
         //                     ^v 1 unit            ^      ^                 ^      ^
         //  boundary_high ---------------------     .      .                 .      .
         //                     ^v 1 unit            .      .                 .      .
         //   - - - - - - - - - - - - - - - - - - -  +  - - + - - - - - -     .      .
         //                                          .      .         ^       .      .
         //                                          .  big_distance  .       .      .
@@ skipping 52 matching lines @@
         // We need to do the following tests in this order to avoid over- and
         // underflows.
         ASSERT(rest <= unsafe_interval);
         while (rest < small_distance &&  // Negated condition 1
                unsafe_interval - rest >= ten_kappa &&  // Negated condition 2
                (rest + ten_kappa < small_distance ||  // buffer{-1} > w_high
                 small_distance - rest >= rest + ten_kappa - small_distance)) {
                    buffer[length - 1]--;
                    rest += ten_kappa;
                }
-        
+
         // We have approached w+ as much as possible. We now test if approaching w-
         // would require changing the buffer. If yes, then we have two possible
         // representations close to w, but we cannot decide which one is closer.
         if (rest < big_distance &&
             unsafe_interval - rest >= ten_kappa &&
             (rest + ten_kappa < big_distance ||
              big_distance - rest > rest + ten_kappa - big_distance)) {
                 return false;
             }
-        
+
         // Weeding test.
         //   The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
         //   Since too_low = too_high - unsafe_interval this is equivalent to
         //      [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
         //   Conceptually we have: rest ~= too_high - buffer
         return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit);
     }
-    
-    
+
+
     // Rounds the buffer upwards if the result is closer to v by possibly adding
     // 1 to the buffer. If the precision of the calculation is not sufficient to
     // round correctly, return false.
     // The rounding might shift the whole buffer in which case the kappa is
     // adjusted. For example "99", kappa = 3 might become "10", kappa = 4.
     //
     // If 2*rest > ten_kappa then the buffer needs to be round up.
     // rest can have an error of +/- 1 unit. This function accounts for the
     // imprecision and returns false, if the rounding direction cannot be
     // unambiguously determined.
@@ skipping 35 matching lines @@
             // first digit to '1' and adjust the kappa. Example: "99" becomes "10" and
             // the power (the kappa) is increased.
             if (buffer[0] == '0' + 10) {
                 buffer[0] = '1';
                 (*kappa) += 1;
             }
             return true;
         }
         return false;
     }
-    
-    
+
+
     static const uint32_t kTen4 = 10000;
     static const uint32_t kTen5 = 100000;
     static const uint32_t kTen6 = 1000000;
     static const uint32_t kTen7 = 10000000;
     static const uint32_t kTen8 = 100000000;
     static const uint32_t kTen9 = 1000000000;
-    
+
     // Returns the biggest power of ten that is less than or equal to the given
     // number. We furthermore receive the maximum number of bits 'number' has.
     // If number_bits == 0 then 0^-1 is returned
     // The number of bits must be <= 32.
     // Precondition: number < (1 << (number_bits + 1)).
     static void BiggestPowerTen(uint32_t number,
                                 int number_bits,
                                 uint32_t* power,
                                 int* exponent) {
         ASSERT(number < (uint32_t)(1 << (number_bits + 1)));
-        
+
         switch (number_bits) {
             case 32:
             case 31:
             case 30:
                 if (kTen9 <= number) {
                     *power = kTen9;
                     *exponent = 9;
                     break;
                 }  // else fallthrough
             case 29:
@@ skipping 74 matching lines @@
                 *power = 0;
                 *exponent = -1;
                 break;
             default:
                 // Following assignments are here to silence compiler warnings.
                 *power = 0;
                 *exponent = 0;
                 UNREACHABLE();
         }
     }
-    
-    
+
+
     // Generates the digits of input number w.
     // w is a floating-point number (DiyFp), consisting of a significand and an
     // exponent. Its exponent is bounded by kMinimalTargetExponent and
     // kMaximalTargetExponent.
     //       Hence -60 <= w.e() <= -32.
     //
     // Returns false if it fails, in which case the generated digits in the buffer
     // should not be used.
     // Preconditions:
     //  * low, w and high are correct up to 1 ulp (unit in the last place). That
@@ skipping 91 matching lines @@
             // Reminder: unsafe_interval.e() == one.e()
             if (rest < unsafe_interval.f()) {
                 // Rounding down (by not emitting the remaining digits) yields a number
                 // that lies within the unsafe interval.
                 return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(),
                                  unsafe_interval.f(), rest,
                                  static_cast<uint64_t>(divisor) << -one.e(), unit);
             }
             divisor /= 10;
         }
-        
+
         // The integrals have been generated. We are at the point of the decimal
         // separator. In the following loop we simply multiply the remaining digits by
         // 10 and divide by one. We just need to pay attention to multiply associated
         // data (like the interval or 'unit'), too.
         // Note that the multiplication by 10 does not overflow, because w.e >= -60
         // and thus one.e >= -60.
         ASSERT(one.e() >= -60);
         ASSERT(fractionals < one.f());
         ASSERT(UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF) / 10 >= one.f());
         while (true) {
             fractionals *= 10;
             unit *= 10;
             unsafe_interval.set_f(unsafe_interval.f() * 10);
             // Integer division by one.
             int digit = static_cast<int>(fractionals >> -one.e());
             buffer[*length] = '0' + digit;
             (*length)++;
             fractionals &= one.f() - 1;  // Modulo by one.
             (*kappa)--;
             if (fractionals < unsafe_interval.f()) {
                 return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit,
                                  unsafe_interval.f(), fractionals, one.f(), unit);
             }
         }
     }
-    
-    
-    
+
+
+
     // Generates (at most) requested_digits digits of input number w.
     // w is a floating-point number (DiyFp), consisting of a significand and an
     // exponent. Its exponent is bounded by kMinimalTargetExponent and
     // kMaximalTargetExponent.
     //       Hence -60 <= w.e() <= -32.
     //
     // Returns false if it fails, in which case the generated digits in the buffer
     // should not be used.
     // Preconditions:
     //  * w is correct up to 1 ulp (unit in the last place). That
@@ skipping 34 matching lines @@
         // Division by one is a shift.
         uint32_t integrals = static_cast<uint32_t>(w.f() >> -one.e());
         // Modulo by one is an and.
         uint64_t fractionals = w.f() & (one.f() - 1);
         uint32_t divisor;
         int divisor_exponent;
         BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()),
                         &divisor, &divisor_exponent);
         *kappa = divisor_exponent + 1;
         *length = 0;
-        
+
         // Loop invariant: buffer = w / 10^kappa  (integer division)
         // The invariant holds for the first iteration: kappa has been initialized
         // with the divisor exponent + 1. And the divisor is the biggest power of ten
         // that is smaller than 'integrals'.
         while (*kappa > 0) {
             int digit = integrals / divisor;
             buffer[*length] = '0' + digit;
             (*length)++;
             requested_digits--;
             integrals %= divisor;
             (*kappa)--;
             // Note that kappa now equals the exponent of the divisor and that the
             // invariant thus holds again.
             if (requested_digits == 0) break;
             divisor /= 10;
         }
-        
+
         if (requested_digits == 0) {
             uint64_t rest =
             (static_cast<uint64_t>(integrals) << -one.e()) + fractionals;
             return RoundWeedCounted(buffer, *length, rest,
                                     static_cast<uint64_t>(divisor) << -one.e(), w_error,
                                     kappa);
         }
-        
+
         // The integrals have been generated. We are at the point of the decimal
         // separator. In the following loop we simply multiply the remaining digits by
         // 10 and divide by one. We just need to pay attention to multiply associated
         // data (the 'unit'), too.
         // Note that the multiplication by 10 does not overflow, because w.e >= -60
         // and thus one.e >= -60.
         ASSERT(one.e() >= -60);
         ASSERT(fractionals < one.f());
         ASSERT(UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF) / 10 >= one.f());
         while (requested_digits > 0 && fractionals > w_error) {
             fractionals *= 10;
             w_error *= 10;
             // Integer division by one.
             int digit = static_cast<int>(fractionals >> -one.e());
             buffer[*length] = '0' + digit;
             (*length)++;
             requested_digits--;
             fractionals &= one.f() - 1;  // Modulo by one.
             (*kappa)--;
         }
         if (requested_digits != 0) return false;
         return RoundWeedCounted(buffer, *length, fractionals, one.f(), w_error,
                                 kappa);
     }
-    
-    
+
+
     // Provides a decimal representation of v.
     // Returns true if it succeeds, otherwise the result cannot be trusted.
     // There will be *length digits inside the buffer (not null-terminated).
     // If the function returns true then
     //        v == (double) (buffer * 10^decimal_exponent).
     // The digits in the buffer are the shortest representation possible: no
     // 0.09999999999999999 instead of 0.1. The shorter representation will even be
     // chosen even if the longer one would be closer to v.
     // The last digit will be closest to the actual v. That is, even if several
     // digits might correctly yield 'v' when read again, the closest will be
@@ skipping 19 matching lines @@
         PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
                                                                ten_mk_minimal_binary_exponent,
                                                                ten_mk_maximal_binary_exponent,
                                                                &ten_mk, &mk);
         ASSERT((kMinimalTargetExponent <= w.e() + ten_mk.e() +
                 DiyFp::kSignificandSize) &&
                (kMaximalTargetExponent >= w.e() + ten_mk.e() +
                 DiyFp::kSignificandSize));
         // Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
         // 64 bit significand and ten_mk is thus only precise up to 64 bits.
-        
+
         // The DiyFp::Times procedure rounds its result, and ten_mk is approximated
         // too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
         // off by a small amount.
         // In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
         // In other words: let f = scaled_w.f() and e = scaled_w.e(), then
         //           (f-1) * 2^e < w*10^k < (f+1) * 2^e
         DiyFp scaled_w = DiyFp::Times(w, ten_mk);
         ASSERT(scaled_w.e() ==
                boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize);
         // In theory it would be possible to avoid some recomputations by computing
         // the difference between w and boundary_minus/plus (a power of 2) and to
         // compute scaled_boundary_minus/plus by subtracting/adding from
         // scaled_w. However the code becomes much less readable and the speed
         // enhancements are not terriffic.
         DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk);
         DiyFp scaled_boundary_plus  = DiyFp::Times(boundary_plus,  ten_mk);
-        
+
         // DigitGen will generate the digits of scaled_w. Therefore we have
         // v == (double) (scaled_w * 10^-mk).
         // Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
         // integer than it will be updated. For instance if scaled_w == 1.23 then
         // the buffer will be filled with "123" und the decimal_exponent will be
         // decreased by 2.
         int kappa;
         bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus,
                                buffer, length, &kappa);
         *decimal_exponent = -mk + kappa;
         return result;
     }
-    
-    
+
+
     // The "counted" version of grisu3 (see above) only generates requested_digits
     // number of digits. This version does not generate the shortest representation,
     // and with enough requested digits 0.1 will at some point print as 0.9999999...
     // Grisu3 is too imprecise for real halfway cases (1.5 will not work) and
     // therefore the rounding strategy for halfway cases is irrelevant.
     static bool Grisu3Counted(double v,
                               int requested_digits,
                               Vector<char> buffer,
                               int* length,
                               int* decimal_exponent) {
         DiyFp w = Double(v).AsNormalizedDiyFp();
         DiyFp ten_mk;  // Cached power of ten: 10^-k
         int mk;        // -k
         int ten_mk_minimal_binary_exponent =
         kMinimalTargetExponent - (w.e() + DiyFp::kSignificandSize);
         int ten_mk_maximal_binary_exponent =
         kMaximalTargetExponent - (w.e() + DiyFp::kSignificandSize);
         PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
                                                                ten_mk_minimal_binary_exponent,
                                                                ten_mk_maximal_binary_exponent,
                                                                &ten_mk, &mk);
         ASSERT((kMinimalTargetExponent <= w.e() + ten_mk.e() +
                 DiyFp::kSignificandSize) &&
                (kMaximalTargetExponent >= w.e() + ten_mk.e() +
                 DiyFp::kSignificandSize));
         // Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
         // 64 bit significand and ten_mk is thus only precise up to 64 bits.
-        
+
         // The DiyFp::Times procedure rounds its result, and ten_mk is approximated
         // too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
         // off by a small amount.
         // In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
         // In other words: let f = scaled_w.f() and e = scaled_w.e(), then
         //           (f-1) * 2^e < w*10^k < (f+1) * 2^e
         DiyFp scaled_w = DiyFp::Times(w, ten_mk);
-        
+
         // We now have (double) (scaled_w * 10^-mk).
         // DigitGen will generate the first requested_digits digits of scaled_w and
         // return together with a kappa such that scaled_w ~= buffer * 10^kappa. (It
         // will not always be exactly the same since DigitGenCounted only produces a
         // limited number of digits.)
         int kappa;
         bool result = DigitGenCounted(scaled_w, requested_digits,
                                       buffer, length, &kappa);
         *decimal_exponent = -mk + kappa;
         return result;
     }
-    
-    
+
+
     bool FastDtoa(double v,
                   FastDtoaMode mode,
                   int requested_digits,
                   Vector<char> buffer,
                   int* length,
                   int* decimal_point) {
         ASSERT(v > 0);
         ASSERT(!Double(v).IsSpecial());
-        
+
         bool result = false;
         int decimal_exponent = 0;
         switch (mode) {
             case FAST_DTOA_SHORTEST:
                 result = Grisu3(v, buffer, length, &decimal_exponent);
                 break;
             case FAST_DTOA_PRECISION:
                 result = Grisu3Counted(v, requested_digits,
                                        buffer, length, &decimal_exponent);
                 break;
             default:
                 UNREACHABLE();
         }
         if (result) {
             *decimal_point = *length + decimal_exponent;
             buffer[*length] = '\0';
         }
         return result;
     }
-    
+
 }  // namespace double_conversion
 
 } // namespace WTF