icu4c/source/i18n/windtfmt.cpp - external/github.com/unicode-org/icu - Git at Google

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ********************************************************************************
 *   Copyright (C) 2005-2016, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ********************************************************************************
 *
 * File WINDTFMT.CPP
 *
 ********************************************************************************
 */

 #include "unicode/utypes.h"

 #if U_PLATFORM_USES_ONLY_WIN32_API

 #if !UCONFIG_NO_FORMATTING

 #include "unicode/ures.h"
 #include "unicode/format.h"
 #include "unicode/fmtable.h"
 #include "unicode/datefmt.h"
 #include "unicode/simpleformatter.h"
 #include "unicode/calendar.h"
 #include "unicode/gregocal.h"
 #include "unicode/locid.h"
 #include "unicode/unistr.h"
 #include "unicode/ustring.h"
 #include "unicode/timezone.h"
 #include "unicode/utmscale.h"

 #include "cmemory.h"
 #include "uresimp.h"
 #include "windtfmt.h"
 #include "wintzimpl.h"

 #ifndef WIN32_LEAN_AND_MEAN
 #   define WIN32_LEAN_AND_MEAN
 #endif
 #   define VC_EXTRALEAN
 #   define NOUSER
 #   define NOSERVICE
 #   define NOIME
 #   define NOMCX
 #include <windows.h>

 U_NAMESPACE_BEGIN

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Win32DateFormat)

 #define NEW_ARRAY(type,count) (type *) uprv_malloc((count) * sizeof(type))
 #define DELETE_ARRAY(array) uprv_free((void *) (array))

 #define STACK_BUFFER_SIZE 64

 UnicodeString* Win32DateFormat::getTimeDateFormat(const Calendar *cal, const Locale *locale, UErrorCode &status) const
 {
     UnicodeString *result = NULL;
     const char *type = cal->getType();
     const char *base = locale->getBaseName();
     UResourceBundle *topBundle = ures_open((char *) 0, base, &status);
     UResourceBundle *calBundle = ures_getByKey(topBundle, "calendar", NULL, &status);
     UResourceBundle *typBundle = ures_getByKeyWithFallback(calBundle, type, NULL, &status);
     UResourceBundle *patBundle = ures_getByKeyWithFallback(typBundle, "DateTimePatterns", NULL, &status);

     if (status == U_MISSING_RESOURCE_ERROR) {
         status = U_ZERO_ERROR;
         typBundle = ures_getByKeyWithFallback(calBundle, "gregorian", typBundle, &status);
         patBundle = ures_getByKeyWithFallback(typBundle, "DateTimePatterns", patBundle, &status);
     }

     if (U_FAILURE(status)) {
         static const UChar defaultPattern[] = {0x007B, 0x0031, 0x007D, 0x0020, 0x007B, 0x0030, 0x007D, 0x0000}; // "{1} {0}"
         return new UnicodeString(defaultPattern, UPRV_LENGTHOF(defaultPattern));
     }

     int32_t resStrLen = 0;
     int32_t glueIndex = DateFormat::kDateTime;
     int32_t patSize = ures_getSize(patBundle);
     if (patSize >= (DateFormat::kDateTimeOffset + DateFormat::kShort + 1)) {
         // Get proper date time format
         glueIndex = (int32_t)(DateFormat::kDateTimeOffset + (fDateStyle - DateFormat::kDateOffset));
     }
     const UChar *resStr = ures_getStringByIndex(patBundle, glueIndex, &resStrLen, &status);

     result = new UnicodeString(TRUE, resStr, resStrLen);

     ures_close(patBundle);
     ures_close(typBundle);
     ures_close(calBundle);
     ures_close(topBundle);

     return result;
 }

 // TODO: This is copied in both winnmfmt.cpp and windtfmt.cpp, but really should
 // be factored out into a common helper for both.
 static UErrorCode GetEquivalentWindowsLocaleName(const Locale& locale, UnicodeString** buffer)
 {
     UErrorCode status = U_ZERO_ERROR;
     char asciiBCP47Tag[LOCALE_NAME_MAX_LENGTH] = {};

     // Convert from names like "en_CA" and "de_DE@collation=phonebook" to "en-CA" and "de-DE-u-co-phonebk".
     (void)uloc_toLanguageTag(locale.getName(), asciiBCP47Tag, UPRV_LENGTHOF(asciiBCP47Tag), FALSE, &status);

     if (U_SUCCESS(status))
     {
         // Need it to be UTF-16, not 8-bit
         // TODO: This seems like a good thing for a helper
         wchar_t bcp47Tag[LOCALE_NAME_MAX_LENGTH] = {};
         int32_t i;
         for (i = 0; i < UPRV_LENGTHOF(bcp47Tag); i++)
         {
             if (asciiBCP47Tag[i] == '\0')
             {
                 break;
             }
             else
             {
                 // normally just copy the character
                 bcp47Tag[i] = static_cast<wchar_t>(asciiBCP47Tag[i]);
             }
         }

         // Ensure it's null terminated
         if (i < (UPRV_LENGTHOF(bcp47Tag) - 1))
         {
             bcp47Tag[i] = L'\0';
         }
         else
         {
             // Ran out of room.
             bcp47Tag[UPRV_LENGTHOF(bcp47Tag) - 1] = L'\0';
         }


         wchar_t windowsLocaleName[LOCALE_NAME_MAX_LENGTH] = {};

         // Note: On Windows versions below 10, there is no support for locale name aliases.
         // This means that it will fail for locales where ICU has a completely different
         // name (like ku vs ckb), and it will also not work for alternate sort locale
         // names like "de-DE-u-co-phonebk".

         // TODO: We could add some sort of exception table for cases like ku vs ckb.

         int length = ResolveLocaleName(bcp47Tag, windowsLocaleName, UPRV_LENGTHOF(windowsLocaleName));

         if (length > 0)
         {
             *buffer = new UnicodeString(windowsLocaleName);
         }
         else
         {
             status = U_UNSUPPORTED_ERROR;
         }
     }
     return status;
 }

 // TODO: Range-check timeStyle, dateStyle
 Win32DateFormat::Win32DateFormat(DateFormat::EStyle timeStyle, DateFormat::EStyle dateStyle, const Locale &locale, UErrorCode &status)
   : DateFormat(), fDateTimeMsg(NULL), fTimeStyle(timeStyle), fDateStyle(dateStyle), fLocale(locale), fZoneID(), fWindowsLocaleName(nullptr)
 {
     if (U_SUCCESS(status)) {
         GetEquivalentWindowsLocaleName(locale, &fWindowsLocaleName);
         // Note: In the previous code, it would look up the LCID for the locale, and if
         // the locale was not recognized then it would get an LCID of 0, which is a
         // synonym for LOCALE_USER_DEFAULT on Windows.
         // If the above method fails, then fWindowsLocaleName will remain as nullptr, and
         // then we will pass nullptr to API GetLocaleInfoEx, which is the same as passing
         // LOCALE_USER_DEFAULT.

         fTZI = NEW_ARRAY(TIME_ZONE_INFORMATION, 1);
         uprv_memset(fTZI, 0, sizeof(TIME_ZONE_INFORMATION));
         adoptCalendar(Calendar::createInstance(locale, status));
     }
 }

 Win32DateFormat::Win32DateFormat(const Win32DateFormat &other)
   : DateFormat(other)
 {
     *this = other;
 }

 Win32DateFormat::~Win32DateFormat()
 {
 //    delete fCalendar;
     uprv_free(fTZI);
     delete fDateTimeMsg;
     delete fWindowsLocaleName;
 }

 Win32DateFormat &Win32DateFormat::operator=(const Win32DateFormat &other)
 {
     if (this == &other) { return *this; }  // self-assignment: no-op
     // The following handles fCalendar
     DateFormat::operator=(other);

 //    delete fCalendar;

     this->fDateTimeMsg = other.fDateTimeMsg == NULL ? NULL : new UnicodeString(*other.fDateTimeMsg);
     this->fTimeStyle   = other.fTimeStyle;
     this->fDateStyle   = other.fDateStyle;
     this->fLocale      = other.fLocale;
 //    this->fCalendar    = other.fCalendar->clone();
     this->fZoneID      = other.fZoneID;

     this->fTZI = NEW_ARRAY(TIME_ZONE_INFORMATION, 1);
     *this->fTZI = *other.fTZI;

     this->fWindowsLocaleName = other.fWindowsLocaleName == NULL ? NULL : new UnicodeString(*other.fWindowsLocaleName);

     return *this;
 }

 Win32DateFormat *Win32DateFormat::clone() const
 {
     return new Win32DateFormat(*this);
 }

 // TODO: Is just ignoring pos the right thing?
 UnicodeString &Win32DateFormat::format(Calendar &cal, UnicodeString &appendTo, FieldPosition & /* pos */) const
 {
     FILETIME ft;
     SYSTEMTIME st_gmt;
     SYSTEMTIME st_local;
     TIME_ZONE_INFORMATION tzi = *fTZI;
     UErrorCode status = U_ZERO_ERROR;
     const TimeZone &tz = cal.getTimeZone();
     int64_t uct, uft;

     setTimeZoneInfo(&tzi, tz);

     uct = utmscale_fromInt64((int64_t) cal.getTime(status), UDTS_ICU4C_TIME, &status);
     uft = utmscale_toInt64(uct, UDTS_WINDOWS_FILE_TIME, &status);

     ft.dwLowDateTime =  (DWORD) (uft & 0xFFFFFFFF);
     ft.dwHighDateTime = (DWORD) ((uft >> 32) & 0xFFFFFFFF);

     FileTimeToSystemTime(&ft, &st_gmt);
     SystemTimeToTzSpecificLocalTime(&tzi, &st_gmt, &st_local);


     if (fDateStyle != DateFormat::kNone && fTimeStyle != DateFormat::kNone) {
         UnicodeString date;
         UnicodeString time;
         UnicodeString *pattern = fDateTimeMsg;

         formatDate(&st_local, date);
         formatTime(&st_local, time);

         if (strcmp(fCalendar->getType(), cal.getType()) != 0) {
             pattern = getTimeDateFormat(&cal, &fLocale, status);
         }

         SimpleFormatter(*pattern, 2, 2, status).format(time, date, appendTo, status);
     } else if (fDateStyle != DateFormat::kNone) {
         formatDate(&st_local, appendTo);
     } else if (fTimeStyle != DateFormat::kNone) {
         formatTime(&st_local, appendTo);
     }

     return appendTo;
 }

 void Win32DateFormat::parse(const UnicodeString& /* text */, Calendar& /* cal */, ParsePosition& pos) const
 {
     pos.setErrorIndex(pos.getIndex());
 }

 void Win32DateFormat::adoptCalendar(Calendar *newCalendar)
 {
     if (fCalendar == NULL || strcmp(fCalendar->getType(), newCalendar->getType()) != 0) {
         UErrorCode status = U_ZERO_ERROR;

         if (fDateStyle != DateFormat::kNone && fTimeStyle != DateFormat::kNone) {
             delete fDateTimeMsg;
             fDateTimeMsg = getTimeDateFormat(newCalendar, &fLocale, status);
         }
     }

     delete fCalendar;
     fCalendar = newCalendar;

     fZoneID = setTimeZoneInfo(fTZI, fCalendar->getTimeZone());
 }

 void Win32DateFormat::setCalendar(const Calendar &newCalendar)
 {
     adoptCalendar(newCalendar.clone());
 }

 void Win32DateFormat::adoptTimeZone(TimeZone *zoneToAdopt)
 {
     fZoneID = setTimeZoneInfo(fTZI, *zoneToAdopt);
     fCalendar->adoptTimeZone(zoneToAdopt);
 }

 void Win32DateFormat::setTimeZone(const TimeZone& zone)
 {
     fZoneID = setTimeZoneInfo(fTZI, zone);
     fCalendar->setTimeZone(zone);
 }

 static const DWORD dfFlags[] = {DATE_LONGDATE, DATE_LONGDATE, DATE_SHORTDATE, DATE_SHORTDATE};

 void Win32DateFormat::formatDate(const SYSTEMTIME *st, UnicodeString &appendTo) const
 {
     int result=0;
     wchar_t stackBuffer[STACK_BUFFER_SIZE];
     wchar_t *buffer = stackBuffer;
     const wchar_t *localeName = nullptr;

     if (fWindowsLocaleName != nullptr)
     {
         localeName = reinterpret_cast<const wchar_t*>(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer()));
     }

     result = GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, buffer, STACK_BUFFER_SIZE, NULL);

     if (result == 0) {
         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
             int newLength = GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, NULL, 0, NULL);

             buffer = NEW_ARRAY(wchar_t, newLength);

             GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, buffer, newLength, NULL);
         }
     }

     appendTo.append((const UChar *)buffer, (int32_t) wcslen(buffer));

     if (buffer != stackBuffer) {
         DELETE_ARRAY(buffer);
     }
 }

 static const DWORD tfFlags[] = {0, 0, 0, TIME_NOSECONDS};

 void Win32DateFormat::formatTime(const SYSTEMTIME *st, UnicodeString &appendTo) const
 {
     int result;
     wchar_t stackBuffer[STACK_BUFFER_SIZE];
     wchar_t *buffer = stackBuffer;
     const wchar_t *localeName = nullptr;

     if (fWindowsLocaleName != nullptr)
     {
         localeName = reinterpret_cast<const wchar_t*>(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer()));
     }

     result = GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, buffer, STACK_BUFFER_SIZE);

     if (result == 0) {
         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
             int newLength = GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, NULL, 0);

             buffer = NEW_ARRAY(wchar_t, newLength);

             GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, buffer, newLength);
         }
     }

     appendTo.append((const UChar *)buffer, (int32_t) wcslen(buffer));

     if (buffer != stackBuffer) {
         DELETE_ARRAY(buffer);
     }
 }

 UnicodeString Win32DateFormat::setTimeZoneInfo(TIME_ZONE_INFORMATION *tzi, const TimeZone &zone) const
 {
     UnicodeString zoneID;

     zone.getID(zoneID);

     if (zoneID.compare(fZoneID) != 0) {
         UnicodeString icuid;

         zone.getID(icuid);
         if (! uprv_getWindowsTimeZoneInfo(tzi, icuid.getBuffer(), icuid.length())) {
             UBool found = FALSE;
             int32_t ec = TimeZone::countEquivalentIDs(icuid);

             for (int z = 0; z < ec; z += 1) {
                 UnicodeString equiv = TimeZone::getEquivalentID(icuid, z);

                 found = uprv_getWindowsTimeZoneInfo(tzi, equiv.getBuffer(), equiv.length());
                 if (found) {
                     break;
                 }
             }

             if (! found) {
                 GetTimeZoneInformation(tzi);
             }
         }
     }

     return zoneID;
 }

 U_NAMESPACE_END

 #endif /* #if !UCONFIG_NO_FORMATTING */

 #endif // U_PLATFORM_USES_ONLY_WIN32_API
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	********************************************************************************
	* Copyright (C) 2005-2016, International Business Machines
	* Corporation and others. All Rights Reserved.
	********************************************************************************
	*
	* File WINDTFMT.CPP
	*
	********************************************************************************
	*/

	#include "unicode/utypes.h"

	#if U_PLATFORM_USES_ONLY_WIN32_API

	#if !UCONFIG_NO_FORMATTING

	#include "unicode/ures.h"
	#include "unicode/format.h"
	#include "unicode/fmtable.h"
	#include "unicode/datefmt.h"
	#include "unicode/simpleformatter.h"
	#include "unicode/calendar.h"
	#include "unicode/gregocal.h"
	#include "unicode/locid.h"
	#include "unicode/unistr.h"
	#include "unicode/ustring.h"
	#include "unicode/timezone.h"
	#include "unicode/utmscale.h"

	#include "cmemory.h"
	#include "uresimp.h"
	#include "windtfmt.h"
	#include "wintzimpl.h"

	#ifndef WIN32_LEAN_AND_MEAN
	# define WIN32_LEAN_AND_MEAN
	#endif
	# define VC_EXTRALEAN
	# define NOUSER
	# define NOSERVICE
	# define NOIME
	# define NOMCX
	#include <windows.h>

	U_NAMESPACE_BEGIN

	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Win32DateFormat)

	#define NEW_ARRAY(type,count) (type ) uprv_malloc((count) sizeof(type))
	#define DELETE_ARRAY(array) uprv_free((void *) (array))

	#define STACK_BUFFER_SIZE 64

	UnicodeString* Win32DateFormat::getTimeDateFormat(const Calendar cal, const Locale locale, UErrorCode &status) const
	{
	UnicodeString *result = NULL;
	const char *type = cal->getType();
	const char *base = locale->getBaseName();
	UResourceBundle topBundle = ures_open((char ) 0, base, &status);
	UResourceBundle *calBundle = ures_getByKey(topBundle, "calendar", NULL, &status);
	UResourceBundle *typBundle = ures_getByKeyWithFallback(calBundle, type, NULL, &status);
	UResourceBundle *patBundle = ures_getByKeyWithFallback(typBundle, "DateTimePatterns", NULL, &status);

	if (status == U_MISSING_RESOURCE_ERROR) {
	status = U_ZERO_ERROR;
	typBundle = ures_getByKeyWithFallback(calBundle, "gregorian", typBundle, &status);
	patBundle = ures_getByKeyWithFallback(typBundle, "DateTimePatterns", patBundle, &status);
	}

	if (U_FAILURE(status)) {
	static const UChar defaultPattern[] = {0x007B, 0x0031, 0x007D, 0x0020, 0x007B, 0x0030, 0x007D, 0x0000}; // "{1} {0}"
	return new UnicodeString(defaultPattern, UPRV_LENGTHOF(defaultPattern));
	}

	int32_t resStrLen = 0;
	int32_t glueIndex = DateFormat::kDateTime;
	int32_t patSize = ures_getSize(patBundle);
	if (patSize >= (DateFormat::kDateTimeOffset + DateFormat::kShort + 1)) {
	// Get proper date time format
	glueIndex = (int32_t)(DateFormat::kDateTimeOffset + (fDateStyle - DateFormat::kDateOffset));
	}
	const UChar *resStr = ures_getStringByIndex(patBundle, glueIndex, &resStrLen, &status);

	result = new UnicodeString(TRUE, resStr, resStrLen);

	ures_close(patBundle);
	ures_close(typBundle);
	ures_close(calBundle);
	ures_close(topBundle);

	return result;
	}

	// TODO: This is copied in both winnmfmt.cpp and windtfmt.cpp, but really should
	// be factored out into a common helper for both.
	static UErrorCode GetEquivalentWindowsLocaleName(const Locale& locale, UnicodeString** buffer)
	{
	UErrorCode status = U_ZERO_ERROR;
	char asciiBCP47Tag[LOCALE_NAME_MAX_LENGTH] = {};

	// Convert from names like "en_CA" and "de_DE@collation=phonebook" to "en-CA" and "de-DE-u-co-phonebk".
	(void)uloc_toLanguageTag(locale.getName(), asciiBCP47Tag, UPRV_LENGTHOF(asciiBCP47Tag), FALSE, &status);

	if (U_SUCCESS(status))
	{
	// Need it to be UTF-16, not 8-bit
	// TODO: This seems like a good thing for a helper
	wchar_t bcp47Tag[LOCALE_NAME_MAX_LENGTH] = {};
	int32_t i;
	for (i = 0; i < UPRV_LENGTHOF(bcp47Tag); i++)
	{
	if (asciiBCP47Tag[i] == '\0')
	{
	break;
	}
	else
	{
	// normally just copy the character
	bcp47Tag[i] = static_cast<wchar_t>(asciiBCP47Tag[i]);
	}
	}

	// Ensure it's null terminated
	if (i < (UPRV_LENGTHOF(bcp47Tag) - 1))
	{
	bcp47Tag[i] = L'\0';
	}
	else
	{
	// Ran out of room.
	bcp47Tag[UPRV_LENGTHOF(bcp47Tag) - 1] = L'\0';
	}


	wchar_t windowsLocaleName[LOCALE_NAME_MAX_LENGTH] = {};

	// Note: On Windows versions below 10, there is no support for locale name aliases.
	// This means that it will fail for locales where ICU has a completely different
	// name (like ku vs ckb), and it will also not work for alternate sort locale
	// names like "de-DE-u-co-phonebk".

	// TODO: We could add some sort of exception table for cases like ku vs ckb.

	int length = ResolveLocaleName(bcp47Tag, windowsLocaleName, UPRV_LENGTHOF(windowsLocaleName));

	if (length > 0)
	{
	*buffer = new UnicodeString(windowsLocaleName);
	}
	else
	{
	status = U_UNSUPPORTED_ERROR;
	}
	}
	return status;
	}

	// TODO: Range-check timeStyle, dateStyle
	Win32DateFormat::Win32DateFormat(DateFormat::EStyle timeStyle, DateFormat::EStyle dateStyle, const Locale &locale, UErrorCode &status)
	: DateFormat(), fDateTimeMsg(NULL), fTimeStyle(timeStyle), fDateStyle(dateStyle), fLocale(locale), fZoneID(), fWindowsLocaleName(nullptr)
	{
	if (U_SUCCESS(status)) {
	GetEquivalentWindowsLocaleName(locale, &fWindowsLocaleName);
	// Note: In the previous code, it would look up the LCID for the locale, and if
	// the locale was not recognized then it would get an LCID of 0, which is a
	// synonym for LOCALE_USER_DEFAULT on Windows.
	// If the above method fails, then fWindowsLocaleName will remain as nullptr, and
	// then we will pass nullptr to API GetLocaleInfoEx, which is the same as passing
	// LOCALE_USER_DEFAULT.

	fTZI = NEW_ARRAY(TIME_ZONE_INFORMATION, 1);
	uprv_memset(fTZI, 0, sizeof(TIME_ZONE_INFORMATION));
	adoptCalendar(Calendar::createInstance(locale, status));
	}
	}

	Win32DateFormat::Win32DateFormat(const Win32DateFormat &other)
	: DateFormat(other)
	{
	*this = other;
	}

	Win32DateFormat::~Win32DateFormat()
	{
	// delete fCalendar;
	uprv_free(fTZI);
	delete fDateTimeMsg;
	delete fWindowsLocaleName;
	}

	Win32DateFormat &Win32DateFormat::operator=(const Win32DateFormat &other)
	{
	if (this == &other) { return *this; } // self-assignment: no-op
	// The following handles fCalendar
	DateFormat::operator=(other);

	// delete fCalendar;

	this->fDateTimeMsg = other.fDateTimeMsg == NULL ? NULL : new UnicodeString(*other.fDateTimeMsg);
	this->fTimeStyle = other.fTimeStyle;
	this->fDateStyle = other.fDateStyle;
	this->fLocale = other.fLocale;
	// this->fCalendar = other.fCalendar->clone();
	this->fZoneID = other.fZoneID;

	this->fTZI = NEW_ARRAY(TIME_ZONE_INFORMATION, 1);
	this->fTZI = other.fTZI;

	this->fWindowsLocaleName = other.fWindowsLocaleName == NULL ? NULL : new UnicodeString(*other.fWindowsLocaleName);

	return *this;
	}

	Win32DateFormat *Win32DateFormat::clone() const
	{
	return new Win32DateFormat(*this);
	}

	// TODO: Is just ignoring pos the right thing?
	UnicodeString &Win32DateFormat::format(Calendar &cal, UnicodeString &appendTo, FieldPosition & /* pos */) const
	{
	FILETIME ft;
	SYSTEMTIME st_gmt;
	SYSTEMTIME st_local;
	TIME_ZONE_INFORMATION tzi = *fTZI;
	UErrorCode status = U_ZERO_ERROR;
	const TimeZone &tz = cal.getTimeZone();
	int64_t uct, uft;

	setTimeZoneInfo(&tzi, tz);

	uct = utmscale_fromInt64((int64_t) cal.getTime(status), UDTS_ICU4C_TIME, &status);
	uft = utmscale_toInt64(uct, UDTS_WINDOWS_FILE_TIME, &status);

	ft.dwLowDateTime = (DWORD) (uft & 0xFFFFFFFF);
	ft.dwHighDateTime = (DWORD) ((uft >> 32) & 0xFFFFFFFF);

	FileTimeToSystemTime(&ft, &st_gmt);
	SystemTimeToTzSpecificLocalTime(&tzi, &st_gmt, &st_local);


	if (fDateStyle != DateFormat::kNone && fTimeStyle != DateFormat::kNone) {
	UnicodeString date;
	UnicodeString time;
	UnicodeString *pattern = fDateTimeMsg;

	formatDate(&st_local, date);
	formatTime(&st_local, time);

	if (strcmp(fCalendar->getType(), cal.getType()) != 0) {
	pattern = getTimeDateFormat(&cal, &fLocale, status);
	}

	SimpleFormatter(*pattern, 2, 2, status).format(time, date, appendTo, status);
	} else if (fDateStyle != DateFormat::kNone) {
	formatDate(&st_local, appendTo);
	} else if (fTimeStyle != DateFormat::kNone) {
	formatTime(&st_local, appendTo);
	}

	return appendTo;
	}

	void Win32DateFormat::parse(const UnicodeString& /* text /, Calendar& / cal */, ParsePosition& pos) const
	{
	pos.setErrorIndex(pos.getIndex());
	}

	void Win32DateFormat::adoptCalendar(Calendar *newCalendar)
	{
	if (fCalendar == NULL \|\| strcmp(fCalendar->getType(), newCalendar->getType()) != 0) {
	UErrorCode status = U_ZERO_ERROR;

	if (fDateStyle != DateFormat::kNone && fTimeStyle != DateFormat::kNone) {
	delete fDateTimeMsg;
	fDateTimeMsg = getTimeDateFormat(newCalendar, &fLocale, status);
	}
	}

	delete fCalendar;
	fCalendar = newCalendar;

	fZoneID = setTimeZoneInfo(fTZI, fCalendar->getTimeZone());
	}

	void Win32DateFormat::setCalendar(const Calendar &newCalendar)
	{
	adoptCalendar(newCalendar.clone());
	}

	void Win32DateFormat::adoptTimeZone(TimeZone *zoneToAdopt)
	{
	fZoneID = setTimeZoneInfo(fTZI, *zoneToAdopt);
	fCalendar->adoptTimeZone(zoneToAdopt);
	}

	void Win32DateFormat::setTimeZone(const TimeZone& zone)
	{
	fZoneID = setTimeZoneInfo(fTZI, zone);
	fCalendar->setTimeZone(zone);
	}

	static const DWORD dfFlags[] = {DATE_LONGDATE, DATE_LONGDATE, DATE_SHORTDATE, DATE_SHORTDATE};

	void Win32DateFormat::formatDate(const SYSTEMTIME *st, UnicodeString &appendTo) const
	{
	int result=0;
	wchar_t stackBuffer[STACK_BUFFER_SIZE];
	wchar_t *buffer = stackBuffer;
	const wchar_t *localeName = nullptr;

	if (fWindowsLocaleName != nullptr)
	{
	localeName = reinterpret_cast<const wchar_t*>(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer()));
	}

	result = GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, buffer, STACK_BUFFER_SIZE, NULL);

	if (result == 0) {
	if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
	int newLength = GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, NULL, 0, NULL);

	buffer = NEW_ARRAY(wchar_t, newLength);

	GetDateFormatEx(localeName, dfFlags[fDateStyle - kDateOffset], st, NULL, buffer, newLength, NULL);
	}
	}

	appendTo.append((const UChar *)buffer, (int32_t) wcslen(buffer));

	if (buffer != stackBuffer) {
	DELETE_ARRAY(buffer);
	}
	}

	static const DWORD tfFlags[] = {0, 0, 0, TIME_NOSECONDS};

	void Win32DateFormat::formatTime(const SYSTEMTIME *st, UnicodeString &appendTo) const
	{
	int result;
	wchar_t stackBuffer[STACK_BUFFER_SIZE];
	wchar_t *buffer = stackBuffer;
	const wchar_t *localeName = nullptr;

	if (fWindowsLocaleName != nullptr)
	{
	localeName = reinterpret_cast<const wchar_t*>(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer()));
	}

	result = GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, buffer, STACK_BUFFER_SIZE);

	if (result == 0) {
	if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
	int newLength = GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, NULL, 0);

	buffer = NEW_ARRAY(wchar_t, newLength);

	GetTimeFormatEx(localeName, tfFlags[fTimeStyle], st, NULL, buffer, newLength);
	}
	}

	appendTo.append((const UChar *)buffer, (int32_t) wcslen(buffer));

	if (buffer != stackBuffer) {
	DELETE_ARRAY(buffer);
	}
	}

	UnicodeString Win32DateFormat::setTimeZoneInfo(TIME_ZONE_INFORMATION *tzi, const TimeZone &zone) const
	{
	UnicodeString zoneID;

	zone.getID(zoneID);

	if (zoneID.compare(fZoneID) != 0) {
	UnicodeString icuid;

	zone.getID(icuid);
	if (! uprv_getWindowsTimeZoneInfo(tzi, icuid.getBuffer(), icuid.length())) {
	UBool found = FALSE;
	int32_t ec = TimeZone::countEquivalentIDs(icuid);

	for (int z = 0; z < ec; z += 1) {
	UnicodeString equiv = TimeZone::getEquivalentID(icuid, z);

	found = uprv_getWindowsTimeZoneInfo(tzi, equiv.getBuffer(), equiv.length());
	if (found) {
	break;
	}
	}

	if (! found) {
	GetTimeZoneInformation(tzi);
	}
	}
	}

	return zoneID;
	}

	U_NAMESPACE_END

	#endif /* #if !UCONFIG_NO_FORMATTING */

	#endif // U_PLATFORM_USES_ONLY_WIN32_API