1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2001-2010, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: ustr_wcs.c 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2004sep07 14 * created by: Markus W. Scherer 15 * 16 * u_strToWCS() and u_strFromWCS() functions 17 * moved here from ustrtrns.c for better modularization. 18 */ 19 20 #include "unicode/utypes.h" 21 #include "unicode/ustring.h" 22 #include "cstring.h" 23 #include "cwchar.h" 24 #include "cmemory.h" 25 #include "ustr_imp.h" 26 #include "ustr_cnv.h" 27 28 #if defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32) || !UCONFIG_NO_CONVERSION 29 30 #define _STACK_BUFFER_CAPACITY 1000 31 #define _BUFFER_CAPACITY_MULTIPLIER 2 32 33 #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) 34 static U_INLINE UBool 35 u_growAnyBufferFromStatic(void *context, 36 void **pBuffer, int32_t *pCapacity, int32_t reqCapacity, 37 int32_t length, int32_t size) { 38 39 void *newBuffer=uprv_malloc(reqCapacity*size); 40 if(newBuffer!=NULL) { 41 if(length>0) { 42 uprv_memcpy(newBuffer, *pBuffer, length*size); 43 } 44 *pCapacity=reqCapacity; 45 } else { 46 *pCapacity=0; 47 } 48 49 /* release the old pBuffer if it was not statically allocated */ 50 if(*pBuffer!=(void *)context) { 51 uprv_free(*pBuffer); 52 } 53 54 *pBuffer=newBuffer; 55 return (UBool)(newBuffer!=NULL); 56 } 57 58 /* helper function */ 59 static wchar_t* 60 _strToWCS(wchar_t *dest, 61 int32_t destCapacity, 62 int32_t *pDestLength, 63 const UChar *src, 64 int32_t srcLength, 65 UErrorCode *pErrorCode){ 66 67 char stackBuffer [_STACK_BUFFER_CAPACITY]; 68 char* tempBuf = stackBuffer; 69 int32_t tempBufCapacity = _STACK_BUFFER_CAPACITY; 70 char* tempBufLimit = stackBuffer + tempBufCapacity; 71 UConverter* conv = NULL; 72 char* saveBuf = tempBuf; 73 wchar_t* intTarget=NULL; 74 int32_t intTargetCapacity=0; 75 int count=0,retVal=0; 76 77 const UChar *pSrcLimit =NULL; 78 const UChar *pSrc = src; 79 80 conv = u_getDefaultConverter(pErrorCode); 81 82 if(U_FAILURE(*pErrorCode)){ 83 return NULL; 84 } 85 86 if(srcLength == -1){ 87 srcLength = u_strlen(pSrc); 88 } 89 90 pSrcLimit = pSrc + srcLength; 91 92 for(;;) { 93 /* reset the error state */ 94 *pErrorCode = U_ZERO_ERROR; 95 96 /* convert to chars using default converter */ 97 ucnv_fromUnicode(conv,&tempBuf,tempBufLimit,&pSrc,pSrcLimit,NULL,(UBool)(pSrc==pSrcLimit),pErrorCode); 98 count =(tempBuf - saveBuf); 99 100 /* This should rarely occur */ 101 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR){ 102 tempBuf = saveBuf; 103 104 /* we dont have enough room on the stack grow the buffer */ 105 if(!u_growAnyBufferFromStatic(stackBuffer,(void**) &tempBuf, &tempBufCapacity, 106 (_BUFFER_CAPACITY_MULTIPLIER * (srcLength)), count,sizeof(char))){ 107 goto cleanup; 108 } 109 110 saveBuf = tempBuf; 111 tempBufLimit = tempBuf + tempBufCapacity; 112 tempBuf = tempBuf + count; 113 114 } else { 115 break; 116 } 117 } 118 119 if(U_FAILURE(*pErrorCode)){ 120 goto cleanup; 121 } 122 123 /* done with conversion null terminate the char buffer */ 124 if(count>=tempBufCapacity){ 125 tempBuf = saveBuf; 126 /* we dont have enough room on the stack grow the buffer */ 127 if(!u_growAnyBufferFromStatic(stackBuffer,(void**) &tempBuf, &tempBufCapacity, 128 tempBufCapacity-count+1, count,sizeof(char))){ 129 goto cleanup; 130 } 131 saveBuf = tempBuf; 132 } 133 134 saveBuf[count]=0; 135 136 137 /* allocate more space than required 138 * here we assume that every char requires 139 * no more than 2 wchar_ts 140 */ 141 intTargetCapacity = (count * _BUFFER_CAPACITY_MULTIPLIER + 1) /*for null termination */; 142 intTarget = (wchar_t*)uprv_malloc( intTargetCapacity * sizeof(wchar_t) ); 143 144 if(intTarget){ 145 146 int32_t nulLen = 0; 147 int32_t remaining = intTargetCapacity; 148 wchar_t* pIntTarget=intTarget; 149 tempBuf = saveBuf; 150 151 /* now convert the mbs to wcs */ 152 for(;;){ 153 154 /* we can call the system API since we are sure that 155 * there is atleast 1 null in the input 156 */ 157 retVal = uprv_mbstowcs(pIntTarget,(tempBuf+nulLen),remaining); 158 159 if(retVal==-1){ 160 *pErrorCode = U_INVALID_CHAR_FOUND; 161 break; 162 }else if(retVal== remaining){/* should never occur */ 163 int numWritten = (pIntTarget-intTarget); 164 u_growAnyBufferFromStatic(NULL,(void**) &intTarget, 165 &intTargetCapacity, 166 intTargetCapacity * _BUFFER_CAPACITY_MULTIPLIER, 167 numWritten, 168 sizeof(wchar_t)); 169 pIntTarget = intTarget; 170 remaining=intTargetCapacity; 171 172 if(nulLen!=count){ /*there are embedded nulls*/ 173 pIntTarget+=numWritten; 174 remaining-=numWritten; 175 } 176 177 }else{ 178 int32_t nulVal; 179 /*scan for nulls */ 180 /* we donot check for limit since tempBuf is null terminated */ 181 while(tempBuf[nulLen++] != 0){ 182 } 183 nulVal = (nulLen < srcLength) ? 1 : 0; 184 pIntTarget = pIntTarget + retVal+nulVal; 185 remaining -=(retVal+nulVal); 186 187 /* check if we have reached the source limit*/ 188 if(nulLen>=(count)){ 189 break; 190 } 191 } 192 } 193 count = (int32_t)(pIntTarget-intTarget); 194 195 if(0 < count && count <= destCapacity){ 196 uprv_memcpy(dest,intTarget,count*sizeof(wchar_t)); 197 } 198 199 if(pDestLength){ 200 *pDestLength = count; 201 } 202 203 /* free the allocated memory */ 204 uprv_free(intTarget); 205 206 }else{ 207 *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 208 } 209 cleanup: 210 /* are we still using stack buffer */ 211 if(stackBuffer != saveBuf){ 212 uprv_free(saveBuf); 213 } 214 u_terminateWChars(dest,destCapacity,count,pErrorCode); 215 216 u_releaseDefaultConverter(conv); 217 218 return dest; 219 } 220 #endif 221 222 U_CAPI wchar_t* U_EXPORT2 223 u_strToWCS(wchar_t *dest, 224 int32_t destCapacity, 225 int32_t *pDestLength, 226 const UChar *src, 227 int32_t srcLength, 228 UErrorCode *pErrorCode){ 229 230 /* args check */ 231 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)){ 232 return NULL; 233 } 234 235 if( (src==NULL && srcLength!=0) || srcLength < -1 || 236 (destCapacity<0) || (dest == NULL && destCapacity > 0) 237 ) { 238 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 239 return NULL; 240 } 241 242 #ifdef U_WCHAR_IS_UTF16 243 /* wchar_t is UTF-16 just do a memcpy */ 244 if(srcLength == -1){ 245 srcLength = u_strlen(src); 246 } 247 if(0 < srcLength && srcLength <= destCapacity){ 248 uprv_memcpy(dest,src,srcLength*U_SIZEOF_UCHAR); 249 } 250 if(pDestLength){ 251 *pDestLength = srcLength; 252 } 253 254 u_terminateUChars(dest,destCapacity,srcLength,pErrorCode); 255 256 return dest; 257 258 #elif defined U_WCHAR_IS_UTF32 259 260 return (wchar_t*)u_strToUTF32((UChar32*)dest, destCapacity, pDestLength, 261 src, srcLength, pErrorCode); 262 263 #else 264 265 return _strToWCS(dest,destCapacity,pDestLength,src,srcLength, pErrorCode); 266 267 #endif 268 269 } 270 271 #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) 272 /* helper function */ 273 static UChar* 274 _strFromWCS( UChar *dest, 275 int32_t destCapacity, 276 int32_t *pDestLength, 277 const wchar_t *src, 278 int32_t srcLength, 279 UErrorCode *pErrorCode) 280 { 281 int32_t retVal =0, count =0 ; 282 UConverter* conv = NULL; 283 UChar* pTarget = NULL; 284 UChar* pTargetLimit = NULL; 285 UChar* target = NULL; 286 287 UChar uStack [_STACK_BUFFER_CAPACITY]; 288 289 wchar_t wStack[_STACK_BUFFER_CAPACITY]; 290 wchar_t* pWStack = wStack; 291 292 293 char cStack[_STACK_BUFFER_CAPACITY]; 294 int32_t cStackCap = _STACK_BUFFER_CAPACITY; 295 char* pCSrc=cStack; 296 char* pCSave=pCSrc; 297 char* pCSrcLimit=NULL; 298 299 const wchar_t* pSrc = src; 300 const wchar_t* pSrcLimit = NULL; 301 302 if(srcLength ==-1){ 303 /* if the wchar_t source is null terminated we can safely 304 * assume that there are no embedded nulls, this is a fast 305 * path for null terminated strings. 306 */ 307 for(;;){ 308 /* convert wchars to chars */ 309 retVal = uprv_wcstombs(pCSrc,src, cStackCap); 310 311 if(retVal == -1){ 312 *pErrorCode = U_ILLEGAL_CHAR_FOUND; 313 goto cleanup; 314 }else if(retVal >= (cStackCap-1)){ 315 /* Should rarely occur */ 316 u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap, 317 cStackCap * _BUFFER_CAPACITY_MULTIPLIER, 0, sizeof(char)); 318 pCSave = pCSrc; 319 }else{ 320 /* converted every thing */ 321 pCSrc = pCSrc+retVal; 322 break; 323 } 324 } 325 326 }else{ 327 /* here the source is not null terminated 328 * so it may have nulls embeded and we need to 329 * do some extra processing 330 */ 331 int32_t remaining =cStackCap; 332 333 pSrcLimit = src + srcLength; 334 335 for(;;){ 336 register int32_t nulLen = 0; 337 338 /* find nulls in the string */ 339 while(nulLen<srcLength && pSrc[nulLen++]!=0){ 340 } 341 342 if((pSrc+nulLen) < pSrcLimit){ 343 /* check if we have enough room in pCSrc */ 344 if(remaining < (nulLen * MB_CUR_MAX)){ 345 /* should rarely occur */ 346 int32_t len = (pCSrc-pCSave); 347 pCSrc = pCSave; 348 /* we do not have enough room so grow the buffer*/ 349 u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap, 350 _BUFFER_CAPACITY_MULTIPLIER*cStackCap+(nulLen*MB_CUR_MAX),len,sizeof(char)); 351 352 pCSave = pCSrc; 353 pCSrc = pCSave+len; 354 remaining = cStackCap-(pCSrc - pCSave); 355 } 356 357 /* we have found a null so convert the 358 * chunk from begining of non-null char to null 359 */ 360 retVal = uprv_wcstombs(pCSrc,pSrc,remaining); 361 362 if(retVal==-1){ 363 /* an error occurred bail out */ 364 *pErrorCode = U_ILLEGAL_CHAR_FOUND; 365 goto cleanup; 366 } 367 368 pCSrc += retVal+1 /* already null terminated */; 369 370 pSrc += nulLen; /* skip past the null */ 371 srcLength-=nulLen; /* decrement the srcLength */ 372 remaining -= (pCSrc-pCSave); 373 374 375 }else{ 376 /* the source is not null terminated and we are 377 * end of source so we copy the source to a temp buffer 378 * null terminate it and convert wchar_ts to chars 379 */ 380 if(nulLen >= _STACK_BUFFER_CAPACITY){ 381 /* Should rarely occcur */ 382 /* allocate new buffer buffer */ 383 pWStack =(wchar_t*) uprv_malloc(sizeof(wchar_t) * (nulLen + 1)); 384 if(pWStack==NULL){ 385 *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 386 goto cleanup; 387 } 388 } 389 if(nulLen>0){ 390 /* copy the contents to tempStack */ 391 uprv_memcpy(pWStack,pSrc,nulLen*sizeof(wchar_t)); 392 } 393 394 /* null terminate the tempBuffer */ 395 pWStack[nulLen] =0 ; 396 397 if(remaining < (nulLen * MB_CUR_MAX)){ 398 /* Should rarely occur */ 399 int32_t len = (pCSrc-pCSave); 400 pCSrc = pCSave; 401 /* we do not have enough room so grow the buffer*/ 402 u_growAnyBufferFromStatic(cStack,(void**)&pCSrc,&cStackCap, 403 cStackCap+(nulLen*MB_CUR_MAX),len,sizeof(char)); 404 405 pCSave = pCSrc; 406 pCSrc = pCSave+len; 407 remaining = cStackCap-(pCSrc - pCSave); 408 } 409 /* convert to chars */ 410 retVal = uprv_wcstombs(pCSrc,pWStack,remaining); 411 412 pCSrc += retVal; 413 pSrc += nulLen; 414 srcLength-=nulLen; /* decrement the srcLength */ 415 break; 416 } 417 } 418 } 419 420 /* OK..now we have converted from wchar_ts to chars now 421 * convert chars to UChars 422 */ 423 pCSrcLimit = pCSrc; 424 pCSrc = pCSave; 425 pTarget = target= dest; 426 pTargetLimit = dest + destCapacity; 427 428 conv= u_getDefaultConverter(pErrorCode); 429 430 if(U_FAILURE(*pErrorCode)|| conv==NULL){ 431 goto cleanup; 432 } 433 434 for(;;) { 435 436 *pErrorCode = U_ZERO_ERROR; 437 438 /* convert to stack buffer*/ 439 ucnv_toUnicode(conv,&pTarget,pTargetLimit,(const char**)&pCSrc,pCSrcLimit,NULL,(UBool)(pCSrc==pCSrcLimit),pErrorCode); 440 441 /* increment count to number written to stack */ 442 count+= pTarget - target; 443 444 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR){ 445 target = uStack; 446 pTarget = uStack; 447 pTargetLimit = uStack + _STACK_BUFFER_CAPACITY; 448 } else { 449 break; 450 } 451 452 } 453 454 if(pDestLength){ 455 *pDestLength =count; 456 } 457 458 u_terminateUChars(dest,destCapacity,count,pErrorCode); 459 460 cleanup: 461 462 if(cStack != pCSave){ 463 uprv_free(pCSave); 464 } 465 466 if(wStack != pWStack){ 467 uprv_free(pWStack); 468 } 469 470 u_releaseDefaultConverter(conv); 471 472 return dest; 473 } 474 #endif 475 476 U_CAPI UChar* U_EXPORT2 477 u_strFromWCS(UChar *dest, 478 int32_t destCapacity, 479 int32_t *pDestLength, 480 const wchar_t *src, 481 int32_t srcLength, 482 UErrorCode *pErrorCode) 483 { 484 485 /* args check */ 486 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)){ 487 return NULL; 488 } 489 490 if( (src==NULL && srcLength!=0) || srcLength < -1 || 491 (destCapacity<0) || (dest == NULL && destCapacity > 0) 492 ) { 493 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 494 return NULL; 495 } 496 497 #ifdef U_WCHAR_IS_UTF16 498 /* wchar_t is UTF-16 just do a memcpy */ 499 if(srcLength == -1){ 500 srcLength = u_strlen(src); 501 } 502 if(0 < srcLength && srcLength <= destCapacity){ 503 uprv_memcpy(dest,src,srcLength*U_SIZEOF_UCHAR); 504 } 505 if(pDestLength){ 506 *pDestLength = srcLength; 507 } 508 509 u_terminateUChars(dest,destCapacity,srcLength,pErrorCode); 510 511 return dest; 512 513 #elif defined U_WCHAR_IS_UTF32 514 515 return u_strFromUTF32(dest, destCapacity, pDestLength, 516 (UChar32*)src, srcLength, pErrorCode); 517 518 #else 519 520 return _strFromWCS(dest,destCapacity,pDestLength,src,srcLength,pErrorCode); 521 522 #endif 523 524 } 525 526 #endif /* #if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32) && !UCONFIG_NO_CONVERSION */ 527
