sal/textenc/tcvtutf7.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 "tenchelp.hxx"
  25 #include "unichars.hxx"
  26
  27 /* ======================================================================= */
  28
  29 static unsigned char const aImplBase64Tab[64] =
  30 {
  31     /* A-Z */
  32           0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  33     0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
  34     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
  35     0x58, 0x59, 0x5A,
  36     /* a-z */
  37           0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  38     0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
  39     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  40     0x78, 0x79, 0x7A,
  41     /* 0-9,+,/ */
  42     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  43     0x38, 0x39, 0x2B, 0x2F
  44 };
  45
  46 /* Index in Base64Tab or 0xFF, when is a invalid character */
  47 static unsigned char const aImplBase64IndexTab[128] =
  48 {
  49     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x00-0x07 */
  50     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x08-0x0F */
  51     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x10-0x17 */
  52     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x18-0x1F */
  53     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x20-0x27  !"#$%&' */
  54     0xFF, 0xFF, 0xFF,   62, 0xFF, 0xFF, 0xFF,   63,     /* 0x28-0x2F ()*+,-./ */
  55       52,   53,   54,   55,   56,   57,   58,   59,     /* 0x30-0x37 01234567 */
  56       60,   61, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x38-0x3F 89:;<=>? */
  57     0xFF,    0,    1,    2,    3,    4,    5,    6,     /* 0x40-0x47 @ABCDEFG */
  58        7,    8,    9,   10,   11,   12,   13,   14,     /* 0x48-0x4F HIJKLMNO */
  59       15,   16,   17,   18,   19,   20,   21,   22,     /* 0x50-0x57 PQRSTUVW */
  60       23,   24,   25, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,     /* 0x58-0x5F XYZ[\]^_ */
  61     0xFF,   26,   27,   28,   29,   30,   31,   32,     /* 0x60-0x67 `abcdefg */
  62       33,   34,   35,   36,   37,   38,   39,   40,     /* 0x68-0x6F hijklmno */
  63       41,   42,   43,   44,   45,   46,   47,   48,     /* 0x70-0x77 pqrstuvw */
  64       49,   50,   51, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF      /* 0x78-0x7F xyz{|}~ */
  65 };
  66
  67 static unsigned char const aImplMustShiftTab[128] =
  68 {
  69     1, 1, 1, 1, 1, 1, 1, 1,     /* 0x00-0x07 */
  70     1, 0, 0, 1, 0, 1, 1, 1,     /* 0x08-0x0F 0x09 == HTAB, 0x0A == LF 0x0C == CR */
  71     1, 1, 1, 1, 1, 1, 1, 1,     /* 0x10-0x17 */
  72     1, 1, 1, 1, 1, 1, 1, 1,     /* 0x18-0x1F */
  73     0, 1, 1, 1, 1, 1, 1, 0,     /* 0x20-0x27  !"#$%&' */
  74     0, 0, 1, 1, 0, 1, 0, 0,     /* 0x28-0x2F ()*+,-./ */
  75     0, 0, 0, 0, 0, 0, 0, 0,     /* 0x30-0x37 01234567 */
  76     0, 0, 0, 1, 1, 1, 1, 0,     /* 0x38-0x3F 89:;<=>? */
  77     1, 0, 0, 0, 0, 0, 0, 0,     /* 0x40-0x47 @ABCDEFG */
  78     0, 0, 0, 0, 0, 0, 0, 0,     /* 0x48-0x4F HIJKLMNO */
  79     0, 0, 0, 0, 0, 0, 0, 0,     /* 0x50-0x57 PQRSTUVW */
  80     0, 0, 0, 1, 1, 1, 1, 1,     /* 0x58-0x5F XYZ[\]^_ */
  81     1, 0, 0, 0, 0, 0, 0, 0,     /* 0x60-0x67 `abcdefg */
  82     0, 0, 0, 0, 0, 0, 0, 0,     /* 0x68-0x6F hijklmno */
  83     0, 0, 0, 0, 0, 0, 0, 0,     /* 0x70-0x77 pqrstuvw */
  84     0, 0, 0, 1, 1, 1, 1, 1      /* 0x78-0x7F xyz{|}~ */
  85 };
  86
  87 /* + */
  88 #define IMPL_SHIFT_IN_CHAR      0x2B
  89 /* - */
  90 #define IMPL_SHIFT_OUT_CHAR     0x2D
  91
  92 /* ----------------------------------------------------------------------- */
  93
  94 struct ImplUTF7ToUCContextData
  95 {
  96     int                     mbShifted;
  97     int                     mbFirst;
  98     int                     mbWroteOne;
  99     sal_uInt32              mnBitBuffer;
 100     sal_uInt32              mnBufferBits;
 101 };
 102
 103 /* ----------------------------------------------------------------------- */
 104
 105 void* ImplUTF7CreateUTF7TextToUnicodeContext()
 106 {
 107     ImplUTF7ToUCContextData* pContextData = new ImplUTF7ToUCContextData;
 108     pContextData->mbShifted         = sal_False;
 109     pContextData->mbFirst           = sal_False;
 110     pContextData->mbWroteOne        = sal_False;
 111     pContextData->mnBitBuffer       = 0;
 112     pContextData->mnBufferBits      = 0;
 113     return pContextData;
 114 }
 115
 116 /* ----------------------------------------------------------------------- */
 117
 118 void ImplUTF7DestroyTextToUnicodeContext( void* pContext )
 119 {
 120     delete static_cast< ImplUTF7ToUCContextData * >(pContext);
 121 }
 122
 123 /* ----------------------------------------------------------------------- */
 124
 125 void ImplUTF7ResetTextToUnicodeContext( void* pContext )
 126 {
 127     ImplUTF7ToUCContextData* pContextData = (ImplUTF7ToUCContextData*)pContext;
 128     pContextData->mbShifted         = sal_False;
 129     pContextData->mbFirst           = sal_False;
 130     pContextData->mbWroteOne        = sal_False;
 131     pContextData->mnBitBuffer       = 0;
 132     pContextData->mnBufferBits      = 0;
 133 }
 134
 135 /* ----------------------------------------------------------------------- */
 136
 137 sal_Size ImplUTF7ToUnicode( SAL_UNUSED_PARAMETER const void*, void* pContext,
 138                             const char* pSrcBuf, sal_Size nSrcBytes,
 139                             sal_Unicode* pDestBuf, sal_Size nDestChars,
 140                             sal_uInt32 nFlags, sal_uInt32* pInfo,
 141                             sal_Size* pSrcCvtBytes )
 142 {
 143     ImplUTF7ToUCContextData*    pContextData = (ImplUTF7ToUCContextData*)pContext;
 144     unsigned char                   c ='\0';
 145     unsigned char                   nBase64Value = 0;
 146     int                         bEnd = sal_False;
 147     int                         bShifted;
 148     int                         bFirst;
 149     int                         bWroteOne;
 150     int                         bBase64End;
 151     sal_uInt32                  nBitBuffer;
 152     sal_uInt32                  nBitBufferTemp;
 153     sal_uInt32                  nBufferBits;
 154     sal_Unicode*                pEndDestBuf;
 155     const char*             pEndSrcBuf;
 156
 157 /* !!! Implementation not finnished !!!
 158     if ( pContextData )
 159     {
 160         bShifted        = pContextData->mbShifted;
 161         bFirst          = pContextData->mbFirst;
 162         bWroteOne       = pContextData->mbWroteOne;
 163         nBitBuffer      = pContextData->mnBitBuffer;
 164         nBufferBits     = pContextData->mnBufferBits;
 165     }
 166     else
 167 */
 168     {
 169         bShifted        = sal_False;
 170         bFirst          = sal_False;
 171         bWroteOne       = sal_False;
 172         nBitBuffer      = 0;
 173         nBufferBits     = 0;
 174     }
 175
 176     *pInfo = 0;
 177     pEndDestBuf = pDestBuf+nDestChars;
 178     pEndSrcBuf  = pSrcBuf+nSrcBytes;
 179     do
 180     {
 181         if ( pSrcBuf < pEndSrcBuf )
 182         {
 183             c = (unsigned char)*pSrcBuf;
 184
 185             /* End, when not a base64 character */
 186             bBase64End = sal_False;
 187             if ( c <= 0x7F )
 188             {
 189                 nBase64Value = aImplBase64IndexTab[c];
 190                 if ( nBase64Value == 0xFF )
 191                     bBase64End = sal_True;
 192             }
 193         }
 194         else
 195         {
 196             bEnd = sal_True;
 197             bBase64End = sal_True;
 198         }
 199
 200         if ( bShifted )
 201         {
 202             if ( bBase64End )
 203             {
 204                 bShifted = sal_False;
 205
 206                 /* If the character causing us to drop out was SHIFT_IN */
 207                 /* or SHIFT_OUT, it may be a special escape for SHIFT_IN. */
 208                 /* The test for SHIFT_IN is not necessary, but allows */
 209                 /* an alternate form of UTF-7 where SHIFT_IN is escaped */
 210                 /* by SHIFT_IN. This only works for some values of */
 211                 /* SHIFT_IN. It is so implemented, because this comes */
 212                 /* from the officel unicode book (The Unicode Standard, */
 213                 /* Version 2.0) and so I think, that someone of the */
 214                 /* world has used this feature. */
 215                 if ( !bEnd )
 216                 {
 217                     if ( (c == IMPL_SHIFT_IN_CHAR) || (c == IMPL_SHIFT_OUT_CHAR) )
 218                     {
 219                         /* If no base64 character, and the terminating */
 220                         /* character of the shift sequence was the */
 221                         /* SHIFT_OUT_CHAR, then it't a special escape */
 222                         /* for SHIFT_IN_CHAR. */
 223                         if ( bFirst && (c == IMPL_SHIFT_OUT_CHAR) )
 224                         {
 225                             if ( pDestBuf >= pEndDestBuf )
 226                             {
 227                                 *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 228                                 break;
 229                             }
 230                             *pDestBuf = IMPL_SHIFT_IN_CHAR;
 231                             pDestBuf++;
 232                             bWroteOne = sal_True;
 233                         }
 234
 235                         /* Skip character */
 236                         pSrcBuf++;
 237                         if ( pSrcBuf < pEndSrcBuf )
 238                             c = (unsigned char)*pSrcBuf;
 239                         else
 240                             bEnd = sal_True;
 241                     }
 242                 }
 243
 244                 /* Empty sequence not allowed, so when we don't write one */
 245                 /* valid char, then the sequence is corrupt */
 246                 if ( !bWroteOne )
 247                 {
 248                     /* When no more bytes in the source buffer, then */
 249                     /* this buffer may be to small */
 250                     if ( bEnd )
 251                         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL;
 252                     else
 253                     {
 254                         *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
 255                         if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
 256                         {
 257                             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 258                             break;
 259                         }
 260                         /* We insert here no default char, because I think */
 261                         /* this is better to ignore this */
 262                     }
 263                 }
 264             }
 265             else
 266             {
 267                 /* Add 6 Bits from character to the bit buffer */
 268                 nBufferBits += 6;
 269                 nBitBuffer |= ((sal_uInt32)(nBase64Value & 0x3F)) << (32-nBufferBits);
 270                 bFirst = sal_False;
 271             }
 272
 273             /* Extract as many full 16 bit characters as possible from the */
 274             /* bit buffer. */
 275             while ( (pDestBuf < pEndDestBuf) && (nBufferBits >= 16) )
 276             {
 277                 nBitBufferTemp = nBitBuffer >> (32-16);
 278                 *pDestBuf = (sal_Unicode)((nBitBufferTemp) & 0xFFFF);
 279                 pDestBuf++;
 280                 nBitBuffer <<= 16;
 281                 nBufferBits -= 16;
 282                 bWroteOne = sal_True;
 283             }
 284
 285             if ( nBufferBits >= 16 )
 286             {
 287                 *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 288                 break;
 289             }
 290
 291             if ( bBase64End )
 292             {
 293                 /* Sequence ended and we have some bits, then the */
 294                 /* sequence is corrupted */
 295                 if ( nBufferBits && nBitBuffer )
 296                 {
 297                     /* When no more bytes in the source buffer, then */
 298                     /* this buffer may be to small */
 299                     if ( bEnd )
 300                         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL;
 301                     else
 302                     {
 303                         *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
 304                         if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
 305                         {
 306                             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 307                             break;
 308                         }
 309                         else if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) != RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
 310                         {
 311                             if ( pDestBuf >= pEndDestBuf )
 312                             {
 313                                 *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 314                                 break;
 315                             }
 316                             *pDestBuf++
 317                                 = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 318                         }
 319                     }
 320
 321                 }
 322
 323                 nBitBuffer = 0;
 324                 nBufferBits = 0;
 325             }
 326         }
 327
 328         if ( !bEnd )
 329         {
 330             if ( !bShifted )
 331             {
 332                 if ( c == IMPL_SHIFT_IN_CHAR )
 333                 {
 334                     bShifted    = sal_True;
 335                     bFirst      = sal_True;
 336                     bWroteOne   = sal_False;
 337                 }
 338                 else
 339                 {
 340                     /* No direct encoded charcater, then the buffer is */
 341                     /* corrupt */
 342                     if ( c > 0x7F )
 343                     {
 344                         *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
 345                         if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
 346                         {
 347                             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
 348                             break;
 349                         }
 350                         else if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) != RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
 351                         {
 352                             if ( pDestBuf >= pEndDestBuf )
 353                             {
 354                                 *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 355                                 break;
 356                             }
 357                             *pDestBuf++
 358                                 = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
 359                         }
 360                     }
 361
 362                     /* Write char to unicode buffer */
 363                     if ( pDestBuf >= pEndDestBuf )
 364                     {
 365                         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
 366                         break;
 367                     }
 368                     *pDestBuf = c;
 369                     pDestBuf++;
 370                 }
 371             }
 372
 373             pSrcBuf++;
 374         }
 375     }
 376     while ( !bEnd );
 377
 378     if ( pContextData )
 379     {
 380         pContextData->mbShifted         = bShifted;
 381         pContextData->mbFirst           = bFirst;
 382         pContextData->mbWroteOne        = bWroteOne;
 383         pContextData->mnBitBuffer       = nBitBuffer;
 384         pContextData->mnBufferBits      = nBufferBits;
 385     }
 386
 387     *pSrcCvtBytes = nSrcBytes - (pEndSrcBuf-pSrcBuf);
 388     return (nDestChars - (pEndDestBuf-pDestBuf));
 389 }
 390
 391 /* ======================================================================= */
 392
 393 struct ImplUTF7FromUCContextData
 394 {
 395     int                     mbShifted;
 396     sal_uInt32              mnBitBuffer;
 397     sal_uInt32              mnBufferBits;
 398 };
 399
 400 /* ----------------------------------------------------------------------- */
 401
 402 void* ImplUTF7CreateUnicodeToTextContext()
 403 {
 404     ImplUTF7FromUCContextData* pContextData = new ImplUTF7FromUCContextData;
 405     pContextData->mbShifted         = sal_False;
 406     pContextData->mnBitBuffer       = 0;
 407     pContextData->mnBufferBits      = 0;
 408     return pContextData;
 409 }
 410
 411 /* ----------------------------------------------------------------------- */
 412
 413 void ImplUTF7DestroyUnicodeToTextContext( void* pContext )
 414 {
 415     delete static_cast< ImplUTF7FromUCContextData * >(pContext);
 416 }
 417
 418 /* ----------------------------------------------------------------------- */
 419
 420 void ImplUTF7ResetUnicodeToTextContext( void* pContext )
 421 {
 422     ImplUTF7FromUCContextData* pContextData = (ImplUTF7FromUCContextData*)pContext;
 423     pContextData->mbShifted         = sal_False;
 424     pContextData->mnBitBuffer       = 0;
 425     pContextData->mnBufferBits      = 0;
 426 }
 427
 428 /* ----------------------------------------------------------------------- */
 429
 430 sal_Size ImplUnicodeToUTF7( SAL_UNUSED_PARAMETER const void*, void* pContext,
 431                             const sal_Unicode* pSrcBuf, sal_Size nSrcChars,
 432                             char* pDestBuf, sal_Size nDestBytes,
 433                             SAL_UNUSED_PARAMETER sal_uInt32, sal_uInt32* pInfo,
 434                             sal_Size* pSrcCvtChars )
 435 {
 436     ImplUTF7FromUCContextData*  pContextData = (ImplUTF7FromUCContextData*)pContext;
 437     sal_Unicode                 c = '\0';
 438     int                         bEnd = sal_False;
 439     int                         bShifted;
 440     bool                        bNeedShift;
 441     sal_uInt32                  nBitBuffer;
 442     sal_uInt32                  nBitBufferTemp;
 443     sal_uInt32                  nBufferBits;
 444     char*                   pEndDestBuf;
 445     const sal_Unicode*          pEndSrcBuf;
 446
 447 /* !!! Implementation not finnished !!!
 448     if ( pContextData )
 449     {
 450         bShifted        = pContextData->mbShifted;
 451         nBitBuffer      = pContextData->mnBitBuffer;
 452         nBufferBits     = pContextData->mnBufferBits;
 453     }
 454     else
 455 */
 456     {
 457         bShifted        = sal_False;
 458         nBitBuffer      = 0;
 459         nBufferBits     = 0;
 460     }
 461
 462     *pInfo = 0;
 463     pEndDestBuf = pDestBuf+nDestBytes;
 464     pEndSrcBuf  = pSrcBuf+nSrcChars;
 465     do
 466     {
 467         if ( pSrcBuf < pEndSrcBuf )
 468         {
 469             c = *pSrcBuf;
 470
 471             bNeedShift = (c > 0x7F) || aImplMustShiftTab[c];
 472             if ( bNeedShift && !bShifted )
 473             {
 474                 if ( pDestBuf >= pEndDestBuf )
 475                 {
 476                     *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 477                     break;
 478                 }
 479                 *pDestBuf = IMPL_SHIFT_IN_CHAR;
 480                 pDestBuf++;
 481                 /* Special case handling for SHIFT_IN_CHAR */
 482                 if ( c == IMPL_SHIFT_IN_CHAR )
 483                 {
 484                     if ( pDestBuf >= pEndDestBuf )
 485                     {
 486                         *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 487                         break;
 488                     }
 489                     *pDestBuf = IMPL_SHIFT_OUT_CHAR;
 490                     pDestBuf++;
 491                 }
 492                 else
 493                     bShifted = sal_True;
 494             }
 495         }
 496         else
 497         {
 498             bEnd = sal_True;
 499             bNeedShift = false;
 500         }
 501
 502         if ( bShifted )
 503         {
 504             /* Write the character to the bit buffer, or pad the bit */
 505             /* buffer out to a full base64 character */
 506             if ( bNeedShift )
 507             {
 508                 nBufferBits += 16;
 509                 nBitBuffer |= ((sal_uInt32)c) << (32-nBufferBits);
 510             }
 511             else
 512                 nBufferBits += (6-(nBufferBits%6))%6;
 513
 514             /* Flush out as many full base64 characters as possible */
 515             while ( (pDestBuf < pEndDestBuf) && (nBufferBits >= 6) )
 516             {
 517                 nBitBufferTemp = nBitBuffer >> (32-6);
 518                 *pDestBuf = aImplBase64Tab[nBitBufferTemp];
 519                 pDestBuf++;
 520                 nBitBuffer <<= 6;
 521                 nBufferBits -= 6;
 522             }
 523
 524             if ( nBufferBits >= 6 )
 525             {
 526                 *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 527                 break;
 528             }
 529
 530             /* Write SHIFT_OUT_CHAR, when needed */
 531             if ( !bNeedShift )
 532             {
 533                 if ( pDestBuf >= pEndDestBuf )
 534                 {
 535                     *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 536                     break;
 537                 }
 538                 *pDestBuf = IMPL_SHIFT_OUT_CHAR;
 539                 pDestBuf++;
 540                 bShifted = sal_False;
 541             }
 542         }
 543
 544         if ( !bEnd )
 545         {
 546             /* Character can be directly endcoded */
 547             if ( !bNeedShift )
 548             {
 549                 if ( pDestBuf >= pEndDestBuf )
 550                 {
 551                     *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
 552                     break;
 553                 }
 554                 *pDestBuf = static_cast< char >(static_cast< unsigned char >(c));
 555                 pDestBuf++;
 556             }
 557
 558             pSrcBuf++;
 559         }
 560     }
 561     while ( !bEnd );
 562
 563     if ( pContextData )
 564     {
 565         pContextData->mbShifted     = bShifted;
 566         pContextData->mnBitBuffer   = nBitBuffer;
 567         pContextData->mnBufferBits  = nBufferBits;
 568     }
 569
 570     *pSrcCvtChars = nSrcChars - (pEndSrcBuf-pSrcBuf);
 571     return (nDestBytes - (pEndDestBuf-pDestBuf));
 572 }
 573
 574 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */