sal/textenc/convertiso2022kr.cxx

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