The Tor Browser / file comparison

comparison: intl/icu/source/common/ucnv.c

intl/icu/source/common/ucnv.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1960033e9e77
1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 1998-2013, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************
8 *
9 * ucnv.c:
10 * Implements APIs for the ICU's codeset conversion library;
11 * mostly calls through internal functions;
12 * created by Bertrand A. Damiba
13 *
14 * Modification History:
15 *
16 * Date Name Description
17 * 04/04/99 helena Fixed internal header inclusion.
18 * 05/09/00 helena Added implementation to handle fallback mappings.
19 * 06/20/2000 helena OS/400 port changes; mostly typecast.
20 */
21
22 #include "unicode/utypes.h"
23
24 #if !UCONFIG_NO_CONVERSION
25
26 #include "unicode/ustring.h"
27 #include "unicode/ucnv.h"
28 #include "unicode/ucnv_err.h"
29 #include "unicode/uset.h"
30 #include "unicode/utf.h"
31 #include "unicode/utf16.h"
32 #include "putilimp.h"
33 #include "cmemory.h"
34 #include "cstring.h"
35 #include "uassert.h"
36 #include "utracimp.h"
37 #include "ustr_imp.h"
38 #include "ucnv_imp.h"
39 #include "ucnv_cnv.h"
40 #include "ucnv_bld.h"
41
42 /* size of intermediate and preflighting buffers in ucnv_convert() */
43 #define CHUNK_SIZE 1024
44
45 typedef struct UAmbiguousConverter {
46 const char *name;
47 const UChar variant5c;
48 } UAmbiguousConverter;
49
50 static const UAmbiguousConverter ambiguousConverters[]={
51 { "ibm-897_P100-1995", 0xa5 },
52 { "ibm-942_P120-1999", 0xa5 },
53 { "ibm-943_P130-1999", 0xa5 },
54 { "ibm-946_P100-1995", 0xa5 },
55 { "ibm-33722_P120-1999", 0xa5 },
56 { "ibm-1041_P100-1995", 0xa5 },
57 /*{ "ibm-54191_P100-2006", 0xa5 },*/
58 /*{ "ibm-62383_P100-2007", 0xa5 },*/
59 /*{ "ibm-891_P100-1995", 0x20a9 },*/
60 { "ibm-944_P100-1995", 0x20a9 },
61 { "ibm-949_P110-1999", 0x20a9 },
62 { "ibm-1363_P110-1997", 0x20a9 },
63 { "ISO_2022,locale=ko,version=0", 0x20a9 },
64 { "ibm-1088_P100-1995", 0x20a9 }
65 };
66
67 /*Calls through createConverter */
68 U_CAPI UConverter* U_EXPORT2
69 ucnv_open (const char *name,
70 UErrorCode * err)
71 {
72 UConverter *r;
73
74 if (err == NULL || U_FAILURE (*err)) {
75 return NULL;
76 }
77
78 r = ucnv_createConverter(NULL, name, err);
79 return r;
80 }
81
82 U_CAPI UConverter* U_EXPORT2
83 ucnv_openPackage (const char *packageName, const char *converterName, UErrorCode * err)
84 {
85 return ucnv_createConverterFromPackage(packageName, converterName, err);
86 }
87
88 /*Extracts the UChar* to a char* and calls through createConverter */
89 U_CAPI UConverter* U_EXPORT2
90 ucnv_openU (const UChar * name,
91 UErrorCode * err)
92 {
93 char asciiName[UCNV_MAX_CONVERTER_NAME_LENGTH];
94
95 if (err == NULL || U_FAILURE(*err))
96 return NULL;
97 if (name == NULL)
98 return ucnv_open (NULL, err);
99 if (u_strlen(name) >= UCNV_MAX_CONVERTER_NAME_LENGTH)
100 {
101 *err = U_ILLEGAL_ARGUMENT_ERROR;
102 return NULL;
103 }
104 return ucnv_open(u_austrcpy(asciiName, name), err);
105 }
106
107 /* Copy the string that is represented by the UConverterPlatform enum
108 * @param platformString An output buffer
109 * @param platform An enum representing a platform
110 * @return the length of the copied string.
111 */
112 static int32_t
113 ucnv_copyPlatformString(char *platformString, UConverterPlatform pltfrm)
114 {
115 switch (pltfrm)
116 {
117 case UCNV_IBM:
118 uprv_strcpy(platformString, "ibm-");
119 return 4;
120 case UCNV_UNKNOWN:
121 break;
122 }
123
124 /* default to empty string */
125 *platformString = 0;
126 return 0;
127 }
128
129 /*Assumes a $platform-#codepage.$CONVERTER_FILE_EXTENSION scheme and calls
130 *through createConverter*/
131 U_CAPI UConverter* U_EXPORT2
132 ucnv_openCCSID (int32_t codepage,
133 UConverterPlatform platform,
134 UErrorCode * err)
135 {
136 char myName[UCNV_MAX_CONVERTER_NAME_LENGTH];
137 int32_t myNameLen;
138
139 if (err == NULL || U_FAILURE (*err))
140 return NULL;
141
142 /* ucnv_copyPlatformString could return "ibm-" or "cp" */
143 myNameLen = ucnv_copyPlatformString(myName, platform);
144 T_CString_integerToString(myName + myNameLen, codepage, 10);
145
146 return ucnv_createConverter(NULL, myName, err);
147 }
148
149 /* Creating a temporary stack-based object that can be used in one thread,
150 and created from a converter that is shared across threads.
151 */
152
153 U_CAPI UConverter* U_EXPORT2
154 ucnv_safeClone(const UConverter* cnv, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
155 {
156 UConverter *localConverter, *allocatedConverter;
157 int32_t stackBufferSize;
158 int32_t bufferSizeNeeded;
159 char *stackBufferChars = (char *)stackBuffer;
160 UErrorCode cbErr;
161 UConverterToUnicodeArgs toUArgs = {
162 sizeof(UConverterToUnicodeArgs),
163 TRUE,
164 NULL,
165 NULL,
166 NULL,
167 NULL,
168 NULL,
169 NULL
170 };
171 UConverterFromUnicodeArgs fromUArgs = {
172 sizeof(UConverterFromUnicodeArgs),
173 TRUE,
174 NULL,
175 NULL,
176 NULL,
177 NULL,
178 NULL,
179 NULL
180 };
181
182 UTRACE_ENTRY_OC(UTRACE_UCNV_CLONE);
183
184 if (status == NULL || U_FAILURE(*status)){
185 UTRACE_EXIT_STATUS(status? *status: U_ILLEGAL_ARGUMENT_ERROR);
186 return NULL;
187 }
188
189 if (cnv == NULL) {
190 *status = U_ILLEGAL_ARGUMENT_ERROR;
191 UTRACE_EXIT_STATUS(*status);
192 return NULL;
193 }
194
195 UTRACE_DATA3(UTRACE_OPEN_CLOSE, "clone converter %s at %p into stackBuffer %p",
196 ucnv_getName(cnv, status), cnv, stackBuffer);
197
198 if (cnv->sharedData->impl->safeClone != NULL) {
199 /* call the custom safeClone function for sizing */
200 bufferSizeNeeded = 0;
201 cnv->sharedData->impl->safeClone(cnv, NULL, &bufferSizeNeeded, status);
202 if (U_FAILURE(*status)) {
203 UTRACE_EXIT_STATUS(*status);
204 return NULL;
205 }
206 }
207 else
208 {
209 /* inherent sizing */
210 bufferSizeNeeded = sizeof(UConverter);
211 }
212
213 if (pBufferSize == NULL) {
214 stackBufferSize = 1;
215 pBufferSize = &stackBufferSize;
216 } else {
217 stackBufferSize = *pBufferSize;
218 if (stackBufferSize <= 0){ /* 'preflighting' request - set needed size into *pBufferSize */
219 *pBufferSize = bufferSizeNeeded;
220 UTRACE_EXIT_VALUE(bufferSizeNeeded);
221 return NULL;
222 }
223 }
224
225
226 /* Pointers on 64-bit platforms need to be aligned
227 * on a 64-bit boundary in memory.
228 */
229 if (U_ALIGNMENT_OFFSET(stackBuffer) != 0) {
230 int32_t offsetUp = (int32_t)U_ALIGNMENT_OFFSET_UP(stackBufferChars);
231 if(stackBufferSize > offsetUp) {
232 stackBufferSize -= offsetUp;
233 stackBufferChars += offsetUp;
234 } else {
235 /* prevent using the stack buffer but keep the size > 0 so that we do not just preflight */
236 stackBufferSize = 1;
237 }
238 }
239
240 stackBuffer = (void *)stackBufferChars;
241
242 /* Now, see if we must allocate any memory */
243 if (stackBufferSize < bufferSizeNeeded || stackBuffer == NULL)
244 {
245 /* allocate one here...*/
246 localConverter = allocatedConverter = (UConverter *) uprv_malloc (bufferSizeNeeded);
247
248 if(localConverter == NULL) {
249 *status = U_MEMORY_ALLOCATION_ERROR;
250 UTRACE_EXIT_STATUS(*status);
251 return NULL;
252 }
253 *status = U_SAFECLONE_ALLOCATED_WARNING;
254
255 /* record the fact that memory was allocated */
256 *pBufferSize = bufferSizeNeeded;
257 } else {
258 /* just use the stack buffer */
259 localConverter = (UConverter*) stackBuffer;
260 allocatedConverter = NULL;
261 }
262
263 uprv_memset(localConverter, 0, bufferSizeNeeded);
264
265 /* Copy initial state */
266 uprv_memcpy(localConverter, cnv, sizeof(UConverter));
267 localConverter->isCopyLocal = localConverter->isExtraLocal = FALSE;
268
269 /* copy the substitution string */
270 if (cnv->subChars == (uint8_t *)cnv->subUChars) {
271 localConverter->subChars = (uint8_t *)localConverter->subUChars;
272 } else {
273 localConverter->subChars = (uint8_t *)uprv_malloc(UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
274 if (localConverter->subChars == NULL) {
275 uprv_free(allocatedConverter);
276 UTRACE_EXIT_STATUS(*status);
277 return NULL;
278 }
279 uprv_memcpy(localConverter->subChars, cnv->subChars, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
280 }
281
282 /* now either call the safeclone fcn or not */
283 if (cnv->sharedData->impl->safeClone != NULL) {
284 /* call the custom safeClone function */
285 localConverter = cnv->sharedData->impl->safeClone(cnv, localConverter, pBufferSize, status);
286 }
287
288 if(localConverter==NULL || U_FAILURE(*status)) {
289 if (allocatedConverter != NULL && allocatedConverter->subChars != (uint8_t *)allocatedConverter->subUChars) {
290 uprv_free(allocatedConverter->subChars);
291 }
292 uprv_free(allocatedConverter);
293 UTRACE_EXIT_STATUS(*status);
294 return NULL;
295 }
296
297 /* increment refcount of shared data if needed */
298 /*
299 Checking whether it's an algorithic converter is okay
300 in multithreaded applications because the value never changes.
301 Don't check referenceCounter for any other value.
302 */
303 if (cnv->sharedData->referenceCounter != ~0) {
304 ucnv_incrementRefCount(cnv->sharedData);
305 }
306
307 if(localConverter == (UConverter*)stackBuffer) {
308 /* we're using user provided data - set to not destroy */
309 localConverter->isCopyLocal = TRUE;
310 }
311
312 /* allow callback functions to handle any memory allocation */
313 toUArgs.converter = fromUArgs.converter = localConverter;
314 cbErr = U_ZERO_ERROR;
315 cnv->fromCharErrorBehaviour(cnv->toUContext, &toUArgs, NULL, 0, UCNV_CLONE, &cbErr);
316 cbErr = U_ZERO_ERROR;
317 cnv->fromUCharErrorBehaviour(cnv->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_CLONE, &cbErr);
318
319 UTRACE_EXIT_PTR_STATUS(localConverter, *status);
320 return localConverter;
321 }
322
323
324
325 /*Decreases the reference counter in the shared immutable section of the object
326 *and frees the mutable part*/
327
328 U_CAPI void U_EXPORT2
329 ucnv_close (UConverter * converter)
330 {
331 UErrorCode errorCode = U_ZERO_ERROR;
332
333 UTRACE_ENTRY_OC(UTRACE_UCNV_CLOSE);
334
335 if (converter == NULL)
336 {
337 UTRACE_EXIT();
338 return;
339 }
340
341 UTRACE_DATA3(UTRACE_OPEN_CLOSE, "close converter %s at %p, isCopyLocal=%b",
342 ucnv_getName(converter, &errorCode), converter, converter->isCopyLocal);
343
344 /* In order to speed up the close, only call the callbacks when they have been changed.
345 This performance check will only work when the callbacks are set within a shared library
346 or from user code that statically links this code. */
347 /* first, notify the callback functions that the converter is closed */
348 if (converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK) {
349 UConverterToUnicodeArgs toUArgs = {
350 sizeof(UConverterToUnicodeArgs),
351 TRUE,
352 NULL,
353 NULL,
354 NULL,
355 NULL,
356 NULL,
357 NULL
358 };
359
360 toUArgs.converter = converter;
361 errorCode = U_ZERO_ERROR;
362 converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL, 0, UCNV_CLOSE, &errorCode);
363 }
364 if (converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK) {
365 UConverterFromUnicodeArgs fromUArgs = {
366 sizeof(UConverterFromUnicodeArgs),
367 TRUE,
368 NULL,
369 NULL,
370 NULL,
371 NULL,
372 NULL,
373 NULL
374 };
375 fromUArgs.converter = converter;
376 errorCode = U_ZERO_ERROR;
377 converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_CLOSE, &errorCode);
378 }
379
380 if (converter->sharedData->impl->close != NULL) {
381 converter->sharedData->impl->close(converter);
382 }
383
384 if (converter->subChars != (uint8_t *)converter->subUChars) {
385 uprv_free(converter->subChars);
386 }
387
388 /*
389 Checking whether it's an algorithic converter is okay
390 in multithreaded applications because the value never changes.
391 Don't check referenceCounter for any other value.
392 */
393 if (converter->sharedData->referenceCounter != ~0) {
394 ucnv_unloadSharedDataIfReady(converter->sharedData);
395 }
396
397 if(!converter->isCopyLocal){
398 uprv_free(converter);
399 }
400
401 UTRACE_EXIT();
402 }
403
404 /*returns a single Name from the list, will return NULL if out of bounds
405 */
406 U_CAPI const char* U_EXPORT2
407 ucnv_getAvailableName (int32_t n)
408 {
409 if (0 <= n && n <= 0xffff) {
410 UErrorCode err = U_ZERO_ERROR;
411 const char *name = ucnv_bld_getAvailableConverter((uint16_t)n, &err);
412 if (U_SUCCESS(err)) {
413 return name;
414 }
415 }
416 return NULL;
417 }
418
419 U_CAPI int32_t U_EXPORT2
420 ucnv_countAvailable ()
421 {
422 UErrorCode err = U_ZERO_ERROR;
423 return ucnv_bld_countAvailableConverters(&err);
424 }
425
426 U_CAPI void U_EXPORT2
427 ucnv_getSubstChars (const UConverter * converter,
428 char *mySubChar,
429 int8_t * len,
430 UErrorCode * err)
431 {
432 if (U_FAILURE (*err))
433 return;
434
435 if (converter->subCharLen <= 0) {
436 /* Unicode string or empty string from ucnv_setSubstString(). */
437 *len = 0;
438 return;
439 }
440
441 if (*len < converter->subCharLen) /*not enough space in subChars */
442 {
443 *err = U_INDEX_OUTOFBOUNDS_ERROR;
444 return;
445 }
446
447 uprv_memcpy (mySubChar, converter->subChars, converter->subCharLen); /*fills in the subchars */
448 *len = converter->subCharLen; /*store # of bytes copied to buffer */
449 }
450
451 U_CAPI void U_EXPORT2
452 ucnv_setSubstChars (UConverter * converter,
453 const char *mySubChar,
454 int8_t len,
455 UErrorCode * err)
456 {
457 if (U_FAILURE (*err))
458 return;
459
460 /*Makes sure that the subChar is within the codepages char length boundaries */
461 if ((len > converter->sharedData->staticData->maxBytesPerChar)
462 || (len < converter->sharedData->staticData->minBytesPerChar))
463 {
464 *err = U_ILLEGAL_ARGUMENT_ERROR;
465 return;
466 }
467
468 uprv_memcpy (converter->subChars, mySubChar, len); /*copies the subchars */
469 converter->subCharLen = len; /*sets the new len */
470
471 /*
472 * There is currently (2001Feb) no separate API to set/get subChar1.
473 * In order to always have subChar written after it is explicitly set,
474 * we set subChar1 to 0.
475 */
476 converter->subChar1 = 0;
477
478 return;
479 }
480
481 U_CAPI void U_EXPORT2
482 ucnv_setSubstString(UConverter *cnv,
483 const UChar *s,
484 int32_t length,
485 UErrorCode *err) {
486 UAlignedMemory cloneBuffer[U_CNV_SAFECLONE_BUFFERSIZE / sizeof(UAlignedMemory) + 1];
487 char chars[UCNV_ERROR_BUFFER_LENGTH];
488
489 UConverter *clone;
490 uint8_t *subChars;
491 int32_t cloneSize, length8;
492
493 /* Let the following functions check all arguments. */
494 cloneSize = sizeof(cloneBuffer);
495 clone = ucnv_safeClone(cnv, cloneBuffer, &cloneSize, err);
496 ucnv_setFromUCallBack(clone, UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, err);
497 length8 = ucnv_fromUChars(clone, chars, (int32_t)sizeof(chars), s, length, err);
498 ucnv_close(clone);
499 if (U_FAILURE(*err)) {
500 return;
501 }
502
503 if (cnv->sharedData->impl->writeSub == NULL
504 #if !UCONFIG_NO_LEGACY_CONVERSION
505 || (cnv->sharedData->staticData->conversionType == UCNV_MBCS &&
506 ucnv_MBCSGetType(cnv) != UCNV_EBCDIC_STATEFUL)
507 #endif
508 ) {
509 /* The converter is not stateful. Store the charset bytes as a fixed string. */
510 subChars = (uint8_t *)chars;
511 } else {
512 /*
513 * The converter has a non-default writeSub() function, indicating
514 * that it is stateful.
515 * Store the Unicode string for on-the-fly conversion for correct
516 * state handling.
517 */
518 if (length > UCNV_ERROR_BUFFER_LENGTH) {
519 /*
520 * Should not occur. The converter should output at least one byte
521 * per UChar, which means that ucnv_fromUChars() should catch all
522 * overflows.
523 */
524 *err = U_BUFFER_OVERFLOW_ERROR;
525 return;
526 }
527 subChars = (uint8_t *)s;
528 if (length < 0) {
529 length = u_strlen(s);
530 }
531 length8 = length * U_SIZEOF_UCHAR;
532 }
533
534 /*
535 * For storing the substitution string, select either the small buffer inside
536 * UConverter or allocate a subChars buffer.
537 */
538 if (length8 > UCNV_MAX_SUBCHAR_LEN) {
539 /* Use a separate buffer for the string. Outside UConverter to not make it too large. */
540 if (cnv->subChars == (uint8_t *)cnv->subUChars) {
541 /* Allocate a new buffer for the string. */
542 cnv->subChars = (uint8_t *)uprv_malloc(UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
543 if (cnv->subChars == NULL) {
544 cnv->subChars = (uint8_t *)cnv->subUChars;
545 *err = U_MEMORY_ALLOCATION_ERROR;
546 return;
547 }
548 uprv_memset(cnv->subChars, 0, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
549 }
550 }
551
552 /* Copy the substitution string into the UConverter or its subChars buffer. */
553 if (length8 == 0) {
554 cnv->subCharLen = 0;
555 } else {
556 uprv_memcpy(cnv->subChars, subChars, length8);
557 if (subChars == (uint8_t *)chars) {
558 cnv->subCharLen = (int8_t)length8;
559 } else /* subChars == s */ {
560 cnv->subCharLen = (int8_t)-length;
561 }
562 }
563
564 /* See comment in ucnv_setSubstChars(). */
565 cnv->subChar1 = 0;
566 }
567
568 /*resets the internal states of a converter
569 *goal : have the same behaviour than a freshly created converter
570 */
571 static void _reset(UConverter *converter, UConverterResetChoice choice,
572 UBool callCallback) {
573 if(converter == NULL) {
574 return;
575 }
576
577 if(callCallback) {
578 /* first, notify the callback functions that the converter is reset */
579 UErrorCode errorCode;
580
581 if(choice<=UCNV_RESET_TO_UNICODE && converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK) {
582 UConverterToUnicodeArgs toUArgs = {
583 sizeof(UConverterToUnicodeArgs),
584 TRUE,
585 NULL,
586 NULL,
587 NULL,
588 NULL,
589 NULL,
590 NULL
591 };
592 toUArgs.converter = converter;
593 errorCode = U_ZERO_ERROR;
594 converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL, 0, UCNV_RESET, &errorCode);
595 }
596 if(choice!=UCNV_RESET_TO_UNICODE && converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK) {
597 UConverterFromUnicodeArgs fromUArgs = {
598 sizeof(UConverterFromUnicodeArgs),
599 TRUE,
600 NULL,
601 NULL,
602 NULL,
603 NULL,
604 NULL,
605 NULL
606 };
607 fromUArgs.converter = converter;
608 errorCode = U_ZERO_ERROR;
609 converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_RESET, &errorCode);
610 }
611 }
612
613 /* now reset the converter itself */
614 if(choice<=UCNV_RESET_TO_UNICODE) {
615 converter->toUnicodeStatus = converter->sharedData->toUnicodeStatus;
616 converter->mode = 0;
617 converter->toULength = 0;
618 converter->invalidCharLength = converter->UCharErrorBufferLength = 0;
619 converter->preToULength = 0;
620 }
621 if(choice!=UCNV_RESET_TO_UNICODE) {
622 converter->fromUnicodeStatus = 0;
623 converter->fromUChar32 = 0;
624 converter->invalidUCharLength = converter->charErrorBufferLength = 0;
625 converter->preFromUFirstCP = U_SENTINEL;
626 converter->preFromULength = 0;
627 }
628
629 if (converter->sharedData->impl->reset != NULL) {
630 /* call the custom reset function */
631 converter->sharedData->impl->reset(converter, choice);
632 }
633 }
634
635 U_CAPI void U_EXPORT2
636 ucnv_reset(UConverter *converter)
637 {
638 _reset(converter, UCNV_RESET_BOTH, TRUE);
639 }
640
641 U_CAPI void U_EXPORT2
642 ucnv_resetToUnicode(UConverter *converter)
643 {
644 _reset(converter, UCNV_RESET_TO_UNICODE, TRUE);
645 }
646
647 U_CAPI void U_EXPORT2
648 ucnv_resetFromUnicode(UConverter *converter)
649 {
650 _reset(converter, UCNV_RESET_FROM_UNICODE, TRUE);
651 }
652
653 U_CAPI int8_t U_EXPORT2
654 ucnv_getMaxCharSize (const UConverter * converter)
655 {
656 return converter->maxBytesPerUChar;
657 }
658
659
660 U_CAPI int8_t U_EXPORT2
661 ucnv_getMinCharSize (const UConverter * converter)
662 {
663 return converter->sharedData->staticData->minBytesPerChar;
664 }
665
666 U_CAPI const char* U_EXPORT2
667 ucnv_getName (const UConverter * converter, UErrorCode * err)
668
669 {
670 if (U_FAILURE (*err))
671 return NULL;
672 if(converter->sharedData->impl->getName){
673 const char* temp= converter->sharedData->impl->getName(converter);
674 if(temp)
675 return temp;
676 }
677 return converter->sharedData->staticData->name;
678 }
679
680 U_CAPI int32_t U_EXPORT2
681 ucnv_getCCSID(const UConverter * converter,
682 UErrorCode * err)
683 {
684 int32_t ccsid;
685 if (U_FAILURE (*err))
686 return -1;
687
688 ccsid = converter->sharedData->staticData->codepage;
689 if (ccsid == 0) {
690 /* Rare case. This is for cases like gb18030,
691 which doesn't have an IBM canonical name, but does have an IBM alias. */
692 const char *standardName = ucnv_getStandardName(ucnv_getName(converter, err), "IBM", err);
693 if (U_SUCCESS(*err) && standardName) {
694 const char *ccsidStr = uprv_strchr(standardName, '-');
695 if (ccsidStr) {
696 ccsid = (int32_t)atol(ccsidStr+1); /* +1 to skip '-' */
697 }
698 }
699 }
700 return ccsid;
701 }
702
703
704 U_CAPI UConverterPlatform U_EXPORT2
705 ucnv_getPlatform (const UConverter * converter,
706 UErrorCode * err)
707 {
708 if (U_FAILURE (*err))
709 return UCNV_UNKNOWN;
710
711 return (UConverterPlatform)converter->sharedData->staticData->platform;
712 }
713
714 U_CAPI void U_EXPORT2
715 ucnv_getToUCallBack (const UConverter * converter,
716 UConverterToUCallback *action,
717 const void **context)
718 {
719 *action = converter->fromCharErrorBehaviour;
720 *context = converter->toUContext;
721 }
722
723 U_CAPI void U_EXPORT2
724 ucnv_getFromUCallBack (const UConverter * converter,
725 UConverterFromUCallback *action,
726 const void **context)
727 {
728 *action = converter->fromUCharErrorBehaviour;
729 *context = converter->fromUContext;
730 }
731
732 U_CAPI void U_EXPORT2
733 ucnv_setToUCallBack (UConverter * converter,
734 UConverterToUCallback newAction,
735 const void* newContext,
736 UConverterToUCallback *oldAction,
737 const void** oldContext,
738 UErrorCode * err)
739 {
740 if (U_FAILURE (*err))
741 return;
742 if (oldAction) *oldAction = converter->fromCharErrorBehaviour;
743 converter->fromCharErrorBehaviour = newAction;
744 if (oldContext) *oldContext = converter->toUContext;
745 converter->toUContext = newContext;
746 }
747
748 U_CAPI void U_EXPORT2
749 ucnv_setFromUCallBack (UConverter * converter,
750 UConverterFromUCallback newAction,
751 const void* newContext,
752 UConverterFromUCallback *oldAction,
753 const void** oldContext,
754 UErrorCode * err)
755 {
756 if (U_FAILURE (*err))
757 return;
758 if (oldAction) *oldAction = converter->fromUCharErrorBehaviour;
759 converter->fromUCharErrorBehaviour = newAction;
760 if (oldContext) *oldContext = converter->fromUContext;
761 converter->fromUContext = newContext;
762 }
763
764 static void
765 _updateOffsets(int32_t *offsets, int32_t length,
766 int32_t sourceIndex, int32_t errorInputLength) {
767 int32_t *limit;
768 int32_t delta, offset;
769
770 if(sourceIndex>=0) {
771 /*
772 * adjust each offset by adding the previous sourceIndex
773 * minus the length of the input sequence that caused an
774 * error, if any
775 */
776 delta=sourceIndex-errorInputLength;
777 } else {
778 /*
779 * set each offset to -1 because this conversion function
780 * does not handle offsets
781 */
782 delta=-1;
783 }
784
785 limit=offsets+length;
786 if(delta==0) {
787 /* most common case, nothing to do */
788 } else if(delta>0) {
789 /* add the delta to each offset (but not if the offset is <0) */
790 while(offsets<limit) {
791 offset=*offsets;
792 if(offset>=0) {
793 *offsets=offset+delta;
794 }
795 ++offsets;
796 }
797 } else /* delta<0 */ {
798 /*
799 * set each offset to -1 because this conversion function
800 * does not handle offsets
801 * or the error input sequence started in a previous buffer
802 */
803 while(offsets<limit) {
804 *offsets++=-1;
805 }
806 }
807 }
808
809 /* ucnv_fromUnicode --------------------------------------------------------- */
810
811 /*
812 * Implementation note for m:n conversions
813 *
814 * While collecting source units to find the longest match for m:n conversion,
815 * some source units may need to be stored for a partial match.
816 * When a second buffer does not yield a match on all of the previously stored
817 * source units, then they must be "replayed", i.e., fed back into the converter.
818 *
819 * The code relies on the fact that replaying will not nest -
820 * converting a replay buffer will not result in a replay.
821 * This is because a replay is necessary only after the _continuation_ of a
822 * partial match failed, but a replay buffer is converted as a whole.
823 * It may result in some of its units being stored again for a partial match,
824 * but there will not be a continuation _during_ the replay which could fail.
825 *
826 * It is conceivable that a callback function could call the converter
827 * recursively in a way that causes another replay to be stored, but that
828 * would be an error in the callback function.
829 * Such violations will cause assertion failures in a debug build,
830 * and wrong output, but they will not cause a crash.
831 */
832
833 static void
834 _fromUnicodeWithCallback(UConverterFromUnicodeArgs *pArgs, UErrorCode *err) {
835 UConverterFromUnicode fromUnicode;
836 UConverter *cnv;
837 const UChar *s;
838 char *t;
839 int32_t *offsets;
840 int32_t sourceIndex;
841 int32_t errorInputLength;
842 UBool converterSawEndOfInput, calledCallback;
843
844 /* variables for m:n conversion */
845 UChar replay[UCNV_EXT_MAX_UCHARS];
846 const UChar *realSource, *realSourceLimit;
847 int32_t realSourceIndex;
848 UBool realFlush;
849
850 cnv=pArgs->converter;
851 s=pArgs->source;
852 t=pArgs->target;
853 offsets=pArgs->offsets;
854
855 /* get the converter implementation function */
856 sourceIndex=0;
857 if(offsets==NULL) {
858 fromUnicode=cnv->sharedData->impl->fromUnicode;
859 } else {
860 fromUnicode=cnv->sharedData->impl->fromUnicodeWithOffsets;
861 if(fromUnicode==NULL) {
862 /* there is no WithOffsets implementation */
863 fromUnicode=cnv->sharedData->impl->fromUnicode;
864 /* we will write -1 for each offset */
865 sourceIndex=-1;
866 }
867 }
868
869 if(cnv->preFromULength>=0) {
870 /* normal mode */
871 realSource=NULL;
872
873 /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
874 realSourceLimit=NULL;
875 realFlush=FALSE;
876 realSourceIndex=0;
877 } else {
878 /*
879 * Previous m:n conversion stored source units from a partial match
880 * and failed to consume all of them.
881 * We need to "replay" them from a temporary buffer and convert them first.
882 */
883 realSource=pArgs->source;
884 realSourceLimit=pArgs->sourceLimit;
885 realFlush=pArgs->flush;
886 realSourceIndex=sourceIndex;
887
888 uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR);
889 pArgs->source=replay;
890 pArgs->sourceLimit=replay-cnv->preFromULength;
891 pArgs->flush=FALSE;
892 sourceIndex=-1;
893
894 cnv->preFromULength=0;
895 }
896
897 /*
898 * loop for conversion and error handling
899 *
900 * loop {
901 * convert
902 * loop {
903 * update offsets
904 * handle end of input
905 * handle errors/call callback
906 * }
907 * }
908 */
909 for(;;) {
910 if(U_SUCCESS(*err)) {
911 /* convert */
912 fromUnicode(pArgs, err);
913
914 /*
915 * set a flag for whether the converter
916 * successfully processed the end of the input
917 *
918 * need not check cnv->preFromULength==0 because a replay (<0) will cause
919 * s<sourceLimit before converterSawEndOfInput is checked
920 */
921 converterSawEndOfInput=
922 (UBool)(U_SUCCESS(*err) &&
923 pArgs->flush && pArgs->source==pArgs->sourceLimit &&
924 cnv->fromUChar32==0);
925 } else {
926 /* handle error from ucnv_convertEx() */
927 converterSawEndOfInput=FALSE;
928 }
929
930 /* no callback called yet for this iteration */
931 calledCallback=FALSE;
932
933 /* no sourceIndex adjustment for conversion, only for callback output */
934 errorInputLength=0;
935
936 /*
937 * loop for offsets and error handling
938 *
939 * iterates at most 3 times:
940 * 1. to clean up after the conversion function
941 * 2. after the callback
942 * 3. after the callback again if there was truncated input
943 */
944 for(;;) {
945 /* update offsets if we write any */
946 if(offsets!=NULL) {
947 int32_t length=(int32_t)(pArgs->target-t);
948 if(length>0) {
949 _updateOffsets(offsets, length, sourceIndex, errorInputLength);
950
951 /*
952 * if a converter handles offsets and updates the offsets
953 * pointer at the end, then pArgs->offset should not change
954 * here;
955 * however, some converters do not handle offsets at all
956 * (sourceIndex<0) or may not update the offsets pointer
957 */
958 pArgs->offsets=offsets+=length;
959 }
960
961 if(sourceIndex>=0) {
962 sourceIndex+=(int32_t)(pArgs->source-s);
963 }
964 }
965
966 if(cnv->preFromULength<0) {
967 /*
968 * switch the source to new replay units (cannot occur while replaying)
969 * after offset handling and before end-of-input and callback handling
970 */
971 if(realSource==NULL) {
972 realSource=pArgs->source;
973 realSourceLimit=pArgs->sourceLimit;
974 realFlush=pArgs->flush;
975 realSourceIndex=sourceIndex;
976
977 uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR);
978 pArgs->source=replay;
979 pArgs->sourceLimit=replay-cnv->preFromULength;
980 pArgs->flush=FALSE;
981 if((sourceIndex+=cnv->preFromULength)<0) {
982 sourceIndex=-1;
983 }
984
985 cnv->preFromULength=0;
986 } else {
987 /* see implementation note before _fromUnicodeWithCallback() */
988 U_ASSERT(realSource==NULL);
989 *err=U_INTERNAL_PROGRAM_ERROR;
990 }
991 }
992
993 /* update pointers */
994 s=pArgs->source;
995 t=pArgs->target;
996
997 if(U_SUCCESS(*err)) {
998 if(s<pArgs->sourceLimit) {
999 /*
1000 * continue with the conversion loop while there is still input left
1001 * (continue converting by breaking out of only the inner loop)
1002 */
1003 break;
1004 } else if(realSource!=NULL) {
1005 /* switch back from replaying to the real source and continue */
1006 pArgs->source=realSource;
1007 pArgs->sourceLimit=realSourceLimit;
1008 pArgs->flush=realFlush;
1009 sourceIndex=realSourceIndex;
1010
1011 realSource=NULL;
1012 break;
1013 } else if(pArgs->flush && cnv->fromUChar32!=0) {
1014 /*
1015 * the entire input stream is consumed
1016 * and there is a partial, truncated input sequence left
1017 */
1018
1019 /* inject an error and continue with callback handling */
1020 *err=U_TRUNCATED_CHAR_FOUND;
1021 calledCallback=FALSE; /* new error condition */
1022 } else {
1023 /* input consumed */
1024 if(pArgs->flush) {
1025 /*
1026 * return to the conversion loop once more if the flush
1027 * flag is set and the conversion function has not
1028 * successfully processed the end of the input yet
1029 *
1030 * (continue converting by breaking out of only the inner loop)
1031 */
1032 if(!converterSawEndOfInput) {
1033 break;
1034 }
1035
1036 /* reset the converter without calling the callback function */
1037 _reset(cnv, UCNV_RESET_FROM_UNICODE, FALSE);
1038 }
1039
1040 /* done successfully */
1041 return;
1042 }
1043 }
1044
1045 /* U_FAILURE(*err) */
1046 {
1047 UErrorCode e;
1048
1049 if( calledCallback ||
1050 (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
1051 (e!=U_INVALID_CHAR_FOUND &&
1052 e!=U_ILLEGAL_CHAR_FOUND &&
1053 e!=U_TRUNCATED_CHAR_FOUND)
1054 ) {
1055 /*
1056 * the callback did not or cannot resolve the error:
1057 * set output pointers and return
1058 *
1059 * the check for buffer overflow is redundant but it is
1060 * a high-runner case and hopefully documents the intent
1061 * well
1062 *
1063 * if we were replaying, then the replay buffer must be
1064 * copied back into the UConverter
1065 * and the real arguments must be restored
1066 */
1067 if(realSource!=NULL) {
1068 int32_t length;
1069
1070 U_ASSERT(cnv->preFromULength==0);
1071
1072 length=(int32_t)(pArgs->sourceLimit-pArgs->source);
1073 if(length>0) {
1074 uprv_memcpy(cnv->preFromU, pArgs->source, length*U_SIZEOF_UCHAR);
1075 cnv->preFromULength=(int8_t)-length;
1076 }
1077
1078 pArgs->source=realSource;
1079 pArgs->sourceLimit=realSourceLimit;
1080 pArgs->flush=realFlush;
1081 }
1082
1083 return;
1084 }
1085 }
1086
1087 /* callback handling */
1088 {
1089 UChar32 codePoint;
1090
1091 /* get and write the code point */
1092 codePoint=cnv->fromUChar32;
1093 errorInputLength=0;
1094 U16_APPEND_UNSAFE(cnv->invalidUCharBuffer, errorInputLength, codePoint);
1095 cnv->invalidUCharLength=(int8_t)errorInputLength;
1096
1097 /* set the converter state to deal with the next character */
1098 cnv->fromUChar32=0;
1099
1100 /* call the callback function */
1101 cnv->fromUCharErrorBehaviour(cnv->fromUContext, pArgs,
1102 cnv->invalidUCharBuffer, errorInputLength, codePoint,
1103 *err==U_INVALID_CHAR_FOUND ? UCNV_UNASSIGNED : UCNV_ILLEGAL,
1104 err);
1105 }
1106
1107 /*
1108 * loop back to the offset handling
1109 *
1110 * this flag will indicate after offset handling
1111 * that a callback was called;
1112 * if the callback did not resolve the error, then we return
1113 */
1114 calledCallback=TRUE;
1115 }
1116 }
1117 }
1118
1119 /*
1120 * Output the fromUnicode overflow buffer.
1121 * Call this function if(cnv->charErrorBufferLength>0).
1122 * @return TRUE if overflow
1123 */
1124 static UBool
1125 ucnv_outputOverflowFromUnicode(UConverter *cnv,
1126 char **target, const char *targetLimit,
1127 int32_t **pOffsets,
1128 UErrorCode *err) {
1129 int32_t *offsets;
1130 char *overflow, *t;
1131 int32_t i, length;
1132
1133 t=*target;
1134 if(pOffsets!=NULL) {
1135 offsets=*pOffsets;
1136 } else {
1137 offsets=NULL;
1138 }
1139
1140 overflow=(char *)cnv->charErrorBuffer;
1141 length=cnv->charErrorBufferLength;
1142 i=0;
1143 while(i<length) {
1144 if(t==targetLimit) {
1145 /* the overflow buffer contains too much, keep the rest */
1146 int32_t j=0;
1147
1148 do {
1149 overflow[j++]=overflow[i++];
1150 } while(i<length);
1151
1152 cnv->charErrorBufferLength=(int8_t)j;
1153 *target=t;
1154 if(offsets!=NULL) {
1155 *pOffsets=offsets;
1156 }
1157 *err=U_BUFFER_OVERFLOW_ERROR;
1158 return TRUE;
1159 }
1160
1161 /* copy the overflow contents to the target */
1162 *t++=overflow[i++];
1163 if(offsets!=NULL) {
1164 *offsets++=-1; /* no source index available for old output */
1165 }
1166 }
1167
1168 /* the overflow buffer is completely copied to the target */
1169 cnv->charErrorBufferLength=0;
1170 *target=t;
1171 if(offsets!=NULL) {
1172 *pOffsets=offsets;
1173 }
1174 return FALSE;
1175 }
1176
1177 U_CAPI void U_EXPORT2
1178 ucnv_fromUnicode(UConverter *cnv,
1179 char **target, const char *targetLimit,
1180 const UChar **source, const UChar *sourceLimit,
1181 int32_t *offsets,
1182 UBool flush,
1183 UErrorCode *err) {
1184 UConverterFromUnicodeArgs args;
1185 const UChar *s;
1186 char *t;
1187
1188 /* check parameters */
1189 if(err==NULL || U_FAILURE(*err)) {
1190 return;
1191 }
1192
1193 if(cnv==NULL || target==NULL || source==NULL) {
1194 *err=U_ILLEGAL_ARGUMENT_ERROR;
1195 return;
1196 }
1197
1198 s=*source;
1199 t=*target;
1200
1201 if ((const void *)U_MAX_PTR(sourceLimit) == (const void *)sourceLimit) {
1202 /*
1203 Prevent code from going into an infinite loop in case we do hit this
1204 limit. The limit pointer is expected to be on a UChar * boundary.
1205 This also prevents the next argument check from failing.
1206 */
1207 sourceLimit = (const UChar *)(((const char *)sourceLimit) - 1);
1208 }
1209
1210 /*
1211 * All these conditions should never happen.
1212 *
1213 * 1) Make sure that the limits are >= to the address source or target
1214 *
1215 * 2) Make sure that the buffer sizes do not exceed the number range for
1216 * int32_t because some functions use the size (in units or bytes)
1217 * rather than comparing pointers, and because offsets are int32_t values.
1218 *
1219 * size_t is guaranteed to be unsigned and large enough for the job.
1220 *
1221 * Return with an error instead of adjusting the limits because we would
1222 * not be able to maintain the semantics that either the source must be
1223 * consumed or the target filled (unless an error occurs).
1224 * An adjustment would be targetLimit=t+0x7fffffff; for example.
1225 *
1226 * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
1227 * to a char * pointer and provide an incomplete UChar code unit.
1228 */
1229 if (sourceLimit<s || targetLimit<t ||
1230 ((size_t)(sourceLimit-s)>(size_t)0x3fffffff && sourceLimit>s) ||
1231 ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t) ||
1232 (((const char *)sourceLimit-(const char *)s) & 1) != 0)
1233 {
1234 *err=U_ILLEGAL_ARGUMENT_ERROR;
1235 return;
1236 }
1237
1238 /* output the target overflow buffer */
1239 if( cnv->charErrorBufferLength>0 &&
1240 ucnv_outputOverflowFromUnicode(cnv, target, targetLimit, &offsets, err)
1241 ) {
1242 /* U_BUFFER_OVERFLOW_ERROR */
1243 return;
1244 }
1245 /* *target may have moved, therefore stop using t */
1246
1247 if(!flush && s==sourceLimit && cnv->preFromULength>=0) {
1248 /* the overflow buffer is emptied and there is no new input: we are done */
1249 return;
1250 }
1251
1252 /*
1253 * Do not simply return with a buffer overflow error if
1254 * !flush && t==targetLimit
1255 * because it is possible that the source will not generate any output.
1256 * For example, the skip callback may be called;
1257 * it does not output anything.
1258 */
1259
1260 /* prepare the converter arguments */
1261 args.converter=cnv;
1262 args.flush=flush;
1263 args.offsets=offsets;
1264 args.source=s;
1265 args.sourceLimit=sourceLimit;
1266 args.target=*target;
1267 args.targetLimit=targetLimit;
1268 args.size=sizeof(args);
1269
1270 _fromUnicodeWithCallback(&args, err);
1271
1272 *source=args.source;
1273 *target=args.target;
1274 }
1275
1276 /* ucnv_toUnicode() --------------------------------------------------------- */
1277
1278 static void
1279 _toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
1280 UConverterToUnicode toUnicode;
1281 UConverter *cnv;
1282 const char *s;
1283 UChar *t;
1284 int32_t *offsets;
1285 int32_t sourceIndex;
1286 int32_t errorInputLength;
1287 UBool converterSawEndOfInput, calledCallback;
1288
1289 /* variables for m:n conversion */
1290 char replay[UCNV_EXT_MAX_BYTES];
1291 const char *realSource, *realSourceLimit;
1292 int32_t realSourceIndex;
1293 UBool realFlush;
1294
1295 cnv=pArgs->converter;
1296 s=pArgs->source;
1297 t=pArgs->target;
1298 offsets=pArgs->offsets;
1299
1300 /* get the converter implementation function */
1301 sourceIndex=0;
1302 if(offsets==NULL) {
1303 toUnicode=cnv->sharedData->impl->toUnicode;
1304 } else {
1305 toUnicode=cnv->sharedData->impl->toUnicodeWithOffsets;
1306 if(toUnicode==NULL) {
1307 /* there is no WithOffsets implementation */
1308 toUnicode=cnv->sharedData->impl->toUnicode;
1309 /* we will write -1 for each offset */
1310 sourceIndex=-1;
1311 }
1312 }
1313
1314 if(cnv->preToULength>=0) {
1315 /* normal mode */
1316 realSource=NULL;
1317
1318 /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
1319 realSourceLimit=NULL;
1320 realFlush=FALSE;
1321 realSourceIndex=0;
1322 } else {
1323 /*
1324 * Previous m:n conversion stored source units from a partial match
1325 * and failed to consume all of them.
1326 * We need to "replay" them from a temporary buffer and convert them first.
1327 */
1328 realSource=pArgs->source;
1329 realSourceLimit=pArgs->sourceLimit;
1330 realFlush=pArgs->flush;
1331 realSourceIndex=sourceIndex;
1332
1333 uprv_memcpy(replay, cnv->preToU, -cnv->preToULength);
1334 pArgs->source=replay;
1335 pArgs->sourceLimit=replay-cnv->preToULength;
1336 pArgs->flush=FALSE;
1337 sourceIndex=-1;
1338
1339 cnv->preToULength=0;
1340 }
1341
1342 /*
1343 * loop for conversion and error handling
1344 *
1345 * loop {
1346 * convert
1347 * loop {
1348 * update offsets
1349 * handle end of input
1350 * handle errors/call callback
1351 * }
1352 * }
1353 */
1354 for(;;) {
1355 if(U_SUCCESS(*err)) {
1356 /* convert */
1357 toUnicode(pArgs, err);
1358
1359 /*
1360 * set a flag for whether the converter
1361 * successfully processed the end of the input
1362 *
1363 * need not check cnv->preToULength==0 because a replay (<0) will cause
1364 * s<sourceLimit before converterSawEndOfInput is checked
1365 */
1366 converterSawEndOfInput=
1367 (UBool)(U_SUCCESS(*err) &&
1368 pArgs->flush && pArgs->source==pArgs->sourceLimit &&
1369 cnv->toULength==0);
1370 } else {
1371 /* handle error from getNextUChar() or ucnv_convertEx() */
1372 converterSawEndOfInput=FALSE;
1373 }
1374
1375 /* no callback called yet for this iteration */
1376 calledCallback=FALSE;
1377
1378 /* no sourceIndex adjustment for conversion, only for callback output */
1379 errorInputLength=0;
1380
1381 /*
1382 * loop for offsets and error handling
1383 *
1384 * iterates at most 3 times:
1385 * 1. to clean up after the conversion function
1386 * 2. after the callback
1387 * 3. after the callback again if there was truncated input
1388 */
1389 for(;;) {
1390 /* update offsets if we write any */
1391 if(offsets!=NULL) {
1392 int32_t length=(int32_t)(pArgs->target-t);
1393 if(length>0) {
1394 _updateOffsets(offsets, length, sourceIndex, errorInputLength);
1395
1396 /*
1397 * if a converter handles offsets and updates the offsets
1398 * pointer at the end, then pArgs->offset should not change
1399 * here;
1400 * however, some converters do not handle offsets at all
1401 * (sourceIndex<0) or may not update the offsets pointer
1402 */
1403 pArgs->offsets=offsets+=length;
1404 }
1405
1406 if(sourceIndex>=0) {
1407 sourceIndex+=(int32_t)(pArgs->source-s);
1408 }
1409 }
1410
1411 if(cnv->preToULength<0) {
1412 /*
1413 * switch the source to new replay units (cannot occur while replaying)
1414 * after offset handling and before end-of-input and callback handling
1415 */
1416 if(realSource==NULL) {
1417 realSource=pArgs->source;
1418 realSourceLimit=pArgs->sourceLimit;
1419 realFlush=pArgs->flush;
1420 realSourceIndex=sourceIndex;
1421
1422 uprv_memcpy(replay, cnv->preToU, -cnv->preToULength);
1423 pArgs->source=replay;
1424 pArgs->sourceLimit=replay-cnv->preToULength;
1425 pArgs->flush=FALSE;
1426 if((sourceIndex+=cnv->preToULength)<0) {
1427 sourceIndex=-1;
1428 }
1429
1430 cnv->preToULength=0;
1431 } else {
1432 /* see implementation note before _fromUnicodeWithCallback() */
1433 U_ASSERT(realSource==NULL);
1434 *err=U_INTERNAL_PROGRAM_ERROR;
1435 }
1436 }
1437
1438 /* update pointers */
1439 s=pArgs->source;
1440 t=pArgs->target;
1441
1442 if(U_SUCCESS(*err)) {
1443 if(s<pArgs->sourceLimit) {
1444 /*
1445 * continue with the conversion loop while there is still input left
1446 * (continue converting by breaking out of only the inner loop)
1447 */
1448 break;
1449 } else if(realSource!=NULL) {
1450 /* switch back from replaying to the real source and continue */
1451 pArgs->source=realSource;
1452 pArgs->sourceLimit=realSourceLimit;
1453 pArgs->flush=realFlush;
1454 sourceIndex=realSourceIndex;
1455
1456 realSource=NULL;
1457 break;
1458 } else if(pArgs->flush && cnv->toULength>0) {
1459 /*
1460 * the entire input stream is consumed
1461 * and there is a partial, truncated input sequence left
1462 */
1463
1464 /* inject an error and continue with callback handling */
1465 *err=U_TRUNCATED_CHAR_FOUND;
1466 calledCallback=FALSE; /* new error condition */
1467 } else {
1468 /* input consumed */
1469 if(pArgs->flush) {
1470 /*
1471 * return to the conversion loop once more if the flush
1472 * flag is set and the conversion function has not
1473 * successfully processed the end of the input yet
1474 *
1475 * (continue converting by breaking out of only the inner loop)
1476 */
1477 if(!converterSawEndOfInput) {
1478 break;
1479 }
1480
1481 /* reset the converter without calling the callback function */
1482 _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE);
1483 }
1484
1485 /* done successfully */
1486 return;
1487 }
1488 }
1489
1490 /* U_FAILURE(*err) */
1491 {
1492 UErrorCode e;
1493
1494 if( calledCallback ||
1495 (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
1496 (e!=U_INVALID_CHAR_FOUND &&
1497 e!=U_ILLEGAL_CHAR_FOUND &&
1498 e!=U_TRUNCATED_CHAR_FOUND &&
1499 e!=U_ILLEGAL_ESCAPE_SEQUENCE &&
1500 e!=U_UNSUPPORTED_ESCAPE_SEQUENCE)
1501 ) {
1502 /*
1503 * the callback did not or cannot resolve the error:
1504 * set output pointers and return
1505 *
1506 * the check for buffer overflow is redundant but it is
1507 * a high-runner case and hopefully documents the intent
1508 * well
1509 *
1510 * if we were replaying, then the replay buffer must be
1511 * copied back into the UConverter
1512 * and the real arguments must be restored
1513 */
1514 if(realSource!=NULL) {
1515 int32_t length;
1516
1517 U_ASSERT(cnv->preToULength==0);
1518
1519 length=(int32_t)(pArgs->sourceLimit-pArgs->source);
1520 if(length>0) {
1521 uprv_memcpy(cnv->preToU, pArgs->source, length);
1522 cnv->preToULength=(int8_t)-length;
1523 }
1524
1525 pArgs->source=realSource;
1526 pArgs->sourceLimit=realSourceLimit;
1527 pArgs->flush=realFlush;
1528 }
1529
1530 return;
1531 }
1532 }
1533
1534 /* copy toUBytes[] to invalidCharBuffer[] */
1535 errorInputLength=cnv->invalidCharLength=cnv->toULength;
1536 if(errorInputLength>0) {
1537 uprv_memcpy(cnv->invalidCharBuffer, cnv->toUBytes, errorInputLength);
1538 }
1539
1540 /* set the converter state to deal with the next character */
1541 cnv->toULength=0;
1542
1543 /* call the callback function */
1544 if(cnv->toUCallbackReason==UCNV_ILLEGAL && *err==U_INVALID_CHAR_FOUND) {
1545 cnv->toUCallbackReason = UCNV_UNASSIGNED;
1546 }
1547 cnv->fromCharErrorBehaviour(cnv->toUContext, pArgs,
1548 cnv->invalidCharBuffer, errorInputLength,
1549 cnv->toUCallbackReason,
1550 err);
1551 cnv->toUCallbackReason = UCNV_ILLEGAL; /* reset to default value */
1552
1553 /*
1554 * loop back to the offset handling
1555 *
1556 * this flag will indicate after offset handling
1557 * that a callback was called;
1558 * if the callback did not resolve the error, then we return
1559 */
1560 calledCallback=TRUE;
1561 }
1562 }
1563 }
1564
1565 /*
1566 * Output the toUnicode overflow buffer.
1567 * Call this function if(cnv->UCharErrorBufferLength>0).
1568 * @return TRUE if overflow
1569 */
1570 static UBool
1571 ucnv_outputOverflowToUnicode(UConverter *cnv,
1572 UChar **target, const UChar *targetLimit,
1573 int32_t **pOffsets,
1574 UErrorCode *err) {
1575 int32_t *offsets;
1576 UChar *overflow, *t;
1577 int32_t i, length;
1578
1579 t=*target;
1580 if(pOffsets!=NULL) {
1581 offsets=*pOffsets;
1582 } else {
1583 offsets=NULL;
1584 }
1585
1586 overflow=cnv->UCharErrorBuffer;
1587 length=cnv->UCharErrorBufferLength;
1588 i=0;
1589 while(i<length) {
1590 if(t==targetLimit) {
1591 /* the overflow buffer contains too much, keep the rest */
1592 int32_t j=0;
1593
1594 do {
1595 overflow[j++]=overflow[i++];
1596 } while(i<length);
1597
1598 cnv->UCharErrorBufferLength=(int8_t)j;
1599 *target=t;
1600 if(offsets!=NULL) {
1601 *pOffsets=offsets;
1602 }
1603 *err=U_BUFFER_OVERFLOW_ERROR;
1604 return TRUE;
1605 }
1606
1607 /* copy the overflow contents to the target */
1608 *t++=overflow[i++];
1609 if(offsets!=NULL) {
1610 *offsets++=-1; /* no source index available for old output */
1611 }
1612 }
1613
1614 /* the overflow buffer is completely copied to the target */
1615 cnv->UCharErrorBufferLength=0;
1616 *target=t;
1617 if(offsets!=NULL) {
1618 *pOffsets=offsets;
1619 }
1620 return FALSE;
1621 }
1622
1623 U_CAPI void U_EXPORT2
1624 ucnv_toUnicode(UConverter *cnv,
1625 UChar **target, const UChar *targetLimit,
1626 const char **source, const char *sourceLimit,
1627 int32_t *offsets,
1628 UBool flush,
1629 UErrorCode *err) {
1630 UConverterToUnicodeArgs args;
1631 const char *s;
1632 UChar *t;
1633
1634 /* check parameters */
1635 if(err==NULL || U_FAILURE(*err)) {
1636 return;
1637 }
1638
1639 if(cnv==NULL || target==NULL || source==NULL) {
1640 *err=U_ILLEGAL_ARGUMENT_ERROR;
1641 return;
1642 }
1643
1644 s=*source;
1645 t=*target;
1646
1647 if ((const void *)U_MAX_PTR(targetLimit) == (const void *)targetLimit) {
1648 /*
1649 Prevent code from going into an infinite loop in case we do hit this
1650 limit. The limit pointer is expected to be on a UChar * boundary.
1651 This also prevents the next argument check from failing.
1652 */
1653 targetLimit = (const UChar *)(((const char *)targetLimit) - 1);
1654 }
1655
1656 /*
1657 * All these conditions should never happen.
1658 *
1659 * 1) Make sure that the limits are >= to the address source or target
1660 *
1661 * 2) Make sure that the buffer sizes do not exceed the number range for
1662 * int32_t because some functions use the size (in units or bytes)
1663 * rather than comparing pointers, and because offsets are int32_t values.
1664 *
1665 * size_t is guaranteed to be unsigned and large enough for the job.
1666 *
1667 * Return with an error instead of adjusting the limits because we would
1668 * not be able to maintain the semantics that either the source must be
1669 * consumed or the target filled (unless an error occurs).
1670 * An adjustment would be sourceLimit=t+0x7fffffff; for example.
1671 *
1672 * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
1673 * to a char * pointer and provide an incomplete UChar code unit.
1674 */
1675 if (sourceLimit<s || targetLimit<t ||
1676 ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s) ||
1677 ((size_t)(targetLimit-t)>(size_t)0x3fffffff && targetLimit>t) ||
1678 (((const char *)targetLimit-(const char *)t) & 1) != 0
1679 ) {
1680 *err=U_ILLEGAL_ARGUMENT_ERROR;
1681 return;
1682 }
1683
1684 /* output the target overflow buffer */
1685 if( cnv->UCharErrorBufferLength>0 &&
1686 ucnv_outputOverflowToUnicode(cnv, target, targetLimit, &offsets, err)
1687 ) {
1688 /* U_BUFFER_OVERFLOW_ERROR */
1689 return;
1690 }
1691 /* *target may have moved, therefore stop using t */
1692
1693 if(!flush && s==sourceLimit && cnv->preToULength>=0) {
1694 /* the overflow buffer is emptied and there is no new input: we are done */
1695 return;
1696 }
1697
1698 /*
1699 * Do not simply return with a buffer overflow error if
1700 * !flush && t==targetLimit
1701 * because it is possible that the source will not generate any output.
1702 * For example, the skip callback may be called;
1703 * it does not output anything.
1704 */
1705
1706 /* prepare the converter arguments */
1707 args.converter=cnv;
1708 args.flush=flush;
1709 args.offsets=offsets;
1710 args.source=s;
1711 args.sourceLimit=sourceLimit;
1712 args.target=*target;
1713 args.targetLimit=targetLimit;
1714 args.size=sizeof(args);
1715
1716 _toUnicodeWithCallback(&args, err);
1717
1718 *source=args.source;
1719 *target=args.target;
1720 }
1721
1722 /* ucnv_to/fromUChars() ----------------------------------------------------- */
1723
1724 U_CAPI int32_t U_EXPORT2
1725 ucnv_fromUChars(UConverter *cnv,
1726 char *dest, int32_t destCapacity,
1727 const UChar *src, int32_t srcLength,
1728 UErrorCode *pErrorCode) {
1729 const UChar *srcLimit;
1730 char *originalDest, *destLimit;
1731 int32_t destLength;
1732
1733 /* check arguments */
1734 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1735 return 0;
1736 }
1737
1738 if( cnv==NULL ||
1739 destCapacity<0 || (destCapacity>0 && dest==NULL) ||
1740 srcLength<-1 || (srcLength!=0 && src==NULL)
1741 ) {
1742 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1743 return 0;
1744 }
1745
1746 /* initialize */
1747 ucnv_resetFromUnicode(cnv);
1748 originalDest=dest;
1749 if(srcLength==-1) {
1750 srcLength=u_strlen(src);
1751 }
1752 if(srcLength>0) {
1753 srcLimit=src+srcLength;
1754 destLimit=dest+destCapacity;
1755
1756 /* pin the destination limit to U_MAX_PTR; NULL check is for OS/400 */
1757 if(destLimit<dest || (destLimit==NULL && dest!=NULL)) {
1758 destLimit=(char *)U_MAX_PTR(dest);
1759 }
1760
1761 /* perform the conversion */
1762 ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
1763 destLength=(int32_t)(dest-originalDest);
1764
1765 /* if an overflow occurs, then get the preflighting length */
1766 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
1767 char buffer[1024];
1768
1769 destLimit=buffer+sizeof(buffer);
1770 do {
1771 dest=buffer;
1772 *pErrorCode=U_ZERO_ERROR;
1773 ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
1774 destLength+=(int32_t)(dest-buffer);
1775 } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
1776 }
1777 } else {
1778 destLength=0;
1779 }
1780
1781 return u_terminateChars(originalDest, destCapacity, destLength, pErrorCode);
1782 }
1783
1784 U_CAPI int32_t U_EXPORT2
1785 ucnv_toUChars(UConverter *cnv,
1786 UChar *dest, int32_t destCapacity,
1787 const char *src, int32_t srcLength,
1788 UErrorCode *pErrorCode) {
1789 const char *srcLimit;
1790 UChar *originalDest, *destLimit;
1791 int32_t destLength;
1792
1793 /* check arguments */
1794 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1795 return 0;
1796 }
1797
1798 if( cnv==NULL ||
1799 destCapacity<0 || (destCapacity>0 && dest==NULL) ||
1800 srcLength<-1 || (srcLength!=0 && src==NULL))
1801 {
1802 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1803 return 0;
1804 }
1805
1806 /* initialize */
1807 ucnv_resetToUnicode(cnv);
1808 originalDest=dest;
1809 if(srcLength==-1) {
1810 srcLength=(int32_t)uprv_strlen(src);
1811 }
1812 if(srcLength>0) {
1813 srcLimit=src+srcLength;
1814 destLimit=dest+destCapacity;
1815
1816 /* pin the destination limit to U_MAX_PTR; NULL check is for OS/400 */
1817 if(destLimit<dest || (destLimit==NULL && dest!=NULL)) {
1818 destLimit=(UChar *)U_MAX_PTR(dest);
1819 }
1820
1821 /* perform the conversion */
1822 ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
1823 destLength=(int32_t)(dest-originalDest);
1824
1825 /* if an overflow occurs, then get the preflighting length */
1826 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR)
1827 {
1828 UChar buffer[1024];
1829
1830 destLimit=buffer+sizeof(buffer)/U_SIZEOF_UCHAR;
1831 do {
1832 dest=buffer;
1833 *pErrorCode=U_ZERO_ERROR;
1834 ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
1835 destLength+=(int32_t)(dest-buffer);
1836 }
1837 while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
1838 }
1839 } else {
1840 destLength=0;
1841 }
1842
1843 return u_terminateUChars(originalDest, destCapacity, destLength, pErrorCode);
1844 }
1845
1846 /* ucnv_getNextUChar() ------------------------------------------------------ */
1847
1848 U_CAPI UChar32 U_EXPORT2
1849 ucnv_getNextUChar(UConverter *cnv,
1850 const char **source, const char *sourceLimit,
1851 UErrorCode *err) {
1852 UConverterToUnicodeArgs args;
1853 UChar buffer[U16_MAX_LENGTH];
1854 const char *s;
1855 UChar32 c;
1856 int32_t i, length;
1857
1858 /* check parameters */
1859 if(err==NULL || U_FAILURE(*err)) {
1860 return 0xffff;
1861 }
1862
1863 if(cnv==NULL || source==NULL) {
1864 *err=U_ILLEGAL_ARGUMENT_ERROR;
1865 return 0xffff;
1866 }
1867
1868 s=*source;
1869 if(sourceLimit<s) {
1870 *err=U_ILLEGAL_ARGUMENT_ERROR;
1871 return 0xffff;
1872 }
1873
1874 /*
1875 * Make sure that the buffer sizes do not exceed the number range for
1876 * int32_t because some functions use the size (in units or bytes)
1877 * rather than comparing pointers, and because offsets are int32_t values.
1878 *
1879 * size_t is guaranteed to be unsigned and large enough for the job.
1880 *
1881 * Return with an error instead of adjusting the limits because we would
1882 * not be able to maintain the semantics that either the source must be
1883 * consumed or the target filled (unless an error occurs).
1884 * An adjustment would be sourceLimit=t+0x7fffffff; for example.
1885 */
1886 if(((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) {
1887 *err=U_ILLEGAL_ARGUMENT_ERROR;
1888 return 0xffff;
1889 }
1890
1891 c=U_SENTINEL;
1892
1893 /* flush the target overflow buffer */
1894 if(cnv->UCharErrorBufferLength>0) {
1895 UChar *overflow;
1896
1897 overflow=cnv->UCharErrorBuffer;
1898 i=0;
1899 length=cnv->UCharErrorBufferLength;
1900 U16_NEXT(overflow, i, length, c);
1901
1902 /* move the remaining overflow contents up to the beginning */
1903 if((cnv->UCharErrorBufferLength=(int8_t)(length-i))>0) {
1904 uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+i,
1905 cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR);
1906 }
1907
1908 if(!U16_IS_LEAD(c) || i<length) {
1909 return c;
1910 }
1911 /*
1912 * Continue if the overflow buffer contained only a lead surrogate,
1913 * in case the converter outputs single surrogates from complete
1914 * input sequences.
1915 */
1916 }
1917
1918 /*
1919 * flush==TRUE is implied for ucnv_getNextUChar()
1920 *
1921 * do not simply return even if s==sourceLimit because the converter may
1922 * not have seen flush==TRUE before
1923 */
1924
1925 /* prepare the converter arguments */
1926 args.converter=cnv;
1927 args.flush=TRUE;
1928 args.offsets=NULL;
1929 args.source=s;
1930 args.sourceLimit=sourceLimit;
1931 args.target=buffer;
1932 args.targetLimit=buffer+1;
1933 args.size=sizeof(args);
1934
1935 if(c<0) {
1936 /*
1937 * call the native getNextUChar() implementation if we are
1938 * at a character boundary (toULength==0)
1939 *
1940 * unlike with _toUnicode(), getNextUChar() implementations must set
1941 * U_TRUNCATED_CHAR_FOUND for truncated input,
1942 * in addition to setting toULength/toUBytes[]
1943 */
1944 if(cnv->toULength==0 && cnv->sharedData->impl->getNextUChar!=NULL) {
1945 c=cnv->sharedData->impl->getNextUChar(&args, err);
1946 *source=s=args.source;
1947 if(*err==U_INDEX_OUTOFBOUNDS_ERROR) {
1948 /* reset the converter without calling the callback function */
1949 _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE);
1950 return 0xffff; /* no output */
1951 } else if(U_SUCCESS(*err) && c>=0) {
1952 return c;
1953 /*
1954 * else fall through to use _toUnicode() because
1955 * UCNV_GET_NEXT_UCHAR_USE_TO_U: the native function did not want to handle it after all
1956 * U_FAILURE: call _toUnicode() for callback handling (do not output c)
1957 */
1958 }
1959 }
1960
1961 /* convert to one UChar in buffer[0], or handle getNextUChar() errors */
1962 _toUnicodeWithCallback(&args, err);
1963
1964 if(*err==U_BUFFER_OVERFLOW_ERROR) {
1965 *err=U_ZERO_ERROR;
1966 }
1967
1968 i=0;
1969 length=(int32_t)(args.target-buffer);
1970 } else {
1971 /* write the lead surrogate from the overflow buffer */
1972 buffer[0]=(UChar)c;
1973 args.target=buffer+1;
1974 i=0;
1975 length=1;
1976 }
1977
1978 /* buffer contents starts at i and ends before length */
1979
1980 if(U_FAILURE(*err)) {
1981 c=0xffff; /* no output */
1982 } else if(length==0) {
1983 /* no input or only state changes */
1984 *err=U_INDEX_OUTOFBOUNDS_ERROR;
1985 /* no need to reset explicitly because _toUnicodeWithCallback() did it */
1986 c=0xffff; /* no output */
1987 } else {
1988 c=buffer[0];
1989 i=1;
1990 if(!U16_IS_LEAD(c)) {
1991 /* consume c=buffer[0], done */
1992 } else {
1993 /* got a lead surrogate, see if a trail surrogate follows */
1994 UChar c2;
1995
1996 if(cnv->UCharErrorBufferLength>0) {
1997 /* got overflow output from the conversion */
1998 if(U16_IS_TRAIL(c2=cnv->UCharErrorBuffer[0])) {
1999 /* got a trail surrogate, too */
2000 c=U16_GET_SUPPLEMENTARY(c, c2);
2001
2002 /* move the remaining overflow contents up to the beginning */
2003 if((--cnv->UCharErrorBufferLength)>0) {
2004 uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+1,
2005 cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR);
2006 }
2007 } else {
2008 /* c is an unpaired lead surrogate, just return it */
2009 }
2010 } else if(args.source<sourceLimit) {
2011 /* convert once more, to buffer[1] */
2012 args.targetLimit=buffer+2;
2013 _toUnicodeWithCallback(&args, err);
2014 if(*err==U_BUFFER_OVERFLOW_ERROR) {
2015 *err=U_ZERO_ERROR;
2016 }
2017
2018 length=(int32_t)(args.target-buffer);
2019 if(U_SUCCESS(*err) && length==2 && U16_IS_TRAIL(c2=buffer[1])) {
2020 /* got a trail surrogate, too */
2021 c=U16_GET_SUPPLEMENTARY(c, c2);
2022 i=2;
2023 }
2024 }
2025 }
2026 }
2027
2028 /*
2029 * move leftover output from buffer[i..length[
2030 * into the beginning of the overflow buffer
2031 */
2032 if(i<length) {
2033 /* move further overflow back */
2034 int32_t delta=length-i;
2035 if((length=cnv->UCharErrorBufferLength)>0) {
2036 uprv_memmove(cnv->UCharErrorBuffer+delta, cnv->UCharErrorBuffer,
2037 length*U_SIZEOF_UCHAR);
2038 }
2039 cnv->UCharErrorBufferLength=(int8_t)(length+delta);
2040
2041 cnv->UCharErrorBuffer[0]=buffer[i++];
2042 if(delta>1) {
2043 cnv->UCharErrorBuffer[1]=buffer[i];
2044 }
2045 }
2046
2047 *source=args.source;
2048 return c;
2049 }
2050
2051 /* ucnv_convert() and siblings ---------------------------------------------- */
2052
2053 U_CAPI void U_EXPORT2
2054 ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
2055 char **target, const char *targetLimit,
2056 const char **source, const char *sourceLimit,
2057 UChar *pivotStart, UChar **pivotSource,
2058 UChar **pivotTarget, const UChar *pivotLimit,
2059 UBool reset, UBool flush,
2060 UErrorCode *pErrorCode) {
2061 UChar pivotBuffer[CHUNK_SIZE];
2062 const UChar *myPivotSource;
2063 UChar *myPivotTarget;
2064 const char *s;
2065 char *t;
2066
2067 UConverterToUnicodeArgs toUArgs;
2068 UConverterFromUnicodeArgs fromUArgs;
2069 UConverterConvert convert;
2070
2071 /* error checking */
2072 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
2073 return;
2074 }
2075
2076 if( targetCnv==NULL || sourceCnv==NULL ||
2077 source==NULL || *source==NULL ||
2078 target==NULL || *target==NULL || targetLimit==NULL
2079 ) {
2080 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2081 return;
2082 }
2083
2084 s=*source;
2085 t=*target;
2086 if((sourceLimit!=NULL && sourceLimit<s) || targetLimit<t) {
2087 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2088 return;
2089 }
2090
2091 /*
2092 * Make sure that the buffer sizes do not exceed the number range for
2093 * int32_t. See ucnv_toUnicode() for a more detailed comment.
2094 */
2095 if(
2096 (sourceLimit!=NULL && ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) ||
2097 ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t)
2098 ) {
2099 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2100 return;
2101 }
2102
2103 if(pivotStart==NULL) {
2104 if(!flush) {
2105 /* streaming conversion requires an explicit pivot buffer */
2106 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2107 return;
2108 }
2109
2110 /* use the stack pivot buffer */
2111 myPivotSource=myPivotTarget=pivotStart=pivotBuffer;
2112 pivotSource=(UChar **)&myPivotSource;
2113 pivotTarget=&myPivotTarget;
2114 pivotLimit=pivotBuffer+CHUNK_SIZE;
2115 } else if( pivotStart>=pivotLimit ||
2116 pivotSource==NULL || *pivotSource==NULL ||
2117 pivotTarget==NULL || *pivotTarget==NULL ||
2118 pivotLimit==NULL
2119 ) {
2120 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2121 return;
2122 }
2123
2124 if(sourceLimit==NULL) {
2125 /* get limit of single-byte-NUL-terminated source string */
2126 sourceLimit=uprv_strchr(*source, 0);
2127 }
2128
2129 if(reset) {
2130 ucnv_resetToUnicode(sourceCnv);
2131 ucnv_resetFromUnicode(targetCnv);
2132 *pivotSource=*pivotTarget=pivotStart;
2133 } else if(targetCnv->charErrorBufferLength>0) {
2134 /* output the targetCnv overflow buffer */
2135 if(ucnv_outputOverflowFromUnicode(targetCnv, target, targetLimit, NULL, pErrorCode)) {
2136 /* U_BUFFER_OVERFLOW_ERROR */
2137 return;
2138 }
2139 /* *target has moved, therefore stop using t */
2140
2141 if( !flush &&
2142 targetCnv->preFromULength>=0 && *pivotSource==*pivotTarget &&
2143 sourceCnv->UCharErrorBufferLength==0 && sourceCnv->preToULength>=0 && s==sourceLimit
2144 ) {
2145 /* the fromUnicode overflow buffer is emptied and there is no new input: we are done */
2146 return;
2147 }
2148 }
2149
2150 /* Is direct-UTF-8 conversion available? */
2151 if( sourceCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
2152 targetCnv->sharedData->impl->fromUTF8!=NULL
2153 ) {
2154 convert=targetCnv->sharedData->impl->fromUTF8;
2155 } else if( targetCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
2156 sourceCnv->sharedData->impl->toUTF8!=NULL
2157 ) {
2158 convert=sourceCnv->sharedData->impl->toUTF8;
2159 } else {
2160 convert=NULL;
2161 }
2162
2163 /*
2164 * If direct-UTF-8 conversion is available, then we use a smaller
2165 * pivot buffer for error handling and partial matches
2166 * so that we quickly return to direct conversion.
2167 *
2168 * 32 is large enough for UCNV_EXT_MAX_UCHARS and UCNV_ERROR_BUFFER_LENGTH.
2169 *
2170 * We could reduce the pivot buffer size further, at the cost of
2171 * buffer overflows from callbacks.
2172 * The pivot buffer should not be smaller than the maximum number of
2173 * fromUnicode extension table input UChars
2174 * (for m:n conversion, see
2175 * targetCnv->sharedData->mbcs.extIndexes[UCNV_EXT_COUNT_UCHARS])
2176 * or 2 for surrogate pairs.
2177 *
2178 * Too small a buffer can cause thrashing between pivoting and direct
2179 * conversion, with function call overhead outweighing the benefits
2180 * of direct conversion.
2181 */
2182 if(convert!=NULL && (pivotLimit-pivotStart)>32) {
2183 pivotLimit=pivotStart+32;
2184 }
2185
2186 /* prepare the converter arguments */
2187 fromUArgs.converter=targetCnv;
2188 fromUArgs.flush=FALSE;
2189 fromUArgs.offsets=NULL;
2190 fromUArgs.target=*target;
2191 fromUArgs.targetLimit=targetLimit;
2192 fromUArgs.size=sizeof(fromUArgs);
2193
2194 toUArgs.converter=sourceCnv;
2195 toUArgs.flush=flush;
2196 toUArgs.offsets=NULL;
2197 toUArgs.source=s;
2198 toUArgs.sourceLimit=sourceLimit;
2199 toUArgs.targetLimit=pivotLimit;
2200 toUArgs.size=sizeof(toUArgs);
2201
2202 /*
2203 * TODO: Consider separating this function into two functions,
2204 * extracting exactly the conversion loop,
2205 * for readability and to reduce the set of visible variables.
2206 *
2207 * Otherwise stop using s and t from here on.
2208 */
2209 s=t=NULL;
2210
2211 /*
2212 * conversion loop
2213 *
2214 * The sequence of steps in the loop may appear backward,
2215 * but the principle is simple:
2216 * In the chain of
2217 * source - sourceCnv overflow - pivot - targetCnv overflow - target
2218 * empty out later buffers before refilling them from earlier ones.
2219 *
2220 * The targetCnv overflow buffer is flushed out only once before the loop.
2221 */
2222 for(;;) {
2223 /*
2224 * if(pivot not empty or error or replay or flush fromUnicode) {
2225 * fromUnicode(pivot -> target);
2226 * }
2227 *
2228 * For pivoting conversion; and for direct conversion for
2229 * error callback handling and flushing the replay buffer.
2230 */
2231 if( *pivotSource<*pivotTarget ||
2232 U_FAILURE(*pErrorCode) ||
2233 targetCnv->preFromULength<0 ||
2234 fromUArgs.flush
2235 ) {
2236 fromUArgs.source=*pivotSource;
2237 fromUArgs.sourceLimit=*pivotTarget;
2238 _fromUnicodeWithCallback(&fromUArgs, pErrorCode);
2239 if(U_FAILURE(*pErrorCode)) {
2240 /* target overflow, or conversion error */
2241 *pivotSource=(UChar *)fromUArgs.source;
2242 break;
2243 }
2244
2245 /*
2246 * _fromUnicodeWithCallback() must have consumed the pivot contents
2247 * (*pivotSource==*pivotTarget) since it returned with U_SUCCESS()
2248 */
2249 }
2250
2251 /* The pivot buffer is empty; reset it so we start at pivotStart. */
2252 *pivotSource=*pivotTarget=pivotStart;
2253
2254 /*
2255 * if(sourceCnv overflow buffer not empty) {
2256 * move(sourceCnv overflow buffer -> pivot);
2257 * continue;
2258 * }
2259 */
2260 /* output the sourceCnv overflow buffer */
2261 if(sourceCnv->UCharErrorBufferLength>0) {
2262 if(ucnv_outputOverflowToUnicode(sourceCnv, pivotTarget, pivotLimit, NULL, pErrorCode)) {
2263 /* U_BUFFER_OVERFLOW_ERROR */
2264 *pErrorCode=U_ZERO_ERROR;
2265 }
2266 continue;
2267 }
2268
2269 /*
2270 * check for end of input and break if done
2271 *
2272 * Checking both flush and fromUArgs.flush ensures that the converters
2273 * have been called with the flush flag set if the ucnv_convertEx()
2274 * caller set it.
2275 */
2276 if( toUArgs.source==sourceLimit &&
2277 sourceCnv->preToULength>=0 && sourceCnv->toULength==0 &&
2278 (!flush || fromUArgs.flush)
2279 ) {
2280 /* done successfully */
2281 break;
2282 }
2283
2284 /*
2285 * use direct conversion if available
2286 * but not if continuing a partial match
2287 * or flushing the toUnicode replay buffer
2288 */
2289 if(convert!=NULL && targetCnv->preFromUFirstCP<0 && sourceCnv->preToULength==0) {
2290 if(*pErrorCode==U_USING_DEFAULT_WARNING) {
2291 /* remove a warning that may be set by this function */
2292 *pErrorCode=U_ZERO_ERROR;
2293 }
2294 convert(&fromUArgs, &toUArgs, pErrorCode);
2295 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
2296 break;
2297 } else if(U_FAILURE(*pErrorCode)) {
2298 if(sourceCnv->toULength>0) {
2299 /*
2300 * Fall through to calling _toUnicodeWithCallback()
2301 * for callback handling.
2302 *
2303 * The pivot buffer will be reset with
2304 * *pivotSource=*pivotTarget=pivotStart;
2305 * which indicates a toUnicode error to the caller
2306 * (*pivotSource==pivotStart shows no pivot UChars consumed).
2307 */
2308 } else {
2309 /*
2310 * Indicate a fromUnicode error to the caller
2311 * (*pivotSource>pivotStart shows some pivot UChars consumed).
2312 */
2313 *pivotSource=*pivotTarget=pivotStart+1;
2314 /*
2315 * Loop around to calling _fromUnicodeWithCallbacks()
2316 * for callback handling.
2317 */
2318 continue;
2319 }
2320 } else if(*pErrorCode==U_USING_DEFAULT_WARNING) {
2321 /*
2322 * No error, but the implementation requested to temporarily
2323 * fall back to pivoting.
2324 */
2325 *pErrorCode=U_ZERO_ERROR;
2326 /*
2327 * The following else branches are almost identical to the end-of-input
2328 * handling in _toUnicodeWithCallback().
2329 * Avoid calling it just for the end of input.
2330 */
2331 } else if(flush && sourceCnv->toULength>0) { /* flush==toUArgs.flush */
2332 /*
2333 * the entire input stream is consumed
2334 * and there is a partial, truncated input sequence left
2335 */
2336
2337 /* inject an error and continue with callback handling */
2338 *pErrorCode=U_TRUNCATED_CHAR_FOUND;
2339 } else {
2340 /* input consumed */
2341 if(flush) {
2342 /* reset the converters without calling the callback functions */
2343 _reset(sourceCnv, UCNV_RESET_TO_UNICODE, FALSE);
2344 _reset(targetCnv, UCNV_RESET_FROM_UNICODE, FALSE);
2345 }
2346
2347 /* done successfully */
2348 break;
2349 }
2350 }
2351
2352 /*
2353 * toUnicode(source -> pivot);
2354 *
2355 * For pivoting conversion; and for direct conversion for
2356 * error callback handling, continuing partial matches
2357 * and flushing the replay buffer.
2358 *
2359 * The pivot buffer is empty and reset.
2360 */
2361 toUArgs.target=pivotStart; /* ==*pivotTarget */
2362 /* toUArgs.targetLimit=pivotLimit; already set before the loop */
2363 _toUnicodeWithCallback(&toUArgs, pErrorCode);
2364 *pivotTarget=toUArgs.target;
2365 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
2366 /* pivot overflow: continue with the conversion loop */
2367 *pErrorCode=U_ZERO_ERROR;
2368 } else if(U_FAILURE(*pErrorCode) || (!flush && *pivotTarget==pivotStart)) {
2369 /* conversion error, or there was nothing left to convert */
2370 break;
2371 }
2372 /*
2373 * else:
2374 * _toUnicodeWithCallback() wrote into the pivot buffer,
2375 * continue with fromUnicode conversion.
2376 *
2377 * Set the fromUnicode flush flag if we flush and if toUnicode has
2378 * processed the end of the input.
2379 */
2380 if( flush && toUArgs.source==sourceLimit &&
2381 sourceCnv->preToULength>=0 &&
2382 sourceCnv->UCharErrorBufferLength==0
2383 ) {
2384 fromUArgs.flush=TRUE;
2385 }
2386 }
2387
2388 /*
2389 * The conversion loop is exited when one of the following is true:
2390 * - the entire source text has been converted successfully to the target buffer
2391 * - a target buffer overflow occurred
2392 * - a conversion error occurred
2393 */
2394
2395 *source=toUArgs.source;
2396 *target=fromUArgs.target;
2397
2398 /* terminate the target buffer if possible */
2399 if(flush && U_SUCCESS(*pErrorCode)) {
2400 if(*target!=targetLimit) {
2401 **target=0;
2402 if(*pErrorCode==U_STRING_NOT_TERMINATED_WARNING) {
2403 *pErrorCode=U_ZERO_ERROR;
2404 }
2405 } else {
2406 *pErrorCode=U_STRING_NOT_TERMINATED_WARNING;
2407 }
2408 }
2409 }
2410
2411 /* internal implementation of ucnv_convert() etc. with preflighting */
2412 static int32_t
2413 ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter,
2414 char *target, int32_t targetCapacity,
2415 const char *source, int32_t sourceLength,
2416 UErrorCode *pErrorCode) {
2417 UChar pivotBuffer[CHUNK_SIZE];
2418 UChar *pivot, *pivot2;
2419
2420 char *myTarget;
2421 const char *sourceLimit;
2422 const char *targetLimit;
2423 int32_t targetLength=0;
2424
2425 /* set up */
2426 if(sourceLength<0) {
2427 sourceLimit=uprv_strchr(source, 0);
2428 } else {
2429 sourceLimit=source+sourceLength;
2430 }
2431
2432 /* if there is no input data, we're done */
2433 if(source==sourceLimit) {
2434 return u_terminateChars(target, targetCapacity, 0, pErrorCode);
2435 }
2436
2437 pivot=pivot2=pivotBuffer;
2438 myTarget=target;
2439 targetLength=0;
2440
2441 if(targetCapacity>0) {
2442 /* perform real conversion */
2443 targetLimit=target+targetCapacity;
2444 ucnv_convertEx(outConverter, inConverter,
2445 &myTarget, targetLimit,
2446 &source, sourceLimit,
2447 pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE,
2448 FALSE,
2449 TRUE,
2450 pErrorCode);
2451 targetLength=(int32_t)(myTarget-target);
2452 }
2453
2454 /*
2455 * If the output buffer is exhausted (or we are only "preflighting"), we need to stop writing
2456 * to it but continue the conversion in order to store in targetCapacity
2457 * the number of bytes that was required.
2458 */
2459 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR || targetCapacity==0)
2460 {
2461 char targetBuffer[CHUNK_SIZE];
2462
2463 targetLimit=targetBuffer+CHUNK_SIZE;
2464 do {
2465 *pErrorCode=U_ZERO_ERROR;
2466 myTarget=targetBuffer;
2467 ucnv_convertEx(outConverter, inConverter,
2468 &myTarget, targetLimit,
2469 &source, sourceLimit,
2470 pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE,
2471 FALSE,
2472 TRUE,
2473 pErrorCode);
2474 targetLength+=(int32_t)(myTarget-targetBuffer);
2475 } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
2476
2477 /* done with preflighting, set warnings and errors as appropriate */
2478 return u_terminateChars(target, targetCapacity, targetLength, pErrorCode);
2479 }
2480
2481 /* no need to call u_terminateChars() because ucnv_convertEx() took care of that */
2482 return targetLength;
2483 }
2484
2485 U_CAPI int32_t U_EXPORT2
2486 ucnv_convert(const char *toConverterName, const char *fromConverterName,
2487 char *target, int32_t targetCapacity,
2488 const char *source, int32_t sourceLength,
2489 UErrorCode *pErrorCode) {
2490 UConverter in, out; /* stack-allocated */
2491 UConverter *inConverter, *outConverter;
2492 int32_t targetLength;
2493
2494 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
2495 return 0;
2496 }
2497
2498 if( source==NULL || sourceLength<-1 ||
2499 targetCapacity<0 || (targetCapacity>0 && target==NULL)
2500 ) {
2501 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2502 return 0;
2503 }
2504
2505 /* if there is no input data, we're done */
2506 if(sourceLength==0 || (sourceLength<0 && *source==0)) {
2507 return u_terminateChars(target, targetCapacity, 0, pErrorCode);
2508 }
2509
2510 /* create the converters */
2511 inConverter=ucnv_createConverter(&in, fromConverterName, pErrorCode);
2512 if(U_FAILURE(*pErrorCode)) {
2513 return 0;
2514 }
2515
2516 outConverter=ucnv_createConverter(&out, toConverterName, pErrorCode);
2517 if(U_FAILURE(*pErrorCode)) {
2518 ucnv_close(inConverter);
2519 return 0;
2520 }
2521
2522 targetLength=ucnv_internalConvert(outConverter, inConverter,
2523 target, targetCapacity,
2524 source, sourceLength,
2525 pErrorCode);
2526
2527 ucnv_close(inConverter);
2528 ucnv_close(outConverter);
2529
2530 return targetLength;
2531 }
2532
2533 /* @internal */
2534 static int32_t
2535 ucnv_convertAlgorithmic(UBool convertToAlgorithmic,
2536 UConverterType algorithmicType,
2537 UConverter *cnv,
2538 char *target, int32_t targetCapacity,
2539 const char *source, int32_t sourceLength,
2540 UErrorCode *pErrorCode) {
2541 UConverter algoConverterStatic; /* stack-allocated */
2542 UConverter *algoConverter, *to, *from;
2543 int32_t targetLength;
2544
2545 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
2546 return 0;
2547 }
2548
2549 if( cnv==NULL || source==NULL || sourceLength<-1 ||
2550 targetCapacity<0 || (targetCapacity>0 && target==NULL)
2551 ) {
2552 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
2553 return 0;
2554 }
2555
2556 /* if there is no input data, we're done */
2557 if(sourceLength==0 || (sourceLength<0 && *source==0)) {
2558 return u_terminateChars(target, targetCapacity, 0, pErrorCode);
2559 }
2560
2561 /* create the algorithmic converter */
2562 algoConverter=ucnv_createAlgorithmicConverter(&algoConverterStatic, algorithmicType,
2563 "", 0, pErrorCode);
2564 if(U_FAILURE(*pErrorCode)) {
2565 return 0;
2566 }
2567
2568 /* reset the other converter */
2569 if(convertToAlgorithmic) {
2570 /* cnv->Unicode->algo */
2571 ucnv_resetToUnicode(cnv);
2572 to=algoConverter;
2573 from=cnv;
2574 } else {
2575 /* algo->Unicode->cnv */
2576 ucnv_resetFromUnicode(cnv);
2577 from=algoConverter;
2578 to=cnv;
2579 }
2580
2581 targetLength=ucnv_internalConvert(to, from,
2582 target, targetCapacity,
2583 source, sourceLength,
2584 pErrorCode);
2585
2586 ucnv_close(algoConverter);
2587
2588 return targetLength;
2589 }
2590
2591 U_CAPI int32_t U_EXPORT2
2592 ucnv_toAlgorithmic(UConverterType algorithmicType,
2593 UConverter *cnv,
2594 char *target, int32_t targetCapacity,
2595 const char *source, int32_t sourceLength,
2596 UErrorCode *pErrorCode) {
2597 return ucnv_convertAlgorithmic(TRUE, algorithmicType, cnv,
2598 target, targetCapacity,
2599 source, sourceLength,
2600 pErrorCode);
2601 }
2602
2603 U_CAPI int32_t U_EXPORT2
2604 ucnv_fromAlgorithmic(UConverter *cnv,
2605 UConverterType algorithmicType,
2606 char *target, int32_t targetCapacity,
2607 const char *source, int32_t sourceLength,
2608 UErrorCode *pErrorCode) {
2609 return ucnv_convertAlgorithmic(FALSE, algorithmicType, cnv,
2610 target, targetCapacity,
2611 source, sourceLength,
2612 pErrorCode);
2613 }
2614
2615 U_CAPI UConverterType U_EXPORT2
2616 ucnv_getType(const UConverter* converter)
2617 {
2618 int8_t type = converter->sharedData->staticData->conversionType;
2619 #if !UCONFIG_NO_LEGACY_CONVERSION
2620 if(type == UCNV_MBCS) {
2621 return ucnv_MBCSGetType(converter);
2622 }
2623 #endif
2624 return (UConverterType)type;
2625 }
2626
2627 U_CAPI void U_EXPORT2
2628 ucnv_getStarters(const UConverter* converter,
2629 UBool starters[256],
2630 UErrorCode* err)
2631 {
2632 if (err == NULL || U_FAILURE(*err)) {
2633 return;
2634 }
2635
2636 if(converter->sharedData->impl->getStarters != NULL) {
2637 converter->sharedData->impl->getStarters(converter, starters, err);
2638 } else {
2639 *err = U_ILLEGAL_ARGUMENT_ERROR;
2640 }
2641 }
2642
2643 static const UAmbiguousConverter *ucnv_getAmbiguous(const UConverter *cnv)
2644 {
2645 UErrorCode errorCode;
2646 const char *name;
2647 int32_t i;
2648
2649 if(cnv==NULL) {
2650 return NULL;
2651 }
2652
2653 errorCode=U_ZERO_ERROR;
2654 name=ucnv_getName(cnv, &errorCode);
2655 if(U_FAILURE(errorCode)) {
2656 return NULL;
2657 }
2658
2659 for(i=0; i<(int32_t)(sizeof(ambiguousConverters)/sizeof(UAmbiguousConverter)); ++i)
2660 {
2661 if(0==uprv_strcmp(name, ambiguousConverters[i].name))
2662 {
2663 return ambiguousConverters+i;
2664 }
2665 }
2666
2667 return NULL;
2668 }
2669
2670 U_CAPI void U_EXPORT2
2671 ucnv_fixFileSeparator(const UConverter *cnv,
2672 UChar* source,
2673 int32_t sourceLength) {
2674 const UAmbiguousConverter *a;
2675 int32_t i;
2676 UChar variant5c;
2677
2678 if(cnv==NULL || source==NULL || sourceLength<=0 || (a=ucnv_getAmbiguous(cnv))==NULL)
2679 {
2680 return;
2681 }
2682
2683 variant5c=a->variant5c;
2684 for(i=0; i<sourceLength; ++i) {
2685 if(source[i]==variant5c) {
2686 source[i]=0x5c;
2687 }
2688 }
2689 }
2690
2691 U_CAPI UBool U_EXPORT2
2692 ucnv_isAmbiguous(const UConverter *cnv) {
2693 return (UBool)(ucnv_getAmbiguous(cnv)!=NULL);
2694 }
2695
2696 U_CAPI void U_EXPORT2
2697 ucnv_setFallback(UConverter *cnv, UBool usesFallback)
2698 {
2699 cnv->useFallback = usesFallback;
2700 }
2701
2702 U_CAPI UBool U_EXPORT2
2703 ucnv_usesFallback(const UConverter *cnv)
2704 {
2705 return cnv->useFallback;
2706 }
2707
2708 U_CAPI void U_EXPORT2
2709 ucnv_getInvalidChars (const UConverter * converter,
2710 char *errBytes,
2711 int8_t * len,
2712 UErrorCode * err)
2713 {
2714 if (err == NULL || U_FAILURE(*err))
2715 {
2716 return;
2717 }
2718 if (len == NULL || errBytes == NULL || converter == NULL)
2719 {
2720 *err = U_ILLEGAL_ARGUMENT_ERROR;
2721 return;
2722 }
2723 if (*len < converter->invalidCharLength)
2724 {
2725 *err = U_INDEX_OUTOFBOUNDS_ERROR;
2726 return;
2727 }
2728 if ((*len = converter->invalidCharLength) > 0)
2729 {
2730 uprv_memcpy (errBytes, converter->invalidCharBuffer, *len);
2731 }
2732 }
2733
2734 U_CAPI void U_EXPORT2
2735 ucnv_getInvalidUChars (const UConverter * converter,
2736 UChar *errChars,
2737 int8_t * len,
2738 UErrorCode * err)
2739 {
2740 if (err == NULL || U_FAILURE(*err))
2741 {
2742 return;
2743 }
2744 if (len == NULL || errChars == NULL || converter == NULL)
2745 {
2746 *err = U_ILLEGAL_ARGUMENT_ERROR;
2747 return;
2748 }
2749 if (*len < converter->invalidUCharLength)
2750 {
2751 *err = U_INDEX_OUTOFBOUNDS_ERROR;
2752 return;
2753 }
2754 if ((*len = converter->invalidUCharLength) > 0)
2755 {
2756 uprv_memcpy (errChars, converter->invalidUCharBuffer, sizeof(UChar) * (*len));
2757 }
2758 }
2759
2760 #define SIG_MAX_LEN 5
2761
2762 U_CAPI const char* U_EXPORT2
2763 ucnv_detectUnicodeSignature( const char* source,
2764 int32_t sourceLength,
2765 int32_t* signatureLength,
2766 UErrorCode* pErrorCode) {
2767 int32_t dummy;
2768
2769 /* initial 0xa5 bytes: make sure that if we read <SIG_MAX_LEN
2770 * bytes we don't misdetect something
2771 */
2772 char start[SIG_MAX_LEN]={ '\xa5', '\xa5', '\xa5', '\xa5', '\xa5' };
2773 int i = 0;
2774
2775 if((pErrorCode==NULL) || U_FAILURE(*pErrorCode)){
2776 return NULL;
2777 }
2778
2779 if(source == NULL || sourceLength < -1){
2780 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
2781 return NULL;
2782 }
2783
2784 if(signatureLength == NULL) {
2785 signatureLength = &dummy;
2786 }
2787
2788 if(sourceLength==-1){
2789 sourceLength=(int32_t)uprv_strlen(source);
2790 }
2791
2792
2793 while(i<sourceLength&& i<SIG_MAX_LEN){
2794 start[i]=source[i];
2795 i++;
2796 }
2797
2798 if(start[0] == '\xFE' && start[1] == '\xFF') {
2799 *signatureLength=2;
2800 return "UTF-16BE";
2801 } else if(start[0] == '\xFF' && start[1] == '\xFE') {
2802 if(start[2] == '\x00' && start[3] =='\x00') {
2803 *signatureLength=4;
2804 return "UTF-32LE";
2805 } else {
2806 *signatureLength=2;
2807 return "UTF-16LE";
2808 }
2809 } else if(start[0] == '\xEF' && start[1] == '\xBB' && start[2] == '\xBF') {
2810 *signatureLength=3;
2811 return "UTF-8";
2812 } else if(start[0] == '\x00' && start[1] == '\x00' &&
2813 start[2] == '\xFE' && start[3]=='\xFF') {
2814 *signatureLength=4;
2815 return "UTF-32BE";
2816 } else if(start[0] == '\x0E' && start[1] == '\xFE' && start[2] == '\xFF') {
2817 *signatureLength=3;
2818 return "SCSU";
2819 } else if(start[0] == '\xFB' && start[1] == '\xEE' && start[2] == '\x28') {
2820 *signatureLength=3;
2821 return "BOCU-1";
2822 } else if(start[0] == '\x2B' && start[1] == '\x2F' && start[2] == '\x76') {
2823 /*
2824 * UTF-7: Initial U+FEFF is encoded as +/v8 or +/v9 or +/v+ or +/v/
2825 * depending on the second UTF-16 code unit.
2826 * Detect the entire, closed Unicode mode sequence +/v8- for only U+FEFF
2827 * if it occurs.
2828 *
2829 * So far we have +/v
2830 */
2831 if(start[3] == '\x38' && start[4] == '\x2D') {
2832 /* 5 bytes +/v8- */
2833 *signatureLength=5;
2834 return "UTF-7";
2835 } else if(start[3] == '\x38' || start[3] == '\x39' || start[3] == '\x2B' || start[3] == '\x2F') {
2836 /* 4 bytes +/v8 or +/v9 or +/v+ or +/v/ */
2837 *signatureLength=4;
2838 return "UTF-7";
2839 }
2840 }else if(start[0]=='\xDD' && start[1]== '\x73'&& start[2]=='\x66' && start[3]=='\x73'){
2841 *signatureLength=4;
2842 return "UTF-EBCDIC";
2843 }
2844
2845
2846 /* no known Unicode signature byte sequence recognized */
2847 *signatureLength=0;
2848 return NULL;
2849 }
2850
2851 U_CAPI int32_t U_EXPORT2
2852 ucnv_fromUCountPending(const UConverter* cnv, UErrorCode* status)
2853 {
2854 if(status == NULL || U_FAILURE(*status)){
2855 return -1;
2856 }
2857 if(cnv == NULL){
2858 *status = U_ILLEGAL_ARGUMENT_ERROR;
2859 return -1;
2860 }
2861
2862 if(cnv->preFromUFirstCP >= 0){
2863 return U16_LENGTH(cnv->preFromUFirstCP)+cnv->preFromULength ;
2864 }else if(cnv->preFromULength < 0){
2865 return -cnv->preFromULength ;
2866 }else if(cnv->fromUChar32 > 0){
2867 return 1;
2868 }
2869 return 0;
2870
2871 }
2872
2873 U_CAPI int32_t U_EXPORT2
2874 ucnv_toUCountPending(const UConverter* cnv, UErrorCode* status){
2875
2876 if(status == NULL || U_FAILURE(*status)){
2877 return -1;
2878 }
2879 if(cnv == NULL){
2880 *status = U_ILLEGAL_ARGUMENT_ERROR;
2881 return -1;
2882 }
2883
2884 if(cnv->preToULength > 0){
2885 return cnv->preToULength ;
2886 }else if(cnv->preToULength < 0){
2887 return -cnv->preToULength;
2888 }else if(cnv->toULength > 0){
2889 return cnv->toULength;
2890 }
2891 return 0;
2892 }
2893
2894 U_CAPI UBool U_EXPORT2
2895 ucnv_isFixedWidth(UConverter *cnv, UErrorCode *status){
2896 if (U_FAILURE(*status)) {
2897 return FALSE;
2898 }
2899
2900 if (cnv == NULL) {
2901 *status = U_ILLEGAL_ARGUMENT_ERROR;
2902 return FALSE;
2903 }
2904
2905 switch (ucnv_getType(cnv)) {
2906 case UCNV_SBCS:
2907 case UCNV_DBCS:
2908 case UCNV_UTF32_BigEndian:
2909 case UCNV_UTF32_LittleEndian:
2910 case UCNV_UTF32:
2911 case UCNV_US_ASCII:
2912 return TRUE;
2913 default:
2914 return FALSE;
2915 }
2916 }
2917 #endif
2918
2919 /*
2920 * Hey, Emacs, please set the following:
2921 *
2922 * Local Variables:
2923 * indent-tabs-mode: nil
2924 * End:
2925 *
2926 */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial