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