git.oblomov.eu Git - wine/blob - dlls/kernel/time.c

   1 /*
   2  * Win32 kernel time functions
   3  *
   4  * Copyright 1995 Martin von Loewis and Cameron Heide
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #ifdef HAVE_UNISTD_H
  25 # include <unistd.h>
  26 #endif
  27 #include <stdlib.h>
  28 #ifdef HAVE_SYS_TIME_H
  29 # include <sys/time.h>
  30 #endif
  31 #ifdef HAVE_SYS_TIMES_H
  32 # include <sys/times.h>
  33 #endif
  34
  35 #define NONAMELESSUNION
  36 #define NONAMELESSSTRUCT
  37 #include "file.h"
  38 #include "winternl.h"
  39 #include "winerror.h"
  40 #include "winnls.h"
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(win32);
  45
  46 /* maximum time adjustment in seconds for SetLocalTime and SetSystemTime */
  47 #define SETTIME_MAX_ADJUST 120
  48 #define CALINFO_MAX_YEAR 2029
  49
  50
  51 /***********************************************************************
  52  *              SetLocalTime            (KERNEL32.@)
  53  *
  54  *  Set the local time using current time zone and daylight
  55  *  savings settings.
  56  *
  57  * RETURNS
  58  *  Success: TRUE. The time was set
  59  *  Failure: FALSE, if the time was invalid or caller does not have
  60  *           permission to change the time.
  61  */
  62 BOOL WINAPI SetLocalTime(
  63     const SYSTEMTIME *systime) /* [in] The desired local time. */
  64 {
  65     FILETIME ft;
  66     LARGE_INTEGER st, st2;
  67     NTSTATUS status;
  68
  69     SystemTimeToFileTime( systime, &ft );
  70     st.s.LowPart = ft.dwLowDateTime;
  71     st.s.HighPart = ft.dwHighDateTime;
  72     RtlLocalTimeToSystemTime( &st, &st2 );
  73
  74     if ((status = NtSetSystemTime(&st2, NULL)))
  75         SetLastError( RtlNtStatusToDosError(status) );
  76     return !status;
  77 }
  78
  79
  80 /***********************************************************************
  81  *           GetSystemTimeAdjustment     (KERNEL32.@)
  82  *
  83  *  Get the period between clock interrupts and the amount the clock
  84  *  is adjusted each interrupt so as to keep it in sync with an external source.
  85  *
  86  * RETURNS
  87  *  TRUE.
  88  *
  89  * BUGS
  90  *  Only the special case of disabled time adjustments is supported.
  91  */
  92 BOOL WINAPI GetSystemTimeAdjustment(
  93     PDWORD lpTimeAdjustment,         /* [out] The clock adjustment per interupt in 100's of nanoseconds. */
  94     PDWORD lpTimeIncrement,          /* [out] The time between clock interupts in 100's of nanoseconds. */
  95     PBOOL  lpTimeAdjustmentDisabled) /* [out] The clock synchonisation has been disabled. */
  96 {
  97     *lpTimeAdjustment = 0;
  98     *lpTimeIncrement = 0;
  99     *lpTimeAdjustmentDisabled = TRUE;
 100     return TRUE;
 101 }
 102
 103
 104 /***********************************************************************
 105  *              SetSystemTime            (KERNEL32.@)
 106  *
 107  *  Set the system time in utc.
 108  *
 109  * RETURNS
 110  *  Success: TRUE. The time was set
 111  *  Failure: FALSE, if the time was invalid or caller does not have
 112  *           permission to change the time.
 113  */
 114 BOOL WINAPI SetSystemTime(
 115     const SYSTEMTIME *systime) /* [in] The desired system time. */
 116 {
 117     FILETIME ft;
 118     LARGE_INTEGER t;
 119     NTSTATUS status;
 120
 121     SystemTimeToFileTime( systime, &ft );
 122     t.s.LowPart = ft.dwLowDateTime;
 123     t.s.HighPart = ft.dwHighDateTime;
 124     if ((status = NtSetSystemTime(&t, NULL)))
 125         SetLastError( RtlNtStatusToDosError(status) );
 126     return !status;
 127 }
 128
 129 /***********************************************************************
 130  *              SetSystemTimeAdjustment  (KERNEL32.@)
 131  *
 132  *  Enables or disables the timing adjustments to the system's clock.
 133  *
 134  * RETURNS
 135  *  Success: TRUE.
 136  *  Failure: FALSE.
 137  */
 138 BOOL WINAPI SetSystemTimeAdjustment(
 139     DWORD dwTimeAdjustment,
 140     BOOL bTimeAdjustmentDisabled)
 141 {
 142     /* Fake function for now... */
 143     FIXME("(%08lx,%d): stub !\n", dwTimeAdjustment, bTimeAdjustmentDisabled);
 144     return TRUE;
 145 }
 146
 147
 148 /***********************************************************************
 149  *              GetTimeZoneInformation  (KERNEL32.@)
 150  *
 151  *  Get information about the current local time zone.
 152  *
 153  * RETURNS
 154  *  Success: TIME_ZONE_ID_STANDARD. tzinfo contains the time zone info.
 155  *  Failure: TIME_ZONE_ID_INVALID.
 156  */
 157 DWORD WINAPI GetTimeZoneInformation(
 158     LPTIME_ZONE_INFORMATION tzinfo) /* [out] Destination for time zone information */
 159 {
 160     NTSTATUS status;
 161     if ((status = RtlQueryTimeZoneInformation(tzinfo)))
 162         SetLastError( RtlNtStatusToDosError(status) );
 163     return TIME_ZONE_ID_STANDARD;
 164 }
 165
 166
 167 /***********************************************************************
 168  *              SetTimeZoneInformation  (KERNEL32.@)
 169  *
 170  *  Change the settings of the current local time zone.
 171  *
 172  * RETURNS
 173  *  Success: TRUE. The time zone was updated with the settings from tzinfo
 174  *  Failure: FALSE.
 175  */
 176 BOOL WINAPI SetTimeZoneInformation(
 177     const LPTIME_ZONE_INFORMATION tzinfo) /* [in] The new time zone. */
 178 {
 179     NTSTATUS status;
 180     if ((status = RtlSetTimeZoneInformation(tzinfo)))
 181         SetLastError( RtlNtStatusToDosError(status) );
 182     return !status;
 183 }
 184
 185
 186 /***********************************************************************
 187  *  _DayLightCompareDate
 188  *
 189  *  Compares two dates without looking at the year
 190  *
 191  * RETURNS
 192  *
 193  *  -1 if date < compareDate
 194  *   0 if date == compareDate
 195  *   1 if date > compareDate
 196  *  -2 if an error occures
 197  */
 198
 199 static int _DayLightCompareDate(
 200     const LPSYSTEMTIME date,                       /* [in] The date to compare. */
 201     const LPSYSTEMTIME compareDate)                /* [in] The daylight saving begin or end date */
 202 {
 203     int limit_day;
 204
 205     if (compareDate->wYear != 0)
 206     {
 207         if (date->wMonth < compareDate->wMonth)
 208             return -1; /* We are in a year before the date limit. */
 209
 210         if (date->wMonth > compareDate->wMonth)
 211             return 1; /* We are in a year after the date limit. */
 212     }
 213
 214     if (date->wMonth < compareDate->wMonth)
 215         return -1; /* We are in a month before the date limit. */
 216
 217     if (date->wMonth > compareDate->wMonth)
 218         return 1; /* We are in a month after the date limit. */
 219
 220     if (compareDate->wDayOfWeek <= 6)
 221     {
 222        SYSTEMTIME tmp;
 223        FILETIME tmp_ft;
 224
 225        /* compareDate->wDay is interpreted as number of the week in the month. */
 226        /* 5 means: the last week in the month */
 227        int weekofmonth = compareDate->wDay;
 228
 229          /* calculate day of week for the first day in the month */
 230         memcpy(&tmp, date, sizeof(SYSTEMTIME));
 231         tmp.wDay = 1;
 232         tmp.wDayOfWeek = -1;
 233
 234         if (weekofmonth == 5)
 235         {
 236              /* Go to the beginning of the next month. */
 237             if (++tmp.wMonth > 12)
 238             {
 239                 tmp.wMonth = 1;
 240                 ++tmp.wYear;
 241             }
 242         }
 243
 244         if (!SystemTimeToFileTime(&tmp, &tmp_ft))
 245             return -2;
 246
 247         if (weekofmonth == 5)
 248         {
 249           LONGLONG t, one_day;
 250
 251           t = tmp_ft.dwHighDateTime;
 252           t <<= 32;
 253           t += (UINT)tmp_ft.dwLowDateTime;
 254
 255           /* subtract one day */
 256           one_day = 24*60*60;
 257           one_day *= 10000000;
 258           t -= one_day;
 259
 260           tmp_ft.dwLowDateTime  = (UINT)t;
 261           tmp_ft.dwHighDateTime = (UINT)(t >> 32);
 262         }
 263
 264         if (!FileTimeToSystemTime(&tmp_ft, &tmp))
 265             return -2;
 266
 267        if (weekofmonth == 5)
 268        {
 269           /* calculate the last matching day of the week in this month */
 270           int dif = tmp.wDayOfWeek - compareDate->wDayOfWeek;
 271           if (dif < 0)
 272              dif += 7;
 273
 274           limit_day = tmp.wDay - dif;
 275        }
 276        else
 277        {
 278           /* calculate the matching day of the week in the given week */
 279           int dif = compareDate->wDayOfWeek - tmp.wDayOfWeek;
 280           if (dif < 0)
 281              dif += 7;
 282
 283           limit_day = tmp.wDay + 7*(weekofmonth-1) + dif;
 284        }
 285     }
 286     else
 287     {
 288        limit_day = compareDate->wDay;
 289     }
 290
 291     if (date->wDay < limit_day)
 292         return -1;
 293
 294     if (date->wDay > limit_day)
 295         return 1;
 296
 297     return 0;   /* date is equal to the date limit. */
 298 }
 299
 300
 301 /***********************************************************************
 302  *  _GetTimezoneBias
 303  *
 304  *  Calculates the local time bias for a given time zone
 305  *
 306  * RETURNS
 307  *
 308  *  Returns TRUE when the time zone bias was calculated.
 309  */
 310
 311 static BOOL _GetTimezoneBias(
 312     const LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The time zone data.            */
 313     LPSYSTEMTIME                  lpSystemTime,          /* [in] The system time.               */
 314     LONG*                         pBias)                 /* [out] The calulated bias in minutes */
 315 {
 316     int ret;
 317     BOOL beforeStandardDate, afterDaylightDate;
 318     BOOL daylightsaving = FALSE;
 319     LONG bias = lpTimeZoneInformation->Bias;
 320
 321     if (lpTimeZoneInformation->DaylightDate.wMonth != 0)
 322     {
 323         if (lpTimeZoneInformation->StandardDate.wMonth == 0 ||
 324             lpTimeZoneInformation->StandardDate.wDay<1 ||
 325             lpTimeZoneInformation->StandardDate.wDay>5 ||
 326             lpTimeZoneInformation->DaylightDate.wDay<1 ||
 327             lpTimeZoneInformation->DaylightDate.wDay>5)
 328         {
 329             SetLastError(ERROR_INVALID_PARAMETER);
 330             return FALSE;
 331         }
 332
 333          /* check for daylight saving */
 334         ret = _DayLightCompareDate(lpSystemTime, &lpTimeZoneInformation->StandardDate);
 335         if (ret == -2)
 336           return FALSE;
 337
 338         beforeStandardDate = ret < 0;
 339
 340         ret = _DayLightCompareDate(lpSystemTime, &lpTimeZoneInformation->DaylightDate);
 341         if (ret == -2)
 342           return FALSE;
 343
 344         afterDaylightDate = ret >= 0;
 345
 346         if (beforeStandardDate && afterDaylightDate)
 347             daylightsaving = TRUE;
 348     }
 349
 350     if (daylightsaving)
 351         bias += lpTimeZoneInformation->DaylightBias;
 352     else if (lpTimeZoneInformation->StandardDate.wMonth != 0)
 353         bias += lpTimeZoneInformation->StandardBias;
 354
 355     *pBias = bias;
 356
 357     return TRUE;
 358 }
 359
 360
 361 /***********************************************************************
 362  *              SystemTimeToTzSpecificLocalTime  (KERNEL32.@)
 363  *
 364  *  Convert a utc system time to a local time in a given time zone.
 365  *
 366  * RETURNS
 367  *  Success: TRUE. lpLocalTime contains the converted time
 368  *  Failure: FALSE.
 369  */
 370
 371 BOOL WINAPI SystemTimeToTzSpecificLocalTime(
 372     LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The desired time zone. */
 373     LPSYSTEMTIME            lpUniversalTime,       /* [in] The utc time to base local time on. */
 374     LPSYSTEMTIME            lpLocalTime)           /* [out] The local time in the time zone. */
 375 {
 376     FILETIME ft;
 377     LONG lBias;
 378     LONGLONG t, bias;
 379     TIME_ZONE_INFORMATION tzinfo;
 380
 381     if (lpTimeZoneInformation != NULL)
 382     {
 383         memcpy(&tzinfo, lpTimeZoneInformation, sizeof(TIME_ZONE_INFORMATION));
 384     }
 385     else
 386     {
 387         if (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_INVALID)
 388             return FALSE;
 389     }
 390
 391     if (!SystemTimeToFileTime(lpUniversalTime, &ft))
 392         return FALSE;
 393
 394     t = ft.dwHighDateTime;
 395     t <<= 32;
 396     t += (UINT)ft.dwLowDateTime;
 397
 398     if (!_GetTimezoneBias(&tzinfo, lpUniversalTime, &lBias))
 399         return FALSE;
 400
 401     bias = (LONGLONG)lBias * 600000000; /* 60 seconds per minute, 100000 [100-nanoseconds-ticks] per second */
 402     t -= bias;
 403
 404     ft.dwLowDateTime  = (UINT)t;
 405     ft.dwHighDateTime = (UINT)(t >> 32);
 406
 407     return FileTimeToSystemTime(&ft, lpLocalTime);
 408 }
 409
 410
 411 /***********************************************************************
 412  *              TzSpecificLocalTimeToSystemTime  (KERNEL32.@)
 413  *
 414  *  Converts a local time to a time in utc.
 415  *
 416  * RETURNS
 417  *  Success: TRUE. lpUniversalTime contains the converted time
 418  *  Failure: FALSE.
 419  */
 420 BOOL WINAPI TzSpecificLocalTimeToSystemTime(
 421     LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The desired time zone. */
 422     LPSYSTEMTIME            lpLocalTime,           /* [in] The local time. */
 423     LPSYSTEMTIME            lpUniversalTime)       /* [out] The calculated utc time. */
 424 {
 425     FILETIME ft;
 426     LONG lBias;
 427     LONGLONG t, bias;
 428     TIME_ZONE_INFORMATION tzinfo;
 429
 430     if (lpTimeZoneInformation != NULL)
 431     {
 432         memcpy(&tzinfo, lpTimeZoneInformation, sizeof(TIME_ZONE_INFORMATION));
 433     }
 434     else
 435     {
 436         if (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_INVALID)
 437             return FALSE;
 438     }
 439
 440     if (!SystemTimeToFileTime(lpLocalTime, &ft))
 441         return FALSE;
 442
 443     t = ft.dwHighDateTime;
 444     t <<= 32;
 445     t += (UINT)ft.dwLowDateTime;
 446
 447     if (!_GetTimezoneBias(&tzinfo, lpLocalTime, &lBias))
 448         return FALSE;
 449
 450     bias = (LONGLONG)lBias * 600000000; /* 60 seconds per minute, 100000 [100-nanoseconds-ticks] per second */
 451     t += bias;
 452
 453     ft.dwLowDateTime  = (UINT)t;
 454     ft.dwHighDateTime = (UINT)(t >> 32);
 455
 456     return FileTimeToSystemTime(&ft, lpUniversalTime);
 457 }
 458
 459
 460 /***********************************************************************
 461  *              GetSystemTimeAsFileTime  (KERNEL32.@)
 462  *
 463  *  Get the current time in utc format.
 464  *
 465  *  RETURNS
 466  *   Nothing.
 467  */
 468 VOID WINAPI GetSystemTimeAsFileTime(
 469     LPFILETIME time) /* [out] Destination for the current utc time */
 470 {
 471     LARGE_INTEGER t;
 472     NtQuerySystemTime( &t );
 473     time->dwLowDateTime = t.s.LowPart;
 474     time->dwHighDateTime = t.s.HighPart;
 475 }
 476
 477
 478 /*********************************************************************
 479  *      TIME_ClockTimeToFileTime    (olorin@fandra.org, 20-Sep-1998)
 480  *
 481  *  Used by GetProcessTimes to convert clock_t into FILETIME.
 482  *
 483  *      Differences to UnixTimeToFileTime:
 484  *          1) Divided by CLK_TCK
 485  *          2) Time is relative. There is no 'starting date', so there is
 486  *             no need for offset correction, like in UnixTimeToFileTime
 487  */
 488 static void TIME_ClockTimeToFileTime(clock_t unix_time, LPFILETIME filetime)
 489 {
 490     ULONGLONG secs = RtlEnlargedUnsignedMultiply( unix_time, 10000000 );
 491     secs = RtlExtendedLargeIntegerDivide( secs, CLK_TCK, NULL );
 492     filetime->dwLowDateTime  = (DWORD)secs;
 493     filetime->dwHighDateTime = (DWORD)(secs >> 32);
 494 }
 495
 496 /*********************************************************************
 497  *      GetProcessTimes                         (KERNEL32.@)
 498  *
 499  *  Get the user and kernel execution times of a process,
 500  *  along with the creation and exit times if known.
 501  *
 502  * RETURNS
 503  *  TRUE.
 504  *
 505  * NOTES
 506  *  olorin@fandra.org:
 507  *  Would be nice to subtract the cpu time used by Wine at startup.
 508  *  Also, there is a need to separate times used by different applications.
 509  *
 510  * BUGS
 511  *  lpCreationTime and lpExitTime are not initialised in the Wine implementation.
 512  */
 513 BOOL WINAPI GetProcessTimes(
 514     HANDLE     hprocess,       /* [in] The process to be queried (obtained from PROCESS_QUERY_INFORMATION). */
 515     LPFILETIME lpCreationTime, /* [out] The creation time of the process. */
 516     LPFILETIME lpExitTime,     /* [out] The exit time of the process if exited. */
 517     LPFILETIME lpKernelTime,   /* [out] The time spent in kernal routines in 100's of nanoseconds. */
 518     LPFILETIME lpUserTime)     /* [out] The time spent in user routines in 100's of nanoseconds. */
 519 {
 520     struct tms tms;
 521
 522     times(&tms);
 523     TIME_ClockTimeToFileTime(tms.tms_utime,lpUserTime);
 524     TIME_ClockTimeToFileTime(tms.tms_stime,lpKernelTime);
 525     return TRUE;
 526 }
 527
 528 /*********************************************************************
 529  *      GetCalendarInfoA                                (KERNEL32.@)
 530  *
 531  */
 532 int WINAPI GetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType,
 533                             LPSTR lpCalData, int cchData, LPDWORD lpValue)
 534 {
 535     int ret;
 536     LPWSTR lpCalDataW = NULL;
 537
 538     FIXME("(%08lx,%08lx,%08lx,%p,%d,%p): quarter-stub\n",
 539           Locale, Calendar, CalType, lpCalData, cchData, lpValue);
 540     /* FIXME: Should verify if Locale is allowable in ANSI, as per MSDN */
 541
 542     if(cchData)
 543       if(!(lpCalDataW = HeapAlloc(GetProcessHeap(), 0, cchData*sizeof(WCHAR)))) return 0;
 544
 545     ret = GetCalendarInfoW(Locale, Calendar, CalType, lpCalDataW, cchData, lpValue);
 546     if(ret && lpCalDataW && lpCalData)
 547       WideCharToMultiByte(CP_ACP, 0, lpCalDataW, cchData, lpCalData, cchData, NULL, NULL);
 548     if(lpCalDataW)
 549       HeapFree(GetProcessHeap(), 0, lpCalDataW);
 550
 551     return ret;
 552 }
 553
 554 /*********************************************************************
 555  *      GetCalendarInfoW                                (KERNEL32.@)
 556  *
 557  * See GetCalendarInfoA.
 558  */
 559 int WINAPI GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType,
 560                             LPWSTR lpCalData, int cchData, LPDWORD lpValue)
 561 {
 562     FIXME("(%08lx,%08lx,%08lx,%p,%d,%p): quarter-stub\n",
 563           Locale, Calendar, CalType, lpCalData, cchData, lpValue);
 564
 565     if (CalType & CAL_NOUSEROVERRIDE)
 566         FIXME("flag CAL_NOUSEROVERRIDE used, not fully implemented\n");
 567     if (CalType & CAL_USE_CP_ACP)
 568         FIXME("flag CAL_USE_CP_ACP used, not fully implemented\n");
 569
 570     if (CalType & CAL_RETURN_NUMBER) {
 571         if (lpCalData != NULL)
 572             WARN("lpCalData not NULL (%p) when it should!\n", lpCalData);
 573         if (cchData != 0)
 574             WARN("cchData not 0 (%d) when it should!\n", cchData);
 575     } else {
 576         if (lpValue != NULL)
 577             WARN("lpValue not NULL (%p) when it should!\n", lpValue);
 578     }
 579
 580     /* FIXME: No verification is made yet wrt Locale
 581      * for the CALTYPES not requiring GetLocaleInfoA */
 582     switch (CalType & ~(CAL_NOUSEROVERRIDE|CAL_RETURN_NUMBER|CAL_USE_CP_ACP)) {
 583         case CAL_ICALINTVALUE:
 584             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 585             return E_FAIL;
 586         case CAL_SCALNAME:
 587             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 588             return E_FAIL;
 589         case CAL_IYEAROFFSETRANGE:
 590             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 591             return E_FAIL;
 592         case CAL_SERASTRING:
 593             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 594             return E_FAIL;
 595         case CAL_SSHORTDATE:
 596             return GetLocaleInfoW(Locale, LOCALE_SSHORTDATE, lpCalData, cchData);
 597         case CAL_SLONGDATE:
 598             return GetLocaleInfoW(Locale, LOCALE_SLONGDATE, lpCalData, cchData);
 599         case CAL_SDAYNAME1:
 600             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME1, lpCalData, cchData);
 601         case CAL_SDAYNAME2:
 602             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME2, lpCalData, cchData);
 603         case CAL_SDAYNAME3:
 604             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME3, lpCalData, cchData);
 605         case CAL_SDAYNAME4:
 606             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME4, lpCalData, cchData);
 607         case CAL_SDAYNAME5:
 608             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME5, lpCalData, cchData);
 609         case CAL_SDAYNAME6:
 610             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME6, lpCalData, cchData);
 611         case CAL_SDAYNAME7:
 612             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME7, lpCalData, cchData);
 613         case CAL_SABBREVDAYNAME1:
 614             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME1, lpCalData, cchData);
 615         case CAL_SABBREVDAYNAME2:
 616             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME2, lpCalData, cchData);
 617         case CAL_SABBREVDAYNAME3:
 618             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME3, lpCalData, cchData);
 619         case CAL_SABBREVDAYNAME4:
 620             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME4, lpCalData, cchData);
 621         case CAL_SABBREVDAYNAME5:
 622             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME5, lpCalData, cchData);
 623         case CAL_SABBREVDAYNAME6:
 624             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME6, lpCalData, cchData);
 625         case CAL_SABBREVDAYNAME7:
 626             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME7, lpCalData, cchData);
 627         case CAL_SMONTHNAME1:
 628             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME1, lpCalData, cchData);
 629         case CAL_SMONTHNAME2:
 630             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME2, lpCalData, cchData);
 631         case CAL_SMONTHNAME3:
 632             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME3, lpCalData, cchData);
 633         case CAL_SMONTHNAME4:
 634             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME4, lpCalData, cchData);
 635         case CAL_SMONTHNAME5:
 636             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME5, lpCalData, cchData);
 637         case CAL_SMONTHNAME6:
 638             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME6, lpCalData, cchData);
 639         case CAL_SMONTHNAME7:
 640             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME7, lpCalData, cchData);
 641         case CAL_SMONTHNAME8:
 642             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME8, lpCalData, cchData);
 643         case CAL_SMONTHNAME9:
 644             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME9, lpCalData, cchData);
 645         case CAL_SMONTHNAME10:
 646             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME10, lpCalData, cchData);
 647         case CAL_SMONTHNAME11:
 648             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME11, lpCalData, cchData);
 649         case CAL_SMONTHNAME12:
 650             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME12, lpCalData, cchData);
 651         case CAL_SMONTHNAME13:
 652             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME13, lpCalData, cchData);
 653         case CAL_SABBREVMONTHNAME1:
 654             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME1, lpCalData, cchData);
 655         case CAL_SABBREVMONTHNAME2:
 656             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME2, lpCalData, cchData);
 657         case CAL_SABBREVMONTHNAME3:
 658             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME3, lpCalData, cchData);
 659         case CAL_SABBREVMONTHNAME4:
 660             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME4, lpCalData, cchData);
 661         case CAL_SABBREVMONTHNAME5:
 662             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME5, lpCalData, cchData);
 663         case CAL_SABBREVMONTHNAME6:
 664             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME6, lpCalData, cchData);
 665         case CAL_SABBREVMONTHNAME7:
 666             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME7, lpCalData, cchData);
 667         case CAL_SABBREVMONTHNAME8:
 668             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME8, lpCalData, cchData);
 669         case CAL_SABBREVMONTHNAME9:
 670             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME9, lpCalData, cchData);
 671         case CAL_SABBREVMONTHNAME10:
 672             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME10, lpCalData, cchData);
 673         case CAL_SABBREVMONTHNAME11:
 674             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME11, lpCalData, cchData);
 675         case CAL_SABBREVMONTHNAME12:
 676             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME12, lpCalData, cchData);
 677         case CAL_SABBREVMONTHNAME13:
 678             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME13, lpCalData, cchData);
 679         case CAL_SYEARMONTH:
 680             return GetLocaleInfoW(Locale, LOCALE_SYEARMONTH, lpCalData, cchData);
 681         case CAL_ITWODIGITYEARMAX:
 682             if (lpValue) *lpValue = CALINFO_MAX_YEAR;
 683             break;
 684         default: MESSAGE("Unknown caltype %ld\n",CalType & 0xffff);
 685                  return E_FAIL;
 686     }
 687     return 0;
 688 }
 689
 690 /*********************************************************************
 691  *      SetCalendarInfoA                                (KERNEL32.@)
 692  *
 693  */
 694 int WINAPI      SetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData)
 695 {
 696     FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
 697           Locale, Calendar, CalType, debugstr_a(lpCalData));
 698     return 0;
 699 }
 700
 701 /*********************************************************************
 702  *      SetCalendarInfoW                                (KERNEL32.@)
 703  *
 704  * See SetCalendarInfoA.
 705  */
 706 int WINAPI      SetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData)
 707 {
 708     FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
 709           Locale, Calendar, CalType, debugstr_w(lpCalData));
 710     return 0;
 711 }
 712
 713 /*********************************************************************
 714  *      LocalFileTimeToFileTime                         (KERNEL32.@)
 715  */
 716 BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft, LPFILETIME utcft )
 717 {
 718     NTSTATUS status;
 719     LARGE_INTEGER local, utc;
 720
 721     local.s.LowPart = localft->dwLowDateTime;
 722     local.s.HighPart = localft->dwHighDateTime;
 723     if (!(status = RtlLocalTimeToSystemTime( &local, &utc )))
 724     {
 725         utcft->dwLowDateTime = utc.s.LowPart;
 726         utcft->dwHighDateTime = utc.s.HighPart;
 727     }
 728     else SetLastError( RtlNtStatusToDosError(status) );
 729
 730     return !status;
 731 }
 732
 733 /*********************************************************************
 734  *      FileTimeToLocalFileTime                         (KERNEL32.@)
 735  */
 736 BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft, LPFILETIME localft )
 737 {
 738     NTSTATUS status;
 739     LARGE_INTEGER local, utc;
 740
 741     utc.s.LowPart = utcft->dwLowDateTime;
 742     utc.s.HighPart = utcft->dwHighDateTime;
 743     if (!(status = RtlSystemTimeToLocalTime( &utc, &local )))
 744     {
 745         localft->dwLowDateTime = local.s.LowPart;
 746         localft->dwHighDateTime = local.s.HighPart;
 747     }
 748     else SetLastError( RtlNtStatusToDosError(status) );
 749
 750     return !status;
 751 }
 752
 753 /*********************************************************************
 754  *      FileTimeToSystemTime                            (KERNEL32.@)
 755  */
 756 BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
 757 {
 758     TIME_FIELDS tf;
 759     LARGE_INTEGER t;
 760
 761     t.s.LowPart = ft->dwLowDateTime;
 762     t.s.HighPart = ft->dwHighDateTime;
 763     RtlTimeToTimeFields(&t, &tf);
 764
 765     syst->wYear = tf.Year;
 766     syst->wMonth = tf.Month;
 767     syst->wDay = tf.Day;
 768     syst->wHour = tf.Hour;
 769     syst->wMinute = tf.Minute;
 770     syst->wSecond = tf.Second;
 771     syst->wMilliseconds = tf.Milliseconds;
 772     syst->wDayOfWeek = tf.Weekday;
 773     return TRUE;
 774 }
 775
 776 /*********************************************************************
 777  *      SystemTimeToFileTime                            (KERNEL32.@)
 778  */
 779 BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
 780 {
 781     TIME_FIELDS tf;
 782     LARGE_INTEGER t;
 783
 784     tf.Year = syst->wYear;
 785     tf.Month = syst->wMonth;
 786     tf.Day = syst->wDay;
 787     tf.Hour = syst->wHour;
 788     tf.Minute = syst->wMinute;
 789     tf.Second = syst->wSecond;
 790     tf.Milliseconds = syst->wMilliseconds;
 791
 792     RtlTimeFieldsToTime(&tf, &t);
 793     ft->dwLowDateTime = t.s.LowPart;
 794     ft->dwHighDateTime = t.s.HighPart;
 795     return TRUE;
 796 }
 797
 798 /*********************************************************************
 799  *      CompareFileTime                                 (KERNEL32.@)
 800  *
 801  * Compare two FILETIME's to each other.
 802  *
 803  * PARAMS
 804  *  x [I] First time
 805  *  y [I] time to compare to x
 806  *
 807  * RETURNS
 808  *  -1, 0, or 1 indicating that x is less than, equal to, or greater
 809  *  than y respectively.
 810  */
 811 INT WINAPI CompareFileTime( const FILETIME *x, const FILETIME *y )
 812 {
 813     if (!x || !y) return -1;
 814
 815     if (x->dwHighDateTime > y->dwHighDateTime)
 816         return 1;
 817     if (x->dwHighDateTime < y->dwHighDateTime)
 818         return -1;
 819     if (x->dwLowDateTime > y->dwLowDateTime)
 820         return 1;
 821     if (x->dwLowDateTime < y->dwLowDateTime)
 822         return -1;
 823     return 0;
 824 }
 825
 826 /*********************************************************************
 827  *      GetLocalTime                                    (KERNEL32.@)
 828  *
 829  * Get the current local time.
 830  *
 831  * RETURNS
 832  *  Nothing.
 833  */
 834 VOID WINAPI GetLocalTime(LPSYSTEMTIME systime) /* [O] Destination for current time */
 835 {
 836     FILETIME lft;
 837     LARGE_INTEGER ft, ft2;
 838
 839     NtQuerySystemTime(&ft);
 840     RtlSystemTimeToLocalTime(&ft, &ft2);
 841     lft.dwLowDateTime = ft2.s.LowPart;
 842     lft.dwHighDateTime = ft2.s.HighPart;
 843     FileTimeToSystemTime(&lft, systime);
 844 }
 845
 846 /*********************************************************************
 847  *      GetSystemTime                                   (KERNEL32.@)
 848  *
 849  * Get the current system time.
 850  *
 851  * RETURNS
 852  *  Nothing.
 853  */
 854 VOID WINAPI GetSystemTime(LPSYSTEMTIME systime) /* [O] Destination for current time */
 855 {
 856     FILETIME ft;
 857     LARGE_INTEGER t;
 858
 859     NtQuerySystemTime(&t);
 860     ft.dwLowDateTime = t.s.LowPart;
 861     ft.dwHighDateTime = t.s.HighPart;
 862     FileTimeToSystemTime(&ft, systime);
 863 }