Collator::Collator(const char* locale, bool shouldSortLowercaseFirst)
{
UErrorCode status = U_ZERO_ERROR;
{
std::lock_guard<Lock> lock(cachedCollatorMutex);
if (cachedCollator && localesMatch(cachedCollatorLocale, locale) && cachedCollatorShouldSortLowercaseFirst == shouldSortLowercaseFirst) {
m_collator = cachedCollator;
m_locale = cachedCollatorLocale;
m_shouldSortLowercaseFirst = shouldSortLowercaseFirst;
cachedCollator = nullptr;
cachedCollatorLocale = nullptr;
return;
}
}
m_collator = ucol_open(resolveDefaultLocale(locale), &status);
if (U_FAILURE(status)) {
status = U_ZERO_ERROR;
m_collator = ucol_open("", &status); // Fall back to Unicode Collation Algorithm.
}
ASSERT(U_SUCCESS(status));
ucol_setAttribute(m_collator, UCOL_CASE_FIRST, shouldSortLowercaseFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status);
ASSERT(U_SUCCESS(status));
ucol_setAttribute(m_collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
ASSERT(U_SUCCESS(status));
m_locale = locale ? fastStrDup(locale) : nullptr;
m_shouldSortLowercaseFirst = shouldSortLowercaseFirst;
}
static void
TestFCDCrash(void) {
static const char *test[] = {
"Gr\\u00F6\\u00DFe",
"Grossist"
};
char *icuDataDir = safeGetICUDataDirectory();
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open("es", &status);
if(U_FAILURE(status)) {
log_err("Couldn't open collator\n");
return;
}
ucol_close(coll);
coll = NULL;
u_cleanup();
u_setDataDirectory(icuDataDir);
coll = ucol_open("de_DE", &status);
if(U_FAILURE(status)) {
log_err("Couldn't open collator\n");
return;
}
ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
genericOrderingTest(coll, test, 2);
ucol_close(coll);
free(icuDataDir);
}
static ErlDrvData couch_drv_start(ErlDrvPort port, char *buff)
{
UErrorCode status = U_ZERO_ERROR;
couch_drv_data* pData = (couch_drv_data*)driver_alloc(sizeof(couch_drv_data));
if (pData == NULL)
return ERL_DRV_ERROR_GENERAL;
pData->port = port;
pData->coll = ucol_open("", &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
pData->collNoCase = ucol_open("", &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
ucol_setAttribute(pData->collNoCase, UCOL_STRENGTH, UCOL_PRIMARY, &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
return (ErlDrvData)pData;
}
void Collator::createCollator() const
{
ASSERT(!m_collator);
UErrorCode status = U_ZERO_ERROR;
{
Locker<Mutex> lock(cachedCollatorMutex());
if (cachedCollator) {
UColAttributeValue cachedCollatorLowerFirst = ucol_getAttribute(cachedCollator, UCOL_CASE_FIRST, &status);
ASSERT(U_SUCCESS(status));
if (0 == strcmp(cachedEquivalentLocale, m_equivalentLocale)
&& ((UCOL_LOWER_FIRST == cachedCollatorLowerFirst && m_lowerFirst) || (UCOL_UPPER_FIRST == cachedCollatorLowerFirst && !m_lowerFirst))) {
m_collator = cachedCollator;
cachedCollator = 0;
cachedEquivalentLocale[0] = 0;
return;
}
}
}
m_collator = ucol_open(m_locale, &status);
if (U_FAILURE(status)) {
status = U_ZERO_ERROR;
m_collator = ucol_open("", &status); // Fallback to Unicode Collation Algorithm.
}
ASSERT(U_SUCCESS(status));
ucol_setAttribute(m_collator, UCOL_CASE_FIRST, m_lowerFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status);
ASSERT(U_SUCCESS(status));
ucol_setAttribute(m_collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
ASSERT(U_SUCCESS(status));
}
static void
TestFCDCrash(void) {
static const char *test[] = {
"Gr\\u00F6\\u00DFe",
"Grossist"
};
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open("es", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_close(coll);
coll = NULL;
ctest_resetICU();
coll = ucol_open("de_DE", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
genericOrderingTest(coll, test, 2);
ucol_close(coll);
}
void Collator::createCollator() const
{
ASSERT(!m_collator);
UErrorCode status = U_ZERO_ERROR;
{
Locker<Mutex> lock(cachedCollatorMutex());
if (cachedCollator) {
const char* cachedCollatorLocale = ucol_getLocaleByType(cachedCollator, ULOC_REQUESTED_LOCALE, &status);
ASSERT(U_SUCCESS(status));
ASSERT(cachedCollatorLocale);
UColAttributeValue cachedCollatorLowerFirst = ucol_getAttribute(cachedCollator, UCOL_CASE_FIRST, &status);
ASSERT(U_SUCCESS(status));
// FIXME: default locale is never matched, because ucol_getLocaleByType returns the actual one used, not 0.
if (m_locale && 0 == strcmp(cachedCollatorLocale, m_locale)
&& ((UCOL_LOWER_FIRST == cachedCollatorLowerFirst && m_lowerFirst) || (UCOL_UPPER_FIRST == cachedCollatorLowerFirst && !m_lowerFirst))) {
m_collator = cachedCollator;
cachedCollator = 0;
return;
}
}
}
m_collator = ucol_open(m_locale, &status);
if (U_FAILURE(status)) {
status = U_ZERO_ERROR;
m_collator = ucol_open("", &status); // Fallback to Unicode Collation Algorithm.
}
ASSERT(U_SUCCESS(status));
ucol_setAttribute(m_collator, UCOL_CASE_FIRST, m_lowerFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status);
ASSERT(U_SUCCESS(status));
}
int helper_collation_str(const char *src, char *dest, int dest_size)
{
HELPER_FN_CALL;
int32_t size = 0;
UErrorCode status = 0;
UChar tmp_result[CTS_SQL_MAX_LEN];
UCollator *collator;
const char *region;
region = vconf_get_str(VCONFKEY_REGIONFORMAT);
HELPER_DBG("region %s", region);
collator = ucol_open(region, &status);
h_retvm_if(U_FAILURE(status), CTS_ERR_ICU_FAILED,
"ucol_open() Failed(%s)", u_errorName(status));
if (U_FAILURE(status)){
ERR("ucol_setAttribute Failed(%s)", u_errorName(status));
ucol_close(collator);
return CTS_ERR_ICU_FAILED;
}
u_strFromUTF8(tmp_result, array_sizeof(tmp_result), NULL, src, -1, &status);
if (U_FAILURE(status)){
ERR("u_strFromUTF8 Failed(%s)", u_errorName(status));
ucol_close(collator);
return CTS_ERR_ICU_FAILED;
}
size = ucol_getSortKey(collator, tmp_result, -1, (uint8_t *)dest, dest_size);
ucol_close(collator);
dest[size]='\0';
return CTS_SUCCESS;
}
static void TestSecondary()
{
int32_t i,j, testAcuteSize;
UCollationResult expected=UCOL_EQUAL;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("fr_CA", &status);
if(U_FAILURE(status)) {
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
ucol_setAttribute(myCollation, UCOL_STRENGTH, UCOL_SECONDARY, &status);
if(U_FAILURE(status)) {
log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
log_verbose("Testing fr_CA Collation with Secondary strength\n");
/*test acute and grave ordering (compare to french collation)*/
testAcuteSize = UPRV_LENGTHOF(testAcute);
for (i = 0; i < testAcuteSize; i++)
{
for (j = 0; j < testAcuteSize; j++)
{
if (i < j) expected = UCOL_LESS;
if (i == j) expected = UCOL_EQUAL;
if (i > j) expected = UCOL_GREATER;
doTest(myCollation, testAcute[i], testAcute[j], expected );
}
}
ucol_close(myCollation);
}
MojErr MojDbTextCollator::init(const MojChar* locale, MojDbCollationStrength level)
{
MojAssert(locale);
MojAssert(!m_ucol);
UCollationStrength strength = UCOL_PRIMARY;
switch (level) {
case MojDbCollationPrimary:
strength = UCOL_PRIMARY;
break;
case MojDbCollationSecondary:
strength = UCOL_SECONDARY;
break;
case MojDbCollationTertiary:
strength = UCOL_TERTIARY;
break;
case MojDbCollationIdentical:
strength = UCOL_IDENTICAL;
break;
default:
MojAssertNotReached();
}
UErrorCode status = U_ZERO_ERROR;
m_ucol = ucol_open(locale, &status);
MojUnicodeErrCheck(status);
MojAssert(m_ucol);
ucol_setAttribute(m_ucol, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
MojUnicodeErrCheck(status);
ucol_setStrength(m_ucol, strength);
return MojErrNone;
}
/* Get a collator */
ERL_NIF_TERM get_collator(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
ERL_NIF_TERM out;
char locale[LOCALE_LEN];
UErrorCode status = U_ZERO_ERROR;
UCollator* col;
cloner* res;
unsigned int index;
if ((argc != 2) && (argc != 1))
return enif_make_badarg(env);
if (!enif_get_atom(env, argv[0], (char*) locale,
LOCALE_LEN, ERL_NIF_LATIN1)) {
return enif_make_badarg(env);
}
col = ucol_open((char *) locale, &status);
CHECK(env, status);
res = (cloner*) enif_alloc_resource(collator_type, sizeof(cloner));
if (collator_open(col, res)) {
enif_release_resource(res);
return enif_make_badarg(env);
}
CHECK_DEST(env, status,
enif_release_resource(res);
);
/* {{{ */
static int collator_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor)
{
const char* locale;
size_t locale_len = 0;
zval* object;
Collator_object* co;
int zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;
intl_error_reset( NULL );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 );
return FAILURE;
}
INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);
COLLATOR_METHOD_FETCH_OBJECT;
if(locale_len == 0) {
locale = intl_locale_get_default();
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
return SUCCESS;
}
CF_INLINE UCollator *
CFStringICUCollatorOpen (CFStringCompareFlags options, CFLocaleRef loc)
{
const char *cLocale;
char buffer[ULOC_FULLNAME_CAPACITY];
UCollator *ret;
UErrorCode err = U_ZERO_ERROR;
if (loc != NULL && (options & kCFCompareLocalized))
cLocale = CFLocaleGetCStringIdentifier (loc, buffer, ULOC_FULLNAME_CAPACITY);
else
cLocale = NULL;
ret = ucol_open (cLocale, &err);
if (options)
{
if (options & kCFCompareCaseInsensitive)
ucol_setAttribute (ret, UCOL_CASE_LEVEL, UCOL_OFF, &err);
if (options & kCFCompareNonliteral)
ucol_setAttribute (ret, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &err);
if (options & kCFCompareNumerically)
ucol_setAttribute (ret, UCOL_NUMERIC_COLLATION, UCOL_ON, &err);
if (options & kCFCompareDiacriticInsensitive)
ucol_setAttribute (ret, UCOL_NORMALIZATION_MODE, UCOL_ON, &err);
/* FIXME if (compareOptions & kCFCompareWidthInsensitive)
*/
if (options & kCFCompareForcedOrdering)
ucol_setAttribute (ret, UCOL_STRENGTH, UCOL_IDENTICAL, &err);
}
return ret;
}
void SSearchTest::goodSuffixTest()
{
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = NULL;
UnicodeString pat = /*"gcagagag"*/ "fxeld";
UnicodeString target = /*"gcatcgcagagagtatacagtacg"*/ "cloveldfxeld";
int32_t start = -1, end = -1;
UBool bFound;
coll = ucol_open(NULL, &status);
TEST_ASSERT_SUCCESS(status);
LocalUStringSearchPointer ss(usearch_openFromCollator(pat.getBuffer(), pat.length(),
target.getBuffer(), target.length(),
coll,
NULL, // the break iterator
&status));
TEST_ASSERT_SUCCESS(status);
bFound = usearch_search(ss.getAlias(), 0, &start, &end, &status);
TEST_ASSERT_SUCCESS(status);
if (bFound) {
logln("Found pattern at [%d, %d].", start, end);
} else {
dataerrln("Did not find pattern.");
}
ucol_close(coll);
}
/**
* Test for CollationElementIterator previous and next for the whole set of
* unicode characters with normalization on.
*/
static void TestNormalizedUnicodeChar()
{
UChar source[0x100];
UCollator *th_th;
UCollationElements *iter;
UErrorCode status = U_ZERO_ERROR;
UChar codepoint;
UChar *test;
/* thai should have normalization on */
th_th = ucol_open("th_TH", &status);
if (U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of thai collation using ucol_open()\n %s\n",
myErrorName(status));
return;
}
for (codepoint = 1; codepoint < 0xFFFE;)
{
test = source;
while (codepoint % 0xFF != 0)
{
if (u_isdefined(codepoint))
*(test ++) = codepoint;
codepoint ++;
}
if (u_isdefined(codepoint))
*(test ++) = codepoint;
if (codepoint != 0xFFFF)
codepoint ++;
*test = 0;
iter=ucol_openElements(th_th, source, u_strlen(source), &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(th_th);
return;
}
backAndForth(iter);
ucol_closeElements(iter);
iter=ucol_openElements(th_th, source, -1, &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(th_th);
return;
}
backAndForth(iter);
ucol_closeElements(iter);
}
ucol_close(th_th);
}
/* {{{ */
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
const char* locale;
size_t locale_len = 0;
zval* object;
Collator_object* co;
intl_error_reset( NULL );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters( ZEND_NUM_ARGS(), "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 );
zval_dtor(return_value);
RETURN_NULL();
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
COLLATOR_METHOD_FETCH_OBJECT;
if(locale_len == 0) {
locale = intl_locale_get_default();
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
}
UCAConformanceTest::UCAConformanceTest() :
rbUCA(NULL),
testFile(NULL),
status(U_ZERO_ERROR)
{
UCA = ucol_open("root", &status);
if(U_FAILURE(status)) {
errln("ERROR - UCAConformanceTest: Unable to open UCA collator!");
}
uprv_strcpy(testDataPath, IntlTest::loadTestData(status));
if (U_FAILURE(status)) {
errln("ERROR: could not open test data %s", u_errorName(status));
return;
}
char* index = 0;
index=strrchr(testDataPath,(char)U_FILE_SEP_CHAR);
if((unsigned int)(index-testDataPath) != (strlen(testDataPath)-1)){
*(index+1)=0;
}
uprv_strcat(testDataPath,".."U_FILE_SEP_STRING);
uprv_strcat(testDataPath, "CollationTest_");
}
static void TestSecondary()
{
UCollationResult expected=UCOL_EQUAL;
int32_t i,j, testAcuteSize;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("en_US", &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
ucol_setStrength(myCollation, UCOL_SECONDARY);
log_verbose("Testing English Collation with Secondary strength\n");
for (i = 43; i < 49 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
/*test acute and grave ordering (compare to french collation) */
testAcuteSize = UPRV_LENGTHOF(testAcute);
for (i = 0; i < testAcuteSize; i++)
{
for (j = 0; j < testAcuteSize; j++)
{
if (i < j) expected = UCOL_LESS;
if (i == j) expected = UCOL_EQUAL;
if (i > j) expected = UCOL_GREATER;
doTest(myCollation, testAcute[i], testAcute[j], expected );
}
}
ucol_close(myCollation);
}
/*
** Implementation of the scalar function icu_load_collation().
**
** This scalar function is used to add ICU collation based collation
** types to an SQLite database connection. It is intended to be called
** as follows:
**
** SELECT icu_load_collation(<locale>, <collation-name>);
**
** Where <locale> is a string containing an ICU locale identifier (i.e.
** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
** collation sequence to create.
*/
static void icuLoadCollation(
sqlite3_context *p,
int nArg,
sqlite3_value **apArg
){
sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
UErrorCode status = U_ZERO_ERROR;
const char *zLocale; /* Locale identifier - (eg. "jp_JP") */
const char *zName; /* SQL Collation sequence name (eg. "japanese") */
UCollator *pUCollator; /* ICU library collation object */
int rc; /* Return code from sqlite3_create_collation_x() */
assert(nArg==2);
zLocale = (const char *)sqlite3_value_text(apArg[0]);
zName = (const char *)sqlite3_value_text(apArg[1]);
if( !zLocale || !zName ){
return;
}
pUCollator = ucol_open(zLocale, &status);
if( !U_SUCCESS(status) ){
icuFunctionError(p, "ucol_open", status);
return;
}
assert(p);
rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
icuCollationColl, icuCollationDel
);
if( rc!=SQLITE_OK ){
ucol_close(pUCollator);
sqlite3_result_error(p, "Error registering collation function", -1);
}
}
static int32_t
sortkey_from_unicode (UChar *input, uint8_t **output)
{
UErrorCode status = U_ZERO_ERROR;
UCollator * collator = ucol_open ("", &status);
int32_t size;
if (icu_failure (status))
return 0;
ucol_setAttribute (collator, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
if (icu_failure (status))
return 0;
*output = (uint8_t *) palloc (sizeof (uint8_t) * PREALLOC_SIZE);
size = ucol_getSortKey (collator, input, -1, *output, PREALLOC_SIZE);
if (size > PREALLOC_SIZE)
{
pfree (*output);
*output = (uint8_t *) palloc (sizeof (uint8_t) * size);
ucol_getSortKey (collator, input, -1, *output, size);
}
ucol_close (collator);
if (size < 1)
{
ereport(ERROR, (errmsg("ICU sortkey is zero")));
}
return size;
}
static int compareUnicodeSlow(const char* str1, size_t len1,
const char* str2, size_t len2)
{
static UCollator* coll = NULL;
UCharIterator iterA, iterB;
int result;
UErrorCode status = U_ZERO_ERROR;
if (!coll) {
coll = ucol_open("", &status);
if (U_FAILURE(status)) {
fprintf(stderr, "CouchStore CollateJSON: Couldn't initialize ICU (%d)\n", (int)status);
return -1;
}
}
uiter_setUTF8(&iterA, str1, (int)len1);
uiter_setUTF8(&iterB, str2, (int)len2);
result = ucol_strcollIter(coll, &iterA, &iterB, &status);
if (U_FAILURE(status)) {
fprintf(stderr, "CouchStore CollateJSON: ICU error %d\n", (int)status);
return -1;
}
if (result < 0) {
return -1;
} else if (result > 0) {
return 1;
}
return 0;
}
/* {{{ */
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
char* locale;
int locale_len = 0;
zval* object;
Collator_object* co;
intl_error_reset( NULL TSRMLS_CC );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 TSRMLS_CC );
zval_dtor(return_value);
RETURN_NULL();
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
co = (Collator_object *) zend_object_store_get_object( object TSRMLS_CC );
intl_error_reset( COLLATOR_ERROR_P( co ) TSRMLS_CC );
if(locale_len == 0) {
locale = UG(default_locale);
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
}
int
on_load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info)
{
UErrorCode status = U_ZERO_ERROR;
int i, j;
couch_ejson_global_ctx_t *globalCtx;
globalCtx = (couch_ejson_global_ctx_t *) enif_alloc(sizeof(couch_ejson_global_ctx_t));
if (globalCtx == NULL) {
return 1;
}
if (!enif_get_int(env, info, &globalCtx->numCollators)) {
return 2;
}
if (globalCtx->numCollators < 1) {
return 3;
}
globalCtx->collMutex = enif_mutex_create("coll_mutex");
if (globalCtx->collMutex == NULL) {
return 4;
}
globalCtx->collators = (UCollator **) enif_alloc(sizeof(UCollator *) * globalCtx->numCollators);
if (globalCtx->collators == NULL) {
enif_mutex_destroy(globalCtx->collMutex);
return 5;
}
for (i = 0; i < globalCtx->numCollators; i++) {
globalCtx->collators[i] = ucol_open("", &status);
if (U_FAILURE(status)) {
for (j = 0; j < i; j++) {
ucol_close(globalCtx->collators[j]);
}
enif_free(globalCtx->collators);
enif_mutex_destroy(globalCtx->collMutex);
return 5;
}
}
globalCtx->collStackTop = 0;
*priv = globalCtx;
ATOM_TRUE = enif_make_atom(env, "true");
ATOM_FALSE = enif_make_atom(env, "false");
ATOM_NULL = enif_make_atom(env, "null");
ATOM_ERROR = enif_make_atom(env, "error");
return 0;
}
U_CDECL_END
#define LINES 6
void CollationThaiTest::TestInvalidThai(void) {
const char *tests[LINES] = {
"\\u0E44\\u0E01\\u0E44\\u0E01",
"\\u0E44\\u0E01\\u0E01\\u0E44",
"\\u0E01\\u0E44\\u0E01\\u0E44",
"\\u0E01\\u0E01\\u0E44\\u0E44",
"\\u0E44\\u0E44\\u0E01\\u0E01",
"\\u0E01\\u0E44\\u0E44\\u0E01",
};
UChar strings[LINES][20];
UChar *toSort[LINES];
int32_t i = 0, j = 0, len = 0;
UErrorCode coll_status = U_ZERO_ERROR;
UnicodeString iteratorText;
thaiColl = ucol_open ("th_TH", &coll_status);
if (U_FAILURE(coll_status)) {
errln("Error opening Thai collator: %s", u_errorName(coll_status));
return;
}
CollationElementIterator* c = ((RuleBasedCollator *)coll)->createCollationElementIterator( iteratorText );
for(i = 0; i < (int32_t)(sizeof(tests)/sizeof(tests[0])); i++) {
len = u_unescape(tests[i], strings[i], 20);
strings[i][len] = 0;
toSort[i] = strings[i];
}
qsort (toSort, LINES, sizeof (UChar *), StrCmp);
for (i=0; i < LINES; i++)
{
logln("%i", i);
for (j=i+1; j < LINES; j++) {
if (ucol_strcoll (thaiColl, toSort[i], -1, toSort[j], -1) == UCOL_GREATER)
{
// inconsistency ordering found!
errln("Inconsistent ordering between strings %i and %i", i, j);
}
}
iteratorText.setTo(toSort[i]);
c->setText(iteratorText, coll_status);
backAndForth(*c);
}
ucol_close(thaiColl);
delete c;
}
int main(int, char **)
{
UErrorCode status = U_ZERO_ERROR;
UCollator *collator = ucol_open("ru_RU", &status);
if (U_FAILURE(status))
return 0;
ucol_close(collator);
return 0;
}
static jlong NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName) {
ScopedUtfChars localeChars(env, localeName);
if (localeChars.c_str() == NULL) {
return 0;
}
UErrorCode status = U_ZERO_ERROR;
UCollator* c = ucol_open(localeChars.c_str(), &status);
maybeThrowIcuException(env, "ucol_open", status);
return static_cast<jlong>(reinterpret_cast<uintptr_t>(c));
}
static jint NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName) {
ScopedUtfChars localeChars(env, localeName);
if (localeChars.c_str() == NULL) {
return 0;
}
UErrorCode status = U_ZERO_ERROR;
UCollator* c = ucol_open(localeChars.c_str(), &status);
icu4jni_error(env, status);
return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
}
// Very simple example code - sticks a sortkey in the buffer
// Not much error checking
int32_t getSortKey_current(const char *locale, const UChar *string, int32_t sLen, uint8_t *buffer, int32_t bLen) {
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open(locale, &status);
if(U_FAILURE(status)) {
return -1;
}
int32_t result = ucol_getSortKey(coll, string, sLen, buffer, bLen);
ucol_close(coll);
return result;
}
void c_Collator::t___construct(CStrRef locale) {
INSTANCE_METHOD_INJECTION_BUILTIN(Collator, Collator::__construct);
if (m_ucoll) {
ucol_close(m_ucoll);
m_ucoll = NULL;
}
m_errcode.clear();
if (!locale.empty()) {
m_locale = locale;
m_ucoll = ucol_open(locale.data(), &(m_errcode.code));
if (!U_FAILURE(m_errcode.code)) {
// If the specified locale opened successfully, return
s_intl_error->m_error.clear();
s_intl_error->m_error.code = m_errcode.code;
return;
}
}
// If the empty string was given or if the specified locale did
// not open successfully, so fall back to using the default locale
m_errcode.code = U_USING_FALLBACK_WARNING;
s_intl_error->m_error.clear();
s_intl_error->m_error.code = m_errcode.code;
if (m_ucoll) {
ucol_close(m_ucoll);
m_ucoll = NULL;
}
UErrorCode errcode = U_ZERO_ERROR;
m_locale = String(uloc_getDefault(), CopyString);
m_ucoll = ucol_open(m_locale.data(), &errcode);
if (U_FAILURE(errcode)) {
m_errcode.code = errcode;
m_errcode.custom_error_message =
"collator_create: unable to open ICU collator";
s_intl_error->m_error.clear();
s_intl_error->m_error.code = m_errcode.code;
s_intl_error->m_error.custom_error_message = m_errcode.custom_error_message;
if (m_ucoll) {
ucol_close(m_ucoll);
m_ucoll = NULL;
}
}
}
static int compareUnicode(const char* str1, size_t len1,
const char* str2, size_t len2)
{
static UCollator* coll = NULL;
UChar *b1;
UChar *b2;
int ret1, ret2;
int result;
UErrorCode status = U_ZERO_ERROR;
if (!coll) {
coll = ucol_open("", &status);
if (U_FAILURE(status)) {
fprintf(stderr, "CouchStore CollateJSON: Couldn't initialize ICU (%d)\n", (int)status);
return -1;
}
}
if (len1 > 256 || len2 > 256) {
return compareUnicodeSlow(str1, len1, str2, len2);
}
b1 = malloc(len1 * sizeof(UChar));
b2 = malloc(len2 * sizeof(UChar));
if (b1 == NULL || b2 == NULL) {
free(b1);
free(b2);
fprintf(stderr, "CouchStore CollateJSON: Couldn't allocate memory\n");
return -2;
}
ret1 = convertUTF8toUChar(str1, b1, len1);
ret2 = convertUTF8toUChar(str2, b2, len2);
if (ret1 < 0 || ret2 < 0) {
/* something went wrong with utf8->utf32 conversion */
free(b1);
free(b2);
return compareUnicodeSlow(str1, len1, str2, len2);
}
result = ucol_strcoll(coll, b1, len1, b2, len2);
free(b1);
free(b2);
if (result < 0) {
return -1;
} else if (result > 0) {
return 1;
}
return 0;
}
/**
* Create & set up an ICU Collator
*
* WARNING: this fuction is allowed to call the error() function.
* Use before STRI__ERROR_HANDLER_BEGIN (with other prepareargs).
*
* @param opts_collator named R list
* @return a Collator object that should be closed with ucol_close() after use
*
*
* @version 0.1-?? (Marek Gagolewski)
*
* @version 0.2-1 (Marek Gagolewski, 2014-04-17)
* allow for NULL opts_collator (identical to list())
*
* @version 0.2-3 (Marek Gagolewski, 2014-05-09)
* disallow NA as opts_collator
*
* @version 0.3-1 (Marek Gagolewski, 2014-11-05)
* Issue #112: str_prepare_arg* retvals were not PROTECTed from gc;
* + many other bugs in settings establishment
*
* @version 0.3-1 (Marek Gagolewski, 2014-11-06)
* Fetch opts vals first to avoid memleaks (missing ucol_close calls on Rf_error)
*
* @version 0.4-1 (Marek Gagolewski, 2014-12-08)
* #23: add `overlap` option
*/
UCollator* stri__ucol_open(SEXP opts_collator)
{
if (!isNull(opts_collator) && !Rf_isVectorList(opts_collator))
Rf_error(MSG__INCORRECT_COLLATOR_OPTION_SPEC); // error() allowed here
R_len_t narg = isNull(opts_collator)?0:LENGTH(opts_collator);
if (narg <= 0) { // no custom settings - use default Collator
UErrorCode status = U_ZERO_ERROR;
UCollator* col = ucol_open(NULL, &status);
STRI__CHECKICUSTATUS_RFERROR(status, {/* do nothing special on err */}) // error() allowed here
return col;
