1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // no include "precompiled_tools.hxx" because this is included in other cxx files. 29 30 // ----------------------------------------------------------------------- 31 32 void ByteString::ImplUpdateStringFromUniString( 33 const sal_Unicode* pUniStr, sal_Size nUniLen, 34 rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) 35 { 36 ByteStringData* pNewStringData = NULL; 37 rtl_uString2String( (rtl_String **)(&pNewStringData), 38 pUniStr, nUniLen, 39 eTextEncoding, nCvtFlags ); 40 STRING_RELEASE((STRING_TYPE *)mpData); 41 mpData = pNewStringData; 42 } 43 44 // ======================================================================= 45 46 ByteString::ByteString( const UniString& rUniStr, rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) 47 { 48 DBG_CTOR( ByteString, DbgCheckByteString ); 49 DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString ); 50 51 mpData = NULL; 52 rtl_uString2String( (rtl_String **)(&mpData), 53 rUniStr.mpData->maStr, rUniStr.mpData->mnLen, 54 eTextEncoding, nCvtFlags ); 55 } 56 57 // ----------------------------------------------------------------------- 58 59 ByteString::ByteString( const UniString& rUniStr, xub_StrLen nPos, xub_StrLen nLen, 60 rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) 61 { 62 DBG_CTOR( ByteString, DbgCheckByteString ); 63 DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString ); 64 65 // Stringlaenge ermitteln 66 if ( nPos > rUniStr.mpData->mnLen ) 67 nLen = 0; 68 else 69 { 70 // Laenge korrigieren, wenn noetig 71 sal_Int32 nMaxLen = rUniStr.mpData->mnLen-nPos; 72 if ( nLen > nMaxLen ) 73 nLen = static_cast< xub_StrLen >(nMaxLen); 74 } 75 76 mpData = NULL; 77 rtl_uString2String( (rtl_String **)(&mpData), 78 rUniStr.mpData->maStr+nPos, nLen, 79 eTextEncoding, nCvtFlags ); 80 } 81 82 // ----------------------------------------------------------------------- 83 84 ByteString::ByteString( const sal_Unicode* pUniStr, 85 rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) 86 { 87 DBG_CTOR( ByteString, DbgCheckByteString ); 88 DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" ); 89 90 mpData = NULL; 91 rtl_uString2String( (rtl_String **)(&mpData), 92 pUniStr, ImplStringLen( pUniStr ), 93 eTextEncoding, nCvtFlags ); 94 } 95 96 // ----------------------------------------------------------------------- 97 98 ByteString::ByteString( const sal_Unicode* pUniStr, xub_StrLen nLen, 99 rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) 100 { 101 DBG_CTOR( ByteString, DbgCheckByteString ); 102 DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" ); 103 104 if ( nLen == STRING_LEN ) 105 nLen = ImplStringLen( pUniStr ); 106 107 mpData = NULL; 108 rtl_uString2String( (rtl_String **)(&mpData), 109 pUniStr, nLen, 110 eTextEncoding, nCvtFlags ); 111 } 112 113 // ======================================================================= 114 115 static sal_uChar aImplByteTab[256] = 116 { 117 0, 1, 2, 3, 4, 5, 6, 7, 118 8, 9, 10, 11, 12, 13, 14, 15, 119 16, 17, 18, 19, 20, 21, 22, 23, 120 24, 25, 26, 27, 28, 29, 30, 31, 121 32, 33, 34, 35, 36, 37, 38, 39, 122 40, 41, 42, 43, 44, 45, 46, 47, 123 48, 49, 50, 51, 52, 53, 54, 55, 124 56, 57, 58, 59, 60, 61, 62, 63, 125 64, 65, 66, 67, 68, 69, 70, 71, 126 72, 73, 74, 75, 76, 77, 78, 79, 127 80, 81, 82, 83, 84, 85, 86, 87, 128 88, 89, 90, 91, 92, 93, 94, 95, 129 96, 97, 98, 99, 100, 101, 102, 103, 130 104, 105, 106, 107, 108, 109, 110, 111, 131 112, 113, 114, 115, 116, 117, 118, 119, 132 120, 121, 122, 123, 124, 125, 126, 127, 133 128, 129, 130, 131, 132, 133, 134, 135, 134 136, 137, 138, 139, 140, 141, 142, 143, 135 144, 145, 146, 147, 148, 149, 150, 151, 136 152, 153, 154, 155, 156, 157, 158, 159, 137 160, 161, 162, 163, 164, 165, 166, 167, 138 168, 169, 170, 171, 172, 173, 174, 175, 139 176, 177, 178, 179, 180, 181, 182, 183, 140 184, 185, 186, 187, 188, 189, 190, 191, 141 192, 193, 194, 195, 196, 197, 198, 199, 142 200, 201, 202, 203, 204, 205, 206, 207, 143 208, 209, 210, 211, 212, 213, 214, 215, 144 216, 217, 218, 219, 220, 221, 222, 223, 145 224, 225, 226, 227, 228, 229, 230, 231, 146 232, 233, 234, 235, 236, 237, 238, 239, 147 240, 241, 242, 243, 244, 245, 246, 247, 148 248, 249, 250, 251, 252, 253, 254, 255 149 }; 150 151 // ======================================================================= 152 153 struct Impl1ByteUnicodeTabData 154 { 155 rtl_TextEncoding meTextEncoding; 156 sal_Unicode maUniTab[256]; 157 Impl1ByteUnicodeTabData* mpNext; 158 }; 159 160 // ----------------------------------------------------------------------- 161 162 struct Impl1ByteConvertTabData 163 { 164 rtl_TextEncoding meSrcTextEncoding; 165 rtl_TextEncoding meDestTextEncoding; 166 sal_uChar maConvertTab[256]; 167 sal_uChar maRepConvertTab[256]; 168 Impl1ByteConvertTabData* mpNext; 169 }; 170 171 // ======================================================================= 172 173 sal_Unicode* ImplGet1ByteUnicodeTab( rtl_TextEncoding eTextEncoding ) 174 { 175 #ifndef BOOTSTRAP 176 TOOLSINDATA* pToolsData = ImplGetToolsInData(); 177 #else 178 TOOLSINDATA* pToolsData = 0x0; 179 #endif 180 Impl1ByteUnicodeTabData* pTab = pToolsData->mpFirstUniTabData; 181 182 while ( pTab ) 183 { 184 if ( pTab->meTextEncoding == eTextEncoding ) 185 return pTab->maUniTab; 186 pTab = pTab->mpNext; 187 } 188 189 // get TextEncodingInfo 190 rtl_TextEncodingInfo aTextEncInfo; 191 aTextEncInfo.StructSize = sizeof( aTextEncInfo ); 192 rtl_getTextEncodingInfo( eTextEncoding, &aTextEncInfo ); 193 194 if ( aTextEncInfo.MaximumCharSize == 1 ) 195 { 196 pTab = new Impl1ByteUnicodeTabData; 197 pTab->meTextEncoding = eTextEncoding; 198 pTab->mpNext = pToolsData->mpFirstUniTabData; 199 200 rtl_TextToUnicodeConverter hConverter; 201 sal_uInt32 nInfo; 202 sal_Size nSrcBytes; 203 sal_Size nDestChars; 204 hConverter = rtl_createTextToUnicodeConverter( eTextEncoding ); 205 nDestChars = rtl_convertTextToUnicode( hConverter, 0, 206 (const sal_Char*)aImplByteTab, 256, 207 pTab->maUniTab, 256, 208 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | 209 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | 210 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, 211 &nInfo, &nSrcBytes ); 212 rtl_destroyTextToUnicodeConverter( hConverter ); 213 214 if ( (nSrcBytes != 256) || (nDestChars != 256) ) 215 delete pTab; 216 else 217 { 218 pToolsData->mpFirstUniTabData = pTab; 219 return pTab->maUniTab; 220 } 221 } 222 223 return NULL; 224 } 225 226 // ----------------------------------------------------------------------- 227 228 static sal_uChar* ImplGet1ByteConvertTab( rtl_TextEncoding eSrcTextEncoding, 229 rtl_TextEncoding eDestTextEncoding, 230 sal_Bool bReplace ) 231 { 232 #ifndef BOOTSTRAP 233 TOOLSINDATA* pToolsData = ImplGetToolsInData(); 234 #else 235 TOOLSINDATA* pToolsData = 0x0; 236 #endif 237 Impl1ByteConvertTabData* pTab = pToolsData->mpFirstConvertTabData; 238 239 while ( pTab ) 240 { 241 if ( (pTab->meSrcTextEncoding == eSrcTextEncoding) && 242 (pTab->meDestTextEncoding == eDestTextEncoding) ) 243 { 244 if ( bReplace ) 245 return pTab->maRepConvertTab; 246 else 247 return pTab->maConvertTab; 248 } 249 pTab = pTab->mpNext; 250 } 251 252 // get TextEncodingInfo 253 rtl_TextEncodingInfo aTextEncInfo1; 254 aTextEncInfo1.StructSize = sizeof( aTextEncInfo1 ); 255 rtl_getTextEncodingInfo( eSrcTextEncoding, &aTextEncInfo1 ); 256 rtl_TextEncodingInfo aTextEncInfo2; 257 aTextEncInfo2.StructSize = sizeof( aTextEncInfo2 ); 258 rtl_getTextEncodingInfo( eDestTextEncoding, &aTextEncInfo2 ); 259 260 if ( (aTextEncInfo1.MaximumCharSize == 1) && 261 (aTextEncInfo2.MaximumCharSize == 1) ) 262 { 263 pTab = new Impl1ByteConvertTabData; 264 pTab->meSrcTextEncoding = eSrcTextEncoding; 265 pTab->meDestTextEncoding = eDestTextEncoding; 266 pTab->mpNext = pToolsData->mpFirstConvertTabData; 267 268 rtl_TextToUnicodeConverter hConverter; 269 rtl_UnicodeToTextConverter hConverter2; 270 sal_uInt32 nInfo; 271 sal_Size nSrcBytes; 272 sal_Size nDestChars; 273 sal_Size nSrcChars; 274 sal_Size nDestBytes; 275 sal_Unicode aTempBuf[256]; 276 hConverter = rtl_createTextToUnicodeConverter( eSrcTextEncoding ); 277 nDestChars = rtl_convertTextToUnicode( hConverter, 0, 278 (const sal_Char*)aImplByteTab, 256, 279 aTempBuf, 256, 280 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT | 281 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | 282 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, 283 &nInfo, &nSrcBytes ); 284 rtl_destroyTextToUnicodeConverter( hConverter ); 285 if ( (nSrcBytes != 256) || (nDestChars != 256) ) 286 delete pTab; 287 else 288 { 289 hConverter2 = rtl_createUnicodeToTextConverter( eDestTextEncoding ); 290 nDestBytes = rtl_convertUnicodeToText( hConverter2, 0, 291 aTempBuf, 256, 292 (sal_Char*)pTab->maConvertTab, 256, 293 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 | 294 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT, 295 &nInfo, &nSrcChars ); 296 if ( (nDestBytes == 256) || (nSrcChars == 256) ) 297 { 298 nDestBytes = rtl_convertUnicodeToText( hConverter2, 0, 299 aTempBuf, 256, 300 (sal_Char*)pTab->maRepConvertTab, 256, 301 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | 302 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT | 303 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE, 304 &nInfo, &nSrcChars ); 305 } 306 rtl_destroyUnicodeToTextConverter( hConverter2 ); 307 if ( (nDestBytes != 256) || (nSrcChars != 256) ) 308 delete pTab; 309 else 310 { 311 pToolsData->mpFirstConvertTabData = pTab; 312 if ( bReplace ) 313 return pTab->maRepConvertTab; 314 else 315 return pTab->maConvertTab; 316 } 317 } 318 } 319 320 return NULL; 321 } 322 323 // ======================================================================= 324 325 void ImplDeleteCharTabData() 326 { 327 #ifndef BOOTSTRAP 328 TOOLSINDATA* pToolsData = ImplGetToolsInData(); 329 #else 330 TOOLSINDATA* pToolsData = 0x0; 331 #endif 332 Impl1ByteUnicodeTabData* pTempUniTab; 333 Impl1ByteUnicodeTabData* pUniTab = pToolsData->mpFirstUniTabData; 334 while ( pUniTab ) 335 { 336 pTempUniTab = pUniTab->mpNext; 337 delete pUniTab; 338 pUniTab = pTempUniTab; 339 } 340 pToolsData->mpFirstUniTabData = NULL; 341 342 Impl1ByteConvertTabData* pTempConvertTab; 343 Impl1ByteConvertTabData* pConvertTab = pToolsData->mpFirstConvertTabData; 344 while ( pConvertTab ) 345 { 346 pTempConvertTab = pConvertTab->mpNext; 347 delete pConvertTab; 348 pConvertTab = pTempConvertTab; 349 } 350 pToolsData->mpFirstConvertTabData = NULL; 351 } 352 353 // ======================================================================= 354 355 void ByteString::ImplStringConvert( 356 rtl_TextEncoding eSource, rtl_TextEncoding eTarget, sal_Bool bReplace ) 357 { 358 sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace ); 359 if ( pConvertTab ) 360 { 361 char* pStr = mpData->maStr; 362 while ( *pStr ) 363 { 364 sal_uChar c = (sal_uChar)*pStr; 365 sal_uChar cConv = pConvertTab[c]; 366 if ( c != cConv ) 367 { 368 pStr = ImplCopyStringData( pStr ); 369 *pStr = (char)cConv; 370 } 371 372 pStr++; 373 } 374 } 375 else 376 { 377 rtl_UnicodeToTextConverter hSrcConverter = rtl_createTextToUnicodeConverter( eSource ); 378 sal_uInt32 nInfo; 379 sal_Size nSrcBytes; 380 sal_Size nDestChars; 381 sal_Size nTempLen; 382 sal_Unicode* pTempBuf; 383 nTempLen = mpData->mnLen; 384 pTempBuf = new sal_Unicode[nTempLen]; 385 nDestChars = rtl_convertTextToUnicode( hSrcConverter, 0, 386 mpData->maStr, mpData->mnLen, 387 pTempBuf, nTempLen, 388 RTL_TEXTTOUNICODE_FLAGS_FLUSH | 389 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | 390 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | 391 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, 392 &nInfo, &nSrcBytes ); 393 rtl_destroyTextToUnicodeConverter( hSrcConverter ); 394 // Hier werten wir bReplace nicht aus, da fuer MultiByte-Textencodings 395 // sowieso keine Ersatzdarstellung moeglich ist. Da sich der String 396 // sowieso in der Laenge aendern kann, nehmen wir auch sonst keine 397 // Ruecksicht darauf, das die Laenge erhalten bleibt. 398 ImplUpdateStringFromUniString( pTempBuf, nDestChars, eTarget, 399 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | 400 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT | 401 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE | 402 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR | 403 RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 | 404 RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE | 405 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE ); 406 delete [] pTempBuf; 407 } 408 } 409 410 // ======================================================================= 411 412 ByteString& ByteString::Convert( rtl_TextEncoding eSource, rtl_TextEncoding eTarget, sal_Bool bReplace ) 413 { 414 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 415 416 // rtl_TextEncoding Dontknow kann nicht konvertiert werden 417 if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) ) 418 return *this; 419 420 // Wenn Source und Target gleich sind, muss nicht konvertiert werden 421 if ( eSource == eTarget ) 422 return *this; 423 424 // rtl_TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten 425 // wollen wir die Zeichencodes beibehalten 426 if ( (eSource == RTL_TEXTENCODING_SYMBOL) && 427 (eTarget != RTL_TEXTENCODING_UTF7) && 428 (eTarget != RTL_TEXTENCODING_UTF8) ) 429 return *this; 430 if ( (eTarget == RTL_TEXTENCODING_SYMBOL) && 431 (eSource != RTL_TEXTENCODING_UTF7) && 432 (eSource != RTL_TEXTENCODING_UTF8) ) 433 return *this; 434 435 // Zeichensatz umwandeln 436 ImplStringConvert( eSource, eTarget, bReplace ); 437 438 return *this; 439 } 440 441 // ======================================================================= 442 443 char ByteString::Convert( char c, 444 rtl_TextEncoding eSource, rtl_TextEncoding eTarget, 445 sal_Bool bReplace ) 446 { 447 // TextEncoding Dontknow kann nicht konvertiert werden 448 if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) ) 449 return '\0'; 450 451 // Wenn Source und Target gleich sind, muss nicht konvertiert werden 452 if ( eSource == eTarget ) 453 return c; 454 455 // TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten 456 // wollen wir die Zeichencodes beibehalten 457 if ( (eSource == RTL_TEXTENCODING_SYMBOL) && 458 (eTarget != RTL_TEXTENCODING_UTF7) && 459 (eTarget != RTL_TEXTENCODING_UTF8) ) 460 return '\0'; 461 if ( (eTarget == RTL_TEXTENCODING_SYMBOL) && 462 (eSource != RTL_TEXTENCODING_UTF7) && 463 (eSource != RTL_TEXTENCODING_UTF8) ) 464 return '\0'; 465 466 sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace ); 467 if ( pConvertTab ) 468 return (char)pConvertTab[(sal_uChar)c]; 469 else 470 return '\0'; 471 } 472 473 // ======================================================================= 474 475 sal_Unicode ByteString::ConvertToUnicode( char c, rtl_TextEncoding eTextEncoding ) 476 { 477 sal_Size nLen = 1; 478 return ConvertToUnicode( &c, &nLen, eTextEncoding ); 479 } 480 481 // ----------------------------------------------------------------------- 482 483 char ByteString::ConvertFromUnicode( sal_Unicode c, rtl_TextEncoding eTextEncoding, sal_Bool bReplace ) 484 { 485 sal_Size nLen; 486 char aBuf[30]; 487 nLen = ConvertFromUnicode( c, aBuf, sizeof( aBuf ), eTextEncoding, bReplace ); 488 if ( nLen == 1 ) 489 return aBuf[0]; 490 else 491 return 0; 492 } 493 494 // ----------------------------------------------------------------------- 495 496 sal_Unicode ByteString::ConvertToUnicode( const char* pChar, sal_Size* pLen, rtl_TextEncoding eTextEncoding ) 497 { 498 // TextEncoding Dontknow wird nicht konvertiert 499 if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW ) 500 return 0; 501 502 rtl_TextToUnicodeConverter hConverter; 503 sal_uInt32 nInfo; 504 sal_Size nSrcBytes; 505 sal_Size nDestChars; 506 sal_Unicode nConvChar; 507 hConverter = rtl_createTextToUnicodeConverter( eTextEncoding ); 508 nDestChars = rtl_convertTextToUnicode( hConverter, 0, 509 (const sal_Char*)pChar, *pLen, 510 &nConvChar, 1, 511 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT | 512 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | 513 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT | 514 RTL_TEXTTOUNICODE_FLAGS_FLUSH, 515 &nInfo, &nSrcBytes ); 516 rtl_destroyTextToUnicodeConverter( hConverter ); 517 518 if ( nDestChars == 1 ) 519 { 520 *pLen = nSrcBytes; 521 return nConvChar; 522 } 523 else 524 { 525 *pLen = 0; 526 return 0; 527 } 528 } 529 530 // ----------------------------------------------------------------------- 531 532 sal_Size ByteString::ConvertFromUnicode( sal_Unicode c, char* pBuf, sal_Size nBufLen, rtl_TextEncoding eTextEncoding, 533 sal_Bool bReplace ) 534 { 535 // TextEncoding Dontknow wird nicht konvertiert 536 if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW ) 537 return '\0'; 538 539 rtl_UnicodeToTextConverter hConverter; 540 sal_uInt32 nInfo; 541 sal_Size nSrcChars; 542 sal_Size nDestBytes; 543 sal_Unicode cUni = c; 544 sal_uInt32 nFlags = RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE | 545 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE | 546 RTL_UNICODETOTEXT_FLAGS_FLUSH; 547 if ( bReplace ) 548 { 549 nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | 550 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT; 551 nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE; 552 if ( nBufLen > 1 ) 553 nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR; 554 } 555 else 556 { 557 nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 | 558 RTL_UNICODETOTEXT_FLAGS_INVALID_0; 559 } 560 561 hConverter = rtl_createUnicodeToTextConverter( eTextEncoding ); 562 nDestBytes = rtl_convertUnicodeToText( hConverter, 0, 563 &cUni, 1, 564 (sal_Char*)pBuf, nBufLen, 565 nFlags, 566 &nInfo, &nSrcChars ); 567 rtl_destroyUnicodeToTextConverter( hConverter ); 568 return nDestBytes; 569 } 570 571 // ======================================================================= 572 573 ByteString::ByteString( const rtl::OString& rStr ) 574 : mpData(NULL) 575 { 576 DBG_CTOR( ByteString, DbgCheckByteString ); 577 578 OSL_ENSURE(rStr.pData->length < STRING_MAXLEN, 579 "Overflowing rtl::OString -> ByteString cut to zero length"); 580 581 if (rStr.pData->length < STRING_MAXLEN) 582 { 583 mpData = reinterpret_cast< ByteStringData * >(const_cast< rtl::OString & >(rStr).pData); 584 STRING_ACQUIRE((STRING_TYPE *)mpData); 585 } 586 else 587 { 588 STRING_NEW((STRING_TYPE **)&mpData); 589 } 590 } 591 592 // ----------------------------------------------------------------------- 593 594 ByteString& ByteString::Assign( const rtl::OString& rStr ) 595 { 596 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 597 598 OSL_ENSURE(rStr.pData->length < STRING_MAXLEN, 599 "Overflowing rtl::OString -> ByteString cut to zero length"); 600 601 if (rStr.pData->length < STRING_MAXLEN) 602 { 603 STRING_RELEASE((STRING_TYPE *)mpData); 604 mpData = reinterpret_cast< ByteStringData * >(const_cast< rtl::OString & >(rStr).pData); 605 STRING_ACQUIRE((STRING_TYPE *)mpData); 606 } 607 else 608 { 609 STRING_NEW((STRING_TYPE **)&mpData); 610 } 611 612 return *this; 613 } 614