| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 2001-2012, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: ustr_wcs.cpp | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2004sep07 | |
| * created by: Markus W. Scherer | |
| * | |
| * u_strToWCS() and u_strFromWCS() functions | |
| * moved here from ustrtrns.c for better modularization. | |
| */ | |
| #include "unicode/utypes.h" | |
| #include "unicode/ustring.h" | |
| #include "cstring.h" | |
| #include "cwchar.h" | |
| #include "cmemory.h" | |
| #include "ustr_imp.h" | |
| #include "ustr_cnv.h" | |
| #if defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32) || !UCONFIG_NO_CONVERSION | |
| #define _STACK_BUFFER_CAPACITY 1000 | |
| #define _BUFFER_CAPACITY_MULTIPLIER 2 | |
| #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) | |
| #if defined(STARBOARD) | |
| #error "Starboard does not (yet) have wcstombs." | |
| #endif | |
| // TODO: We should use CharString for char buffers and UnicodeString for UChar buffers. | |
| // Then we could change this to work only with wchar_t buffers. | |
| static inline UBool | |
| u_growAnyBufferFromStatic(void *context, | |
| void **pBuffer, int32_t *pCapacity, int32_t reqCapacity, | |
| int32_t length, int32_t size) { | |
| // Use char* not void* to avoid the compiler's strict-aliasing assumptions | |
| // and related warnings. | |
| char *newBuffer=(char *)uprv_malloc(reqCapacity*size); | |
| if(newBuffer!=NULL) { | |
| if(length>0) { | |
| uprv_memcpy(newBuffer, *pBuffer, (size_t)length*size); | |
| } | |
| *pCapacity=reqCapacity; | |
| } else { | |
| *pCapacity=0; | |
| } | |
| /* release the old pBuffer if it was not statically allocated */ | |
| if(*pBuffer!=(char *)context) { | |
| uprv_free(*pBuffer); | |
| } | |
| *pBuffer=newBuffer; | |
| return (UBool)(newBuffer!=NULL); | |
| } | |
| /* 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; | |
| int32_t intTargetCapacity=0; | |
| int count=0,retVal=0; | |
| const UChar *pSrcLimit =NULL; | |
| const UChar *pSrc = src; | |
| conv = u_getDefaultConverter(pErrorCode); | |
| if(U_FAILURE(*pErrorCode)){ | |
| return NULL; | |
| } | |
| if(srcLength == -1){ | |
| srcLength = u_strlen(pSrc); | |
| } | |
| pSrcLimit = pSrc + srcLength; | |
| for(;;) { | |
| /* reset the error state */ | |
| *pErrorCode = U_ZERO_ERROR; | |
| /* convert to chars using default converter */ | |
| ucnv_fromUnicode(conv,&tempBuf,tempBufLimit,&pSrc,pSrcLimit,NULL,(UBool)(pSrc==pSrcLimit),pErrorCode); | |
| count =(tempBuf - saveBuf); | |
| /* This should rarely occur */ | |
| if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR){ | |
| tempBuf = saveBuf; | |
| /* we dont have enough room on the stack grow the buffer */ | |
| int32_t newCapacity = 2 * srcLength; | |
| if(newCapacity <= tempBufCapacity) { | |
| newCapacity = _BUFFER_CAPACITY_MULTIPLIER * tempBufCapacity; | |
| } | |
| if(!u_growAnyBufferFromStatic(stackBuffer,(void**) &tempBuf, &tempBufCapacity, | |
| newCapacity, count, 1)) { | |
| goto cleanup; | |
| } | |
| saveBuf = tempBuf; | |
| tempBufLimit = tempBuf + tempBufCapacity; | |
| tempBuf = tempBuf + count; | |
| } else { | |
| break; | |
| } | |
| } | |
| if(U_FAILURE(*pErrorCode)){ | |
| goto cleanup; | |
| } | |
| /* done with conversion null terminate the char buffer */ | |
| if(count>=tempBufCapacity){ | |
| tempBuf = saveBuf; | |
| /* we dont have enough room on the stack grow the buffer */ | |
| if(!u_growAnyBufferFromStatic(stackBuffer,(void**) &tempBuf, &tempBufCapacity, | |
| count+1, count, 1)) { | |
| goto cleanup; | |
| } | |
| saveBuf = tempBuf; | |
| } | |
| saveBuf[count]=0; | |
| /* allocate more space than required | |
| * here we assume that every char requires | |
| * no more than 2 wchar_ts | |
| */ | |
| intTargetCapacity = (count * _BUFFER_CAPACITY_MULTIPLIER + 1) /*for null termination */; | |
| intTarget = (wchar_t*)uprv_malloc( intTargetCapacity * sizeof(wchar_t) ); | |
| if(intTarget){ | |
| int32_t nulLen = 0; | |
| int32_t remaining = intTargetCapacity; | |
| wchar_t* pIntTarget=intTarget; | |
| 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),remaining); | |
| if(retVal==-1){ | |
| *pErrorCode = U_INVALID_CHAR_FOUND; | |
| break; | |
| }else if(retVal== remaining){/* should never occur */ | |
| int numWritten = (pIntTarget-intTarget); | |
| u_growAnyBufferFromStatic(NULL,(void**) &intTarget, | |
| &intTargetCapacity, | |
| intTargetCapacity * _BUFFER_CAPACITY_MULTIPLIER, | |
| numWritten, | |
| sizeof(wchar_t)); | |
| pIntTarget = intTarget; | |
| remaining=intTargetCapacity; | |
| if(nulLen!=count){ /*there are embedded nulls*/ | |
| pIntTarget+=numWritten; | |
| remaining-=numWritten; | |
| } | |
| }else{ | |
| int32_t nulVal; | |
| /*scan for nulls */ | |
| /* we donot check for limit since tempBuf is null terminated */ | |
| while(tempBuf[nulLen++] != 0){ | |
| } | |
| nulVal = (nulLen < srcLength) ? 1 : 0; | |
| pIntTarget = pIntTarget + retVal+nulVal; | |
| remaining -=(retVal+nulVal); | |
| /* check if we have reached the source limit*/ | |
| if(nulLen>=(count)){ | |
| break; | |
| } | |
| } | |
| } | |
| count = (int32_t)(pIntTarget-intTarget); | |
| if(0 < count && count <= destCapacity){ | |
| uprv_memcpy(dest, intTarget, (size_t)count*sizeof(wchar_t)); | |
| } | |
| if(pDestLength){ | |
| *pDestLength = count; | |
| } | |
| /* free the allocated memory */ | |
| uprv_free(intTarget); | |
| }else{ | |
| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| cleanup: | |
| /* are we still using stack buffer */ | |
| if(stackBuffer != saveBuf){ | |
| uprv_free(saveBuf); | |
| } | |
| u_terminateWChars(dest,destCapacity,count,pErrorCode); | |
| u_releaseDefaultConverter(conv); | |
| return dest; | |
| } | |
| #endif | |
| 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){ | |
| /* args check */ | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)){ | |
| return NULL; | |
| } | |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || | |
| (destCapacity<0) || (dest == NULL && 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 = u_strlen(src); | |
| } | |
| if(0 < srcLength && srcLength <= destCapacity){ | |
| u_memcpy((UChar *)dest, src, srcLength); | |
| } | |
| if(pDestLength){ | |
| *pDestLength = srcLength; | |
| } | |
| u_terminateUChars((UChar *)dest,destCapacity,srcLength,pErrorCode); | |
| return dest; | |
| #elif defined U_WCHAR_IS_UTF32 | |
| return (wchar_t*)u_strToUTF32((UChar32*)dest, destCapacity, pDestLength, | |
| src, srcLength, pErrorCode); | |
| #else | |
| return _strToWCS(dest,destCapacity,pDestLength,src,srcLength, pErrorCode); | |
| #endif | |
| } | |
| #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) | |
| /* 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* target = 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-1)){ | |
| /* Should rarely occur */ | |
| u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap, | |
| cStackCap * _BUFFER_CAPACITY_MULTIPLIER, 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(nulLen<srcLength && 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, | |
| _BUFFER_CAPACITY_MULTIPLIER*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 += retVal+1 /* already null terminated */; | |
| pSrc += nulLen; /* skip past the null */ | |
| srcLength-=nulLen; /* decrement the srcLength */ | |
| 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 + 1)); | |
| if(pWStack==NULL){ | |
| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanup; | |
| } | |
| } | |
| if(nulLen>0){ | |
| /* copy the contents to tempStack */ | |
| uprv_memcpy(pWStack, pSrc, (size_t)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 += retVal; | |
| pSrc += nulLen; | |
| srcLength-=nulLen; /* decrement the srcLength */ | |
| break; | |
| } | |
| } | |
| } | |
| /* OK..now we have converted from wchar_ts to chars now | |
| * convert chars to UChars | |
| */ | |
| pCSrcLimit = pCSrc; | |
| pCSrc = pCSave; | |
| pTarget = target= dest; | |
| pTargetLimit = dest + destCapacity; | |
| conv= u_getDefaultConverter(pErrorCode); | |
| if(U_FAILURE(*pErrorCode)|| conv==NULL){ | |
| goto cleanup; | |
| } | |
| for(;;) { | |
| *pErrorCode = U_ZERO_ERROR; | |
| /* convert to stack buffer*/ | |
| ucnv_toUnicode(conv,&pTarget,pTargetLimit,(const char**)&pCSrc,pCSrcLimit,NULL,(UBool)(pCSrc==pCSrcLimit),pErrorCode); | |
| /* increment count to number written to stack */ | |
| count+= pTarget - target; | |
| if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR){ | |
| target = uStack; | |
| pTarget = uStack; | |
| pTargetLimit = uStack + _STACK_BUFFER_CAPACITY; | |
| } else { | |
| break; | |
| } | |
| } | |
| 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; | |
| } | |
| #endif | |
| U_CAPI UChar* U_EXPORT2 | |
| u_strFromWCS(UChar *dest, | |
| int32_t destCapacity, | |
| int32_t *pDestLength, | |
| const wchar_t *src, | |
| int32_t srcLength, | |
| UErrorCode *pErrorCode) | |
| { | |
| /* args check */ | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)){ | |
| return NULL; | |
| } | |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || | |
| (destCapacity<0) || (dest == NULL && 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 = u_strlen((const UChar *)src); | |
| } | |
| if(0 < srcLength && srcLength <= destCapacity){ | |
| u_memcpy(dest, (const UChar *)src, srcLength); | |
| } | |
| if(pDestLength){ | |
| *pDestLength = srcLength; | |
| } | |
| u_terminateUChars(dest,destCapacity,srcLength,pErrorCode); | |
| return dest; | |
| #elif defined U_WCHAR_IS_UTF32 | |
| return u_strFromUTF32(dest, destCapacity, pDestLength, | |
| (UChar32*)src, srcLength, pErrorCode); | |
| #else | |
| return _strFromWCS(dest,destCapacity,pDestLength,src,srcLength,pErrorCode); | |
| #endif | |
| } | |
| #endif /* #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) && !UCONFIG_NO_CONVERSION */ |