wtf/DateMath.h

   1 /*
   2  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
   4  * Copyright (C) 2009 Google Inc. All rights reserved.
   5  *
   6  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   7  *
   8  * The contents of this file are subject to the Mozilla Public License Version
   9  * 1.1 (the "License"); you may not use this file except in compliance with
  10  * the License. You may obtain a copy of the License at
  11  * http://www.mozilla.org/MPL/
  12  *
  13  * Software distributed under the License is distributed on an "AS IS" basis,
  14  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  15  * for the specific language governing rights and limitations under the
  16  * License.
  17  *
  18  * The Original Code is Mozilla Communicator client code, released
  19  * March 31, 1998.
  20  *
  21  * The Initial Developer of the Original Code is
  22  * Netscape Communications Corporation.
  23  * Portions created by the Initial Developer are Copyright (C) 1998
  24  * the Initial Developer. All Rights Reserved.
  25  *
  26  * Contributor(s):
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either of the GNU General Public License Version 2 or later (the "GPL"),
  30  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  */
  41
  42 #ifndef DateMath_h
  43 #define DateMath_h
  44
  45 #include <math.h>
  46 #include <string.h>
  47 #include <time.h>
  48 #include <wtf/CurrentTime.h>
  49 #include <wtf/Noncopyable.h>
  50 #include <wtf/UnusedParam.h>
  51
  52 namespace WTF {
  53 void initializeDates();
  54 int equivalentYearForDST(int year);
  55
  56 // Not really math related, but this is currently the only shared place to put these.
  57 double parseDateFromNullTerminatedCharacters(const char* dateString);
  58 double timeClip(double);
  59
  60 inline double jsCurrentTime()
  61 {
  62     // JavaScript doesn't recognize fractions of a millisecond.
  63     return floor(WTF::currentTimeMS());
  64 }
  65
  66 const char * const weekdayName[7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
  67 const char * const monthName[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
  68
  69 const double hoursPerDay = 24.0;
  70 const double minutesPerHour = 60.0;
  71 const double secondsPerHour = 60.0 * 60.0;
  72 const double secondsPerMinute = 60.0;
  73 const double msPerSecond = 1000.0;
  74 const double msPerMinute = 60.0 * 1000.0;
  75 const double msPerHour = 60.0 * 60.0 * 1000.0;
  76 const double msPerDay = 24.0 * 60.0 * 60.0 * 1000.0;
  77 const double msPerMonth = 2592000000.0;
  78
  79 // Returns the number of days from 1970-01-01 to the specified date.
  80 double dateToDaysFrom1970(int year, int month, int day);
  81 int msToYear(double ms);
  82 int dayInYear(double ms, int year);
  83 int monthFromDayInYear(int dayInYear, bool leapYear);
  84 int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
  85
  86 } // namespace WTF
  87
  88 using WTF::dateToDaysFrom1970;
  89 using WTF::dayInMonthFromDayInYear;
  90 using WTF::dayInYear;
  91 using WTF::minutesPerHour;
  92 using WTF::monthFromDayInYear;
  93 using WTF::msPerDay;
  94 using WTF::msPerSecond;
  95 using WTF::msToYear;
  96 using WTF::secondsPerMinute;
  97
  98 #if USE(JSC)
  99 namespace JSC {
 100 class ExecState;
 101 struct GregorianDateTime;
 102
 103 void msToGregorianDateTime(ExecState*, double, bool outputIsUTC, GregorianDateTime&);
 104 double gregorianDateTimeToMS(ExecState*, const GregorianDateTime&, double, bool inputIsUTC);
 105 double getUTCOffset(ExecState*);
 106 double parseDateFromNullTerminatedCharacters(ExecState*, const char* dateString);
 107
 108 // Intentionally overridding the default tm of the system.
 109 // The members of tm differ on various operating systems.
 110 struct GregorianDateTime : Noncopyable {
 111     GregorianDateTime()
 112         : second(0)
 113         , minute(0)
 114         , hour(0)
 115         , weekDay(0)
 116         , monthDay(0)
 117         , yearDay(0)
 118         , month(0)
 119         , year(0)
 120         , isDST(0)
 121         , utcOffset(0)
 122         , timeZone(0)
 123     {
 124     }
 125
 126     ~GregorianDateTime()
 127     {
 128         delete [] timeZone;
 129     }
 130
 131     GregorianDateTime(ExecState* exec, const tm& inTm)
 132         : second(inTm.tm_sec)
 133         , minute(inTm.tm_min)
 134         , hour(inTm.tm_hour)
 135         , weekDay(inTm.tm_wday)
 136         , monthDay(inTm.tm_mday)
 137         , yearDay(inTm.tm_yday)
 138         , month(inTm.tm_mon)
 139         , year(inTm.tm_year)
 140         , isDST(inTm.tm_isdst)
 141     {
 142         UNUSED_PARAM(exec);
 143 #if HAVE(TM_GMTOFF)
 144         utcOffset = static_cast<int>(inTm.tm_gmtoff);
 145 #else
 146         utcOffset = static_cast<int>(getUTCOffset(exec) / WTF::msPerSecond + (isDST ? WTF::secondsPerHour : 0));
 147 #endif
 148
 149 #if HAVE(TM_ZONE)
 150         int inZoneSize = strlen(inTm.tm_zone) + 1;
 151         timeZone = new char[inZoneSize];
 152         strncpy(timeZone, inTm.tm_zone, inZoneSize);
 153 #else
 154         timeZone = 0;
 155 #endif
 156     }
 157
 158     operator tm() const
 159     {
 160         tm ret;
 161         memset(&ret, 0, sizeof(ret));
 162
 163         ret.tm_sec   =  second;
 164         ret.tm_min   =  minute;
 165         ret.tm_hour  =  hour;
 166         ret.tm_wday  =  weekDay;
 167         ret.tm_mday  =  monthDay;
 168         ret.tm_yday  =  yearDay;
 169         ret.tm_mon   =  month;
 170         ret.tm_year  =  year;
 171         ret.tm_isdst =  isDST;
 172
 173 #if HAVE(TM_GMTOFF)
 174         ret.tm_gmtoff = static_cast<long>(utcOffset);
 175 #endif
 176 #if HAVE(TM_ZONE)
 177         ret.tm_zone = timeZone;
 178 #endif
 179
 180         return ret;
 181     }
 182
 183     void copyFrom(const GregorianDateTime& rhs)
 184     {
 185         second = rhs.second;
 186         minute = rhs.minute;
 187         hour = rhs.hour;
 188         weekDay = rhs.weekDay;
 189         monthDay = rhs.monthDay;
 190         yearDay = rhs.yearDay;
 191         month = rhs.month;
 192         year = rhs.year;
 193         isDST = rhs.isDST;
 194         utcOffset = rhs.utcOffset;
 195         if (rhs.timeZone) {
 196             int inZoneSize = strlen(rhs.timeZone) + 1;
 197             timeZone = new char[inZoneSize];
 198             strncpy(timeZone, rhs.timeZone, inZoneSize);
 199         } else
 200             timeZone = 0;
 201     }
 202
 203     int second;
 204     int minute;
 205     int hour;
 206     int weekDay;
 207     int monthDay;
 208     int yearDay;
 209     int month;
 210     int year;
 211     int isDST;
 212     int utcOffset;
 213     char* timeZone;
 214 };
 215
 216 static inline int gmtoffset(const GregorianDateTime& t)
 217 {
 218     return t.utcOffset;
 219 }
 220 } // namespace JSC
 221 #endif // USE(JSC)
 222
 223 #endif // DateMath_h