Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

Source/wtf/dtoa/double-conversion.h

 // 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
 #define DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
 
 #include "wtf/dtoa/utils.h"
 
 namespace WTF {
 
 namespace double_conversion {
-    
+
     class DoubleToStringConverter {
     public:
         // When calling ToFixed with a double > 10^kMaxFixedDigitsBeforePoint
         // or a requested_digits parameter > kMaxFixedDigitsAfterPoint then the
         // function returns false.
         static const int kMaxFixedDigitsBeforePoint = 60;
         static const int kMaxFixedDigitsAfterPoint = 60;
-        
+
         // When calling ToExponential with a requested_digits
         // parameter > kMaxExponentialDigits then the function returns false.
         static const int kMaxExponentialDigits = 120;
-        
+
         // When calling ToPrecision with a requested_digits
         // parameter < kMinPrecisionDigits or requested_digits > kMaxPrecisionDigits
         // then the function returns false.
         static const int kMinPrecisionDigits = 1;
         static const int kMaxPrecisionDigits = 120;
-        
+
         enum Flags {
             NO_FLAGS = 0,
             EMIT_POSITIVE_EXPONENT_SIGN = 1,
             EMIT_TRAILING_DECIMAL_POINT = 2,
             EMIT_TRAILING_ZERO_AFTER_POINT = 4,
             UNIQUE_ZERO = 8
         };
-        
+
         // Flags should be a bit-or combination of the possible Flags-enum.
         //  - NO_FLAGS: no special flags.
         //  - EMIT_POSITIVE_EXPONENT_SIGN: when the number is converted into exponent
         //    form, emits a '+' for positive exponents. Example: 1.2e+2.
         //  - EMIT_TRAILING_DECIMAL_POINT: when the input number is an integer and is
         //    converted into decimal format then a trailing decimal point is appended.
         //    Example: 2345.0 is converted to "2345.".
         //  - EMIT_TRAILING_ZERO_AFTER_POINT: in addition to a trailing decimal point
         //    emits a trailing '0'-character. This flag requires the
         //    EXMIT_TRAILING_DECIMAL_POINT flag.
@@ skipping 49 matching lines @@
         decimal_in_shortest_high_(decimal_in_shortest_high),
         max_leading_padding_zeroes_in_precision_mode_(
                                                       max_leading_padding_zeroes_in_precision_mode),
         max_trailing_padding_zeroes_in_precision_mode_(
                                                        max_trailing_padding_zeroes_in_precision_mode) {
             // When 'trailing zero after the point' is set, then 'trailing point'
             // must be set too.
             ASSERT(((flags & EMIT_TRAILING_DECIMAL_POINT) != 0) ||
                    !((flags & EMIT_TRAILING_ZERO_AFTER_POINT) != 0));
         }
-        
+
         // Returns a converter following the EcmaScript specification.
         static const DoubleToStringConverter& EcmaScriptConverter();
-        
+
         // Computes the shortest string of digits that correctly represent the input
         // number. Depending on decimal_in_shortest_low and decimal_in_shortest_high
         // (see constructor) it then either returns a decimal representation, or an
         // exponential representation.
         // Example with decimal_in_shortest_low = -6,
         //              decimal_in_shortest_high = 21,
         //              EMIT_POSITIVE_EXPONENT_SIGN activated, and
         //              EMIT_TRAILING_DECIMAL_POINT deactived:
         //   ToShortest(0.000001)  -> "0.000001"
         //   ToShortest(0.0000001) -> "1e-7"
         //   ToShortest(111111111111111111111.0)  -> "111111111111111110000"
         //   ToShortest(100000000000000000000.0)  -> "100000000000000000000"
         //   ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
         //
         // Note: the conversion may round the output if the returned string
         // is accurate enough to uniquely identify the input-number.
         // For example the most precise representation of the double 9e59 equals
         // "899999999999999918767229449717619953810131273674690656206848", but
         // the converter will return the shorter (but still correct) "9e59".
         //
         // Returns true if the conversion succeeds. The conversion always succeeds
         // except when the input value is special and no infinity_symbol or
         // nan_symbol has been given to the constructor.
         bool ToShortest(double value, StringBuilder* result_builder) const;
-        
-        
+
+
         // Computes a decimal representation with a fixed number of digits after the
         // decimal point. The last emitted digit is rounded.
         //
         // Examples:
         //   ToFixed(3.12, 1) -> "3.1"
         //   ToFixed(3.1415, 3) -> "3.142"
         //   ToFixed(1234.56789, 4) -> "1234.5679"
         //   ToFixed(1.23, 5) -> "1.23000"
         //   ToFixed(0.1, 4) -> "0.1000"
         //   ToFixed(1e30, 2) -> "1000000000000000019884624838656.00"
@@ skipping 16 matching lines @@
         //   - the input value is special and no infinity_symbol or nan_symbol has
         //     been provided to the constructor,
         //   - 'value' > 10^kMaxFixedDigitsBeforePoint, or
         //   - 'requested_digits' > kMaxFixedDigitsAfterPoint.
         // The last two conditions imply that the result will never contain more than
         // 1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
         // (one additional character for the sign, and one for the decimal point).
         bool ToFixed(double value,
                      int requested_digits,
                      StringBuilder* result_builder) const;
-        
+
         // Computes a representation in exponential format with requested_digits
         // after the decimal point. The last emitted digit is rounded.
         // If requested_digits equals -1, then the shortest exponential representation
         // is computed.
         //
         // Examples with EMIT_POSITIVE_EXPONENT_SIGN deactivated, and
         //               exponent_character set to 'e'.
         //   ToExponential(3.12, 1) -> "3.1e0"
         //   ToExponential(5.0, 3) -> "5.000e0"
         //   ToExponential(0.001, 2) -> "1.00e-3"
@@ skipping 11 matching lines @@
         //   - the input value is special and no infinity_symbol or nan_symbol has
         //     been provided to the constructor,
         //   - 'requested_digits' > kMaxExponentialDigits.
         // The last condition implies that the result will never contain more than
         // kMaxExponentialDigits + 8 characters (the sign, the digit before the
         // decimal point, the decimal point, the exponent character, the
         // exponent's sign, and at most 3 exponent digits).
         bool ToExponential(double value,
                            int requested_digits,
                            StringBuilder* result_builder) const;
-        
+
         // Computes 'precision' leading digits of the given 'value' and returns them
         // either in exponential or decimal format, depending on
         // max_{leading|trailing}_padding_zeroes_in_precision_mode (given to the
         // constructor).
         // The last computed digit is rounded.
         //
         // Example with max_leading_padding_zeroes_in_precision_mode = 6.
         //   ToPrecision(0.0000012345, 2) -> "0.0000012"
         //   ToPrecision(0.00000012345, 2) -> "1.2e-7"
         // Similarily the converter may add up to
@@ skipping 17 matching lines @@
         //   - the input value is special and no infinity_symbol or nan_symbol has
         //     been provided to the constructor,
         //   - precision < kMinPericisionDigits
         //   - precision > kMaxPrecisionDigits
         // The last condition implies that the result will never contain more than
         // kMaxPrecisionDigits + 7 characters (the sign, the decimal point, the
         // exponent character, the exponent's sign, and at most 3 exponent digits).
         bool ToPrecision(double value,
                          int precision,
                          StringBuilder* result_builder) const;
-        
+
         enum DtoaMode {
             // Produce the shortest correct representation.
             // For example the output of 0.299999999999999988897 is (the less accurate
             // but correct) 0.3.
             SHORTEST,
             // Produce a fixed number of digits after the decimal point.
             // For instance fixed(0.1, 4) becomes 0.1000
             // If the input number is big, the output will be big.
             FIXED,
             // Fixed number of digits (independent of the decimal point).
             PRECISION
         };
-        
+
         // The maximal number of digits that are needed to emit a double in base 10.
         // A higher precision can be achieved by using more digits, but the shortest
         // accurate representation of any double will never use more digits than
         // kBase10MaximalLength.
         // Note that DoubleToAscii null-terminates its input. So the given buffer
         // should be at least kBase10MaximalLength + 1 characters long.
         static const int kBase10MaximalLength = 17;
-        
+
         // Converts the given double 'v' to ascii.
         // The result should be interpreted as buffer * 10^(point-length).
         //
         // The output depends on the given mode:
         //  - SHORTEST: produce the least amount of digits for which the internal
         //   identity requirement is still satisfied. If the digits are printed
         //   (together with the correct exponent) then reading this number will give
         //   'v' again. The buffer will choose the representation that is closest to
         //   'v'. If there are two at the same distance, than the one farther away
         //   from 0 is chosen (halfway cases - ending with 5 - are rounded up).
@@ skipping 19 matching lines @@
         // the output. The given length is only used in debug mode to ensure the
         // buffer is big enough.
         static void DoubleToAscii(double v,
                                   DtoaMode mode,
                                   int requested_digits,
                                   char* buffer,
                                   int buffer_length,
                                   bool* sign,
                                   int* length,
                                   int* point);
-        
+
     private:
         // If the value is a special value (NaN or Infinity) constructs the
         // corresponding string using the configured infinity/nan-symbol.
         // If either of them is NULL or the value is not special then the
         // function returns false.
         bool HandleSpecialValues(double value, StringBuilder* result_builder) const;
         // Constructs an exponential representation (i.e. 1.234e56).
         // The given exponent assumes a decimal point after the first decimal digit.
         void CreateExponentialRepresentation(const char* decimal_digits,
                                              int length,
                                              int exponent,
                                              StringBuilder* result_builder) const;
         // Creates a decimal representation (i.e 1234.5678).
         void CreateDecimalRepresentation(const char* decimal_digits,
                                          int length,
                                          int decimal_point,
                                          int digits_after_point,
                                          StringBuilder* result_builder) const;
-        
+
         const int flags_;
         const char* const infinity_symbol_;
         const char* const nan_symbol_;
         const char exponent_character_;
         const int decimal_in_shortest_low_;
         const int decimal_in_shortest_high_;
         const int max_leading_padding_zeroes_in_precision_mode_;
         const int max_trailing_padding_zeroes_in_precision_mode_;
-        
+
         DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
     };
-    
-    
+
+
     class StringToDoubleConverter {
     public:
         // Performs the conversion.
         // The output parameter 'processed_characters_count' is set to the number
         // of characters that have been processed to read the number.
         static double StringToDouble(const char* buffer, size_t length, size_t* processed_characters_count);
-        
+
     private:
         DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
     };
-    
+
 }  // namespace double_conversion
 
 } // namespace WTF
 
 #endif  // DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_