Line data Source code
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 : bool mbShifted;
97 : bool mbFirst;
98 : bool mbWroteOne;
99 : sal_uInt32 mnBitBuffer;
100 : sal_uInt32 mnBufferBits;
101 : };
102 :
103 : /* ----------------------------------------------------------------------- */
104 :
105 0 : void* ImplUTF7CreateUTF7TextToUnicodeContext()
106 : {
107 0 : ImplUTF7ToUCContextData* pContextData = new ImplUTF7ToUCContextData;
108 0 : pContextData->mbShifted = false;
109 0 : pContextData->mbFirst = false;
110 0 : pContextData->mbWroteOne = false;
111 0 : pContextData->mnBitBuffer = 0;
112 0 : pContextData->mnBufferBits = 0;
113 0 : return pContextData;
114 : }
115 :
116 : /* ----------------------------------------------------------------------- */
117 :
118 0 : void ImplUTF7DestroyTextToUnicodeContext( void* pContext )
119 : {
120 0 : delete static_cast< ImplUTF7ToUCContextData * >(pContext);
121 0 : }
122 :
123 : /* ----------------------------------------------------------------------- */
124 :
125 0 : void ImplUTF7ResetTextToUnicodeContext( void* pContext )
126 : {
127 0 : ImplUTF7ToUCContextData* pContextData = static_cast<ImplUTF7ToUCContextData*>(pContext);
128 0 : pContextData->mbShifted = false;
129 0 : pContextData->mbFirst = false;
130 0 : pContextData->mbWroteOne = false;
131 0 : pContextData->mnBitBuffer = 0;
132 0 : pContextData->mnBufferBits = 0;
133 0 : }
134 :
135 : /* ----------------------------------------------------------------------- */
136 :
137 0 : 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 0 : ImplUTF7ToUCContextData* pContextData = static_cast<ImplUTF7ToUCContextData*>(pContext);
144 0 : unsigned char c ='\0';
145 0 : unsigned char nBase64Value = 0;
146 0 : bool bEnd = false;
147 : bool bShifted;
148 : bool bFirst;
149 : bool bWroteOne;
150 : bool 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 0 : bShifted = false;
170 0 : bFirst = false;
171 0 : bWroteOne = false;
172 0 : nBitBuffer = 0;
173 0 : nBufferBits = 0;
174 : }
175 :
176 0 : *pInfo = 0;
177 0 : pEndDestBuf = pDestBuf+nDestChars;
178 0 : pEndSrcBuf = pSrcBuf+nSrcBytes;
179 0 : do
180 : {
181 0 : if ( pSrcBuf < pEndSrcBuf )
182 : {
183 0 : c = (unsigned char)*pSrcBuf;
184 :
185 : /* End, when not a base64 character */
186 0 : bBase64End = false;
187 0 : if ( c <= 0x7F )
188 : {
189 0 : nBase64Value = aImplBase64IndexTab[c];
190 0 : if ( nBase64Value == 0xFF )
191 0 : bBase64End = true;
192 : }
193 : }
194 : else
195 : {
196 0 : bEnd = true;
197 0 : bBase64End = true;
198 : }
199 :
200 0 : if ( bShifted )
201 : {
202 0 : if ( bBase64End )
203 : {
204 0 : bShifted = 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 0 : if ( !bEnd )
216 : {
217 0 : 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 0 : if ( bFirst && (c == IMPL_SHIFT_OUT_CHAR) )
224 : {
225 0 : if ( pDestBuf >= pEndDestBuf )
226 : {
227 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
228 0 : break;
229 : }
230 0 : *pDestBuf = IMPL_SHIFT_IN_CHAR;
231 0 : pDestBuf++;
232 0 : bWroteOne = true;
233 : }
234 :
235 : /* Skip character */
236 0 : pSrcBuf++;
237 0 : if ( pSrcBuf < pEndSrcBuf )
238 0 : c = (unsigned char)*pSrcBuf;
239 : else
240 0 : bEnd = 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 0 : if ( !bWroteOne )
247 : {
248 : /* When no more bytes in the source buffer, then */
249 : /* this buffer may be to small */
250 0 : if ( bEnd )
251 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL;
252 : else
253 : {
254 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
255 0 : if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
256 : {
257 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
258 0 : 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 0 : nBufferBits += 6;
269 0 : nBitBuffer |= ((sal_uInt32)(nBase64Value & 0x3F)) << (32-nBufferBits);
270 0 : bFirst = false;
271 : }
272 :
273 : /* Extract as many full 16 bit characters as possible from the */
274 : /* bit buffer. */
275 0 : while ( (pDestBuf < pEndDestBuf) && (nBufferBits >= 16) )
276 : {
277 0 : nBitBufferTemp = nBitBuffer >> (32-16);
278 0 : *pDestBuf = (sal_Unicode)((nBitBufferTemp) & 0xFFFF);
279 0 : pDestBuf++;
280 0 : nBitBuffer <<= 16;
281 0 : nBufferBits -= 16;
282 0 : bWroteOne = true;
283 : }
284 :
285 0 : if ( nBufferBits >= 16 )
286 : {
287 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
288 0 : break;
289 : }
290 :
291 0 : if ( bBase64End )
292 : {
293 : /* Sequence ended and we have some bits, then the */
294 : /* sequence is corrupted */
295 0 : if ( nBufferBits && nBitBuffer )
296 : {
297 : /* When no more bytes in the source buffer, then */
298 : /* this buffer may be to small */
299 0 : if ( bEnd )
300 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL;
301 : else
302 : {
303 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
304 0 : if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
305 : {
306 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
307 0 : break;
308 : }
309 0 : else if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) != RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
310 : {
311 0 : if ( pDestBuf >= pEndDestBuf )
312 : {
313 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
314 0 : break;
315 : }
316 : *pDestBuf++
317 0 : = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
318 : }
319 : }
320 :
321 : }
322 :
323 0 : nBitBuffer = 0;
324 0 : nBufferBits = 0;
325 : }
326 : }
327 :
328 0 : if ( !bEnd )
329 : {
330 0 : if ( !bShifted )
331 : {
332 0 : if ( c == IMPL_SHIFT_IN_CHAR )
333 : {
334 0 : bShifted = true;
335 0 : bFirst = true;
336 0 : bWroteOne = false;
337 : }
338 : else
339 : {
340 : /* No direct encoded charcater, then the buffer is */
341 : /* corrupt */
342 0 : if ( c > 0x7F )
343 : {
344 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_INVALID;
345 0 : if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) == RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR )
346 : {
347 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR;
348 0 : break;
349 : }
350 0 : else if ( (nFlags & RTL_TEXTTOUNICODE_FLAGS_INVALID_MASK) != RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE )
351 : {
352 0 : if ( pDestBuf >= pEndDestBuf )
353 : {
354 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
355 0 : break;
356 : }
357 : *pDestBuf++
358 0 : = RTL_TEXTENC_UNICODE_REPLACEMENT_CHARACTER;
359 : }
360 : }
361 :
362 : /* Write char to unicode buffer */
363 0 : if ( pDestBuf >= pEndDestBuf )
364 : {
365 0 : *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
366 0 : break;
367 : }
368 0 : *pDestBuf = c;
369 0 : pDestBuf++;
370 : }
371 : }
372 :
373 0 : pSrcBuf++;
374 : }
375 : }
376 0 : while ( !bEnd );
377 :
378 0 : if ( pContextData )
379 : {
380 0 : pContextData->mbShifted = bShifted;
381 0 : pContextData->mbFirst = bFirst;
382 0 : pContextData->mbWroteOne = bWroteOne;
383 0 : pContextData->mnBitBuffer = nBitBuffer;
384 0 : pContextData->mnBufferBits = nBufferBits;
385 : }
386 :
387 0 : *pSrcCvtBytes = nSrcBytes - (pEndSrcBuf-pSrcBuf);
388 0 : return (nDestChars - (pEndDestBuf-pDestBuf));
389 : }
390 :
391 : /* ======================================================================= */
392 :
393 : struct ImplUTF7FromUCContextData
394 : {
395 : bool mbShifted;
396 : sal_uInt32 mnBitBuffer;
397 : sal_uInt32 mnBufferBits;
398 : };
399 :
400 : /* ----------------------------------------------------------------------- */
401 :
402 0 : void* ImplUTF7CreateUnicodeToTextContext()
403 : {
404 0 : ImplUTF7FromUCContextData* pContextData = new ImplUTF7FromUCContextData;
405 0 : pContextData->mbShifted = false;
406 0 : pContextData->mnBitBuffer = 0;
407 0 : pContextData->mnBufferBits = 0;
408 0 : return pContextData;
409 : }
410 :
411 : /* ----------------------------------------------------------------------- */
412 :
413 0 : void ImplUTF7DestroyUnicodeToTextContext( void* pContext )
414 : {
415 0 : delete static_cast< ImplUTF7FromUCContextData * >(pContext);
416 0 : }
417 :
418 : /* ----------------------------------------------------------------------- */
419 :
420 0 : void ImplUTF7ResetUnicodeToTextContext( void* pContext )
421 : {
422 0 : ImplUTF7FromUCContextData* pContextData = static_cast<ImplUTF7FromUCContextData*>(pContext);
423 0 : pContextData->mbShifted = false;
424 0 : pContextData->mnBitBuffer = 0;
425 0 : pContextData->mnBufferBits = 0;
426 0 : }
427 :
428 : /* ----------------------------------------------------------------------- */
429 :
430 19 : 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 19 : ImplUTF7FromUCContextData* pContextData = static_cast<ImplUTF7FromUCContextData*>(pContext);
437 19 : sal_Unicode c = '\0';
438 19 : bool bEnd = false;
439 : bool 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 19 : bShifted = false;
458 19 : nBitBuffer = 0;
459 19 : nBufferBits = 0;
460 : }
461 :
462 19 : *pInfo = 0;
463 19 : pEndDestBuf = pDestBuf+nDestBytes;
464 19 : pEndSrcBuf = pSrcBuf+nSrcChars;
465 247 : do
466 : {
467 248 : if ( pSrcBuf < pEndSrcBuf )
468 : {
469 230 : c = *pSrcBuf;
470 :
471 230 : bNeedShift = (c > 0x7F) || aImplMustShiftTab[c];
472 230 : if ( bNeedShift && !bShifted )
473 : {
474 2 : if ( pDestBuf >= pEndDestBuf )
475 : {
476 0 : *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
477 0 : break;
478 : }
479 2 : *pDestBuf = IMPL_SHIFT_IN_CHAR;
480 2 : pDestBuf++;
481 : /* Special case handling for SHIFT_IN_CHAR */
482 2 : if ( c == IMPL_SHIFT_IN_CHAR )
483 : {
484 0 : if ( pDestBuf >= pEndDestBuf )
485 : {
486 0 : *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
487 0 : break;
488 : }
489 0 : *pDestBuf = IMPL_SHIFT_OUT_CHAR;
490 0 : pDestBuf++;
491 : }
492 : else
493 2 : bShifted = true;
494 : }
495 : }
496 : else
497 : {
498 18 : bEnd = true;
499 18 : bNeedShift = false;
500 : }
501 :
502 248 : if ( bShifted )
503 : {
504 : /* Write the character to the bit buffer, or pad the bit */
505 : /* buffer out to a full base64 character */
506 3 : if ( bNeedShift )
507 : {
508 2 : nBufferBits += 16;
509 2 : nBitBuffer |= ((sal_uInt32)c) << (32-nBufferBits);
510 : }
511 : else
512 1 : nBufferBits += (6-(nBufferBits%6))%6;
513 :
514 : /* Flush out as many full base64 characters as possible */
515 10 : while ( (pDestBuf < pEndDestBuf) && (nBufferBits >= 6) )
516 : {
517 4 : nBitBufferTemp = nBitBuffer >> (32-6);
518 4 : *pDestBuf = aImplBase64Tab[nBitBufferTemp];
519 4 : pDestBuf++;
520 4 : nBitBuffer <<= 6;
521 4 : nBufferBits -= 6;
522 : }
523 :
524 3 : if ( nBufferBits >= 6 )
525 : {
526 1 : *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
527 1 : break;
528 : }
529 :
530 : /* Write SHIFT_OUT_CHAR, when needed */
531 2 : if ( !bNeedShift )
532 : {
533 1 : if ( pDestBuf >= pEndDestBuf )
534 : {
535 0 : *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
536 0 : break;
537 : }
538 1 : *pDestBuf = IMPL_SHIFT_OUT_CHAR;
539 1 : pDestBuf++;
540 1 : bShifted = false;
541 : }
542 : }
543 :
544 247 : if ( !bEnd )
545 : {
546 : /* Character can be directly endcoded */
547 229 : if ( !bNeedShift )
548 : {
549 228 : if ( pDestBuf >= pEndDestBuf )
550 : {
551 0 : *pInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
552 0 : break;
553 : }
554 228 : *pDestBuf = static_cast< char >(static_cast< unsigned char >(c));
555 228 : pDestBuf++;
556 : }
557 :
558 229 : pSrcBuf++;
559 : }
560 : }
561 247 : while ( !bEnd );
562 :
563 19 : if ( pContextData )
564 : {
565 0 : pContextData->mbShifted = bShifted;
566 0 : pContextData->mnBitBuffer = nBitBuffer;
567 0 : pContextData->mnBufferBits = nBufferBits;
568 : }
569 :
570 19 : *pSrcCvtChars = nSrcChars - (pEndSrcBuf-pSrcBuf);
571 19 : return (nDestBytes - (pEndDestBuf-pDestBuf));
572 : }
573 :
574 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
