sal/rtl/source/ustring.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ustring.c,v $
  10  * $Revision: 1.31 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #if defined(_MSC_VER) && (_MSC_VER >= 1400)
  31 #pragma warning(disable:4738) // storing 32-bit float result in memory, possible loss of performance
  32 #endif
  33
  34 #include <rtl/memory.h>
  35 #include <osl/diagnose.h>
  36 #include <osl/interlck.h>
  37 #include <rtl/alloc.h>
  38 #include <osl/mutex.h>
  39 #include <osl/doublecheckedlocking.h>
  40 #include <rtl/tencinfo.h>
  41
  42 #include <string.h>
  43 #include <sal/alloca.h>
  44
  45 #include "hash.h"
  46 #include "strimp.h"
  47 #include "surrogates.h"
  48 #include <rtl/ustring.h>
  49
  50 #include "rtl/math.h"
  51 #include "rtl/tencinfo.h"
  52
  53 /* ======================================================================= */
  54
  55 /* static data to be referenced by all empty strings
  56  * the refCount is predefined to 1 and must never become 0 !
  57  */
  58 static rtl_uString const aImplEmpty_rtl_uString =
  59 {
  60     (sal_Int32) (SAL_STRING_INTERN_FLAG|SAL_STRING_STATIC_FLAG|1), /*sal_Int32    refCount; */
  61     0,                                               /*sal_Int32    length;   */
  62     { 0 }                                            /*sal_Unicode  buffer[1];*/
  63 };
  64
  65 /* ======================================================================= */
  66
  67 #define IMPL_RTL_STRCODE            sal_Unicode
  68 #define IMPL_RTL_USTRCODE( c )      (c)
  69 #define IMPL_RTL_STRNAME( n )       rtl_ustr_ ## n
  70
  71 #define IMPL_RTL_STRINGNAME( n )    rtl_uString_ ## n
  72 #define IMPL_RTL_STRINGDATA         rtl_uString
  73 #define IMPL_RTL_EMPTYSTRING        aImplEmpty_rtl_uString
  74 #define IMPL_RTL_INTERN
  75 static void internRelease (rtl_uString *pThis);
  76
  77 /* ======================================================================= */
  78
  79 /* Include String/UString template code */
  80
  81 #include "strtmpl.c"
  82
  83 sal_Int32 rtl_ustr_indexOfAscii_WithLength(
  84     sal_Unicode const * str, sal_Int32 len,
  85     char const * subStr, sal_Int32 subLen)
  86 {
  87     if (subLen > 0 && subLen <= len) {
  88         sal_Int32 i;
  89         for (i = 0; i <= len - subLen; ++i) {
  90             if (rtl_ustr_asciil_reverseEquals_WithLength(
  91                     str + i, subStr, subLen))
  92             {
  93                 return i;
  94             }
  95         }
  96     }
  97     return -1;
  98 }
  99
 100 sal_Int32 rtl_ustr_lastIndexOfAscii_WithLength(
 101     sal_Unicode const * str, sal_Int32 len,
 102     char const * subStr, sal_Int32 subLen)
 103 {
 104     if (subLen > 0 && subLen <= len) {
 105         sal_Int32 i;
 106         for (i = len - subLen; i >= 0; --i) {
 107             if (rtl_ustr_asciil_reverseEquals_WithLength(
 108                     str + i, subStr, subLen))
 109             {
 110                 return i;
 111             }
 112         }
 113     }
 114     return -1;
 115 }
 116
 117 sal_Int32 SAL_CALL rtl_ustr_valueOfFloat(sal_Unicode * pStr, float f)
 118 {
 119     rtl_uString * pResult = NULL;
 120     sal_Int32 nLen;
 121     rtl_math_doubleToUString(
 122         &pResult, 0, 0, f, rtl_math_StringFormat_G,
 123         RTL_USTR_MAX_VALUEOFFLOAT - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', 0,
 124         0, sal_True);
 125     nLen = pResult->length;
 126     OSL_ASSERT(nLen < RTL_USTR_MAX_VALUEOFFLOAT);
 127     rtl_copyMemory(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Unicode));
 128     rtl_uString_release(pResult);
 129     return nLen;
 130 }
 131
 132 sal_Int32 SAL_CALL rtl_ustr_valueOfDouble(sal_Unicode * pStr, double d)
 133 {
 134     rtl_uString * pResult = NULL;
 135     sal_Int32 nLen;
 136     rtl_math_doubleToUString(
 137         &pResult, 0, 0, d, rtl_math_StringFormat_G,
 138         RTL_USTR_MAX_VALUEOFDOUBLE - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', 0,
 139         0, sal_True);
 140     nLen = pResult->length;
 141     OSL_ASSERT(nLen < RTL_USTR_MAX_VALUEOFDOUBLE);
 142     rtl_copyMemory(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Unicode));
 143     rtl_uString_release(pResult);
 144     return nLen;
 145 }
 146
 147 float SAL_CALL rtl_ustr_toFloat(sal_Unicode const * pStr)
 148 {
 149     return (float) rtl_math_uStringToDouble(pStr,
 150                                             pStr + rtl_ustr_getLength(pStr),
 151                                             '.', 0, 0, 0);
 152 }
 153
 154 double SAL_CALL rtl_ustr_toDouble(sal_Unicode const * pStr)
 155 {
 156     return rtl_math_uStringToDouble(pStr, pStr + rtl_ustr_getLength(pStr), '.',
 157                                     0, 0, 0);
 158 }
 159
 160 /* ======================================================================= */
 161
 162 sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode* pStr1,
 163                                            const sal_Char* pStr2 )
 164 {
 165     sal_Int32 nRet;
 166     while ( ((nRet = ((sal_Int32)(*pStr1))-
 167                      ((sal_Int32)((unsigned char)(*pStr2)))) == 0) &&
 168             *pStr2 )
 169     {
 170         pStr1++;
 171         pStr2++;
 172     }
 173
 174     return nRet;
 175 }
 176
 177 /* ----------------------------------------------------------------------- */
 178
 179 sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
 180                                                       sal_Int32 nStr1Len,
 181                                                       const sal_Char* pStr2 )
 182 {
 183     sal_Int32 nRet = 0;
 184     while( ((nRet = (nStr1Len ? (sal_Int32)(*pStr1) : 0)-
 185                     ((sal_Int32)((unsigned char)(*pStr2)))) == 0) &&
 186            nStr1Len && *pStr2 )
 187     {
 188         pStr1++;
 189         pStr2++;
 190         nStr1Len--;
 191     }
 192
 193     return nRet;
 194 }
 195
 196 /* ----------------------------------------------------------------------- */
 197
 198 sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode* pStr1,
 199                                                                sal_Int32 nStr1Len,
 200                                                                const sal_Char* pStr2,
 201                                                                sal_Int32 nShortenedLength )
 202 {
 203     const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
 204     sal_Int32           nRet;
 205     while ( (nShortenedLength > 0) &&
 206             (pStr1 < pStr1End) && *pStr2 )
 207     {
 208         /* Check ASCII range */
 209         OSL_ENSURE( (*pStr2 & 0x80) == 0, "Found ASCII char > 127");
 210
 211         nRet = ((sal_Int32)*pStr1)-
 212                ((sal_Int32)(unsigned char)*pStr2);
 213         if ( nRet != 0 )
 214             return nRet;
 215
 216         nShortenedLength--;
 217         pStr1++;
 218         pStr2++;
 219     }
 220
 221     if ( nShortenedLength <= 0 )
 222         return 0;
 223
 224     if ( *pStr2 )
 225     {
 226         OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
 227         // first is a substring of the second string => less (negative value)
 228         nRet = -1;
 229     }
 230     else
 231     {
 232         // greater or equal
 233         nRet = pStr1End - pStr1;
 234     }
 235
 236     return nRet;
 237 }
 238
 239 /* ----------------------------------------------------------------------- */
 240
 241 sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode* pStr1,
 242                                                               sal_Int32 nStr1Len,
 243                                                               const sal_Char* pStr2,
 244                                                               sal_Int32 nStr2Len )
 245 {
 246     const sal_Unicode*  pStr1Run = pStr1+nStr1Len;
 247     const sal_Char*     pStr2Run = pStr2+nStr2Len;
 248     sal_Int32           nRet;
 249     while ( (pStr1 < pStr1Run) && (pStr2 < pStr2Run) )
 250     {
 251         pStr1Run--;
 252         pStr2Run--;
 253         nRet = ((sal_Int32)*pStr1Run)-((sal_Int32)*pStr2Run);
 254         if ( nRet )
 255             return nRet;
 256     }
 257
 258     return nStr1Len - nStr2Len;
 259 }
 260
 261 /* ----------------------------------------------------------------------- */
 262
 263 sal_Bool SAL_CALL rtl_ustr_asciil_reverseEquals_WithLength( const sal_Unicode* pStr1,
 264                                                               const sal_Char* pStr2,
 265                                                               sal_Int32 nStrLen )
 266 {
 267     const sal_Unicode*  pStr1Run = pStr1+nStrLen;
 268     const sal_Char*     pStr2Run = pStr2+nStrLen;
 269     while ( pStr1 < pStr1Run )
 270     {
 271         pStr1Run--;
 272         pStr2Run--;
 273         if( *pStr1Run != (sal_Unicode)*pStr2Run )
 274             return sal_False;
 275     }
 276
 277     return sal_True;
 278 }
 279
 280 /* ----------------------------------------------------------------------- */
 281
 282 sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode* pStr1,
 283                                                           const sal_Char* pStr2 )
 284 {
 285     sal_Int32   nRet;
 286     sal_Int32   c1;
 287     sal_Int32   c2;
 288     do
 289     {
 290         /* If character between 'A' and 'Z', than convert it to lowercase */
 291         c1 = (sal_Int32)*pStr1;
 292         c2 = (sal_Int32)((unsigned char)*pStr2);
 293         if ( (c1 >= 65) && (c1 <= 90) )
 294             c1 += 32;
 295         if ( (c2 >= 65) && (c2 <= 90) )
 296             c2 += 32;
 297         nRet = c1-c2;
 298         if ( nRet != 0 )
 299             return nRet;
 300
 301         pStr1++;
 302         pStr2++;
 303     }
 304     while ( c2 );
 305
 306     return 0;
 307 }
 308
 309 /* ----------------------------------------------------------------------- */
 310
 311 sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_Unicode* pStr1,
 312                                                                      sal_Int32 nStr1Len,
 313                                                                      const sal_Char* pStr2 )
 314 {
 315     sal_Int32   nRet;
 316     sal_Int32   c1;
 317     sal_Int32   c2;
 318     do
 319     {
 320         if ( !nStr1Len )
 321             return *pStr2 == '\0' ? 0 : -1;
 322
 323         /* If character between 'A' and 'Z', than convert it to lowercase */
 324         c1 = (sal_Int32)*pStr1;
 325         c2 = (sal_Int32)((unsigned char)*pStr2);
 326         if ( (c1 >= 65) && (c1 <= 90) )
 327             c1 += 32;
 328         if ( (c2 >= 65) && (c2 <= 90) )
 329             c2 += 32;
 330         nRet = c1-c2;
 331         if ( nRet != 0 )
 332             return nRet;
 333
 334         pStr1++;
 335         pStr2++;
 336         nStr1Len--;
 337     }
 338     while( c2 );
 339
 340     return 0;
 341 }
 342
 343 sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
 344     sal_Unicode const * first, sal_Int32 firstLen,
 345     char const * second, sal_Int32 secondLen)
 346 {
 347     sal_Int32 i;
 348     sal_Int32 len = firstLen < secondLen ? firstLen : secondLen;
 349     for (i = 0; i < len; ++i) {
 350         sal_Int32 c1 = *first++;
 351         sal_Int32 c2 = (unsigned char) *second++;
 352         sal_Int32 d;
 353         if (c1 >= 65 && c1 <= 90) {
 354             c1 += 32;
 355         }
 356         if (c2 >= 65 && c2 <= 90) {
 357             c2 += 32;
 358         }
 359         d = c1 - c2;
 360         if (d != 0) {
 361             return d;
 362         }
 363     }
 364     return firstLen - secondLen;
 365 }
 366
 367 /* ----------------------------------------------------------------------- */
 368
 369 sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( const sal_Unicode* pStr1,
 370                                                                               sal_Int32 nStr1Len,
 371                                                                               const sal_Char* pStr2,
 372                                                                               sal_Int32 nShortenedLength )
 373 {
 374     const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
 375     sal_Int32           nRet;
 376     sal_Int32           c1;
 377     sal_Int32           c2;
 378     while ( (nShortenedLength > 0) &&
 379             (pStr1 < pStr1End) && *pStr2 )
 380     {
 381         /* Check ASCII range */
 382         OSL_ENSURE( (*pStr2 & 0x80) == 0, "Found ASCII char > 127");
 383
 384         /* If character between 'A' and 'Z', than convert it to lowercase */
 385         c1 = (sal_Int32)*pStr1;
 386         c2 = (sal_Int32)((unsigned char)*pStr2);
 387         if ( (c1 >= 65) && (c1 <= 90) )
 388             c1 += 32;
 389         if ( (c2 >= 65) && (c2 <= 90) )
 390             c2 += 32;
 391         nRet = c1-c2;
 392         if ( nRet != 0 )
 393             return nRet;
 394
 395         nShortenedLength--;
 396         pStr1++;
 397         pStr2++;
 398     }
 399
 400     if ( nShortenedLength <= 0 )
 401         return 0;
 402
 403     if ( *pStr2 )
 404     {
 405         OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
 406         // first is a substring of the second string => less (negative value)
 407         nRet = -1;
 408     }
 409     else
 410     {
 411         // greater or equal
 412         nRet = pStr1End - pStr1;
 413     }
 414
 415     return nRet;
 416 }
 417
 418 /* ----------------------------------------------------------------------- */
 419
 420 void SAL_CALL rtl_uString_newFromAscii( rtl_uString** ppThis,
 421                                         const sal_Char* pCharStr )
 422 {
 423     sal_Int32 nLen;
 424
 425     if ( pCharStr )
 426     {
 427         const sal_Char* pTempStr = pCharStr;
 428         while( *pTempStr )
 429             pTempStr++;
 430         nLen = pTempStr-pCharStr;
 431     }
 432     else
 433         nLen = 0;
 434
 435     if ( !nLen )
 436     {
 437         IMPL_RTL_STRINGNAME( new )( ppThis );
 438         return;
 439     }
 440
 441     if ( *ppThis )
 442         IMPL_RTL_STRINGNAME( release )( *ppThis );
 443
 444     *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
 445     OSL_ASSERT(*ppThis != NULL);
 446     if ( (*ppThis) )
 447     {
 448         IMPL_RTL_STRCODE* pBuffer = (*ppThis)->buffer;
 449         do
 450         {
 451             /* Check ASCII range */
 452             OSL_ENSURE( ((unsigned char)*pCharStr) <= 127,
 453                         "rtl_uString_newFromAscii() - Found ASCII char > 127" );
 454
 455             *pBuffer = *pCharStr;
 456             pBuffer++;
 457             pCharStr++;
 458         }
 459         while ( *pCharStr );
 460     }
 461 }
 462
 463 void SAL_CALL rtl_uString_newFromCodePoints(
 464     rtl_uString ** newString, sal_uInt32 const * codePoints,
 465     sal_Int32 codePointCount)
 466 {
 467     sal_Int32 n;
 468     sal_Int32 i;
 469     sal_Unicode * p;
 470     OSL_ASSERT(
 471         newString != NULL &&
 472         (codePoints != NULL || codePointCount == 0) &&
 473         codePointCount >= 0);
 474     if (codePointCount == 0) {
 475         rtl_uString_new(newString);
 476         return;
 477     }
 478     if (*newString != NULL) {
 479         rtl_uString_release(*newString);
 480     }
 481     n = codePointCount;
 482     for (i = 0; i < codePointCount; ++i) {
 483         OSL_ASSERT(codePoints[i] <= 0x10FFFF);
 484         if (codePoints[i] >= 0x10000) {
 485             ++n;
 486         }
 487     }
 488     /* Builds on the assumption that sal_Int32 uses 32 bit two's complement
 489        representation with wrap around (the necessary number of UTF-16 code
 490        units will be no larger than 2 * SAL_MAX_INT32, represented as
 491        sal_Int32 -2): */
 492     if (n < 0) {
 493         *newString = NULL;
 494         return;
 495     }
 496     *newString = rtl_uString_ImplAlloc(n);
 497     if (*newString == NULL) {
 498         return;
 499     }
 500     p = (*newString)->buffer;
 501     for (i = 0; i < codePointCount; ++i) {
 502         sal_uInt32 c = codePoints[i];
 503         if (c < 0x10000) {
 504             *p++ = (sal_Unicode) c;
 505         } else {
 506             c -= 0x10000;
 507             *p++ = (sal_Unicode) ((c >> 10) | SAL_RTL_FIRST_HIGH_SURROGATE);
 508             *p++ = (sal_Unicode) ((c & 0x3FF) | SAL_RTL_FIRST_LOW_SURROGATE);
 509         }
 510     }
 511 }
 512
 513 /* ======================================================================= */
 514
 515 static int rtl_ImplGetFastUTF8UnicodeLen( const sal_Char* pStr, sal_Int32 nLen )
 516 {
 517     int             n;
 518     sal_uChar       c;
 519     const sal_Char* pEndStr;
 520
 521     n = 0;
 522     pEndStr  = pStr+nLen;
 523     while ( pStr < pEndStr )
 524     {
 525         c = (sal_uChar)*pStr;
 526
 527         if ( !(c & 0x80) )
 528             pStr++;
 529         else if ( (c & 0xE0) == 0xC0 )
 530             pStr += 2;
 531         else if ( (c & 0xF0) == 0xE0 )
 532             pStr += 3;
 533         else if ( (c & 0xF8) == 0xF0 )
 534             pStr += 4;
 535         else if ( (c & 0xFC) == 0xF8 )
 536             pStr += 5;
 537         else if ( (c & 0xFE) == 0xFC )
 538             pStr += 6;
 539         else
 540             pStr++;
 541
 542         n++;
 543     }
 544
 545     return n;
 546 }
 547
 548 /* ----------------------------------------------------------------------- */
 549
 550 static void rtl_string2UString_status( rtl_uString** ppThis,
 551                                        const sal_Char* pStr,
 552                                        sal_Int32 nLen,
 553                                        rtl_TextEncoding eTextEncoding,
 554                                        sal_uInt32 nCvtFlags,
 555                                        sal_uInt32 *pInfo )
 556 {
 557     OSL_ENSURE(rtl_isOctetTextEncoding(eTextEncoding),
 558                "rtl_string2UString_status() - Wrong TextEncoding" );
 559
 560     if ( !nLen )
 561         rtl_uString_new( ppThis );
 562     else
 563     {
 564         if ( *ppThis )
 565             IMPL_RTL_STRINGNAME( release )( *ppThis );
 566
 567         /* Optimization for US-ASCII */
 568         if ( eTextEncoding == RTL_TEXTENCODING_ASCII_US )
 569         {
 570             IMPL_RTL_STRCODE* pBuffer;
 571             *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
 572             if (*ppThis == NULL) {
 573                 if (pInfo != NULL) {
 574                     *pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
 575                         RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 576                 }
 577                 return;
 578             }
 579             pBuffer = (*ppThis)->buffer;
 580             do
 581             {
 582                 /* Check ASCII range */
 583                 OSL_ENSURE( ((unsigned char)*pStr) <= 127,
 584                             "rtl_string2UString_status() - Found char > 127 and RTL_TEXTENCODING_ASCII_US is specified" );
 585
 586                 *pBuffer = *pStr;
 587                 pBuffer++;
 588                 pStr++;
 589                 nLen--;
 590             }
 591             while ( nLen );
 592         }
 593         else
 594         {
 595             rtl_uString*                pTemp;
 596             rtl_uString*                pTemp2 = NULL;
 597             rtl_TextToUnicodeConverter  hConverter;
 598             sal_uInt32                  nInfo;
 599             sal_Size                    nSrcBytes;
 600             sal_Size                    nDestChars;
 601             sal_Size                    nNewLen;
 602
 603             /* Optimization for UTF-8 - we try to calculate the exact length */
 604             /* For all other encoding we try the maximum - and reallocate
 605                the buffer if needed */
 606             if ( eTextEncoding == RTL_TEXTENCODING_UTF8 )
 607             {
 608                 nNewLen = rtl_ImplGetFastUTF8UnicodeLen( pStr, nLen );
 609                 /* Includes the string only ASCII, then we could copy
 610                    the buffer faster */
 611                 if ( nNewLen == (sal_Size)nLen )
 612                 {
 613                     IMPL_RTL_STRCODE* pBuffer;
 614                     *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
 615                     if (*ppThis == NULL)
 616                     {
 617                         if (pInfo != NULL) {
 618                             *pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
 619                                 RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 620                         }
 621                         return;
 622                     }
 623                     pBuffer = (*ppThis)->buffer;
 624                     do
 625                     {
 626                         /* Check ASCII range */
 627                         OSL_ENSURE( ((unsigned char)*pStr) <= 127,
 628                                     "rtl_string2UString_status() - UTF8 test encoding is wrong" );
 629
 630                         *pBuffer = *pStr;
 631                         pBuffer++;
 632                         pStr++;
 633                         nLen--;
 634                     }
 635                     while ( nLen );
 636                     if (pInfo != NULL) {
 637                         *pInfo = 0;
 638                     }
 639                     return;
 640                 }
 641             }
 642             else
 643                 nNewLen = nLen;
 644
 645             nCvtFlags |= RTL_TEXTTOUNICODE_FLAGS_FLUSH;
 646             hConverter = rtl_createTextToUnicodeConverter( eTextEncoding );
 647
 648             pTemp = IMPL_RTL_STRINGNAME( ImplAlloc )( nNewLen );
 649             if (pTemp == NULL) {
 650                 if (pInfo != NULL) {
 651                     *pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
 652                         RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 653                 }
 654                 return;
 655             }
 656             nDestChars = rtl_convertTextToUnicode( hConverter, 0,
 657                                                    pStr, nLen,
 658                                                    pTemp->buffer, nNewLen,
 659                                                    nCvtFlags,
 660                                                    &nInfo, &nSrcBytes );
 661
 662             /* Buffer not big enough, try again with enough space */
 663             /* Shouldn't be the case, but if we get textencoding which
 664                could results in more unicode characters we have this
 665                code here. Could be the case for apple encodings */
 666             while ( nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL )
 667             {
 668                 rtl_freeMemory( pTemp );
 669                 nNewLen += 8;
 670                 pTemp = IMPL_RTL_STRINGNAME( ImplAlloc )( nNewLen );
 671                 if (pTemp == NULL) {
 672                     if (pInfo != NULL) {
 673                         *pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
 674                             RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 675                     }
 676                     return;
 677                 }
 678                 nDestChars = rtl_convertTextToUnicode( hConverter, 0,
 679                                                        pStr, nLen,
 680                                                        pTemp->buffer, nNewLen,
 681                                                        nCvtFlags,
 682                                                        &nInfo, &nSrcBytes );
 683             }
 684
 685             if (pInfo)
 686                 *pInfo = nInfo;
 687
 688             /* Set the buffer to the correct size or if there is too
 689                much overhead, reallocate to the correct size */
 690             if ( nNewLen > nDestChars+8 )
 691             {
 692                 pTemp2 = IMPL_RTL_STRINGNAME( ImplAlloc )( nDestChars );
 693             }
 694             if (pTemp2 != NULL)
 695             {
 696                 rtl_str_ImplCopy(pTemp2->buffer, pTemp->buffer, nDestChars);
 697                 rtl_freeMemory(pTemp);
 698                 pTemp = pTemp2;
 699             }
 700             else
 701             {
 702                 pTemp->length = nDestChars;
 703                 pTemp->buffer[nDestChars] = 0;
 704             }
 705
 706             rtl_destroyTextToUnicodeConverter( hConverter );
 707             *ppThis = pTemp;
 708
 709             /* Results the conversion in an empty buffer -
 710                create an empty string */
 711             if ( pTemp && !nDestChars )
 712                 rtl_uString_new( ppThis );
 713         }
 714     }
 715 }
 716
 717 void SAL_CALL rtl_string2UString( rtl_uString** ppThis,
 718                                   const sal_Char* pStr,
 719                                   sal_Int32 nLen,
 720                                   rtl_TextEncoding eTextEncoding,
 721                                   sal_uInt32 nCvtFlags )
 722 {
 723     rtl_string2UString_status( ppThis, pStr, nLen, eTextEncoding,
 724                                nCvtFlags, NULL );
 725 }
 726
 727 /* ----------------------------------------------------------------------- */
 728
 729 typedef enum {
 730     CANNOT_RETURN,
 731     CAN_RETURN = 1
 732 } StrLifecycle;
 733
 734 static oslMutex
 735 getInternMutex()
 736 {
 737     static oslMutex pPoolGuard = NULL;
 738     if( !pPoolGuard )
 739     {
 740         oslMutex pGlobalGuard;
 741         pGlobalGuard = *osl_getGlobalMutex();
 742         osl_acquireMutex( pGlobalGuard );
 743         if( !pPoolGuard )
 744         {
 745             oslMutex p = osl_createMutex();
 746             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 747             pPoolGuard = p;
 748         }
 749         osl_releaseMutex( pGlobalGuard );
 750     }
 751     else
 752     {
 753         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 754     }
 755
 756     return pPoolGuard;
 757 }
 758
 759 static StringHashTable *pInternPool = NULL;
 760
 761 /* returns true if we found a dup in the pool */
 762 static void rtl_ustring_intern_internal( rtl_uString ** newStr,
 763                                          rtl_uString  * str,
 764                                          StrLifecycle   can_return )
 765 {
 766     oslMutex pPoolMutex;
 767
 768     pPoolMutex = getInternMutex();
 769
 770     osl_acquireMutex( pPoolMutex );
 771
 772     if (!pInternPool)
 773         pInternPool = rtl_str_hash_new (1024);
 774     *newStr = rtl_str_hash_intern (pInternPool, str, can_return);
 775
 776     osl_releaseMutex( pPoolMutex );
 777
 778     if( can_return && *newStr != str )
 779     { /* we dupped, then found a match */
 780         rtl_freeMemory( str );
 781     }
 782 }
 783
 784 void SAL_CALL rtl_uString_intern( rtl_uString ** newStr,
 785                                   rtl_uString  * str)
 786 {
 787     if (SAL_STRING_IS_INTERN(str))
 788     {
 789         IMPL_RTL_AQUIRE( str );
 790         *newStr = str;
 791     }
 792     else
 793     {
 794         rtl_uString *pOrg = *newStr;
 795         *newStr = NULL;
 796         rtl_ustring_intern_internal( newStr, str, CANNOT_RETURN );
 797         if (pOrg)
 798             rtl_uString_release (pOrg);
 799     }
 800 }
 801
 802 void SAL_CALL rtl_uString_internConvert( rtl_uString   ** newStr,
 803                                          const sal_Char * str,
 804                                          sal_Int32        len,
 805                                          rtl_TextEncoding eTextEncoding,
 806                                          sal_uInt32       convertFlags,
 807                                          sal_uInt32     * pInfo )
 808 {
 809     rtl_uString *scratch;
 810
 811     if (*newStr)
 812     {
 813         rtl_uString_release (*newStr);
 814         *newStr = NULL;
 815     }
 816
 817     if ( len < 256 )
 818     { // try various optimisations
 819         if ( len < 0 )
 820             len = strlen( str );
 821         if ( eTextEncoding == RTL_TEXTENCODING_ASCII_US )
 822         {
 823             int i;
 824             rtl_uString *pScratch;
 825             pScratch = alloca( sizeof( rtl_uString )
 826                                + len * sizeof (IMPL_RTL_STRCODE ) );
 827             for (i = 0; i < len; i++)
 828             {
 829                 /* Check ASCII range */
 830                 OSL_ENSURE( ((unsigned char)str[i]) <= 127,
 831                             "rtl_ustring_internConvert() - Found char > 127 and RTL_TEXTENCODING_ASCII_US is specified" );
 832                 pScratch->buffer[i] = str[i];
 833             }
 834             pScratch->length = len;
 835             rtl_ustring_intern_internal( newStr, pScratch, CANNOT_RETURN );
 836             return;
 837         }
 838         /* FIXME: we want a nice UTF-8 / alloca shortcut here */
 839     }
 840
 841     scratch = NULL;
 842     rtl_string2UString_status( &scratch, str, len, eTextEncoding, convertFlags,
 843                                pInfo );
 844     if (!scratch) {
 845         return;
 846     }
 847     rtl_ustring_intern_internal( newStr, scratch, CAN_RETURN );
 848 }
 849
 850 static void
 851 internRelease (rtl_uString *pThis)
 852 {
 853     oslMutex pPoolMutex;
 854
 855     rtl_uString *pFree = NULL;
 856     if ( SAL_STRING_REFCOUNT(
 857              osl_decrementInterlockedCount( &(pThis->refCount) ) ) == 0)
 858     {
 859         pPoolMutex = getInternMutex();
 860         osl_acquireMutex( pPoolMutex );
 861
 862         rtl_str_hash_remove (pInternPool, pThis);
 863
 864         /* May have been separately acquired */
 865         if ( SAL_STRING_REFCOUNT(
 866                  osl_incrementInterlockedCount( &(pThis->refCount) ) ) == 1 )
 867         {
 868             /* we got the last ref */
 869             pFree = pThis;
 870         }
 871         else /* very unusual */
 872         {
 873             internRelease (pThis);
 874         }
 875
 876         osl_releaseMutex( pPoolMutex );
 877     }
 878     if (pFree)
 879         rtl_freeMemory (pFree);
 880 }
 881
 882 sal_uInt32 SAL_CALL rtl_uString_iterateCodePoints(
 883     rtl_uString const * string, sal_Int32 * indexUtf16,
 884     sal_Int32 incrementCodePoints)
 885 {
 886     sal_Int32 n;
 887     sal_Unicode cu;
 888     sal_uInt32 cp;
 889     OSL_ASSERT(string != NULL && indexUtf16 != NULL);
 890     n = *indexUtf16;
 891     OSL_ASSERT(n >= 0 && n <= string->length);
 892     while (incrementCodePoints < 0) {
 893         OSL_ASSERT(n > 0);
 894         cu = string->buffer[--n];
 895         if (SAL_RTL_IS_LOW_SURROGATE(cu) && n != 0 &&
 896             SAL_RTL_IS_HIGH_SURROGATE(string->buffer[n - 1]))
 897         {
 898             --n;
 899         }
 900         ++incrementCodePoints;
 901     }
 902     OSL_ASSERT(n >= 0 && n < string->length);
 903     cu = string->buffer[n];
 904     if (SAL_RTL_IS_HIGH_SURROGATE(cu) && string->length - n >= 2 &&
 905         SAL_RTL_IS_LOW_SURROGATE(string->buffer[n + 1]))
 906     {
 907         cp = SAL_RTL_COMBINE_SURROGATES(cu, string->buffer[n + 1]);
 908     } else {
 909         cp = cu;
 910     }
 911     while (incrementCodePoints > 0) {
 912         OSL_ASSERT(n < string->length);
 913         cu = string->buffer[n++];
 914         if (SAL_RTL_IS_HIGH_SURROGATE(cu) && n != string->length &&
 915             SAL_RTL_IS_LOW_SURROGATE(string->buffer[n]))
 916         {
 917             ++n;
 918         }
 919         --incrementCodePoints;
 920     }
 921     OSL_ASSERT(n >= 0 && n <= string->length);
 922     *indexUtf16 = n;
 923     return cp;
 924 }
 925
 926 sal_Bool rtl_convertStringToUString(
 927     rtl_uString ** target, char const * source, sal_Int32 length,
 928     rtl_TextEncoding encoding, sal_uInt32 flags) SAL_THROW_EXTERN_C()
 929 {
 930     sal_uInt32 info;
 931     rtl_string2UString_status(target, source, length, encoding, flags, &info);
 932     return (sal_Bool) ((info & RTL_TEXTTOUNICODE_INFO_ERROR) == 0);
 933 }