?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid potential negative array index access to cached text.
[LibreOffice.git] / sal / textenc / convertbig5hkscs.cxx
blob275e91d3d3b482695032310986933a15cbbc774c
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 <cassert>
23
24 #include <rtl/character.hxx>
25 #include <rtl/textcvt.h>
26 #include <sal/types.h>
27
28 #include "context.hxx"
29 #include "convertbig5hkscs.hxx"
30 #include "converter.hxx"
31 #include "tenchelp.hxx"
32
33 namespace {
34
35 struct ImplBig5HkscsToUnicodeContext
36 {
37 sal_Int32 m_nRow; // 0--255; 0 means none
38 };
39
40 }
41
42 void * ImplCreateBig5HkscsToUnicodeContext()
43 {
44 ImplBig5HkscsToUnicodeContext * pContext =
45 new ImplBig5HkscsToUnicodeContext;
46 pContext->m_nRow = 0;
47 return pContext;
48 }
49
50 void ImplResetBig5HkscsToUnicodeContext(void * pContext)
51 {
52 if (pContext)
53 static_cast< ImplBig5HkscsToUnicodeContext * >(pContext)->m_nRow = 0;
54 }
55
56 void ImplDestroyBig5HkscsToUnicodeContext(void * pContext)
57 {
58 delete static_cast< ImplBig5HkscsToUnicodeContext * >(pContext);
59 }
60
61 sal_Size ImplConvertBig5HkscsToUnicode(void const * pData,
62 void * pContext,
63 char const * pSrcBuf,
64 sal_Size nSrcBytes,
65 sal_Unicode * pDestBuf,
66 sal_Size nDestChars,
67 sal_uInt32 nFlags,
68 sal_uInt32 * pInfo,
69 sal_Size * pSrcCvtBytes)
70 {
71 sal_uInt16 const * pBig5Hkscs2001Data
72 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
73 m_pBig5Hkscs2001ToUnicodeData;
74 sal_Int32 const * pBig5Hkscs2001RowOffsets
75 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
76 m_pBig5Hkscs2001ToUnicodeRowOffsets;
77 ImplDBCSToUniLeadTab const * pBig5Data
78 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
79 m_pBig5ToUnicodeData;
80 sal_Int32 nRow = 0;
81 sal_uInt32 nInfo = 0;
82 sal_Size nConverted = 0;
83 sal_Unicode * pDestBufPtr = pDestBuf;
84 sal_Unicode * pDestBufEnd = pDestBuf + nDestChars;
85 sal_Size startOfCurrentChar = 0;
86
87 if (pContext)
88 nRow = static_cast< ImplBig5HkscsToUnicodeContext * >(pContext)->m_nRow;
89
90 for (; nConverted < nSrcBytes; ++nConverted)
91 {
92 bool bUndefined = true;
93 sal_uInt32 nChar = *reinterpret_cast<unsigned char const *>(pSrcBuf++);
94 if (nRow == 0)
95 if (nChar < 0x80)
96 if (pDestBufPtr != pDestBufEnd) {
97 *pDestBufPtr++ = static_cast<sal_Unicode>(nChar);
98 startOfCurrentChar = nConverted + 1;
99 } else
100 goto no_output;
101 else if (nChar >= 0x81 && nChar <= 0xFE)
102 nRow = nChar;
103 else
104 {
105 bUndefined = false;
106 goto bad_input;
107 }
108 else
109 if ((nChar >= 0x40 && nChar <= 0x7E)
110 || (nChar >= 0xA1 && nChar <= 0xFE))
111 {
112 sal_uInt32 nUnicode = 0xFFFF;
113 sal_Int32 nOffset = pBig5Hkscs2001RowOffsets[nRow];
114 sal_uInt32 nFirst=0;
115 sal_uInt32 nLast=0;
116 if (nOffset != -1)
117 {
118 sal_uInt32 nFirstLast = pBig5Hkscs2001Data[nOffset++];
119 nFirst = nFirstLast & 0xFF;
120 nLast = nFirstLast >> 8;
121 if (nChar >= nFirst && nChar <= nLast)
122 nUnicode
123 = pBig5Hkscs2001Data[nOffset + (nChar - nFirst)];
124 }
125 if (nUnicode == 0xFFFF)
126 {
127 sal_uInt32 n = pBig5Data[nRow].mnTrailStart;
128 if (nChar >= n && nChar <= pBig5Data[nRow].mnTrailEnd)
129 {
130 nUnicode = pBig5Data[nRow].mpToUniTrailTab[nChar - n];
131 if (nUnicode == 0)
132 nUnicode = 0xFFFF;
133 assert(!rtl::isHighSurrogate(nUnicode));
134 }
135 }
136 if (nUnicode == 0xFFFF)
137 {
138 ImplDBCSEUDCData const * p
139 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
140 m_pEudcData;
141 sal_uInt32 nCount
142 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
143 m_nEudcCount;
144 sal_uInt32 i;
145 for (i = 0; i < nCount; ++i)
146 {
147 if (nRow >= p->mnLeadStart && nRow <= p->mnLeadEnd)
148 {
149 if (nChar < p->mnTrail1Start)
150 break;
151 if (nChar <= p->mnTrail1End)
152 {
153 nUnicode
154 = p->mnUniStart
155 + (nRow - p->mnLeadStart)
156 * p->mnTrailRangeCount
157 + (nChar - p->mnTrail1Start);
158 break;
159 }
160 if (p->mnTrailCount < 2
161 || nChar < p->mnTrail2Start)
162 break;
163 if (nChar <= p->mnTrail2End)
164 {
165 nUnicode
166 = p->mnUniStart
167 + (nRow - p->mnLeadStart)
168 * p->mnTrailRangeCount
169 + (nChar - p->mnTrail2Start)
170 + (p->mnTrail1End - p->mnTrail1Start
171 + 1);
172 break;
173 }
174 if (p->mnTrailCount < 3
175 || nChar < p->mnTrail3Start)
176 break;
177 if (nChar <= p->mnTrail3End)
178 {
179 nUnicode
180 = p->mnUniStart
181 + (nRow - p->mnLeadStart)
182 * p->mnTrailRangeCount
183 + (nChar - p->mnTrail3Start)
184 + (p->mnTrail1End - p->mnTrail1Start
185 + 1)
186 + (p->mnTrail2End - p->mnTrail2Start
187 + 1);
188 break;
189 }
190 break;
191 }
192 ++p;
193 }
194 assert(!rtl::isHighSurrogate(nUnicode));
195 }
196 if (nUnicode == 0xFFFF)
197 goto bad_input;
198 if (rtl::isHighSurrogate(nUnicode))
199 if (pDestBufEnd - pDestBufPtr >= 2)
200 {
201 nOffset += nLast - nFirst + 1;
202 nFirst = pBig5Hkscs2001Data[nOffset++];
203 *pDestBufPtr++ = static_cast<sal_Unicode>(nUnicode);
204 *pDestBufPtr++
205 = static_cast<sal_Unicode>(pBig5Hkscs2001Data[
206 nOffset + (nChar - nFirst)]);
207 startOfCurrentChar = nConverted + 1;
208 }
209 else
210 goto no_output;
211 else
212 if (pDestBufPtr != pDestBufEnd) {
213 *pDestBufPtr++ = static_cast<sal_Unicode>(nUnicode);
214 startOfCurrentChar = nConverted + 1;
215 } else
216 goto no_output;
217 nRow = 0;
218 }
219 else
220 {
221 bUndefined = false;
222 goto bad_input;
223 }
224 continue;
225
226 bad_input:
227 switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
228 bUndefined, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
229 &nInfo))
230 {
231 case sal::detail::textenc::BAD_INPUT_STOP:
232 nRow = 0;
233 if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0) {
234 ++nConverted;
235 } else {
236 nConverted = startOfCurrentChar;
237 }
238 break;
239
240 case sal::detail::textenc::BAD_INPUT_CONTINUE:
241 nRow = 0;
242 startOfCurrentChar = nConverted + 1;
243 continue;
244
245 case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
246 goto no_output;
247 }
248 break;
249
250 no_output:
251 --pSrcBuf;
252 nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
253 break;
254 }
255
256 if (nRow != 0
257 && (nInfo & (RTL_TEXTTOUNICODE_INFO_ERROR
258 | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL))
259 == 0)
260 {
261 if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) == 0)
262 nInfo |= RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOOSMALL;
263 else
264 switch (sal::detail::textenc::handleBadInputTextToUnicodeConversion(
265 false, true, 0, nFlags, &pDestBufPtr, pDestBufEnd,
266 &nInfo))
267 {
268 case sal::detail::textenc::BAD_INPUT_STOP:
269 if ((nFlags & RTL_TEXTTOUNICODE_FLAGS_FLUSH) != 0) {
270 nConverted = startOfCurrentChar;
271 }
272 [[fallthrough]];
273 case sal::detail::textenc::BAD_INPUT_CONTINUE:
274 nRow = 0;
275 break;
276
277 case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
278 nInfo |= RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
279 break;
280 }
281 }
282
283 if (pContext)
284 static_cast< ImplBig5HkscsToUnicodeContext * >(pContext)->m_nRow = nRow;
285 if (pInfo)
286 *pInfo = nInfo;
287 if (pSrcCvtBytes)
288 *pSrcCvtBytes = nConverted;
289
290 return pDestBufPtr - pDestBuf;
291 }
292
293 sal_Size ImplConvertUnicodeToBig5Hkscs(void const * pData,
294 void * pContext,
295 sal_Unicode const * pSrcBuf,
296 sal_Size nSrcChars,
297 char * pDestBuf,
298 sal_Size nDestBytes,
299 sal_uInt32 nFlags,
300 sal_uInt32 * pInfo,
301 sal_Size * pSrcCvtChars)
302 {
303 sal_uInt16 const * pBig5Hkscs2001Data
304 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
305 m_pUnicodeToBig5Hkscs2001Data;
306 sal_Int32 const * pBig5Hkscs2001PageOffsets
307 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
308 m_pUnicodeToBig5Hkscs2001PageOffsets;
309 sal_Int32 const * pBig5Hkscs2001PlaneOffsets
310 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
311 m_pUnicodeToBig5Hkscs2001PlaneOffsets;
312 ImplUniToDBCSHighTab const * pBig5Data
313 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
314 m_pUnicodeToBig5Data;
315 sal_Unicode nHighSurrogate = 0;
316 sal_uInt32 nInfo = 0;
317 sal_Size nConverted = 0;
318 char * pDestBufPtr = pDestBuf;
319 char * pDestBufEnd = pDestBuf + nDestBytes;
320
321 if (pContext)
322 nHighSurrogate
323 = static_cast<ImplUnicodeToTextContext *>(pContext)->m_nHighSurrogate;
324
325 for (; nConverted < nSrcChars; ++nConverted)
326 {
327 bool bUndefined = true;
328 sal_uInt32 nChar = *pSrcBuf++;
329 if (nHighSurrogate == 0)
330 {
331 if (rtl::isHighSurrogate(nChar))
332 {
333 nHighSurrogate = static_cast<sal_Unicode>(nChar);
334 continue;
335 }
336 else if (rtl::isLowSurrogate(nChar))
337 {
338 bUndefined = false;
339 goto bad_input;
340 }
341 }
342 else if (rtl::isLowSurrogate(nChar))
343 nChar = rtl::combineSurrogates(nHighSurrogate, nChar);
344 else
345 {
346 bUndefined = false;
347 goto bad_input;
348 }
349
350 assert(rtl::isUnicodeScalarValue(nChar));
351
352 if (nChar < 0x80)
353 if (pDestBufPtr != pDestBufEnd)
354 *pDestBufPtr++ = static_cast< char >(nChar);
355 else
356 goto no_output;
357 else
358 {
359 sal_uInt32 nBytes = 0;
360 sal_Int32 nOffset = pBig5Hkscs2001PlaneOffsets[nChar >> 16];
361 if (nOffset != -1)
362 {
363 nOffset
364 = pBig5Hkscs2001PageOffsets[nOffset + ((nChar & 0xFF00)
365 >> 8)];
366 if (nOffset != -1)
367 {
368 sal_uInt32 nFirstLast = pBig5Hkscs2001Data[nOffset++];
369 sal_uInt32 nFirst = nFirstLast & 0xFF;
370 sal_uInt32 nLast = nFirstLast >> 8;
371 sal_uInt32 nIndex = nChar & 0xFF;
372 if (nIndex >= nFirst && nIndex <= nLast)
373 {
374 nBytes
375 = pBig5Hkscs2001Data[nOffset + (nIndex - nFirst)];
376 }
377 }
378 }
379 if (nBytes == 0)
380 {
381 sal_uInt32 nIndex1 = nChar >> 8;
382 if (nIndex1 < 0x100)
383 {
384 sal_uInt32 nIndex2 = nChar & 0xFF;
385 sal_uInt32 nFirst = pBig5Data[nIndex1].mnLowStart;
386 if (nIndex2 >= nFirst
387 && nIndex2 <= pBig5Data[nIndex1].mnLowEnd)
388 nBytes = pBig5Data[nIndex1].
389 mpToUniTrailTab[nIndex2 - nFirst];
390 }
391 }
392 if (nBytes == 0)
393 {
394 ImplDBCSEUDCData const * p
395 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
396 m_pEudcData;
397 sal_uInt32 nCount
398 = static_cast< ImplBig5HkscsConverterData const * >(pData)->
399 m_nEudcCount;
400 sal_uInt32 i;
401 for (i = 0; i < nCount; ++i) {
402 if (nChar >= p->mnUniStart && nChar <= p->mnUniEnd)
403 {
404 sal_uInt32 nIndex = nChar - p->mnUniStart;
405 sal_uInt32 nLeadOff = nIndex / p->mnTrailRangeCount;
406 sal_uInt32 nTrailOff = nIndex % p->mnTrailRangeCount;
407 sal_uInt32 nSize;
408 nBytes = (p->mnLeadStart + nLeadOff) << 8;
409 nSize = p->mnTrail1End - p->mnTrail1Start + 1;
410 if (nTrailOff < nSize)
411 {
412 nBytes |= p->mnTrail1Start + nTrailOff;
413 break;
414 }
415 nTrailOff -= nSize;
416 nSize = p->mnTrail2End - p->mnTrail2Start + 1;
417 if (nTrailOff < nSize)
418 {
419 nBytes |= p->mnTrail2Start + nTrailOff;
420 break;
421 }
422 nTrailOff -= nSize;
423 nBytes |= p->mnTrail3Start + nTrailOff;
424 break;
425 }
426 ++p;
427 }
428 }
429 if (nBytes == 0)
430 goto bad_input;
431 if (pDestBufEnd - pDestBufPtr >= 2)
432 {
433 *pDestBufPtr++ = static_cast< char >(nBytes >> 8);
434 *pDestBufPtr++ = static_cast< char >(nBytes & 0xFF);
435 }
436 else
437 goto no_output;
438 }
439 nHighSurrogate = 0;
440 continue;
441
442 bad_input:
443 switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
444 bUndefined, nChar, nFlags, &pDestBufPtr, pDestBufEnd,
445 &nInfo, nullptr, 0, nullptr))
446 {
447 case sal::detail::textenc::BAD_INPUT_STOP:
448 nHighSurrogate = 0;
449 break;
450
451 case sal::detail::textenc::BAD_INPUT_CONTINUE:
452 nHighSurrogate = 0;
453 continue;
454
455 case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
456 goto no_output;
457 }
458 break;
459
460 no_output:
461 --pSrcBuf;
462 nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
463 break;
464 }
465
466 if (nHighSurrogate != 0
467 && (nInfo & (RTL_UNICODETOTEXT_INFO_ERROR
468 | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL))
469 == 0)
470 {
471 if ((nFlags & RTL_UNICODETOTEXT_FLAGS_FLUSH) != 0)
472 nInfo |= RTL_UNICODETOTEXT_INFO_SRCBUFFERTOSMALL;
473 else
474 switch (sal::detail::textenc::handleBadInputUnicodeToTextConversion(
475 false, 0, nFlags, &pDestBufPtr, pDestBufEnd, &nInfo,
476 nullptr, 0, nullptr))
477 {
478 case sal::detail::textenc::BAD_INPUT_STOP:
479 case sal::detail::textenc::BAD_INPUT_CONTINUE:
480 nHighSurrogate = 0;
481 break;
482
483 case sal::detail::textenc::BAD_INPUT_NO_OUTPUT:
484 nInfo |= RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
485 break;
486 }
487 }
488
489 if (pContext)
490 static_cast<ImplUnicodeToTextContext *>(pContext)->m_nHighSurrogate
491 = nHighSurrogate;
492 if (pInfo)
493 *pInfo = nInfo;
494 if (pSrcCvtChars)
495 *pSrcCvtChars = nConverted;
496
497 return pDestBufPtr - pDestBuf;
498 }
499
500 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE