[apple/icu.git] / icuSources / common / ualoc.cpp

/*
*****************************************************************************************
* Copyright (C) 2014 Apple Inc. All Rights Reserved.
*****************************************************************************************
*/

#include "unicode/utypes.h"
#include "unicode/ualoc.h"
#include "unicode/uloc.h"
#include "unicode/ures.h"
#include "unicode/putil.h"
#include "cstring.h"
#include "cmemory.h"
// the following has replacements for some math.h funcs etc
#include "putilimp.h"


// The numeric values in territoryInfo are in "IntF" format from LDML2ICUConverter.
// From its docs (adapted): [IntF is] a special integer that represents the number in
// normalized scientific notation.
// Resultant integers are in the form -?xxyyyyyy, where xx is the exponent
// offset by 50 and yyyyyy is the coefficient to 5 decimal places (range 1.0 to 9.99999), e.g.
// 14660000000000 -> 1.46600E13 -> 63146600
// 0.0001 -> 1.00000E-4 -> 46100000
// -123.456 -> -1.23456E-2 -> -48123456
//
// Here to avoid an extra division we have the max coefficient as 999999 (instead of
// 9.99999) and instead offset the exponent by -55.
//
static double doubleFromIntF(int32_t intF) {
    double coefficient = (double)(intF % 1000000);
    int32_t exponent = (intF / 1000000) - 55;
    return coefficient * uprv_pow10(exponent);
}

static int compareLangEntries(const void * entry1, const void * entry2) {
    double fraction1 = ((const UALanguageEntry *)entry1)->userFraction;
    double fraction2 = ((const UALanguageEntry *)entry2)->userFraction;
    // want descending order
    if (fraction1 > fraction2) return -1;
    if (fraction1 < fraction2) return 1;
    // userFractions the same, sort by languageCode
    return uprv_strcmp(((const UALanguageEntry *)entry1)->languageCode,((const UALanguageEntry *)entry2)->languageCode);
}

static const UChar ustrLangStatusDefacto[]  = {0x64,0x65,0x5F,0x66,0x61,0x63,0x74,0x6F,0x5F,0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0}; //"de_facto_official"
static const UChar ustrLangStatusOfficial[] = {0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0}; //"official"
static const UChar ustrLangStatusRegional[] = {0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0x5F,0x72,0x65,0x67,0x69,0x6F,0x6E,0x61,0x6C,0}; //"official_regional"

enum {
    kLocalLangEntriesMax = 26, // enough for most regions to minimumFraction 0.001 except India
    kLangEntriesFactor = 3     // if we have to allocate, multiply existing size by this
};

U_CAPI int32_t U_EXPORT2
ualoc_getLanguagesForRegion(const char *regionID, double minimumFraction,
                            UALanguageEntry *entries, int32_t entriesCapacity,
                            UErrorCode *err)
{
    if (U_FAILURE(*err)) {
        return 0;
    }
    if ( regionID == NULL || minimumFraction < 0.0 || minimumFraction > 1.0 ||
        ((entries==NULL)? entriesCapacity!=0: entriesCapacity<0) ) {
        *err = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", err);
    rb = ures_getByKey(rb, "territoryInfo", rb, err);
    rb = ures_getByKey(rb, regionID, rb, err);
    if (U_FAILURE(*err)) {
        ures_close(rb);
        return 0;
    }

    int32_t entryCount = 0;
    UResourceBundle *langBund = NULL;
    int32_t lbIdx, lbCount = ures_getSize(rb);
    UALanguageEntry localLangEntries[kLocalLangEntriesMax];
    UALanguageEntry * langEntries = localLangEntries;
    int32_t langEntriesMax = kLocalLangEntriesMax;

    for (lbIdx = 0; lbIdx < lbCount; lbIdx++) {
        langBund = ures_getByIndex(rb, lbIdx, langBund, err);
        if (U_FAILURE(*err)) {
            break;
        }
        const char * langCode = ures_getKey(langBund);
        if (uprv_strcmp(langCode,"territoryF") == 0) {
            continue;
        }
        if (strnlen(langCode, UALANGDATA_CODELEN+1) > UALANGDATA_CODELEN) { // no uprv_strnlen
            continue; // a code we cannot handle
        }

        UErrorCode localErr = U_ZERO_ERROR;
        double userFraction = 0.0;
        UResourceBundle *itemBund = ures_getByKey(langBund, "populationShareF", NULL, &localErr);
        if (U_SUCCESS(localErr)) {
            int32_t intF = ures_getInt(itemBund, &localErr);
            if (U_SUCCESS(localErr)) {
                userFraction = doubleFromIntF(intF);
            }
            ures_close(itemBund);
        }
        if (userFraction < minimumFraction) {
            continue;
        }
        if (entries != NULL) {
            localErr = U_ZERO_ERROR;
            UALanguageStatus langStatus = UALANGSTATUS_UNSPECIFIED;
            int32_t ulen;
            const UChar * ustrLangStatus = ures_getStringByKey(langBund, "officialStatus", &ulen, &localErr);
            if (U_SUCCESS(localErr)) {
                int32_t cmp = u_strcmp(ustrLangStatus, ustrLangStatusOfficial);
                if (cmp == 0) {
                    langStatus = UALANGSTATUS_OFFICIAL;
                } else if (cmp < 0 && u_strcmp(ustrLangStatus, ustrLangStatusDefacto) == 0) {
                    langStatus = UALANGSTATUS_DEFACTO_OFFICIAL;
                } else if (u_strcmp(ustrLangStatus, ustrLangStatusRegional) == 0) {
                    langStatus = UALANGSTATUS_REGIONAL_OFFICIAL;
                }
            }
            // Now we have all of the info for our next entry
            if (entryCount >= langEntriesMax) {
                int32_t newMax = langEntriesMax * kLangEntriesFactor;
                if (langEntries == localLangEntries) {
                    // first allocation, copy from local buf
                    langEntries = (UALanguageEntry*)uprv_malloc(newMax*sizeof(UALanguageEntry));
                    if (langEntries == NULL) {
                        *err = U_MEMORY_ALLOCATION_ERROR;
                        break;
                    }
                    uprv_memcpy(langEntries, localLangEntries, entryCount*sizeof(UALanguageEntry));
                } else {
                    langEntries = (UALanguageEntry*)uprv_realloc(langEntries, newMax*sizeof(UALanguageEntry));
                    if (langEntries == NULL) {
                        *err = U_MEMORY_ALLOCATION_ERROR;
                        break;
                    }
                }
                langEntriesMax = newMax;
            }
            uprv_strcpy(langEntries[entryCount].languageCode, langCode);
            langEntries[entryCount].userFraction = userFraction;
            langEntries[entryCount].status = langStatus;
        }
        entryCount++;
    }
    ures_close(langBund);
    ures_close(rb);
    if (U_FAILURE(*err)) {
        if (langEntries != localLangEntries) {
            free(langEntries);
        }
        return 0;
    }
    if (entries != NULL) {
        // sort langEntries, copy entries that fit to provided array
        qsort(langEntries, entryCount, sizeof(UALanguageEntry), compareLangEntries);
        if (entryCount > entriesCapacity) {
            entryCount = entriesCapacity;
        }
        uprv_memcpy(entries, langEntries, entryCount*sizeof(UALanguageEntry));
        if (langEntries != localLangEntries) {
            free(langEntries);
        }
    }
    return entryCount;
}


static const char * forceParent[] = {
    "zh",      "zh_CN",
    "zh_CN",   "root",
    "zh_Hant", "zh_TW",
    "zh_TW",   "root",
    NULL
};

U_CAPI int32_t U_EXPORT2
ualoc_getAppleParent(const char* localeID,
                     char * parent,
                     int32_t parentCapacity,
                     UErrorCode* err)
{
    UResourceBundle *rb;
    int32_t len;
    UErrorCode tempStatus;
    char locbuf[ULOC_FULLNAME_CAPACITY+1];

    if (U_FAILURE(*err)) {
        return 0;
    }
    if ( (parent==NULL)? parentCapacity!=0: parentCapacity<0 ) {
        *err = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    len = uloc_canonicalize(localeID, locbuf, ULOC_FULLNAME_CAPACITY, err);
    if (U_FAILURE(*err)) {
        return 0;
    }
    if (*err == U_STRING_NOT_TERMINATED_WARNING) {
        locbuf[ULOC_FULLNAME_CAPACITY] = 0;
        *err = U_ZERO_ERROR;
    }
    if (len >= 2 && uprv_strncmp(locbuf, "zh", 2) == 0) {
        const char ** forceParentPtr = forceParent;
        const char * testCurLoc;
        while ( (testCurLoc = *forceParentPtr++) != NULL ) {
            int cmp = uprv_strcmp(locbuf, testCurLoc);
            if (cmp <= 0) {
                if (cmp == 0) {
                    len = uprv_strlen(*forceParentPtr);
                    if (len < parentCapacity) {
                        uprv_strcpy(parent, *forceParentPtr);
                    } else {
                        *err = U_BUFFER_OVERFLOW_ERROR;
                    }
                    return len;
                }
                break;
            }
            forceParentPtr++;
        }
    }
    tempStatus = U_ZERO_ERROR;
    rb = ures_openDirect(NULL, locbuf, &tempStatus);
    if (U_SUCCESS(tempStatus)) {
        const char * actualLocale = ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &tempStatus);
        if (U_SUCCESS(tempStatus) && uprv_strcmp(locbuf, actualLocale) != 0) {
            // we have followed an alias
            len = uprv_strlen(actualLocale);
            if (len < parentCapacity) {
                uprv_strcpy(parent, actualLocale);
            } else {
                *err = U_BUFFER_OVERFLOW_ERROR;
            }
            ures_close(rb);
            return len;
        }
        tempStatus = U_ZERO_ERROR;
        const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &len, &tempStatus);
        if (U_SUCCESS(tempStatus) && tempStatus != U_USING_FALLBACK_WARNING) {
            if (len < parentCapacity) {
                u_UCharsToChars(parentUName, parent, len + 1);
            } else {
                *err = U_BUFFER_OVERFLOW_ERROR;
            }
            ures_close(rb);
            return len;
        }
        ures_close(rb);
    }
    len = uloc_getParent(locbuf, parent, parentCapacity, err);
    if (U_SUCCESS(*err) && len == 0) {
        len = 4;
        if (len < parentCapacity) {
            uprv_strcpy(parent, "root");
        } else {
            *err = U_BUFFER_OVERFLOW_ERROR;
        }
    }
    return len;
}
Commit	Line	Data
57a6839d A	1	/*
	2	*****************************************************************************************
	3	* Copyright (C) 2014 Apple Inc. All Rights Reserved.
	4	*****************************************************************************************
	5	*/
	6
	7	#include "unicode/utypes.h"
	8	#include "unicode/ualoc.h"
	9	#include "unicode/uloc.h"
	10	#include "unicode/ures.h"
	11	#include "unicode/putil.h"
	12	#include "cstring.h"
	13	#include "cmemory.h"
	14	// the following has replacements for some math.h funcs etc
	15	#include "putilimp.h"
	16
	17
	18	// The numeric values in territoryInfo are in "IntF" format from LDML2ICUConverter.
	19	// From its docs (adapted): [IntF is] a special integer that represents the number in
	20	// normalized scientific notation.
	21	// Resultant integers are in the form -?xxyyyyyy, where xx is the exponent
	22	// offset by 50 and yyyyyy is the coefficient to 5 decimal places (range 1.0 to 9.99999), e.g.
	23	// 14660000000000 -> 1.46600E13 -> 63146600
	24	// 0.0001 -> 1.00000E-4 -> 46100000
	25	// -123.456 -> -1.23456E-2 -> -48123456
	26	//
	27	// Here to avoid an extra division we have the max coefficient as 999999 (instead of
	28	// 9.99999) and instead offset the exponent by -55.
	29	//
	30	static double doubleFromIntF(int32_t intF) {
	31	double coefficient = (double)(intF % 1000000);
	32	int32_t exponent = (intF / 1000000) - 55;
	33	return coefficient * uprv_pow10(exponent);
	34	}
	35
	36	static int compareLangEntries(const void * entry1, const void * entry2) {
	37	double fraction1 = ((const UALanguageEntry *)entry1)->userFraction;
	38	double fraction2 = ((const UALanguageEntry *)entry2)->userFraction;
	39	// want descending order
	40	if (fraction1 > fraction2) return -1;
	41	if (fraction1 < fraction2) return 1;
	42	// userFractions the same, sort by languageCode
	43	return uprv_strcmp(((const UALanguageEntry )entry1)->languageCode,((const UALanguageEntry )entry2)->languageCode);
	44	}
	45
	46	static const UChar ustrLangStatusDefacto[] = {0x64,0x65,0x5F,0x66,0x61,0x63,0x74,0x6F,0x5F,0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0}; //"de_facto_official"
	47	static const UChar ustrLangStatusOfficial[] = {0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0}; //"official"
	48	static const UChar ustrLangStatusRegional[] = {0x6F,0x66,0x66,0x69,0x63,0x69,0x61,0x6C,0x5F,0x72,0x65,0x67,0x69,0x6F,0x6E,0x61,0x6C,0}; //"official_regional"
	49
	50	enum {
	51	kLocalLangEntriesMax = 26, // enough for most regions to minimumFraction 0.001 except India
	52	kLangEntriesFactor = 3 // if we have to allocate, multiply existing size by this
	53	};
	54
	55	U_CAPI int32_t U_EXPORT2
	56	ualoc_getLanguagesForRegion(const char *regionID, double minimumFraction,
	57	UALanguageEntry *entries, int32_t entriesCapacity,
	58	UErrorCode *err)
	59	{
	60	if (U_FAILURE(*err)) {
	61	return 0;
	62	}
	63	if ( regionID == NULL \|\| minimumFraction < 0.0 \|\| minimumFraction > 1.0 \|\|
	64	((entries==NULL)? entriesCapacity!=0: entriesCapacity<0) ) {
65	*err = U_ILLEGAL_ARGUMENT_ERROR;
66	return 0;
67	}
68	UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", err);
69	rb = ures_getByKey(rb, "territoryInfo", rb, err);
70	rb = ures_getByKey(rb, regionID, rb, err);
71	if (U_FAILURE(*err)) {
72	ures_close(rb);
73	return 0;
74	}
75
76	int32_t entryCount = 0;
77	UResourceBundle *langBund = NULL;
78	int32_t lbIdx, lbCount = ures_getSize(rb);
79	UALanguageEntry localLangEntries[kLocalLangEntriesMax];
80	UALanguageEntry * langEntries = localLangEntries;
81	int32_t langEntriesMax = kLocalLangEntriesMax;
82
83	for (lbIdx = 0; lbIdx < lbCount; lbIdx++) {
84	langBund = ures_getByIndex(rb, lbIdx, langBund, err);
85	if (U_FAILURE(*err)) {
86	break;
87	}
88	const char * langCode = ures_getKey(langBund);
89	if (uprv_strcmp(langCode,"territoryF") == 0) {
90	continue;
91	}
92	if (strnlen(langCode, UALANGDATA_CODELEN+1) > UALANGDATA_CODELEN) { // no uprv_strnlen
93	continue; // a code we cannot handle
94	}
95
96	UErrorCode localErr = U_ZERO_ERROR;
97	double userFraction = 0.0;
98	UResourceBundle *itemBund = ures_getByKey(langBund, "populationShareF", NULL, &localErr);
99	if (U_SUCCESS(localErr)) {
100	int32_t intF = ures_getInt(itemBund, &localErr);
101	if (U_SUCCESS(localErr)) {
102	userFraction = doubleFromIntF(intF);
103	}
104	ures_close(itemBund);
105	}
106	if (userFraction < minimumFraction) {
107	continue;
108	}
109	if (entries != NULL) {
110	localErr = U_ZERO_ERROR;
111	UALanguageStatus langStatus = UALANGSTATUS_UNSPECIFIED;
112	int32_t ulen;
113	const UChar * ustrLangStatus = ures_getStringByKey(langBund, "officialStatus", &ulen, &localErr);
114	if (U_SUCCESS(localErr)) {
115	int32_t cmp = u_strcmp(ustrLangStatus, ustrLangStatusOfficial);
116	if (cmp == 0) {
117	langStatus = UALANGSTATUS_OFFICIAL;
118	} else if (cmp < 0 && u_strcmp(ustrLangStatus, ustrLangStatusDefacto) == 0) {
119	langStatus = UALANGSTATUS_DEFACTO_OFFICIAL;
120	} else if (u_strcmp(ustrLangStatus, ustrLangStatusRegional) == 0) {
121	langStatus = UALANGSTATUS_REGIONAL_OFFICIAL;
122	}
123	}
124	// Now we have all of the info for our next entry
125	if (entryCount >= langEntriesMax) {
126	int32_t newMax = langEntriesMax * kLangEntriesFactor;
127	if (langEntries == localLangEntries) {
128	// first allocation, copy from local buf
129	langEntries = (UALanguageEntry)uprv_malloc(newMaxsizeof(UALanguageEntry));
130	if (langEntries == NULL) {
131	*err = U_MEMORY_ALLOCATION_ERROR;
132	break;
133	}
134	uprv_memcpy(langEntries, localLangEntries, entryCount*sizeof(UALanguageEntry));
135	} else {
136	langEntries = (UALanguageEntry)uprv_realloc(langEntries, newMaxsizeof(UALanguageEntry));
137	if (langEntries == NULL) {
138	*err = U_MEMORY_ALLOCATION_ERROR;
139	break;
140	}
141	}
142	langEntriesMax = newMax;
143	}
144	uprv_strcpy(langEntries[entryCount].languageCode, langCode);
145	langEntries[entryCount].userFraction = userFraction;
146	langEntries[entryCount].status = langStatus;
147	}
148	entryCount++;
149	}
150	ures_close(langBund);
151	ures_close(rb);
152	if (U_FAILURE(*err)) {
153	if (langEntries != localLangEntries) {
154	free(langEntries);
155	}
156	return 0;
157	}
158	if (entries != NULL) {
159	// sort langEntries, copy entries that fit to provided array
160	qsort(langEntries, entryCount, sizeof(UALanguageEntry), compareLangEntries);
161	if (entryCount > entriesCapacity) {
162	entryCount = entriesCapacity;
163	}
164	uprv_memcpy(entries, langEntries, entryCount*sizeof(UALanguageEntry));
165	if (langEntries != localLangEntries) {
166	free(langEntries);
167	}
168	}
169	return entryCount;
170	}
171
172
173	static const char * forceParent[] = {
174	"zh", "zh_CN",
175	"zh_CN", "root",
176	"zh_Hant", "zh_TW",
177	"zh_TW", "root",
178	NULL
179	};
180
181	U_CAPI int32_t U_EXPORT2
182	ualoc_getAppleParent(const char* localeID,
183	char * parent,
184	int32_t parentCapacity,
185	UErrorCode* err)
186	{
187	UResourceBundle *rb;
188	int32_t len;
189	UErrorCode tempStatus;
190	char locbuf[ULOC_FULLNAME_CAPACITY+1];
191
192	if (U_FAILURE(*err)) {
193	return 0;
194	}
195	if ( (parent==NULL)? parentCapacity!=0: parentCapacity<0 ) {
196	*err = U_ILLEGAL_ARGUMENT_ERROR;
197	return 0;
198	}
199	len = uloc_canonicalize(localeID, locbuf, ULOC_FULLNAME_CAPACITY, err);
200	if (U_FAILURE(*err)) {
201	return 0;
202	}
203	if (*err == U_STRING_NOT_TERMINATED_WARNING) {
204	locbuf[ULOC_FULLNAME_CAPACITY] = 0;
205	*err = U_ZERO_ERROR;
206	}
207	if (len >= 2 && uprv_strncmp(locbuf, "zh", 2) == 0) {
208	const char ** forceParentPtr = forceParent;
209	const char * testCurLoc;
210	while ( (testCurLoc = *forceParentPtr++) != NULL ) {
211	int cmp = uprv_strcmp(locbuf, testCurLoc);
212	if (cmp <= 0) {
213	if (cmp == 0) {
214	len = uprv_strlen(*forceParentPtr);
215	if (len < parentCapacity) {
216	uprv_strcpy(parent, *forceParentPtr);
217	} else {
218	*err = U_BUFFER_OVERFLOW_ERROR;
219	}
220	return len;
221	}
222	break;
223	}
224	forceParentPtr++;
225	}
226	}
227	tempStatus = U_ZERO_ERROR;
228	rb = ures_openDirect(NULL, locbuf, &tempStatus);
229	if (U_SUCCESS(tempStatus)) {
230	const char * actualLocale = ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &tempStatus);
231	if (U_SUCCESS(tempStatus) && uprv_strcmp(locbuf, actualLocale) != 0) {
232	// we have followed an alias
233	len = uprv_strlen(actualLocale);
234	if (len < parentCapacity) {
235	uprv_strcpy(parent, actualLocale);
236	} else {
237	*err = U_BUFFER_OVERFLOW_ERROR;
238	}
239	ures_close(rb);
240	return len;
241	}
242	tempStatus = U_ZERO_ERROR;
243	const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &len, &tempStatus);
244	if (U_SUCCESS(tempStatus) && tempStatus != U_USING_FALLBACK_WARNING) {
245	if (len < parentCapacity) {
246	u_UCharsToChars(parentUName, parent, len + 1);
247	} else {
248	*err = U_BUFFER_OVERFLOW_ERROR;
249	}
250	ures_close(rb);
251	return len;
252	}
253	ures_close(rb);
254	}
255	len = uloc_getParent(locbuf, parent, parentCapacity, err);
256	if (U_SUCCESS(*err) && len == 0) {
257	len = 4;
258	if (len < parentCapacity) {
259	uprv_strcpy(parent, "root");
260	} else {
261	*err = U_BUFFER_OVERFLOW_ERROR;
262	}
263	}
264	return len;
265	}
266