自学教程：C++ u_strncpy函数代码示例

/** * 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;}

/* 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 voidupdateSrc(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:GetLocaleCurrencyNameGets 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_tu_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_tu_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_EXPORT2ulocdata_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;}

U_DRAFT int32_t U_EXPORT2ulocdata_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));//.........这里部分代码省略.........

//.........这里部分代码省略.........    // 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) {

/* 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_EXPORT2ubiditransform_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("[email
C++ u_terminateUChars函数代码示例
C++ u_strdup函数代码示例