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

Source/wtf/DateMath.cpp

 /*
  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  * Copyright (C) 2010 &yet, LLC. (nate@andyet.net)
  *
  * The Original Code is Mozilla Communicator client code, released
  * March 31, 1998.
  *
@@ skipping 557 matching lines @@
     // This is a bit more lenient on the year string than ES5 specifies:
     // instead of restricting to 4 digits (or 6 digits with mandatory +/-),
     // it accepts any integer value. Consider this an implementation fallback.
     if (!parseInt(currentPosition, &postParsePosition, 10, &year))
         return 0;
 
     // Check for presence of -MM portion.
     if (*postParsePosition != '-')
         return postParsePosition;
     currentPosition = postParsePosition + 1;
-    
+
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &month))
         return 0;
     if ((postParsePosition - currentPosition) != 2)
         return 0;
 
     // Check for presence of -DD portion.
     if (*postParsePosition != '-')
         return postParsePosition;
     currentPosition = postParsePosition + 1;
-    
+
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &day))
         return 0;
     if ((postParsePosition - currentPosition) != 2)
         return 0;
     return postParsePosition;
 }
 
 // Parses a time with the format HH:mm[:ss[.sss]][Z|(+|-)00:00].
 // Fractional seconds parsing is lenient, allows any number of digits.
 // Returns 0 if a parse error occurs, else returns the end of the parsed portion of the string.
 static char* parseES5TimePortion(char* currentPosition, long& hours, long& minutes, double& seconds, long& timeZoneSeconds)
 {
     char* postParsePosition;
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &hours))
         return 0;
     if (*postParsePosition != ':' || (postParsePosition - currentPosition) != 2)
         return 0;
     currentPosition = postParsePosition + 1;
-    
+
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &minutes))
         return 0;
     if ((postParsePosition - currentPosition) != 2)
         return 0;
     currentPosition = postParsePosition;
 
     // Seconds are optional.
     if (*currentPosition == ':') {
         ++currentPosition;
-    
+
         long intSeconds;
         if (!isASCIIDigit(*currentPosition))
             return 0;
         if (!parseLong(currentPosition, &postParsePosition, 10, &intSeconds))
             return 0;
         if ((postParsePosition - currentPosition) != 2)
             return 0;
         seconds = intSeconds;
         if (*postParsePosition == '.') {
             currentPosition = postParsePosition + 1;
-            
+
             // In ECMA-262-5 it's a bit unclear if '.' can be present without milliseconds, but
             // a reasonable interpretation guided by the given examples and RFC 3339 says "no".
             // We check the next character to avoid reading +/- timezone hours after an invalid decimal.
             if (!isASCIIDigit(*currentPosition))
                 return 0;
-            
+
             // We are more lenient than ES5 by accepting more or less than 3 fraction digits.
             long fracSeconds;
             if (!parseLong(currentPosition, &postParsePosition, 10, &fracSeconds))
                 return 0;
-            
+
             long numFracDigits = postParsePosition - currentPosition;
             seconds += fracSeconds * pow(10.0, static_cast<double>(-numFracDigits));
         }
         currentPosition = postParsePosition;
     }
 
     if (*currentPosition == 'Z')
         return currentPosition + 1;
 
     bool tzNegative;
     if (*currentPosition == '-')
         tzNegative = true;
     else if (*currentPosition == '+')
         tzNegative = false;
     else
         return currentPosition; // no timezone
     ++currentPosition;
-    
+
     long tzHours;
     long tzHoursAbs;
     long tzMinutes;
-    
+
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &tzHours))
         return 0;
     if (*postParsePosition != ':' || (postParsePosition - currentPosition) != 2)
         return 0;
     tzHoursAbs = labs(tzHours);
     currentPosition = postParsePosition + 1;
-    
+
     if (!isASCIIDigit(*currentPosition))
         return 0;
     if (!parseLong(currentPosition, &postParsePosition, 10, &tzMinutes))
         return 0;
     if ((postParsePosition - currentPosition) != 2)
         return 0;
     currentPosition = postParsePosition;
-    
+
     if (tzHoursAbs > 24)
         return 0;
     if (tzMinutes < 0 || tzMinutes > 59)
         return 0;
-    
+
     timeZoneSeconds = 60 * (tzMinutes + (60 * tzHoursAbs));
     if (tzNegative)
         timeZoneSeconds = -timeZoneSeconds;
 
     return currentPosition;
 }
 
 double parseES5DateFromNullTerminatedCharacters(const char* dateString)
 {
     // This parses a date of the form defined in ECMA-262-5, section 15.9.1.15
     // (similar to RFC 3339 / ISO 8601: YYYY-MM-DDTHH:mm:ss[.sss]Z).
     // In most cases it is intentionally strict (e.g. correct field widths, no stray whitespace).
-    
+
     static const long daysPerMonth[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-    
+
     // The year must be present, but the other fields may be omitted - see ES5.1 15.9.1.15.
     int year = 0;
     long month = 1;
     long day = 1;
     long hours = 0;
     long minutes = 0;
     double seconds = 0;
     long timeZoneSeconds = 0;
 
     // Parse the date YYYY[-MM[-DD]]
@@ skipping 24 matching lines @@
     if (hours == 24 && (minutes || seconds))
         return std::numeric_limits<double>::quiet_NaN();
     if (minutes < 0 || minutes > 59)
         return std::numeric_limits<double>::quiet_NaN();
     if (seconds < 0 || seconds >= 61)
         return std::numeric_limits<double>::quiet_NaN();
     if (seconds > 60) {
         // Discard leap seconds by clamping to the end of a minute.
         seconds = 60;
     }
-        
+
     double dateSeconds = ymdhmsToSeconds(year, month, day, hours, minutes, seconds) - timeZoneSeconds;
     return dateSeconds * msPerSecond;
 }
 
 // Odd case where 'exec' is allowed to be 0, to accomodate a caller in WebCore.
 double parseDateFromNullTerminatedCharacters(const char* dateString, bool& haveTZ, int& offset)
 {
     haveTZ = false;
     offset = 0;
 
     // This parses a date in the form:
     //     Tuesday, 09-Nov-99 23:12:40 GMT
     // or
     //     Sat, 01-Jan-2000 08:00:00 GMT
     // or
     //     Sat, 01 Jan 2000 08:00:00 GMT
     // or
     //     01 Jan 99 22:00 +0100    (exceptions in rfc822/rfc2822)
     // ### non RFC formats, added for Javascript:
     //     [Wednesday] January 09 1999 23:12:40 GMT
     //     [Wednesday] January 09 23:12:40 GMT 1999
     //
     // We ignore the weekday.
-     
+
     // Skip leading space
     skipSpacesAndComments(dateString);
 
     long month = -1;
     const char *wordStart = dateString;
     // Check contents of first words if not number
     while (*dateString && !isASCIIDigit(*dateString)) {
         if (isASCIISpace(*dateString) || *dateString == '(') {
             if (dateString - wordStart >= 3)
                 month = findMonth(wordStart);
@@ skipping 167 matching lines @@
             } else if (strncasecmp(dateString, "PM", 2) == 0) {
                 if (hour > 12)
                     return std::numeric_limits<double>::quiet_NaN();
                 if (hour != 12)
                     hour += 12;
                 dateString += 2;
                 skipSpacesAndComments(dateString);
             }
         }
     }
-    
+
     // The year may be after the time but before the time zone.
     if (isASCIIDigit(*dateString) && year == -1) {
         if (!parseInt(dateString, &newPosStr, 10, &year))
             return std::numeric_limits<double>::quiet_NaN();
         dateString = newPosStr;
         skipSpacesAndComments(dateString);
     }
 
-    // Don't fail if the time zone is missing. 
+    // Don't fail if the time zone is missing.
     // Some websites omit the time zone (4275206).
     if (*dateString) {
         if (strncasecmp(dateString, "GMT", 3) == 0 || strncasecmp(dateString, "UTC", 3) == 0) {
             dateString += 3;
             haveTZ = true;
         }
 
         if (*dateString == '+' || *dateString == '-') {
             int o;
             if (!parseInt(dateString, &newPosStr, 10, &o))
@@ skipping 44 matching lines @@
     if (*dateString)
         return std::numeric_limits<double>::quiet_NaN();
 
     // Y2K: Handle 2 digit years.
     if (year >= 0 && year < 100) {
         if (year < 50)
             year += 2000;
         else
             year += 1900;
     }
-    
+
     return ymdhmsToSeconds(year, month + 1, day, hour, minute, second) * msPerSecond;
 }
 
 double parseDateFromNullTerminatedCharacters(const char* dateString)
 {
     bool haveTZ;
     int offset;
     double ms = parseDateFromNullTerminatedCharacters(dateString, haveTZ, offset);
     if (std::isnan(ms))
         return std::numeric_limits<double>::quiet_NaN();
@@ skipping 38 matching lines @@
 
     stringBuilder.append(utcOffset > 0 ? '+' : '-');
     int absoluteUTCOffset = abs(utcOffset);
     stringBuilder.append(twoDigitStringFromNumber(absoluteUTCOffset / 60));
     stringBuilder.append(twoDigitStringFromNumber(absoluteUTCOffset % 60));
 
     return stringBuilder.toString();
 }
 
 } // namespace WTF