CFDateFormatter.c

/*
 * Copyright (c) 2008-2009 Brent Fulgham <bfulgham@gmail.org>.  All rights reserved.
 *
 * This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
 * the terms of the APSL version 2.0 (see below).
 *
 * For information about changes from the original Apple source release can be found by reviewing the
 * source control system for the project at https://sourceforge.net/svn/?group_id=246198.
 *
 * The original license information is as follows:
 * 
 * Copyright (c) 2008 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*	CFDateFormatter.c
	Copyright 2002-2003, Apple, Inc. All rights reserved.
	Responsibility: Christopher Kane
*/

#include <CoreFoundation/CFDateFormatter.h>
#include <CoreFoundation/CFDate.h>
#include <CoreFoundation/CFTimeZone.h>
#include <CoreFoundation/CFCalendar.h>
#include <CoreFoundation/CFNumber.h>
#include "CFInternal.h"
#include <unicode/udat.h>
#include <math.h>
#include <float.h>

extern UCalendar *__CFCalendarCreateUCalendar(CFStringRef calendarID, CFStringRef localeID, CFTimeZoneRef tz);
#ifdef DEPLOYMENT_TARGET_WINDOWS
extern CFAbsoluteTime __CFDateWindowsSystemTimeToAbsoluteTime(SYSTEMTIME *time);
#endif
static void __CFDateFormatterCustomize(CFDateFormatterRef formatter);

CF_EXPORT const CFStringRef kCFDateFormatterCalendarIdentifier;

#define BUFFER_SIZE 768

struct __CFDateFormatter {
    CFRuntimeBase _base;
    UDateFormat *_df;
    CFLocaleRef _locale;
    CFDateFormatterStyle _timeStyle;
    CFDateFormatterStyle _dateStyle;
    CFStringRef _format;
    CFStringRef _defformat;
    CFStringRef _calendarName;
    CFTimeZoneRef _tz;
    CFDateRef _defaultDate;
};

static CFStringRef __CFDateFormatterCopyDescription(CFTypeRef cf) {
    CFDateFormatterRef formatter = (CFDateFormatterRef)cf;
    return CFStringCreateWithFormat(CFGetAllocator(formatter), NULL, CFSTR("<CFDateFormatter %p [%p]>"), cf, CFGetAllocator(formatter));
}

static void __CFDateFormatterDeallocate(CFTypeRef cf) {
    CFDateFormatterRef formatter = (CFDateFormatterRef)cf;
    if (formatter->_df) udat_close(formatter->_df);
    if (formatter->_locale) CFRelease(formatter->_locale);
    if (formatter->_format) CFRelease(formatter->_format);
    if (formatter->_defformat) CFRelease(formatter->_defformat);
    if (formatter->_calendarName) CFRelease(formatter->_calendarName);
    if (formatter->_tz) CFRelease(formatter->_tz);
    if (formatter->_defaultDate) CFRelease(formatter->_defaultDate);
}

static CFTypeID __kCFDateFormatterTypeID = _kCFRuntimeNotATypeID;

static const CFRuntimeClass __CFDateFormatterClass = {
    0,
    "CFDateFormatter",
    NULL,	// init
    NULL,	// copy
    __CFDateFormatterDeallocate,
    NULL,
    NULL,
    NULL,	// 
    __CFDateFormatterCopyDescription
};

static void __CFDateFormatterInitialize(void) {
    __kCFDateFormatterTypeID = _CFRuntimeRegisterClass(&__CFDateFormatterClass);
}

CFTypeID CFDateFormatterGetTypeID(void) {
    if (_kCFRuntimeNotATypeID == __kCFDateFormatterTypeID) __CFDateFormatterInitialize();
    return __kCFDateFormatterTypeID;
}

CFDateFormatterRef CFDateFormatterCreate(CFAllocatorRef allocator, CFLocaleRef locale, CFDateFormatterStyle dateStyle, CFDateFormatterStyle timeStyle) {
    struct __CFDateFormatter *memory;
    uint32_t size = sizeof(struct __CFDateFormatter) - sizeof(CFRuntimeBase);
    if (allocator == NULL) allocator = __CFGetDefaultAllocator();
    __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
    if (locale) __CFGenericValidateType(locale, CFLocaleGetTypeID());
    memory = (struct __CFDateFormatter *)_CFRuntimeCreateInstance(allocator, CFDateFormatterGetTypeID(), size, NULL);
    if (NULL == memory) {
	return NULL;
    }
    memory->_df = NULL;
    memory->_locale = NULL;
    memory->_format = NULL;
    memory->_defformat = NULL;
    memory->_calendarName = NULL;
    memory->_tz = NULL;
    memory->_defaultDate = NULL;
    if (NULL == locale) locale = CFLocaleGetSystem();
    memory->_dateStyle = dateStyle;
    memory->_timeStyle = timeStyle;
    int32_t udstyle, utstyle;
    switch (dateStyle) {
    case kCFDateFormatterNoStyle: udstyle = UDAT_NONE; break;
    case kCFDateFormatterShortStyle: udstyle = UDAT_SHORT; break;
    case kCFDateFormatterMediumStyle: udstyle = UDAT_MEDIUM; break;
    case kCFDateFormatterLongStyle: udstyle = UDAT_LONG; break;
    case kCFDateFormatterFullStyle: udstyle = UDAT_FULL; break;
    default:
	CFAssert2(0, __kCFLogAssertion, "%s(): unknown date style %d", __PRETTY_FUNCTION__, dateStyle);
	udstyle = UDAT_MEDIUM;
	memory->_dateStyle = kCFDateFormatterMediumStyle;
	break;
    }
    switch (timeStyle) {
    case kCFDateFormatterNoStyle: utstyle = UDAT_NONE; break;
    case kCFDateFormatterShortStyle: utstyle = UDAT_SHORT; break;
    case kCFDateFormatterMediumStyle: utstyle = UDAT_MEDIUM; break;
    case kCFDateFormatterLongStyle: utstyle = UDAT_LONG; break;
    case kCFDateFormatterFullStyle: utstyle = UDAT_FULL; break;
    default:
	CFAssert2(0, __kCFLogAssertion, "%s(): unknown time style %d", __PRETTY_FUNCTION__, timeStyle);
	utstyle = UDAT_MEDIUM;
	memory->_timeStyle = kCFDateFormatterMediumStyle;
	break;
    }
    CFStringRef localeName = locale ? CFLocaleGetIdentifier(locale) : CFSTR("");
    char buffer[BUFFER_SIZE];
    const char *cstr = CFStringGetCStringPtr(localeName, kCFStringEncodingASCII);
    if (NULL == cstr) {
        if (CFStringGetCString(localeName, buffer, BUFFER_SIZE, kCFStringEncodingASCII)) cstr = buffer;
    }
    if (NULL == cstr) {
        CFRelease(memory);
        return NULL;
    }
    UChar ubuffer[BUFFER_SIZE];
    memset(ubuffer, 0x00, sizeof(UChar) * BUFFER_SIZE);
    memory->_tz = CFTimeZoneCopyDefault();
#ifdef DEPLOYMENT_TARGET_WINDOWS
    // ICU doesn't know about Windows Time Zone names.  It'll understand the abbreviation for the non-daylight saving time, though
    TIME_ZONE_INFORMATION *tzi = (TIME_ZONE_INFORMATION *)CFDataGetBytePtr(CFTimeZoneGetData(memory->_tz));
    CFAbsoluteTime at = __CFDateWindowsSystemTimeToAbsoluteTime(&tzi->DaylightDate);
    // subtract a day to get us off the time change boundary
    at -= (60 * 60 * 24);
    CFStringRef tznam = CFTimeZoneCopyAbbreviation(memory->_tz, at);
#else
    CFStringRef tznam = CFTimeZoneGetName(memory->_tz);
#endif
    CFIndex cnt = CFStringGetLength(tznam);
    if (BUFFER_SIZE < cnt) cnt = BUFFER_SIZE;
    CFStringGetCharacters(tznam, CFRangeMake(0, cnt), (UniChar *)ubuffer);
    UErrorCode status = U_ZERO_ERROR;
    memory->_df = udat_open((UDateFormatStyle)utstyle, (UDateFormatStyle)udstyle, cstr, ubuffer, cnt, NULL, 0, &status);
    CFAssert2(memory->_df, __kCFLogAssertion, "%s(): error (%d) creating date formatter", __PRETTY_FUNCTION__, status);
    if (NULL == memory->_df) {
	CFRelease(memory->_tz);
	CFRelease(memory);
	return NULL;
    }
    udat_setLenient(memory->_df, 0);
    if (kCFDateFormatterNoStyle == dateStyle && kCFDateFormatterNoStyle == timeStyle) {
	udat_applyPattern(memory->_df, false, NULL, 0);
    }
    CFTypeRef calident = CFLocaleGetValue(locale, kCFLocaleCalendarIdentifier);
    if (calident && CFEqual(calident, kCFGregorianCalendar)) {
	status = U_ZERO_ERROR;
	udat_set2DigitYearStart(memory->_df, -631152000000.0, &status); // 1950-01-01 00:00:00 GMT
    }
    memory->_locale = locale ? CFLocaleCreateCopy(allocator, locale) : CFLocaleGetSystem();
    __CFDateFormatterCustomize(memory);
    status = U_ZERO_ERROR;
    int32_t ret = udat_toPattern(memory->_df, false, ubuffer, BUFFER_SIZE, &status);
    if (U_SUCCESS(status) && ret <= BUFFER_SIZE) {
	memory->_format = CFStringCreateWithCharacters(allocator, (const UniChar *)ubuffer, ret);
    }
    memory->_defformat = memory->_format ? (CFStringRef)CFRetain(memory->_format) : NULL;
    return (CFDateFormatterRef)memory;
}

extern CFDictionaryRef __CFLocaleGetPrefs(CFLocaleRef locale);

static void __substituteFormatStringFromPrefsDF(CFDateFormatterRef formatter, bool doTime) {
    CFIndex formatStyle = doTime ? formatter->_timeStyle : formatter->_dateStyle;
    CFStringRef prefName = doTime ? CFSTR("AppleICUTimeFormatStrings") : CFSTR("AppleICUDateFormatStrings");
    if (kCFDateFormatterNoStyle != formatStyle) {
        CFStringRef pref = NULL;
        CFDictionaryRef prefs = __CFLocaleGetPrefs(formatter->_locale);
        CFPropertyListRef metapref = prefs ? CFDictionaryGetValue(prefs, prefName) : NULL;
        if (NULL != metapref && CFGetTypeID(metapref) == CFDictionaryGetTypeID()) {
            CFStringRef key;
            switch (formatStyle) {
                case kCFDateFormatterShortStyle: key = CFSTR("1"); break;
                case kCFDateFormatterMediumStyle: key = CFSTR("2"); break;
                case kCFDateFormatterLongStyle: key = CFSTR("3"); break;
                case kCFDateFormatterFullStyle: key = CFSTR("4"); break;
                default: key = CFSTR("0"); break;
            }
            pref = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)metapref, key);
        }
        if (NULL != pref && CFGetTypeID(pref) == CFStringGetTypeID()) {
            int32_t icustyle = UDAT_NONE;
            switch (formatStyle) {
                case kCFDateFormatterShortStyle: icustyle = UDAT_SHORT; break;
                case kCFDateFormatterMediumStyle: icustyle = UDAT_MEDIUM; break;
                case kCFDateFormatterLongStyle: icustyle = UDAT_LONG; break;
                case kCFDateFormatterFullStyle: icustyle = UDAT_FULL; break;
            }
            CFStringRef localeName = CFLocaleGetIdentifier(formatter->_locale);
            char buffer[BUFFER_SIZE];
            const char *cstr = CFStringGetCStringPtr(localeName, kCFStringEncodingASCII);
            if (NULL == cstr) {
                if (CFStringGetCString(localeName, buffer, BUFFER_SIZE, kCFStringEncodingASCII)) cstr = buffer;
            }
            UErrorCode status = U_ZERO_ERROR;
            UDateFormat *df = udat_open((UDateFormatStyle)(doTime ? icustyle : UDAT_NONE), (UDateFormatStyle)(doTime ? UDAT_NONE : icustyle), cstr, NULL, 0, NULL, 0, &status);
            if (NULL != df) {
                UChar ubuffer[BUFFER_SIZE];
                status = U_ZERO_ERROR;
                int32_t date_len = udat_toPattern(df, false, ubuffer, BUFFER_SIZE, &status);
                if (U_SUCCESS(status) && date_len <= BUFFER_SIZE) {
                    CFStringRef dateString = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (UniChar *)ubuffer, date_len);
                    status = U_ZERO_ERROR;
                    int32_t formatter_len = udat_toPattern(formatter->_df, false, ubuffer, BUFFER_SIZE, &status);
                    if (U_SUCCESS(status) && formatter_len <= BUFFER_SIZE) {
                        CFMutableStringRef formatString = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);
                        CFStringAppendCharacters(formatString, (UniChar *)ubuffer, formatter_len);
                        // find dateString inside formatString, substitute the pref in that range
                        CFRange result;
                        if (CFStringFindWithOptions(formatString, dateString, CFRangeMake(0, formatter_len), 0, &result)) {
                            CFStringReplace(formatString, result, pref);
                            int32_t new_len = CFStringGetLength(formatString);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
                            STACK_BUFFER_DECL(UChar, new_buffer, new_len);
#else
                            UChar new_buffer[BUFFER_SIZE]; // Dynamic stack allocation is GNU specific
#endif
                            const UChar *new_ustr = (UChar *)CFStringGetCharactersPtr(formatString);
                            if (NULL == new_ustr) {
                                CFStringGetCharacters(formatString, CFRangeMake(0, new_len), (UniChar *)new_buffer);
                                new_ustr = new_buffer;
                            }
                            status = U_ZERO_ERROR;
//	                         udat_applyPattern(formatter->_df, false, new_ustr, new_len, &status);
                            udat_applyPattern(formatter->_df, false, new_ustr, new_len);
                        }
                        CFRelease(formatString);
                    }
                    CFRelease(dateString);
                }
                udat_close(df);
            }
        }
    }
}

static void __CFDateFormatterApplySymbolPrefs(const void *key, const void *value, void *context) {
    if (CFGetTypeID(key) == CFStringGetTypeID() && CFGetTypeID(value) == CFArrayGetTypeID()) {
        CFDateFormatterRef formatter = (CFDateFormatterRef)context;
        UDateFormatSymbolType sym = (UDateFormatSymbolType)CFStringGetIntValue((CFStringRef)key);
        CFArrayRef array = (CFArrayRef)value;
        CFIndex idx, cnt = CFArrayGetCount(array);
        for (idx = 0; idx < cnt; idx++) {
            CFStringRef item = (CFStringRef)CFArrayGetValueAtIndex(array, idx);
            if (CFGetTypeID(item) != CFStringGetTypeID()) continue;
            CFIndex item_cnt = CFStringGetLength(item);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
	         STACK_BUFFER_DECL(UChar, item_buffer, __CFMin(BUFFER_SIZE, item_cnt));
#else
            UChar item_buffer[BUFFER_SIZE]; // Dynamic stack allocation is GNU specific
#endif
            UChar *item_ustr = (UChar *)CFStringGetCharactersPtr(item);
            if (NULL == item_ustr) {
                item_cnt = __CFMin(BUFFER_SIZE, item_cnt);
                CFStringGetCharacters(item, CFRangeMake(0, item_cnt), (UniChar *)item_buffer);
                item_ustr = item_buffer;
            }
            UErrorCode status = U_ZERO_ERROR;
            udat_setSymbols(formatter->_df, sym, idx, item_ustr, item_cnt, &status);
        }
    }
}

static void __CFDateFormatterCustomize(CFDateFormatterRef formatter) {
    __substituteFormatStringFromPrefsDF(formatter, false);
    __substituteFormatStringFromPrefsDF(formatter, true);
    CFDictionaryRef prefs = __CFLocaleGetPrefs(formatter->_locale);
    CFPropertyListRef metapref = prefs ? CFDictionaryGetValue(prefs, CFSTR("AppleICUDateTimeSymbols")) : NULL;
    if (NULL != metapref && CFGetTypeID(metapref) == CFDictionaryGetTypeID()) {
	CFDictionaryApplyFunction((CFDictionaryRef)metapref, __CFDateFormatterApplySymbolPrefs, formatter);
    }
}

CFLocaleRef CFDateFormatterGetLocale(CFDateFormatterRef formatter) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    return formatter->_locale;
}

CFDateFormatterStyle CFDateFormatterGetDateStyle(CFDateFormatterRef formatter) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    return formatter->_dateStyle;
}

CFDateFormatterStyle CFDateFormatterGetTimeStyle(CFDateFormatterRef formatter) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    return formatter->_timeStyle;
}

CFStringRef CFDateFormatterGetFormat(CFDateFormatterRef formatter) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    return formatter->_format;
}

void CFDateFormatterSetFormat(CFDateFormatterRef formatter, CFStringRef formatString) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(formatString, CFStringGetTypeID());
    CFIndex cnt = CFStringGetLength(formatString);
    CFAssert1(cnt <= 1024, __kCFLogAssertion, "%s(): format string too long", __PRETTY_FUNCTION__);
    if (formatter->_format != formatString && cnt <= 1024) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
        STACK_BUFFER_DECL(UChar, ubuffer, cnt);
#else
        UChar ubuffer[BUFFER_SIZE]; // Dynamic stack allocation is GNU specific
#endif
        const UChar *ustr = (UChar *)CFStringGetCharactersPtr((CFStringRef)formatString);
        if (NULL == ustr) {
            CFStringGetCharacters(formatString, CFRangeMake(0, cnt), (UniChar *)ubuffer);
            ustr = ubuffer;
        }
        UErrorCode status = U_ZERO_ERROR;
//	     udat_applyPattern(formatter->_df, false, ustr, cnt, &status);
        udat_applyPattern(formatter->_df, false, ustr, cnt);
        if (U_SUCCESS(status)) {
            if (formatter->_format) CFRelease(formatter->_format);
            formatter->_format = (CFStringRef)CFStringCreateCopy(CFGetAllocator(formatter), formatString);
        }
    }
}

CFStringRef CFDateFormatterCreateStringWithDate(CFAllocatorRef allocator, CFDateFormatterRef formatter, CFDateRef date) {
    if (allocator == NULL) allocator = __CFGetDefaultAllocator();
    __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(date, CFDateGetTypeID());
    return CFDateFormatterCreateStringWithAbsoluteTime(allocator, formatter, CFDateGetAbsoluteTime(date));
}

CFStringRef CFDateFormatterCreateStringWithAbsoluteTime(CFAllocatorRef allocator, CFDateFormatterRef formatter, CFAbsoluteTime at) {
    if (allocator == NULL) allocator = __CFGetDefaultAllocator();
    __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    UChar *ustr = NULL, ubuffer[BUFFER_SIZE];
    UErrorCode status = U_ZERO_ERROR;
    CFIndex used, cnt = BUFFER_SIZE;
    UDate ud = (at + kCFAbsoluteTimeIntervalSince1970) * 1000.0 + 0.5;
    used = udat_format(formatter->_df, ud, ubuffer, cnt, NULL, &status);
    if (status == U_BUFFER_OVERFLOW_ERROR || cnt < used) {
	cnt = used + 1;
	ustr = (UChar *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(UChar) * cnt, 0);
	status = U_ZERO_ERROR;
	used = udat_format(formatter->_df, ud, ustr, cnt, NULL, &status);
    }
    CFStringRef string = NULL;
    if (U_SUCCESS(status)) {
	string = CFStringCreateWithCharacters(allocator, (const UniChar *)(ustr ? ustr : ubuffer), used);
    }
    if (ustr) CFAllocatorDeallocate(kCFAllocatorSystemDefault, ustr);
    return string;
}

CFDateRef CFDateFormatterCreateDateFromString(CFAllocatorRef allocator, CFDateFormatterRef formatter, CFStringRef string, CFRange *rangep) {
    if (allocator == NULL) allocator = __CFGetDefaultAllocator();
    __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(string, CFStringGetTypeID());
    CFAbsoluteTime at;
    if (CFDateFormatterGetAbsoluteTimeFromString(formatter, string, rangep, &at)) {
	return CFDateCreate(allocator, at);
    }
    return NULL;
}

Boolean CFDateFormatterGetAbsoluteTimeFromString(CFDateFormatterRef formatter, CFStringRef string, CFRange *rangep, CFAbsoluteTime *atp) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(string, CFStringGetTypeID());
    CFRange range = {0, 0};
    if (rangep) {
       range = *rangep;
    } else {
        range.length = CFStringGetLength(string);
    }
    if (1024 < range.length) range.length = 1024;
    const UChar *ustr = (UChar *)CFStringGetCharactersPtr(string);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
    STACK_BUFFER_DECL(UChar, ubuffer, (NULL == ustr) ? range.length : 1);
#else
    UChar ubuffer[BUFFER_SIZE]; // Dynamic stack allocation is GNU specific
#endif
    if (NULL == ustr) {
        CFStringGetCharacters(string, range, (UniChar *)ubuffer);
        ustr = ubuffer;
    } else {
        ustr += range.location;
    }
    UDate udate;
    int32_t dpos = 0;
    UErrorCode status = U_ZERO_ERROR;
    if (formatter->_defaultDate) {
        CFAbsoluteTime at = CFDateGetAbsoluteTime(formatter->_defaultDate);
        udate = (at + kCFAbsoluteTimeIntervalSince1970) * 1000.0;
        UDateFormat *df2 = udat_clone(formatter->_df, &status);
        UCalendar *cal2 = (UCalendar *)udat_getCalendar(df2);
        ucal_setMillis(cal2, udate, &status);
        udat_parseCalendar(formatter->_df, cal2, ustr, range.length, &dpos, &status);
        udate = ucal_getMillis(cal2, &status);
        udat_close(df2);
    } else {
        udate = udat_parse(formatter->_df, ustr, range.length, &dpos, &status);
    }
    if (rangep) rangep->length = dpos;
    if (U_FAILURE(status)) {
        return false;
    }
    if (atp) {
        *atp = (double)udate / 1000.0 - kCFAbsoluteTimeIntervalSince1970;
    }
    return true;
}

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
#define SET_SYMBOLS_ARRAY(ICU_CODE, INDEX_BASE) \
        __CFGenericValidateType(value, CFArrayGetTypeID()); \
	CFArrayRef array = (CFArrayRef)value; \
	CFIndex idx, cnt = CFArrayGetCount(array); \
	for (idx = 0; idx < cnt; idx++) { \
	    CFStringRef item = (CFStringRef)CFArrayGetValueAtIndex(array, idx); \
	    __CFGenericValidateType(item, CFStringGetTypeID()); \
	    CFIndex item_cnt = CFStringGetLength(item); \
	    STACK_BUFFER_DECL(UChar, item_buffer, __CFMin(BUFFER_SIZE, item_cnt)); \
	    UChar *item_ustr = (UChar *)CFStringGetCharactersPtr(item); \
	    if (NULL == item_ustr) { \
		item_cnt = __CFMin(BUFFER_SIZE, item_cnt); \
	        CFStringGetCharacters(item, CFRangeMake(0, item_cnt), (UniChar *)item_buffer); \
		item_ustr = item_buffer; \
	    } \
	    status = U_ZERO_ERROR; \
	    udat_setSymbols(formatter->_df, ICU_CODE, idx + INDEX_BASE, item_ustr, item_cnt, &status); \
	}
#else
#define SET_SYMBOLS_ARRAY(ICU_CODE, INDEX_BASE) \
        __CFGenericValidateType(value, CFArrayGetTypeID()); \
	CFArrayRef array = (CFArrayRef)value; \
	CFIndex idx, cnt = CFArrayGetCount(array); \
	for (idx = 0; idx < cnt; idx++) { \
	    CFStringRef item = (CFStringRef)CFArrayGetValueAtIndex(array, idx); \
	    __CFGenericValidateType(item, CFStringGetTypeID()); \
	    CFIndex item_cnt = CFStringGetLength(item); \
       UChar item_buffer[BUFFER_SIZE]; \
	    UChar *item_ustr = (UChar *)CFStringGetCharactersPtr(item); \
	    if (NULL == item_ustr) { \
		item_cnt = __CFMin(BUFFER_SIZE, item_cnt); \
	        CFStringGetCharacters(item, CFRangeMake(0, item_cnt), (UniChar *)item_buffer); \
		item_ustr = item_buffer; \
	    } \
	    status = U_ZERO_ERROR; \
	    udat_setSymbols(formatter->_df, ICU_CODE, idx + INDEX_BASE, item_ustr, item_cnt, &status); \
	}
#endif


void CFDateFormatterSetProperty(CFDateFormatterRef formatter, CFStringRef key, CFTypeRef value) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(key, CFStringGetTypeID());
    UErrorCode status = U_ZERO_ERROR;
    UChar ubuffer[BUFFER_SIZE];

    if (kCFDateFormatterIsLenient == key) {
	__CFGenericValidateType(value, CFBooleanGetTypeID());
	udat_setLenient(formatter->_df, (kCFBooleanTrue == value));
    } else if (kCFDateFormatterCalendar == key) {
	__CFGenericValidateType(value, CFCalendarGetTypeID());
	CFStringRef localeName = CFLocaleGetIdentifier(formatter->_locale);
	CFDictionaryRef components = CFLocaleCreateComponentsFromLocaleIdentifier(kCFAllocatorSystemDefault, localeName);
	CFMutableDictionaryRef mcomponents = CFDictionaryCreateMutableCopy(kCFAllocatorSystemDefault, 0, components);
	CFDictionarySetValue(mcomponents, kCFLocaleCalendarIdentifier, CFCalendarGetIdentifier((CFCalendarRef)value));
	localeName = CFLocaleCreateLocaleIdentifierFromComponents(kCFAllocatorSystemDefault, mcomponents);
	CFRelease(mcomponents);
	CFRelease(components);
	CFLocaleRef newLocale = CFLocaleCreate(CFGetAllocator(formatter->_locale), localeName);
	CFRelease(localeName);
	CFRelease(formatter->_locale);
	formatter->_locale = newLocale;
	UCalendar *cal = __CFCalendarCreateUCalendar(NULL, CFLocaleGetIdentifier(formatter->_locale), formatter->_tz);
	if (cal) udat_setCalendar(formatter->_df, cal);
	if (cal) ucal_close(cal);
    } else if (kCFDateFormatterCalendarIdentifier == key || kCFDateFormatterCalendarName == key) {
	__CFGenericValidateType(value, CFStringGetTypeID());
	CFStringRef localeName = CFLocaleGetIdentifier(formatter->_locale);
	CFDictionaryRef components = CFLocaleCreateComponentsFromLocaleIdentifier(kCFAllocatorSystemDefault, localeName);
	CFMutableDictionaryRef mcomponents = CFDictionaryCreateMutableCopy(kCFAllocatorSystemDefault, 0, components);
	CFDictionarySetValue(mcomponents, kCFLocaleCalendarIdentifier, value);
	localeName = CFLocaleCreateLocaleIdentifierFromComponents(kCFAllocatorSystemDefault, mcomponents);
	CFRelease(mcomponents);
	CFRelease(components);
	CFLocaleRef newLocale = CFLocaleCreate(CFGetAllocator(formatter->_locale), localeName);
	CFRelease(localeName);
	CFRelease(formatter->_locale);
	formatter->_locale = newLocale;
	UCalendar *cal = __CFCalendarCreateUCalendar(NULL, CFLocaleGetIdentifier(formatter->_locale), formatter->_tz);
	if (cal) udat_setCalendar(formatter->_df, cal);
	if (cal) ucal_close(cal);
    } else if (kCFDateFormatterTimeZone == key) {
	__CFGenericValidateType(value, CFTimeZoneGetTypeID());
	CFTimeZoneRef old = formatter->_tz;
	formatter->_tz = value ? (CFTimeZoneRef)CFRetain(value) : CFTimeZoneCopyDefault();
	if (old) CFRelease(old);
	CFStringRef tznam = CFTimeZoneGetName(formatter->_tz);
	UCalendar *cal = (UCalendar *)udat_getCalendar(formatter->_df);
	CFIndex ucnt = CFStringGetLength(tznam);
	if (BUFFER_SIZE < ucnt) ucnt = BUFFER_SIZE;
	CFStringGetCharacters(tznam, CFRangeMake(0, ucnt), (UniChar *)ubuffer);
	ucal_setTimeZone(cal, ubuffer, ucnt, &status);
    } else if (kCFDateFormatterDefaultFormat == key) {
	// read-only attribute
    } else if (kCFDateFormatterTwoDigitStartDate == key) {
        __CFGenericValidateType(value, CFDateGetTypeID());
	CFAbsoluteTime at = CFDateGetAbsoluteTime((CFDateRef)value);
	UDate udate = (at + kCFAbsoluteTimeIntervalSince1970) * 1000.0;
	udat_set2DigitYearStart(formatter->_df, udate, &status);
    } else if (kCFDateFormatterDefaultDate == key) {
        __CFGenericValidateType(value, CFDateGetTypeID());
	CFDateRef old = formatter->_defaultDate;
	formatter->_defaultDate = value ? (CFDateRef)CFRetain(value) : NULL;
	if (old) CFRelease(old);
    } else if (kCFDateFormatterEraSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_ERAS, 0)
    } else if (kCFDateFormatterMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_MONTHS, 0)
    } else if (kCFDateFormatterShortMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_SHORT_MONTHS, 0)
    } else if (kCFDateFormatterWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_WEEKDAYS, 1)
    } else if (kCFDateFormatterShortWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_SHORT_WEEKDAYS, 1)
    } else if (kCFDateFormatterAMSymbol == key) {
        __CFGenericValidateType(value, CFStringGetTypeID());
	CFIndex item_cnt = CFStringGetLength((CFStringRef)value);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
	STACK_BUFFER_DECL(UChar, item_buffer, __CFMin(BUFFER_SIZE, item_cnt));
#else
   UChar item_buffer[BUFFER_SIZE];
#endif
	UChar *item_ustr = (UChar *)CFStringGetCharactersPtr((CFStringRef)value);
	if (NULL == item_ustr) {
	    item_cnt = __CFMin(BUFFER_SIZE, item_cnt);
	    CFStringGetCharacters((CFStringRef)value, CFRangeMake(0, item_cnt), (UniChar *)item_buffer);
	    item_ustr = item_buffer;
	}
	udat_setSymbols(formatter->_df, UDAT_AM_PMS, 0, item_ustr, item_cnt, &status);
    } else if (kCFDateFormatterPMSymbol == key) {
        __CFGenericValidateType(value, CFStringGetTypeID());
	CFIndex item_cnt = CFStringGetLength((CFStringRef)value);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
	STACK_BUFFER_DECL(UChar, item_buffer, __CFMin(BUFFER_SIZE, item_cnt));
#else
   UChar item_buffer[BUFFER_SIZE];
#endif
	UChar *item_ustr = (UChar *)CFStringGetCharactersPtr((CFStringRef)value);
	if (NULL == item_ustr) {
	    item_cnt = __CFMin(BUFFER_SIZE, item_cnt);
	    CFStringGetCharacters((CFStringRef)value, CFRangeMake(0, item_cnt), (UniChar *)item_buffer);
	    item_ustr = item_buffer;
	}
	udat_setSymbols(formatter->_df, UDAT_AM_PMS, 1, item_ustr, item_cnt, &status);
    } else if (kCFDateFormatterGregorianStartDate == key) {
	__CFGenericValidateType(value, CFDateGetTypeID());
	CFAbsoluteTime at = CFDateGetAbsoluteTime((CFDateRef)value);
	UDate udate = (at + kCFAbsoluteTimeIntervalSince1970) * 1000.0;
	UCalendar *cal = (UCalendar *)udat_getCalendar(formatter->_df);
	ucal_setGregorianChange(cal, udate, &status);
    } else if (kCFDateFormatterLongEraSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_ERA_NAMES, 0)
    } else if (kCFDateFormatterVeryShortMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_NARROW_MONTHS, 0)
    } else if (kCFDateFormatterStandaloneMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_MONTHS, 0)
    } else if (kCFDateFormatterShortStandaloneMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_MONTHS, 0)
    } else if (kCFDateFormatterVeryShortStandaloneMonthSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_NARROW_MONTHS, 0)
    } else if (kCFDateFormatterVeryShortWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_NARROW_WEEKDAYS, 1)
    } else if (kCFDateFormatterStandaloneWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_WEEKDAYS, 1)
    } else if (kCFDateFormatterShortStandaloneWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_WEEKDAYS, 1)
    } else if (kCFDateFormatterVeryShortStandaloneWeekdaySymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_NARROW_WEEKDAYS, 1)
    } else if (kCFDateFormatterQuarterSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_QUARTERS, 1)
    } else if (kCFDateFormatterShortQuarterSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_SHORT_QUARTERS, 1)
    } else if (kCFDateFormatterStandaloneQuarterSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_QUARTERS, 1)
    } else if (kCFDateFormatterShortStandaloneQuarterSymbols == key) {
	SET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_QUARTERS, 1)
    } else {
	CFAssert3(0, __kCFLogAssertion, "%s(): unknown key %p (%@)", __PRETTY_FUNCTION__, key, key);
    }
}

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
#define GET_SYMBOLS_ARRAY(ICU_CODE, INDEX_BASE) \
	CFIndex idx, cnt = udat_countSymbols(formatter->_df, ICU_CODE) - INDEX_BASE; \
	STACK_BUFFER_DECL(CFStringRef, strings, cnt); \
	for (idx = 0; idx < cnt; idx++) { \
	    CFStringRef str = NULL; \
	    status = U_ZERO_ERROR; \
	    CFIndex ucnt = udat_getSymbols(formatter->_df, ICU_CODE, idx + INDEX_BASE, ubuffer, BUFFER_SIZE, &status); \
	    if (U_SUCCESS(status) && cnt <= BUFFER_SIZE) { \
		str = CFStringCreateWithCharacters(CFGetAllocator(formatter), (const UniChar *)ubuffer, ucnt); \
	    } \
	    strings[idx] = !str ? (CFStringRef)CFRetain(CFSTR("<error>")) : str; \
	} \
	CFArrayRef array = CFArrayCreate(CFGetAllocator(formatter), (const void **)strings, cnt, &kCFTypeArrayCallBacks); \
	while (cnt--) { \
	    CFRelease(strings[cnt]); \
	} \
	return array;
#else
#define GET_SYMBOLS_ARRAY(ICU_CODE, INDEX_BASE) \
	CFIndex idx, cnt = udat_countSymbols(formatter->_df, ICU_CODE) - INDEX_BASE; \
	CFStringRef strings[BUFFER_SIZE]; \
	for (idx = 0; idx < cnt; idx++) { \
	    CFStringRef str = NULL; \
	    status = U_ZERO_ERROR; \
	    CFIndex ucnt = udat_getSymbols(formatter->_df, ICU_CODE, idx + INDEX_BASE, ubuffer, BUFFER_SIZE, &status); \
	    if (U_SUCCESS(status) && cnt <= BUFFER_SIZE) { \
		str = CFStringCreateWithCharacters(CFGetAllocator(formatter), (const UniChar *)ubuffer, ucnt); \
	    } \
	    strings[idx] = !str ? (CFStringRef)CFRetain(CFSTR("<error>")) : str; \
	} \
	CFArrayRef array = CFArrayCreate(CFGetAllocator(formatter), (const void **)strings, cnt, &kCFTypeArrayCallBacks); \
	while (cnt--) { \
	    CFRelease(strings[cnt]); \
	} \
	return array;
#endif

CFTypeRef CFDateFormatterCopyProperty(CFDateFormatterRef formatter, CFStringRef key) {
    __CFGenericValidateType(formatter, CFDateFormatterGetTypeID());
    __CFGenericValidateType(key, CFStringGetTypeID());
    UErrorCode status = U_ZERO_ERROR;
    UChar ubuffer[BUFFER_SIZE];

    if (kCFDateFormatterIsLenient == key) {
	return CFRetain(udat_isLenient(formatter->_df) ? kCFBooleanTrue : kCFBooleanFalse);
    } else if (kCFDateFormatterCalendar == key) {
	CFCalendarRef calendar = (CFCalendarRef)CFLocaleGetValue(formatter->_locale, kCFLocaleCalendar);
	return calendar ? CFRetain(calendar) : NULL;
    } else if (kCFDateFormatterCalendarIdentifier == key || kCFDateFormatterCalendarName == key) {
	CFStringRef ident = (CFStringRef)CFLocaleGetValue(formatter->_locale, kCFLocaleCalendarIdentifier);
	return ident ? CFRetain(ident) : NULL;
    } else if (kCFDateFormatterTimeZone == key) {
	return CFRetain(formatter->_tz);
    } else if (kCFDateFormatterDefaultFormat == key) {
	return formatter->_defformat ? CFRetain(formatter->_defformat) : NULL;
    } else if (kCFDateFormatterTwoDigitStartDate == key) {
	UDate udate = udat_get2DigitYearStart(formatter->_df, &status);
        if (U_SUCCESS(status)) {
	    CFAbsoluteTime at = (double)udate / 1000.0 - kCFAbsoluteTimeIntervalSince1970;
            return CFDateCreate(CFGetAllocator(formatter), at);
        }
    } else if (kCFDateFormatterDefaultDate == key) {
	return formatter->_defaultDate ? CFRetain(formatter->_defaultDate) : NULL;
    } else if (kCFDateFormatterEraSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_ERAS, 0)
    } else if (kCFDateFormatterMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_MONTHS, 0)
    } else if (kCFDateFormatterShortMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_SHORT_MONTHS, 0)
    } else if (kCFDateFormatterWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_WEEKDAYS, 1)
    } else if (kCFDateFormatterShortWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_SHORT_WEEKDAYS, 1)
    } else if (kCFDateFormatterAMSymbol == key) {
	CFIndex cnt = udat_countSymbols(formatter->_df, UDAT_AM_PMS);
	if (2 <= cnt) {
	    CFIndex ucnt = udat_getSymbols(formatter->_df, UDAT_AM_PMS, 0, ubuffer, BUFFER_SIZE, &status);
	    if (U_SUCCESS(status) && cnt <= BUFFER_SIZE) {
		return CFStringCreateWithCharacters(CFGetAllocator(formatter), (UniChar *)ubuffer, ucnt);
	    }
	}	
    } else if (kCFDateFormatterPMSymbol == key) {
	CFIndex cnt = udat_countSymbols(formatter->_df, UDAT_AM_PMS);
	if (2 <= cnt) {
	    CFIndex ucnt = udat_getSymbols(formatter->_df, UDAT_AM_PMS, 1, ubuffer, BUFFER_SIZE, &status);
	    if (U_SUCCESS(status) && cnt <= BUFFER_SIZE) {
		return CFStringCreateWithCharacters(CFGetAllocator(formatter), (UniChar *)ubuffer, ucnt);
	    }
	}	
    } else if (kCFDateFormatterGregorianStartDate == key) {
	UCalendar *cal = (UCalendar *)udat_getCalendar(formatter->_df);
	UDate udate = ucal_getGregorianChange(cal, &status);
        if (U_SUCCESS(status)) {
	    CFAbsoluteTime at = (double)udate / 1000.0 - kCFAbsoluteTimeIntervalSince1970;
            return CFDateCreate(CFGetAllocator(formatter), at);
        }
    } else if (kCFDateFormatterLongEraSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_ERA_NAMES, 0)
    } else if (kCFDateFormatterVeryShortMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_NARROW_MONTHS, 0)
    } else if (kCFDateFormatterStandaloneMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_MONTHS, 0)
    } else if (kCFDateFormatterShortStandaloneMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_MONTHS, 0)
    } else if (kCFDateFormatterVeryShortStandaloneMonthSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_NARROW_MONTHS, 0)
    } else if (kCFDateFormatterVeryShortWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_NARROW_WEEKDAYS, 1)
    } else if (kCFDateFormatterStandaloneWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_WEEKDAYS, 1)
    } else if (kCFDateFormatterShortStandaloneWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_WEEKDAYS, 1)
    } else if (kCFDateFormatterVeryShortStandaloneWeekdaySymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_NARROW_WEEKDAYS, 1)
    } else if (kCFDateFormatterQuarterSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_QUARTERS, 1)
    } else if (kCFDateFormatterShortQuarterSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_SHORT_QUARTERS, 1)
    } else if (kCFDateFormatterStandaloneQuarterSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_QUARTERS, 1)
    } else if (kCFDateFormatterShortStandaloneQuarterSymbols == key) {
	GET_SYMBOLS_ARRAY(UDAT_STANDALONE_SHORT_QUARTERS, 1)
    } else {
	CFAssert3(0, __kCFLogAssertion, "%s(): unknown key %p (%@)", __PRETTY_FUNCTION__, key, key);
    }
    return NULL;
}

CONST_STRING_DECL(kCFDateFormatterIsLenient, "kCFDateFormatterIsLenient")
CONST_STRING_DECL(kCFDateFormatterTimeZone, "kCFDateFormatterTimeZone")
CONST_STRING_DECL(kCFDateFormatterCalendarName, "kCFDateFormatterCalendarName")
CONST_STRING_DECL(kCFDateFormatterCalendarIdentifier, "kCFDateFormatterCalendarIdentifier")
CONST_STRING_DECL(kCFDateFormatterCalendar, "kCFDateFormatterCalendar")
CONST_STRING_DECL(kCFDateFormatterDefaultFormat, "kCFDateFormatterDefaultFormat")

CONST_STRING_DECL(kCFDateFormatterTwoDigitStartDate, "kCFDateFormatterTwoDigitStartDate")
CONST_STRING_DECL(kCFDateFormatterDefaultDate, "kCFDateFormatterDefaultDate")
CONST_STRING_DECL(kCFDateFormatterEraSymbols, "kCFDateFormatterEraSymbols")
CONST_STRING_DECL(kCFDateFormatterMonthSymbols, "kCFDateFormatterMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterShortMonthSymbols, "kCFDateFormatterShortMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterWeekdaySymbols, "kCFDateFormatterWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterShortWeekdaySymbols, "kCFDateFormatterShortWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterAMSymbol, "kCFDateFormatterAMSymbol")
CONST_STRING_DECL(kCFDateFormatterPMSymbol, "kCFDateFormatterPMSymbol")

CONST_STRING_DECL(kCFDateFormatterLongEraSymbols, "kCFDateFormatterLongEraSymbols")
CONST_STRING_DECL(kCFDateFormatterVeryShortMonthSymbols, "kCFDateFormatterVeryShortMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterStandaloneMonthSymbols, "kCFDateFormatterStandaloneMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterShortStandaloneMonthSymbols, "kCFDateFormatterShortStandaloneMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterVeryShortStandaloneMonthSymbols, "kCFDateFormatterVeryShortStandaloneMonthSymbols")
CONST_STRING_DECL(kCFDateFormatterVeryShortWeekdaySymbols, "kCFDateFormatterVeryShortWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterStandaloneWeekdaySymbols, "kCFDateFormatterStandaloneWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterShortStandaloneWeekdaySymbols, "kCFDateFormatterShortStandaloneWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterVeryShortStandaloneWeekdaySymbols, "kCFDateFormatterVeryShortStandaloneWeekdaySymbols")
CONST_STRING_DECL(kCFDateFormatterQuarterSymbols, "kCFDateFormatterQuarterSymbols")
CONST_STRING_DECL(kCFDateFormatterShortQuarterSymbols, "kCFDateFormatterShortQuarterSymbols")
CONST_STRING_DECL(kCFDateFormatterStandaloneQuarterSymbols, "kCFDateFormatterStandaloneQuarterSymbols")
CONST_STRING_DECL(kCFDateFormatterShortStandaloneQuarterSymbols, "kCFDateFormatterShortStandaloneQuarterSymbols")
CONST_STRING_DECL(kCFDateFormatterGregorianStartDate, "kCFDateFormatterGregorianStartDate")

#undef BUFFER_SIZE