icuSources/common/ustr_wcs.cpp

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