sal/textenc/convertiso2022kr.cxx

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