sal/textenc/convertgb18030.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 <cassert>
  23
  24 #include <rtl/character.hxx>
  25 #include <rtl/textcvt.h>
  26 #include <sal/types.h>
  27
  28 #include "context.hxx"
  29 #include "converter.hxx"
  30 #include "convertgb18030.hxx"
  31 #include "tenchelp.hxx"
  32 #include "unichars.hxx"
  33
  34 namespace {
  35
  36 enum ImplGb18030ToUnicodeState
  37 {
  38     IMPL_GB_18030_TO_UNICODE_STATE_0,
  39     IMPL_GB_18030_TO_UNICODE_STATE_1,
  40     IMPL_GB_18030_TO_UNICODE_STATE_2,
  41     IMPL_GB_18030_TO_UNICODE_STATE_3
  42 };
  43
  44 struct ImplGb18030ToUnicodeContext
  45 {
  46     ImplGb18030ToUnicodeState m_eState;
  47     sal_uInt32 m_nCode;
  48 };
  49
  50 }
  51
  52 void * ImplCreateGb18030ToUnicodeContext()
  53 {
  54     ImplGb18030ToUnicodeContext * pContext = new ImplGb18030ToUnicodeContext;
  55     pContext->m_eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
  56     return pContext;
  57 }
  58
  59 void ImplResetGb18030ToUnicodeContext(void * pContext)
  60 {
  61     if (pContext)
  62         static_cast< ImplGb18030ToUnicodeContext * >(pContext)->m_eState
  63             = IMPL_GB_18030_TO_UNICODE_STATE_0;
  64 }
  65
  66 void ImplDestroyGb18030ToUnicodeContext(void * pContext)
  67 {
  68     delete static_cast< ImplGb18030ToUnicodeContext * >(pContext);
  69 }
  70
  71 sal_Size ImplConvertGb18030ToUnicode(void const * pData,
  72                                      void * pContext,
  73                                      char const * pSrcBuf,
  74                                      sal_Size nSrcBytes,
  75                                      sal_Unicode * pDestBuf,
  76                                      sal_Size nDestChars,
  77                                      sal_uInt32 nFlags,
  78                                      sal_uInt32 * pInfo,
  79                                      sal_Size * pSrcCvtBytes)
  80 {
  81     sal_Unicode const * pGb18030Data
  82         = static_cast< ImplGb18030ConverterData const * >(pData)->m_pGb18030ToUnicodeData;
  83     ImplGb180302000ToUnicodeRange const * pGb18030Ranges
  84         = static_cast< ImplGb18030ConverterData const * >(pData)->
  85               m_pGb18030ToUnicodeRanges;
  86     ImplGb18030ToUnicodeState eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
  87     sal_uInt32 nCode = 0;
  88     sal_uInt32 nInfo = 0;
  89     sal_Size nConverted = 0;
  90     sal_Unicode * pDestBufPtr = pDestBuf;
  91     sal_Unicode * pDestBufEnd = pDestBuf + nDestChars;
  92     sal_Size startOfCurrentChar = 0;
  93
  94     if (pContext)
  95     {
  96         eState = static_cast< ImplGb18030ToUnicodeContext * >(pContext)->m_eState;
  97         nCode = static_cast< ImplGb18030ToUnicodeContext * >(pContext)->m_nCode;
  98     }
  99
 100     for (; nConverted < nSrcBytes; ++nConverted)
 101     {
 102         bool bUndefined = true;
 103         sal_uInt32 nChar = *reinterpret_cast<unsigned char const *>(pSrcBuf++);
 104         switch (eState)
 105         {
 106         case IMPL_GB_18030_TO_UNICODE_STATE_0:
 107             if (nChar < 0x80)
 108                 if (pDestBufPtr != pDestBufEnd) {
 109                     *pDestBufPtr++ = static_cast<sal_Unicode>(nChar);
 110                     startOfCurrentChar = nConverted + 1;
 111                 } else
 112                     goto no_output;
 113             else if (nChar == 0x80)
 114                 goto bad_input;
 115             else if (nChar <= 0xFE)
 116             {
 117                 nCode = nChar - 0x81;
 118                 eState = IMPL_GB_18030_TO_UNICODE_STATE_1;
 119             }
 120             else
 121             {
 122                 bUndefined = false;
 123                 goto bad_input;
 124             }
 125             break;
 126
 127         case IMPL_GB_18030_TO_UNICODE_STATE_1:
 128             if (nChar >= 0x30 && nChar <= 0x39)
 129             {
 130                 nCode = nCode * 10 + (nChar - 0x30);
 131                 eState = IMPL_GB_18030_TO_UNICODE_STATE_2;
 132             }
 133             else if ((nChar >= 0x40 && nChar <= 0x7E)
 134                      || (nChar >= 0x80 && nChar <= 0xFE))
 135             {
 136                 nCode = nCode * 190 + (nChar <= 0x7E ? nChar - 0x40 :
 137                                                        nChar - 0x80 + 63);
 138                 if (pDestBufPtr != pDestBufEnd) {
 139                     *pDestBufPtr++ = pGb18030Data[nCode];
 140                     startOfCurrentChar = nConverted + 1;
 141                 } else
 142                     goto no_output;
 143                 eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
 144             }
 145             else
 146             {
 147                 bUndefined = false;
 148                 goto bad_input;
 149             }
 150             break;
 151
 152         case IMPL_GB_18030_TO_UNICODE_STATE_2:
 153             if (nChar >= 0x81 && nChar <= 0xFE)
 154             {
 155                 nCode = nCode * 126 + (nChar - 0x81);
 156                 eState = IMPL_GB_18030_TO_UNICODE_STATE_3;
 157             }
 158             else
 159             {
 160                 bUndefined = false;
 161                 goto bad_input;
 162             }
 163             break;
 164
 165         case IMPL_GB_18030_TO_UNICODE_STATE_3:
 166             if (nChar >= 0x30 && nChar <= 0x39)
 167             {
 168                 nCode = nCode * 10 + (nChar - 0x30);
 169
 170                 // 90 30 81 30 to E3 32 9A 35 maps to U+10000 to U+10FFFF:
 171                 if (nCode >= 189000 && nCode <= 1237575)
 172                     if (pDestBufEnd - pDestBufPtr >= 2)
 173                     {
 174                         nCode -= 189000 - 0x10000;
 175                         pDestBufPtr += rtl::splitSurrogates(nCode, pDestBufPtr);
 176                         startOfCurrentChar = nConverted + 1;
 177                     }
 178                     else
 179                         goto no_output;
 180                 else
 181                 {
 182                     ImplGb180302000ToUnicodeRange const * pRange
 183                         = pGb18030Ranges;
 184                     sal_uInt32 nFirstNonRange = 0;
 185                     for (;;)
 186                     {
 187                         if (pRange->m_nNonRangeDataIndex == -1)
 188                             goto bad_input;
 189                         else if (nCode < pRange->m_nFirstLinear)
 190                         {
 191                             if (pDestBufPtr != pDestBufEnd) {
 192                                 *pDestBufPtr++
 193                                     = pGb18030Data[
 194                                           pRange->m_nNonRangeDataIndex
 195                                               + (nCode - nFirstNonRange)];
 196                                 startOfCurrentChar = nConverted + 1;
 197                             } else
 198                                 goto no_output;
 199                             break;
 200                         }
 201                         else if (nCode < pRange->m_nPastLinear)
 202                         {
 203                             if (pDestBufPtr != pDestBufEnd) {
 204                                 *pDestBufPtr++
 205                                     = static_cast<sal_Unicode>(pRange->m_nFirstUnicode
 206                                                + (nCode
 207                                                       - pRange->
 208                                                             m_nFirstLinear));
 209                                 startOfCurrentChar = nConverted + 1;
 210                             } else
 211                                 goto no_output;
 212                             break;
 213                         }
 214                         nFirstNonRange = (pRange++)->m_nPastLinear;
 215                     }
 216                 }
 217                 eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
 218             }
 219             else
 220             {
 221                 bUndefined = false;
 222                 goto bad_input;
 223             }
 224             break;
 225         }
 226         continue;
 227
 228     bad_input:
 229         switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
 230                     bUndefined, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
 231                     &nInfo))
 232         {
 233         case sal::detail::textenc::BAD_INPUT_STOP:
 234             eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
 235             if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
 236                 ++nConverted;
 237             } else {
 238                 nConverted = startOfCurrentChar;
 239             }
 240             break;
 241
 242         case sal::detail::textenc::BAD_INPUT_CONTINUE:
 243             eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
 244             startOfCurrentChar = nConverted + 1;
 245             continue;
 246
 247         case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
 248             goto no_output;
 249         }
 250         break;
 251
 252     no_output:
 253         --pSrcBuf;
 254         nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
 255         break;
 256     }
 257
 258     if (eState != IMPL_GB_18030_TO_UNICODE_STATE_0
 259         && (nInfo & (RTL_TEXTTOUNICODE_INFO_ERROR
 260                          | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL))
 261                == 0)
 262     {
 263         if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0)
 264             nInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
 265         else
 266             switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
 267                         false, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
 268                         &nInfo))
 269             {
 270             case sal::detail::textenc::BAD_INPUT_STOP:
 271                 if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) != 0) {
 272                     nConverted = startOfCurrentChar;
 273                 }
 274                 [[fallthrough]];
 275             case sal::detail::textenc::BAD_INPUT_CONTINUE:
 276                 eState = IMPL_GB_18030_TO_UNICODE_STATE_0;
 277                 break;
 278
 279             case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
 280                 nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
 281                 break;
 282             }
 283     }
 284
 285     if (pContext)
 286     {
 287         static_cast< ImplGb18030ToUnicodeContext * >(pContext)->m_eState = eState;
 288         static_cast< ImplGb18030ToUnicodeContext * >(pContext)->m_nCode = nCode;
 289     }
 290     if (pInfo)
 291         *pInfo = nInfo;
 292     if (pSrcCvtBytes)
 293         *pSrcCvtBytes = nConverted;
 294
 295     return pDestBufPtr - pDestBuf;
 296 }
 297
 298 sal_Size ImplConvertUnicodeToGb18030(void const * pData,
 299                                      void * pContext,
 300                                      sal_Unicode const * pSrcBuf,
 301                                      sal_Size nSrcChars,
 302                                      char * pDestBuf,
 303                                      sal_Size nDestBytes,
 304                                      sal_uInt32 nFlags,
 305                                      sal_uInt32 * pInfo,
 306                                      sal_Size * pSrcCvtChars)
 307 {
 308     sal_uInt32 const * pGb18030Data
 309         = static_cast< ImplGb18030ConverterData const * >(pData)->
 310               m_pUnicodeToGb18030Data;
 311     ImplUnicodeToGb180302000Range const * pGb18030Ranges
 312         = static_cast< ImplGb18030ConverterData const * >(pData)->
 313               m_pUnicodeToGb18030Ranges;
 314     sal_Unicode nHighSurrogate = 0;
 315     sal_uInt32 nInfo = 0;
 316     sal_Size nConverted = 0;
 317     char * pDestBufPtr = pDestBuf;
 318     char * pDestBufEnd = pDestBuf + nDestBytes;
 319
 320     if (pContext)
 321         nHighSurrogate
 322             = static_cast<ImplUnicodeToTextContext *>(pContext)->m_nHighSurrogate;
 323
 324     for (; nConverted < nSrcChars; ++nConverted)
 325     {
 326         bool bUndefined = true;
 327         sal_uInt32 nChar = *pSrcBuf++;
 328         if (nHighSurrogate == 0)
 329         {
 330             if (rtl::isHighSurrogate(nChar))
 331             {
 332                 nHighSurrogate = static_cast<sal_Unicode>(nChar);
 333                 continue;
 334             }
 335             else if (rtl::isLowSurrogate(nChar))
 336             {
 337                 bUndefined = false;
 338                 goto bad_input;
 339             }
 340         }
 341         else if (rtl::isLowSurrogate(nChar))
 342             nChar = rtl::combineSurrogates(nHighSurrogate, nChar);
 343         else
 344         {
 345             bUndefined = false;
 346             goto bad_input;
 347         }
 348
 349         assert(rtl::isUnicodeScalarValue(nChar));
 350
 351         if (nChar < 0x80)
 352             if (pDestBufPtr != pDestBufEnd)
 353                 *pDestBufPtr++ = static_cast< char >(nChar);
 354             else
 355                 goto no_output;
 356         else if (nChar < 0x10000)
 357         {
 358             ImplUnicodeToGb180302000Range const * pRange = pGb18030Ranges;
 359             sal_Unicode nFirstNonRange = 0x80;
 360             for (;;)
 361             {
 362                 if (nChar < pRange->m_nFirstUnicode)
 363                 {
 364                     sal_uInt32 nCode
 365                         = pGb18030Data[pRange->m_nNonRangeDataIndex
 366                                            + (nChar - nFirstNonRange)];
 367                     if (pDestBufEnd - pDestBufPtr
 368                             >= (nCode <= 0xFFFF ? 2 : 4))
 369                     {
 370                         if (nCode > 0xFFFF)
 371                         {
 372                             *pDestBufPtr++ = static_cast< char >(nCode >> 24);
 373                             *pDestBufPtr++ = static_cast< char >(nCode >> 16 & 0xFF);
 374                         }
 375                         *pDestBufPtr++ = static_cast< char >(nCode >> 8 & 0xFF);
 376                         *pDestBufPtr++ = static_cast< char >(nCode & 0xFF);
 377                     }
 378                     else
 379                         goto no_output;
 380                     break;
 381                 }
 382                 if (nChar <= pRange->m_nLastUnicode)
 383                 {
 384                     if (pDestBufEnd - pDestBufPtr >= 4)
 385                     {
 386                         sal_uInt32 nCode
 387                             = pRange->m_nFirstLinear
 388                                   + (nChar - pRange->m_nFirstUnicode);
 389                         *pDestBufPtr++ = static_cast< char >(nCode / 12600 + 0x81);
 390                         *pDestBufPtr++
 391                             = static_cast< char >(nCode / 1260 % 10 + 0x30);
 392                         *pDestBufPtr++ = static_cast< char >(nCode / 10 % 126 + 0x81);
 393                         *pDestBufPtr++ = static_cast< char >(nCode % 10 + 0x30);
 394                     }
 395                     else
 396                         goto no_output;
 397                     break;
 398                 }
 399                 nFirstNonRange
 400                     = static_cast<sal_Unicode>((pRange++)->m_nLastUnicode + 1);
 401             }
 402         }
 403         else
 404             if (pDestBufEnd - pDestBufPtr >= 4)
 405             {
 406                 sal_uInt32 nCode = nChar - 0x10000;
 407                 *pDestBufPtr++ = static_cast< char >(nCode / 12600 + 0x90);
 408                 *pDestBufPtr++ = static_cast< char >(nCode / 1260 % 10 + 0x30);
 409                 *pDestBufPtr++ = static_cast< char >(nCode / 10 % 126 + 0x81);
 410                 *pDestBufPtr++ = static_cast< char >(nCode % 10 + 0x30);
 411             }
 412             else
 413                 goto no_output;
 414         nHighSurrogate = 0;
 415         continue;
 416
 417     bad_input:
 418         switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
 419                     bUndefined, nChar, nFlags, &pDestBufPtr, pDestBufEnd,
 420                     &nInfo, nullptr, 0, nullptr))
 421         {
 422         case sal::detail::textenc::BAD_INPUT_STOP:
 423             nHighSurrogate = 0;
 424             break;
 425
 426         case sal::detail::textenc::BAD_INPUT_CONTINUE:
 427             nHighSurrogate = 0;
 428             continue;
 429
 430         case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
 431             goto no_output;
 432         }
 433         break;
 434
 435     no_output:
 436         --pSrcBuf;
 437         nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 438         break;
 439     }
 440
 441     if (nHighSurrogate != 0
 442         && (nInfo & (RTL_UNICODETOTEXT_INFO_ERROR
 443                          | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL))
 444                == 0)
 445     {
 446         if ((nFlags & RTL_UNICODETOTEXT_FLAGS_FLUSH) != 0)
 447             nInfo |= RTL_UNICODETOTEXT_INFO_SRCBUFFERTOSMALL;
 448         else
 449             switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
 450                         false, 0, nFlags, &pDestBufPtr, pDestBufEnd, &nInfo,
 451                         nullptr, 0, nullptr))
 452             {
 453             case sal::detail::textenc::BAD_INPUT_STOP:
 454             case sal::detail::textenc::BAD_INPUT_CONTINUE:
 455                 nHighSurrogate = 0;
 456                 break;
 457
 458             case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
 459                 nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 460                 break;
 461             }
 462     }
 463
 464     if (pContext)
 465         static_cast<ImplUnicodeToTextContext *>(pContext)->m_nHighSurrogate
 466             = nHighSurrogate;
 467     if (pInfo)
 468         *pInfo = nInfo;
 469     if (pSrcCvtChars)
 470         *pSrcCvtChars = nConverted;
 471
 472     return pDestBufPtr - pDestBuf;
 473 }
 474
 475 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */