ntoskrnl/rtl/time.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            kernel/rtl/time.c
   6  * PURPOSE:         Conversion between Time and TimeFields
   7  * PROGRAMMER:      Rex Jolliff (rex@lvcablemodem.com)
   8  * UPDATE HISTORY:
   9  *                  Created 22/05/98
  10  *   08/03/98  RJJ  Implemented these functions
  11  */
  12
  13 /* INCLUDES *****************************************************************/
  14
  15 #include <ddk/ntddk.h>
  16
  17 #define NDEBUG
  18 #include <internal/debug.h>
  19
  20 #define TICKSPERMIN        600000000
  21 #define TICKSPERSEC        10000000
  22 #define TICKSPERMSEC       10000
  23 #define SECSPERDAY         86400
  24 #define SECSPERHOUR        3600
  25 #define SECSPERMIN         60
  26 #define MINSPERHOUR        60
  27 #define HOURSPERDAY        24
  28 #define EPOCHWEEKDAY       1
  29 #define DAYSPERWEEK        7
  30 #define EPOCHYEAR          1601
  31 #define DAYSPERNORMALYEAR  365
  32 #define DAYSPERLEAPYEAR    366
  33 #define MONSPERYEAR        12
  34
  35 #define TICKSTO1970         0x019db1ded53e8000
  36 #define TICKSTO1980         0x01a8e79fe1d58000
  37
  38
  39 static const int YearLengths[2] = {DAYSPERNORMALYEAR, DAYSPERLEAPYEAR};
  40 static const int MonthLengths[2][MONSPERYEAR] =
  41 {
  42         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  43         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  44 };
  45
  46 static __inline int IsLeapYear(int Year)
  47 {
  48   return Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0) ? 1 : 0;
  49 }
  50
  51 static __inline void NormalizeTimeFields(CSHORT *FieldToNormalize,
  52                                          CSHORT *CarryField,
  53                                          int Modulus)
  54 {
  55   *FieldToNormalize = (CSHORT) (*FieldToNormalize - Modulus);
  56   *CarryField = (CSHORT) (*CarryField + 1);
  57 }
  58
  59 /* FUNCTIONS *****************************************************************/
  60
  61 #ifndef LIBCAPTIVE
  62
  63 VOID
  64 STDCALL
  65 RtlTimeToTimeFields (
  66         PLARGE_INTEGER liTime,
  67         PTIME_FIELDS TimeFields
  68         )
  69 {
  70   const int *Months;
  71   int LeapSecondCorrections, SecondsInDay, CurYear;
  72   int LeapYear, CurMonth, GMTOffset;
  73   long int Days;
  74   long long int Time = (long long int)liTime->QuadPart;
  75
  76     /* Extract millisecond from time and convert time into seconds */
  77   TimeFields->Milliseconds = (CSHORT) ((Time % TICKSPERSEC) / TICKSPERMSEC);
  78   Time = Time / TICKSPERSEC;
  79
  80     /* FIXME: Compute the number of leap second corrections here */
  81   LeapSecondCorrections = 0;
  82
  83     /* FIXME: get the GMT offset here */
  84   GMTOffset = 0;
  85
  86     /* Split the time into days and seconds within the day */
  87   Days = Time / SECSPERDAY;
  88   SecondsInDay = Time % SECSPERDAY;
  89
  90     /* Adjust the values for GMT and leap seconds */
  91   SecondsInDay += (GMTOffset - LeapSecondCorrections);
  92   while (SecondsInDay < 0)
  93     {
  94       SecondsInDay += SECSPERDAY;
  95       Days--;
  96     }
  97   while (SecondsInDay >= SECSPERDAY)
  98     {
  99       SecondsInDay -= SECSPERDAY;
 100       Days++;
 101     }
 102
 103     /* compute time of day */
 104   TimeFields->Hour = (CSHORT) (SecondsInDay / SECSPERHOUR);
 105   SecondsInDay = SecondsInDay % SECSPERHOUR;
 106   TimeFields->Minute = (CSHORT) (SecondsInDay / SECSPERMIN);
 107   TimeFields->Second = (CSHORT) (SecondsInDay % SECSPERMIN);
 108
 109     /* FIXME: handle the possibility that we are on a leap second (i.e. Second = 60) */
 110
 111     /* compute day of week */
 112   TimeFields->Weekday = (CSHORT) ((EPOCHWEEKDAY + Days) % DAYSPERWEEK);
 113
 114     /* compute year */
 115   CurYear = EPOCHYEAR;
 116     /* FIXME: handle calendar modifications */
 117   CurYear += Days / DAYSPERLEAPYEAR;
 118   Days -= (CurYear - EPOCHYEAR) * DAYSPERLEAPYEAR;
 119   CurYear--; /* The next calculation needs CurYear - 1 */
 120   Days += CurYear - CurYear / 4 + CurYear / 100 - CurYear / 400;
 121   CurYear++;
 122   Days -= EPOCHYEAR - 1 - (EPOCHYEAR -1) / 4 + (EPOCHYEAR -1) / 100 - (EPOCHYEAR - 1) / 400;
 123   while (1)
 124     {
 125       LeapYear = IsLeapYear(CurYear);
 126       if (Days < (long) YearLengths[LeapYear])
 127         {
 128           break;
 129         }
 130       CurYear++;
 131       Days = Days - (long) YearLengths[LeapYear];
 132     }
 133   TimeFields->Year = (CSHORT) CurYear;
 134
 135     /* Compute month of year */
 136   LeapYear = IsLeapYear(CurYear);
 137   Months = MonthLengths[LeapYear];
 138   for (CurMonth = 0; Days >= (long) Months[CurMonth]; CurMonth++)
 139     Days = Days - (long) Months[CurMonth];
 140   TimeFields->Month = (CSHORT) (CurMonth + 1);
 141   TimeFields->Day = (CSHORT) (Days + 1);
 142 }
 143
 144 #endif /* LIBCAPTIVE */
 145
 146 BOOLEAN
 147 STDCALL
 148 RtlTimeFieldsToTime (
 149         PTIME_FIELDS tfTimeFields,
 150         PLARGE_INTEGER Time
 151         )
 152 {
 153   int CurMonth;
 154   long long int rcTime;
 155   TIME_FIELDS TimeFields = *tfTimeFields;
 156   const int *Months;
 157
 158   rcTime = 0;
 159
 160   /* Normalize the month value, because we don't know the length for month -1, 0, 13, 14, ... */
 161   if (TimeFields.Month < 1 || TimeFields.Month > 12)
 162   {
 163      TimeFields.Year += (TimeFields.Month - 1) / MONSPERYEAR;
 164      TimeFields.Month = ((TimeFields.Month - 1) % MONSPERYEAR) + 1;
 165      if (TimeFields.Month < 1)
 166      {
 167         TimeFields.Year--;
 168         TimeFields.Month += MONSPERYEAR;
 169      }
 170   }
 171     /* FIXME: handle calendar corrections here */
 172
 173   rcTime += (TimeFields.Year - EPOCHYEAR) * DAYSPERNORMALYEAR;
 174   /* Adjust leap years */
 175   rcTime += (TimeFields.Year - 1)/ 4 - (TimeFields.Year - 1) / 100 + (TimeFields.Year - 1) / 400;
 176   rcTime -= EPOCHYEAR / 4 - EPOCHYEAR / 100 + EPOCHYEAR / 400;
 177
 178     /* FIXME: handle calendar corrections here */
 179   Months = MonthLengths[IsLeapYear(TimeFields.Year)];
 180   for (CurMonth = 1; CurMonth < TimeFields.Month; CurMonth++)
 181     {
 182       rcTime += Months[CurMonth - 1];
 183     }
 184   rcTime += TimeFields.Day - 1;
 185   rcTime *= SECSPERDAY;
 186   rcTime += TimeFields.Hour * SECSPERHOUR + TimeFields.Minute * SECSPERMIN +
 187             TimeFields.Second;
 188   rcTime *= TICKSPERSEC;
 189   rcTime += TimeFields.Milliseconds * TICKSPERMSEC;
 190
 191     /* FIXME: handle UTC bias here */
 192 //  rcTime += UTCBias * TICKSPERMIN;
 193
 194   *Time = *(LARGE_INTEGER *)&rcTime;
 195
 196   return TRUE;
 197 }
 198
 199 #ifndef LIBCAPTIVE
 200
 201 VOID
 202 STDCALL
 203 RtlSecondsSince1970ToTime (
 204         ULONG SecondsSince1970,
 205         PLARGE_INTEGER Time
 206         )
 207 {
 208    LONGLONG llTime;
 209
 210    llTime = (SecondsSince1970 * TICKSPERSEC) + TICKSTO1970;
 211
 212    *Time = *(LARGE_INTEGER *)&llTime;
 213 }
 214
 215
 216 VOID
 217 STDCALL
 218 RtlSecondsSince1980ToTime (
 219         ULONG SecondsSince1980,
 220         PLARGE_INTEGER Time
 221         )
 222 {
 223    LONGLONG llTime;
 224
 225    llTime = (SecondsSince1980 * TICKSPERSEC) + TICKSTO1980;
 226
 227    *Time = *(LARGE_INTEGER *)&llTime;
 228 }
 229
 230
 231 BOOLEAN
 232 STDCALL
 233 RtlTimeToSecondsSince1970 (
 234         PLARGE_INTEGER Time,
 235         PULONG SecondsSince1970
 236         )
 237 {
 238    LARGE_INTEGER liTime;
 239
 240    liTime.QuadPart = Time->QuadPart - TICKSTO1970;
 241    liTime.QuadPart = liTime.QuadPart / TICKSPERSEC;
 242
 243    if (liTime.u.HighPart != 0)
 244       return FALSE;
 245
 246    *SecondsSince1970 = liTime.u.LowPart;
 247
 248    return TRUE;
 249 }
 250
 251
 252 BOOLEAN
 253 STDCALL
 254 RtlTimeToSecondsSince1980 (
 255         PLARGE_INTEGER Time,
 256         PULONG SecondsSince1980
 257         )
 258 {
 259    LARGE_INTEGER liTime;
 260
 261    liTime.QuadPart = Time->QuadPart - TICKSTO1980;
 262    liTime.QuadPart = liTime.QuadPart / TICKSPERSEC;
 263
 264    if (liTime.u.HighPart != 0)
 265       return FALSE;
 266
 267    *SecondsSince1980 = liTime.u.LowPart;
 268
 269    return TRUE;
 270 }
 271
 272 #endif /* LIBCAPTIVE */
 273
 274 /* EOF */