Fix trailing whitespace in scripts and misc. files

Source/wtf/dtoa/bignum-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 19 matching lines @@
 #include <math.h>
 
 #include "bignum-dtoa.h"
 
 #include "bignum.h"
 #include "double.h"
 
 namespace WTF {
 
 namespace double_conversion {
-    
+
     static int NormalizedExponent(uint64_t significand, int exponent) {
         ASSERT(significand != 0);
         while ((significand & Double::kHiddenBit) == 0) {
             significand = significand << 1;
             exponent = exponent - 1;
         }
         return exponent;
     }
-    
-    
+
+
     // Forward declarations:
     // Returns an estimation of k such that 10^(k-1) <= v < 10^k.
     static int EstimatePower(int exponent);
     // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
     // and denominator.
     static void InitialScaledStartValues(double v,
                                          int estimated_power,
                                          bool need_boundary_deltas,
                                          Bignum* numerator,
                                          Bignum* denominator,
@@ skipping 18 matching lines @@
     static void BignumToFixed(int requested_digits, int* decimal_point,
                               Bignum* numerator, Bignum* denominator,
                               Vector<char>(buffer), int* length);
     // Generates 'count' digits of numerator/denominator.
     // Once 'count' digits have been produced rounds the result depending on the
     // remainder (remainders of exactly .5 round upwards). Might update the
     // decimal_point when rounding up (for example for 0.9999).
     static void GenerateCountedDigits(int count, int* decimal_point,
                                       Bignum* numerator, Bignum* denominator,
                                       Vector<char>(buffer), int* length);
-    
-    
+
+
     void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
                     Vector<char> buffer, int* length, int* decimal_point) {
         ASSERT(v > 0);
         ASSERT(!Double(v).IsSpecial());
         uint64_t significand = Double(v).Significand();
         bool is_even = (significand & 1) == 0;
         int exponent = Double(v).Exponent();
         int normalized_exponent = NormalizedExponent(significand, exponent);
         // estimated_power might be too low by 1.
         int estimated_power = EstimatePower(normalized_exponent);
-        
+
         // Shortcut for Fixed.
         // The requested digits correspond to the digits after the point. If the
         // number is much too small, then there is no need in trying to get any
         // digits.
         if (mode == BIGNUM_DTOA_FIXED && -estimated_power - 1 > requested_digits) {
             buffer[0] = '\0';
             *length = 0;
             // Set decimal-point to -requested_digits. This is what Gay does.
             // Note that it should not have any effect anyways since the string is
             // empty.
             *decimal_point = -requested_digits;
             return;
         }
-        
+
         Bignum numerator;
         Bignum denominator;
         Bignum delta_minus;
         Bignum delta_plus;
         // Make sure the bignum can grow large enough. The smallest double equals
         // 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
         // The maximum double is 1.7976931348623157e308 which needs fewer than
         // 308*4 binary digits.
         ASSERT(Bignum::kMaxSignificantBits >= 324*4);
         bool need_boundary_deltas = (mode == BIGNUM_DTOA_SHORTEST);
@@ skipping 20 matching lines @@
             case BIGNUM_DTOA_PRECISION:
                 GenerateCountedDigits(requested_digits, decimal_point,
                                       &numerator, &denominator,
                                       buffer, length);
                 break;
             default:
                 UNREACHABLE();
         }
         buffer[*length] = '\0';
     }
-    
-    
+
+
     // The procedure starts generating digits from the left to the right and stops
     // when the generated digits yield the shortest decimal representation of v. A
     // decimal representation of v is a number lying closer to v than to any other
     // double, so it converts to v when read.
     //
     // This is true if d, the decimal representation, is between m- and m+, the
     // upper and lower boundaries. d must be strictly between them if !is_even.
     //           m- := (numerator - delta_minus) / denominator
     //           m+ := (numerator + delta_plus) / denominator
     //
@@ skipping 10 matching lines @@
             delta_plus = delta_minus;
         }
         *length = 0;
         while (true) {
             uint16_t digit;
             digit = numerator->DivideModuloIntBignum(*denominator);
             ASSERT(digit <= 9);  // digit is a uint16_t and therefore always positive.
             // digit = numerator / denominator (integer division).
             // numerator = numerator % denominator.
             buffer[(*length)++] = digit + '0';
-            
+
             // Can we stop already?
             // If the remainder of the division is less than the distance to the lower
             // boundary we can stop. In this case we simply round down (discarding the
             // remainder).
             // Similarly we test if we can round up (using the upper boundary).
             bool in_delta_room_minus;
             bool in_delta_room_plus;
             if (is_even) {
                 in_delta_room_minus = Bignum::LessEqual(*numerator, *delta_minus);
             } else {
@@ skipping 28 matching lines @@
                     // loop would have stopped earlier.
                     // We still have an assert here in case the preconditions were not
                     // satisfied.
                     ASSERT(buffer[(*length) - 1] != '9');
                     buffer[(*length) - 1]++;
                 } else {
                     // Halfway case.
                     // TODO(floitsch): need a way to solve half-way cases.
                     //   For now let's round towards even (since this is what Gay seems to
                     //   do).
-                    
+
                     if ((buffer[(*length) - 1] - '0') % 2 == 0) {
                         // Round down => Do nothing.
                     } else {
                         ASSERT(buffer[(*length) - 1] != '9');
                         buffer[(*length) - 1]++;
                     }
                 }
                 return;
             } else if (in_delta_room_minus) {
                 // Round down (== do nothing).
                 return;
             } else {  // in_delta_room_plus
                 // Round up.
                 // Note again that the last digit could not be '9' since this would have
                 // stopped the loop earlier.
                 // We still have an ASSERT here, in case the preconditions were not
                 // satisfied.
                 ASSERT(buffer[(*length) -1] != '9');
                 buffer[(*length) - 1]++;
                 return;
             }
         }
     }
-    
-    
+
+
     // Let v = numerator / denominator < 10.
     // Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
     // from left to right. Once 'count' digits have been produced we decide wether
     // to round up or down. Remainders of exactly .5 round upwards. Numbers such
     // as 9.999999 propagate a carry all the way, and change the
     // exponent (decimal_point), when rounding upwards.
     static void GenerateCountedDigits(int count, int* decimal_point,
                                       Bignum* numerator, Bignum* denominator,
                                       Vector<char>(buffer), int* length) {
         ASSERT(count >= 0);
@@ skipping 21 matching lines @@
             buffer[i] = '0';
             buffer[i - 1]++;
         }
         if (buffer[0] == '0' + 10) {
             // Propagate a carry past the top place.
             buffer[0] = '1';
             (*decimal_point)++;
         }
         *length = count;
     }
-    
-    
+
+
     // Generates 'requested_digits' after the decimal point. It might omit
     // trailing '0's. If the input number is too small then no digits at all are
     // generated (ex.: 2 fixed digits for 0.00001).
     //
     // Input verifies:  1 <= (numerator + delta) / denominator < 10.
     static void BignumToFixed(int requested_digits, int* decimal_point,
                               Bignum* numerator, Bignum* denominator,
                               Vector<char>(buffer), int* length) {
         // Note that we have to look at more than just the requested_digits, since
         // a number could be rounded up. Example: v=0.5 with requested_digits=0.
@@ skipping 27 matching lines @@
             return;
         } else {
             // The requested digits correspond to the digits after the point.
             // The variable 'needed_digits' includes the digits before the point.
             int needed_digits = (*decimal_point) + requested_digits;
             GenerateCountedDigits(needed_digits, decimal_point,
                                   numerator, denominator,
                                   buffer, length);
         }
     }
-    
-    
+
+
     // Returns an estimation of k such that 10^(k-1) <= v < 10^k where
     // v = f * 2^exponent and 2^52 <= f < 2^53.
     // v is hence a normalized double with the given exponent. The output is an
     // approximation for the exponent of the decimal approimation .digits * 10^k.
     //
     // The result might undershoot by 1 in which case 10^k <= v < 10^k+1.
     // Note: this property holds for v's upper boundary m+ too.
     //    10^k <= m+ < 10^k+1.
     //   (see explanation below).
     //
@@ skipping 16 matching lines @@
         // Optimization: since we only need an approximated result this computation
         // can be performed on 64 bit integers. On x86/x64 architecture the speedup is
         // not really measurable, though.
         //
         // Since we want to avoid overshooting we decrement by 1e10 so that
         // floating-point imprecisions don't affect us.
         //
         // Explanation for v's boundary m+: the computation takes advantage of
         // the fact that 2^(p-1) <= f < 2^p. Boundaries still satisfy this requirement
         // (even for denormals where the delta can be much more important).
-        
+
         const double k1Log10 = 0.30102999566398114;  // 1/lg(10)
-        
+
         // For doubles len(f) == 53 (don't forget the hidden bit).
         const int kSignificandSize = 53;
         double estimate = ceil((exponent + kSignificandSize - 1) * k1Log10 - 1e-10);
         return static_cast<int>(estimate);
     }
-    
-    
+
+
     // See comments for InitialScaledStartValues.
     static void InitialScaledStartValuesPositiveExponent(
                                                          double v, int estimated_power, bool need_boundary_deltas,
                                                          Bignum* numerator, Bignum* denominator,
                                                          Bignum* delta_minus, Bignum* delta_plus) {
         // A positive exponent implies a positive power.
         ASSERT(estimated_power >= 0);
         // Since the estimated_power is positive we simply multiply the denominator
         // by 10^estimated_power.
-        
+
         // numerator = v.
         numerator->AssignUInt64(Double(v).Significand());
         numerator->ShiftLeft(Double(v).Exponent());
         // denominator = 10^estimated_power.
         denominator->AssignPowerUInt16(10, estimated_power);
-        
+
         if (need_boundary_deltas) {
             // Introduce a common denominator so that the deltas to the boundaries are
             // integers.
             denominator->ShiftLeft(1);
             numerator->ShiftLeft(1);
             // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
             // denominator (of 2) delta_plus equals 2^e.
             delta_plus->AssignUInt16(1);
             delta_plus->ShiftLeft(Double(v).Exponent());
             // Same for delta_minus (with adjustments below if f == 2^p-1).
             delta_minus->AssignUInt16(1);
             delta_minus->ShiftLeft(Double(v).Exponent());
-            
+
             // If the significand (without the hidden bit) is 0, then the lower
             // boundary is closer than just half a ulp (unit in the last place).
             // There is only one exception: if the next lower number is a denormal then
             // the distance is 1 ulp. This cannot be the case for exponent >= 0 (but we
             // have to test it in the other function where exponent < 0).
             uint64_t v_bits = Double(v).AsUint64();
             if ((v_bits & Double::kSignificandMask) == 0) {
                 // The lower boundary is closer at half the distance of "normal" numbers.
                 // Increase the common denominator and adapt all but the delta_minus.
                 denominator->ShiftLeft(1);  // *2
                 numerator->ShiftLeft(1);    // *2
                 delta_plus->ShiftLeft(1);   // *2
             }
         }
     }
-    
-    
+
+
     // See comments for InitialScaledStartValues
     static void InitialScaledStartValuesNegativeExponentPositivePower(
                                                                       double v, int estimated_power, bool need_boundary_deltas,
                                                                       Bignum* numerator, Bignum* denominator,
                                                                       Bignum* delta_minus, Bignum* delta_plus) {
         uint64_t significand = Double(v).Significand();
         int exponent = Double(v).Exponent();
         // v = f * 2^e with e < 0, and with estimated_power >= 0.
         // This means that e is close to 0 (have a look at how estimated_power is
         // computed).
-        
+
         // numerator = significand
         //  since v = significand * 2^exponent this is equivalent to
         //  numerator = v * / 2^-exponent
         numerator->AssignUInt64(significand);
         // denominator = 10^estimated_power * 2^-exponent (with exponent < 0)
         denominator->AssignPowerUInt16(10, estimated_power);
         denominator->ShiftLeft(-exponent);
-        
+
         if (need_boundary_deltas) {
             // Introduce a common denominator so that the deltas to the boundaries are
             // integers.
             denominator->ShiftLeft(1);
             numerator->ShiftLeft(1);
             // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
             // denominator (of 2) delta_plus equals 2^e.
             // Given that the denominator already includes v's exponent the distance
             // to the boundaries is simply 1.
             delta_plus->AssignUInt16(1);
             // Same for delta_minus (with adjustments below if f == 2^p-1).
             delta_minus->AssignUInt16(1);
-            
+
             // If the significand (without the hidden bit) is 0, then the lower
             // boundary is closer than just one ulp (unit in the last place).
             // There is only one exception: if the next lower number is a denormal
             // then the distance is 1 ulp. Since the exponent is close to zero
             // (otherwise estimated_power would have been negative) this cannot happen
             // here either.
             uint64_t v_bits = Double(v).AsUint64();
             if ((v_bits & Double::kSignificandMask) == 0) {
                 // The lower boundary is closer at half the distance of "normal" numbers.
                 // Increase the denominator and adapt all but the delta_minus.
                 denominator->ShiftLeft(1);  // *2
                 numerator->ShiftLeft(1);    // *2
                 delta_plus->ShiftLeft(1);   // *2
             }
         }
     }
-    
-    
+
+
     // See comments for InitialScaledStartValues
     static void InitialScaledStartValuesNegativeExponentNegativePower(
                                                                       double v, int estimated_power, bool need_boundary_deltas,
                                                                       Bignum* numerator, Bignum* denominator,
                                                                       Bignum* delta_minus, Bignum* delta_plus) {
         const uint64_t kMinimalNormalizedExponent =
         UINT64_2PART_C(0x00100000, 00000000);
         uint64_t significand = Double(v).Significand();
         int exponent = Double(v).Exponent();
         // Instead of multiplying the denominator with 10^estimated_power we
         // multiply all values (numerator and deltas) by 10^-estimated_power.
-        
+
         // Use numerator as temporary container for power_ten.
         Bignum* power_ten = numerator;
         power_ten->AssignPowerUInt16(10, -estimated_power);
-        
+
         if (need_boundary_deltas) {
             // Since power_ten == numerator we must make a copy of 10^estimated_power
             // before we complete the computation of the numerator.
             // delta_plus = delta_minus = 10^estimated_power
             delta_plus->AssignBignum(*power_ten);
             delta_minus->AssignBignum(*power_ten);
         }
-        
+
         // numerator = significand * 2 * 10^-estimated_power
         //  since v = significand * 2^exponent this is equivalent to
         // numerator = v * 10^-estimated_power * 2 * 2^-exponent.
         // Remember: numerator has been abused as power_ten. So no need to assign it
         //  to itself.
         ASSERT(numerator == power_ten);
         numerator->MultiplyByUInt64(significand);
-        
+
         // denominator = 2 * 2^-exponent with exponent < 0.
         denominator->AssignUInt16(1);
         denominator->ShiftLeft(-exponent);
-        
+
         if (need_boundary_deltas) {
             // Introduce a common denominator so that the deltas to the boundaries are
             // integers.
             numerator->ShiftLeft(1);
             denominator->ShiftLeft(1);
             // With this shift the boundaries have their correct value, since
             // delta_plus = 10^-estimated_power, and
             // delta_minus = 10^-estimated_power.
             // These assignments have been done earlier.
-            
+
             // The special case where the lower boundary is twice as close.
             // This time we have to look out for the exception too.
             uint64_t v_bits = Double(v).AsUint64();
             if ((v_bits & Double::kSignificandMask) == 0 &&
                 // The only exception where a significand == 0 has its boundaries at
                 // "normal" distances:
                 (v_bits & Double::kExponentMask) != kMinimalNormalizedExponent) {
                 numerator->ShiftLeft(1);    // *2
                 denominator->ShiftLeft(1);  // *2
                 delta_plus->ShiftLeft(1);   // *2
             }
         }
     }
-    
-    
+
+
     // Let v = significand * 2^exponent.
     // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
     // and denominator. The functions GenerateShortestDigits and
     // GenerateCountedDigits will then convert this ratio to its decimal
     // representation d, with the required accuracy.
     // Then d * 10^estimated_power is the representation of v.
     // (Note: the fraction and the estimated_power might get adjusted before
     // generating the decimal representation.)
     //
     // The initial start values consist of:
@@ skipping 37 matching lines @@
         } else if (estimated_power >= 0) {
             InitialScaledStartValuesNegativeExponentPositivePower(
                                                                   v, estimated_power, need_boundary_deltas,
                                                                   numerator, denominator, delta_minus, delta_plus);
         } else {
             InitialScaledStartValuesNegativeExponentNegativePower(
                                                                   v, estimated_power, need_boundary_deltas,
                                                                   numerator, denominator, delta_minus, delta_plus);
         }
     }
-    
-    
+
+
     // This routine multiplies numerator/denominator so that its values lies in the
     // range 1-10. That is after a call to this function we have:
     //    1 <= (numerator + delta_plus) /denominator < 10.
     // Let numerator the input before modification and numerator' the argument
     // after modification, then the output-parameter decimal_point is such that
     //  numerator / denominator * 10^estimated_power ==
     //    numerator' / denominator' * 10^(decimal_point - 1)
     // In some cases estimated_power was too low, and this is already the case. We
     // then simply adjust the power so that 10^(k-1) <= v < 10^k (with k ==
     // estimated_power) but do not touch the numerator or denominator.
@@ skipping 19 matching lines @@
             numerator->Times10();
             if (Bignum::Equal(*delta_minus, *delta_plus)) {
                 delta_minus->Times10();
                 delta_plus->AssignBignum(*delta_minus);
             } else {
                 delta_minus->Times10();
                 delta_plus->Times10();
             }
         }
     }
-    
+
 }  // namespace double_conversion
 
 } // namespace WTF