sal/textenc/tcvtmb.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
  24 #include "handleundefinedunicodetotextchar.hxx"
  25 #include "tenchelp.hxx"
  26 #include "unichars.hxx"
  27
  28 /* DBCS to Unicode conversion routine use a lead table for the first byte, */
  29 /* where we determine the trail table or for single byte chars the unicode */
  30 /* value. We have for all lead byte a separate table, because we can */
  31 /* then share many tables for different charset encodings. */
  32
  33 sal_Size ImplDBCSToUnicode( const void* pData, SAL_UNUSED_PARAMETER void*,
  34                             const char* pSrcBuf, sal_Size nSrcBytes,
  35                             sal_Unicode* pDestBuf, sal_Size nDestChars,
  36                             sal_uInt32 nFlags, sal_uInt32* pInfo,
  37                             sal_Size* pSrcCvtBytes )
  38 {
  39     unsigned char                   cTrail;
  40     sal_Unicode                 cConv;
  41     const ImplDBCSToUniLeadTab* pLeadEntry;
  42     const ImplDBCSConvertData*  pConvertData = static_cast<const ImplDBCSConvertData*>(pData);
  43     const ImplDBCSToUniLeadTab* pLeadTab = pConvertData->mpToUniLeadTab;
  44     sal_Unicode*                pEndDestBuf;
  45     const char*             pEndSrcBuf;
  46     char const * startOfCurrentChar = pSrcBuf;
  47
  48     *pInfo = 0;
  49     pEndDestBuf = pDestBuf+nDestChars;
  50     pEndSrcBuf  = pSrcBuf+nSrcBytes;
  51     while ( pSrcBuf < pEndSrcBuf )
  52     {
  53         unsigned char cLead = static_cast<unsigned char>(*pSrcBuf);
  54
  55         /* get entry for the lead byte */
  56         pLeadEntry = pLeadTab+cLead;
  57
  58         /* SingleByte char? */
  59         if (pLeadEntry->mpToUniTrailTab == nullptr
  60             || cLead < pConvertData->mnLeadStart
  61             || cLead > pConvertData->mnLeadEnd)
  62         {
  63             cConv = pLeadEntry->mnUniChar;
  64             if ( !cConv && (cLead != 0) )
  65             {
  66                 *pInfo |= RTL_TEXTTOUNICODE_INFO_UNDEFINED;
  67                 if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR )
  68                 {
  69                     if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
  70                         ++pSrcBuf;
  71                     } else {
  72                         pSrcBuf = startOfCurrentChar;
  73                     }
  74                     *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
  75                     break;
  76                 }
  77                 if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE )
  78                 {
  79                     pSrcBuf++;
  80                     startOfCurrentChar = pSrcBuf;
  81                     continue;
  82                 }
  83                 cConv = ImplGetUndefinedUnicodeChar(cLead, nFlags);
  84             }
  85         }
  86         else
  87         {
  88             /* Source buffer too small */
  89             if ( pSrcBuf +1 == pEndSrcBuf )
  90             {
  91                 if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0 )
  92                 {
  93                     *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
  94                     break;
  95                 }
  96                 cConv = 0;
  97             }
  98             else
  99             {
 100                 pSrcBuf++;
 101                 cTrail = static_cast<unsigned char>(*pSrcBuf);
 102                 if ( (cTrail >= pLeadEntry->mnTrailStart) && (cTrail <= pLeadEntry->mnTrailEnd) )
 103                     cConv = pLeadEntry->mpToUniTrailTab[cTrail-pLeadEntry->mnTrailStart];
 104                 else
 105                     cConv = 0;
 106
 107                 if ( !cConv )
 108                 {
 109                     /* EUDC Ranges */
 110                     sal_uInt16              i;
 111                     const ImplDBCSEUDCData* pEUDCTab = pConvertData->mpEUDCTab;
 112                     for ( i = 0; i < pConvertData->mnEUDCCount; i++ )
 113                     {
 114                         if ( (cLead >= pEUDCTab->mnLeadStart) &&
 115                              (cLead <= pEUDCTab->mnLeadEnd) )
 116                         {
 117                             if ( (cTrail >= pEUDCTab->mnTrail1Start) &&
 118                                  (cTrail <= pEUDCTab->mnTrail1End) )
 119                             {
 120                                 cConv = pEUDCTab->mnUniStart+
 121                                     ((cLead-pEUDCTab->mnLeadStart)*pEUDCTab->mnTrailRangeCount)+
 122                                     (cTrail-pEUDCTab->mnTrail1Start);
 123                                 break;
 124                             }
 125                             sal_uInt16 nTrailCount = pEUDCTab->mnTrail1End-pEUDCTab->mnTrail1Start+1;
 126                             if ( (pEUDCTab->mnTrailCount >= 2) &&
 127                                  (cTrail >= pEUDCTab->mnTrail2Start) &&
 128                                  (cTrail <= pEUDCTab->mnTrail2End) )
 129                             {
 130                                 cConv = pEUDCTab->mnUniStart+
 131                                     ((cLead-pEUDCTab->mnLeadStart)*pEUDCTab->mnTrailRangeCount)+
 132                                     nTrailCount+
 133                                     (cTrail-pEUDCTab->mnTrail2Start);
 134                                 break;
 135                             }
 136                             nTrailCount = pEUDCTab->mnTrail2End-pEUDCTab->mnTrail2Start+1;
 137                             if ( (pEUDCTab->mnTrailCount >= 3) &&
 138                                  (cTrail >= pEUDCTab->mnTrail3Start) &&
 139                                  (cTrail <= pEUDCTab->mnTrail3End) )
 140                             {
 141                                 cConv = pEUDCTab->mnUniStart+
 142                                       ((cLead-pEUDCTab->mnLeadStart)*pEUDCTab->mnTrailRangeCount)+
 143                                       nTrailCount+
 144                                       (cTrail-pEUDCTab->mnTrail3Start);
 145                                 break;
 146                             }
 147                         }
 148
 149                         pEUDCTab++;
 150                     }
 151
 152                     if ( !cConv )
 153                     {
 154                         /* We compare the full range of the trail we defined, */
 155                         /* which can often be greater than the limit. We do this */
 156                         /* so that extensions that don't consider encodings */
 157                         /* correctly treat double-byte characters as a single */
 158                         /* character as much as possible. */
 159
 160                         if (cLead < pConvertData->mnLeadStart
 161                             || cLead > pConvertData->mnLeadEnd
 162                             || cTrail < pConvertData->mnTrailStart
 163                             || cTrail > pConvertData->mnTrailEnd)
 164                         {
 165                             *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
 166                             if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
 167                             {
 168                                 if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
 169                                     ++pSrcBuf;
 170                                 } else {
 171                                     pSrcBuf = startOfCurrentChar;
 172                                 }
 173                                 *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 174                                 break;
 175                             }
 176                             if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
 177                             {
 178                                 pSrcBuf++;
 179                                 startOfCurrentChar = pSrcBuf;
 180                                 continue;
 181                             }
 182                             cConv = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 183                         }
 184                     }
 185                 }
 186             }
 187             if ( !cConv )
 188             {
 189                 *pInfo |= RTL_TEXTTOUNICODE_INFO_MBUNDEFINED;
 190                 if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR )
 191                 {
 192                     if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
 193                         ++pSrcBuf;
 194                     } else {
 195                         pSrcBuf = startOfCurrentChar;
 196                     }
 197                     *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 198                     break;
 199                 }
 200                 if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_IGNORE )
 201                 {
 202                     pSrcBuf++;
 203                     startOfCurrentChar = pSrcBuf;
 204                     continue;
 205                 }
 206                 cConv = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 207             }
 208         }
 209
 210         if ( pDestBuf == pEndDestBuf )
 211         {
 212             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
 213             break;
 214         }
 215
 216         *pDestBuf = cConv;
 217         pDestBuf++;
 218         pSrcBuf++;
 219         startOfCurrentChar = pSrcBuf;
 220     }
 221
 222     *pSrcCvtBytes = nSrcBytes - (pEndSrcBuf-pSrcBuf);
 223     return (nDestChars - (pEndDestBuf-pDestBuf));
 224 }
 225
 226 sal_Size ImplUnicodeToDBCS( const void* pData, SAL_UNUSED_PARAMETER void*,
 227                             const sal_Unicode* pSrcBuf, sal_Size nSrcChars,
 228                             char* pDestBuf, sal_Size nDestBytes,
 229                             sal_uInt32 nFlags, sal_uInt32* pInfo,
 230                             sal_Size* pSrcCvtChars )
 231 {
 232     sal_uInt16                  cConv;
 233     sal_Unicode                 c;
 234     const ImplUniToDBCSHighTab* pHighEntry;
 235     const ImplDBCSConvertData*  pConvertData = static_cast<const ImplDBCSConvertData*>(pData);
 236     const ImplUniToDBCSHighTab* pHighTab = pConvertData->mpToDBCSHighTab;
 237     char*                   pEndDestBuf;
 238     const sal_Unicode*          pEndSrcBuf;
 239
 240     bool bCheckRange =
 241         pConvertData->mnLeadStart != 0 || pConvertData->mnLeadEnd != 0xFF;
 242         /* this statement has the effect that this extra check is only done for
 243            EUC-KR, which uses the MS-949 tables, but does not support the full
 244            range of MS-949 */
 245
 246     *pInfo = 0;
 247     pEndDestBuf = pDestBuf+nDestBytes;
 248     pEndSrcBuf  = pSrcBuf+nSrcChars;
 249     while ( pSrcBuf < pEndSrcBuf )
 250     {
 251         c = *pSrcBuf;
 252         unsigned char nHighChar = static_cast<unsigned char>((c >> 8) & 0xFF);
 253         unsigned char nLowChar = static_cast<unsigned char>(c & 0xFF);
 254
 255         /* get entry for the high byte */
 256         pHighEntry = pHighTab+nHighChar;
 257
 258         /* is low byte in the table range */
 259         if ( (nLowChar >= pHighEntry->mnLowStart) && (nLowChar <= pHighEntry->mnLowEnd) )
 260         {
 261             cConv = pHighEntry->mpToUniTrailTab[nLowChar-pHighEntry->mnLowStart];
 262             if (bCheckRange && cConv > 0x7F
 263                 && ((cConv >> 8) < pConvertData->mnLeadStart
 264                     || (cConv >> 8) > pConvertData->mnLeadEnd
 265                     || (cConv & 0xFF) < pConvertData->mnTrailStart
 266                     || (cConv & 0xFF) > pConvertData->mnTrailEnd))
 267                 cConv = 0;
 268         }
 269         else
 270             cConv = 0;
 271
 272         if (cConv == 0 && c != 0)
 273         {
 274             /* Map to EUDC ranges: */
 275             ImplDBCSEUDCData const * pEUDCTab = pConvertData->mpEUDCTab;
 276             sal_uInt32 i;
 277             for (i = 0; i < pConvertData->mnEUDCCount; ++i)
 278             {
 279                 if (c >= pEUDCTab->mnUniStart && c <= pEUDCTab->mnUniEnd)
 280                 {
 281                     sal_uInt32 nIndex = c - pEUDCTab->mnUniStart;
 282                     sal_uInt32 nLeadOff
 283                         = nIndex / pEUDCTab->mnTrailRangeCount;
 284                     sal_uInt32 nTrailOff
 285                         = nIndex % pEUDCTab->mnTrailRangeCount;
 286                     sal_uInt32 nSize;
 287                     cConv = static_cast<sal_uInt16>((pEUDCTab->mnLeadStart + nLeadOff) << 8);
 288                     nSize
 289                         = pEUDCTab->mnTrail1End - pEUDCTab->mnTrail1Start + 1;
 290                     if (nTrailOff < nSize)
 291                     {
 292                         cConv |= pEUDCTab->mnTrail1Start + nTrailOff;
 293                         break;
 294                     }
 295                     nTrailOff -= nSize;
 296                     nSize
 297                         = pEUDCTab->mnTrail2End - pEUDCTab->mnTrail2Start + 1;
 298                     if (nTrailOff < nSize)
 299                     {
 300                         cConv |= pEUDCTab->mnTrail2Start + nTrailOff;
 301                         break;
 302                     }
 303                     nTrailOff -= nSize;
 304                     cConv |= pEUDCTab->mnTrail3Start + nTrailOff;
 305                     break;
 306                 }
 307                 pEUDCTab++;
 308             }
 309
 310             /* FIXME
 311              * SB: Not sure why this is in here.  Plus, it does not work as
 312              * intended when (c & 0xFF) == 0, because the next !cConv check
 313              * will then think c has not yet been converted...
 314              */
 315             if (c >= RTL_TEXTCVT_BYTE_PRIVATE_START
 316                 && c <= RTL_TEXTCVT_BYTE_PRIVATE_END)
 317             {
 318                 if ( nFlags & RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 )
 319                     cConv = static_cast< char >(static_cast< unsigned char >(c & 0xFF));
 320             }
 321         }
 322
 323         if (cConv == 0 && c != 0)
 324         {
 325             if ( nFlags & RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE )
 326             {
 327                 /* !!! */
 328             }
 329
 330             if ( nFlags & RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR )
 331             {
 332                 /* !!! */
 333             }
 334
 335             /* Handle undefined and surrogates characters */
 336             /* (all surrogates characters are undefined) */
 337             if (sal::detail::textenc::handleUndefinedUnicodeToTextChar(
 338                     &pSrcBuf, pEndSrcBuf, &pDestBuf, pEndDestBuf, nFlags,
 339                     pInfo))
 340                 continue;
 341             break;
 342         }
 343
 344         /* SingleByte */
 345         if ( !(cConv & 0xFF00) )
 346         {
 347             if ( pDestBuf == pEndDestBuf )
 348             {
 349                 *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 350                 break;
 351             }
 352
 353             *pDestBuf = static_cast< char >(static_cast< unsigned char >(cConv & 0xFF));
 354             pDestBuf++;
 355         }
 356         else
 357         {
 358             if ( pDestBuf+1 >= pEndDestBuf )
 359             {
 360                 *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 361                 break;
 362             }
 363
 364             *pDestBuf = static_cast< char >(static_cast< unsigned char >((cConv >> 8) & 0xFF));
 365             pDestBuf++;
 366             *pDestBuf = static_cast< char >(static_cast< unsigned char >(cConv & 0xFF));
 367             pDestBuf++;
 368         }
 369
 370         pSrcBuf++;
 371     }
 372
 373     *pSrcCvtChars = nSrcChars - (pEndSrcBuf-pSrcBuf);
 374     return (nDestBytes - (pEndDestBuf-pDestBuf));
 375 }
 376
 377 #define JIS_EUC_LEAD_OFF                                        0x80
 378 #define JIS_EUC_TRAIL_OFF                                       0x80
 379
 380 sal_Size ImplEUCJPToUnicode( const void* pData,
 381                              SAL_UNUSED_PARAMETER void*,
 382                              const char* pSrcBuf, sal_Size nSrcBytes,
 383                              sal_Unicode* pDestBuf, sal_Size nDestChars,
 384                              sal_uInt32 nFlags, sal_uInt32* pInfo,
 385                              sal_Size* pSrcCvtBytes )
 386 {
 387     unsigned char                   cLead = '\0';
 388     unsigned char                   cTrail = '\0';
 389     sal_Unicode                 cConv;
 390     const ImplDBCSToUniLeadTab* pLeadEntry;
 391     const ImplDBCSToUniLeadTab* pLeadTab;
 392     const ImplEUCJPConvertData* pConvertData = static_cast<const ImplEUCJPConvertData*>(pData);
 393     sal_Unicode*                pEndDestBuf;
 394     const char*             pEndSrcBuf;
 395     char const * startOfCurrentChar = pSrcBuf;
 396
 397     *pInfo = 0;
 398     pEndDestBuf = pDestBuf+nDestChars;
 399     pEndSrcBuf  = pSrcBuf+nSrcBytes;
 400     while ( pSrcBuf < pEndSrcBuf )
 401     {
 402         unsigned char c = static_cast<unsigned char>(*pSrcBuf);
 403
 404         /* ASCII */
 405         if ( c <= 0x7F )
 406             cConv = c;
 407         else
 408         {
 409             /* SS2 - Half-width katakana */
 410             /* 8E + A1-DF */
 411             if ( c == 0x8E )
 412             {
 413                 /* Source buffer too small */
 414                 if ( pSrcBuf + 1 == pEndSrcBuf )
 415                 {
 416                     *pInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
 417                     break;
 418                 }
 419
 420                 pSrcBuf++;
 421                 c = static_cast<unsigned char>(*pSrcBuf);
 422                 if ( (c >= 0xA1) && (c <= 0xDF) )
 423                     cConv = 0xFF61+(c-0xA1);
 424                 else
 425                 {
 426                     cConv = 0;
 427                     cLead = 0x8E;
 428                     cTrail = c;
 429                 }
 430             }
 431             else
 432             {
 433                 /* SS3 - JIS 0212-1990 */
 434                 /* 8F + A1-FE + A1-FE */
 435                 if ( c == 0x8F )
 436                 {
 437                     /* Source buffer too small */
 438                     if (pEndSrcBuf - pSrcBuf < 3)
 439                     {
 440                         *pInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
 441                         break;
 442                     }
 443
 444                     pSrcBuf++;
 445                     cLead = static_cast<unsigned char>(*pSrcBuf);
 446                     pSrcBuf++;
 447                     cTrail = static_cast<unsigned char>(*pSrcBuf);
 448                     pLeadTab = pConvertData->mpJIS0212ToUniLeadTab;
 449                 }
 450                 /* CodeSet 2 JIS 0208-1997 */
 451                 /* A1-FE + A1-FE */
 452                 else
 453                 {
 454                     /* Source buffer too small */
 455                     if ( pSrcBuf + 1 == pEndSrcBuf )
 456                     {
 457                         *pInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
 458                         break;
 459                     }
 460
 461                     cLead = c;
 462                     pSrcBuf++;
 463                     cTrail = static_cast<unsigned char>(*pSrcBuf);
 464                     pLeadTab = pConvertData->mpJIS0208ToUniLeadTab;
 465                 }
 466
 467                 /* Undefined Range */
 468                 if ( (cLead < JIS_EUC_LEAD_OFF) || (cTrail < JIS_EUC_TRAIL_OFF) )
 469                     cConv = 0;
 470                 else
 471                 {
 472                     cLead   -= JIS_EUC_LEAD_OFF;
 473                     cTrail  -= JIS_EUC_TRAIL_OFF;
 474                     pLeadEntry = pLeadTab+cLead;
 475                     if ( (cTrail >= pLeadEntry->mnTrailStart) && (cTrail <= pLeadEntry->mnTrailEnd) )
 476                         cConv = pLeadEntry->mpToUniTrailTab[cTrail-pLeadEntry->mnTrailStart];
 477                     else
 478                         cConv = 0;
 479                 }
 480             }
 481
 482             if ( !cConv )
 483             {
 484                 /* We compare the full range of the trail we defined, */
 485                 /* which can often be greater than the limit. We do this */
 486                 /* so that extensions that don't consider encodings */
 487                 /* correctly treat double-byte characters as a single */
 488                 /* character as much as possible. */
 489
 490                 if ( (cLead < JIS_EUC_LEAD_OFF) || (cTrail < JIS_EUC_TRAIL_OFF) )
 491                 {
 492                     *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
 493                     if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
 494                     {
 495                         if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
 496                             ++pSrcBuf;
 497                         } else {
 498                             pSrcBuf = startOfCurrentChar;
 499                         }
 500                         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 501                         break;
 502                     }
 503                     if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
 504                     {
 505                         pSrcBuf++;
 506                         startOfCurrentChar = pSrcBuf;
 507                         continue;
 508                     }
 509                     cConv = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 510                 }
 511                 else
 512                 {
 513                     if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
 514                         ++pSrcBuf;
 515                     } else {
 516                         pSrcBuf = startOfCurrentChar;
 517                     }
 518                     *pInfo |= RTL_TEXTTOUNICODE_INFO_MBUNDEFINED;
 519                     if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR )
 520                     {
 521                         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 522                         break;
 523                     }
 524                     if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_IGNORE )
 525                     {
 526                         pSrcBuf++;
 527                         startOfCurrentChar = pSrcBuf;
 528                         continue;
 529                     }
 530                     cConv = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 531                 }
 532             }
 533         }
 534
 535         if ( pDestBuf == pEndDestBuf )
 536         {
 537             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
 538             break;
 539         }
 540
 541         *pDestBuf = cConv;
 542         pDestBuf++;
 543         pSrcBuf++;
 544         startOfCurrentChar = pSrcBuf;
 545     }
 546
 547     *pSrcCvtBytes = nSrcBytes - (pEndSrcBuf-pSrcBuf);
 548     return (nDestChars - (pEndDestBuf-pDestBuf));
 549 }
 550
 551 sal_Size ImplUnicodeToEUCJP( const void* pData,
 552                              SAL_UNUSED_PARAMETER void*,
 553                              const sal_Unicode* pSrcBuf, sal_Size nSrcChars,
 554                              char* pDestBuf, sal_Size nDestBytes,
 555                              sal_uInt32 nFlags, sal_uInt32* pInfo,
 556                              sal_Size* pSrcCvtChars )
 557 {
 558     sal_uInt32                  cConv;
 559     sal_Unicode                 c;
 560     unsigned char                   nHighChar;
 561     unsigned char                   nLowChar;
 562     const ImplUniToDBCSHighTab* pHighEntry;
 563     const ImplUniToDBCSHighTab* pHighTab;
 564     const ImplEUCJPConvertData* pConvertData = static_cast<const ImplEUCJPConvertData*>(pData);
 565     char*                   pEndDestBuf;
 566     const sal_Unicode*          pEndSrcBuf;
 567
 568     *pInfo = 0;
 569     pEndDestBuf = pDestBuf+nDestBytes;
 570     pEndSrcBuf  = pSrcBuf+nSrcChars;
 571     while ( pSrcBuf < pEndSrcBuf )
 572     {
 573         c = *pSrcBuf;
 574
 575         /* ASCII */
 576         if ( c <= 0x7F )
 577             cConv = c;
 578         /* Half-width katakana */
 579         else if ( (c >= 0xFF61) && (c <= 0xFF9F) )
 580             cConv = 0x8E00+0xA1+(c-0xFF61);
 581         else
 582         {
 583             nHighChar = static_cast<unsigned char>((c >> 8) & 0xFF);
 584             nLowChar = static_cast<unsigned char>(c & 0xFF);
 585
 586             /* JIS 0208 */
 587             pHighTab = pConvertData->mpUniToJIS0208HighTab;
 588             pHighEntry = pHighTab+nHighChar;
 589             if ( (nLowChar >= pHighEntry->mnLowStart) && (nLowChar <= pHighEntry->mnLowEnd) )
 590             {
 591                 cConv = pHighEntry->mpToUniTrailTab[nLowChar-pHighEntry->mnLowStart];
 592                 if (cConv != 0)
 593                     cConv |= 0x8080;
 594             }
 595             else
 596                 cConv = 0;
 597
 598             /* JIS 0212 */
 599             if ( !cConv )
 600             {
 601                 pHighTab = pConvertData->mpUniToJIS0212HighTab;
 602                 pHighEntry = pHighTab+nHighChar;
 603                 if ( (nLowChar >= pHighEntry->mnLowStart) && (nLowChar <= pHighEntry->mnLowEnd) )
 604                 {
 605                     cConv = pHighEntry->mpToUniTrailTab[nLowChar-pHighEntry->mnLowStart];
 606                     if (cConv != 0)
 607                         cConv |= 0x8F8080;
 608                 }
 609
 610                 if ( !cConv )
 611                 {
 612                     if ( nFlags & RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE )
 613                     {
 614                         /* !!! */
 615                     }
 616
 617                     if ( nFlags & RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR )
 618                     {
 619                         /* !!! */
 620                     }
 621
 622                     /* Handle undefined and surrogates characters */
 623                     /* (all surrogates characters are undefined) */
 624                     if (sal::detail::textenc::handleUndefinedUnicodeToTextChar(
 625                             &pSrcBuf, pEndSrcBuf, &pDestBuf, pEndDestBuf,
 626                             nFlags, pInfo))
 627                         continue;
 628                     break;
 629                 }
 630             }
 631         }
 632
 633         /* SingleByte */
 634         if ( !(cConv & 0xFFFF00) )
 635         {
 636             if ( pDestBuf == pEndDestBuf )
 637             {
 638                 *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 639                 break;
 640             }
 641
 642             *pDestBuf = static_cast< char >(static_cast< unsigned char >(cConv & 0xFF));
 643             pDestBuf++;
 644         }
 645         /* DoubleByte */
 646         else if ( !(cConv & 0xFF0000) )
 647         {
 648             if ( pDestBuf+1 >= pEndDestBuf )
 649             {
 650                 *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 651                 break;
 652             }
 653
 654             *pDestBuf = static_cast< char >(static_cast< unsigned char >((cConv >> 8) & 0xFF));
 655             pDestBuf++;
 656             *pDestBuf = static_cast< char >(static_cast< unsigned char >(cConv & 0xFF));
 657             pDestBuf++;
 658         }
 659         else
 660         {
 661             if ( pDestBuf+2 >= pEndDestBuf )
 662             {
 663                 *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 664                 break;
 665             }
 666
 667             *pDestBuf = static_cast< char >(static_cast< unsigned char >((cConv >> 16) & 0xFF));
 668             pDestBuf++;
 669             *pDestBuf = static_cast< char >(static_cast< unsigned char >((cConv >> 8) & 0xFF));
 670             pDestBuf++;
 671             *pDestBuf = static_cast< char >(static_cast< unsigned char >(cConv & 0xFF));
 672             pDestBuf++;
 673         }
 674
 675         pSrcBuf++;
 676     }
 677
 678     *pSrcCvtChars = nSrcChars - (pEndSrcBuf-pSrcBuf);
 679     return (nDestBytes - (pEndDestBuf-pDestBuf));
 680 }
 681
 682 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */