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

static int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString){    UErrorCode status = U_ZERO_ERROR;    int32_t len = 0;    // preflight to get the destination buffer size    u_strToUTF8(NULL,                0,                &len,                outString.getBuffer(),                outString.length(),                &status);    // allocate the buffer    char* dest = (char*)uprv_malloc(len);    status = U_ZERO_ERROR;    // convert the data    u_strToUTF8(dest,                len,                &len,                outString.getBuffer(),                outString.length(),                &status);    // write data to out file    int32_t ret = T_FileStream_write(fileStream, dest, len);    uprv_free(dest);    return (ret);}

    UTrie2PerfTest(int32_t argc, const char *argv[], UErrorCode &status)            : UPerfTest(argc, argv, NULL, 0, "", status),              utf8(NULL), utf8Length(0), countInputCodePoints(0) {        if (U_SUCCESS(status)) {#if 0       // See comment at unorm_initUTrie2() forward declaration.            unorm_initUTrie2(&status);            ubidi_initUTrie2(&status);#endif            int32_t inputLength;            UPerfTest::getBuffer(inputLength, status);            if(U_SUCCESS(status) && inputLength>0) {                countInputCodePoints = u_countChar32(buffer, bufferLen);                // Preflight the UTF-8 length and allocate utf8.                u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);                if(status==U_BUFFER_OVERFLOW_ERROR) {                    utf8=(char *)malloc(utf8Length);                    if(utf8!=NULL) {                        status=U_ZERO_ERROR;                        u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);                    } else {                        status=U_MEMORY_ALLOCATION_ERROR;                    }                }                if(verbose) {                    printf("code points:%ld  len16:%ld  len8:%ld  "                           "B/cp:%.3g/n",                           (long)countInputCodePoints, (long)bufferLen, (long)utf8Length,                           (double)utf8Length/countInputCodePoints);                }            }        }    }

static gchar *ustring_to_utf8 (const UChar *ustr, int32_t ustrLength){  gchar *dest;  int32_t destLength;  UErrorCode errorCode;  errorCode = 0;  u_strToUTF8 (NULL, 0, &destLength, ustr, ustrLength, &errorCode);  if (errorCode != U_BUFFER_OVERFLOW_ERROR)    {      g_warning ("can't get the number of byte required to convert ustring: %s",		 u_errorName (errorCode));      return NULL;    }  dest = g_malloc0 (destLength + 1);  errorCode = 0;  u_strToUTF8 (dest, destLength + 1, NULL, ustr, ustrLength, &errorCode);  if (errorCode != U_ZERO_ERROR)    {      g_free (dest);      g_warning ("can't convert ustring to UTF-8 string: %s",		 u_errorName (errorCode));      return NULL;    }  return dest;}

UErrorCode icu_utf16_to_utf8(struct icu_buf_utf8 *dest8,                             const struct icu_buf_utf16 *src16,                             UErrorCode *status){    int32_t utf8_len = 0;    u_strToUTF8((char *) dest8->utf8, dest8->utf8_cap,                &utf8_len,                src16->utf16, src16->utf16_len, status);    /* check for buffer overflow, resize and retry */    if (*status == U_BUFFER_OVERFLOW_ERROR)    {        icu_buf_utf8_resize(dest8, utf8_len * 2);        *status = U_ZERO_ERROR;        u_strToUTF8((char *) dest8->utf8, dest8->utf8_cap,                    &utf8_len,                    src16->utf16, src16->utf16_len, status);    }    if (U_SUCCESS(*status) && utf8_len <= dest8->utf8_cap)        dest8->utf8_len = utf8_len;    else        icu_buf_utf8_clear(dest8);    return *status;}

static VALUE to_utf8(UChar *ustr, int32_t ulen) {    char buffer[BUF_SIZE];    int32_t len = 0;    UErrorCode status = U_ZERO_ERROR;    /* Figure out the size of the buffer we need to allocate: */    u_strToUTF8(buffer, 0, &len, ustr, ulen, &status);    if (status == U_INVALID_CHAR_FOUND)        len = 0;    else if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)        return Qnil;    /* Allocate the buffer and encode into it: */    status = U_ZERO_ERROR;    char *ptr = ALLOC_N(char, len);    u_strToUTF8(ptr, len, &len, ustr, ulen, &status);    if (U_FAILURE(status)) {        xfree(ptr);        return Qnil;    }    VALUE str = rb_enc_str_new(ptr, len, rb_utf8_encoding());    xfree(ptr);    return str;;}

//ret_utf_str must be freed after usage. -1 on icu_str_sz will assume//icu_str is null terminatedstatic intutf8_from_icu_str_slice(const UChar *icu_str,    int32_t icu_str_sz,    char **ret_utf_str,    UErrorCode *ret_icu_err){    int32_t utf_sz;    SOL_NULL_CHECK(ret_utf_str, -EINVAL);    SOL_NULL_CHECK(ret_icu_err, -EINVAL);    *ret_icu_err = U_ZERO_ERROR;    u_strToUTF8(NULL, 0, &utf_sz, icu_str, icu_str_sz, ret_icu_err);    if (U_FAILURE(*ret_icu_err) && *ret_icu_err != U_BUFFER_OVERFLOW_ERROR)        return -EINVAL;    *ret_utf_str = calloc(utf_sz + 1, sizeof(char));    SOL_NULL_CHECK(*ret_utf_str, -ENOMEM);    *ret_icu_err = U_ZERO_ERROR;    u_strToUTF8(*ret_utf_str, utf_sz + 1, NULL, icu_str, icu_str_sz,        ret_icu_err);    if (U_FAILURE(*ret_icu_err) || (*ret_utf_str)[utf_sz] != '/0') {        free(*ret_utf_str);        *ret_utf_str = NULL;        return -EINVAL;    }    return 0;}

/* append a full case mapping result, see UCASE_MAX_STRING_LENGTH */static U_INLINE int32_tappendResult(uint8_t *dest, int32_t destIndex, int32_t destCapacity,             int32_t result, const UChar *s) {    UChar32 c;    int32_t length, destLength;    UErrorCode errorCode;    /* decode the result */    if(result<0) {        /* (not) original code point */        c=~result;        length=-1;    } else if(result<=UCASE_MAX_STRING_LENGTH) {        c=U_SENTINEL;        length=result;    } else {        c=result;        length=-1;    }    if(destIndex<destCapacity) {        /* append the result */        if(length<0) {            /* code point */            UBool isError=FALSE;            U8_APPEND(dest, destIndex, destCapacity, c, isError);            if(isError) {                /* overflow, nothing written */                destIndex+=U8_LENGTH(c);            }        } else {            /* string */            errorCode=U_ZERO_ERROR;            u_strToUTF8(                (char *)(dest+destIndex), destCapacity-destIndex, &destLength,                s, length,                &errorCode);            destIndex+=destLength;            /* we might have an overflow, but we know the actual length */        }    } else {        /* preflight */        if(length<0) {            destIndex+=U8_LENGTH(c);        } else {            errorCode=U_ZERO_ERROR;            u_strToUTF8(                NULL, 0, &destLength,                s, length,                &errorCode);            destIndex+=destLength;        }    }    return destIndex;}

inline void do_to_utf8(    ErlNifBinary  in,    ErlNifBinary& out,     int32_t& len,    UErrorCode& status) {    status = U_ZERO_ERROR;    if (!enif_alloc_binary(len, &out)) {        status = U_MEMORY_ALLOCATION_ERROR;        return;    }    u_strToUTF8(         (char*) out.data,  /* dest */        len,         &len,         (const UChar*) in.data, /* src */        TO_ULEN(in.size),       /* len of src */        &status);    if (U_FAILURE(status)) {        enif_release_binary(&out);        return;    }    if (len != (int32_t) out.size) {        /* shrink binary if it was too large */        enif_realloc_binary(&out, len);    }}

char *ICUStringMgr::upperUTF8(char *buf, unsigned int maxlen) const {	char *ret = buf;	int max = (maxlen) ? maxlen : strlen(buf);			UErrorCode err = U_ZERO_ERROR;			if (!buf || !max) {		return ret;	}			UChar *lowerStr = new UChar[max+10];	UChar *upperStr = new UChar[max+10];			u_strFromUTF8(lowerStr, max+9, 0, buf, -1, &err);	if (err != U_ZERO_ERROR) {//		SWLog::getSystemLog()->logError("from: %s", u_errorName(err));		delete [] lowerStr;		delete [] upperStr;		return ret;	}	u_strToUpper(upperStr, max+9, lowerStr, -1, 0, &err);	if (err != U_ZERO_ERROR) {//		SWLog::getSystemLog()->logError("upperCase: %s", u_errorName(err));		delete [] lowerStr;		delete [] upperStr;		return ret;	}	ret = u_strToUTF8(ret, max, 0, upperStr, -1, &err);			delete [] lowerStr;	delete [] upperStr;	return ret;}

U_CAPI int32_t U_EXPORT2uspoof_getSkeletonUTF8(const USpoofChecker *sc,                       uint32_t type,                       const char *s,  int32_t length,                       char *dest, int32_t destCapacity,                       UErrorCode *status) {    // Lacking a UTF-8 normalization API, just converting the input to    // UTF-16 seems as good an approach as any.  In typical use, input will    // be an identifier, which is to say not too long for stack buffers.    if (U_FAILURE(*status)) {        return 0;    }    // Buffers for the UChar form of the input and skeleton strings.    UChar    smallInBuf[USPOOF_STACK_BUFFER_SIZE];    UChar   *inBuf = smallInBuf;    UChar    smallOutBuf[USPOOF_STACK_BUFFER_SIZE];    UChar   *outBuf = smallOutBuf;    int32_t  lengthInUChars = 0;    int32_t  skelLengthInUChars = 0;    int32_t  skelLengthInUTF8 = 0;        u_strFromUTF8(inBuf, USPOOF_STACK_BUFFER_SIZE, &lengthInUChars,                  s, length, status);    if (*status == U_BUFFER_OVERFLOW_ERROR) {        inBuf = static_cast<UChar *>(uprv_malloc((lengthInUChars+1)*sizeof(UChar)));        if (inBuf == NULL) {            *status = U_MEMORY_ALLOCATION_ERROR;            goto cleanup;        }        *status = U_ZERO_ERROR;        u_strFromUTF8(inBuf, lengthInUChars+1, &lengthInUChars,                      s, length, status);    }        skelLengthInUChars = uspoof_getSkeleton(sc, type, inBuf, lengthInUChars,                                         outBuf, USPOOF_STACK_BUFFER_SIZE, status);    if (*status == U_BUFFER_OVERFLOW_ERROR) {        outBuf = static_cast<UChar *>(uprv_malloc((skelLengthInUChars+1)*sizeof(UChar)));        if (outBuf == NULL) {            *status = U_MEMORY_ALLOCATION_ERROR;            goto cleanup;        }        *status = U_ZERO_ERROR;        skelLengthInUChars = uspoof_getSkeleton(sc, type, inBuf, lengthInUChars,                                         outBuf, skelLengthInUChars+1, status);    }    u_strToUTF8(dest, destCapacity, &skelLengthInUTF8,                outBuf, skelLengthInUChars, status);  cleanup:    if (inBuf != smallInBuf) {        uprv_free(inBuf);    }    if (outBuf != smallOutBuf) {        uprv_free(outBuf);    }    return skelLengthInUTF8;}

U_CAPI int32_t U_EXPORT2uspoof_getSkeletonUTF8(const USpoofChecker *sc,                       uint32_t type,                       const char *id,  int32_t length,                       char *dest, int32_t destCapacity,                       UErrorCode *status) {    SpoofImpl::validateThis(sc, *status);    if (U_FAILURE(*status)) {        return 0;    }    if (length<-1 || destCapacity<0 || (destCapacity==0 && dest!=NULL)) {        *status = U_ILLEGAL_ARGUMENT_ERROR;        return 0;    }    UnicodeString srcStr = UnicodeString::fromUTF8(StringPiece(id, length>=0 ? length : uprv_strlen(id)));    UnicodeString destStr;    uspoof_getSkeletonUnicodeString(sc, type, srcStr, destStr, status);    if (U_FAILURE(*status)) {        return 0;    }    int32_t lengthInUTF8 = 0;    u_strToUTF8(dest, destCapacity, &lengthInUTF8,                destStr.getBuffer(), destStr.length(), status);    return lengthInUTF8;}

int cq_select_all(struct dbconn con, const char *table, struct dlist **out,        const char *conditions){    int rc;    char *query;    const char *fmt = u8"* FROM %s %s";    query = calloc(CQ_QLEN, sizeof(char));    if (query == NULL)        return -10;    UChar *buf16 = calloc(CQ_QLEN, sizeof(UChar));    if (buf16 == NULL) {        free(query);        return -11;    }    rc = u_snprintf(buf16, CQ_QLEN, fmt, table, conditions);    if ((size_t) rc >= CQ_QLEN) {        free(query);        free(buf16);        return 100;    }    UErrorCode status = U_ZERO_ERROR;    u_strToUTF8(query, CQ_QLEN, NULL, buf16, u_strlen(buf16), &status);    free(buf16);    if (!U_SUCCESS(status)) {        free(query);        return 101;    }    rc = cq_select_query(con, out, query);    return rc;}

static VALUE to_utf8(UChar *ustr, int32_t ulen) {    char str[BUF_SIZE];    int32_t len = 0;    UErrorCode status = U_ZERO_ERROR;    u_strToUTF8(str, BUF_SIZE, &len, ustr, ulen, &status);    if (status == U_INVALID_CHAR_FOUND) len = 0;    return rb_str_new(str, len);}

int cq_fields_to_utf8(char *buf, size_t buflen, size_t fieldc,        char **fieldnames, bool usequotes){    UChar *buf16;    UErrorCode status = U_ZERO_ERROR;    size_t num_left = fieldc;    int rc = 0;    if (num_left == 0)        return 1;    buf16 = calloc(buflen, sizeof(UChar));    if (buf16 == NULL)        return -1;    for (size_t i = 0; i < fieldc; ++i) {        UChar *temp = calloc(buflen, sizeof(UChar));        if (temp == NULL) {            rc = -2;            break;        }        u_strFromUTF8(temp, buflen, NULL, fieldnames[i], strlen(fieldnames[i]),                &status);        if (!U_SUCCESS(status)) {            rc = 2;            free(temp);            break;        }        bool isstr = false;        if (usequotes) {            for (int32_t j = 0; j < u_strlen(temp); ++j) {                if (!isdigit(temp[j])) {                    isstr = true;                    break;                }            }        }        if (isstr) u_strcat(buf16, u"'");        u_strcat(buf16, temp);        if (isstr) u_strcat(buf16, u"'");        free(temp);        if (--num_left > 0) {            u_strcat(buf16, u",");        }    }    u_strToUTF8(buf, buflen, NULL, buf16, u_strlen(buf16), &status);    if (!U_SUCCESS(status))        rc = 3;    free(buf16);    return rc;}

static void TestFPos_SkelWithSeconds(){	const LocaleAndSkeletonItem * locSkelItemPtr;	for (locSkelItemPtr = locSkelItems; locSkelItemPtr->locale != NULL; locSkelItemPtr++) {	    UDateIntervalFormat* udifmt;	    UChar   ubuf[kSizeUBuf];	    int32_t ulen, uelen;	    UErrorCode status = U_ZERO_ERROR;	    	    u_strFromUTF8(ubuf, kSizeUBuf, &ulen, locSkelItemPtr->skeleton, -1, &status);	    udifmt = udtitvfmt_open(locSkelItemPtr->locale, ubuf, ulen, zoneGMT, -1, &status);	    if ( U_FAILURE(status) ) {           log_data_err("FAIL: udtitvfmt_open for locale %s, skeleton %s: %s/n",                    locSkelItemPtr->locale, locSkelItemPtr->skeleton, u_errorName(status));	    } else {			const double * deltasPtr = deltas;			const ExpectPosAndFormat * expectedPtr = locSkelItemPtr->expected;			for (; *deltasPtr >= 0.0; deltasPtr++, expectedPtr++) {			    UFieldPosition fpos = { locSkelItemPtr->fieldToCheck, 0, 0 };			    UChar uebuf[kSizeUBuf];			    char bbuf[kSizeBBuf];			    char bebuf[kSizeBBuf];			    status = U_ZERO_ERROR;			    uelen = u_unescape(expectedPtr->format, uebuf, kSizeUBuf);			    ulen = udtitvfmt_format(udifmt, startTime, startTime + *deltasPtr, ubuf, kSizeUBuf, &fpos, &status);			    if ( U_FAILURE(status) ) {			        log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %.1f: %s/n",			             locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr, u_errorName(status));			    } else if ( ulen != uelen || u_strncmp(ubuf,uebuf,uelen) != 0 ||			                fpos.beginIndex != expectedPtr->posBegin || fpos.endIndex != expectedPtr->posEnd ) {			        u_strToUTF8(bbuf, kSizeBBuf, NULL, ubuf, ulen, &status);			        u_strToUTF8(bebuf, kSizeBBuf, NULL, uebuf, uelen, &status); // convert back to get unescaped string			        log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %12.1f, expect %d-%d /"%s/", get %d-%d /"%s/"/n",			             locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr,			             expectedPtr->posBegin, expectedPtr->posEnd, bebuf,			             fpos.beginIndex, fpos.endIndex, bbuf);			    }			}	        udtitvfmt_close(udifmt);	    }    }}

String u8(const UChar *u16, int32_t u16_len, UErrorCode &error) {  error = U_ZERO_ERROR;  if (u16_len == 0) {    return empty_string();  }  int32_t outlen;  u_strToUTF8(nullptr, 0, &outlen, u16, u16_len, &error);  if (error != U_BUFFER_OVERFLOW_ERROR) {    return String();  }  String ret(outlen + 1, ReserveString);  char *out = ret.get()->mutableData();  error = U_ZERO_ERROR;  u_strToUTF8(out, outlen + 1, &outlen, u16, u16_len, &error);  if (U_FAILURE(error)) {    return String();  }  ret.setSize(outlen);  return ret;}

 inline const char* v8_String_to_utf8(v8::Local<v8::String> string) {     UErrorCode error_code = U_ZERO_ERROR;     uint16_t src[characters*2];     static char buffer[characters*4];     int32_t buffer_length;     string->Write(src, 0, characters*2);     u_strToUTF8(buffer, characters*4, &buffer_length, src, std::min(characters*2, string->Length()), &error_code);     if (error_code != U_ZERO_ERROR) {         throw UTF16_to_UTF8_Conversion_Error(error_code);     }     return buffer; }

    UnicodeSetPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status)            : UPerfTest(argc, argv, options, LENGTHOF(options), unisetperf_usage, status),              utf8(NULL), utf8Length(0), countInputCodePoints(0), spanCount(0) {        if (U_SUCCESS(status)) {            UnicodeString pattern=UnicodeString(options[SET_PATTERN].value, -1, US_INV).unescape();            set.applyPattern(pattern, status);            prefrozen=set;            if(0==strcmp(options[FAST_TYPE].value, "fast")) {                set.freeze();            }            int32_t inputLength;            UPerfTest::getBuffer(inputLength, status);            if(U_SUCCESS(status) && inputLength>0) {                countInputCodePoints = u_countChar32(buffer, bufferLen);                countSpans();                // Preflight the UTF-8 length and allocate utf8.                u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);                if(status==U_BUFFER_OVERFLOW_ERROR) {                    utf8=(char *)malloc(utf8Length);                    if(utf8!=NULL) {                        status=U_ZERO_ERROR;                        u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);                    } else {                        status=U_MEMORY_ALLOCATION_ERROR;                    }                }                if(verbose) {                    printf("code points:%ld  len16:%ld  len8:%ld  spans:%ld  "                           "cp/span:%.3g  UChar/span:%.3g  B/span:%.3g  B/cp:%.3g/n",                           (long)countInputCodePoints, (long)bufferLen, (long)utf8Length, (long)spanCount,                           (double)countInputCodePoints/spanCount, (double)bufferLen/spanCount, (double)utf8Length/spanCount,                           (double)utf8Length/countInputCodePoints);                }            }        }    }

U_CAPI int32_t U_EXPORT2uspoof_checkUTF8(const USpoofChecker *sc,                 const char *text, int32_t length,                 int32_t *position,                 UErrorCode *status) {    if (U_FAILURE(*status)) {        return 0;    }    UChar stackBuf[USPOOF_STACK_BUFFER_SIZE];    UChar* text16 = stackBuf;    int32_t len16;        u_strFromUTF8(text16, USPOOF_STACK_BUFFER_SIZE, &len16, text, length, status);    if (U_FAILURE(*status) && *status != U_BUFFER_OVERFLOW_ERROR) {        return 0;    }    if (*status == U_BUFFER_OVERFLOW_ERROR) {        text16 = static_cast<UChar *>(uprv_malloc(len16 * sizeof(UChar) + 2));        if (text16 == NULL) {            *status = U_MEMORY_ALLOCATION_ERROR;            return 0;        }        *status = U_ZERO_ERROR;        u_strFromUTF8(text16, len16+1, NULL, text, length, status);    }    int32_t position16 = -1;    int32_t result = uspoof_check(sc, text16, len16, &position16, status);    if (U_FAILURE(*status)) {        return 0;    }    if (position16 > 0) {        // Translate a UTF-16 based error position back to a UTF-8 offset.        // u_strToUTF8() in preflight mode is an easy way to do it.        U_ASSERT(position16 <= len16);        u_strToUTF8(NULL, 0, position, text16, position16, status);        if (position > 0) {            // position is the required buffer length from u_strToUTF8, which includes            // space for a terminating NULL, which we don't want, hence the -1.            *position -= 1;        }        *status = U_ZERO_ERROR;   // u_strToUTF8, above sets BUFFER_OVERFLOW_ERROR.    }    if (text16 != stackBuf) {        uprv_free(text16);    }    return result;    }

int helper_unicode_to_utf8(char *src, int src_len, char *dest, int dest_size){	int32_t size = 0;	UErrorCode status = 0;	UChar *unicode_src = (UChar *)src;	u_strToUTF8(dest, dest_size, &size, unicode_src, -1, &status);	h_retvm_if(U_FAILURE(status), CTS_ERR_ICU_FAILED,			"u_strToUTF8() Failed(%s)", u_errorName(status));	dest[size]='/0';	return CTS_SUCCESS;}

/*----------------------------------------------------------------------------------------------	This method uses an ICU function to convert a string from UTF-16 to UTF-8.	Assumptions:		If sourceLen is -1, it will be computed (by ICU)	Exit conditions:		<text>	Parameters:		<text>	Return value:		The number of characters required to store the fully-converted string			(which may be greater than targetLen)----------------------------------------------------------------------------------------------*/int UnicodeConverter::Convert(const UChar* source, int sourceLen,	char* target, int targetLen){	UErrorCode status = U_ZERO_ERROR;	int32_t spaceRequiredForData;	u_strToUTF8(target, targetLen, &spaceRequiredForData, source, sourceLen, &status);	if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)		throw std::runtime_error("Unable to convert from UTF-16 to UTF-8");	return spaceRequiredForData;}

void icu_iter_get_org_info2(yaz_icu_iter_t iter, size_t *start, size_t *len,                            const char **cstr){    int32_t len1 = 0, len2 = 0;    UErrorCode status = U_ZERO_ERROR;    if (iter->org_start < iter->utf16_base)    {        iter->utf8_base = 0;        iter->utf16_base = 0;    }    u_strToUTF8(0, 0, &len1,                iter->org->utf16 + iter->utf16_base,                iter->org_start - iter->utf16_base,                &status);    status = U_ZERO_ERROR;    *start = len1 + iter->utf8_base;    u_strToUTF8(0, 0, &len2,                iter->org->utf16 + iter->utf16_base,                iter->org_start - iter->utf16_base + iter->org_len,                &status);    *len = len2 - len1;    if (cstr)    {        if (!iter->org8)            iter->org8 = icu_buf_utf8_create(0);        status = U_ZERO_ERROR;        icu_utf16_to_utf8(iter->org8, iter->org, &status);        *cstr = icu_buf_utf8_to_cstr(iter->org8);    }    iter->utf8_base = *start;    iter->utf16_base = iter->org_start;}

void intl_convert_utf16_to_utf8(char** target, int* target_len,                                const UChar* src, int  src_len,                                UErrorCode*  status) {  char* dst_buf = NULL;  int32_t dst_len;  /* Determine required destination buffer size (pre-flighting). */  *status = U_ZERO_ERROR;  u_strToUTF8(NULL, 0, &dst_len, src, src_len, status);  /* Bail out if an unexpected error occured.   * (U_BUFFER_OVERFLOW_ERROR means that *target buffer is not large enough).   * (U_STRING_NOT_TERMINATED_WARNING usually means that the input string   * is empty).   */  if (*status != U_BUFFER_OVERFLOW_ERROR &&      *status != U_STRING_NOT_TERMINATED_WARNING) {    return;  }  // Allocate memory for the destination buffer (it will be zero-terminated).  dst_buf = (char *)malloc(dst_len + 1);  /* Convert source string from UTF-16 to UTF-8. */  *status = U_ZERO_ERROR;  u_strToUTF8(dst_buf, dst_len, NULL, src, src_len, status);  if (U_FAILURE(*status)) {    free(dst_buf);    return;  }  /* U_STRING_NOT_TERMINATED_WARNING is OK for us => reset 'status'. */  *status = U_ZERO_ERROR;  dst_buf[dst_len] = 0;  *target = dst_buf;  *target_len = dst_len;}

/* Writing Functions */static void string_write_java(struct SResource *res,UErrorCode *status) {           if(uprv_strcmp(srBundle->fKeys+res->fKey,"%%UCARULES")==0 ){        char fileName[1024] ={0};        const char* file = "UCARules.utf8";        FileStream* datFile = NULL;        const char* type = "new ICUListResourceBundle.ResourceString(";        char* dest  = (char*) uprv_malloc( 8 * res->u.fString.fLength);        int32_t len = 0;        if(outDir){            uprv_strcat(fileName,outDir);            if(outDir[uprv_strlen(outDir)-1]!=U_FILE_SEP_CHAR){                uprv_strcat(fileName,U_FILE_SEP_STRING);            }        }        uprv_strcat(fileName,file);/* UCARULES.utf8 UTF-8 file */                write_tabs(out);        T_FileStream_write(out, type, (int32_t)uprv_strlen(type));        T_FileStream_write(out, "/"", 1);        T_FileStream_write(out, file, (int32_t)uprv_strlen(file));        T_FileStream_write(out, "/")/n", 3);        datFile=T_FileStream_open(fileName,"w");                if(!dest){            *status=U_MEMORY_ALLOCATION_ERROR;        }                u_strToUTF8(dest,8*res->u.fString.fLength,&len,res->u.fString.fChars,res->u.fString.fLength,status);        if(U_FAILURE(*status)){            T_FileStream_close(datFile);            uprv_free(dest);            return;        }        T_FileStream_write(datFile,dest,len);        T_FileStream_close(datFile);        uprv_free(dest);               }else{        str_write_java(res->u.fString.fChars,res->u.fString.fLength,TRUE,status);        if(uprv_strcmp(srBundle->fKeys+res->fKey,"Rule")==0){            UChar* buf = (UChar*) uprv_malloc(sizeof(UChar)*res->u.fString.fLength);            uprv_memcpy(buf,res->u.fString.fChars,res->u.fString.fLength);                  uprv_free(buf);        }    }}

inline void writeUTF8String(std::ostream& output, const UChar *str, size_t len = 0) {	if (len == 0) {		len = u_strlen(str);	}	std::vector<char> buffer(len * 4);	int32_t olen = 0;	UErrorCode status = U_ZERO_ERROR;	u_strToUTF8(&buffer[0], len * 4 - 1, &olen, str, len, &status);	uint16_t cs = static_cast<uint16_t>(olen);	writeRaw(output, cs);	output.write(&buffer[0], cs);}

/* {{{ intl_convert_utf16_to_utf8 * Convert given string from UTF-16 to UTF-8. * * @param source      String to convert. * @param source_len  Length of the source string. * @param status      Conversion status. * * @return zend_string */zend_string* intl_convert_utf16_to_utf8(	const UChar* src,    int32_t  src_len,	UErrorCode*  status ){	zend_string* dst;	int32_t      dst_len;	/* Determine required destination buffer size (pre-flighting). */	*status = U_ZERO_ERROR;	u_strToUTF8( NULL, 0, &dst_len, src, src_len, status );	/* Bail out if an unexpected error occurred.	 * (U_BUFFER_OVERFLOW_ERROR means that *target buffer is not large enough).	 * (U_STRING_NOT_TERMINATED_WARNING usually means that the input string is empty).	 */	if( *status != U_BUFFER_OVERFLOW_ERROR && *status != U_STRING_NOT_TERMINATED_WARNING )		return NULL;	/* Allocate memory for the destination buffer (it will be zero-terminated). */	dst = zend_string_alloc(dst_len, 0);	/* Convert source string from UTF-8 to UTF-16. */	*status = U_ZERO_ERROR;	u_strToUTF8( ZSTR_VAL(dst), dst_len, NULL, src, src_len, status );	if( U_FAILURE( *status ) )	{		zend_string_free(dst);		return NULL;	}	/* U_STRING_NOT_TERMINATED_WARNING is OK for us => reset 'status'. */	*status = U_ZERO_ERROR;	ZSTR_VAL(dst)[dst_len] = 0;	return dst;}

/* * Generate a text file with spaces in it from a file without. */int generateFile(const UChar *chars, int32_t length) {    Locale root("");    UCharCharacterIterator *noSpaceIter = new UCharCharacterIterator(chars, length);    UErrorCode status = U_ZERO_ERROR;        UnicodeSet complexContext(UNICODE_STRING_SIMPLE("[:LineBreak=SA:]"), status);    BreakIterator *breakIter = BreakIterator::createWordInstance(root, status);    breakIter->adoptText(noSpaceIter);    char outbuf[1024];    int32_t strlength;    UChar bom = 0xFEFF;        printf("%s", u_strToUTF8(outbuf, sizeof(outbuf), &strlength, &bom, 1, &status));    int32_t prevbreak = 0;    while (U_SUCCESS(status)) {        int32_t nextbreak = breakIter->next();        if (nextbreak == BreakIterator::DONE) {            break;        }        printf("%s", u_strToUTF8(outbuf, sizeof(outbuf), &strlength, &chars[prevbreak],                                    nextbreak-prevbreak, &status));        if (nextbreak > 0 && complexContext.contains(chars[nextbreak-1])            && complexContext.contains(chars[nextbreak])) {            printf(" ");        }        prevbreak = nextbreak;    }        if (U_FAILURE(status)) {        fprintf(stderr, "generate failed: %s/n", u_errorName(status));        return status;    }    else {        return 0;    }}

// There are quicker ways to do this conversion, but it's necessary to follow// this to match the functionality of fbcode/multifeed/text/TokenizeTextMap.cpp.std::string icuStringToUTF8(const UnicodeString& ustr) {  UErrorCode status = U_ZERO_ERROR;  int32_t bufSize = 0;  std::string result;  // Calculate the size of the buffer needed to hold ustr, converted to UTF-8.  u_strToUTF8(NULL, 0, &bufSize, ustr.getBuffer(), ustr.length(), &status);  if (status != U_BUFFER_OVERFLOW_ERROR &&      status != U_STRING_NOT_TERMINATED_WARNING) {    return result;  }  result.resize(bufSize);  status = U_ZERO_ERROR;  u_strToUTF8(&result[0], bufSize, NULL, ustr.getBuffer(), ustr.length(),              &status);  if (U_FAILURE(status)) {    result.clear();  }  return result;}

 int add_string_attribute(int n, v8::Local<v8::Value> value) const {     uint16_t source[(max_dbf_field_length+2)*2];     char dest[(max_dbf_field_length+1)*4];     memset(source, 0, (max_dbf_field_length+2)*4);     memset(dest, 0, (max_dbf_field_length+1)*4);     int32_t dest_length;     UErrorCode error_code = U_ZERO_ERROR;     value->ToString()->Write(source, 0, max_dbf_field_length+1);     u_strToUTF8(dest, m_fields[n].width(), &dest_length, source, std::min(max_dbf_field_length+1, value->ToString()->Length()), &error_code);     if (error_code == U_BUFFER_OVERFLOW_ERROR) {         // thats ok, it just means we clip the text at that point     } else if (U_FAILURE(error_code)) {         throw std::runtime_error("UTF-16 to UTF-8 conversion failed");     }     return DBFWriteStringAttribute(m_dbf_handle, m_current_shape, n, dest); }

 static void add_string_attribute(Osmium::Export::Shapefile* shapefile, int n, v8::Local<v8::Value> value) {     uint16_t source[(Osmium::Export::Shapefile::max_dbf_field_length+2)*2];     char dest[(Osmium::Export::Shapefile::max_dbf_field_length+1)*4];     memset(source, 0, (Osmium::Export::Shapefile::max_dbf_field_length+2)*4);     memset(dest, 0, (Osmium::Export::Shapefile::max_dbf_field_length+1)*4);     int32_t dest_length;     UErrorCode error_code = U_ZERO_ERROR;     value->ToString()->Write(source, 0, Osmium::Export::Shapefile::max_dbf_field_length+1);     u_strToUTF8(dest, shapefile->field(n).width(), &dest_length, source, std::min(Osmium::Export::Shapefile::max_dbf_field_length+1, value->ToString()->Length()), &error_code);     if (error_code == U_BUFFER_OVERFLOW_ERROR) {         // thats ok, it just means we clip the text at that point     } else if (U_FAILURE(error_code)) {         throw std::runtime_error("UTF-16 to UTF-8 conversion failed");     }     shapefile->add_attribute(n, dest); }