reflow comments in wtf

third_party/WebKit/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.
  *
  * The Initial Developer of the Original Code is
  * Netscape Communications Corporation.
  * Portions created by the Initial Developer are Copyright (C) 1998
  * the Initial Developer. All Rights Reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
@@ skipping 56 matching lines @@
 
 /* Constants */
 
 static const double hoursPerDay = 24.0;
 static const double secondsPerDay = 24.0 * 60.0 * 60.0;
 
 static const double maxUnixTime = 2145859200.0;  // 12/31/2037
 static const double kMinimumECMADateInMs = -8640000000000000.0;
 static const double kMaximumECMADateInMs = 8640000000000000.0;
 
-// Day of year for the first day of each month, where index 0 is January, and day 0 is January 1.
-// First for non-leap years, then for leap years.
+// Day of year for the first day of each month, where index 0 is January, and
+// day 0 is January 1.  First for non-leap years, then for leap years.
 static const int firstDayOfMonth[2][12] = {
     {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
     {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}};
 
 static inline void getLocalTime(const time_t* localTime, struct tm* localTM) {
 #if COMPILER(MSVC)
   localtime_s(localTM, localTime);
 #else
   localtime_r(localTime, localTM);
 #endif
 }
 
 bool isLeapYear(int year) {
   if (year % 4 != 0)
     return false;
   if (year % 400 == 0)
     return true;
   if (year % 100 == 0)
     return false;
   return true;
 }
 
 static inline int daysInYear(int year) {
   return 365 + isLeapYear(year);
 }
 
 static inline double daysFrom1970ToYear(int year) {
   // The Gregorian Calendar rules for leap years:
   // Every fourth year is a leap year.  2004, 2008, and 2012 are leap years.
-  // However, every hundredth year is not a leap year.  1900 and 2100 are not leap years.
-  // Every four hundred years, there's a leap year after all.  2000 and 2400 are leap years.
+  // However, every hundredth year is not a leap year.  1900 and 2100 are not
+  // leap years.
+  // Every four hundred years, there's a leap year after all.  2000 and 2400 are
+  // leap years.
 
   static const int leapDaysBefore1971By4Rule = 1970 / 4;
   static const int excludedLeapDaysBefore1971By100Rule = 1970 / 100;
   static const int leapDaysBefore1971By400Rule = 1970 / 400;
 
   const double yearMinusOne = year - 1;
   const double yearsToAddBy4Rule =
       floor(yearMinusOne / 4.0) - leapDaysBefore1971By4Rule;
   const double yearsToExcludeBy100Rule =
       floor(yearMinusOne / 100.0) - excludedLeapDaysBefore1971By100Rule;
@@ skipping 140 matching lines @@
 }
 
 static inline int minimumYearForDST() {
   // Because of the 2038 issue (see maximumYearForDST) if the current year is
   // greater than the max year minus 27 (2010), we want to use the max year
   // minus 27 instead, to ensure there is a range of 28 years that all years
   // can map to.
   return std::min(msToYear(jsCurrentTime()), maximumYearForDST() - 27);
 }
 
-/*
- * Find an equivalent year for the one given, where equivalence is deterined by
- * the two years having the same leapness and the first day of the year, falling
- * on the same day of the week.
- *
- * This function returns a year between this current year and 2037, however this
- * function will potentially return incorrect results if the current year is after
- * 2010, (rdar://problem/5052975), if the year passed in is before 1900 or after
- * 2100, (rdar://problem/5055038).
- */
+// Find an equivalent year for the one given, where equivalence is deterined by
+// the two years having the same leapness and the first day of the year, falling
+// on the same day of the week.
+//
+// This function returns a year between this current year and 2037, however this
+// function will potentially return incorrect results if the current year is
+// after 2010, (rdar://problem/5052975), if the year passed in is before 1900
+// or after 2100, (rdar://problem/5055038).
 static int equivalentYearForDST(int year) {
   // It is ok if the cached year is not the current year as long as the rules
-  // for DST did not change between the two years; if they did the app would need
-  // to be restarted.
+  // for DST did not change between the two years; if they did the app would
+  // need to be restarted.
   static int minYear = minimumYearForDST();
   int maxYear = maximumYearForDST();
 
   int difference;
   if (year > maxYear)
     difference = minYear - year;
   else if (year < minYear)
     difference = maxYear - year;
   else
     return year;
@@ skipping 40 matching lines @@
   time_t localTime = static_cast<time_t>(localTimeSeconds);
 
   tm localTM;
   getLocalTime(&localTime, &localTM);
 
   return localTM.tm_isdst > 0 ? msPerHour : 0;
 }
 
 // Get the DST offset, given a time in UTC
 static double calculateDSTOffset(double ms, double utcOffset) {
-  // On Mac OS X, the call to localtime (see calculateDSTOffsetSimple) will return historically accurate
-  // DST information (e.g. New Zealand did not have DST from 1946 to 1974) however the JavaScript
-  // standard explicitly dictates that historical information should not be considered when
-  // determining DST. For this reason we shift away from years that localtime can handle but would
-  // return historically accurate information.
+  // On macOS, the call to localtime (see calculateDSTOffsetSimple) will return
+  // historically accurate DST information (e.g. New Zealand did not have DST
+  // from 1946 to 1974) however the JavaScript standard explicitly dictates
+  // that historical information should not be considered when determining DST.
+  // For this reason we shift away from years that localtime can handle but
+  // would return historically accurate information.
   int year = msToYear(ms);
   int equivalentYear = equivalentYearForDST(year);
   if (year != equivalentYear) {
     bool leapYear = isLeapYear(year);
     int dayInYearLocal = dayInYear(ms, year);
     int dayInMonth = dayInMonthFromDayInYear(dayInYearLocal, leapYear);
     int month = monthFromDayInYear(dayInYearLocal, leapYear);
     double day = dateToDaysFrom1970(equivalentYear, month, dayInMonth);
     ms = (day * msPerDay) + msToMilliseconds(ms);
   }
@@ skipping 444 matching lines @@
   return stringBuilder.toString();
 }
 
 double convertToLocalTime(double ms) {
   double utcOffset = calculateUTCOffset();
   double dstOffset = calculateDSTOffset(ms, utcOffset);
   return (ms + utcOffset + dstOffset);
 }
 
 }  // namespace WTF