LCOV - code coverage report
Current view: top level - sal/textenc - convertiso2022kr.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 151 238 63.4 %
Date: 2014-11-03 Functions: 6 8 75.0 %
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             : 
      20             : #include "sal/config.h"
      21             : 
      22             : #include "rtl/textcvt.h"
      23             : #include "sal/types.h"
      24             : 
      25             : #include "context.hxx"
      26             : #include "converter.hxx"
      27             : #include "convertiso2022kr.hxx"
      28             : #include "tenchelp.hxx"
      29             : #include "unichars.hxx"
      30             : 
      31             : namespace {
      32             : 
      33             : enum ImplIso2022KrToUnicodeState // order is important:
      34             : {
      35             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII,
      36             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001,
      37             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001_2,
      38             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC,
      39             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR,
      40             :     IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR_RPAREN
      41             : };
      42             : 
      43             : struct ImplIso2022KrToUnicodeContext
      44             : {
      45             :     ImplIso2022KrToUnicodeState m_eState;
      46             :     sal_uInt32 m_nRow;
      47             : };
      48             : 
      49             : enum ImplUnicodeToIso2022KrSet
      50             : {
      51             :     IMPL_UNICODE_TO_ISO_2022_KR_SET_NONE,
      52             :     IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII,
      53             :     IMPL_UNICODE_TO_ISO_2022_KR_SET_1001
      54             : };
      55             : 
      56             : struct ImplUnicodeToIso2022KrContext
      57             : {
      58             :     sal_Unicode m_nHighSurrogate;
      59             :     ImplUnicodeToIso2022KrSet m_eSet;
      60             : };
      61             : 
      62             : }
      63             : 
      64           8 : void * ImplCreateIso2022KrToUnicodeContext()
      65             : {
      66             :     ImplIso2022KrToUnicodeContext * pContext =
      67           8 :         new ImplIso2022KrToUnicodeContext;
      68           8 :     pContext->m_eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
      69           8 :     return pContext;
      70             : }
      71             : 
      72           0 : void ImplResetIso2022KrToUnicodeContext(void * pContext)
      73             : {
      74           0 :     if (pContext)
      75             :         static_cast< ImplIso2022KrToUnicodeContext * >(pContext)->m_eState
      76           0 :             = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
      77           0 : }
      78             : 
      79           8 : void ImplDestroyIso2022KrToUnicodeContext(void * pContext)
      80             : {
      81           8 :     delete static_cast< ImplIso2022KrToUnicodeContext * >(pContext);
      82           8 : }
      83             : 
      84          62 : sal_Size ImplConvertIso2022KrToUnicode(void const * pData,
      85             :                                        void * pContext,
      86             :                                        char const * pSrcBuf,
      87             :                                        sal_Size nSrcBytes,
      88             :                                        sal_Unicode * pDestBuf,
      89             :                                        sal_Size nDestChars,
      90             :                                        sal_uInt32 nFlags,
      91             :                                        sal_uInt32 * pInfo,
      92             :                                        sal_Size * pSrcCvtBytes)
      93             : {
      94             :     ImplDBCSToUniLeadTab const * pKsX1001Data
      95             :         = static_cast< ImplIso2022KrConverterData const * >(pData)->
      96          62 :               m_pKsX1001ToUnicodeData;
      97             :     ImplIso2022KrToUnicodeState eState
      98          62 :         = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
      99          62 :     sal_uInt32 nRow = 0;
     100          62 :     sal_uInt32 nInfo = 0;
     101          62 :     sal_Size nConverted = 0;
     102          62 :     sal_Unicode * pDestBufPtr = pDestBuf;
     103          62 :     sal_Unicode * pDestBufEnd = pDestBuf + nDestChars;
     104             : 
     105          62 :     if (pContext)
     106             :     {
     107          62 :         eState = static_cast< ImplIso2022KrToUnicodeContext * >(pContext)->m_eState;
     108          62 :         nRow = static_cast< ImplIso2022KrToUnicodeContext * >(pContext)->m_nRow;
     109             :     }
     110             : 
     111         170 :     for (; nConverted < nSrcBytes; ++nConverted)
     112             :     {
     113         108 :         bool bUndefined = true;
     114         108 :         sal_uInt32 nChar = *(unsigned char const *) pSrcBuf++;
     115         108 :         switch (eState)
     116             :         {
     117             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII:
     118          60 :             if (nChar == 0x0E) // SO
     119           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001;
     120          52 :             else if (nChar == 0x1B) // ESC
     121           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC;
     122          44 :             else if (nChar < 0x80)
     123          44 :                 if (pDestBufPtr != pDestBufEnd)
     124          44 :                     *pDestBufPtr++ = (sal_Unicode) nChar;
     125             :                 else
     126           0 :                     goto no_output;
     127             :             else
     128             :             {
     129           0 :                 bUndefined = false;
     130           0 :                 goto bad_input;
     131             :             }
     132          60 :             break;
     133             : 
     134             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001:
     135          16 :             if (nChar == 0x0F) // SI
     136           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
     137           8 :             else if (nChar >= 0x21 && nChar <= 0x7E)
     138             :             {
     139           8 :                 nRow = nChar + 0x80;
     140           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001_2;
     141             :             }
     142             :             else
     143             :             {
     144           0 :                 bUndefined = false;
     145           0 :                 goto bad_input;
     146             :             }
     147          16 :             break;
     148             : 
     149             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001_2:
     150           8 :             if (nChar >= 0x21 && nChar <= 0x7E)
     151             :             {
     152           8 :                 sal_uInt16 nUnicode = 0;
     153           8 :                 sal_uInt32 nFirst = pKsX1001Data[nRow].mnTrailStart;
     154           8 :                 nChar += 0x80;
     155           8 :                 if (nChar >= nFirst && nChar <= pKsX1001Data[nRow].mnTrailEnd)
     156           8 :                     nUnicode = pKsX1001Data[nRow].
     157           8 :                                    mpToUniTrailTab[nChar - nFirst];
     158           8 :                 if (nUnicode != 0)
     159           8 :                     if (pDestBufPtr != pDestBufEnd)
     160             :                     {
     161           8 :                         *pDestBufPtr++ = (sal_Unicode) nUnicode;
     162           8 :                         eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001;
     163             :                     }
     164             :                     else
     165           0 :                         goto no_output;
     166             :                 else
     167           0 :                     goto bad_input;
     168             :             }
     169             :             else
     170             :             {
     171           0 :                 bUndefined = false;
     172           0 :                 goto bad_input;
     173             :             }
     174           8 :             break;
     175             : 
     176             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC:
     177           8 :             if (nChar == 0x24) // $
     178           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR;
     179             :             else
     180             :             {
     181           0 :                 bUndefined = false;
     182           0 :                 goto bad_input;
     183             :             }
     184           8 :             break;
     185             : 
     186             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR:
     187           8 :             if (nChar == 0x29) // )
     188           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR_RPAREN;
     189             :             else
     190             :             {
     191           0 :                 bUndefined = false;
     192           0 :                 goto bad_input;
     193             :             }
     194           8 :             break;
     195             : 
     196             :         case IMPL_ISO_2022_KR_TO_UNICODE_STATE_ESC_DOLLAR_RPAREN:
     197           8 :             if (nChar == 0x43) // C
     198           8 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
     199             :             else
     200             :             {
     201           0 :                 bUndefined = false;
     202           0 :                 goto bad_input;
     203             :             }
     204           8 :             break;
     205             :         }
     206         108 :         continue;
     207             : 
     208             :     bad_input:
     209           0 :         switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
     210             :                     bUndefined, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
     211           0 :                     &nInfo))
     212             :         {
     213             :         case sal::detail::textenc::BAD_INPUT_STOP:
     214           0 :             eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
     215           0 :             break;
     216             : 
     217             :         case sal::detail::textenc::BAD_INPUT_CONTINUE:
     218           0 :             eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
     219           0 :             continue;
     220             : 
     221             :         case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
     222           0 :             goto no_output;
     223             :         }
     224           0 :         break;
     225             : 
     226             :     no_output:
     227           0 :         --pSrcBuf;
     228           0 :         nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
     229           0 :         break;
     230             :     }
     231             : 
     232          62 :     if (eState > IMPL_ISO_2022_KR_TO_UNICODE_STATE_1001
     233          16 :         && (nInfo & (RTL_TEXTTOUNICODE_INFO_ERROR
     234             :                          | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL))
     235             :                == 0)
     236             :     {
     237          16 :         if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0)
     238          16 :             nInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL;
     239             :         else
     240           0 :             switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
     241             :                         false, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
     242           0 :                         &nInfo))
     243             :             {
     244             :             case sal::detail::textenc::BAD_INPUT_STOP:
     245             :             case sal::detail::textenc::BAD_INPUT_CONTINUE:
     246           0 :                 eState = IMPL_ISO_2022_KR_TO_UNICODE_STATE_ASCII;
     247           0 :                 break;
     248             : 
     249             :             case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
     250           0 :                 nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
     251           0 :                 break;
     252             :             }
     253             :     }
     254             : 
     255          62 :     if (pContext)
     256             :     {
     257          62 :         static_cast< ImplIso2022KrToUnicodeContext * >(pContext)->m_eState = eState;
     258          62 :         static_cast< ImplIso2022KrToUnicodeContext * >(pContext)->m_nRow = nRow;
     259             :     }
     260          62 :     if (pInfo)
     261          62 :         *pInfo = nInfo;
     262          62 :     if (pSrcCvtBytes)
     263          62 :         *pSrcCvtBytes = nConverted;
     264             : 
     265          62 :     return pDestBufPtr - pDestBuf;
     266             : }
     267             : 
     268           4 : void * ImplCreateUnicodeToIso2022KrContext()
     269             : {
     270             :     ImplUnicodeToIso2022KrContext * pContext =
     271           4 :         new ImplUnicodeToIso2022KrContext;
     272           4 :     pContext->m_nHighSurrogate = 0;
     273           4 :     pContext->m_eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_NONE;
     274           4 :     return pContext;
     275             : }
     276             : 
     277           0 : void ImplResetUnicodeToIso2022KrContext(void * pContext)
     278             : {
     279           0 :     if (pContext)
     280             :     {
     281           0 :         static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_nHighSurrogate = 0;
     282             :         static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_eSet
     283           0 :             = IMPL_UNICODE_TO_ISO_2022_KR_SET_NONE;
     284             :     }
     285           0 : }
     286             : 
     287           4 : void ImplDestroyUnicodeToIso2022KrContext(void * pContext)
     288             : {
     289           4 :     delete static_cast< ImplUnicodeToIso2022KrContext * >(pContext);
     290           4 : }
     291             : 
     292           4 : sal_Size ImplConvertUnicodeToIso2022Kr(void const * pData,
     293             :                                        void * pContext,
     294             :                                        sal_Unicode const * pSrcBuf,
     295             :                                        sal_Size nSrcChars,
     296             :                                        char * pDestBuf,
     297             :                                        sal_Size nDestBytes,
     298             :                                        sal_uInt32 nFlags,
     299             :                                        sal_uInt32 * pInfo,
     300             :                                        sal_Size * pSrcCvtChars)
     301             : {
     302             :     ImplUniToDBCSHighTab const * pKsX1001Data
     303             :         = static_cast< ImplIso2022KrConverterData const * >(pData)->
     304           4 :               m_pUnicodeToKsX1001Data;
     305           4 :     sal_Unicode nHighSurrogate = 0;
     306           4 :     ImplUnicodeToIso2022KrSet eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_NONE;
     307           4 :     sal_uInt32 nInfo = 0;
     308           4 :     sal_Size nConverted = 0;
     309           4 :     char * pDestBufPtr = pDestBuf;
     310           4 :     char * pDestBufEnd = pDestBuf + nDestBytes;
     311             :     bool bWritten;
     312             : 
     313           4 :     if (pContext)
     314             :     {
     315             :         nHighSurrogate
     316           4 :             = static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_nHighSurrogate;
     317           4 :         eSet = static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_eSet;
     318             :     }
     319             : 
     320           4 :     if (eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_NONE)
     321             :     {
     322           4 :         if (pDestBufEnd - pDestBufPtr >= 4)
     323             :         {
     324           4 :             *pDestBufPtr++ = 0x1B; // ESC
     325           4 :             *pDestBufPtr++ = 0x24; // $
     326           4 :             *pDestBufPtr++ = 0x29; // )
     327           4 :             *pDestBufPtr++ = 0x43; // C
     328           4 :             eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     329             :         }
     330             :         else
     331           0 :             nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
     332             :     }
     333             : 
     334           4 :     if ((nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL) == 0)
     335          30 :         for (; nConverted < nSrcChars; ++nConverted)
     336             :         {
     337          26 :             bool bUndefined = true;
     338          26 :             sal_uInt32 nChar = *pSrcBuf++;
     339          26 :             if (nHighSurrogate == 0)
     340             :             {
     341          26 :                 if (ImplIsHighSurrogate(nChar))
     342             :                 {
     343           0 :                     nHighSurrogate = (sal_Unicode) nChar;
     344           0 :                     continue;
     345             :                 }
     346             :             }
     347           0 :             else if (ImplIsLowSurrogate(nChar))
     348           0 :                 nChar = ImplCombineSurrogates(nHighSurrogate, nChar);
     349             :             else
     350             :             {
     351           0 :                 bUndefined = false;
     352           0 :                 goto bad_input;
     353             :             }
     354             : 
     355          26 :             if (ImplIsLowSurrogate(nChar) || ImplIsNoncharacter(nChar))
     356             :             {
     357           0 :                 bUndefined = false;
     358           0 :                 goto bad_input;
     359             :             }
     360             : 
     361          26 :             if (nChar == 0x0A || nChar == 0x0D) // LF, CR
     362             :             {
     363           4 :                 if (eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_1001)
     364             :                 {
     365           2 :                     if (pDestBufPtr != pDestBufEnd)
     366             :                     {
     367           2 :                         *pDestBufPtr++ = 0x0F; // SI
     368           2 :                         eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     369             :                     }
     370             :                     else
     371           0 :                         goto no_output;
     372             :                 }
     373           8 :                 if (pDestBufPtr != pDestBufEnd)
     374           4 :                     *pDestBufPtr++ = static_cast< char >(nChar);
     375             :                 else
     376           0 :                     goto no_output;
     377             :             }
     378          22 :             else if (nChar == 0x0E || nChar == 0x0F || nChar == 0x1B)
     379             :                 goto bad_input;
     380          22 :             else if (nChar < 0x80)
     381             :             {
     382          18 :                 if (eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_1001)
     383             :                 {
     384           0 :                     if (pDestBufPtr != pDestBufEnd)
     385             :                     {
     386           0 :                         *pDestBufPtr++ = 0x0F; // SI
     387           0 :                         eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     388             :                     }
     389             :                     else
     390           0 :                         goto no_output;
     391             :                 }
     392          18 :                 if (pDestBufPtr != pDestBufEnd)
     393          18 :                     *pDestBufPtr++ = static_cast< char >(nChar);
     394             :                 else
     395           0 :                     goto no_output;
     396             :             }
     397             :             else
     398             :             {
     399           4 :                 sal_uInt16 nBytes = 0;
     400           4 :                 sal_uInt32 nIndex1 = nChar >> 8;
     401           4 :                 if (nIndex1 < 0x100)
     402             :                 {
     403           4 :                     sal_uInt32 nIndex2 = nChar & 0xFF;
     404           4 :                     sal_uInt32 nFirst = pKsX1001Data[nIndex1].mnLowStart;
     405           4 :                     if (nIndex2 >= nFirst
     406           4 :                         && nIndex2 <= pKsX1001Data[nIndex1].mnLowEnd)
     407           4 :                         nBytes = pKsX1001Data[nIndex1].
     408           4 :                                      mpToUniTrailTab[nIndex2 - nFirst];
     409             :                 }
     410           4 :                 if (nBytes != 0)
     411             :                 {
     412           4 :                     if (eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII)
     413             :                     {
     414           4 :                         if (pDestBufPtr != pDestBufEnd)
     415             :                         {
     416           4 :                             *pDestBufPtr++ = 0x0E; // SO
     417           4 :                             eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_1001;
     418             :                         }
     419             :                         else
     420           0 :                             goto no_output;
     421             :                     }
     422           4 :                     if (pDestBufEnd - pDestBufPtr >= 2)
     423             :                     {
     424           4 :                         *pDestBufPtr++ = static_cast< char >((nBytes >> 8) & 0x7F);
     425           4 :                         *pDestBufPtr++ = static_cast< char >(nBytes & 0x7F);
     426             :                     }
     427             :                     else
     428           0 :                         goto no_output;
     429             :                 }
     430             :                 else
     431           0 :                     goto bad_input;
     432             :             }
     433          26 :             nHighSurrogate = 0;
     434          26 :             continue;
     435             : 
     436             :         bad_input:
     437           0 :             switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
     438             :                         bUndefined, nChar, nFlags, &pDestBufPtr, pDestBufEnd,
     439             :                         &nInfo, "\x0F" /* SI */,
     440             :                         eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII ? 0 : 1,
     441           0 :                         &bWritten))
     442             :             {
     443             :             case sal::detail::textenc::BAD_INPUT_STOP:
     444           0 :                 nHighSurrogate = 0;
     445           0 :                 break;
     446             : 
     447             :             case sal::detail::textenc::BAD_INPUT_CONTINUE:
     448           0 :                 if (bWritten)
     449           0 :                     eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     450           0 :                 nHighSurrogate = 0;
     451           0 :                 continue;
     452             : 
     453             :             case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
     454           0 :                 goto no_output;
     455             :             }
     456           0 :             break;
     457             : 
     458             :         no_output:
     459           0 :             --pSrcBuf;
     460           0 :             nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
     461           0 :             break;
     462             :         }
     463             : 
     464           4 :     if ((nInfo & (RTL_UNICODETOTEXT_INFO_ERROR
     465             :                       | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL))
     466             :             == 0)
     467             :     {
     468           4 :         bool bFlush = true;
     469           4 :         if (nHighSurrogate != 0)
     470             :         {
     471           0 :             if ((nFlags & RTL_UNICODETOTEXT_FLAGS_FLUSH) != 0)
     472           0 :                 nInfo |= RTL_UNICODETOTEXT_INFO_SRCBUFFERTOSMALL;
     473             :             else
     474           0 :                 switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
     475             :                             false, 0, nFlags, &pDestBufPtr, pDestBufEnd, &nInfo,
     476             :                             "\x0F" /* SI */,
     477             :                             (eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII
     478             :                              ? 0 : 1),
     479           0 :                             &bWritten))
     480             :                 {
     481             :                 case sal::detail::textenc::BAD_INPUT_STOP:
     482           0 :                     nHighSurrogate = 0;
     483           0 :                     bFlush = false;
     484           0 :                     break;
     485             : 
     486             :                 case sal::detail::textenc::BAD_INPUT_CONTINUE:
     487           0 :                     if (bWritten)
     488           0 :                         eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     489           0 :                     nHighSurrogate = 0;
     490           0 :                     break;
     491             : 
     492             :                 case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
     493           0 :                     nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
     494           0 :                     break;
     495             :                 }
     496             :         }
     497           4 :         if (bFlush
     498           4 :             && eSet == IMPL_UNICODE_TO_ISO_2022_KR_SET_1001
     499           2 :             && (nFlags & RTL_UNICODETOTEXT_FLAGS_FLUSH) != 0)
     500             :         {
     501           2 :             if (pDestBufPtr != pDestBufEnd)
     502             :             {
     503           2 :                 *pDestBufPtr++ = 0x0F; // SI
     504           2 :                 eSet = IMPL_UNICODE_TO_ISO_2022_KR_SET_ASCII;
     505             :             }
     506             :             else
     507           0 :                 nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
     508             :         }
     509             :     }
     510             : 
     511           4 :     if (pContext)
     512             :     {
     513             :         static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_nHighSurrogate
     514           4 :             = nHighSurrogate;
     515           4 :         static_cast< ImplUnicodeToIso2022KrContext * >(pContext)->m_eSet = eSet;
     516             :     }
     517           4 :     if (pInfo)
     518           4 :         *pInfo = nInfo;
     519           4 :     if (pSrcCvtChars)
     520           4 :         *pSrcCvtChars = nConverted;
     521             : 
     522           4 :     return pDestBufPtr - pDestBuf;
     523             : }
     524             : 
     525             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10