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