LCOV - code coverage report
Current view: top level - sax/source/expatwrap - xml2utf.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 111 231 48.1 %
Date: 2015-06-13 12:38:46 Functions: 6 14 42.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : #include <string.h>
      20             : 
      21             : #include <algorithm>
      22             : 
      23             : #include <sal/types.h>
      24             : 
      25             : #include <rtl/textenc.h>
      26             : #include <rtl/tencinfo.h>
      27             : 
      28             : #include <com/sun/star/io/XInputStream.hpp>
      29             : 
      30             : using namespace ::com::sun::star::uno;
      31             : using namespace ::com::sun::star::io;
      32             : 
      33             : 
      34             : #include "xml2utf.hxx"
      35             : #include <boost/scoped_array.hpp>
      36             : 
      37             : namespace sax_expatwrap {
      38             : 
      39       89241 : sal_Int32 XMLFile2UTFConverter::readAndConvert( Sequence<sal_Int8> &seq , sal_Int32 nMaxToRead )
      40             :     throw ( IOException, NotConnectedException , BufferSizeExceededException , RuntimeException )
      41             : {
      42       89241 :     if( ! m_in.is() ) {
      43           0 :         throw NotConnectedException();
      44             :     }
      45       89241 :     if( ! m_bStarted ) {
      46             :         // it should be possible to find the encoding attribute
      47             :         // within the first 512 bytes == 128 chars in UCS-4
      48       42949 :         nMaxToRead = ::std::max( sal_Int32(512) , nMaxToRead );
      49             :     }
      50             : 
      51             :     sal_Int32 nRead;
      52       89241 :     Sequence< sal_Int8 > seqStart;
      53             :     while( true )
      54             :     {
      55       89244 :         nRead = m_in->readSomeBytes( seq , nMaxToRead );
      56             : 
      57       89244 :         if( nRead + seqStart.getLength())
      58             :         {
      59             :             // if nRead is 0, the file is already eof.
      60       46300 :             if( ! m_bStarted && nRead )
      61             :             {
      62             :                 // ensure that enough data is available to parse encoding
      63       42359 :                 if( seqStart.getLength() )
      64             :                 {
      65             :                   // prefix with what we had so far.
      66           2 :                   sal_Int32 nLength = seq.getLength();
      67           2 :                   seq.realloc( seqStart.getLength() + nLength );
      68             : 
      69           4 :                   memmove (seq.getArray() + seqStart.getLength(),
      70           2 :                        seq.getConstArray(),
      71           6 :                        nLength);
      72           2 :                   memcpy  (seq.getArray(),
      73           2 :                        seqStart.getConstArray(),
      74           4 :                        seqStart.getLength());
      75             :                 }
      76             : 
      77             :                 // autodetection with the first bytes
      78       42359 :                 if( ! isEncodingRecognizable( seq ) )
      79             :                 {
      80             :                   // remember what we have so far.
      81           3 :                   seqStart = seq;
      82             : 
      83             :                   // read more !
      84           3 :                   continue;
      85             :                 }
      86       42356 :                 if( scanForEncoding( seq ) || !m_sEncoding.isEmpty() ) {
      87             :                     // initialize decoding
      88       42044 :                     initializeDecoding();
      89             :                 }
      90       42356 :                 seqStart = Sequence < sal_Int8 > ();
      91             :             }
      92             : 
      93             :             // do the encoding
      94       46297 :             if( m_pText2Unicode && m_pUnicode2Text &&
      95       46297 :                 m_pText2Unicode->canContinue() && m_pUnicode2Text->canContinue() ) {
      96             : 
      97           0 :                 Sequence<sal_Unicode> seqUnicode = m_pText2Unicode->convert( seq );
      98           0 :                 seq = m_pUnicode2Text->convert( seqUnicode.getConstArray(), seqUnicode.getLength() );
      99             :             }
     100             : 
     101       46297 :             if( ! m_bStarted )
     102             :             {
     103             :                 // it must now be ensured, that no encoding attribute exist anymore
     104             :                 // ( otherwise the expat-Parser will crash )
     105             :                 // This must be done after decoding !
     106             :                 // ( e.g. Files decoded in ucs-4 cannot be read properly )
     107       42357 :                 m_bStarted = true;
     108       42357 :                 removeEncoding( seq );
     109             :             }
     110       46297 :             nRead = seq.getLength();
     111             :         }
     112             : 
     113       89241 :         break;
     114             :     }
     115       89241 :     return nRead;
     116             : }
     117             : 
     118             : 
     119      172930 : XMLFile2UTFConverter::~XMLFile2UTFConverter()
     120             : {
     121       86465 :     if( m_pText2Unicode )
     122           0 :         delete m_pText2Unicode;
     123       86465 :     if( m_pUnicode2Text )
     124           0 :         delete m_pUnicode2Text;
     125       86465 : }
     126             : 
     127             : 
     128       42357 : void XMLFile2UTFConverter::removeEncoding( Sequence<sal_Int8> &seq )
     129             : {
     130       42357 :     const sal_Int8 *pSource = seq.getArray();
     131       42357 :     if( ! strncmp( reinterpret_cast<const char *>(pSource), "<?xml", 4) )
     132             :     {
     133             : 
     134             :         // scan for encoding
     135       42044 :         OString str( reinterpret_cast<char const *>(pSource), seq.getLength() );
     136             : 
     137             :         // cut sequence to first line break
     138             :         // find first line break;
     139       42044 :         int nMax = str.indexOf( 10 );
     140       42044 :         if( nMax >= 0 )
     141             :         {
     142       41975 :             str = str.copy( 0 , nMax );
     143             :         }
     144             : 
     145       42044 :         int nFound = str.indexOf( " encoding" );
     146       42044 :         if( nFound >= 0 ) {
     147             :             int nStop;
     148       42027 :             int nStart = str.indexOf( "\"" , nFound );
     149       42027 :             if( nStart < 0 || str.indexOf( "'" , nFound ) < nStart )
     150             :             {
     151       42026 :                 nStart = str.indexOf( "'" , nFound );
     152       42026 :                 nStop  = str.indexOf( "'" , nStart +1 );
     153             :             }
     154             :             else
     155             :             {
     156           1 :                 nStop  = str.indexOf( "\"" , nStart +1);
     157             :             }
     158             : 
     159       42027 :             if( nStart >= 0 && nStop >= 0 && nStart+1 < nStop )
     160             :             {
     161             :                 // remove encoding tag from file
     162           2 :                 memmove(        &( seq.getArray()[nFound] ) ,
     163           1 :                                 &( seq.getArray()[nStop+1]) ,
     164           3 :                                 seq.getLength() - nStop -1);
     165           1 :                 seq.realloc( seq.getLength() - ( nStop+1 - nFound ) );
     166             : //              str = String( (char * ) seq.getArray() , seq.getLen() );
     167             :             }
     168       42044 :         }
     169             :     }
     170       42357 : }
     171             : 
     172             : // Checks, if enough data has been accumulated to recognize the encoding
     173       42359 : bool XMLFile2UTFConverter::isEncodingRecognizable( const Sequence< sal_Int8 > &seq)
     174             : {
     175       42359 :     const sal_Int8 *pSource = seq.getConstArray();
     176       42359 :     bool bCheckIfFirstClosingBracketExsists = false;
     177             : 
     178       42359 :     if( seq.getLength() < 8 ) {
     179             :         // no recognition possible, when less than 8 bytes are available
     180           1 :         return false;
     181             :     }
     182             : 
     183       42358 :     if( ! strncmp( reinterpret_cast<const char *>(pSource), "<?xml", 4 ) ) {
     184             :         // scan if the <?xml tag finishes within this buffer
     185       42016 :         bCheckIfFirstClosingBracketExsists = true;
     186             :     }
     187         654 :     else if( ('<' == pSource[0] || '<' == pSource[2] ) &&
     188         624 :              ( ('?' == pSource[4] || '?' == pSource[6] ) ) )
     189             :     {
     190             :         // check for utf-16
     191           0 :         bCheckIfFirstClosingBracketExsists = true;
     192             :     }
     193         372 :     else if( ( '<' == pSource[1] || '<' == pSource[3] ) &&
     194          60 :              ( '?' == pSource[5] || '?' == pSource[7] ) )
     195             :     {
     196             :         // check for
     197           0 :         bCheckIfFirstClosingBracketExsists = true;
     198             :     }
     199             : 
     200       42358 :     if( bCheckIfFirstClosingBracketExsists )
     201             :     {
     202     2136853 :         for( sal_Int32 i = 0; i < seq.getLength() ; i ++ )
     203             :         {
     204             :             // whole <?xml tag is valid
     205     2136851 :             if( '>' == pSource[ i ] )
     206             :             {
     207       42014 :                 return true;
     208             :             }
     209             :         }
     210           2 :         return false;
     211             :     }
     212             : 
     213             :     // No <? tag in front, no need for a bigger buffer
     214         342 :     return true;
     215             : }
     216             : 
     217       42356 : bool XMLFile2UTFConverter::scanForEncoding( Sequence< sal_Int8 > &seq )
     218             : {
     219       42356 :     const sal_uInt8 *pSource = reinterpret_cast<const sal_uInt8*>( seq.getConstArray() );
     220       42356 :     bool bReturn = true;
     221             : 
     222       42356 :     if( seq.getLength() < 4 ) {
     223             :         // no recognition possible, when less than 4 bytes are available
     224           0 :         return false;
     225             :     }
     226             : 
     227             :     // first level : detect possible file formats
     228       42356 :     if( ! strncmp( reinterpret_cast<const char *>(pSource), "<?xml", 4 ) ) {
     229             : 
     230             :         // scan for encoding
     231       42014 :         OString str( reinterpret_cast<const char *>(pSource), seq.getLength() );
     232             : 
     233             :         // cut sequence to first line break
     234             :         //find first line break;
     235       42014 :         int nMax = str.indexOf( 10 );
     236       42014 :         if( nMax >= 0 )
     237             :         {
     238       41957 :             str = str.copy( 0 , nMax );
     239             :         }
     240             : 
     241       42014 :         int nFound = str.indexOf( " encoding" );
     242       42014 :         if( nFound >= 0 ) {
     243             :             int nStop;
     244       41997 :             int nStart = str.indexOf( "\"" , nFound );
     245       41997 :             if( nStart < 0 || str.indexOf( "'" , nFound ) < nStart )
     246             :             {
     247       41996 :                 nStart = str.indexOf( "'" , nFound );
     248       41996 :                 nStop  = str.indexOf( "'" , nStart +1 );
     249             :             }
     250             :             else
     251             :             {
     252           1 :                 nStop  = str.indexOf( "\"" , nStart +1);
     253             :             }
     254       41997 :             if( nStart >= 0 && nStop >= 0 && nStart+1 < nStop )
     255             :             {
     256             :                 // encoding found finally
     257           1 :                 m_sEncoding = str.copy( nStart+1 , nStop - nStart - 1 );
     258             :             }
     259       42014 :         }
     260             :     }
     261         342 :     else if( 0xFE == pSource[0] &&
     262           0 :              0xFF == pSource[1] ) {
     263             :         // UTF-16 big endian
     264             :         // conversion is done so that encoding information can be easily extracted
     265           0 :         m_sEncoding = "utf-16";
     266             :     }
     267         342 :     else if( 0xFF == pSource[0] &&
     268           0 :              0xFE == pSource[1] ) {
     269             :         // UTF-16 little endian
     270             :         // conversion is done so that encoding information can be easily extracted
     271           0 :         m_sEncoding = "utf-16";
     272             :     }
     273         342 :     else if( 0x00 == pSource[0] && 0x3c == pSource[1]  && 0x00 == pSource[2] && 0x3f == pSource[3] ) {
     274             :         // UTF-16 big endian without byte order mark (this is (strictly speaking) an error.)
     275             :         // The byte order mark is simply added
     276             : 
     277             :         // simply add the byte order mark !
     278           0 :         seq.realloc( seq.getLength() + 2 );
     279           0 :         memmove( &( seq.getArray()[2] ) , seq.getArray() , seq.getLength() - 2 );
     280           0 :         reinterpret_cast<sal_uInt8*>(seq.getArray())[0] = 0xFE;
     281           0 :         reinterpret_cast<sal_uInt8*>(seq.getArray())[1] = 0xFF;
     282             : 
     283           0 :         m_sEncoding = "utf-16";
     284             :     }
     285         342 :     else if( 0x3c == pSource[0] && 0x00 == pSource[1]  && 0x3f == pSource[2] && 0x00 == pSource[3] ) {
     286             :         // UTF-16 little endian without byte order mark (this is (strictly speaking) an error.)
     287             :         // The byte order mark is simply added
     288             : 
     289           0 :         seq.realloc( seq.getLength() + 2 );
     290           0 :         memmove( &( seq.getArray()[2] ) , seq.getArray() , seq.getLength() - 2 );
     291           0 :         reinterpret_cast<sal_uInt8*>(seq.getArray())[0] = 0xFF;
     292           0 :         reinterpret_cast<sal_uInt8*>(seq.getArray())[1] = 0xFE;
     293             : 
     294           0 :         m_sEncoding = "utf-16";
     295             :     }
     296         372 :     else if( 0xEF == pSource[0] &&
     297          60 :              0xBB == pSource[1] &&
     298          30 :              0xBF == pSource[2] )
     299             :     {
     300             :         // UTF-8 BOM (byte order mark); signifies utf-8, and not byte order
     301             :         // The BOM is removed.
     302          30 :         memmove( seq.getArray(), &( seq.getArray()[3] ), seq.getLength()-3 );
     303          30 :         seq.realloc( seq.getLength() - 3 );
     304          30 :         m_sEncoding = "utf-8";
     305             :     }
     306         312 :     else if( 0x00 == pSource[0] && 0x00 == pSource[1]  && 0x00 == pSource[2] && 0x3c == pSource[3] ) {
     307             :         // UCS-4 big endian
     308           0 :         m_sEncoding = "ucs-4";
     309             :     }
     310         312 :     else if( 0x3c == pSource[0] && 0x00 == pSource[1]  && 0x00 == pSource[2] && 0x00 == pSource[3] ) {
     311             :         // UCS-4 little endian
     312           0 :         m_sEncoding = "ucs-4";
     313             :     }
     314             : /* TODO: no need to test for the moment since we return sal_False like default case anyway
     315             :     else if( 0x4c == pSource[0] && 0x6f == pSource[1]  &&
     316             :              0xa7 == static_cast<unsigned char> (pSource[2]) &&
     317             :              0x94 == static_cast<unsigned char> (pSource[3]) ) {
     318             :         // EBCDIC
     319             :         bReturn = sal_False;   // must be extended
     320             :     }
     321             : */
     322             :     else {
     323             :         // other
     324             :         // UTF8 is directly recognized by the parser.
     325         312 :         bReturn = false;
     326             :     }
     327             : 
     328       42356 :     return bReturn;
     329             : }
     330             : 
     331       42044 : void XMLFile2UTFConverter::initializeDecoding()
     332             : {
     333             : 
     334       42044 :     if( !m_sEncoding.isEmpty() )
     335             :     {
     336          31 :         rtl_TextEncoding encoding = rtl_getTextEncodingFromMimeCharset( m_sEncoding.getStr() );
     337          31 :         if( encoding != RTL_TEXTENCODING_UTF8 )
     338             :         {
     339           0 :             m_pText2Unicode = new Text2UnicodeConverter( m_sEncoding );
     340           0 :             m_pUnicode2Text = new Unicode2TextConverter( RTL_TEXTENCODING_UTF8 );
     341             :         }
     342             :     }
     343       42044 : }
     344             : 
     345             : 
     346             : 
     347             : 
     348             : // Text2UnicodeConverter
     349             : 
     350             : 
     351           0 : Text2UnicodeConverter::Text2UnicodeConverter( const OString &sEncoding )
     352             :     : m_convText2Unicode(NULL)
     353             :     , m_contextText2Unicode(NULL)
     354           0 :     , m_rtlEncoding(RTL_TEXTENCODING_DONTKNOW)
     355             : {
     356           0 :     rtl_TextEncoding encoding = rtl_getTextEncodingFromMimeCharset( sEncoding.getStr() );
     357           0 :     if( RTL_TEXTENCODING_DONTKNOW == encoding )
     358             :     {
     359           0 :         m_bCanContinue = false;
     360           0 :         m_bInitialized = false;
     361             :     }
     362             :     else
     363             :     {
     364           0 :         init( encoding );
     365             :     }
     366           0 : }
     367             : 
     368           0 : Text2UnicodeConverter::~Text2UnicodeConverter()
     369             : {
     370           0 :     if( m_bInitialized )
     371             :     {
     372           0 :         rtl_destroyTextToUnicodeContext( m_convText2Unicode , m_contextText2Unicode );
     373           0 :         rtl_destroyUnicodeToTextConverter( m_convText2Unicode );
     374             :     }
     375           0 : }
     376             : 
     377           0 : void Text2UnicodeConverter::init( rtl_TextEncoding encoding )
     378             : {
     379           0 :     m_bCanContinue = true;
     380           0 :     m_bInitialized = true;
     381             : 
     382           0 :     m_convText2Unicode  = rtl_createTextToUnicodeConverter(encoding);
     383           0 :     m_contextText2Unicode = rtl_createTextToUnicodeContext( m_convText2Unicode );
     384           0 :     m_rtlEncoding = encoding;
     385           0 : }
     386             : 
     387             : 
     388           0 : Sequence<sal_Unicode> Text2UnicodeConverter::convert( const Sequence<sal_Int8> &seqText )
     389             : {
     390             :     sal_uInt32 uiInfo;
     391           0 :     sal_Size nSrcCvtBytes   = 0;
     392           0 :     sal_Size nTargetCount   = 0;
     393           0 :     sal_Size nSourceCount   = 0;
     394             : 
     395             :     // the whole source size
     396           0 :     sal_Int32   nSourceSize = seqText.getLength() + m_seqSource.getLength();
     397           0 :     Sequence<sal_Unicode>   seqUnicode ( nSourceSize );
     398             : 
     399           0 :     const sal_Int8 *pbSource = seqText.getConstArray();
     400           0 :     boost::scoped_array<sal_Int8> pbTempMem;
     401             : 
     402           0 :     if( m_seqSource.getLength() ) {
     403             :         // put old rest and new byte sequence into one array
     404           0 :         pbTempMem.reset(new sal_Int8[ nSourceSize ]);
     405           0 :         memcpy( pbTempMem.get() , m_seqSource.getConstArray() , m_seqSource.getLength() );
     406           0 :         memcpy( &(pbTempMem[ m_seqSource.getLength() ]) , seqText.getConstArray() , seqText.getLength() );
     407           0 :         pbSource = pbTempMem.get();
     408             : 
     409             :         // set to zero again
     410           0 :         m_seqSource = Sequence< sal_Int8 >();
     411             :     }
     412             : 
     413             :     while( true ) {
     414             : 
     415             :         /* All invalid characters are transformed to the unicode undefined char */
     416             :         nTargetCount +=     rtl_convertTextToUnicode(
     417             :                                     m_convText2Unicode,
     418             :                                     m_contextText2Unicode,
     419             :                                     reinterpret_cast<const char *>(&( pbSource[nSourceCount] )),
     420             :                                     nSourceSize - nSourceCount ,
     421           0 :                                     &( seqUnicode.getArray()[ nTargetCount ] ),
     422           0 :                                     seqUnicode.getLength() - nTargetCount,
     423             :                                     RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT   |
     424             :                                     RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
     425             :                                     RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT,
     426             :                                     &uiInfo,
     427           0 :                                     &nSrcCvtBytes );
     428           0 :         nSourceCount += nSrcCvtBytes;
     429             : 
     430           0 :         if( uiInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL ) {
     431             :             // save necessary bytes for next conversion
     432           0 :             seqUnicode.realloc( seqUnicode.getLength() * 2 );
     433           0 :             continue;
     434             :         }
     435           0 :         break;
     436             :     }
     437           0 :     if( uiInfo & RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL ) {
     438           0 :         m_seqSource.realloc( nSourceSize - nSourceCount );
     439           0 :         memcpy( m_seqSource.getArray() , &(pbSource[nSourceCount]) , nSourceSize-nSourceCount );
     440             :     }
     441             : 
     442             :     // set to correct unicode size
     443           0 :     seqUnicode.realloc( nTargetCount );
     444             : 
     445           0 :     return seqUnicode;
     446             : }
     447             : 
     448             : 
     449             : 
     450             : 
     451             : 
     452             : // Unicode2TextConverter
     453             : 
     454             : 
     455           0 : Unicode2TextConverter::Unicode2TextConverter( rtl_TextEncoding encoding )
     456             : {
     457           0 :     init( encoding );
     458           0 : }
     459             : 
     460             : 
     461           0 : Unicode2TextConverter::~Unicode2TextConverter()
     462             : {
     463           0 :     if( m_bInitialized ) {
     464           0 :         rtl_destroyUnicodeToTextContext( m_convUnicode2Text , m_contextUnicode2Text );
     465           0 :         rtl_destroyUnicodeToTextConverter( m_convUnicode2Text );
     466             :     }
     467           0 : }
     468             : 
     469             : 
     470           0 : Sequence<sal_Int8> Unicode2TextConverter::convert(const sal_Unicode *puSource , sal_Int32 nSourceSize)
     471             : {
     472           0 :     boost::scoped_array<sal_Unicode> puTempMem;
     473             : 
     474           0 :     if( m_seqSource.getLength() ) {
     475             :         // For surrogates !
     476             :         // put old rest and new byte sequence into one array
     477             :         // In general when surrogates are used, they should be rarely
     478             :         // cut off between two convert()-calls. So this code is used
     479             :         // rarely and the extra copy is acceptable.
     480           0 :         puTempMem.reset(new sal_Unicode[ nSourceSize + m_seqSource.getLength()]);
     481           0 :         memcpy( puTempMem.get() ,
     482           0 :                 m_seqSource.getConstArray() ,
     483           0 :                 m_seqSource.getLength() * sizeof( sal_Unicode ) );
     484             :         memcpy(
     485           0 :             &(puTempMem[ m_seqSource.getLength() ]) ,
     486             :             puSource ,
     487           0 :             nSourceSize*sizeof( sal_Unicode ) );
     488           0 :         puSource = puTempMem.get();
     489           0 :         nSourceSize += m_seqSource.getLength();
     490             : 
     491           0 :         m_seqSource = Sequence< sal_Unicode > ();
     492             :     }
     493             : 
     494             : 
     495           0 :     sal_Size nTargetCount = 0;
     496           0 :     sal_Size nSourceCount = 0;
     497             : 
     498             :     sal_uInt32 uiInfo;
     499             :     sal_Size nSrcCvtChars;
     500             : 
     501             :     // take nSourceSize * 3 as preference
     502             :     // this is an upper boundary for converting to utf8,
     503             :     // which most often used as the target.
     504           0 :     sal_Int32 nSeqSize =  nSourceSize * 3;
     505             : 
     506           0 :     Sequence<sal_Int8>  seqText( nSeqSize );
     507           0 :     sal_Char *pTarget = reinterpret_cast<char *>(seqText.getArray());
     508             :     while( true ) {
     509             : 
     510             :         nTargetCount += rtl_convertUnicodeToText(
     511             :                                     m_convUnicode2Text,
     512             :                                     m_contextUnicode2Text,
     513             :                                     &( puSource[nSourceCount] ),
     514             :                                     nSourceSize - nSourceCount ,
     515             :                                     &( pTarget[nTargetCount] ),
     516             :                                     nSeqSize - nTargetCount,
     517             :                                     RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
     518             :                                     RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT ,
     519             :                                     &uiInfo,
     520           0 :                                     &nSrcCvtChars);
     521           0 :         nSourceCount += nSrcCvtChars;
     522             : 
     523           0 :         if( uiInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL ) {
     524           0 :             nSeqSize = nSeqSize *2;
     525           0 :             seqText.realloc( nSeqSize );  // double array size
     526           0 :             pTarget = reinterpret_cast<char *>(seqText.getArray());
     527           0 :             continue;
     528             :         }
     529           0 :         break;
     530             :     }
     531             : 
     532             :     // for surrogates
     533           0 :     if( uiInfo & RTL_UNICODETOTEXT_INFO_SRCBUFFERTOSMALL ) {
     534           0 :         m_seqSource.realloc( nSourceSize - nSourceCount );
     535           0 :         memcpy( m_seqSource.getArray() ,
     536           0 :                 &(puSource[nSourceCount]),
     537           0 :                 (nSourceSize - nSourceCount) * sizeof( sal_Unicode ) );
     538             :     }
     539             : 
     540             :     // reduce the size of the buffer (fast, no copy necessary)
     541           0 :     seqText.realloc( nTargetCount );
     542             : 
     543           0 :     return seqText;
     544             : }
     545             : 
     546           0 : void Unicode2TextConverter::init( rtl_TextEncoding encoding )
     547             : {
     548           0 :     m_bCanContinue = true;
     549           0 :     m_bInitialized = true;
     550             : 
     551           0 :     m_convUnicode2Text  = rtl_createUnicodeToTextConverter( encoding );
     552           0 :     m_contextUnicode2Text = rtl_createUnicodeToTextContext( m_convUnicode2Text );
     553           0 :     m_rtlEncoding = encoding;
     554           0 : };
     555             : 
     556             : 
     557             : }
     558             : 
     559             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11