796 lines
22 KiB
C
796 lines
22 KiB
C
/*
|
|
******************************************************************************
|
|
*
|
|
* Copyright (C) 2001-2003, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
******************************************************************************
|
|
*
|
|
* File ustrtrns.c
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 9/10/2001 Ram Creation.
|
|
******************************************************************************
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* u_strTo* and u_strFrom* APIs
|
|
*
|
|
*******************************************************************************
|
|
*/
|
|
|
|
|
|
#include "unicode/putil.h"
|
|
#include "unicode/ucnv.h"
|
|
#include "unicode/ustring.h"
|
|
#include "cstring.h"
|
|
#include "cwchar.h"
|
|
#include "cmemory.h"
|
|
#include "ustr_imp.h"
|
|
|
|
|
|
U_CAPI UBool /* U_CALLCONV U_EXPORT2 */
|
|
u_growAnyBufferFromStatic(void *context,
|
|
void **pBuffer, int32_t *pCapacity, int32_t reqCapacity,
|
|
int32_t length, int32_t size) {
|
|
|
|
void *newBuffer=uprv_malloc(reqCapacity*size);
|
|
if(newBuffer!=NULL) {
|
|
if(length>0) {
|
|
uprv_memcpy(newBuffer, *pBuffer, length*size);
|
|
}
|
|
*pCapacity=reqCapacity;
|
|
} else {
|
|
*pCapacity=0;
|
|
}
|
|
|
|
/* release the old pBuffer if it was not statically allocated */
|
|
if(*pBuffer!=(void *)context) {
|
|
uprv_free(*pBuffer);
|
|
}
|
|
|
|
*pBuffer=newBuffer;
|
|
return (UBool)(newBuffer!=NULL);
|
|
}
|
|
|
|
#define _STACK_BUFFER_CAPACITY 1000
|
|
|
|
U_CAPI UChar* U_EXPORT2
|
|
u_strFromUTF32(UChar *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const uint32_t *pSrc,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
int32_t reqLength = 0;
|
|
uint32_t ch =0;
|
|
UChar *pDestLimit =dest+destCapacity;
|
|
UChar *pDest = dest;
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
/* Check if the source is null terminated */
|
|
if(srcLength == -1 ){
|
|
while((ch=*pSrc)!=0){
|
|
if(pDest < pDestLimit){
|
|
++pSrc;
|
|
if(ch<=0xFFFF){
|
|
*(pDest++)=(UChar)ch;
|
|
}else{
|
|
*(pDest++)=(uint16_t)((ch>>10)+0xd7c0); /*UTF_FIRST_SURROGATE(ch);*/
|
|
if(pDest<pDestLimit){
|
|
*(pDest++)=(uint16_t)((ch&0x3ff)|0xdc00); /*UTF_SECOND_SURROGATE(ch);*/
|
|
}else{
|
|
reqLength++;
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
while((ch=*pSrc++) != 0){
|
|
reqLength+=UTF_CHAR_LENGTH(ch);
|
|
}
|
|
}else{
|
|
const uint32_t* pSrcLimit = pSrc + srcLength;
|
|
while(pSrc<pSrcLimit){
|
|
if(pDest < pDestLimit){
|
|
ch = *pSrc++;
|
|
if(ch<=0xFFFF){
|
|
*(pDest++)=(UChar)ch;
|
|
}else{
|
|
*(pDest++)=(uint16_t)((ch>>10)+0xd7c0); /*UTF_FIRST_SURROGATE(ch);*/
|
|
if(pDest<pDestLimit){
|
|
*(pDest++)=(uint16_t)((ch&0x3ff)|0xdc00); /*UTF_SECOND_SURROGATE(ch);*/
|
|
}else{
|
|
reqLength++;
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
while(pSrc <pSrcLimit){
|
|
ch = *pSrc++;
|
|
reqLength+=UTF_CHAR_LENGTH(ch);
|
|
}
|
|
}
|
|
|
|
/* return the required length */
|
|
reqLength+=(pDest - dest);
|
|
|
|
if(pDestLength){
|
|
*pDestLength = reqLength;
|
|
}
|
|
|
|
/* Terminate the buffer */
|
|
u_terminateUChars(dest,destCapacity,reqLength,pErrorCode);
|
|
|
|
return dest;
|
|
}
|
|
|
|
|
|
U_CAPI uint32_t* U_EXPORT2
|
|
u_strToUTF32(uint32_t *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const UChar *src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
const UChar* pSrc = src;
|
|
int32_t reqLength=0;
|
|
uint32_t ch=0;
|
|
int32_t index=0;
|
|
uint32_t *pDest = dest;
|
|
uint32_t *pDestLimit = dest + destCapacity;
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
if(srcLength == -1){
|
|
srcLength = u_strlen(pSrc);
|
|
}
|
|
|
|
while(index < srcLength){
|
|
if(pDest <pDestLimit){
|
|
UTF16_NEXT_CHAR_SAFE(src, index, srcLength, ch, TRUE);
|
|
if(ch!=UTF_ERROR_VALUE){
|
|
*(pDest++)= ch;
|
|
}else{
|
|
*pErrorCode = U_ILLEGAL_CHAR_FOUND;
|
|
return NULL;
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
/* donot fill the dest buffer just count the UChars needed */
|
|
while(index < srcLength){
|
|
UTF16_NEXT_CHAR_SAFE(src, index, srcLength, ch, TRUE);
|
|
if(ch!=UTF_ERROR_VALUE){
|
|
reqLength++;
|
|
}else{
|
|
*pErrorCode = U_ILLEGAL_CHAR_FOUND;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
reqLength+=(pDest - dest);
|
|
if(pDestLength){
|
|
*pDestLength = reqLength;
|
|
}
|
|
|
|
/* Terminate the buffer */
|
|
u_terminateUChar32s(dest,destCapacity,reqLength,pErrorCode);
|
|
|
|
return dest;
|
|
}
|
|
|
|
U_CAPI UChar* U_EXPORT2
|
|
u_strFromUTF8(UChar *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const char* src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
UChar *pDest = dest;
|
|
UChar *pDestLimit = dest+destCapacity;
|
|
UChar32 ch=0;
|
|
int32_t index = 0;
|
|
int32_t reqLength = 0;
|
|
uint8_t* pSrc = (uint8_t*) src;
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
if(srcLength == -1){
|
|
srcLength = uprv_strlen((char*)pSrc);
|
|
}
|
|
|
|
while(index < srcLength){
|
|
if(pDest <pDestLimit){
|
|
ch = pSrc[index++];
|
|
if(ch <=0x7f){
|
|
*pDest++=(UChar)ch;
|
|
}else{
|
|
ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, FALSE);
|
|
if(ch<=0xFFFF){
|
|
*(pDest++)=(UChar)ch;
|
|
}else{
|
|
*(pDest++)=(uint16_t)((ch>>10)+0xd7c0); /*UTF_FIRST_SURROGATE(ch);*/
|
|
if(pDest<pDestLimit){
|
|
*(pDest++)=(uint16_t)((ch&0x3ff)|0xdc00); /*UTF_SECOND_SURROGATE(ch);*/
|
|
}else{
|
|
reqLength++;
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
/* donot fill the dest buffer just count the UChars needed */
|
|
while(index < srcLength){
|
|
ch = pSrc[index++];
|
|
if(ch <= 0x7f){
|
|
reqLength++;
|
|
}else{
|
|
ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, FALSE);
|
|
reqLength+=UTF_CHAR_LENGTH(ch);
|
|
}
|
|
}
|
|
|
|
reqLength+=(pDest - dest);
|
|
|
|
if(pDestLength){
|
|
*pDestLength = reqLength;
|
|
}
|
|
|
|
/* Terminate the buffer */
|
|
u_terminateUChars(dest,destCapacity,reqLength,pErrorCode);
|
|
|
|
return dest;
|
|
}
|
|
|
|
U_CAPI char* U_EXPORT2
|
|
u_strToUTF8(char *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const UChar *pSrc,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
int32_t reqLength=0;
|
|
const UChar *pSrcLimit;
|
|
uint32_t ch;
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
if(srcLength == -1){
|
|
while(*pSrc!=0){
|
|
if(reqLength < destCapacity){
|
|
ch = *pSrc++;
|
|
if(ch<=0x7f) {
|
|
dest[reqLength++]=(uint8_t)ch;
|
|
} else {
|
|
int num = utf8_appendCharSafeBody((uint8_t*)dest, reqLength, destCapacity, ch);
|
|
if(num==reqLength){
|
|
*pErrorCode =U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
reqLength = num;
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
while(*pSrc!=0){
|
|
ch = *pSrc++;
|
|
reqLength+=UTF8_CHAR_LENGTH(ch);
|
|
}
|
|
}else{
|
|
pSrcLimit = pSrc + srcLength;
|
|
while(pSrc < pSrcLimit){
|
|
if(reqLength < destCapacity){
|
|
ch = *pSrc++;
|
|
if(ch<=0x7f) {
|
|
dest[reqLength++]=(uint8_t)ch;
|
|
} else {
|
|
int num = utf8_appendCharSafeBody((uint8_t*)dest, reqLength, destCapacity, ch);
|
|
if(num==reqLength){
|
|
*pErrorCode =U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
reqLength = num;
|
|
}
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
while(pSrc < pSrcLimit){
|
|
ch = *pSrc++;
|
|
reqLength+=UTF8_CHAR_LENGTH(ch);
|
|
}
|
|
}
|
|
if(destCapacity==0){
|
|
reqLength+=destCapacity;
|
|
}
|
|
if(pDestLength){
|
|
*pDestLength = reqLength;
|
|
}
|
|
|
|
/* Terminate the buffer */
|
|
u_terminateChars((char*)dest,destCapacity,reqLength,pErrorCode);
|
|
|
|
return (char*)dest;
|
|
}
|
|
|
|
/* helper function */
|
|
static wchar_t*
|
|
_strToWCS(wchar_t *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const UChar *src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
char stackBuffer [_STACK_BUFFER_CAPACITY];
|
|
char* tempBuf = stackBuffer;
|
|
int32_t tempBufCapacity = _STACK_BUFFER_CAPACITY;
|
|
char* tempBufLimit = stackBuffer + tempBufCapacity;
|
|
UConverter* conv = NULL;
|
|
char* saveBuf = tempBuf;
|
|
wchar_t* intTarget=NULL;
|
|
int count=0,retVal=0;
|
|
|
|
const UChar *pSrcLimit =NULL;
|
|
const UChar *pSrc = src;
|
|
pSrcLimit = pSrc + srcLength;
|
|
conv = u_getDefaultConverter(pErrorCode);
|
|
do{
|
|
/* convert to chars using default converter */
|
|
ucnv_fromUnicode(conv,&tempBuf,tempBufLimit,&pSrc,pSrcLimit,NULL,FALSE,pErrorCode);
|
|
|
|
/* This should rarely occur */
|
|
if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR){
|
|
int32_t count = tempBuf - saveBuf;
|
|
*pErrorCode=U_ZERO_ERROR;
|
|
tempBuf = saveBuf;
|
|
/* we dont have enough room on the stack grow the buffer */
|
|
u_growAnyBufferFromStatic(stackBuffer,(void**) &tempBuf, &tempBufCapacity,
|
|
(tempBufCapacity+_STACK_BUFFER_CAPACITY), count,sizeof(char));
|
|
|
|
saveBuf = tempBuf;
|
|
tempBufLimit = tempBuf + tempBufCapacity;
|
|
tempBuf = tempBuf + count;
|
|
/* to flush the converters internal state when pSrc<pSrcLimit */
|
|
continue;
|
|
|
|
}
|
|
|
|
}while (pSrc<pSrcLimit);
|
|
|
|
count =(tempBuf - saveBuf);
|
|
|
|
/* allocate more space than required
|
|
* here we assume that every char requires
|
|
* no more than 2 wchar_ts
|
|
*/
|
|
intTarget = (wchar_t*)uprv_malloc( ((count * 2)+1/* for null termination */) * sizeof(wchar_t) );
|
|
|
|
if(intTarget){
|
|
|
|
int nulLen = 0;
|
|
wchar_t* pIntTarget=intTarget;
|
|
|
|
/* null terminate the UChar buffer */
|
|
u_terminateChars((char*)saveBuf,(tempBufLimit-saveBuf),count,pErrorCode);
|
|
|
|
tempBuf = saveBuf;
|
|
|
|
/* now convert the mbs to wcs */
|
|
for(;;){
|
|
|
|
/* we can call the system API since we are sure that
|
|
* there is atleast 1 null in the input
|
|
*/
|
|
retVal = uprv_mbstowcs(pIntTarget,(tempBuf+nulLen),(count+1));
|
|
|
|
if(retVal==-1){
|
|
*pErrorCode = U_INVALID_CHAR_FOUND;
|
|
break;
|
|
}
|
|
|
|
/*scan for nulls */
|
|
/* we donot check for limit since tempBuf is null terminated */
|
|
while(tempBuf[nulLen++] != 0){
|
|
}
|
|
|
|
/* check if we have reached the source limit*/
|
|
if(nulLen>=(count)){
|
|
break;
|
|
}
|
|
pIntTarget = pIntTarget + retVal+1/* for terminating null*/;
|
|
}
|
|
|
|
if(count < destCapacity){
|
|
uprv_memcpy(dest,intTarget,count*sizeof(wchar_t));
|
|
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
|
|
if(pDestLength){
|
|
*pDestLength = count;
|
|
}
|
|
|
|
/* free the allocated memory */
|
|
uprv_free(intTarget);
|
|
|
|
}else{
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
|
|
/* are we still using stack buffer */
|
|
if(stackBuffer != saveBuf){
|
|
uprv_free(saveBuf);
|
|
}
|
|
u_terminateWChars(dest,destCapacity,count,pErrorCode);
|
|
|
|
u_releaseDefaultConverter(conv);
|
|
|
|
return dest;
|
|
}
|
|
|
|
U_CAPI wchar_t* U_EXPORT2
|
|
u_strToWCS(wchar_t *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const UChar *src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
const UChar *pSrc = src;
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
if(srcLength == -1){
|
|
srcLength = u_strlen(pSrc);
|
|
}
|
|
|
|
#ifdef U_WCHAR_IS_UTF16
|
|
/* wchar_t is UTF-16 just do a memcpy */
|
|
if(srcLength==-1){
|
|
srcLength =0;
|
|
while(pSrc[srcLength++]!=0){
|
|
}
|
|
}
|
|
if(srcLength <= destCapacity){
|
|
uprv_memcpy(dest,src,srcLength*U_SIZEOF_UCHAR);
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
if(pDestLength){
|
|
*pDestLength = srcLength;
|
|
}
|
|
|
|
u_terminateUChars(dest,destCapacity,srcLength,pErrorCode);
|
|
|
|
return dest;;
|
|
#elif defined U_WCHAR_IS_UTF32
|
|
|
|
return u_strToUTF32(dest,destCapacity,pDestLength,src,srcLength,pErrorCode);
|
|
|
|
#else
|
|
|
|
return _strToWCS(dest,destCapacity,pDestLength,src,srcLength, pErrorCode);
|
|
|
|
#endif
|
|
}
|
|
|
|
/* helper function */
|
|
static UChar*
|
|
_strFromWCS( UChar *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const wchar_t *src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
int32_t retVal =0, count =0 ;
|
|
UConverter* conv = NULL;
|
|
UChar* pTarget = NULL;
|
|
UChar* pTargetLimit = NULL;
|
|
|
|
UChar uStack [_STACK_BUFFER_CAPACITY];
|
|
|
|
wchar_t wStack[_STACK_BUFFER_CAPACITY];
|
|
wchar_t* pWStack = wStack;
|
|
|
|
|
|
char cStack[_STACK_BUFFER_CAPACITY];
|
|
int32_t cStackCap = _STACK_BUFFER_CAPACITY;
|
|
char* pCSrc=cStack;
|
|
char* pCSave=pCSrc;
|
|
char* pCSrcLimit=NULL;
|
|
|
|
const wchar_t* pSrc = src;
|
|
const wchar_t* pSrcLimit = NULL;
|
|
|
|
if(srcLength ==-1){
|
|
/* if the wchar_t source is null terminated we can safely
|
|
* assume that there are no embedded nulls, this is a fast
|
|
* path for null terminated strings.
|
|
*/
|
|
for(;;){
|
|
/* convert wchars to chars */
|
|
retVal = uprv_wcstombs(pCSrc,src, cStackCap);
|
|
|
|
if(retVal == -1){
|
|
*pErrorCode = U_ILLEGAL_CHAR_FOUND;
|
|
goto cleanup;
|
|
}else if(retVal == cStackCap){
|
|
/* Should rarely occur */
|
|
u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap,
|
|
cStackCap*2,0,sizeof(char));
|
|
pCSave = pCSrc;
|
|
}else{
|
|
/* converted every thing */
|
|
pCSrc = pCSrc+retVal;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}else{
|
|
/* here the source is not null terminated
|
|
* so it may have nulls embeded and we need to
|
|
* do some extra processing
|
|
*/
|
|
int32_t remaining =cStackCap;
|
|
|
|
pSrcLimit = src + srcLength;
|
|
|
|
for(;;){
|
|
int32_t nulLen = 0;
|
|
|
|
/* find nulls in the string */
|
|
while((pSrc+nulLen)<pSrcLimit && pSrc[nulLen++]!=0){
|
|
}
|
|
|
|
|
|
if((pSrc+nulLen != pSrcLimit)){
|
|
/* check if we have enough room in pCSrc */
|
|
if(remaining < (nulLen * MB_CUR_MAX)){
|
|
/* should rarely occur */
|
|
int32_t len = (pCSrc-pCSave);
|
|
pCSrc = pCSave;
|
|
/* we do not have enough room so grow the buffer*/
|
|
u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap,
|
|
2*cStackCap+(nulLen*MB_CUR_MAX),len,sizeof(char));
|
|
|
|
pCSave = pCSrc;
|
|
pCSrc = pCSave+len;
|
|
remaining = cStackCap-(pCSrc - pCSave);
|
|
}
|
|
|
|
/* we have found a null so convert the
|
|
* chunk from begining of non-null char to null
|
|
*/
|
|
retVal = uprv_wcstombs(pCSrc,pSrc,remaining);
|
|
|
|
if(retVal==-1){
|
|
/* an error occurred bail out */
|
|
*pErrorCode = U_ILLEGAL_CHAR_FOUND;
|
|
goto cleanup;
|
|
}
|
|
|
|
pCSrc = pCSrc + retVal+1 /* already null terminated */;
|
|
|
|
pSrc = pSrc+nulLen; /* skip past the null */
|
|
|
|
remaining -= (pCSrc-pCSave);
|
|
|
|
|
|
}else{
|
|
/* the source is not null terminated and we are
|
|
* end of source so we copy the source to a temp buffer
|
|
* null terminate it and convert wchar_ts to chars
|
|
*/
|
|
if(nulLen > _STACK_BUFFER_CAPACITY){
|
|
/* Should rarely occcur */
|
|
/* allocate new buffer buffer */
|
|
pWStack =(wchar_t*) uprv_malloc(sizeof(wchar_t) * nulLen);
|
|
}
|
|
/* copy the contents to tempStack */
|
|
uprv_memcpy(pWStack,pSrc,nulLen*sizeof(wchar_t));
|
|
|
|
/* null terminate the tempBuffer */
|
|
pWStack[nulLen] =0 ;
|
|
|
|
if(remaining < (nulLen * MB_CUR_MAX)){
|
|
/* Should rarely occur */
|
|
int32_t len = (pCSrc-pCSave);
|
|
pCSrc = pCSave;
|
|
/* we do not have enough room so grow the buffer*/
|
|
u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap,
|
|
cStackCap+(nulLen*MB_CUR_MAX),len,sizeof(char));
|
|
|
|
pCSave = pCSrc;
|
|
pCSrc = pCSave+len;
|
|
remaining = cStackCap-(pCSrc - pCSave);
|
|
}
|
|
/* convert to chars */
|
|
retVal = uprv_wcstombs(pCSrc,pWStack,remaining);
|
|
|
|
pCSrc = pCSrc+retVal +1;
|
|
pSrc = pSrc + nulLen;
|
|
}
|
|
|
|
/* ran out of input, break */
|
|
if(pSrc >= pSrcLimit){
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* OK..now we have converted from wchar_ts to chars now
|
|
* convert chars to UChars
|
|
*/
|
|
pCSrcLimit = pCSrc;
|
|
pCSrc = pCSave;
|
|
pTarget = dest;
|
|
pTargetLimit = dest + destCapacity;
|
|
|
|
conv= u_getDefaultConverter(pErrorCode);
|
|
|
|
/* convert and write to the target */
|
|
ucnv_toUnicode(conv,&pTarget,pTargetLimit,(const char**)&pCSrc,pCSrcLimit,NULL,FALSE,pErrorCode);
|
|
/* count the number converted */
|
|
count=pTarget - dest;
|
|
|
|
while(*pErrorCode ==U_BUFFER_OVERFLOW_ERROR){
|
|
|
|
*pErrorCode = U_ZERO_ERROR;
|
|
|
|
pTarget = uStack;
|
|
pTargetLimit = uStack + _STACK_BUFFER_CAPACITY;
|
|
|
|
/* convert to stack buffer*/
|
|
ucnv_toUnicode(conv,&pTarget,pTargetLimit,(const char**)&pCSrc,pCSrcLimit,NULL,FALSE,pErrorCode);
|
|
|
|
/* increment count to number written to stack */
|
|
count+= pTarget - uStack;
|
|
}
|
|
|
|
if(pDestLength){
|
|
*pDestLength =count;
|
|
}
|
|
|
|
u_terminateUChars(dest,destCapacity,count,pErrorCode);
|
|
|
|
cleanup:
|
|
|
|
if(cStack != pCSave){
|
|
uprv_free(pCSave);
|
|
}
|
|
|
|
if(wStack != pWStack){
|
|
uprv_free(pWStack);
|
|
}
|
|
|
|
u_releaseDefaultConverter(conv);
|
|
|
|
return dest;
|
|
}
|
|
|
|
U_CAPI UChar* U_EXPORT2
|
|
u_strFromWCS(UChar *dest,
|
|
int32_t destCapacity,
|
|
int32_t *pDestLength,
|
|
const wchar_t *src,
|
|
int32_t srcLength,
|
|
UErrorCode *pErrorCode){
|
|
|
|
const wchar_t* pSrc = src;
|
|
|
|
|
|
/* args check */
|
|
if(pErrorCode && U_FAILURE(*pErrorCode)){
|
|
return NULL;
|
|
}
|
|
|
|
if((srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef U_WCHAR_IS_UTF16
|
|
/* wchar_t is UTF-16 just do a memcpy */
|
|
if(srcLength==-1){
|
|
srcLength =0;
|
|
while(pSrc[srcLength++]!=0){
|
|
}
|
|
}
|
|
if(srcLength <= destCapacity){
|
|
uprv_memcpy(dest,src,srcLength*U_SIZEOF_UCHAR);
|
|
}else{
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
if(pDestLength){
|
|
*pDestLength = srcLength;
|
|
}
|
|
|
|
u_terminateUChars(dest,destCapacity,srcLength,pErrorCode);
|
|
|
|
return dest;
|
|
|
|
#elif defined U_WCHAR_IS_UTF32
|
|
|
|
return u_strFromUTF32(dest,destCapacity,pDestLength,src,srcLength,pErrorCode);
|
|
|
|
#else
|
|
|
|
return _strFromWCS(dest,destCapacity,pDestLength,src,srcLength,pErrorCode);
|
|
|
|
#endif
|
|
|
|
}
|