tools/source/string/strascii.cxx

   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: strascii.cxx,v $
  10  * $Revision: 1.9 $
  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
  31 // no include "precompiled_tools.hxx" because this is included in other cxx files.
  32
  33 // =======================================================================
  34
  35 #ifdef DBG_UTIL
  36
  37 static BOOL ImplDbgCheckAsciiStr( const sal_Char* pAsciiStr, sal_Int32 nLen )
  38 {
  39     while ( nLen && *pAsciiStr )
  40     {
  41         if ( ((unsigned char)*pAsciiStr) > 127 )
  42             return FALSE;
  43         ++pAsciiStr,
  44         --nLen;
  45     }
  46
  47     return TRUE;
  48 }
  49
  50 #endif
  51
  52 // =======================================================================
  53
  54 static void ImplCopyAsciiStr( sal_Unicode* pDest, const sal_Char* pSrc,
  55                               sal_Int32 nLen )
  56 {
  57     DBG_ASSERT( ImplDbgCheckAsciiStr( pSrc, nLen ),
  58                 "UniString::CopyAsciiStr() - pAsciiStr include characters > 127" );
  59
  60     while ( nLen )
  61     {
  62         *pDest = (unsigned char)*pSrc;
  63         ++pDest,
  64         ++pSrc,
  65         --nLen;
  66     }
  67 }
  68
  69 // =======================================================================
  70
  71 static sal_Int32 ImplStringCompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2 )
  72 {
  73     sal_Int32 nRet;
  74     while ( ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) &&
  75             *pStr2 )
  76     {
  77         ++pStr1,
  78         ++pStr2;
  79     }
  80
  81     return nRet;
  82 }
  83
  84 // -----------------------------------------------------------------------
  85
  86 static sal_Int32 ImplStringCompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2,
  87                                          xub_StrLen nCount )
  88 {
  89     sal_Int32 nRet = 0;
  90     while ( nCount &&
  91             ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) &&
  92             *pStr2 )
  93     {
  94         ++pStr1,
  95         ++pStr2,
  96         --nCount;
  97     }
  98
  99     return nRet;
 100 }
 101
 102 // -----------------------------------------------------------------------
 103
 104 static sal_Int32 ImplStringCompareWithoutZeroAscii( const sal_Unicode* pStr1, const sal_Char* pStr2,
 105                                                     xub_StrLen nCount )
 106 {
 107     sal_Int32 nRet = 0;
 108     while ( nCount &&
 109             ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) )
 110     {
 111         ++pStr1,
 112         ++pStr2,
 113         --nCount;
 114     }
 115
 116     return nRet;
 117 }
 118
 119 // -----------------------------------------------------------------------
 120
 121 static sal_Int32 ImplStringICompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2 )
 122 {
 123     sal_Int32   nRet;
 124     sal_Unicode c1;
 125     sal_Char    c2;
 126     do
 127     {
 128         // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln
 129         c1 = *pStr1;
 130         c2 = *pStr2;
 131         if ( (c1 >= 65) && (c1 <= 90) )
 132             c1 += 32;
 133         if ( (c2 >= 65) && (c2 <= 90) )
 134             c2 += 32;
 135         nRet = ((sal_Int32)c1)-((sal_Int32)((unsigned char)c2));
 136         if ( nRet != 0 )
 137             break;
 138
 139         ++pStr1,
 140         ++pStr2;
 141     }
 142     while ( c2 );
 143
 144     return nRet;
 145 }
 146
 147 // -----------------------------------------------------------------------
 148
 149 static sal_Int32 ImplStringICompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2,
 150                                           xub_StrLen nCount )
 151 {
 152     sal_Int32   nRet = 0;
 153     sal_Unicode c1;
 154     sal_Char    c2;
 155     do
 156     {
 157         if ( !nCount )
 158             break;
 159
 160         // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln
 161         c1 = *pStr1;
 162         c2 = *pStr2;
 163         if ( (c1 >= 65) && (c1 <= 90) )
 164             c1 += 32;
 165         if ( (c2 >= 65) && (c2 <= 90) )
 166             c2 += 32;
 167         nRet = ((sal_Int32)c1)-((sal_Int32)((unsigned char)c2));
 168         if ( nRet != 0 )
 169             break;
 170
 171         ++pStr1,
 172         ++pStr2,
 173         --nCount;
 174     }
 175     while ( c2 );
 176
 177     return nRet;
 178 }
 179
 180 // =======================================================================
 181
 182 UniString UniString::CreateFromAscii( const sal_Char* pAsciiStr )
 183 {
 184     DBG_ASSERT( pAsciiStr, "UniString::CreateFromAscii() - pAsciiStr is NULL" );
 185
 186     // Stringlaenge ermitteln
 187     xub_StrLen nLen = ImplStringLen( pAsciiStr );
 188
 189     UniString aTempStr;
 190     if ( nLen )
 191     {
 192         ImplCopyAsciiStr( aTempStr.AllocBuffer( nLen ), pAsciiStr, nLen );
 193     }
 194     return aTempStr;
 195 }
 196
 197 // -----------------------------------------------------------------------
 198
 199 UniString UniString::CreateFromAscii( const sal_Char* pAsciiStr, xub_StrLen nLen )
 200 {
 201     DBG_ASSERT( pAsciiStr, "UniString::CreateFromAscii() - pAsciiStr is NULL" );
 202
 203     // Stringlaenge ermitteln
 204     if ( nLen == STRING_LEN )
 205         nLen = ImplStringLen( pAsciiStr );
 206
 207     UniString aTempStr;
 208
 209     if ( nLen )
 210     {
 211         ImplCopyAsciiStr( aTempStr.AllocBuffer( nLen ), pAsciiStr, nLen );
 212     }
 213     return aTempStr;
 214 }
 215
 216 // -----------------------------------------------------------------------
 217
 218 UniString& UniString::AssignAscii( const sal_Char* pAsciiStr )
 219 {
 220     DBG_CHKTHIS( UniString, DbgCheckUniString );
 221     DBG_ASSERT( pAsciiStr, "UniString::AssignAscii() - pAsciiStr is NULL" );
 222
 223     // Stringlaenge ermitteln
 224     xub_StrLen nLen = ImplStringLen( pAsciiStr );
 225
 226     if ( !nLen )
 227     {
 228         STRING_NEW((STRING_TYPE **)&mpData);
 229     }
 230     else
 231     {
 232         // Wenn String genauso lang ist, wie der String, dann direkt kopieren
 233         if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) )
 234             ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen );
 235         else
 236         {
 237             // Alte Daten loeschen
 238             STRING_RELEASE((STRING_TYPE *)mpData);
 239
 240             // Daten initialisieren und String kopieren
 241             mpData = ImplAllocData( nLen );
 242             ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen );
 243         }
 244     }
 245
 246     return *this;
 247 }
 248
 249 // -----------------------------------------------------------------------
 250
 251 UniString& UniString::AssignAscii( const sal_Char* pAsciiStr, xub_StrLen nLen )
 252 {
 253     DBG_CHKTHIS( UniString, DbgCheckUniString );
 254     DBG_ASSERT( pAsciiStr, "UniString::AssignAscii() - pAsciiStr is NULL" );
 255
 256     if ( nLen == STRING_LEN )
 257         nLen = ImplStringLen( pAsciiStr );
 258
 259 #ifdef DBG_UTIL
 260     if ( DbgIsAssert() )
 261     {
 262         for ( xub_StrLen i = 0; i < nLen; ++i )
 263         {
 264             if ( !pAsciiStr[i] )
 265             {
 266                 DBG_ERROR( "UniString::AssignAscii() : nLen is wrong" );
 267             }
 268         }
 269     }
 270 #endif
 271
 272     if ( !nLen )
 273     {
 274         STRING_NEW((STRING_TYPE **)&mpData);
 275     }
 276     else
 277     {
 278         // Wenn String genauso lang ist, wie der String, dann direkt kopieren
 279         if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) )
 280             ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen );
 281         else
 282         {
 283             // Alte Daten loeschen
 284             STRING_RELEASE((STRING_TYPE *)mpData);
 285
 286             // Daten initialisieren und String kopieren
 287             mpData = ImplAllocData( nLen );
 288             ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen );
 289         }
 290     }
 291
 292     return *this;
 293 }
 294
 295 // -----------------------------------------------------------------------
 296
 297 UniString& UniString::AppendAscii( const sal_Char* pAsciiStr )
 298 {
 299     DBG_CHKTHIS( UniString, DbgCheckUniString );
 300     DBG_ASSERT( pAsciiStr, "UniString::AppendAscii() - pAsciiStr is NULL" );
 301
 302     // Stringlaenge ermitteln
 303     sal_Int32 nCopyLen = ImplStringLen( pAsciiStr );
 304
 305     // Ueberlauf abfangen
 306     nCopyLen = ImplGetCopyLen( mpData->mnLen, nCopyLen );
 307
 308     // Ist es kein leerer String
 309     if ( nCopyLen )
 310     {
 311         // Neue Datenstruktur und neuen String erzeugen
 312         UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen );
 313
 314         // String kopieren
 315         memcpy( pNewData->maStr, mpData->maStr, mpData->mnLen*sizeof( sal_Unicode ) );
 316         ImplCopyAsciiStr( pNewData->maStr+mpData->mnLen, pAsciiStr, nCopyLen );
 317
 318         // Alte Daten loeschen und Neue zuweisen
 319         STRING_RELEASE((STRING_TYPE *)mpData);
 320         mpData = pNewData;
 321     }
 322
 323     return *this;
 324 }
 325
 326 // -----------------------------------------------------------------------
 327
 328 UniString& UniString::AppendAscii( const sal_Char* pAsciiStr, xub_StrLen nLen )
 329 {
 330     DBG_CHKTHIS( UniString, DbgCheckUniString );
 331     DBG_ASSERT( pAsciiStr, "UniString::AppendAscii() - pAsciiStr is NULL" );
 332
 333     if ( nLen == STRING_LEN )
 334         nLen = ImplStringLen( pAsciiStr );
 335
 336 #ifdef DBG_UTIL
 337     if ( DbgIsAssert() )
 338     {
 339         for ( xub_StrLen i = 0; i < nLen; ++i )
 340         {
 341             if ( !pAsciiStr[i] )
 342             {
 343                 DBG_ERROR( "UniString::AppendAscii() : nLen is wrong" );
 344             }
 345         }
 346     }
 347 #endif
 348
 349     // Ueberlauf abfangen
 350     sal_Int32 nCopyLen = ImplGetCopyLen( mpData->mnLen, nLen );
 351
 352     // Ist es kein leerer String
 353     if ( nCopyLen )
 354     {
 355         // Neue Datenstruktur und neuen String erzeugen
 356         UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen );
 357
 358         // String kopieren
 359         memcpy( pNewData->maStr, mpData->maStr, mpData->mnLen*sizeof( sal_Unicode ) );
 360         ImplCopyAsciiStr( pNewData->maStr+mpData->mnLen, pAsciiStr, nCopyLen );
 361
 362         // Alte Daten loeschen und Neue zuweisen
 363         STRING_RELEASE((STRING_TYPE *)mpData);
 364         mpData = pNewData;
 365     }
 366
 367     return *this;
 368 }
 369
 370 // -----------------------------------------------------------------------
 371
 372 UniString& UniString::InsertAscii( const char* pAsciiStr, xub_StrLen nIndex )
 373 {
 374     DBG_CHKTHIS( UniString, DbgCheckUniString );
 375     DBG_ASSERT( pAsciiStr, "UniString::InsertAscii() - pAsciiStr is NULL" );
 376
 377     // Stringlaenge ermitteln
 378     sal_Int32 nCopyLen = ImplStringLen( pAsciiStr );
 379
 380     // Ueberlauf abfangen
 381     nCopyLen = ImplGetCopyLen( mpData->mnLen, nCopyLen );
 382
 383     // Ist der einzufuegende String ein Leerstring
 384     if ( !nCopyLen )
 385         return *this;
 386
 387     // Index groesser als Laenge
 388     if ( nIndex > mpData->mnLen )
 389         nIndex = static_cast< xub_StrLen >(mpData->mnLen);
 390
 391     // Neue Laenge ermitteln und neuen String anlegen
 392     UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen );
 393
 394     // String kopieren
 395     memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( sal_Unicode ) );
 396     ImplCopyAsciiStr( pNewData->maStr+nIndex, pAsciiStr, nCopyLen );
 397     memcpy( pNewData->maStr+nIndex+nCopyLen, mpData->maStr+nIndex,
 398             (mpData->mnLen-nIndex)*sizeof( sal_Unicode ) );
 399
 400     // Alte Daten loeschen und Neue zuweisen
 401     STRING_RELEASE((STRING_TYPE *)mpData);
 402     mpData = pNewData;
 403
 404     return *this;
 405 }
 406
 407 // -----------------------------------------------------------------------
 408
 409 UniString& UniString::ReplaceAscii( xub_StrLen nIndex, xub_StrLen nCount,
 410                                     const sal_Char* pAsciiStr, xub_StrLen nStrLen )
 411 {
 412     DBG_CHKTHIS( UniString, DbgCheckUniString );
 413     DBG_ASSERT( pAsciiStr, "UniString::ReplaceAscii() - pAsciiStr is NULL" );
 414
 415     // Wenn Index groessergleich Laenge ist, dann ist es ein Append
 416     if ( nIndex >= mpData->mnLen )
 417     {
 418         AppendAscii( pAsciiStr, nStrLen );
 419         return *this;
 420     }
 421
 422     // Ist es eine Zuweisung
 423     if ( (nIndex == 0) && (nCount >= mpData->mnLen) )
 424     {
 425         AssignAscii( pAsciiStr, nStrLen );
 426         return *this;
 427     }
 428
 429     // Reicht ein Erase
 430     if ( nStrLen == STRING_LEN )
 431         nStrLen = ImplStringLen( pAsciiStr );
 432     if ( !nStrLen )
 433         return Erase( nIndex, nCount );
 434
 435     // nCount darf nicht ueber das Stringende hinnausgehen
 436     if ( nCount > mpData->mnLen - nIndex )
 437         nCount = static_cast< xub_StrLen >(mpData->mnLen-nIndex);
 438
 439     // Reicht eine zeichenweise Zuweisung
 440     if ( nCount == nStrLen )
 441     {
 442         ImplCopyData();
 443         ImplCopyAsciiStr( mpData->maStr+nIndex, pAsciiStr, nStrLen );
 444         return *this;
 445     }
 446
 447     // Ueberlauf abfangen
 448     sal_Int32 n = ImplGetCopyLen( mpData->mnLen-nCount, nStrLen );
 449
 450     // Neue Daten anlegen
 451     STRINGDATA* pNewData = ImplAllocData( mpData->mnLen-nCount+n );
 452
 453     // String kopieren
 454     memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) );
 455     ImplCopyAsciiStr( pNewData->maStr+nIndex, pAsciiStr, n );
 456     memcpy( pNewData->maStr+nIndex+n, mpData->maStr+nIndex+nCount,
 457             (mpData->mnLen-nIndex-nCount+1)*sizeof( STRCODE ) );
 458
 459     // Alte Daten loeschen und Neue zuweisen
 460     STRING_RELEASE((STRING_TYPE *)mpData);
 461     mpData = pNewData;
 462
 463     return *this;
 464 }
 465
 466 // -----------------------------------------------------------------------
 467
 468 StringCompare UniString::CompareToAscii( const sal_Char* pAsciiStr,
 469                                          xub_StrLen nLen ) const
 470 {
 471     DBG_CHKTHIS( UniString, DbgCheckUniString );
 472     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ),
 473                 "UniString::CompareToAscii() - pAsciiStr include characters > 127" );
 474
 475     // String vergleichen
 476     sal_Int32 nCompare = ImplStringCompareAscii( mpData->maStr, pAsciiStr, nLen );
 477
 478     // Rueckgabewert anpassen
 479     if ( nCompare == 0 )
 480         return COMPARE_EQUAL;
 481     else if ( nCompare < 0 )
 482         return COMPARE_LESS;
 483     else
 484         return COMPARE_GREATER;
 485 }
 486
 487 // -----------------------------------------------------------------------
 488
 489 StringCompare UniString::CompareIgnoreCaseToAscii( const sal_Char* pAsciiStr,
 490                                                    xub_StrLen nLen ) const
 491 {
 492     DBG_CHKTHIS( UniString, DbgCheckUniString );
 493     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ),
 494                 "UniString::CompareIgnoreCaseToAscii() - pAsciiStr include characters > 127" );
 495
 496     // String vergleichen
 497     sal_Int32 nCompare = ImplStringICompareAscii( mpData->maStr, pAsciiStr, nLen );
 498
 499     // Rueckgabewert anpassen
 500     if ( nCompare == 0 )
 501         return COMPARE_EQUAL;
 502     else if ( nCompare < 0 )
 503         return COMPARE_LESS;
 504     else
 505         return COMPARE_GREATER;
 506 }
 507
 508 // -----------------------------------------------------------------------
 509
 510 BOOL UniString::EqualsAscii( const sal_Char* pAsciiStr ) const
 511 {
 512     DBG_CHKTHIS( UniString, DbgCheckUniString );
 513     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ),
 514                 "UniString::EqualsAscii() - pAsciiStr include characters > 127" );
 515
 516     return (ImplStringCompareAscii( mpData->maStr, pAsciiStr ) == 0);
 517 }
 518
 519 // -----------------------------------------------------------------------
 520
 521 BOOL UniString::EqualsIgnoreCaseAscii( const sal_Char* pAsciiStr ) const
 522 {
 523     DBG_CHKTHIS( UniString, DbgCheckUniString );
 524     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ),
 525                 "UniString::EqualsIgnoreCaseAscii() - pAsciiStr include characters > 127" );
 526
 527     return (ImplStringICompareAscii( mpData->maStr, pAsciiStr ) == 0);
 528 }
 529
 530 // -----------------------------------------------------------------------
 531
 532 BOOL UniString::EqualsAscii( const sal_Char* pAsciiStr,
 533                              xub_StrLen nIndex, xub_StrLen nLen ) const
 534 {
 535     DBG_CHKTHIS( UniString, DbgCheckUniString );
 536     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ),
 537                 "UniString::EqualsAscii() - pAsciiStr include characters > 127" );
 538
 539     // Are there enough codes for comparing?
 540     if ( nIndex > mpData->mnLen )
 541         return (*pAsciiStr == 0);
 542
 543     return (ImplStringCompareAscii( mpData->maStr+nIndex, pAsciiStr, nLen ) == 0);
 544 }
 545
 546 // -----------------------------------------------------------------------
 547
 548 BOOL UniString::EqualsIgnoreCaseAscii( const sal_Char* pAsciiStr,
 549                                        xub_StrLen nIndex, xub_StrLen nLen ) const
 550 {
 551     DBG_CHKTHIS( UniString, DbgCheckUniString );
 552     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ),
 553                 "UniString::EqualsIgnoreCaseAscii() - pAsciiStr include characters > 127" );
 554
 555     // Are there enough codes for comparing?
 556     if ( nIndex > mpData->mnLen )
 557         return (*pAsciiStr == 0);
 558
 559     return (ImplStringICompareAscii( mpData->maStr+nIndex, pAsciiStr, nLen ) == 0);
 560 }
 561
 562 // -----------------------------------------------------------------------
 563
 564 xub_StrLen UniString::SearchAscii( const sal_Char* pAsciiStr, xub_StrLen nIndex ) const
 565 {
 566     DBG_CHKTHIS( UniString, DbgCheckUniString );
 567     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ),
 568                 "UniString::SearchAscii() - pAsciiStr include characters > 127" );
 569
 570     sal_Int32 nLen = mpData->mnLen;
 571     xub_StrLen nStrLen  = ImplStringLen( pAsciiStr );
 572
 573     // Falls die Laenge des uebergebenen Strings 0 ist oder der Index
 574     // hinter dem String liegt, dann wurde der String nicht gefunden
 575     if ( !nStrLen || (nIndex >= nLen) )
 576         return STRING_NOTFOUND;
 577
 578     const sal_Unicode* pStr = mpData->maStr;
 579     pStr += nIndex;
 580
 581     if ( nStrLen == 1 )
 582     {
 583         sal_Unicode cSearch = (unsigned char)*pAsciiStr;
 584         while ( nIndex < nLen )
 585         {
 586             if ( *pStr == cSearch )
 587                 return nIndex;
 588             ++pStr,
 589             ++nIndex;
 590         }
 591     }
 592     else
 593     {
 594         // Nur innerhalb des Strings suchen
 595         while ( nLen - nIndex >= nStrLen )
 596         {
 597             // Stimmt der String ueberein
 598             if ( ImplStringCompareWithoutZeroAscii( pStr, pAsciiStr, nStrLen ) == 0 )
 599                 return nIndex;
 600             ++pStr,
 601             ++nIndex;
 602         }
 603     }
 604
 605     return STRING_NOTFOUND;
 606 }
 607
 608 // -----------------------------------------------------------------------
 609
 610 xub_StrLen UniString::SearchAndReplaceAscii( const sal_Char* pAsciiStr, const UniString& rRepStr,
 611                                              xub_StrLen nIndex )
 612 {
 613     DBG_CHKTHIS( UniString, DbgCheckUniString );
 614     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ),
 615                 "UniString::SearchAndReplaceAscii() - pAsciiStr include characters > 127" );
 616
 617     xub_StrLen nSPos = SearchAscii( pAsciiStr, nIndex );
 618     if ( nSPos != STRING_NOTFOUND )
 619         Replace( nSPos, ImplStringLen( pAsciiStr ), rRepStr );
 620
 621     return nSPos;
 622 }
 623
 624 // -----------------------------------------------------------------------
 625
 626 void UniString::SearchAndReplaceAllAscii( const sal_Char* pAsciiStr, const UniString& rRepStr )
 627 {
 628     DBG_CHKTHIS( UniString, DbgCheckUniString );
 629     DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ),
 630                 "UniString::SearchAndReplaceAllAscii() - pAsciiStr include characters > 127" );
 631
 632     xub_StrLen nCharLen = ImplStringLen( pAsciiStr );
 633     xub_StrLen nSPos = SearchAscii( pAsciiStr, 0 );
 634     while ( nSPos != STRING_NOTFOUND )
 635     {
 636         Replace( nSPos, nCharLen, rRepStr );
 637         nSPos = nSPos + rRepStr.Len();
 638         nSPos = SearchAscii( pAsciiStr, nSPos );
 639     }
 640 }