/**
* Add some content to a removed range
* @param r the range in question
* @param s the content
* @param len its length
*/
void range_add_content( range *r, const UChar *s, int len )
{
if ( r->content_len > 0 )
{
UChar *new_content = calloc( r->content_len+len+1, sizeof(UChar) );
if ( new_content == NULL )
error( "range: failed to reallocate content\n");
else
{
u_strncpy( new_content, r->content, r->content_len );
u_strncpy( &new_content[r->content_len], s, len );
new_content[r->content_len+len] = 0;
free( r->content );
r->content = new_content;
r->content_len += len;
//printf("content now %s\n",r->content );
}
}
else
{
r->content = calloc( len+1, sizeof(UChar) );
if ( r->content == NULL )
error( "range: failed to allocate new content\n");
u_strncpy( r->content, s, len );
r->content[len] = 0;
r->content_len = len;
// printf("created content length %d\n",len);
}
}
/* UReplaceableCallbacks callback */
static void Xcopy(UReplaceable* rep, int32_t start, int32_t limit, int32_t dest) {
XReplaceable* x = (XReplaceable*)rep;
int32_t newLen = Xlength(rep) + limit - start;
UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
u_strncpy(newText, x->text, dest);
u_strncpy(newText + dest, x->text + start, limit - start);
u_strcpy(newText + dest + limit - start, x->text + dest);
free(x->text);
x->text = newText;
}
void
LocDataParser::parseError(const char* /*str*/) {
if (!data) {
return;
}
const UChar* start = p - U_PARSE_CONTEXT_LEN - 1;
if (start < data) {
start = data;
}
for (UChar* x = p; --x >= start;) {
if (!*x) {
start = x+1;
break;
}
}
const UChar* limit = p + U_PARSE_CONTEXT_LEN - 1;
if (limit > e) {
limit = e;
}
u_strncpy(pe.preContext, start, (int32_t)(p-start));
pe.preContext[p-start] = 0;
u_strncpy(pe.postContext, p, (int32_t)(limit-p));
pe.postContext[limit-p] = 0;
pe.offset = (int32_t)(p - data);
#ifdef DEBUG
fprintf(stderr, "%s at or near character %d: ", str, p-data);
UnicodeString msg;
msg.append(start, p - start);
msg.append((UChar)0x002f); /* SOLIDUS/SLASH */
msg.append(p, limit-p);
msg.append("'");
char buf[128];
int32_t len = msg.extract(0, msg.length(), buf, 128);
if (len >= 128) {
buf[127] = 0;
} else {
buf[len] = 0;
}
fprintf(stderr, "%s\n", buf);
fflush(stderr);
#endif
uprv_free(data);
data = NULL;
p = NULL;
e = NULL;
if (U_SUCCESS(ec)) {
ec = U_PARSE_ERROR;
}
}
/* UReplaceableCallbacks callback */
static void Xreplace(UReplaceable* rep, int32_t start, int32_t limit,
const UChar* text, int32_t textLength) {
XReplaceable* x = (XReplaceable*)rep;
int32_t newLen = Xlength(rep) + limit - start + textLength;
UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
u_strncpy(newText, x->text, start);
u_strncpy(newText + start, text, textLength);
u_strcpy(newText + start + textLength, x->text + limit);
free(x->text);
x->text = newText;
}
static void NativeConverter_setCallbackDecode(JNIEnv* env, jclass, jlong address,
jint onMalformedInput, jint onUnmappableInput, jstring javaReplacement) {
UConverter* cnv = toUConverter(address);
if (cnv == NULL) {
maybeThrowIcuException(env, "toConverter", U_ILLEGAL_ARGUMENT_ERROR);
return;
}
UConverterToUCallback oldCallback;
const void* oldCallbackContext;
ucnv_getToUCallBack(cnv, &oldCallback, &oldCallbackContext);
DecoderCallbackContext* callbackContext = const_cast<DecoderCallbackContext*>(
reinterpret_cast<const DecoderCallbackContext*>(oldCallbackContext));
if (callbackContext == NULL) {
callbackContext = new DecoderCallbackContext;
}
callbackContext->onMalformedInput = getToUCallback(onMalformedInput);
callbackContext->onUnmappableInput = getToUCallback(onUnmappableInput);
ScopedStringChars replacement(env, javaReplacement);
if (replacement.get() == NULL) {
maybeThrowIcuException(env, "replacement", U_ILLEGAL_ARGUMENT_ERROR);
return;
}
u_strncpy(callbackContext->replacementChars, replacement.get(), replacement.size());
callbackContext->replacementCharCount = replacement.size();
UErrorCode errorCode = U_ZERO_ERROR;
ucnv_setToUCallBack(cnv, CHARSET_DECODER_CALLBACK, callbackContext, NULL, NULL, &errorCode);
maybeThrowIcuException(env, "ucnv_setToUCallBack", errorCode);
}
/**
* Applies a new value to the text that serves as input at the current
* processing step. This value is identical to the original one when we begin
* the processing, but usually changes as the transformation progresses.
*
* @param pTransform A pointer to the <code>UBiDiTransform</code> structure.
* @param newSrc A pointer whose value is to be used as input text.
* @param newLength A length of the new text in <code>UChar</code>s.
* @param newSize A new source capacity in <code>UChar</code>s.
* @param pErrorCode Pointer to the error code value.
*/
static void
updateSrc(UBiDiTransform *pTransform, const UChar *newSrc, uint32_t newLength,
uint32_t newSize, UErrorCode *pErrorCode)
{
if (newSize < newLength) {
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
return;
}
if (newSize > pTransform->srcSize) {
newSize += 50; // allocate slightly more than needed right now
if (pTransform->src != NULL) {
uprv_free(pTransform->src);
pTransform->src = NULL;
}
pTransform->src = (UChar *)uprv_malloc(newSize * sizeof(UChar));
if (pTransform->src == NULL) {
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
//pTransform->srcLength = pTransform->srcSize = 0;
return;
}
pTransform->srcSize = newSize;
}
u_strncpy(pTransform->src, newSrc, newLength);
pTransform->srcLength = u_terminateUChars(pTransform->src,
pTransform->srcSize, newLength, pErrorCode);
}
/*
Function:
GetLocaleCurrencyName
Gets the locale currency English or native name and convert the result to UChars
*/
static UErrorCode GetLocaleCurrencyName(const char* locale, UBool nativeName, UChar* value, int32_t valueLength)
{
UErrorCode status = U_ZERO_ERROR;
UChar currencyThreeLettersName[4]; // 3 letters currency iso name + NULL
ucurr_forLocale(locale, currencyThreeLettersName, 4, &status);
if (!U_SUCCESS(status))
{
return status;
}
int32_t len;
UBool formatChoice;
const UChar *pCurrencyLongName = ucurr_getName(
currencyThreeLettersName,
nativeName ? locale : ULOC_US,
UCURR_LONG_NAME,
&formatChoice,
&len,
&status);
if (!U_SUCCESS(status))
{
return status;
}
if (len >= valueLength) // we need to have room for NULL too
{
return U_BUFFER_OVERFLOW_ERROR;
}
u_strncpy(value, pCurrencyLongName, len);
value[len] = 0;
return status;
}
const UChar* UPerfTest::getBuffer(int32_t& len, UErrorCode& status){
len = ucbuf_size(ucharBuf);
buffer = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * (len+1));
u_strncpy(buffer,ucbuf_getBuffer(ucharBuf,&bufferLen,&status),len);
buffer[len]=0;
len = bufferLen;
return buffer;
}
/* copies the minimum number of code units of (count or output->available) */
static int32_t
u_minstrncpy(u_localized_string *output, const UChar *str, int32_t count) {
int32_t size = ufmt_min(count, output->available);
u_strncpy(output->str + (output->len - output->available), str, size);
output->available -= size;
return size;
}
void NumberFormat::setCurrency(const UChar* theCurrency) {
if (theCurrency) {
u_strncpy(currency, theCurrency, 3);
currency[3] = 0;
} else {
currency[0] = 0;
}
}
unichar_t *u_GFileBuildName(unichar_t *dir,unichar_t *fname,unichar_t *buffer,int size) {
int len;
if ( dir==NULL || *dir=='\0' ) {
u_strncpy(buffer,fname,size-1);
buffer[size-1]='\0';
} else {
if ( buffer!=dir ) {
u_strncpy(buffer,dir,size-3);
buffer[size-3]='\0';
}
len = u_strlen(buffer);
if ( buffer[len-1]!='/' )
buffer[len++] = '/';
u_strncpy(buffer+len,fname,size-len-1);
buffer[size-1]='\0';
}
return( buffer );
}
void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
if (U_FAILURE(ec)) {
return;
}
if (theCurrency) {
u_strncpy(fCurrency, theCurrency, 3);
fCurrency[3] = 0;
} else {
fCurrency[0] = 0;
}
}
/* u_minstrncpy copies the minimum number of code units of (count or output->available) */
static int32_t
u_sprintf_write(void *context,
const UChar *str,
int32_t count)
{
u_localized_print_string *output = (u_localized_print_string *)context;
int32_t size = ufmt_min(count, output->available);
u_strncpy(output->str + (output->len - output->available), str, size);
output->available -= size;
return size;
}
U_CAPI int32_t U_EXPORT2
ulocdata_getDelimiter(ULocaleData *uld, ULocaleDataDelimiterType type,
UChar *result, int32_t resultLength, UErrorCode *status){
static const char* const delimiterKeys[] = {
"quotationStart",
"quotationEnd",
"alternateQuotationStart",
"alternateQuotationEnd"
};
UResourceBundle *delimiterBundle;
int32_t len = 0;
const UChar *delimiter = NULL;
UErrorCode localStatus = U_ZERO_ERROR;
if (U_FAILURE(*status))
return 0;
delimiterBundle = ures_getByKey(uld->bundle, "delimiters", NULL, &localStatus);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
ures_close(delimiterBundle);
return 0;
}
delimiter = ures_getStringByKey(delimiterBundle, delimiterKeys[type], &len, &localStatus);
ures_close(delimiterBundle);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
return 0;
}
u_strncpy(result,delimiter, resultLength);
return len;
}
/* create a new filename using that directory and the given nametail */
unichar_t *u_GFileReplaceName(unichar_t *oldname,unichar_t *fname,unichar_t *buffer,int size) {
int len;
unichar_t *dirend;
dirend = u_strrchr(oldname,'/');
if ( dirend == NULL ) {
u_strncpy(buffer,fname,size-1);
buffer[size-1]='\0';
} else {
*dirend = '\0';
if ( buffer!=oldname ) {
u_strncpy(buffer,oldname,size-3);
buffer[size-3]='\0';
}
len = u_strlen(buffer);
*dirend = '/';
buffer[len++] = '/';
u_strncpy(buffer+len,fname,size-len-1);
buffer[size-1]='\0';
}
return( buffer );
}
void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const {
const UChar* c = getCurrency();
if (*c != 0) {
u_strncpy(result, c, 3);
result[3] = 0;
} else {
const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec);
if (loc == NULL) {
loc = uloc_getDefault();
}
ucurr_forLocale(loc, result, 4, &ec);
}
}
/**
* Concatenate some text to the buf
* @param tb the text buf in question
* @param text the text
* @param len the length of the text
* @return 1 if it worked, else 0
*/
int text_buf_concat( text_buf *tb, UChar *text, int len )
{
if ( len+tb->len+1 > tb->allocated )
{
int new_size = (tb->len+len+1)*3/2;
UChar *temp = calloc( new_size, sizeof(UChar) );
if ( temp == NULL )
{
return 0;
}
else
{
u_strncpy( temp, tb->buf, tb->len );
free( tb->buf );
tb->allocated = new_size;
tb->buf = temp;
}
}
u_strncpy( &tb->buf[tb->len], text, len );
tb->len += len;
tb->buf[tb->len] = 0;
return 1;
}
struct icu_buf_utf16 *icu_buf_utf16_copy(struct icu_buf_utf16 *dest16,
const struct icu_buf_utf16 *src16)
{
if (!dest16 || !src16 || dest16 == src16)
return 0;
if (dest16->utf16_cap < src16->utf16_len)
icu_buf_utf16_resize(dest16, src16->utf16_len * 2);
u_strncpy(dest16->utf16, src16->utf16, src16->utf16_len);
dest16->utf16_len = src16->utf16_len;
return dest16;
}
void QueryToken::set(const UChar *inValue, int32_t inStart, int32_t inEnd, QueryToken::Types inType)
{
if (mValue)
delete [] mValue;
if (inEnd == -1)
inEnd = u_strlen(inValue);
mValue = new UChar[inEnd + 1];
u_strncpy(mValue, inValue, inEnd);
mValue[inEnd] = 0;
this->mStart = inStart;
this->mEnd = inEnd;
this->mType = inType;
}
NumberFormat&
NumberFormat::operator=(const NumberFormat& rhs)
{
if (this != &rhs)
{
Format::operator=(rhs);
fGroupingUsed = rhs.fGroupingUsed;
fMaxIntegerDigits = rhs.fMaxIntegerDigits;
fMinIntegerDigits = rhs.fMinIntegerDigits;
fMaxFractionDigits = rhs.fMaxFractionDigits;
fMinFractionDigits = rhs.fMinFractionDigits;
fParseIntegerOnly = rhs.fParseIntegerOnly;
u_strncpy(fCurrency, rhs.fCurrency, 4);
}
return *this;
}
U_DRAFT int32_t U_EXPORT2
ulocdata_getLocaleSeparator(ULocaleData *uld,
UChar *result,
int32_t resultCapacity,
UErrorCode *status) {
UResourceBundle *separatorBundle;
int32_t len = 0;
const UChar *separator = NULL;
UErrorCode localStatus = U_ZERO_ERROR;
if (U_FAILURE(*status))
return 0;
separatorBundle = ures_getByKey(uld->bundle, "localeDisplayPattern", NULL, &localStatus);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
ures_close(separatorBundle);
return 0;
}
separator = ures_getStringByKey(separatorBundle, "separator", &len, &localStatus);
ures_close(separatorBundle);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
return 0;
}
u_strncpy(result, separator, resultCapacity);
return len;
}
unichar_t *u_GFileGetAbsoluteName(unichar_t *name, unichar_t *result, int rsiz) {
/* result may be the same as name */
unichar_t buffer[1000];
if ( ! u_GFileIsAbsolute(name) ) {
unichar_t *pt, *spt, *rpt, *bpt;
if ( dirname_[0]=='\0' ) {
getcwd(dirname_,sizeof(dirname_));
}
uc_strcpy(buffer,dirname_);
if ( buffer[u_strlen(buffer)-1]!='/' )
uc_strcat(buffer,"/");
u_strcat(buffer,name);
_u_backslash_to_slash(buffer);
/* Normalize out any .. */
spt = rpt = buffer;
while ( *spt!='\0' ) {
if ( *spt=='/' ) ++spt;
for ( pt = spt; *pt!='\0' && *pt!='/'; ++pt );
if ( pt==spt ) /* Found // in a path spec, reduce to / (we've*/
u_strcpy(spt,pt); /* skipped past the :// of the machine name) */
else if ( pt==spt+1 && spt[0]=='.' && *pt=='/' ) /* Noop */
u_strcpy(spt,spt+2);
else if ( pt==spt+2 && spt[0]=='.' && spt[1]=='.' ) {
for ( bpt=spt-2 ; bpt>rpt && *bpt!='/'; --bpt );
if ( bpt>=rpt && *bpt=='/' ) {
u_strcpy(bpt,pt);
spt = bpt;
} else {
rpt = pt;
spt = pt;
}
} else
spt = pt;
}
name = buffer;
}
if (result!=name) {
u_strncpy(result,name,rsiz);
result[rsiz-1]='\0';
_u_backslash_to_slash(result);
}
return(result);
}
struct icu_buf_utf16 *icu_buf_utf16_append(struct icu_buf_utf16 *dest16,
const struct icu_buf_utf16 *src16)
{
assert(dest16);
if (!src16)
return dest16;
if (dest16 == src16)
return 0;
if (dest16->utf16_cap <= src16->utf16_len + dest16->utf16_len)
icu_buf_utf16_resize(dest16, dest16->utf16_len + src16->utf16_len * 2);
u_strncpy(dest16->utf16 + dest16->utf16_len,
src16->utf16, src16->utf16_len);
dest16->utf16_len += src16->utf16_len;
return dest16;
}
static const UChar * u_file_translit(UFILE *f, const UChar *src, int32_t *count, UBool flush)
{
int32_t newlen;
int32_t junkCount = 0;
int32_t textLength;
int32_t textLimit;
UTransPosition pos;
UErrorCode status = U_ZERO_ERROR;
if(count == NULL)
{
count = &junkCount;
}
if ((!f)||(!f->fTranslit)||(!f->fTranslit->translit))
{
/* fast path */
return src;
}
/* First: slide over everything */
if(f->fTranslit->length > f->fTranslit->pos)
{
memmove(f->fTranslit->buffer, f->fTranslit->buffer + f->fTranslit->pos,
(f->fTranslit->length - f->fTranslit->pos)*sizeof(UChar));
}
f->fTranslit->length -= f->fTranslit->pos; /* always */
f->fTranslit->pos = 0;
/* Calculate new buffer size needed */
newlen = (*count + f->fTranslit->length) * 4;
if(newlen > f->fTranslit->capacity)
{
if(f->fTranslit->buffer == NULL)
{
f->fTranslit->buffer = (UChar*)uprv_malloc(newlen * sizeof(UChar));
}
else
{
f->fTranslit->buffer = (UChar*)uprv_realloc(f->fTranslit->buffer, newlen * sizeof(UChar));
}
f->fTranslit->capacity = newlen;
}
/* Now, copy any data over */
u_strncpy(f->fTranslit->buffer + f->fTranslit->length,
src,
*count);
f->fTranslit->length += *count;
/* Now, translit in place as much as we can */
if(flush == FALSE)
{
textLength = f->fTranslit->length;
pos.contextStart = 0;
pos.contextLimit = textLength;
pos.start = 0;
pos.limit = textLength;
utrans_transIncrementalUChars(f->fTranslit->translit,
f->fTranslit->buffer, /* because we shifted */
&textLength,
f->fTranslit->capacity,
&pos,
&status);
#ifdef _DEBUG
if(U_FAILURE(status))
{
fprintf(stderr, " Gack. Translit blew up with a %s\n", u_errorName(status));
return src;
}
#endif
/* now: start/limit point to the transliterated text */
/* Transliterated is [buffer..pos.start) */
*count = pos.start;
f->fTranslit->pos = pos.start;
f->fTranslit->length = pos.limit;
return f->fTranslit->buffer;
}
else
{
textLength = f->fTranslit->length;
textLimit = f->fTranslit->length;
utrans_transUChars(f->fTranslit->translit,
f->fTranslit->buffer,
&textLength,
f->fTranslit->capacity,
0,
&textLimit,
&status);
#ifdef _DEBUG
if(U_FAILURE(status))
{
fprintf(stderr, " Gack. Translit(flush) blew up with a %s\n", u_errorName(status));
return src;
}
#endif
/* out: converted len */
*count = textLimit;
/* Set pointers to 0 */
f->fTranslit->pos = 0;
f->fTranslit->length = 0;
return f->fTranslit->buffer;
}
}
static jobjectArray getContentImpl(JNIEnv* env, jclass clazz,
jstring locale, jboolean needsTZ) {
UErrorCode status = U_ZERO_ERROR;
const char *loc = env->GetStringUTFChars(locale, NULL);
UResourceBundle *root = ures_openU(NULL, loc, &status);
env->ReleaseStringUTFChars(locale, loc);
if(U_FAILURE(status)) {
LOGI("Error getting resources");
status = U_ZERO_ERROR;
return NULL;
}
jclass obj_class = env->FindClass("java/lang/Object");
jclass integer_class = env->FindClass("java/lang/Integer");
jmethodID integerInit = env->GetMethodID(integer_class, "<init>", "(I)V");
jobjectArray result;
jobject firstDayOfWeek = NULL;
jobject minimalDaysInFirstWeek = NULL;
jobjectArray amPmMarkers = NULL;
jobjectArray eras = NULL;
jstring localPatternChars = NULL;
jobjectArray weekdays = NULL;
jobjectArray shortWeekdays = NULL;
jobjectArray months = NULL;
jobjectArray shortMonths = NULL;
jstring time_SHORT = NULL;
jstring time_MEDIUM = NULL;
jstring time_LONG = NULL;
jstring time_FULL = NULL;
jstring date_SHORT = NULL;
jstring date_MEDIUM = NULL;
jstring date_LONG = NULL;
jstring date_FULL = NULL;
jstring decimalPatternChars = NULL;
jstring naN = NULL;
jstring infinity = NULL;
jstring currencySymbol = NULL;
jstring intCurrencySymbol = NULL;
jstring numberPattern = NULL;
jstring integerPattern = NULL;
jstring currencyPattern = NULL;
jstring percentPattern = NULL;
jobjectArray zones = NULL;
int counter = 0;
int firstDayVals[2] = {-1, -1};
const jchar* nan = (const jchar *)NULL;
const jchar* inf = (const jchar *)NULL;
int nanL, infL;
UResourceBundle *gregorian;
UResourceBundle *gregorianElems;
UResourceBundle *rootElems;
// get the resources needed
rootElems = ures_getByKey(root, "calendar", NULL, &status);
if(U_FAILURE(status)) {
return NULL;
}
gregorian = ures_getByKey(rootElems, "gregorian", NULL, &status);
if(U_FAILURE(status)) {
ures_close(rootElems);
return NULL;
}
// adding the first day of week and minimal days in first week values
getDayInitVector(env, gregorian, firstDayVals);
if((firstDayVals[0] != -1) && (firstDayVals[1] != -1)) {
firstDayOfWeek = env->NewObject(integer_class, integerInit, firstDayVals[0]);
minimalDaysInFirstWeek = env->NewObject(integer_class, integerInit, firstDayVals[1]);
// adding First_Day and Minimal_Days integer to the result
counter += 2;
}
// adding ampm string array to the result");
amPmMarkers = getAmPmMarkers(env, gregorian);
if(amPmMarkers != NULL) {
counter++;
}
// adding eras string array to the result
eras = getEras(env, gregorian);
if(eras != NULL) {
counter++;
}
// local pattern chars are initially always the same
localPatternChars = env->NewStringUTF("GyMdkHmsSEDFwWahKzZ");
// adding local pattern chars string to the result
counter++;
// adding month names string array to the result
months = getMonthNames(env, gregorian);
if(months != NULL) {
counter++;
}
// adding short month names string array to the result
shortMonths = getShortMonthNames(env, gregorian);
if(shortMonths != NULL) {
counter++;
}
// adding day names string array to the result
weekdays = getWeekdayNames(env, gregorian);
if(weekdays != NULL) {
counter++;
}
// adding short day names string array to the result
shortWeekdays = getShortWeekdayNames(env, gregorian);
if(shortWeekdays != NULL) {
counter++;
}
const UChar *pattern;
jchar check[2] = {0, 0};
u_uastrcpy(check, "v");
jchar replacement[2] = {0, 0};
u_uastrcpy(replacement, "z");
jchar *pos;
jchar *patternCopy;
int patternLength;
// adding date and time format patterns to the result
gregorianElems = ures_getByKey(gregorian, "DateTimePatterns", NULL, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
pattern = ures_getStringByIndex(gregorianElems, 0, &patternLength, &status);
// there are some patterns in icu that use the pattern character 'v'
// java doesn't accept this, so it gets replaced by 'z' which has
// about the same result as 'v', the timezone name.
// 'v' -> "PT", 'z' -> "PST", v is the generic timezone and z the standard tz
// "vvvv" -> "Pacific Time", "zzzz" -> "Pacific Standard Time"
patternCopy = (jchar *) malloc((patternLength + 1) * sizeof(jchar));
u_strcpy(patternCopy, pattern);
if(U_FAILURE(status)) {
free(patternCopy);
status = U_ZERO_ERROR;
goto endOfCalendar;
}
while((pos = u_strchr(patternCopy, check[0])) != NULL) {
u_memset(pos, replacement[0], 1);
}
time_FULL = env->NewString(patternCopy, patternLength);
free(patternCopy);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 1, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
time_LONG = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 2, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
time_MEDIUM = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 3, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
time_SHORT = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 4, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
date_FULL = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 5, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
date_LONG = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 6, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
date_MEDIUM = env->NewString(pattern, patternLength);
counter++;
pattern = ures_getStringByIndex(gregorianElems, 7, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto endOfCalendar;
}
date_SHORT = env->NewString(pattern, patternLength);
counter++;
endOfCalendar:
if(gregorianElems != NULL) {
ures_close(gregorianElems);
}
ures_close(gregorian);
ures_close(rootElems);
rootElems = ures_getByKey(root, "NumberElements", NULL, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
}
if(ures_getSize(rootElems) >= 11) {
// adding decimal pattern chars to the result
decimalPatternChars = getDecimalPatternChars(env, rootElems);
if(decimalPatternChars != NULL) {
counter++;
}
// adding NaN pattern char to the result
nan = ures_getStringByIndex(rootElems, 10, &nanL, &status);
if(U_SUCCESS(status)) {
naN = env->NewString(nan, nanL);
counter++;
}
status = U_ZERO_ERROR;
// adding infinity pattern char to the result
inf = ures_getStringByIndex(rootElems, 9, &infL, &status);
if(U_SUCCESS(status)) {
infinity = env->NewString(inf, infL);
counter++;
}
status = U_ZERO_ERROR;
}
ures_close(rootElems);
// adding intl currency code to result
intCurrencySymbol = getIntCurrencyCode(env, clazz, locale);
if(intCurrencySymbol != NULL) {
// adding currency symbol to result
currencySymbol = getCurrencySymbol(env, clazz, locale, intCurrencySymbol);
} else {
intCurrencySymbol = env->NewStringUTF("XXX");
}
if(currencySymbol == NULL) {
currencySymbol = env->NewStringUTF("\u00a4");
}
counter += 2;
// adding number format patterns to the result
int numOfEntries;
int decSepOffset;
NumberFormat *nf;
jchar *tmpPattern;
rootElems = ures_getByKey(root, "NumberPatterns", NULL, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
goto zones;
}
numOfEntries = ures_getSize(rootElems);
if(numOfEntries < 3) {
ures_close(rootElems);
goto zones;
}
// number pattern
pattern = ures_getStringByIndex(rootElems, 0, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
ures_close(rootElems);
goto zones;
}
numberPattern = env->NewString(pattern, patternLength);
counter++;
// integer pattern derived from number pattern
decSepOffset = u_strcspn(pattern, (jchar *)".\0");
tmpPattern = (jchar *) malloc((decSepOffset + 1) * sizeof(jchar));
u_strncpy(tmpPattern, pattern, decSepOffset);
integerPattern = env->NewString(tmpPattern, decSepOffset);
free(tmpPattern);
counter++;
// currency pattern
pattern = ures_getStringByIndex(rootElems, 1, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
ures_close(rootElems);
goto zones;
}
currencyPattern = env->NewString(pattern, patternLength);
counter++;
// percent pattern
pattern = ures_getStringByIndex(rootElems, 2, &patternLength, &status);
if(U_FAILURE(status)) {
status = U_ZERO_ERROR;
ures_close(rootElems);
goto zones;
}
percentPattern = env->NewString(pattern, patternLength);
counter++;
ures_close(rootElems);
zones:
ures_close(root);
if(needsTZ == JNI_TRUE) {
counter++; //add empty timezone
}
// collect all content and put it into an array
result = env->NewObjectArray(counter, obj_class, NULL);
int index = 0;
if(needsTZ == JNI_TRUE) {
addObject(env, result, "timezones", NULL, index++);
}
if(firstDayOfWeek != NULL && index < counter) {
addObject(env, result, "First_Day", firstDayOfWeek, index++);
}
if(minimalDaysInFirstWeek != NULL && index < counter) {
addObject(env, result, "Minimal_Days", minimalDaysInFirstWeek, index++);
}
if(amPmMarkers != NULL && index < counter) {
addObject(env, result, "ampm", amPmMarkers, index++);
}
if(eras != NULL && index < counter) {
addObject(env, result, "eras", eras, index++);
}
if(localPatternChars != NULL && index < counter) {
addObject(env, result, "LocalPatternChars", localPatternChars, index++);
}
if(weekdays != NULL && index < counter) {
addObject(env, result, "weekdays", weekdays, index++);
}
if(shortWeekdays != NULL && index < counter) {
addObject(env, result, "shortWeekdays", shortWeekdays, index++);
}
if(months != NULL && index < counter) {
addObject(env, result, "months", months, index++);
}
if(shortMonths != NULL && index < counter) {
addObject(env, result, "shortMonths", shortMonths, index++);
}
if(time_SHORT != NULL && index < counter) {
addObject(env, result, "Time_SHORT", time_SHORT, index++);
}
if(time_MEDIUM != NULL && index < counter) {
addObject(env, result, "Time_MEDIUM", time_MEDIUM, index++);
}
if(time_LONG != NULL && index < counter) {
addObject(env, result, "Time_LONG", time_LONG, index++);
}
if(time_FULL != NULL && index < counter) {
addObject(env, result, "Time_FULL", time_FULL, index++);
}
if(date_SHORT != NULL && index < counter) {
addObject(env, result, "Date_SHORT", date_SHORT, index++);
}
if(date_MEDIUM != NULL && index < counter) {
addObject(env, result, "Date_MEDIUM", date_MEDIUM, index++);
}
if(date_LONG != NULL && index < counter) {
addObject(env, result, "Date_LONG", date_LONG, index++);
}
if(date_FULL != NULL && index < counter) {
addObject(env, result, "Date_FULL", date_FULL, index++);
}
if(decimalPatternChars != NULL && index < counter) {
addObject(env, result, "DecimalPatternChars", decimalPatternChars, index++);
}
if(naN != NULL && index < counter) {
addObject(env, result, "NaN", naN, index++);
}
if(infinity != NULL && index < counter) {
addObject(env, result, "Infinity", infinity, index++);
}
if(currencySymbol != NULL && index < counter) {
addObject(env, result, "CurrencySymbol", currencySymbol, index++);
}
if(intCurrencySymbol != NULL && index < counter) {
addObject(env, result, "IntCurrencySymbol", intCurrencySymbol, index++);
}
if(numberPattern != NULL && index < counter) {
addObject(env, result, "Number", numberPattern, index++);
}
if(integerPattern != NULL && index < counter) {
addObject(env, result, "Integer", integerPattern, index++);
}
if(currencyPattern != NULL && index < counter) {
addObject(env, result, "Currency", currencyPattern, index++);
}
if(percentPattern != NULL && index < counter) {
addObject(env, result, "Percent", percentPattern, index++);
}
return result;
}
/* UReplaceableCallbacks callback */
static void Xextract(UReplaceable* rep, int32_t start, int32_t limit, UChar* dst) {
XReplaceable* x = (XReplaceable*)rep;
int32_t len = limit - start;
u_strncpy(dst, x->text, len);
}
U_DRAFT uint32_t U_EXPORT2
ubiditransform_transform(UBiDiTransform *pBiDiTransform,
const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
UBiDiLevel inParaLevel, UBiDiOrder inOrder,
UBiDiLevel outParaLevel, UBiDiOrder outOrder,
UBiDiMirroring doMirroring, uint32_t shapingOptions,
UErrorCode *pErrorCode)
{
uint32_t destLength = 0;
UBool textChanged = FALSE;
const UBiDiTransform *pOrigTransform = pBiDiTransform;
const UBiDiAction *action = NULL;
if (U_FAILURE(*pErrorCode)) {
return 0;
}
if (src == NULL || dest == NULL) {
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
CHECK_LEN(src, srcLength, pErrorCode);
CHECK_LEN(dest, destSize, pErrorCode);
if (pBiDiTransform == NULL) {
pBiDiTransform = ubiditransform_open(pErrorCode);
if (U_FAILURE(*pErrorCode)) {
return 0;
}
}
/* Current limitation: in multiple paragraphs will be resolved according
to the 1st paragraph */
resolveBaseDirection(src, srcLength, &inParaLevel, &outParaLevel);
pBiDiTransform->pActiveScheme = findMatchingScheme(inParaLevel, outParaLevel,
inOrder, outOrder);
if (pBiDiTransform->pActiveScheme == NULL) {
goto cleanup;
}
pBiDiTransform->reorderingOptions = doMirroring ? UBIDI_DO_MIRRORING
: UBIDI_REORDER_DEFAULT;
/* Ignore TEXT_DIRECTION_* flags, as we apply our own depending on the text
scheme at the time shaping is invoked. */
shapingOptions &= ~U_SHAPE_TEXT_DIRECTION_MASK;
pBiDiTransform->digits = shapingOptions & ~U_SHAPE_LETTERS_MASK;
pBiDiTransform->letters = shapingOptions & ~U_SHAPE_DIGITS_MASK;
updateSrc(pBiDiTransform, src, srcLength, destSize > srcLength ? destSize : srcLength, pErrorCode);
if (U_FAILURE(*pErrorCode)) {
goto cleanup;
}
if (pBiDiTransform->pBidi == NULL) {
pBiDiTransform->pBidi = ubidi_openSized(0, 0, pErrorCode);
if (U_FAILURE(*pErrorCode)) {
goto cleanup;
}
}
pBiDiTransform->dest = dest;
pBiDiTransform->destSize = destSize;
pBiDiTransform->pDestLength = &destLength;
/* Checking for U_SUCCESS() within the loop to bail out on first failure. */
for (action = pBiDiTransform->pActiveScheme->actions; *action && U_SUCCESS(*pErrorCode); action++) {
if ((*action)(pBiDiTransform, pErrorCode)) {
if (action + 1) {
updateSrc(pBiDiTransform, pBiDiTransform->dest, *pBiDiTransform->pDestLength,
*pBiDiTransform->pDestLength, pErrorCode);
}
textChanged = TRUE;
}
}
ubidi_setInverse(pBiDiTransform->pBidi, FALSE);
if (!textChanged && U_SUCCESS(*pErrorCode)) {
/* Text was not changed - just copy src to dest */
if (destSize < srcLength) {
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
} else {
u_strncpy(dest, src, srcLength);
destLength = srcLength;
}
}
cleanup:
if (pOrigTransform != pBiDiTransform) {
ubiditransform_close(pBiDiTransform);
} else {
pBiDiTransform->dest = NULL;
pBiDiTransform->pDestLength = NULL;
pBiDiTransform->srcLength = 0;
pBiDiTransform->destSize = 0;
}
return U_FAILURE(*pErrorCode) ? 0 : destLength;
}
static void GIOdispatch(GIOControl *gc, enum giofuncs gf) {
unichar_t *temp, *pt, *tpt;
int i;
gc->gf = gf;
if ( _GIO_stdfuncs.useragent == NULL )
_GIO_stdfuncs.useragent = copy("*****@*****.**");
temp = _GIO_translateURL(gc->path,gf);
if ( temp!=NULL ) {
if ( gc->origpath==NULL )
gc->origpath = gc->path;
else
free(gc->path);
gc->path = temp;
}
if ( gc->topath!=NULL ) {
temp = _GIO_translateURL(gc->topath,gf);
if ( temp!=NULL ) {
free(gc->topath);
gc->topath = temp;
}
if ( gf==gf_renamefile ) {
if (( pt = uc_strstr(gc->path,"://"))== NULL )
pt = gc->path;
else {
pt=u_strchr(pt+3,'/');
if ( pt==NULL ) pt = gc->path+u_strlen(gc->path);
}
if (( tpt = uc_strstr(gc->topath,"://"))== NULL )
tpt = gc->topath;
else {
tpt=u_strchr(tpt+3,'/');
if ( tpt==NULL ) tpt = gc->topath+u_strlen(gc->topath);
}
if ( tpt-gc->topath!=pt-gc->path ||
u_strnmatch(gc->path,gc->topath,pt-gc->path)!=0 ) {
_GIO_reporterror(gc,EXDEV);
return;
}
}
}
pt = uc_strstr(gc->path,"://");
if ( pt!=NULL ) {
for ( i=0; i<plen; ++i )
if ( u_strnmatch(protocols[i].proto,gc->path,pt-gc->path)==0 )
break;
if ( i>=plen && !AddProtocol(gc->path,pt-gc->path) ) {
gc->protocol_index = -2;
gc->return_code = 501;
gc->error = err501;
uc_strcpy(gc->status,"No support for browsing: ");
u_strncpy(gc->status+u_strlen(gc->status), gc->path, pt-gc->path );
gc->done = true;
(gc->receiveerror)(gc);
return;
}
gc->protocol_index = i;
if ( !protocols[i].dothread )
(protocols[i].dispatcher)(gc);
else {
#ifndef HAVE_PTHREAD_H
gc->return_code = 501;
gc->error = err501;
uc_strcpy(gc->status,"No support for protocol");
gc->done = true;
(gc->receiveerror)(gc);
return;
#else
static pthread_cond_t initcond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t initmutex = PTHREAD_MUTEX_INITIALIZER;
/* could put stuff here to queue functions if we get too many */
/* threads, or perhaps even a thread pool */
uc_strcpy(gc->status,"Queued");
gc->threaddata = (struct gio_threaddata *) malloc(sizeof(struct gio_threaddata));
gc->threaddata->mutex = initmutex;
gc->threaddata->cond = initcond;
if ( _GIO_stdfuncs.gdraw_sync_thread!=NULL )
(_GIO_stdfuncs.gdraw_sync_thread)(NULL,NULL,NULL);
pthread_create(&gc->threaddata->thread,NULL,
(ptread_startfunc_t *) (protocols[i].dispatcher), gc);
#endif
}
} else {
gc->protocol_index = -1;
_GIO_localDispatch(gc);
}
}
U_CFUNC int32_t U_EXPORT2
u_file_write_flush(const UChar *chars,
int32_t count,
UFILE *f,
UBool flushIO,
UBool flushTranslit)
{
/* Set up conversion parameters */
UErrorCode status = U_ZERO_ERROR;
const UChar *mySource = chars;
const UChar *mySourceBegin;
const UChar *mySourceEnd;
char charBuffer[UFILE_CHARBUFFER_SIZE];
char *myTarget = charBuffer;
int32_t written = 0;
int32_t numConverted = 0;
if (count < 0) {
count = u_strlen(chars);
}
#if !UCONFIG_NO_TRANSLITERATION
if((f->fTranslit) && (f->fTranslit->translit))
{
/* Do the transliteration */
mySource = u_file_translit(f, chars, &count, flushTranslit);
}
#endif
/* Write to a string. */
if (!f->fFile) {
int32_t charsLeft = (int32_t)(f->str.fLimit - f->str.fPos);
if (flushIO && charsLeft > count) {
count++;
}
written = ufmt_min(count, charsLeft);
u_strncpy(f->str.fPos, mySource, written);
f->str.fPos += written;
return written;
}
mySourceEnd = mySource + count;
/* Perform the conversion in a loop */
do {
mySourceBegin = mySource; /* beginning location for this loop */
status = U_ZERO_ERROR;
if(f->fConverter != NULL) { /* We have a valid converter */
ucnv_fromUnicode(f->fConverter,
&myTarget,
charBuffer + UFILE_CHARBUFFER_SIZE,
&mySource,
mySourceEnd,
NULL,
flushIO,
&status);
} else { /*weiv: do the invariant conversion */
int32_t convertChars = (int32_t) (mySourceEnd - mySource);
if (convertChars > UFILE_CHARBUFFER_SIZE) {
convertChars = UFILE_CHARBUFFER_SIZE;
status = U_BUFFER_OVERFLOW_ERROR;
}
u_UCharsToChars(mySource, myTarget, convertChars);
mySource += convertChars;
myTarget += convertChars;
}
numConverted = (int32_t)(myTarget - charBuffer);
if (numConverted > 0) {
/* write the converted bytes */
fwrite(charBuffer,
sizeof(char),
numConverted,
f->fFile);
written += (int32_t) (mySource - mySourceBegin);
}
myTarget = charBuffer;
}
while(status == U_BUFFER_OVERFLOW_ERROR);
/* return # of chars written */
return written;
}
U_CAPI int32_t U_EXPORT2
ulocdata_getLocaleSeparator(ULocaleData *uld,
UChar *result,
int32_t resultCapacity,
UErrorCode *status) {
UResourceBundle *separatorBundle;
int32_t len = 0;
const UChar *separator = NULL;
UErrorCode localStatus = U_ZERO_ERROR;
UChar *p0, *p1;
static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 }; /* {0} */
static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 }; /* {1} */
static const int32_t subLen = 3;
if (U_FAILURE(*status))
return 0;
separatorBundle = ures_getByKey(uld->langBundle, "localeDisplayPattern", NULL, &localStatus);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
ures_close(separatorBundle);
return 0;
}
separator = ures_getStringByKey(separatorBundle, "separator", &len, &localStatus);
ures_close(separatorBundle);
if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
localStatus = U_MISSING_RESOURCE_ERROR;
}
if (localStatus != U_ZERO_ERROR) {
*status = localStatus;
}
if (U_FAILURE(*status)){
return 0;
}
/* For backwards compatibility, if we have a pattern, return the portion between {0} and {1} */
p0=u_strstr(separator, sub0);
p1=u_strstr(separator, sub1);
if (p0!=NULL && p1!=NULL && p0<=p1) {
separator = (const UChar *)p0 + subLen;
len = static_cast<int32_t>(p1 - separator);
/* Desired separator is no longer zero-terminated; handle that if necessary */
if (len < resultCapacity) {
u_strncpy(result, separator, len);
result[len] = 0;
return len;
}
}
u_strncpy(result, separator, resultCapacity);
return len;
}
